Irreducible loop metadata for more accurate block frequency under PGO.

[hjyamauchi]

Summary

Currently the block frequency analysis is an approximation for irreducible
loops.

The new irreducible loop metadata is used to annotate the irreducible loop
headers with their header weights based on the PGO profile (currently this is
approximated to be evenly weighted) and to help improve the accuracy of the
block frequency analysis for irreducible loops.

This patch is a basic support for this.

[davidxl]

include/llvm/Analysis/BlockFrequencyInfoImpl.h

1161

may be

if ( !(... HeaderWeight = ))

continue;

1166

Is this check needed?

1172

Can this share the same code with 'distributeIrrLoopHeaderMass' by making weights evenly distributed?

lib/IR/MDBuilder.cpp

203

loop_header_weight?

test/Analysis/BlockFrequencyInfo/irreducible_pgo.ll

5

Can this test case be minimized (eg. shrinking BB size ..) ?

[hjyamauchi]

Addressed comments.

[hjyamauchi]

include/llvm/Analysis/BlockFrequencyInfoImpl.h

1166

Yes, Dist.addLocal will has an assert against incoming zero value.

[hjyamauchi]

Changed the metadata name.
Added the metadata to the doc.

[davidxl]

include/llvm/Analysis/BlockFrequencyInfoImpl.h

1164

can just break here.

test/Transforms/PGOProfile/irreducible.ll

2

The profile generate tests do not seem to be relevant, can be removed.

[hjyamauchi]

Addressed comments.

include/llvm/Analysis/BlockFrequencyInfoImpl.h

1164

I tried it, turned out it needs to be a continue, because we still need the "IsIrrLoopHeader" (see line 1161 above) to be fully populated so that the PGO annotate pass can see which blocks are the headers and annotate accordingly (no headers have annotations before the PGO annotate pass, obviously.)

[davidxl]

lgtm

[hjyamauchi]

Rebased.

include/llvm/Analysis/BlockFrequencyInfo.h

public:
   /// the enclosing function's count (if available) and returns the value.
   Optional<uint64_t> getBlockProfileCount(const BasicBlock *BB) const;
 
   /// \brief Returns the estimated profile count of \p Freq.
   /// This uses the frequency \p Freq and multiplies it by
   /// the enclosing function's count (if available) and returns the value.
   Optional<uint64_t> getProfileCountFromFreq(uint64_t Freq) const;
 
+  /// \brief Returns true if \p BB is an irreducible loop header
+  /// block. Otherwise false.
+  bool isIrrLoopHeader(const BasicBlock *BB);
+
   // Set the frequency of the given basic block.
   void setBlockFreq(const BasicBlock *BB, uint64_t Freq);
 
   /// Set the frequency of \p ReferenceBB to \p Freq and scale the frequencies
   /// of the blocks in \p BlocksToScale such that their frequencies relative
   /// to \p ReferenceBB remain unchanged.
   void setBlockFreqAndScale(const BasicBlock *ReferenceBB, uint64_t Freq,
                             SmallPtrSetImpl<BasicBlock *> &BlocksToScale);

include/llvm/Analysis/BlockFrequencyInfoImpl.h

 #ifndef LLVM_ANALYSIS_BLOCKFREQUENCYINFOIMPL_H
 #define LLVM_ANALYSIS_BLOCKFREQUENCYINFOIMPL_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/SparseBitVector.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/Support/BlockFrequency.h"
 #include "llvm/Support/BranchProbability.h"
 #include "llvm/Support/DOTGraphTraits.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
public:
 
   private:
     void add(const BlockNode &Node, uint64_t Amount, Weight::DistType Type);
   };
 
   /// \brief Data about each block.  This is used downstream.
   std::vector<FrequencyData> Freqs;
 
+  /// \brief Whether each block is an irreducible loop header.
+  /// This is used downstream.
+  SparseBitVector<> IsIrrLoopHeader;
+
   /// \brief Loop data: see initializeLoops().
   std::vector<WorkingData> Working;
 
   /// \brief Indexed information about loops.
   std::list<LoopData> Loops;
 
   /// \brief Virtual destructor.
   ///
public:
   /// Initially, irreducible loops are assumed to distribute their mass
   /// equally among its headers. This can lead to wrong frequency estimates
   /// since some headers may be executed more frequently than others.
   ///
   /// This adjusts header mass distribution so it matches the weights of
   /// the backedges going into each of the loop headers.
   void adjustLoopHeaderMass(LoopData &Loop);
 
+  void distributeIrrLoopHeaderMass(Distribution &Dist);
+
   /// \brief Package up a loop.
   void packageLoop(LoopData &Loop);
 
   /// \brief Unwrap loops.
   void unwrapLoops();
 
   /// \brief Finalize frequency metrics.
   ///
public:
 
   Scaled64 getFloatingBlockFreq(const BlockNode &Node) const;
 
   BlockFrequency getBlockFreq(const BlockNode &Node) const;
   Optional<uint64_t> getBlockProfileCount(const Function &F,
                                           const BlockNode &Node) const;
   Optional<uint64_t> getProfileCountFromFreq(const Function &F,
                                              uint64_t Freq) const;
