[Pseudo Probe] Use the name from debug info to compute GUID in probe desc

[wlei]

Summary

This is to fix a GUID mismatch while decoding pseudo probe, a GUID from the inline tree is not in the GUID2FuncDescMap. It turned out that frontend could change the function name making it different from the one in debug info(https://reviews.llvm.org/D111009). Here change to use the function name from debug info to be consistent with the probe name from the inline stack.

[hoy]

Good catch, thanks for the fix.

[hoy]

llvm/lib/Transforms/IPO/SampleProfileProbe.cpp

381

The dwarf name should also be used inside this function.

[wlei]

fix another func name usage.

[wenlei]

Is the patch mentioned above the only case where name from IR would be different from name in debug info? Just want to make sure this change doesn't have any compatibility issue while fixing the mismatch from the patch.

[wlei]

In D146657#4215089, @wenlei wrote:

Is the patch mentioned above the only case where name from IR would be different from name in debug info? Just want to make sure this change doesn't have any compatibility issue while fixing the mismatch from the patch.

Yes, from our internal issue, I dumped all the mismatched GUID function names, they are memcpy.inline, memset.inline, memmove.inline. Interesting, assuming this is the first time we got this mismatch, that means before the frontend all generated a consistent symbol and dwarf name.

[wenlei]

lgtm, thanks.

llvm/include/llvm/IR/MDBuilder.h

public:
   /// enable the same inlines as the profiled optimized binary
   MDNode *createFunctionEntryCount(uint64_t Count, bool Synthetic,
                                    const DenseSet<GlobalValue::GUID> *Imports);
 
   /// Return metadata containing the section prefix for a function.
   MDNode *createFunctionSectionPrefix(StringRef Prefix);
 
   /// Return metadata containing the pseudo probe descriptor for a function.
-  MDNode *createPseudoProbeDesc(uint64_t GUID, uint64_t Hash, Function *F);
+  MDNode *createPseudoProbeDesc(uint64_t GUID, uint64_t Hash, StringRef FName);
 
   /// Return metadata containing llvm statistics.
   MDNode *
   createLLVMStats(ArrayRef<std::pair<StringRef, uint64_t>> LLVMStatsVec);
 
   //===------------------------------------------------------------------===//
   // Range metadata.
   //===------------------------------------------------------------------===//

llvm/lib/IR/MDBuilder.cpp

MDNode *MDBuilder::createIrrLoopHeaderWeight(uint64_t Weight) {
   Metadata *Vals[] = {
     createString("loop_header_weight"),
     createConstant(ConstantInt::get(Type::getInt64Ty(Context), Weight)),
   };
   return MDNode::get(Context, Vals);
 }
 
 MDNode *MDBuilder::createPseudoProbeDesc(uint64_t GUID, uint64_t Hash,
-                                         Function *F) {
+                                         StringRef FName) {
   auto *Int64Ty = Type::getInt64Ty(Context);
   SmallVector<Metadata *, 3> Ops(3);
   Ops[0] = createConstant(ConstantInt::get(Int64Ty, GUID));
   Ops[1] = createConstant(ConstantInt::get(Int64Ty, Hash));
-  Ops[2] = createString(F->getName());
+  Ops[2] = createString(FName);
   return MDNode::get(Context, Ops);
 }
 
 MDNode *
 MDBuilder::createLLVMStats(ArrayRef<std::pair<StringRef, uint64_t>> LLVMStats) {
   auto *Int64Ty = Type::getInt64Ty(Context);
   SmallVector<Metadata *, 4> Ops(LLVMStats.size() * 2);
   for (size_t I = 0; I < LLVMStats.size(); I++) {
     Ops[I * 2] = createString(LLVMStats[I].first);
     Ops[I * 2 + 1] =
         createConstant(ConstantInt::get(Int64Ty, LLVMStats[I].second));
   }
   return MDNode::get(Context, Ops);
 }

llvm/lib/Transforms/IPO/SampleProfileProbe.cpp

 uint32_t SampleProfileProber::getCallsiteId(const Instruction *Call) const {
   auto Iter = CallProbeIds.find(const_cast<Instruction *>(Call));
   return Iter == CallProbeIds.end() ? 0 : Iter->second;
 }
 
 void SampleProfileProber::instrumentOneFunc(Function &F, TargetMachine *TM) {
   Module *M = F.getParent();
   MDBuilder MDB(F.getContext());
-  // Compute a GUID without considering the function's linkage type. This is
-  // fine since function name is the only key in the profile database.
-  uint64_t Guid = Function::getGUID(F.getName());
+  // Since the GUID from probe desc and inline stack are computed seperately, we
+  // need to make sure their names are consistent, so here also use the name
+  // from debug info.
+  StringRef FName = F.getName();
+  if (auto *SP = F.getSubprogram()) {
+    FName = SP->getLinkageName();
+    if (FName.empty())
+      FName = SP->getName();
+  }
+  uint64_t Guid = Function::getGUID(FName);
 
   // Assign an artificial debug line to a probe that doesn't come with a real
   // line. A probe not having a debug line will get an incomplete inline
   // context. This will cause samples collected on the probe to be counted
   // into the base profile instead of a context profile. The line number
   // itself is not important though.
   auto AssignDebugLoc = [&](Instruction *I) {
     assert((isa<PseudoProbeInst>(I) || isa<CallBase>(I)) &&
void SampleProfileProber::instrumentOneFunc(Function &F, TargetMachine *TM) {
   }
 
   // Create module-level metadata that contains function info necessary to
   // synthesize probe-based sample counts,  which are
   // - FunctionGUID
   // - FunctionHash.
   // - FunctionName
   auto Hash = getFunctionHash();
-  auto *MD = MDB.createPseudoProbeDesc(Guid, Hash, &F);
+  auto *MD = MDB.createPseudoProbeDesc(Guid, Hash, FName);
   auto *NMD = M->getNamedMetadata(PseudoProbeDescMetadataName);
   assert(NMD && "llvm.pseudo_probe_desc should be pre-created");
   NMD->addOperand(MD);
 
   // Preserve a comdat group to hold all probes materialized later. This
   // allows that when the function is considered dead and removed, the
   // materialized probes are disposed too.
   // Imported functions are defined in another module. They do not need