[CSSPGO] Undoing the concept of dangling pseudo probe

[hoy]

Summary

As a follow-up to https://reviews.llvm.org/D104129, I'm cleaning up the danling probe related code in both the compiler and llvm-profgen.

I'm seeing a 5% size win for the pseudo_probe section for SPEC2017 and 10% for Ciner. Certain benchmark such as 602.gcc has a 20% size win. No obvious difference seen on build time for SPEC2017 and Cinder.

[hoy]

Updating D104477: [CSSPGO] Undoing the concept of dangling pseudo probe

[wenlei]

Thanks for the clean up.

llvm/test/tools/llvm-profgen/merge-cold-profile.test

25

I thought the changes for removing dangling probes are later, and checksum is computed earlier? What triggered cfg checksum changes?

[hoy]

llvm/test/tools/llvm-profgen/merge-cold-profile.test

25

It' probably due to different version of compilers used to build the test binary. Previous compiler didn't include number of direct calls in CFGChecksum.

[wenlei]

lgtm, thanks.

llvm/include/llvm/CodeGen/MachineBasicBlock.h

#endif
   /// copies all the successors FromMBB and remove all the successors from
   /// FromMBB).
   void transferSuccessors(MachineBasicBlock *FromMBB);
 
   /// Transfers all the successors, as in transferSuccessors, and update PHI
   /// operands in the successor blocks which refer to FromMBB to refer to this.
   void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB);
 
-  /// move all pseudo probes in this block to the end of /c ToMBB To and tag
-  /// them dangling.
-  void moveAndDanglePseudoProbes(MachineBasicBlock *ToMBB);
-
   /// Return true if any of the successors have probabilities attached to them.
   bool hasSuccessorProbabilities() const { return !Probs.empty(); }
 
   /// Return true if the specified MBB is a predecessor of this block.
   bool isPredecessor(const MachineBasicBlock *MBB) const;
 
   /// Return true if the specified MBB is a successor of this block.
   bool isSuccessor(const MachineBasicBlock *MBB) const;

llvm/include/llvm/IR/PseudoProbe.h

 class BasicBlock;
 
 constexpr const char *PseudoProbeDescMetadataName = "llvm.pseudo_probe_desc";
 
 enum class PseudoProbeType { Block = 0, IndirectCall, DirectCall };
 
 enum class PseudoProbeAttributes {
   Reserved = 0x1, // Reserved for future use.
-  Dangling = 0x2, // The probe is dangling.
 };
 
 // The saturated distrution factor representing 100% for block probes.
 constexpr static uint64_t PseudoProbeFullDistributionFactor =
     std::numeric_limits<uint64_t>::max();
 
 struct PseudoProbeDwarfDiscriminator {
 public:

 struct PseudoProbe {
   uint32_t Id;
   uint32_t Type;
   uint32_t Attr;
   // Distribution factor that estimates the portion of the real execution count.
   // A saturated distribution factor stands for 1.0 or 100%. A pesudo probe has
   // a factor with the value ranged from 0.0 to 1.0.
   float Factor;
-
-  bool isDangling() const {
-    return Attr & (uint32_t)PseudoProbeAttributes::Dangling;
-  }
 };
 
 Optional<PseudoProbe> extractProbe(const Instruction &Inst);
 
 void setProbeDistributionFactor(Instruction &Inst, float Factor);
-
-bool moveAndDanglePseudoProbes(BasicBlock *From, Instruction *To);
-
-bool removeRedundantPseudoProbes(BasicBlock *Block);
 } // end namespace llvm
 
 #endif // LLVM_IR_PSEUDOPROBE_H

llvm/include/llvm/MC/MCPseudoProbe.h

 //        Number of callees inlined into this function, aka number of
 //        first-level inlinees
 //    PROBE RECORDS
 //        A list of NPROBES entries. Each entry contains:
 //          INDEX (ULEB128)
 //          TYPE (uint4)
 //            0 - block probe, 1 - indirect call, 2 - direct call
 //          ATTRIBUTE (uint3)
-//            1 - reserved, 2 - dangling
+//            1 - reserved
 //          ADDRESS_TYPE (uint1)
 //            0 - code address, 1 - address delta
 //          CODE_ADDRESS (uint64 or ULEB128)
 //            code address or address delta, depending on ADDRESS_TYPE
 //    INLINED FUNCTION RECORDS
 //        A list of NUM_INLINED_FUNCTIONS entries describing each of the inlined
 //        callees.  Each record contains:
 //          INLINE SITE

llvm/include/llvm/Transforms/Utils/BasicBlockUtils.h

 /// MergeBlockIntoPredecessor returns true.
 bool MergeBlockSuccessorsIntoGivenBlocks(
     SmallPtrSetImpl<BasicBlock *> &MergeBlocks, Loop *L = nullptr,
     DomTreeUpdater *DTU = nullptr, LoopInfo *LI = nullptr);
 
 /// Try to remove redundant dbg.value instructions from given basic block.
 /// Returns true if at least one instruction was removed. Remove redundant
 /// pseudo ops when RemovePseudoOp is true.
-bool RemoveRedundantDbgInstrs(BasicBlock *BB, bool RemovePseudoOp = false);
+bool RemoveRedundantDbgInstrs(BasicBlock *BB);
 
 /// Replace all uses of an instruction (specified by BI) with a value, then
 /// remove and delete the original instruction.
 void ReplaceInstWithValue(BasicBlock::InstListType &BIL,
                           BasicBlock::iterator &BI, Value *V);
 
 /// Replace the instruction specified by BI with the instruction specified by I.
 /// Copies DebugLoc from BI to I, if I doesn't already have a DebugLoc. The

llvm/lib/CodeGen/BranchFolding.cpp

for (MachineBasicBlock *SuccBB : MBB.successors())
     if (SuccBB->pred_size() == 1)
       copyDebugInfoToSuccessor(TII, MBB, *SuccBB);
   // If this MBB is the only successor of a predecessor it is legal to copy the
   // DBG_VALUE instructions to the end of the predecessor (just before the
   // terminators, assuming that the terminator isn't affecting the DBG_VALUE).
   for (MachineBasicBlock *PredBB : MBB.predecessors())
     if (PredBB->succ_size() == 1)
       copyDebugInfoToPredecessor(TII, MBB, *PredBB);
-
-  // For AutoFDO, if the block is removed, we won't be able to sample it. To
-  // avoid assigning a zero weight for BB, move all its pseudo probes into once
-  // of its predecessors or successors and mark them dangling. This should allow
-  // the counts inference a chance to get a more reasonable weight for the
-  // block.
-  if (!MBB.pred_empty())
-    MBB.moveAndDanglePseudoProbes(*MBB.pred_begin());
-  else if (!MBB.succ_empty())
-    MBB.moveAndDanglePseudoProbes(*MBB.succ_begin());
 }
 
 bool BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) {
   bool MadeChange = false;
   MachineFunction &MF = *MBB->getParent();
 ReoptimizeBlock:
 
   MachineFunction::iterator FallThrough = MBB->getIterator();

llvm/lib/CodeGen/MachineBasicBlock.cpp

while (!FromMBB->succ_empty()) {
     FromMBB->removeSuccessor(Succ);
 
     // Fix up any PHI nodes in the successor.
     Succ->replacePhiUsesWith(FromMBB, this);
   }
   normalizeSuccProbs();
 }
 
-/// A block emptied (i.e., with all instructions moved out of it) won't be
-/// sampled at run time. In such cases, AutoFDO will be informed of zero samples
-/// collected for the block. This is not accurate and could lead to misleading
-/// weights assigned for the block. A way to mitigate that is to treat such
-/// block as having unknown counts in the AutoFDO profile loader and allow the
-/// counts inference tool a chance to calculate a relatively reasonable weight
-/// for it. This can be done by moving all pseudo probes in the emptied block
-/// i.e, /c this, to before /c ToMBB and tag them dangling. Note that this is
-/// not needed for dead blocks which really have a zero weight. It's per
-/// transforms to decide whether to call this function or not.
-void MachineBasicBlock::moveAndDanglePseudoProbes(MachineBasicBlock *ToMBB) {
-  SmallVector<MachineInstr *, 4> ToBeMoved;
-  for (MachineInstr &MI : instrs()) {
-    if (MI.isPseudoProbe()) {
-      MI.addPseudoProbeAttribute(PseudoProbeAttributes::Dangling);
-      ToBeMoved.push_back(&MI);
-    }
-  }
-
-  MachineBasicBlock::iterator I = ToMBB->getFirstTerminator();
-  for (MachineInstr *MI : ToBeMoved) {
-    MI->removeFromParent();
-    ToMBB->insert(I, MI);
-  }
-}
-
 bool MachineBasicBlock::isPredecessor(const MachineBasicBlock *MBB) const {
   return is_contained(predecessors(), MBB);
 }
 
 bool MachineBasicBlock::isSuccessor(const MachineBasicBlock *MBB) const {
   return is_contained(successors(), MBB);
 }
 

llvm/lib/CodeGen/PseudoProbeInserter.cpp