+  bool isIrrLoopHeader(const BlockNode &Node);
 
   void setBlockFreq(const BlockNode &Node, uint64_t Freq);
 
   raw_ostream &printBlockFreq(raw_ostream &OS, const BlockNode &Node) const;
   raw_ostream &printBlockFreq(raw_ostream &OS,
                               const BlockFrequency &Freq) const;
 
   uint64_t getEntryFreq() const {
Optional<uint64_t> getBlockProfileCount(const Function &F,
     return BlockFrequencyInfoImplBase::getBlockProfileCount(F, getNode(BB));
   }
 
   Optional<uint64_t> getProfileCountFromFreq(const Function &F,
                                              uint64_t Freq) const {
     return BlockFrequencyInfoImplBase::getProfileCountFromFreq(F, Freq);
   }
 
+  bool isIrrLoopHeader(const BlockT *BB) {
+    return BlockFrequencyInfoImplBase::isIrrLoopHeader(getNode(BB));
+  }
+
   void setBlockFreq(const BlockT *BB, uint64_t Freq);
 
   Scaled64 getFloatingBlockFreq(const BlockT *BB) const {
     return BlockFrequencyInfoImplBase::getFloatingBlockFreq(getNode(BB));
   }
 
   const BranchProbabilityInfoT &getBPI() const { return *BPI; }
 

 }
 
 template <class BT>
 bool BlockFrequencyInfoImpl<BT>::computeMassInLoop(LoopData &Loop) {
   // Compute mass in loop.
   DEBUG(dbgs() << "compute-mass-in-loop: " << getLoopName(Loop) << "\n");
 
   if (Loop.isIrreducible()) {
+    DEBUG(dbgs() << "isIrreducible = true\n");
+    Distribution Dist;
+    unsigned NumHeadersWithWeight = 0;
+    for (uint32_t H = 0; H < Loop.NumHeaders; ++H) {
+      auto &HeaderNode = Loop.Nodes[H];
+      const BlockT *Block = getBlock(HeaderNode);
+      if (Optional<uint64_t> HeaderWeight = Block->getIrrLoopHeaderWeight()) {
+        DEBUG(dbgs() << getBlockName(HeaderNode)
+              << " has irr loop header weight " << HeaderWeight.getValue()
+              << "\n");
+        NumHeadersWithWeight++;
+        if (HeaderWeight.getValue())
+          Dist.addLocal(HeaderNode, HeaderWeight.getValue());
+      }
+      IsIrrLoopHeader.set(Loop.Nodes[H].Index);
+    }
+    if (NumHeadersWithWeight != Loop.NumHeaders) {
+      // Non-PGO
       BlockMass Remaining = BlockMass::getFull();
       for (uint32_t H = 0; H < Loop.NumHeaders; ++H) {
         auto &Mass = Working[Loop.Nodes[H].Index].getMass();
         Mass = Remaining * BranchProbability(1, Loop.NumHeaders - H);
         Remaining -= Mass;
       }
       for (const BlockNode &M : Loop.Nodes)
         if (!propagateMassToSuccessors(&Loop, M))
           llvm_unreachable("unhandled irreducible control flow");
-
       adjustLoopHeaderMass(Loop);
     } else {
+      // PGO.
+      distributeIrrLoopHeaderMass(Dist);
+      for (const BlockNode &M : Loop.Nodes)
+        if (!propagateMassToSuccessors(&Loop, M))
+          llvm_unreachable("unhandled irreducible control flow");
+    }
+  } else {
     Working[Loop.getHeader().Index].getMass() = BlockMass::getFull();
     if (!propagateMassToSuccessors(&Loop, Loop.getHeader()))
       llvm_unreachable("irreducible control flow to loop header!?");
     for (const BlockNode &M : Loop.members())
       if (!propagateMassToSuccessors(&Loop, M))
         // Irreducible backedge.
         return false;
   }
raw_ostream &BlockFrequencyInfoImpl<BT>::print(raw_ostream &OS) const {
   for (const BlockT &BB : *F) {
     OS << " - " << bfi_detail::getBlockName(&BB) << ": float = ";
     getFloatingBlockFreq(&BB).print(OS, 5)
         << ", int = " << getBlockFreq(&BB).getFrequency();
     if (Optional<uint64_t> ProfileCount =
         BlockFrequencyInfoImplBase::getBlockProfileCount(
             *F->getFunction(), getNode(&BB)))
       OS << ", count = " << ProfileCount.getValue();
+    if (Optional<uint64_t> IrrLoopHeaderWeight =
+        BB.getIrrLoopHeaderWeight())
+      OS << ", irr_loop_header_weight = " << IrrLoopHeaderWeight.getValue();
     OS << "\n";
   }
 
   // Add an extra newline for readability.
   OS << "\n";
   return OS;
 }
 

include/llvm/CodeGen/MachineBasicBlock.h

private:
   /// Keep track of the probabilities to the successors. This vector has the
   /// same order as Successors, or it is empty if we don't use it (disable
   /// optimization).
   std::vector<BranchProbability> Probs;
   using probability_iterator = std::vector<BranchProbability>::iterator;
   using const_probability_iterator =
       std::vector<BranchProbability>::const_iterator;
 
+  Optional<uint64_t> IrrLoopHeaderWeight;
+
   /// Keep track of the physical registers that are livein of the basicblock.
   using LiveInVector = std::vector<RegisterMaskPair>;
   LiveInVector LiveIns;
 
   /// Alignment of the basic block. Zero if the basic block does not need to be
   /// aligned. The alignment is specified as log2(bytes).
   unsigned Alignment = 0;
 
#endif
   /// MachineBasicBlocks are uniquely numbered at the function level, unless
   /// they're not in a MachineFunction yet, in which case this will return -1.
   int getNumber() const { return Number; }
   void setNumber(int N) { Number = N; }
 
   /// Return the MCSymbol for this basic block.
   MCSymbol *getSymbol() const;
 
+  Optional<uint64_t> getIrrLoopHeaderWeight() const {
+    return IrrLoopHeaderWeight;
+  }
+
+  void setIrrLoopHeaderWeight(uint64_t Weight) {
+    IrrLoopHeaderWeight = Weight;
+  }
+
 private:
   /// Return probability iterator corresponding to the I successor iterator.
   probability_iterator getProbabilityIterator(succ_iterator I);
   const_probability_iterator
   getProbabilityIterator(const_succ_iterator I) const;
 
   friend class MachineBranchProbabilityInfo;
   friend class MIPrinter;

include/llvm/CodeGen/MachineBlockFrequencyInfo.h

public:
   /// that we should not rely on the value itself, but only on the comparison to
   /// the other block frequencies. We do this to avoid using of floating points.
   ///
   BlockFrequency getBlockFreq(const MachineBasicBlock *MBB) const;
 
   Optional<uint64_t> getBlockProfileCount(const MachineBasicBlock *MBB) const;
   Optional<uint64_t> getProfileCountFromFreq(uint64_t Freq) const;
 
+  bool isIrrLoopHeader(const MachineBasicBlock *MBB);
+
   const MachineFunction *getFunction() const;
   const MachineBranchProbabilityInfo *getMBPI() const;
   void view(const Twine &Name, bool isSimple = true) const;
 
   // Print the block frequency Freq to OS using the current functions entry
   // frequency to convert freq into a relative decimal form.
   raw_ostream &printBlockFreq(raw_ostream &OS, const BlockFrequency Freq) const;
 

include/llvm/IR/BasicBlock.h

public:
   LandingPadInst *getLandingPadInst() {
     return const_cast<LandingPadInst *>(
                     static_cast<const BasicBlock *>(this)->getLandingPadInst());
   }
 
   /// \brief Return true if it is legal to hoist instructions into this block.
   bool isLegalToHoistInto() const;
 
+  Optional<uint64_t> getIrrLoopHeaderWeight() const;
+
 private:
   /// \brief Increment the internal refcount of the number of BlockAddresses
   /// referencing this BasicBlock by \p Amt.
   ///
   /// This is almost always 0, sometimes one possibly, but almost never 2, and
   /// inconceivably 3 or more.
   void AdjustBlockAddressRefCount(int Amt) {
     setValueSubclassData(getSubclassDataFromValue()+Amt);

include/llvm/IR/LLVMContext.h

enum {
     MD_invariant_group = 16,          // "invariant.group"
     MD_align = 17,                    // "align"
     MD_loop = 18,                     // "llvm.loop"
     MD_type = 19,                     // "type"
     MD_section_prefix = 20,           // "section_prefix"
     MD_absolute_symbol = 21,          // "absolute_symbol"
     MD_associated = 22,               // "associated"
     MD_callees = 23,                  // "callees"
+    MD_irr_loop_header = 24,          // "irr_loop_header"
   };
 
   /// Known operand bundle tag IDs, which always have the same value.  All
   /// operand bundle tags that LLVM has special knowledge of are listed here.
   /// Additionally, this scheme allows LLVM to efficiently check for specific
   /// operand bundle tags without comparing strings.
   enum {
     OB_deopt = 0,         // "deopt"

include/llvm/IR/MDBuilder.h

public:
   /// given name, an offset and a parent in the TBAA type DAG.
   MDNode *createTBAAScalarTypeNode(StringRef Name, MDNode *Parent,
                                    uint64_t Offset = 0);
 
   /// \brief Return metadata for a TBAA tag node with the given
   /// base type, access type and offset relative to the base type.
   MDNode *createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
                                   uint64_t Offset, bool IsConstant = false);
+
+  /// \brief Return metadata containing an irreducible loop header weight.
+  MDNode *createIrrLoopHeaderWeight(uint64_t Weight);
 };
 
 } // end namespace llvm
 
 #endif

include/llvm/Transforms/PGOInstrumentation.h

 public:
   PGOMemOPSizeOpt() {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
 void setProfMetadata(Module *M, Instruction *TI, ArrayRef<uint64_t> EdgeCounts,
                      uint64_t MaxCount);
 
+void setIrrLoopHeaderMetadata(Module *M, Instruction *TI, uint64_t Count);
+
 } // End llvm namespace
 #endif

lib/Analysis/BlockFrequencyInfo.cpp

 
 Optional<uint64_t>
 BlockFrequencyInfo::getProfileCountFromFreq(uint64_t Freq) const {
   if (!BFI)
     return None;
   return BFI->getProfileCountFromFreq(*getFunction(), Freq);
 }
 
+bool BlockFrequencyInfo::isIrrLoopHeader(const BasicBlock *BB) {
+  assert(BFI && "Expected analysis to be available");
+  return BFI->isIrrLoopHeader(BB);
+}
+
 void BlockFrequencyInfo::setBlockFreq(const BasicBlock *BB, uint64_t Freq) {
   assert(BFI && "Expected analysis to be available");
   BFI->setBlockFreq(BB, Freq);
 }
 
 void BlockFrequencyInfo::setBlockFreqAndScale(
     const BasicBlock *ReferenceBB, uint64_t Freq,
     SmallPtrSetImpl<BasicBlock *> &BlocksToScale) {

lib/Analysis/BlockFrequencyInfoImpl.cpp

void Distribution::normalize() {
   }
   assert(Total <= UINT32_MAX);
 }
 
 void BlockFrequencyInfoImplBase::clear() {
   // Swap with a default-constructed std::vector, since std::vector<>::clear()
   // does not actually clear heap storage.
   std::vector<FrequencyData>().swap(Freqs);
+  IsIrrLoopHeader.clear();
   std::vector<WorkingData>().swap(Working);
   Loops.clear();
 }
 
 /// \brief Clear all memory not needed downstream.
 ///
 /// Releases all memory not used downstream.  In particular, saves Freqs.
 static void cleanup(BlockFrequencyInfoImplBase &BFI) {
   std::vector<FrequencyData> SavedFreqs(std::move(BFI.Freqs));
+  SparseBitVector<> SavedIsIrrLoopHeader(std::move(BFI.IsIrrLoopHeader));
   BFI.clear();
   BFI.Freqs = std::move(SavedFreqs);
+  BFI.IsIrrLoopHeader = std::move(SavedIsIrrLoopHeader);
 }
 
 bool BlockFrequencyInfoImplBase::addToDist(Distribution &Dist,
                                            const LoopData *OuterLoop,
                                            const BlockNode &Pred,
                                            const BlockNode &Succ,
                                            uint64_t Weight) {
   if (!Weight)
BlockFrequencyInfoImplBase::getProfileCountFromFreq(const Function &F,
   APInt BlockCount(128, EntryCount.getValue());
   APInt BlockFreq(128, Freq);
   APInt EntryFreq(128, getEntryFreq());
   BlockCount *= BlockFreq;
   BlockCount = BlockCount.udiv(EntryFreq);
   return BlockCount.getLimitedValue();
 }
 
+bool
+BlockFrequencyInfoImplBase::isIrrLoopHeader(const BlockNode &Node) {
+  if (!Node.isValid())
+    return false;
+  return IsIrrLoopHeader.test(Node.Index);
+}
+
 Scaled64
 BlockFrequencyInfoImplBase::getFloatingBlockFreq(const BlockNode &Node) const {
   if (!Node.isValid())
     return Scaled64::getZero();
   return Freqs[Node.Index].Scaled;
 }
 
 void BlockFrequencyInfoImplBase::setBlockFreq(const BlockNode &Node,
DEBUG(dbgs() << " Distribute loop mass " << LoopMass
                << " to headers using above weights\n");
   for (const Weight &W : Dist.Weights) {
     BlockMass Taken = D.takeMass(W.Amount);
     assert(W.Type == Weight::Local && "all weights should be local");
     Working[W.TargetNode.Index].getMass() = Taken;
     DEBUG(debugAssign(*this, D, W.TargetNode, Taken, nullptr));
   }
 }
+
+void BlockFrequencyInfoImplBase::distributeIrrLoopHeaderMass(Distribution &Dist) {
+  BlockMass LoopMass = BlockMass::getFull();
+  DitheringDistributer D(Dist, LoopMass);
+  for (const Weight &W : Dist.Weights) {
+    BlockMass Taken = D.takeMass(W.Amount);
+    assert(W.Type == Weight::Local && "all weights should be local");
+    Working[W.TargetNode.Index].getMass() = Taken;
+    DEBUG(debugAssign(*this, D, W.TargetNode, Taken, nullptr));
+  }
+}

lib/CodeGen/MachineBasicBlock.cpp

 #include <algorithm>
 using namespace llvm;
 
 #define DEBUG_TYPE "codegen"
 
 MachineBasicBlock::MachineBasicBlock(MachineFunction &MF, const BasicBlock *B)
     : BB(B), Number(-1), xParent(&MF) {
   Insts.Parent = this;
+  if (B)
+    IrrLoopHeaderWeight = B->getIrrLoopHeaderWeight();
 }
 
 MachineBasicBlock::~MachineBasicBlock() {
 }
 
 /// Return the MCSymbol for this basic block.
 MCSymbol *MachineBasicBlock::getSymbol() const {
   if (!CachedMCSymbol) {
if (!succ_empty()) {
     OS << "    Successors according to CFG:";
     for (const_succ_iterator SI = succ_begin(), E = succ_end(); SI != E; ++SI) {
       OS << " BB#" << (*SI)->getNumber();
       if (!Probs.empty())
         OS << '(' << *getProbabilityIterator(SI) << ')';
     }
     OS << '\n';
   }
+  if (IrrLoopHeaderWeight) {
+    if (Indexes) OS << '\t';
+    OS << "    Irreducible loop header weight: "
+       << IrrLoopHeaderWeight.getValue();
+    OS << '\n';
+  }
 }
 
 void MachineBasicBlock::printAsOperand(raw_ostream &OS,
                                        bool /*PrintType*/) const {
   OS << "BB#" << getNumber();
 }
 
 void MachineBasicBlock::removeLiveIn(MCPhysReg Reg, LaneBitmask LaneMask) {

lib/CodeGen/MachineBlockFrequencyInfo.cpp

 }
 
 Optional<uint64_t>
 MachineBlockFrequencyInfo::getProfileCountFromFreq(uint64_t Freq) const {
   const Function *F = MBFI->getFunction()->getFunction();
   return MBFI ? MBFI->getProfileCountFromFreq(*F, Freq) : None;
 }
 
+bool
+MachineBlockFrequencyInfo::isIrrLoopHeader(const MachineBasicBlock *MBB) {
+  assert(MBFI && "Expected analysis to be available");
+  return MBFI->isIrrLoopHeader(MBB);
+}
+
 const MachineFunction *MachineBlockFrequencyInfo::getFunction() const {
   return MBFI ? MBFI->getFunction() : nullptr;
 }
 
 const MachineBranchProbabilityInfo *MachineBlockFrequencyInfo::getMBPI() const {
   return MBFI ? &MBFI->getBPI() : nullptr;
 }
 

lib/IR/BasicBlock.cpp

 bool BasicBlock::isLandingPad() const {
   return isa<LandingPadInst>(getFirstNonPHI());
 }
 
 /// Return the landingpad instruction associated with the landing pad.
 const LandingPadInst *BasicBlock::getLandingPadInst() const {
   return dyn_cast<LandingPadInst>(getFirstNonPHI());
 }
+
+Optional<uint64_t> BasicBlock::getIrrLoopHeaderWeight() const {
+  const TerminatorInst *TI = getTerminator();
+  if (MDNode *MDIrrLoopHeader =
+      TI->getMetadata(LLVMContext::MD_irr_loop_header)) {
+    MDString *MDName = cast<MDString>(MDIrrLoopHeader->getOperand(0));
+    if (MDName->getString().equals("header_weight")) {
+      auto *CI = mdconst::extract<ConstantInt>(MDIrrLoopHeader->getOperand(1));
+      return Optional<uint64_t>(CI->getValue().getZExtValue());
+    }
+  }
+  return Optional<uint64_t>();
+}

lib/IR/LLVMContext.cpp

std::pair<unsigned, StringRef> MDKinds[] = {
     {MD_invariant_group, "invariant.group"},
     {MD_align, "align"},
     {MD_loop, "llvm.loop"},
     {MD_type, "type"},
     {MD_section_prefix, "section_prefix"},
     {MD_absolute_symbol, "absolute_symbol"},
     {MD_associated, "associated"},
     {MD_callees, "callees"},
+    {MD_irr_loop_header, "irr_loop_header"},
   };
 
   for (auto &MDKind : MDKinds) {
     unsigned ID = getMDKindID(MDKind.second);
     assert(ID == MDKind.first && "metadata kind id drifted");
     (void)ID;
   }
 

lib/IR/MDBuilder.cpp

MDNode *MDBuilder::createTBAAStructTagNode(MDNode *BaseType, MDNode *AccessType,
   IntegerType *Int64 = Type::getInt64Ty(Context);
   ConstantInt *Off = ConstantInt::get(Int64, Offset);
   if (IsConstant) {
     return MDNode::get(Context, {BaseType, AccessType, createConstant(Off),
                                  createConstant(ConstantInt::get(Int64, 1))});
   }
   return MDNode::get(Context, {BaseType, AccessType, createConstant(Off)});
 }
+
+MDNode *MDBuilder::createIrrLoopHeaderWeight(uint64_t Weight) {
+  SmallVector<Metadata *, 2> Vals(2);
+  Vals[0] = createString("header_weight");
+  Vals[1] = createConstant(ConstantInt::get(Type::getInt64Ty(Context), Weight));
+  return MDNode::get(Context, Vals);
+}

lib/Transforms/Instrumentation/PGOInstrumentation.cpp

static uint64_t sumEdgeCount(const ArrayRef<PGOUseEdge *> Edges) {
   return Total;
 }
 
 class PGOUseFunc {
 public:
   PGOUseFunc(Function &Func, Module *Modu,
              std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers,
              BranchProbabilityInfo *BPI = nullptr,
-             BlockFrequencyInfo *BFI = nullptr)
-      : F(Func), M(Modu), FuncInfo(Func, ComdatMembers, false, BPI, BFI),
+             BlockFrequencyInfo *BFIin = nullptr)
+      : F(Func), M(Modu), BFI(BFIin),
+        FuncInfo(Func, ComdatMembers, false, BPI, BFIin),
         CountPosition(0), ProfileCountSize(0), FreqAttr(FFA_Normal) {}
 
   // Read counts for the instrumented BB from profile.
   bool readCounters(IndexedInstrProfReader *PGOReader);
 
   // Populate the counts for all BBs.
   void populateCounters();
 
   // Set the branch weights based on the count values.
   void setBranchWeights();
 
   // Annotate the value profile call sites all all value kind.
   void annotateValueSites();
 
   // Annotate the value profile call sites for one value kind.
   void annotateValueSites(uint32_t Kind);
 
+  // Annotate the irreducible loop header weights.
+  void annotateIrrLoopHeaderWeights();
+
   // The hotness of the function from the profile count.
   enum FuncFreqAttr { FFA_Normal, FFA_Cold, FFA_Hot };
 
   // Return the function hotness from the profile.
   FuncFreqAttr getFuncFreqAttr() const { return FreqAttr; }
 
   // Return the function hash.
   uint64_t getFuncHash() const { return FuncInfo.FunctionHash; }
public:
 
   void dumpInfo(std::string Str = "") const {
     FuncInfo.dumpInfo(Str);
   }
 
 private:
   Function &F;
   Module *M;
+  BlockFrequencyInfo *BFI;
   // This member stores the shared information with class PGOGenFunc.
   FuncPGOInstrumentation<PGOUseEdge, UseBBInfo> FuncInfo;
 
   // The maximum count value in the profile. This is only used in PGO use
   // compilation.
   uint64_t ProgramMaxCount;
 
   // Position of counter that remains to be read.
for (unsigned s = 0; s < Size; s++) {
       if (EdgeCount > MaxCount)
         MaxCount = EdgeCount;
       EdgeCounts[SuccNum] = EdgeCount;
     }
     setProfMetadata(M, TI, EdgeCounts, MaxCount);
   }
 }
 