for (MachineBasicBlock &MBB : MF) {
           MBB.remove(ProbeInstr);
           MBB.insert(FirstInstr, ProbeInstr);
           Changed = true;
         }
       } else {
         // Probes not surrounded by any real instructions in the same block are
         // called dangling probes. Since there's no good way to pick up a sample
         // collection point for dangling probes at compile time, they are being
-        // tagged so that the profile correlation tool will not report any
+        // removed so that the profile correlation tool will not report any
         // samples collected for them and it's up to the counts inference tool
         // to get them a reasonable count.
-        for (MachineInstr &MI : MBB) {
-          if (MI.isPseudoProbe())
-            MI.addPseudoProbeAttribute(PseudoProbeAttributes::Dangling);
-        }
-      }
-    }
-
-    // Remove redundant dangling probes. Same dangling probes are redundant
-    // since they all have the same semantic that is to rely on the counts
-    // inference too to get reasonable count for the same original block.
-    // Therefore, there's no need to keep multiple copies of them.
-    auto Hash = [](const MachineInstr *MI) {
-      return std::hash<uint64_t>()(MI->getOperand(0).getImm()) ^
-             std::hash<uint64_t>()(MI->getOperand(1).getImm());
-    };
-
-    auto IsEqual = [](const MachineInstr *Left, const MachineInstr *Right) {
-      return Left->getOperand(0).getImm() == Right->getOperand(0).getImm() &&
-             Left->getOperand(1).getImm() == Right->getOperand(1).getImm() &&
-             Left->getOperand(3).getImm() == Right->getOperand(3).getImm() &&
-             Left->getDebugLoc() == Right->getDebugLoc();
-    };
-
         SmallVector<MachineInstr *, 4> ToBeRemoved;
-    std::unordered_set<MachineInstr *, decltype(Hash), decltype(IsEqual)>
-        DanglingProbes(0, Hash, IsEqual);
-
-    for (MachineBasicBlock &MBB : MF) {
         for (MachineInstr &MI : MBB) {
-        if (MI.isPseudoProbe()) {
-          if ((uint32_t)MI.getPseudoProbeAttribute() &
-              (uint32_t)PseudoProbeAttributes::Dangling)
-            if (!DanglingProbes.insert(&MI).second)
-              ToBeRemoved.push_back(&MI);
+          if (MI.isPseudoProbe())
         }
-      }
-    }
 
         for (auto *MI : ToBeRemoved)
           MI->eraseFromParent();
 
         Changed |= !ToBeRemoved.empty();
+      }
+    }
+
     return Changed;
   }
 
 private:
   uint64_t getFuncGUID(Module *M, DILocation *DL) {
     auto *SP = DL->getScope()->getSubprogram();
     auto Name = SP->getLinkageName();
     if (Name.empty())

llvm/lib/CodeGen/TailDuplicator.cpp

for (MachineBasicBlock *PredBB : Preds) {
 
     if (!PredBB->isSuccessor(NewTarget))
       PredBB->replaceSuccessor(TailBB, NewTarget);
     else {
       PredBB->removeSuccessor(TailBB, true);
       assert(PredBB->succ_size() <= 1);
     }
 
-    // For AutoFDO, since BB is going to be removed, we won't be able to sample
-    // it. To avoid assigning a zero weight for BB, move all its pseudo probes
-    // into Succ and mark them dangling. This should allow the counts inference
-    // a chance to get a more reasonable weight for BB.
-    TailBB->moveAndDanglePseudoProbes(PredBB);
-
     if (PredTBB)
       TII->insertBranch(*PredBB, PredTBB, PredFBB, PredCond, DL);
 
     TDBBs.push_back(PredBB);
   }
   return Changed;
 }
 

llvm/lib/IR/PseudoProbe.cpp

 void addPseudoProbeAttribute(PseudoProbeInst &Inst,
                              PseudoProbeAttributes Attr) {
   IRBuilder<> Builder(&Inst);
   uint32_t OldAttr = Inst.getAttributes()->getZExtValue();
   uint32_t NewAttr = OldAttr | (uint32_t)Attr;
   if (OldAttr != NewAttr)
     Inst.replaceUsesOfWith(Inst.getAttributes(), Builder.getInt32(NewAttr));
 }
-
-/// A block emptied (i.e., with all instructions moved out of it) won't be
-/// sampled at run time. In such cases, AutoFDO will be informed of zero samples
-/// collected for the block. This is not accurate and could lead to misleading
-/// weights assigned for the block. A way to mitigate that is to treat such
-/// block as having unknown counts in the AutoFDO profile loader and allow the
-/// counts inference tool a chance to calculate a relatively reasonable weight
-/// for it. This can be done by moving all pseudo probes in the emptied block
-/// i.e, /c From, to before /c To and tag them dangling. Note that this is
-/// not needed for dead blocks which really have a zero weight. It's per
-/// transforms to decide whether to call this function or not.
-bool moveAndDanglePseudoProbes(BasicBlock *From, Instruction *To) {
-  SmallVector<PseudoProbeInst *, 4> ToBeMoved;
-  for (auto &I : *From) {
-    if (auto *II = dyn_cast<PseudoProbeInst>(&I)) {
-      addPseudoProbeAttribute(*II, PseudoProbeAttributes::Dangling);
-      ToBeMoved.push_back(II);
-    }
-  }
-
-  for (auto *I : ToBeMoved)
-    I->moveBefore(To);
-
-  return !ToBeMoved.empty();
-}
-
-/// Same dangling probes in one blocks are redundant since they all have the
-/// same semantic that is to rely on the counts inference too to get reasonable
-/// count for the same original block. Therefore, there's no need to keep
-/// multiple copies of them.
-bool removeRedundantPseudoProbes(BasicBlock *Block) {
-
-  auto Hash = [](const PseudoProbeInst *I) {
-    return std::hash<uint64_t>()(I->getFuncGuid()->getZExtValue()) ^
-           std::hash<uint64_t>()(I->getIndex()->getZExtValue());
-  };
-
-  auto IsEqual = [](const PseudoProbeInst *Left, const PseudoProbeInst *Right) {
-    return Left->getFuncGuid() == Right->getFuncGuid() &&
-           Left->getIndex() == Right->getIndex() &&
-           Left->getAttributes() == Right->getAttributes() &&
-           Left->getDebugLoc() == Right->getDebugLoc();
-  };
-
-  SmallVector<PseudoProbeInst *, 4> ToBeRemoved;
-  std::unordered_set<PseudoProbeInst *, decltype(Hash), decltype(IsEqual)>
-      DanglingProbes(0, Hash, IsEqual);
-
-  for (auto &I : *Block) {
-    if (auto *II = dyn_cast<PseudoProbeInst>(&I)) {
-      if (II->getAttributes()->getZExtValue() &
-          (uint32_t)PseudoProbeAttributes::Dangling)
-        if (!DanglingProbes.insert(II).second)
-          ToBeRemoved.push_back(II);
-    }
-  }
-
-  for (auto *I : ToBeRemoved)
-    I->eraseFromParent();
-  return !ToBeRemoved.empty();
-}
 } // namespace llvm

llvm/lib/Transforms/IPO/SampleProfile.cpp

ErrorOr<uint64_t> SampleProfileLoader::getProbeWeight(const Instruction &Inst) {
   assert(FunctionSamples::ProfileIsProbeBased &&
          "Profile is not pseudo probe based");
   Optional<PseudoProbe> Probe = extractProbe(Inst);
   // Ignore the non-probe instruction. If none of the instruction in the BB is
   // probe, we choose to infer the BB's weight.
   if (!Probe)
     return std::error_code();
 
-  // This is not the dangling probe from the training pass but generated by the
-  // current compilation. Ignore this since they are logically deleted and
-  // should not consume any profile samples.
-  if (Probe->isDangling())
-    return std::error_code();
-
   const FunctionSamples *FS = findFunctionSamples(Inst);
   // If none of the instruction has FunctionSample, we choose to return zero
   // value sample to indicate the BB is cold. This could happen when the
   // instruction is from inlinee and no profile data is found.
   // FIXME: This should not be affected by the source drift issue as 1) if the
   // newly added function is top-level inliner, it won't match the CFG checksum
   // in the function profile or 2) if it's the inlinee, the inlinee should have
   // a profile, otherwise it wouldn't be inlined. For non-probe based profile,

llvm/lib/Transforms/IPO/SampleProfileProbe.cpp

return BFI.getBlockProfileCount(BB)
                : 0;
   };
 
   // Collect the sum of execution weight for each probe.
   ProbeFactorMap ProbeFactors;
   for (auto &Block : F) {
     for (auto &I : Block) {
       if (Optional<PseudoProbe> Probe = extractProbe(I)) {
-        // Do not count dangling probes since they are logically deleted and the
-        // current block that a dangling probe resides in doesn't reflect the
-        // execution count of the probe. The original samples of the probe will
-        // be distributed among the rest probes if there are any, this is
-        // less-than-deal but at least we don't lose any samples.
-        if (!Probe->isDangling()) {
-          uint64_t Hash = computeCallStackHash(I);
-          ProbeFactors[{Probe->Id, Hash}] += BBProfileCount(&Block);
-        }
-      }
-    }
-  }
 
   // Fix up over-counted probes.
   for (auto &Block : F) {
     for (auto &I : Block) {
       if (Optional<PseudoProbe> Probe = extractProbe(I)) {
-        // Ignore danling probes since they are logically deleted and should do
-        // not consume any profile samples in the subsequent profile annotation.
-        if (!Probe->isDangling()) {
-          uint64_t Hash = computeCallStackHash(I);
-          float Sum = ProbeFactors[{Probe->Id, Hash}];
-          if (Sum != 0)
-            setProbeDistributionFactor(I, BBProfileCount(&Block) / Sum);
-        }
-      }
-    }
-  }
-}
 
 PreservedAnalyses PseudoProbeUpdatePass::run(Module &M,
                                              ModuleAnalysisManager &AM) {
   if (UpdatePseudoProbe) {
     for (auto &F : M) {
       if (F.isDeclaration())
         continue;
       FunctionAnalysisManager &FAM =
           AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
       runOnFunction(F, FAM);
     }
   }
   return PreservedAnalyses::none();
 }