+void PGOUseFunc::annotateIrrLoopHeaderWeights() {
+  DEBUG(dbgs() << "\nAnnotating irreducible loop header weights.\n");
+  // Find irr loop headers
+  for (auto &BB : F) {
+    if (BFI->isIrrLoopHeader(&BB)) {
+      TerminatorInst *TI = BB.getTerminator();
+      const UseBBInfo &BBCountInfo = getBBInfo(&BB);
+      setIrrLoopHeaderMetadata(M, TI, BBCountInfo.CountValue);
+    }
+  }
+}
+
 void SelectInstVisitor::instrumentOneSelectInst(SelectInst &SI) {
   Module *M = F.getParent();
   IRBuilder<> Builder(&SI);
   Type *Int64Ty = Builder.getInt64Ty();
   Type *I8PtrTy = Builder.getInt8PtrTy();
   auto *Step = Builder.CreateZExt(SI.getCondition(), Int64Ty);
   Builder.CreateCall(
       Intrinsic::getDeclaration(M, Intrinsic::instrprof_increment_step),
for (auto &F : M) {
     auto *BPI = LookupBPI(F);
     auto *BFI = LookupBFI(F);
     PGOUseFunc Func(F, &M, ComdatMembers, BPI, BFI);
     if (!Func.readCounters(PGOReader.get()))
       continue;
     Func.populateCounters();
     Func.setBranchWeights();
     Func.annotateValueSites();
+    Func.annotateIrrLoopHeaderWeights();
     PGOUseFunc::FuncFreqAttr FreqAttr = Func.getFuncFreqAttr();
     if (FreqAttr == PGOUseFunc::FFA_Cold)
       ColdFunctions.push_back(&F);
     else if (FreqAttr == PGOUseFunc::FFA_Hot)
       HotFunctions.push_back(&F);
     if (PGOViewCounts != PGOVCT_None &&
         (ViewBlockFreqFuncName.empty() ||
          F.getName().equals(ViewBlockFreqFuncName))) {
if (EmitBranchProbability) {
     OptimizationRemarkEmitter ORE(F);
     ORE.emit([&]() {
       return OptimizationRemark(DEBUG_TYPE, "pgo-instrumentation", TI)
              << BrCondStr << " is true with probability : " << BranchProbStr;
     });
   }
 }
 
+void setIrrLoopHeaderMetadata(Module *M, Instruction *TI, uint64_t Count) {
+  MDBuilder MDB(M->getContext());
+  TI->setMetadata(llvm::LLVMContext::MD_irr_loop_header,
+                  MDB.createIrrLoopHeaderWeight(Count));
+}
+
 template <> struct GraphTraits<PGOUseFunc *> {
   typedef const BasicBlock *NodeRef;
   typedef succ_const_iterator ChildIteratorType;
   typedef pointer_iterator<Function::const_iterator> nodes_iterator;
 
   static NodeRef getEntryNode(const PGOUseFunc *G) {
     return &G->getFunc().front();
   }

test/Analysis/BlockFrequencyInfo/irreducible_pgo.ll

+; RUN: opt < %s -analyze -block-freq | FileCheck %s
+; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
+
+; Function Attrs: noinline norecurse nounwind readnone uwtable
+define i32 @_Z11irreducibleii(i32 %iter_outer, i32 %iter_inner) local_unnamed_addr !prof !27 {
+entry:
+  %cmp24 = icmp sgt i32 %iter_outer, 0
+  br i1 %cmp24, label %for.body, label %entry.for.cond.cleanup_crit_edge, !prof !28
+
+entry.for.cond.cleanup_crit_edge:                 ; preds = %entry
+  br label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %for.end, %entry.for.cond.cleanup_crit_edge
+  %sum.0.lcssa = phi i32 [ 0, %entry.for.cond.cleanup_crit_edge ], [ %sum.1, %for.end ]
+  ret i32 %sum.0.lcssa
+
+for.body:                                         ; preds = %for.end, %entry
+  %k.026 = phi i32 [ %inc12, %for.end ], [ 0, %entry ]
+  %sum.025 = phi i32 [ %sum.1, %for.end ], [ 0, %entry ]
+  %rem23 = and i32 %k.026, 1
+  %cmp1 = icmp eq i32 %rem23, 0
+  br i1 %cmp1, label %entry8, label %for.cond2, !prof !29
+
+for.cond2:                                        ; preds = %if.end9, %for.body
+  %sum.1 = phi i32 [ %add10, %if.end9 ], [ %sum.025, %for.body ]
+  %i.0 = phi i32 [ %inc, %if.end9 ], [ 0, %for.body ]
+  %cmp3 = icmp slt i32 %i.0, %iter_inner
+  br i1 %cmp3, label %for.body4, label %for.end, !prof !30, !irr_loop_header !31
+
+for.body4:                                        ; preds = %for.cond2
+  %rem5 = srem i32 %k.026, 3
+  %cmp6 = icmp eq i32 %rem5, 0
+  br i1 %cmp6, label %entry8, label %if.end9, !prof !32
+
+entry8:                                           ; preds = %for.body4, %for.body
+  %sum.2 = phi i32 [ %sum.025, %for.body ], [ %sum.1, %for.body4 ]
+  %i.1 = phi i32 [ 0, %for.body ], [ %i.0, %for.body4 ]
+  %add = add nsw i32 %sum.2, 4
+  br label %if.end9, !irr_loop_header !33
+
+if.end9:                                          ; preds = %entry8, %for.body4
+  %sum.3 = phi i32 [ %add, %entry8 ], [ %sum.1, %for.body4 ]
+  %i.2 = phi i32 [ %i.1, %entry8 ], [ %i.0, %for.body4 ]
+  %add10 = add nsw i32 %sum.3, 1
+  %inc = add nsw i32 %i.2, 1
+  br label %for.cond2, !irr_loop_header !34
+
+for.end:                                          ; preds = %for.cond2
+  %inc12 = add nuw nsw i32 %k.026, 1
+  %exitcond = icmp eq i32 %inc12, %iter_outer
+  br i1 %exitcond, label %for.cond.cleanup, label %for.body, !prof !35
+}
+
+!27 = !{!"function_entry_count", i64 1}
+!28 = !{!"branch_weights", i32 1, i32 0}
+!29 = !{!"branch_weights", i32 50, i32 50}
+!30 = !{!"branch_weights", i32 950, i32 100}
+!31 = !{!"header_weight", i64 1050}
+!32 = !{!"branch_weights", i32 323, i32 627}
+!33 = !{!"header_weight", i64 373}
+!34 = !{!"header_weight", i64 1000}
+!35 = !{!"branch_weights", i32 1, i32 99}
+
+; CHECK-LABEL: Printing analysis {{.*}} for function '_Z11irreducibleii':
+; CHECK-NEXT: block-frequency-info: _Z11irreducibleii
+; CHECK-NEXT: - entry: {{.*}} count = 1
+; CHECK-NEXT: - entry.for.cond.cleanup_crit_edge: {{.*}} count = 0
+; CHECK-NEXT: - for.cond.cleanup: {{.*}} count = 1
+; CHECK-NEXT: - for.body: {{.*}} count = 100
+; CHECK-NEXT: - for.cond2: {{.*}} count = 1050, irr_loop_header_weight = 1050
+; CHECK-NEXT: - for.body4: {{.*}} count = 950
+; CHECK-NEXT: - entry8: {{.*}} count = 373, irr_loop_header_weight = 373
+; CHECK-NEXT: - if.end9: {{.*}} count = 1000, irr_loop_header_weight = 1000
+; CHECK-NEXT: - for.end: {{.*}} count = 100
+
+@targets = local_unnamed_addr global [256 x i8*] zeroinitializer, align 16
+@tracing = local_unnamed_addr global i32 0, align 4
+
+; Function Attrs: noinline norecurse nounwind uwtable
+define i32 @_Z11irreduciblePh(i8* nocapture readonly %p) !prof !27 {
+entry:
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast ([256 x i8*]* @targets to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 2) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 4) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 6) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 8) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 10) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 12) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 14) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 16) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 18) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 20) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 22) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 24) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 26) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 28) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 30) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 32) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 34) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 36) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 38) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 40) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 42) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 44) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 46) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 48) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 50) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 52) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 54) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 56) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 58) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 60) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 62) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 64) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 66) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 68) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 70) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 72) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 74) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 76) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 78) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 80) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 82) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 84) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 86) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 88) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 90) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 92) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 94) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 96) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 98) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 100) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 102) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 104) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 106) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 108) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 110) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 112) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 114) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 116) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 118) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 120) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 122) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 124) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 126) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 128) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 130) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 132) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 134) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 136) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 138) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 140) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 142) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 144) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 146) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 148) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 150) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 152) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 154) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 156) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 158) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 160) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 162) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 164) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 166) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 168) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 170) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 172) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 174) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 176) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 178) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 180) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 182) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 184) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 186) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 188) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 190) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 192) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 194) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 196) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 198) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 200) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 202) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 204) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 206) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 208) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 210) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 212) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 214) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 216) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 218) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 220) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 222) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 224) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 226) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 228) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 230) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 232) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 234) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 236) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 238) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 240) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 242) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 244) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 246) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 248) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 250) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 252) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 254) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %sw.bb), i8* blockaddress(@_Z11irreduciblePh, %TARGET_1)>, <2 x i8*>* bitcast ([256 x i8*]* @targets to <2 x i8*>*), align 16
+  store i8* blockaddress(@_Z11irreduciblePh, %TARGET_2), i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 2), align 16
+  %0 = load i32, i32* @tracing, align 4
+  %tobool = icmp eq i32 %0, 0
+  br label %for.cond1
+
+for.cond1:                                        ; preds = %sw.default, %entry
+  %p.addr.0 = phi i8* [ %p, %entry ], [ %p.addr.4, %sw.default ]
+  %sum.0 = phi i32 [ 0, %entry ], [ %add25, %sw.default ]
+  %incdec.ptr = getelementptr inbounds i8, i8* %p.addr.0, i64 1
+  %1 = load i8, i8* %p.addr.0, align 1
+  %incdec.ptr2 = getelementptr inbounds i8, i8* %p.addr.0, i64 2
+  %2 = load i8, i8* %incdec.ptr, align 1
+  %conv3 = zext i8 %2 to i32
+  br label %dispatch_op
+
+dispatch_op:                                      ; preds = %sw.bb6, %for.cond1
+  %p.addr.1 = phi i8* [ %incdec.ptr2, %for.cond1 ], [ %p.addr.2, %sw.bb6 ]
+  %op.0 = phi i8 [ %1, %for.cond1 ], [ 1, %sw.bb6 ]
+  %oparg.0 = phi i32 [ %conv3, %for.cond1 ], [ %oparg.2, %sw.bb6 ]
+  %sum.1 = phi i32 [ %sum.0, %for.cond1 ], [ %add7, %sw.bb6 ]
+  switch i8 %op.0, label %sw.default [
+    i8 0, label %sw.bb
+    i8 1, label %dispatch_op.sw.bb6_crit_edge
+    i8 2, label %sw.bb15
+  ], !prof !36
+
+dispatch_op.sw.bb6_crit_edge:                     ; preds = %dispatch_op
+  br label %sw.bb6
+
+sw.bb:                                            ; preds = %indirectgoto, %dispatch_op
+  %oparg.1 = phi i32 [ %oparg.0, %dispatch_op ], [ 0, %indirectgoto ]
+  %sum.2 = phi i32 [ %sum.1, %dispatch_op ], [ %sum.7, %indirectgoto ]
+  %add.neg = sub i32 -5, %oparg.1
+  %sub = add i32 %add.neg, %sum.2
+  br label %exit
+
+TARGET_1:                                         ; preds = %indirectgoto
+  %incdec.ptr4 = getelementptr inbounds i8, i8* %add.ptr.pn, i64 2
+  %3 = load i8, i8* %p.addr.5, align 1
+  %conv5 = zext i8 %3 to i32
+  br label %sw.bb6
+
+sw.bb6:                                           ; preds = %TARGET_1, %dispatch_op.sw.bb6_crit_edge
+  %p.addr.2 = phi i8* [ %incdec.ptr4, %TARGET_1 ], [ %p.addr.1, %dispatch_op.sw.bb6_crit_edge ]
+  %oparg.2 = phi i32 [ %conv5, %TARGET_1 ], [ %oparg.0, %dispatch_op.sw.bb6_crit_edge ]
+  %sum.3 = phi i32 [ %sum.7, %TARGET_1 ], [ %sum.1, %dispatch_op.sw.bb6_crit_edge ]
+  %mul = mul nsw i32 %oparg.2, 7
+  %add7 = add nsw i32 %sum.3, %mul
+  %rem46 = and i32 %add7, 1
+  %cmp8 = icmp eq i32 %rem46, 0
+  br i1 %cmp8, label %dispatch_op, label %if.then, !prof !37, !irr_loop_header !38
+
+if.then:                                          ; preds = %sw.bb6
+  %mul9 = mul nsw i32 %add7, 9
+  br label %indirectgoto
+
+TARGET_2:                                         ; preds = %indirectgoto
+  %incdec.ptr13 = getelementptr inbounds i8, i8* %add.ptr.pn, i64 2
+  %4 = load i8, i8* %p.addr.5, align 1
+  %conv14 = zext i8 %4 to i32
+  br label %sw.bb15
+
+sw.bb15:                                          ; preds = %TARGET_2, %dispatch_op
+  %p.addr.3 = phi i8* [ %p.addr.1, %dispatch_op ], [ %incdec.ptr13, %TARGET_2 ]
+  %oparg.3 = phi i32 [ %oparg.0, %dispatch_op ], [ %conv14, %TARGET_2 ]
+  %sum.4 = phi i32 [ %sum.1, %dispatch_op ], [ %sum.7, %TARGET_2 ]
+  %add16 = add nsw i32 %oparg.3, 3
+  %add17 = add nsw i32 %add16, %sum.4
+  br i1 %tobool, label %if.then18, label %exit, !prof !39, !irr_loop_header !40
+
+if.then18:                                        ; preds = %sw.bb15
+  %idx.ext = sext i32 %oparg.3 to i64
+  %add.ptr = getelementptr inbounds i8, i8* %p.addr.3, i64 %idx.ext
+  %mul19 = mul nsw i32 %add17, 17
+  br label %indirectgoto
+
+unknown_op:                                       ; preds = %indirectgoto
+  %sub24 = add nsw i32 %sum.7, -4
+  br label %sw.default
+
+sw.default:                                       ; preds = %unknown_op, %dispatch_op
+  %p.addr.4 = phi i8* [ %p.addr.5, %unknown_op ], [ %p.addr.1, %dispatch_op ]
+  %sum.5 = phi i32 [ %sub24, %unknown_op ], [ %sum.1, %dispatch_op ]
+  %add25 = add nsw i32 %sum.5, 11
+  br label %for.cond1
+
+exit:                                             ; preds = %sw.bb15, %sw.bb
+  %sum.6 = phi i32 [ %sub, %sw.bb ], [ %add17, %sw.bb15 ]
+  ret i32 %sum.6
+
+indirectgoto:                                     ; preds = %if.then18, %if.then
+  %add.ptr.pn = phi i8* [ %add.ptr, %if.then18 ], [ %p.addr.2, %if.then ]
+  %sum.7 = phi i32 [ %mul19, %if.then18 ], [ %mul9, %if.then ]
+  %p.addr.5 = getelementptr inbounds i8, i8* %add.ptr.pn, i64 1
+  %5 = load i8, i8* %add.ptr.pn, align 1
+  %idxprom21 = zext i8 %5 to i64
+  %arrayidx22 = getelementptr inbounds [256 x i8*], [256 x i8*]* @targets, i64 0, i64 %idxprom21
+  %6 = load i8*, i8** %arrayidx22, align 8
+  indirectbr i8* %6, [label %unknown_op, label %sw.bb, label %TARGET_1, label %TARGET_2], !prof !41, !irr_loop_header !42
+}
+
+!36 = !{!"branch_weights", i32 0, i32 0, i32 201, i32 1}
+!37 = !{!"branch_weights", i32 201, i32 300}
+!38 = !{!"header_weight", i64 501}
+!39 = !{!"branch_weights", i32 100, i32 0}
+!40 = !{!"header_weight", i64 100}
+!41 = !{!"branch_weights", i32 0, i32 1, i32 300, i32 99}
+!42 = !{!"header_weight", i64 400}
+
+; CHECK-LABEL: Printing analysis {{.*}} for function '_Z11irreduciblePh':
+; CHECK-NEXT: block-frequency-info: _Z11irreduciblePh
+; CHECK-NEXT: - entry: {{.*}} count = 1
+; CHECK-NEXT: - for.cond1: {{.*}} count = 1
+; CHECK-NEXT: - dispatch_op: {{.*}} count = 201
+; CHECK-NEXT: - dispatch_op.sw.bb6_crit_edge: {{.*}} count = 200
+; CHECK-NEXT: - sw.bb: {{.*}} count = 0
+; CHECK-NEXT: - TARGET_1: {{.*}} count = 299
+; CHECK-NEXT: - sw.bb6: {{.*}} count = 500, irr_loop_header_weight = 501
+; CHECK-NEXT: - if.then: {{.*}} count = 299
+; CHECK-NEXT: - TARGET_2: {{.*}} count = 98
+; CHECK-NEXT: - sw.bb15: {{.*}} count = 99, irr_loop_header_weight = 100
+; CHECK-NEXT: - if.then18: {{.*}} count = 99
+; CHECK-NEXT: - unknown_op: {{.*}} count = 0
+; CHECK-NEXT: - sw.default: {{.*}} count = 0
+; CHECK-NEXT: - exit: {{.*}} count = 1
+; CHECK-NEXT: - indirectgoto: {{.*}} count = 399, irr_loop_header_weight = 400

test/ThinLTO/X86/lazyload_metadata.ll

 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t.bc -bitcode-mdindex-threshold=0
 ; RUN: opt -module-summary %p/Inputs/lazyload_metadata.ll -o %t2.bc -bitcode-mdindex-threshold=0
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.bc %t.bc %t2.bc
 ; REQUIRES: asserts
 
 ; Check that importing @globalfunc1 does not trigger loading all the global
 ; metadata for @globalfunc2 and @globalfunc3
 
 ; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc \
 ; RUN:          -o /dev/null -stats \
 ; RUN:  2>&1 | FileCheck %s -check-prefix=LAZY
-; LAZY: 53 bitcode-reader  - Number of Metadata records loaded
+; LAZY: 55 bitcode-reader  - Number of Metadata records loaded
 ; LAZY: 2 bitcode-reader  - Number of MDStrings loaded
 
 ; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc \
 ; RUN:          -o /dev/null -disable-ondemand-mds-loading -stats \
 ; RUN:  2>&1 | FileCheck %s -check-prefix=NOTLAZY
-; NOTLAZY: 62 bitcode-reader  - Number of Metadata records loaded
+; NOTLAZY: 64 bitcode-reader  - Number of Metadata records loaded
 ; NOTLAZY: 7 bitcode-reader  - Number of MDStrings loaded
 
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 define void @globalfunc1(i32 %arg) {
   %x = call i1 @llvm.type.test(i8* undef, metadata !"typeid1")

test/Transforms/PGOProfile/Inputs/irreducible.proftext

+:ir
+_Z11irreducibleii
+# Func Hash:
[phone]
+# Num Counters:
+6
+# Counter Values:
+1000
+950
+100
+373
+1
+0
+
+_Z11irreduciblePh
+# Func Hash:
[phone]
+# Num Counters:
+9
+# Counter Values:
+100
+300
+99
+300
+201
+1
+1
+0
+0

test/Transforms/PGOProfile/irreducible.ll

+; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
+; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
+; RUN: llvm-profdata merge %S/Inputs/irreducible.proftext -o %t.profdata
+; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
+; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
+
+; GEN: $__llvm_profile_raw_version = comdat any
+
+; Function Attrs: noinline norecurse nounwind readnone uwtable
+define i32 @_Z11irreducibleii(i32 %iter_outer, i32 %iter_inner) local_unnamed_addr #0 {
+entry:
+  %cmp24 = icmp sgt i32 %iter_outer, 0
+  br i1 %cmp24, label %for.body, label %entry.for.cond.cleanup_crit_edge
+
+entry.for.cond.cleanup_crit_edge:                 ; preds = %entry
+  br label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %entry.for.cond.cleanup_crit_edge, %for.end
+  %sum.0.lcssa = phi i32 [ 0, %entry.for.cond.cleanup_crit_edge ], [ %sum.1, %for.end ]
+  ret i32 %sum.0.lcssa
+
+for.body:                                         ; preds = %entry, %for.end
+  %k.026 = phi i32 [ %inc12, %for.end ], [ 0, %entry ]
+  %sum.025 = phi i32 [ %sum.1, %for.end ], [ 0, %entry ]
+  %rem23 = and i32 %k.026, 1
+  %cmp1 = icmp eq i32 %rem23, 0
+  br i1 %cmp1, label %entry8, label %for.cond2
+
+for.cond2:                                        ; preds = %for.body, %if.end9
+  %sum.1 = phi i32 [ %add10, %if.end9 ], [ %sum.025, %for.body ]
+  %i.0 = phi i32 [ %inc, %if.end9 ], [ 0, %for.body ]
+  %cmp3 = icmp slt i32 %i.0, %iter_inner
+  br i1 %cmp3, label %for.body4, label %for.end
+; USE: br i1 %cmp3, label %for.body4, label %for.end, !prof !{{[0-9]+}},
+; USE-SAME: !irr_loop_header ![[FOR_COND2_IRR_LOOP:[0-9]+]]
+
+for.body4:                                        ; preds = %for.cond2
+  %rem5 = srem i32 %k.026, 3
+  %cmp6 = icmp eq i32 %rem5, 0
+  br i1 %cmp6, label %entry8, label %if.end9
+
+entry8:                                           ; preds = %for.body4, %for.body
+  %sum.2 = phi i32 [ %sum.025, %for.body ], [ %sum.1, %for.body4 ]
+  %i.1 = phi i32 [ 0, %for.body ], [ %i.0, %for.body4 ]
+  %add = add nsw i32 %sum.2, 4
+  br label %if.end9
+; USE: br label %if.end9,
+; USE-SAME: !irr_loop_header ![[ENTRY8_IRR_LOOP:[0-9]+]]
+
+if.end9:                                          ; preds = %entry8, %for.body4
+  %sum.3 = phi i32 [ %add, %entry8 ], [ %sum.1, %for.body4 ]
+  %i.2 = phi i32 [ %i.1, %entry8 ], [ %i.0, %for.body4 ]
+  %add10 = add nsw i32 %sum.3, 1
+  %inc = add nsw i32 %i.2, 1
+  br label %for.cond2
+; USE: br label %for.cond2,
+; USE-SAME: !irr_loop_header ![[IF_END9_IRR_LOOP:[0-9]+]]
+
+for.end:                                          ; preds = %for.cond2
+  %inc12 = add nuw nsw i32 %k.026, 1
+  %exitcond = icmp eq i32 %inc12, %iter_outer
+  br i1 %exitcond, label %for.cond.cleanup, label %for.body
+}
+
+
+
+@targets = local_unnamed_addr global [256 x i8*] zeroinitializer, align 16
+@tracing = local_unnamed_addr global i32 0, align 4
+
+; Function Attrs: noinline norecurse nounwind uwtable
+define i32 @_Z11irreduciblePh(i8* nocapture readonly %p) {
+entry:
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast ([256 x i8*]* @targets to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 2) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 4) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 6) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 8) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 10) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 12) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 14) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 16) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 18) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 20) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 22) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 24) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 26) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 28) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 30) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 32) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 34) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 36) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 38) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 40) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 42) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 44) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 46) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 48) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 50) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 52) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 54) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 56) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 58) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 60) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 62) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 64) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 66) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 68) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 70) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 72) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 74) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 76) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 78) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 80) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 82) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 84) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 86) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 88) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 90) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 92) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 94) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 96) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 98) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 100) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 102) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 104) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 106) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 108) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 110) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 112) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 114) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 116) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 118) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 120) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 122) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 124) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 126) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 128) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 130) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 132) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 134) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 136) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 138) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 140) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 142) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 144) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 146) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 148) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 150) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 152) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 154) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 156) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 158) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 160) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 162) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 164) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 166) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 168) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 170) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 172) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 174) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 176) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 178) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 180) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 182) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 184) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 186) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 188) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 190) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 192) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 194) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 196) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 198) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 200) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 202) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 204) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 206) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 208) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 210) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 212) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 214) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 216) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 218) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 220) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 222) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 224) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 226) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 228) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 230) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 232) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 234) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 236) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 238) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 240) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 242) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 244) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 246) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 248) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 250) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 252) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %unknown_op), i8* blockaddress(@_Z11irreduciblePh, %unknown_op)>, <2 x i8*>* bitcast (i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 254) to <2 x i8*>*), align 16
+  store <2 x i8*> <i8* blockaddress(@_Z11irreduciblePh, %sw.bb), i8* blockaddress(@_Z11irreduciblePh, %TARGET_1)>, <2 x i8*>* bitcast ([256 x i8*]* @targets to <2 x i8*>*), align 16
+  store i8* blockaddress(@_Z11irreduciblePh, %TARGET_2), i8** getelementptr inbounds ([256 x i8*], [256 x i8*]* @targets, i64 0, i64 2), align 16
+  %0 = load i32, i32* @tracing, align 4
+  %tobool = icmp eq i32 %0, 0
+  br label %for.cond1
+
+for.cond1:                                        ; preds = %sw.default, %entry
+  %p.addr.0 = phi i8* [ %p, %entry ], [ %p.addr.4, %sw.default ]
+  %sum.0 = phi i32 [ 0, %entry ], [ %add25, %sw.default ]
+  %incdec.ptr = getelementptr inbounds i8, i8* %p.addr.0, i64 1
+  %1 = load i8, i8* %p.addr.0, align 1
+  %incdec.ptr2 = getelementptr inbounds i8, i8* %p.addr.0, i64 2
+  %2 = load i8, i8* %incdec.ptr, align 1
+  %conv3 = zext i8 %2 to i32
+  br label %dispatch_op
+
+dispatch_op:                                      ; preds = %sw.bb6, %for.cond1
+  %p.addr.1 = phi i8* [ %incdec.ptr2, %for.cond1 ], [ %p.addr.2, %sw.bb6 ]
+  %op.0 = phi i8 [ %1, %for.cond1 ], [ 1, %sw.bb6 ]
+  %oparg.0 = phi i32 [ %conv3, %for.cond1 ], [ %oparg.2, %sw.bb6 ]
+  %sum.1 = phi i32 [ %sum.0, %for.cond1 ], [ %add7, %sw.bb6 ]
+  switch i8 %op.0, label %sw.default [
+    i8 0, label %sw.bb
+    i8 1, label %dispatch_op.sw.bb6_crit_edge
+    i8 2, label %sw.bb15
+  ]
+
+dispatch_op.sw.bb6_crit_edge:                     ; preds = %dispatch_op
+  br label %sw.bb6
+
+sw.bb:                                            ; preds = %indirectgoto, %dispatch_op
+  %oparg.1 = phi i32 [ %oparg.0, %dispatch_op ], [ 0, %indirectgoto ]
+  %sum.2 = phi i32 [ %sum.1, %dispatch_op ], [ %sum.7, %indirectgoto ]
+  %add.neg = sub i32 -5, %oparg.1
+  %sub = add i32 %add.neg, %sum.2
+  br label %exit
+
+TARGET_1:                                         ; preds = %indirectgoto
+  %incdec.ptr4 = getelementptr inbounds i8, i8* %add.ptr.pn, i64 2
+  %3 = load i8, i8* %p.addr.5, align 1
+  %conv5 = zext i8 %3 to i32
+  br label %sw.bb6
+
+sw.bb6:                                           ; preds = %dispatch_op.sw.bb6_crit_edge, %TARGET_1
+  %p.addr.2 = phi i8* [ %incdec.ptr4, %TARGET_1 ], [ %p.addr.1, %dispatch_op.sw.bb6_crit_edge ]
+  %oparg.2 = phi i32 [ %conv5, %TARGET_1 ], [ %oparg.0, %dispatch_op.sw.bb6_crit_edge ]
+  %sum.3 = phi i32 [ %sum.7, %TARGET_1 ], [ %sum.1, %dispatch_op.sw.bb6_crit_edge ]
+  %mul = mul nsw i32 %oparg.2, 7
+  %add7 = add nsw i32 %sum.3, %mul
+  %rem46 = and i32 %add7, 1
+  %cmp8 = icmp eq i32 %rem46, 0
+  br i1 %cmp8, label %dispatch_op, label %if.then
+; USE: br i1 %cmp8, label %dispatch_op, label %if.then, !prof !{{[0-9]+}},
+; USE-SAME: !irr_loop_header ![[SW_BB6_IRR_LOOP:[0-9]+]]
+
+if.then:                                          ; preds = %sw.bb6
+  %mul9 = mul nsw i32 %add7, 9
+  br label %indirectgoto
+
+TARGET_2:                                         ; preds = %indirectgoto
+  %incdec.ptr13 = getelementptr inbounds i8, i8* %add.ptr.pn, i64 2
+  %4 = load i8, i8* %p.addr.5, align 1
+  %conv14 = zext i8 %4 to i32
+  br label %sw.bb15
+
+sw.bb15:                                          ; preds = %TARGET_2, %dispatch_op
+  %p.addr.3 = phi i8* [ %p.addr.1, %dispatch_op ], [ %incdec.ptr13, %TARGET_2 ]
+  %oparg.3 = phi i32 [ %oparg.0, %dispatch_op ], [ %conv14, %TARGET_2 ]
+  %sum.4 = phi i32 [ %sum.1, %dispatch_op ], [ %sum.7, %TARGET_2 ]
+  %add16 = add nsw i32 %oparg.3, 3
+  %add17 = add nsw i32 %add16, %sum.4
+  br i1 %tobool, label %if.then18, label %exit
+; USE: br i1 %tobool, label %if.then18, label %exit, !prof !{{[0-9]+}},
+; USE-SAME: !irr_loop_header ![[SW_BB15_IRR_LOOP:[0-9]+]]
+
+if.then18:                                        ; preds = %sw.bb15
+  %idx.ext = sext i32 %oparg.3 to i64
+  %add.ptr = getelementptr inbounds i8, i8* %p.addr.3, i64 %idx.ext
+  %mul19 = mul nsw i32 %add17, 17
+  br label %indirectgoto
+
+unknown_op:                                       ; preds = %indirectgoto
+  %sub24 = add nsw i32 %sum.7, -4
+  br label %sw.default
+
+sw.default:                                       ; preds = %unknown_op, %dispatch_op
+  %p.addr.4 = phi i8* [ %p.addr.5, %unknown_op ], [ %p.addr.1, %dispatch_op ]
+  %sum.5 = phi i32 [ %sub24, %unknown_op ], [ %sum.1, %dispatch_op ]
+  %add25 = add nsw i32 %sum.5, 11
+  br label %for.cond1
+
+exit:                                             ; preds = %sw.bb15, %sw.bb
+  %sum.6 = phi i32 [ %sub, %sw.bb ], [ %add17, %sw.bb15 ]
+  ret i32 %sum.6
+
+indirectgoto:                                     ; preds = %if.then18, %if.then
+  %add.ptr.pn = phi i8* [ %add.ptr, %if.then18 ], [ %p.addr.2, %if.then ]
+  %sum.7 = phi i32 [ %mul19, %if.then18 ], [ %mul9, %if.then ]
+  %p.addr.5 = getelementptr inbounds i8, i8* %add.ptr.pn, i64 1
+  %5 = load i8, i8* %add.ptr.pn, align 1
+  %idxprom21 = zext i8 %5 to i64
+  %arrayidx22 = getelementptr inbounds [256 x i8*], [256 x i8*]* @targets, i64 0, i64 %idxprom21
+  %6 = load i8*, i8** %arrayidx22, align 8
+  indirectbr i8* %6, [label %unknown_op, label %sw.bb, label %TARGET_1, label %TARGET_2]
+; USE: indirectbr i8* %6, [label %unknown_op, label %sw.bb, label %TARGET_1, label %TARGET_2], !prof !{{[0-9]+}},
+; USE-SAME: !irr_loop_header ![[INDIRECTGOTO_IRR_LOOP:[0-9]+]]
+}
+
+; USE: ![[FOR_COND2_IRR_LOOP]] = !{!"header_weight", i64 1050}
+; USE: ![[ENTRY8_IRR_LOOP]] = !{!"header_weight", i64 373}
+; USE: ![[IF_END9_IRR_LOOP]] = !{!"header_weight", i64 1000}
+; USE: ![[SW_BB6_IRR_LOOP]] = !{!"header_weight", i64 501}
+; USE: ![[SW_BB15_IRR_LOOP]] = !{!"header_weight", i64 100}
+; USE: ![[INDIRECTGOTO_IRR_LOOP]] = !{!"header_weight", i64 400}