llvm/lib/Transforms/Scalar/JumpThreading.cpp

do {
     for (auto &BB : F) {
       if (Unreachable.count(&BB))
         continue;
       while (processBlock(&BB)) // Thread all of the branches we can over BB.
         Changed = true;
 
       // Jump threading may have introduced redundant debug values into BB
       // which should be removed.
-      // Remove redundant pseudo probes as well.
       if (Changed)
-        RemoveRedundantDbgInstrs(&BB, true);
+        RemoveRedundantDbgInstrs(&BB);
 
       // Stop processing BB if it's the entry or is now deleted. The following
       // routines attempt to eliminate BB and locating a suitable replacement
       // for the entry is non-trivial.
       if (&BB == &F.getEntryBlock() || DTU->isBBPendingDeletion(&BB))
         continue;
 
       if (pred_empty(&BB)) {
for (auto &BB : F) {
         BasicBlock *Succ = BI->getSuccessor(0);
         if (
             // The terminator must be the only non-phi instruction in BB.
             BB.getFirstNonPHIOrDbg(true)->isTerminator() &&
             // Don't alter Loop headers and latches to ensure another pass can
             // detect and transform nested loops later.
             !LoopHeaders.count(&BB) && !LoopHeaders.count(Succ) &&
             TryToSimplifyUncondBranchFromEmptyBlock(&BB, DTU)) {
-          RemoveRedundantDbgInstrs(Succ, true);
+          RemoveRedundantDbgInstrs(Succ);
           // BB is valid for cleanup here because we passed in DTU. F remains
           // BB's parent until a DTU->getDomTree() event.
           LVI->eraseBlock(&BB);
           Changed = true;
         }
       }
     }
     EverChanged |= Changed;

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

static bool removeRedundantDbgInstrsUsingForwardScan(BasicBlock *BB) {
   }
 
   for (auto &Instr : ToBeRemoved)
     Instr->eraseFromParent();
 
   return !ToBeRemoved.empty();
 }
 
-bool llvm::RemoveRedundantDbgInstrs(BasicBlock *BB, bool RemovePseudoOp) {
+bool llvm::RemoveRedundantDbgInstrs(BasicBlock *BB) {
   bool MadeChanges = false;
   // By using the "backward scan" strategy before the "forward scan" strategy we
   // can remove both dbg.value (2) and (3) in a situation like this:
   //
   //   (1) dbg.value V1, "x", DIExpression()
   //       ...
   //   (2) dbg.value V2, "x", DIExpression()
   //   (3) dbg.value V1, "x", DIExpression()
   //
   // The backward scan will remove (2), it is made obsolete by (3). After
   // getting (2) out of the way, the foward scan will remove (3) since "x"
   // already is described as having the value V1 at (1).
   MadeChanges |= removeRedundantDbgInstrsUsingBackwardScan(BB);
   MadeChanges |= removeRedundantDbgInstrsUsingForwardScan(BB);
-  if (RemovePseudoOp)
-    MadeChanges |= removeRedundantPseudoProbes(BB);
 
   if (MadeChanges)
     LLVM_DEBUG(dbgs() << "Removed redundant dbg instrs from: "
                       << BB->getName() << "\n");
   return MadeChanges;
 }
 
 void llvm::ReplaceInstWithValue(BasicBlock::InstListType &BIL,

llvm/lib/Transforms/Utils/Local.cpp

bool llvm::TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB,
   // add the metadata to the branch instructions in the predecessors.
   unsigned LoopMDKind = BB->getContext().getMDKindID("llvm.loop");
   Instruction *TI = BB->getTerminator();
   if (TI)
     if (MDNode *LoopMD = TI->getMetadata(LoopMDKind))
       for (BasicBlock *Pred : predecessors(BB))
         Pred->getTerminator()->setMetadata(LoopMDKind, LoopMD);
 
-  // For AutoFDO, since BB is going to be removed, we won't be able to sample
-  // it. To avoid assigning a zero weight for BB, move all its pseudo probes
-  // into Succ and mark them dangling. This should allow the counts inference a
-  // chance to get a more reasonable weight for BB.
-  moveAndDanglePseudoProbes(BB, &*Succ->getFirstInsertionPt());
-
   // Everything that jumped to BB now goes to Succ.
   BB->replaceAllUsesWith(Succ);
   if (!Succ->hasName()) Succ->takeName(BB);
 
   // Clear the successor list of BB to match updates applying to DTU later.
   if (BB->getTerminator())
     BB->getInstList().pop_back();
   new UnreachableInst(BB->getContext(), BB);
void llvm::hoistAllInstructionsInto(BasicBlock *DomBlock, Instruction *InsertPt,
   // can only insert a dbg.value after the two branches are joined again.
   //
   // See PR38762, PR39243 for more details.
   //
   // TODO: Extend llvm.dbg.value to take more than one SSA Value (PR39141) to
   // encode predicated DIExpressions that yield different results on different
   // code paths.
 
-  // A hoisted conditional probe should be treated as dangling so that it will
-  // not be over-counted when the samples collected on the non-conditional path
-  // are counted towards the conditional path. We leave it for the counts
-  // inference algorithm to figure out a proper count for a danglng probe.
-  moveAndDanglePseudoProbes(BB, InsertPt);
-
   for (BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE;) {
     Instruction *I = &*II;
     I->dropUnknownNonDebugMetadata();
     if (I->isUsedByMetadata())
       dropDebugUsers(*I);
-    if (isa<DbgInfoIntrinsic>(I)) {
-      // Remove DbgInfo Intrinsics.
+    if (I->isDebugOrPseudoInst()) {
+      // Remove DbgInfo and pseudo probe Intrinsics.
       II = I->eraseFromParent();
       continue;
     }
     I->setDebugLoc(InsertPt->getDebugLoc());
     ++II;
   }
   DomBlock->getInstList().splice(InsertPt->getIterator(), BB->getInstList(),
                                  BB->begin(),

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

if (DTU) {
     if (InfLoopBlock)
       Updates.push_back({DominatorTree::Insert, Pred, InfLoopBlock});
 
     Updates.push_back({DominatorTree::Delete, Pred, BB});
 
     DTU->applyUpdates(Updates);
   }
 
-  // Here the BB is not a dead block but folded into its predecessors, so move
-  // the probe and mark it as dangling.
-  moveAndDanglePseudoProbes(BB, NewSI);
-
   ++NumFoldValueComparisonIntoPredecessors;
   return true;
 }
 
 /// The specified terminator is a value equality comparison instruction
 /// (either a switch or a branch on "X == c").
 /// See if any of the predecessors of the terminator block are value comparisons
 /// on the same value.  If so, and if safe to do so, fold them together.
if (isa<DbgInfoIntrinsic>(I)) {
       SpeculatedDbgIntrinsics.push_back(I);
       continue;
     }
 
     // Skip pseudo probes. The consequence is we lose track of the branch
     // probability for ThenBB, which is fine since the optimization here takes
     // place regardless of the branch probability.
     if (isa<PseudoProbeInst>(I)) {
+      // The probe should be deleted so that it will not be over-counted when
+      // the samples collected on the non-conditional path are counted towards
+      // the conditional path. We leave it for the counts inference algorithm to
+      // figure out a proper count for an unknown probe.
+      SpeculatedDbgIntrinsics.push_back(I);
       continue;
     }
 
     // Only speculatively execute a single instruction (not counting the
     // terminator) for now.
     ++SpeculatedInstructions;
     if (SpeculatedInstructions > 1)
       return false;
if (Invert)
       std::swap(TrueV, FalseV);
     Value *S = Builder.CreateSelect(
         BrCond, TrueV, FalseV, "spec.store.select", BI);
     SpeculatedStore->setOperand(0, S);
     SpeculatedStore->applyMergedLocation(BI->getDebugLoc(),
                                          SpeculatedStore->getDebugLoc());
   }
 
-  // A hoisted conditional probe should be treated as dangling so that it will
-  // not be over-counted when the samples collected on the non-conditional path
-  // are counted towards the conditional path. We leave it for the counts
-  // inference algorithm to figure out a proper count for a danglng probe.
-  moveAndDanglePseudoProbes(ThenBB, BI);
-
   // Metadata can be dependent on the condition we are hoisting above.
   // Conservatively strip all metadata on the instruction. Drop the debug loc
   // to avoid making it appear as if the condition is a constant, which would
   // be misleading while debugging.
   for (auto &I : *ThenBB) {
-    assert(!isa<PseudoProbeInst>(I) &&
-           "Should not drop debug info from any pseudo probes.");
     if (!SpeculatedStoreValue || &I != SpeculatedStore)
       I.setDebugLoc(DebugLoc());
     I.dropUnknownNonDebugMetadata();
   }
 
   // Hoist the instructions.
   BB->getInstList().splice(BI->getIterator(), ThenBB->getInstList(),
                            ThenBB->begin(), std::prev(ThenBB->end()));

llvm/test/Transforms/SampleProfile/pseudo-probe-dangle.ll

 ; ASM: pseudoprobe  6699318081062747564 1 0 0
   %call = call i32 @f1()
   br i1 %cond, label %T, label %F
 T:
   br label %Merge
 F:
   br label %Merge
 Merge:
-;; Check branch T and F are gone, and their probes (probe 2 and 3) are dangling.
+;; Check branch T and F are gone, and their probes (probe 2 and 3) are gone too.
 ; JT-LABEL-NO: T
 ; JT-LABEL-NO: F
 ; JT-LABEL: Merge
-; JT: call void @llvm.pseudoprobe(i64 [[#GUID:]], i64 3, i32 2, i64 -1)
-; JT: call void @llvm.pseudoprobe(i64 [[#GUID:]], i64 2, i32 2, i64 -1)
+; JT-NOT: call void @llvm.pseudoprobe(i64 [[#GUID:]], i64 3
+; JT-NOT: call void @llvm.pseudoprobe(i64 [[#GUID:]], i64 2
 ; JT: call void @llvm.pseudoprobe(i64 [[#GUID:]], i64 4, i32 0, i64 -1)
-; ASM: .pseudoprobe 6699318081062747564 3 0 2
-; ASM: .pseudoprobe 6699318081062747564 2 0 2
+; ASM-NOT: .pseudoprobe 6699318081062747564 3
+; ASM-NOT: .pseudoprobe 6699318081062747564 2
 ; ASM: .pseudoprobe 6699318081062747564 4 0 0
   ret i32 %call
 }
 
-;; Check block T and F are gone, and their probes (probe 2 and 3) are dangling.
+;; Check block T and F are gone, and their probes (probe 2 and 3) are gone too.
 ; MIR-tail: bb.0
 ; MIR-tail: PSEUDO_PROBE [[#GUID:]], 1, 0, 0
-; MIR-tail: PSEUDO_PROBE [[#GUID:]], 2, 0, 2
-; MIR-tail: PSEUDO_PROBE [[#GUID:]], 3, 0, 2
+; MIR-tail-NOT: PSEUDO_PROBE [[#GUID:]], 2
+; MIR-tail-NOT: PSEUDO_PROBE [[#GUID:]], 3
 ; MIR-tail: PSEUDO_PROBE [[#GUID:]], 4, 0, 0
 
 
-define void @foo2() {
-bb:
-  %tmp = call i32 @f1()
-  %tmp1 = icmp eq i32 %tmp, 1
-  br i1 %tmp1, label %bb5, label %bb8
-
-bb2:
-  %tmp4 = icmp ne i32 %tmp, 1
-  switch i1 %tmp4, label %bb2 [
-  i1 0, label %bb5
-  i1 1, label %bb8
-  ]
-
-bb5:
-;; Check the pseudo probe with id 3 only has one copy.
-; JT-COUNT-1: call void @llvm.pseudoprobe(i64 [[#GUID2:]], i64 3, i32 2, i64 -1)
-; JT-NOT: call void @llvm.pseudoprobe(i64 [[#GUID2:]], i64 3, i32 2, i64 -1)
-  %tmp6 = phi i1 [ %tmp1, %bb ], [ false, %bb2 ]
-  br i1 %tmp6, label %bb8, label %bb7
-
-bb7:
-  br label %bb8
-
-bb8:
-  ret void
-}
-
 define i32 @test(i32 %a, i32 %b, i32 %c) {
-;; Check block bb1 and bb2 are gone, and their probes (probe 2 and 3) are dangling.
+;; Check block bb1 and bb2 are gone, and their probes (probe 2 and 3) are gone too.
 ; SC-LABEL: @test(
 ; SC-LABEL-NO: bb1
 ; SC-LABEL-NO: bb2
 ; SC:    [[T1:%.*]] = icmp eq i32 [[B:%.*]], 0
-; SC-DAG:    call void @llvm.pseudoprobe(i64 [[#GUID3:]], i64 2, i32 2, i64 -1)
-; SC-DAG:    call void @llvm.pseudoprobe(i64 [[#GUID3]], i64 3, i32 2, i64 -1)
+; SC-NOT:    call void @llvm.pseudoprobe(i64 [[#]], i64 2
+; SC-NOT:    call void @llvm.pseudoprobe(i64 [[#]], i64 3
 ; SC:    [[T2:%.*]] = icmp sgt i32 [[C:%.*]], 1
 ; SC:    [[T3:%.*]] = add i32 [[A:%.*]], 1
 ; SC:    [[SPEC_SELECT:%.*]] = select i1 [[T2]], i32 [[T3]], i32 [[A]]
 ; SC:    [[T4:%.*]] = select i1 [[T1]], i32 [[SPEC_SELECT]], i32 [[B]]
 ; SC:    [[T5:%.*]] = sub i32 [[T4]], 1
 ; SC:    ret i32 [[T5]]
 
 entry:

llvm/test/Transforms/SampleProfile/pseudo-probe-dangle2.ll

 ; REQUIRES: x86_64-linux
 ; RUN: opt < %s -simplifycfg -S -o %t
 ; RUN: FileCheck %s < %t
 
-; Test to make sure the dangling probe's metadata not being dropped.
+; Test to make sure the dangling probe is gone.
 ; CHECK: define dso_local i32 @foo
-; CHECK: call void @llvm.pseudoprobe(i64 -4224472938262609671, i64 5, i32 2, i64 -1), !dbg ![[#]]
+; CHECK-NOT: call void @llvm.pseudoprobe(i64 -4224472938262609671, i64 5
 
 ; Function Attrs: nounwind uwtable
 define dso_local i32 @foo(i32* nocapture %marker, i32* nocapture %move_ordering, i32* nocapture %moves, i32 %num_moves) local_unnamed_addr #0 !dbg !10 {
 entry:
   call void @llvm.dbg.value(metadata i32* %marker, metadata !19, metadata !DIExpression()), !dbg !28
   call void @llvm.dbg.value(metadata i32* %move_ordering, metadata !20, metadata !DIExpression()), !dbg !28
   call void @llvm.dbg.value(metadata i32* %moves, metadata !21, metadata !DIExpression()), !dbg !28
   call void @llvm.dbg.value(metadata i32 %num_moves, metadata !22, metadata !DIExpression()), !dbg !28

llvm/test/Transforms/SampleProfile/pseudo-probe-dangle3.ll

-; Test after FoldValueComparisonIntoPredecessors, one dangling probe is generated
+; Test after FoldValueComparisonIntoPredecessors, one dangling probe is gone
 ; RUN: opt -S -passes='pseudo-probe,simplifycfg' < %s | FileCheck %s
 
 
 ; CHECK: if.end80:                                         ; preds = %if.end
 ; CHECK-NEXT:   call void @llvm.pseudoprobe(i64 -2281696412744416103, i64 3, i32 0, i64 -1)
-; CHECK-NEXT:   call void @llvm.pseudoprobe(i64 -2281696412744416103, i64 4, i32 2, i64 -1)
+; CHECK-NOT:   call void @llvm.pseudoprobe(i64 -2281696412744416103, i64 4
 
 define dso_local i32 @readCBPandCoeffsFromNAL(i1 %c, i32 %x, i32 %y) local_unnamed_addr {
 ;
 if.end:
   br i1 %c, label %if.end80, label %if.then64
 
 if.then64:                                        ; preds = %if.end
   ret i32 %y

llvm/test/Transforms/SampleProfile/pseudo-probe-dangling.mir

-
-# REQUIRES: x86-registered-target
-# Ensure llc can read and parse MIR pseudo probe operations.
-# RUN: llc -mtriple x86_64-- -run-pass=pseudo-probe-inserter %s -o - | FileCheck %s
-
-# CHECK: PSEUDO_PROBE 6699318081062747564, 1, 0, 0
-# check probe 2 is moved before the test instruction.
-# CHECK: PSEUDO_PROBE 6699318081062747564, 2, 0, 0
-# CHECK: TEST32rr
-# check probe 3 is dangling.
-# CHECK: PSEUDO_PROBE 6699318081062747564, 3, 0, 2
-
-name:            foo
-body:             |
-  bb.0:
-    TEST32rr killed renamable $edi, renamable $edi, implicit-def $eflags
-    PSEUDO_PROBE 6699318081062747564, 1, 0, 0
-    JCC_1 %bb.1, 4, implicit $eflags
-  
-  bb.2:
-    TEST32rr killed renamable $edi, renamable $edi, implicit-def $eflags
-    PSEUDO_PROBE 6699318081062747564, 2, 0, 0
-  
-  bb.1:
-    PSEUDO_PROBE 6699318081062747564, 3, 0, 0
-
-...

llvm/test/Transforms/SampleProfile/pseudo-probe-dedup.ll

-; REQUIRES: x86_64-linux
-; RUN: llc -pseudo-probe-for-profiling %s -filetype=asm -o - | FileCheck %s
-
-declare i32 @f1()
-declare void @llvm.pseudoprobe(i64, i64, i32, i64) #0
-
-define void @foo2() {
-bb:
-; CHECK: .pseudoprobe 2494702099028631698 1 0 0
-  call void @llvm.pseudoprobe(i64 2494702099028631698, i64 1, i32 0, i64 -1)
-  %tmp = call i32 @f1()
-  %tmp1 = icmp eq i32 %tmp, 1
-  br i1 %tmp1, label %bb5, label %bb8
-
-bb2:
-;; Check the pseudo probe with id 2 only has one copy.
-; CHECK-COUNT-1: .pseudoprobe 2494702099028631698 2 0 2
-; CHECK-NOT: .pseudoprobe 2494702099028631698 2 0 2
-  call void @llvm.pseudoprobe(i64 2494702099028631698, i64 2, i32 2, i64 -1)
-  %tmp4 = icmp ne i32 %tmp, 1
-  call void @llvm.pseudoprobe(i64 2494702099028631698, i64 2, i32 2, i64 -1)
-  switch i1 %tmp4, label %bb2 [
-  i1 0, label %bb5
-  i1 1, label %bb8
-  ]
-
-bb5:
-  %tmp6 = phi i1 [ %tmp1, %bb ], [ false, %bb2 ]
-  call void @llvm.pseudoprobe(i64 2494702099028631698, i64 2, i32 2, i64 -1)
-  br i1 %tmp6, label %bb8, label %bb7
-
-bb7:
-  br label %bb8
-
-bb8:
-  ret void
-}
-
-!llvm.pseudo_probe_desc = !{!0}
-
-!0 = !{i64 2494702099028631698, i64 281612674956943, !"foo2", null}
 

llvm/test/tools/llvm-profgen/Inputs/inline-cs-dangling-pseudoprobe.perfscript

-PERF_RECORD_MMAP2 595196/595196: [0x201000(0x1000) @ 0 00:1d 224227621 1042948]: r-xp /home/inline-cs-pseudoprobe.perfbin
-
-            20180e
-  5541f689495641d7
- 0x201858/0x20180e/P/-/-/0  0x20182b/0x20184d/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0  0x20182b/0x201800/P/-/-/0

llvm/test/tools/llvm-profgen/Inputs/truncated-pseudoprobe.ll

 
 if.then:                                          ; preds = %while.body
   call void @llvm.pseudoprobe(i64 6699318081062747564, i64 4, i32 0, i64 -1), !dbg !40
   call void @llvm.dbg.value(metadata i32 %inc8, metadata !15, metadata !DIExpression()) #6, !dbg !41
   call void @llvm.dbg.value(metadata i32 %s.07, metadata !16, metadata !DIExpression()) #6, !dbg !41
   call void @llvm.pseudoprobe(i64 -2012135647395072713, i64 1, i32 0, i64 -1) #6, !dbg !44
   %rem.i = urem i32 %inc8, 3, !dbg !45
   %tobool.not.i = icmp eq i32 %rem.i, 0, !dbg !45
-  call void @llvm.pseudoprobe(i64 -2012135647395072713, i64 2, i32 2, i64 -1) #6, !dbg !46
-  call void @llvm.pseudoprobe(i64 -2012135647395072713, i64 3, i32 2, i64 -1) #6, !dbg !47
   %0 = sub i32 0, %s.07, !dbg !48
   %retval.0.p.i = select i1 %tobool.not.i, i32 %s.07, i32 %0, !dbg !48
   %retval.0.i = add i32 %retval.0.p.i, %inc8, !dbg !48
   call void @llvm.pseudoprobe(i64 -2012135647395072713, i64 4, i32 0, i64 -1) #6, !dbg !49
   call void @llvm.dbg.value(metadata i32 %retval.0.i, metadata !30, metadata !DIExpression()), !dbg !33
   br label %if.end, !dbg !50
 
 if.else:                                          ; preds = %while.body

llvm/test/tools/llvm-profgen/Inputs/truncated-pseudoprobe.perfscript

 PERF_RECORD_MMAP2 1664112/1664112: [0x400000(0x1000) @ 0 08:11 806256818 82060973]: r-xp truncated-pseudoprobe.perfbin
-            40057d
-            4005b9
+            40060d
+            400659
       7f67469af555
- 0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0  0x40059f/0x400553/P/-/-/0 
+ 0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0  0x40062f/0x4005e3/P/-/-/0 

llvm/test/tools/llvm-profgen/fname-canonicalization.test

 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/unique-linkage-name-probe.perfscript --binary=%S/Inputs/unique-linkage-name-probe.perfbin --output=%t --profile-summary-cold-count=0
 ; RUN: FileCheck %s --input-file %t --check-prefix=CHECK-PROBE-FNAME
 
 ; CHECK-PROBE-FNAME:[main:2 @ foo]:75:0
 ; CHECK-PROBE-FNAME: 2: 15
 ; CHECK-PROBE-FNAME: 3: 15
 ; CHECK-PROBE-FNAME: 4: 15
 ; CHECK-PROBE-FNAME: 6: 15
-; CHECK-PROBE-FNAME: 8: 15 _ZL3barii.__uniq.26267048767521081047744692097241227776:15
+; CHECK-PROBE-FNAME: 8: 15 _ZL3barii.__uniq.276699478366846449772231447066107882794:15
 ; CHECK-PROBE-FNAME: !CFGChecksum: 563088904013236
-; CHECK-PROBE-FNAME:[main:2 @ foo:8 @ _ZL3barii.__uniq.26267048767521081047744692097241227776]:30:15
+; CHECK-PROBE-FNAME:[main:2 @ foo:8 @ _ZL3barii.__uniq.276699478366846449772231447066107882794]:30:15
 ; CHECK-PROBE-FNAME: 1: 15
 ; CHECK-PROBE-FNAME: 4: 15
 ; CHECK-PROBE-FNAME: !CFGChecksum: 72617220756
 
 
 ; Original code:
 ; Dwarf:  clang -O3 -funique-internal-linkage-names -g test.c -o a.out
 ; Probe:  clang -O3 -funique-internal-linkage-names  -fexperimental-new-pass-manager -fuse-ld=lld -fpseudo-probe-for-profiling -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -Xclang -mdisable-tail-calls  -g test.c  -o a.out

llvm/test/tools/llvm-profgen/inline-cs-dangling-pseudoprobe.test

-; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-cs-dangling-pseudoprobe.perfscript --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --output=%t --show-unwinder-output --profile-summary-cold-count=0 | FileCheck %s --check-prefix=CHECK-UNWINDER
-; RUN: FileCheck %s --input-file %t
-
-; CHECK:     [main:2 @ foo]:58:0
-; CHECK-NEXT: 1: 0
-; CHECK-NEXT: 2: 15
-; CHECK-NEXT: 3: 14
-; CHECK-NEXT: 4: 0
-; CHECK-NEXT: 5: 14
-; CHECK-NEXT: 6: 15
-; CHECK-NEXT: 7: 0
-; CHECK-NEXT: 9: 0
-; CHECK-NEXT: !CFGChecksum: 138950591924
-; CHECK:[main:2 @ foo:8 @ bar]:1:0
-; CHECK-NEXT: 1: 0
-; CHECK-NEXT: 4: 1
-; CHECK-NEXT: !CFGChecksum: 72617220756
-
-
-; CHECK-UNWINDER:      Binary(inline-cs-pseudoprobe.perfbin)'s Range Counter:
-; CHECK-UNWINDER-EMPTY:
-; CHECK-UNWINDER-NEXT:   (800, 82b): 14
-; CHECK-UNWINDER-NEXT:   (84d, 858): 1
-
-; CHECK-UNWINDER:      Binary(inline-cs-pseudoprobe.perfbin)'s Branch Counter:
-; CHECK-UNWINDER-EMPTY:
-; CHECK-UNWINDER-NEXT:   (82b, 800): 14
-; CHECK-UNWINDER-NEXT:   (82b, 84d): 1
-; CHECK-UNWINDER-NEXT:   (858, 80e): 1
-
-; clang -O3 -fexperimental-new-pass-manager -fuse-ld=lld -fpseudo-probe-for-profiling
-; -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -Xclang -mdisable-tail-calls
-; -g test.c  -o a.out
-
-#include <stdio.h>
-
-int bar(int x, int y) {
-  if (x % 3) {
-    return x - y;
-  }
-  return x + y;
-}
-
-void foo() {
-  int s, i = 0;
-  while (i++ < 4000 * 4000)
-    if (i % 91) s = bar(i, s); else s += 30;
-  printf("sum is %d\n", s);
-}
-
-int main() {
-  foo();
-  return 0;
-}

llvm/test/tools/llvm-profgen/inline-cs-pseudoprobe.test

 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/inline-cs-pseudoprobe.perfscript --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --output=%t --show-unwinder-output --profile-summary-cold-count=0 | FileCheck %s --check-prefix=CHECK-UNWINDER
 ; RUN: FileCheck %s --input-file %t
 
 ; CHECK:     [main:2 @ foo]:74:0
 ; CHECK-NEXT: 1: 0
 ; CHECK-NEXT: 2: 15
 ; CHECK-NEXT: 3: 15
 ; CHECK-NEXT: 4: 14
 ; CHECK-NEXT: 5: 1
 ; CHECK-NEXT: 6: 15
 ; CHECK-NEXT: 7: 0
 ; CHECK-NEXT: 8: 14 bar:14
 ; CHECK-NEXT: 9: 0
-; CHECK-NEXT: !CFGChecksum: 138950591924
+; CHECK-NEXT: !CFGChecksum: 563088904013236
 ; CHECK:[main:2 @ foo:8 @ bar]:28:14
 ; CHECK-NEXT: 1: 14
 ; CHECK-NEXT: 4: 14
 ; CHECK-NEXT: !CFGChecksum: 72617220756
 
 
 ; CHECK-UNWINDER:      Binary(inline-cs-pseudoprobe.perfbin)'s Range Counter:
 ; CHECK-UNWINDER-EMPTY:

llvm/test/tools/llvm-profgen/merge-cold-profile.test

 ; CHECK:     [fa]:14:4
 ; CHECK-NEXT: 1: 4
 ; CHECK-NEXT: 3: 4
 ; CHECK-NEXT: 4: 2
 ; CHECK-NEXT: 5: 1
 ; CHECK-NEXT: 6: 0
 ; CHECK-NEXT: 7: 2 fb:2
 ; CHECK-NEXT: 8: 1 fa:1
-; CHECK-NEXT: !CFGChecksum: 120515930909
+; CHECK-NEXT: !CFGChecksum: 563070469352221
 ; CHECK-NEXT: !Attributes: 0
 ; CHECK-NEXT:[main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb]:13:4
 ; CHECK-NEXT: 1: 4
 ; CHECK-NEXT: 2: 3
 ; CHECK-NEXT: 3: 1
 ; CHECK-NEXT: 4: 0
 ; CHECK-NEXT: 5: 4 fb:4
 ; CHECK-NEXT: 6: 1 fa:1
-; CHECK-NEXT: !CFGChecksum: 72617220756
+; CHECK-NEXT: !CFGChecksum: 563022570642068
 
 ; CHECK-KEEP-COLD:     [fb]:19:6
 ; CHECK-KEEP-COLD-NEXT: 1: 6
 ; CHECK-KEEP-COLD-NEXT: 2: 3
 ; CHECK-KEEP-COLD-NEXT: 3: 3
 ; CHECK-KEEP-COLD-NEXT: 4: 0
 ; CHECK-KEEP-COLD-NEXT: 5: 4 fb:4
 ; CHECK-KEEP-COLD-NEXT: 6: 3 fa:3
-; CHECK-KEEP-COLD-NEXT: !CFGChecksum: 72617220756
+; CHECK-KEEP-COLD-NEXT: !CFGChecksum: 563022570642068
 ; CHECK-KEEP-COLD-NEXT: !Attributes: 0
 ; CHECK-KEEP-COLD-NEXT:[fa]:14:4
 ; CHECK-KEEP-COLD-NEXT: 1: 4
 ; CHECK-KEEP-COLD-NEXT: 3: 4
 ; CHECK-KEEP-COLD-NEXT: 4: 2
 ; CHECK-KEEP-COLD-NEXT: 5: 1
 ; CHECK-KEEP-COLD-NEXT: 6: 0
 ; CHECK-KEEP-COLD-NEXT: 7: 2 fb:2
 ; CHECK-KEEP-COLD-NEXT: 8: 1 fa:1
-; CHECK-KEEP-COLD-NEXT: !CFGChecksum: 120515930909
+; CHECK-KEEP-COLD-NEXT: !CFGChecksum: 563070469352221
 
 ; CHECK-UNMERGED:     [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb]:13:4
 ; CHECK-UNMERGED-NEXT: 1: 4
 ; CHECK-UNMERGED-NEXT: 2: 3
 ; CHECK-UNMERGED-NEXT: 3: 1
 ; CHECK-UNMERGED-NEXT: 4: 0
 ; CHECK-UNMERGED-NEXT: 5: 4 fb:4
 ; CHECK-UNMERGED-NEXT: 6: 1 fa:1
-; CHECK-UNMERGED-NEXT: !CFGChecksum: 72617220756
+; CHECK-UNMERGED-NEXT: !CFGChecksum: 563022570642068
 ; CHECK-UNMERGED-NOT: [fa]
 ; CHECK-UNMERGED-NOT: [fb]
 
 ; CHECK-COLD-CONTEXT-LENGTH:     [fb:5 @ fb]:13:4
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 1: 4
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 2: 3
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 3: 1
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 4: 0
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 5: 4 fb:4
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 6: 1 fa:1
-; CHECK-COLD-CONTEXT-LENGTH-NEXT: !CFGChecksum: 72617220756
+; CHECK-COLD-CONTEXT-LENGTH-NEXT: !CFGChecksum: 563022570642068
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: !Attributes: 0
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT:[fb:6 @ fa]:10:3
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 1: 3
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 3: 3
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 4: 1
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 5: 1
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 6: 0
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 7: 1 fb:1
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 8: 1 fa:1
-; CHECK-COLD-CONTEXT-LENGTH-NEXT: !CFGChecksum: 120515930909
+; CHECK-COLD-CONTEXT-LENGTH-NEXT: !CFGChecksum: 563070469352221
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: !Attributes: 0
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT:[fa:7 @ fb]:6:2
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 1: 2
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 2: 0
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 3: 2
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 4: 0
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 5: 0
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 6: 2 fa:2
-; CHECK-COLD-CONTEXT-LENGTH-NEXT: !CFGChecksum: 72617220756
+; CHECK-COLD-CONTEXT-LENGTH-NEXT: !CFGChecksum: 563022570642068
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: !Attributes: 0
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT:[fa:8 @ fa]:4:1
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 1: 1
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 3: 1
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 4: 1
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 5: 0
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 6: 0
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 7: 1 fb:1
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: 8: 0
-; CHECK-COLD-CONTEXT-LENGTH-NEXT: !CFGChecksum: 120515930909
+; CHECK-COLD-CONTEXT-LENGTH-NEXT: !CFGChecksum: 563070469352221
 ; CHECK-COLD-CONTEXT-LENGTH-NEXT: !Attributes: 0
 
 ; clang -O3 -fexperimental-new-pass-manager -fuse-ld=lld -fpseudo-probe-for-profiling
 ; -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -Xclang -mdisable-tail-calls
 ; -g test.c  -o a.out
 
 ; Copied from recursion-compression.test
 #include <stdio.h>

llvm/test/tools/llvm-profgen/noinline-cs-pseudoprobe.test

 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/noinline-cs-pseudoprobe.perfscript --binary=%S/Inputs/noinline-cs-pseudoprobe.perfbin --output=%t --show-unwinder-output --profile-summary-cold-count=0 | FileCheck %s --check-prefix=CHECK-UNWINDER
 ; RUN: FileCheck %s --input-file %t
 
 ; CHECK:     [main:2 @ foo]:75:0
 ; CHECK-NEXT: 1: 0
 ; CHECK-NEXT: 2: 15
 ; CHECK-NEXT: 3: 15
 ; CHECK-NEXT: 4: 15
 ; CHECK-NEXT: 5: 0
 ; CHECK-NEXT: 6: 15
 ; CHECK-NEXT: 7: 0
 ; CHECK-NEXT: 8: 15 bar:15
 ; CHECK-NEXT: 9: 0
-; CHECK-NEXT: !CFGChecksum: 138950591924
+; CHECK-NEXT: !CFGChecksum: 563088904013236
 ; CHECK:[main:2 @ foo:8 @ bar]:30:15
 ; CHECK-NEXT: 1: 15
 ; CHECK-NEXT: 4: 15
 ; CHECK-NEXT: !CFGChecksum: 72617220756
 
 
 ; CHECK-UNWINDER:      Binary(noinline-cs-pseudoprobe.perfbin)'s Range Counter:
 ; CHECK-UNWINDER-NEXT: main:2

llvm/test/tools/llvm-profgen/pseudoprobe-decoding.test

 ; RUN: llvm-profgen --format=text --perfscript=%s  --binary=%S/Inputs/inline-cs-pseudoprobe.perfbin --output=%t --show-pseudo-probe --show-disassembly-only | FileCheck %s
 
 PERF_RECORD_MMAP2 2854748/2854748: [0x400000(0x1000) @ 0 00:1d 123291722 526021]: r-xp /home/inline-cs-pseudoprobe.perfbin
 
 ; CHECK: Pseudo Probe Desc:
 ; CHECK: GUID: 6699318081062747564 Name: foo
-; CHECK: Hash: 138950591924
+; CHECK: Hash: 563088904013236
 ; CHECK: GUID: 15822663052811949562 Name: main
-; CHECK: Hash: 4294967295
+; CHECK: Hash: 281479271677951
 ; CHECK: GUID: 16434608426314478903 Name: bar
 ; CHECK: Hash: 72617220756
 
 
 
 ; CHECK:      <bar>:
 
 ; CHECK:       [Probe]: FUNC: bar Index: 1  Type: Block
+; CHECK-NEXT:  [Probe]: FUNC: bar Index: 4  Type: Block
 ; CHECK-NEXT:      754: imull $2863311531, %edi, %eax
 
-; CHECK:       [Probe]: FUNC: bar Index: 2  Type: Block  Dangling
-; CHECK-NEXT:  [Probe]: FUNC: bar Index: 3  Type: Block  Dangling
-; CHECK-NEXT:      768: cmovbl  %esi, %ecx
-
-; CHECK:       [Probe]: FUNC: bar Index: 4  Type: Block
-; CHECK-NEXT:      76e: popq  %rbp
-
-
 ; CHECK:      <foo>:
 ; CHECK:       [Probe]: FUNC: foo Index: 1  Type: Block
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block
 ; CHECK-NEXT:      770: movl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 5  Type: Block
 ; CHECK-NEXT:      780: addl  $30, %esi
 ; CHECK:       [Probe]: FUNC: foo Index: 6  Type: Block
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block
 ; CHECK-NEXT:      783: addl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 3  Type: Block
-; CHECK-NEXT:      7a9: cmpl  %eax, %ecx
+; CHECK-NEXT:      78e: movl  %ecx, %edx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 4  Type: Block
 ; CHECK-NEXT:  [Probe]: FUNC: bar Index: 1  Type: Block  Inlined: @ foo:8
+; CHECK-NEXT:  [Probe]: FUNC: bar Index: 4  Type: Block  Inlined: @ foo:8
 ; CHECK-NEXT:      7bf: addl  %ecx, %edx
 
-; CHECK:       [Probe]: FUNC: bar Index: 2  Type: Block  Dangling  Inlined: @ foo:8
-; CHECK-NEXT:  [Probe]: FUNC: bar Index: 3  Type: Block  Dangling  Inlined: @ foo:8
-; CHECK-NEXT:      7c8: cmovel  %esi, %eax
 
-; CHECK:       [Probe]: FUNC: bar Index: 4  Type: Block  Inlined: @ foo:8
-; CHECK-NEXT:      7cd: movl  %eax, %esi
 ; CHECK:       [Probe]: FUNC: foo Index: 6  Type: Block
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block
+; CHECK-NEXT:      7cf: addl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 7  Type: Block
 ; CHECK-NEXT:      7de: movl  $2098432, %edi
 
 ; CHECK:       [Probe]: FUNC: foo Index: 9  Type: DirectCall
 ; CHECK-NEXT:      7e5: callq 0x930
 
 
 ; CHECK:      <main>:
 ; CHECK:       [Probe]: FUNC: main Index: 1  Type: Block
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 1  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:      7f0: movl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 5  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:      800: addl  $30, %esi
 ; CHECK:       [Probe]: FUNC: foo Index: 6  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:      803: addl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 3  Type: Block  Inlined: @ main:2
-; CHECK-NEXT:      829: cmpl  %eax, %ecx
+; CHECK-NEXT:      80e: movl  %ecx, %edx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 4  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:  [Probe]: FUNC: bar Index: 1  Type: Block  Inlined: @ main:2 @ foo:8
+; CHECK-NEXT:  [Probe]: FUNC: bar Index: 4  Type: Block  Inlined: @ main:2 @ foo:8
 ; CHECK-NEXT:      83f: addl  %ecx, %edx
 
-; CHECK:       [Probe]: FUNC: bar Index: 2  Type: Block  Dangling  Inlined: @ main:2 @ foo:8
-; CHECK-NEXT:  [Probe]: FUNC: bar Index: 3  Type: Block  Dangling  Inlined: @ main:2 @ foo:8
-; CHECK-NEXT:      848: cmovel  %esi, %eax
-
-; CHECK:       [Probe]: FUNC: bar Index: 4  Type: Block  Inlined: @ main:2 @ foo:8
-; CHECK-NEXT:      84d: movl  %eax, %esi
 ; CHECK:       [Probe]: FUNC: foo Index: 6  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:  [Probe]: FUNC: foo Index: 2  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:      84f: addl  $1, %ecx
 
 ; CHECK:       [Probe]: FUNC: foo Index: 7  Type: Block  Inlined: @ main:2
 ; CHECK-NEXT:      85e: movl  $2098432, %edi
 
 ; CHECK:       [Probe]: FUNC: foo Index: 9  Type: DirectCall  Inlined: @ main:2

llvm/test/tools/llvm-profgen/recursion-compression-pseudoprobe.test

 ; Firstly test uncompression(--compress-recursion=0)
 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/recursion-compression-pseudoprobe.perfscript --binary=%S/Inputs/recursion-compression-pseudoprobe.perfbin --output=%t --compress-recursion=0 --profile-summary-cold-count=0
 ; RUN: FileCheck %s --input-file %t -check-prefix=CHECK-UNCOMPRESS
 ; RUN: llvm-profgen --format=text --perfscript=%S/Inputs/recursion-compression-pseudoprobe.perfscript --binary=%S/Inputs/recursion-compression-pseudoprobe.perfbin --output=%t --show-unwinder-output --profile-summary-cold-count=0 | FileCheck %s --check-prefix=CHECK-UNWINDER
 ; RUN: FileCheck %s --input-file %t
 
 ; CHECK-UNCOMPRESS: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:6 @ fa:8 @ fa:7 @ fb:6 @ fa]:4:1
 ; CHECK-UNCOMPRESS:  1: 1
 ; CHECK-UNCOMPRESS:  3: 1
 ; CHECK-UNCOMPRESS:  4: 1
 ; CHECK-UNCOMPRESS:  7: 1 fb:1
-; CHECK-UNCOMPRESS:  !CFGChecksum: 120515930909
+; CHECK-UNCOMPRESS:  !CFGChecksum: 563070469352221
 ; CHECK-UNCOMPRESS: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:6 @ fa:8 @ fa]:4:1
 ; CHECK-UNCOMPRESS:  1: 1
 ; CHECK-UNCOMPRESS:  3: 1
 ; CHECK-UNCOMPRESS:  4: 1
 ; CHECK-UNCOMPRESS:  7: 1 fb:1
-; CHECK-UNCOMPRESS:  !CFGChecksum: 120515930909
+; CHECK-UNCOMPRESS:  !CFGChecksum: 563070469352221
 ; CHECK-UNCOMPRESS: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:6 @ fa]:4:1
 ; CHECK-UNCOMPRESS:  1: 1
 ; CHECK-UNCOMPRESS:  3: 1
 ; CHECK-UNCOMPRESS:  5: 1
 ; CHECK-UNCOMPRESS:  8: 1 fa:1
-; CHECK-UNCOMPRESS:  !CFGChecksum: 120515930909
+; CHECK-UNCOMPRESS:  !CFGChecksum: 563070469352221
 ; CHECK-UNCOMPRESS: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:6 @ fa:8 @ fa:7 @ fb:6 @ fa:7 @ fb]:3:1
 ; CHECK-UNCOMPRESS:  1: 1
 ; CHECK-UNCOMPRESS:  3: 1
 ; CHECK-UNCOMPRESS:  6: 1 fa:1
-; CHECK-UNCOMPRESS:  !CFGChecksum: 72617220756
+; CHECK-UNCOMPRESS:  !CFGChecksum: 563022570642068
 ; CHECK-UNCOMPRESS: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:6 @ fa:8 @ fa:7 @ fb]:3:1
 ; CHECK-UNCOMPRESS:  1: 1
 ; CHECK-UNCOMPRESS:  3: 1
 ; CHECK-UNCOMPRESS:  6: 1 fa:1
-; CHECK-UNCOMPRESS:  !CFGChecksum: 72617220756
+; CHECK-UNCOMPRESS:  !CFGChecksum: 563022570642068
 ; CHECK-UNCOMPRESS: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb]:3:1
 ; CHECK-UNCOMPRESS:  1: 1
 ; CHECK-UNCOMPRESS:  3: 1
 ; CHECK-UNCOMPRESS:  6: 1 fa:1
-; CHECK-UNCOMPRESS:  !CFGChecksum: 72617220756
+; CHECK-UNCOMPRESS:  !CFGChecksum: 563022570642068
 ; CHECK-UNCOMPRESS: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb]:3:1
 ; CHECK-UNCOMPRESS:  1: 1
 ; CHECK-UNCOMPRESS:  2: 1
 ; CHECK-UNCOMPRESS:  5: 1 fb:1
-; CHECK-UNCOMPRESS:  !CFGChecksum: 72617220756
+; CHECK-UNCOMPRESS:  !CFGChecksum: 563022570642068
 ; CHECK-UNCOMPRESS: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb]:3:1
 ; CHECK-UNCOMPRESS:  1: 1
 ; CHECK-UNCOMPRESS:  2: 1
 ; CHECK-UNCOMPRESS:  5: 1 fb:1
-; CHECK-UNCOMPRESS:  !CFGChecksum: 72617220756
+; CHECK-UNCOMPRESS:  !CFGChecksum: 563022570642068
 ; CHECK-UNCOMPRESS: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb]:3:1
 ; CHECK-UNCOMPRESS:  1: 1
 ; CHECK-UNCOMPRESS:  2: 1
 ; CHECK-UNCOMPRESS:  5: 1 fb:1
-; CHECK-UNCOMPRESS:  !CFGChecksum: 72617220756
+; CHECK-UNCOMPRESS:  !CFGChecksum: 563022570642068
 ; CHECK-UNCOMPRESS: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb:6 @ fa:8 @ fa:7 @ fb:6 @ fa:7 @ fb:6 @ fa]:2:1
 ; CHECK-UNCOMPRESS:  1: 1
 ; CHECK-UNCOMPRESS:  3: 1
-; CHECK-UNCOMPRESS:  !CFGChecksum: 120515930909
+; CHECK-UNCOMPRESS:  !CFGChecksum: 563070469352221
 ; CHECK-UNCOMPRESS: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:5 @ fb:5 @ fb:5 @ fb]:1:0
 ; CHECK-UNCOMPRESS:  5: 1 fb:1
-; CHECK-UNCOMPRESS:  !CFGChecksum: 72617220756
+; CHECK-UNCOMPRESS:  !CFGChecksum: 563022570642068
 
 
 ; CHECK: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb]:13:4
 ; CHECK:  1: 4
 ; CHECK:  2: 3
 ; CHECK:  3: 1
 ; CEHCK:  5: 4 fb:4
 ; CHECK:  6: 1 fa:1
-; CHECK !CFGChecksum: 72617220756
+; CHECK !CFGChecksum: 563022570642068
 ; CHECK: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:6 @ fa:8 @ fa:7 @ fb:6 @ fa]:6:2
 ; CHECK:  1: 2
 ; CHECK:  3: 2
 ; CHECK:  4: 1
 ; CHECK:  7: 1 fb:1
-; CHECK:  !CFGChecksum: 120515930909
+; CHECK:  !CFGChecksum: 563070469352221
 ; CHECK: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:6 @ fa:8 @ fa]:4:1
 ; CHECK:  1: 1
 ; CHECK:  3: 1
 ; CHECK:  4: 1
 ; CHECK:  7: 1 fb:1
-; CHECK:  !CFGChecksum: 120515930909
+; CHECK:  !CFGChecksum: 563070469352221
 ; CHECK: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:6 @ fa]:4:1
 ; CHECK:  1: 1
 ; CHECK:  3: 1
 ; CHECK:  5: 1
 ; CHECK:  8: 1 fa:1
-; CHECK:  !CFGChecksum: 120515930909
+; CHECK:  !CFGChecksum: 563070469352221
 ; CHECK: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:6 @ fa:8 @ fa:7 @ fb:6 @ fa:7 @ fb]:3:1
 ; CHECK:  1: 1
 ; CHECK:  3: 1
 ; CHECK:  6: 1 fa:1
-; CHECK:  !CFGChecksum: 72617220756
+; CHECK:  !CFGChecksum: 563022570642068
 ; CHECK: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:6 @ fa:8 @ fa:7 @ fb]:3:1
 ; CHECK:  1: 1
 ; CHECK:  3: 1
 ; CHECK:  6: 1 fa:1
-; CHECK:  !CFGChecksum: 72617220756
+; CHECK:  !CFGChecksum: 563022570642068
 
 
 
 
 ; CHECK-UNWINDER: Binary(recursion-compression-pseudoprobe.perfbin)'s Range Counter:
 ; CHECK-UNWINDER: main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5
 ; CHECK-UNWINDER:   (7a0, 7a7): 1
 ; CHECK-UNWINDER:   (7a0, 7ab): 3

llvm/tools/llvm-profgen/ProfileGenerator.cpp

void PseudoProbeCSProfileGenerator::populateBodySamplesWithProbes(
   ProbeCounterMap ProbeCounter;
   // Extract the top frame probes by looking up each address among the range in
   // the Address2ProbeMap
   extractProbesFromRange(RangeCounter, ProbeCounter, Binary);
   std::unordered_map<PseudoProbeInlineTree *, FunctionSamples *> FrameSamples;
   for (auto PI : ProbeCounter) {
     const PseudoProbe *Probe = PI.first;
     uint64_t Count = PI.second;
-    // Ignore dangling probes since they will be reported later if needed.
-    if (Probe->isDangling())
-      continue;
     FunctionSamples &FunctionProfile =
         getFunctionProfileForLeafProbe(ContextStrStack, Probe, Binary);
     // Record the current frame and FunctionProfile whenever samples are
     // collected for non-danglie probes. This is for reporting all of the
-    // dangling probes of the frame later.
+    // zero count probes of the frame later.
     FrameSamples[Probe->getInlineTreeNode()] = &FunctionProfile;
     FunctionProfile.addBodySamplesForProbe(Probe->Index, Count);
     FunctionProfile.addTotalSamples(Count);
     if (Probe->isEntry()) {
       FunctionProfile.addHeadSamples(Count);
       // Look up for the caller's function profile
       const auto *InlinerDesc = Binary->getInlinerDescForProbe(Probe);
       if (InlinerDesc != nullptr) {
for (auto PI : ProbeCounter) {
     }
 
     // Assign zero count for remaining probes without sample hits to
     // differentiate from probes optimized away, of which the counts are unknown
     // and will be inferred by the compiler.
     for (auto &I : FrameSamples) {
       auto *FunctionProfile = I.second;
       for (auto *Probe : I.first->getProbes()) {
-        if (!Probe->isDangling())
           FunctionProfile->addBodySamplesForProbe(Probe->Index, 0);
       }
     }
   }
 }
 
 void PseudoProbeCSProfileGenerator::populateBoundarySamplesWithProbes(
     const BranchSample &BranchCounter,

llvm/tools/llvm-profgen/PseudoProbe.h

 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 namespace llvm {
 namespace sampleprof {
 
-enum PseudoProbeAttributes { TAILCALL = 1, DANGLING = 2 };
+enum PseudoProbeAttributes { RESERVED = 1 };
 
 // Use func GUID and index as the location info of the inline site
 using InlineSite = std::tuple<uint64_t, uint32_t>;
 
 struct PseudoProbe;
 
 // Tree node to represent the inline relation and its inline site, we use a
 // dummy root in the PseudoProbeDecoder to lead the tree, the outlined

 using AddressProbesMap = std::unordered_map<uint64_t, std::list<PseudoProbe>>;
 
 /*
 A pseudo probe has the format like below:
   INDEX (ULEB128)
   TYPE (uint4)
     0 - block probe, 1 - indirect call, 2 - direct call
   ATTRIBUTE (uint3)
-    1 - tail call, 2 - dangling
+    1 - reserved
   ADDRESS_TYPE (uint1)
     0 - code address, 1 - address delta
   CODE_ADDRESS (uint64 or ULEB128)
   code address or address delta, depending on Flag
 */
 struct PseudoProbe {
   uint64_t Address;
   uint64_t GUID;
   uint32_t Index;
   PseudoProbeType Type;
   uint8_t Attribute;
   PseudoProbeInlineTree *InlineTree;
   const static uint32_t PseudoProbeFirstId =
       static_cast<uint32_t>(PseudoProbeReservedId::Last) + 1;
 
   PseudoProbe(uint64_t Ad, uint64_t G, uint32_t I, PseudoProbeType K,
               uint8_t At, PseudoProbeInlineTree *Tree)
       : Address(Ad), GUID(G), Index(I), Type(K), Attribute(At),
         InlineTree(Tree){};
 
   bool isEntry() const { return Index == PseudoProbeFirstId; }
-
-  bool isDangling() const {
-    return Attribute & static_cast<uint8_t>(PseudoProbeAttributes::DANGLING);
-  }
-
-  bool isTailCall() const {
-    return Attribute & static_cast<uint8_t>(PseudoProbeAttributes::TAILCALL);
-  }
-
   bool isBlock() const { return Type == PseudoProbeType::Block; }
   bool isIndirectCall() const { return Type == PseudoProbeType::IndirectCall; }
   bool isDirectCall() const { return Type == PseudoProbeType::DirectCall; }
   bool isCall() const { return isIndirectCall() || isDirectCall(); }
 
   PseudoProbeInlineTree *getInlineTreeNode() const { return InlineTree; }
 
   // Get the inlined context by traversing current inline tree backwards,

llvm/tools/llvm-profgen/PseudoProbe.cpp

void PseudoProbe::print(raw_ostream &OS,
   if (ShowName) {
     StringRef FuncName = getProbeFNameForGUID(GUID2FuncMAP, GUID);
     OS << FuncName.str() << " ";
   } else {
     OS << GUID << " ";
   }
   OS << "Index: " << Index << "  ";
   OS << "Type: " << PseudoProbeTypeStr[static_cast<uint8_t>(Type)] << "  ";
-  if (isDangling()) {
-    OS << "Dangling  ";
-  }
-  if (isTailCall()) {
-    OS << "TailCall  ";
-  }
+
   std::string InlineContextStr = getInlineContextStr(GUID2FuncMAP, ShowName);
   if (InlineContextStr.size()) {
     OS << "Inlined: @ ";
     OS << InlineContextStr;
   }
   OS << "\n";
 }
 
void PseudoProbeDecoder::buildAddress2ProbeMap(const uint8_t *Start,
   //         Number of callees inlined into this function, aka number of
   //         first-level inlinees
   //     PROBE RECORDS
   //         A list of NPROBES entries. Each entry contains:
   //           INDEX (ULEB128)
   //           TYPE (uint4)
   //             0 - block probe, 1 - indirect call, 2 - direct call
   //           ATTRIBUTE (uint3)
-  //             1 - tail call, 2 - dangling
+  //             1 - reserved
   //           ADDRESS_TYPE (uint1)
   //             0 - code address, 1 - address delta
   //           CODE_ADDRESS (uint64 or ULEB128)
   //             code address or address delta, depending on Flag
   //     INLINED FUNCTION RECORDS
   //         A list of NUM_INLINED_FUNCTIONS entries describing each of the
   //         inlined callees.  Each record contains:
   //           INLINE SITE