Use LineLocation instead of CallsiteLocation to index callsite profile.

[danielcdh]

Summary

With discriminator, LineLocation can uniquely identify a callsite without the need to specifying callee name. Remove Callee function name from the key, and put it in the value (FunctionSamples).

[dnovillo]

Nice cleanup! I think we can prevent breaking the AutoFDO tool by adding an overload.

include/llvm/ProfileData/SampleProf.h

284

Add documentation for this field. Indicate that this is the mangled name of the function.

include/llvm/ProfileData/SampleProfWriter.h

38–43

This will break the AutoFDO tool.

Idea: keep the old call as a temporary overload. This gives you time to fix AutoFDO without it breaking on you in the interim. The version of SampleProfileWriter::write() that takes FName as an argument simply does nothing with it.

[danielcdh]

keep old writer interface.

include/llvm/ProfileData/SampleProfWriter.h

38–43

Thanks for bring this up.

[dnovillo]

LGTM. Thanks.

Just to make sure AutoFDO is still working, would you mind building it with your LLVM build to make sure that create_llvm_prof still works?

include/llvm/ProfileData/SampleProf.h

struct LineLocation {
   }
 
   uint32_t LineOffset;
   uint32_t Discriminator;
 };
 
 raw_ostream &operator<<(raw_ostream &OS, const LineLocation &Loc);
 
-/// Represents the relative location of a callsite.
-///
-/// Callsite locations are specified by the line offset from the
-/// beginning of the function (marked by the line where the function
-/// head is), the discriminator value within that line, and the callee
-/// function name.
-struct CallsiteLocation : public LineLocation {
-  CallsiteLocation(uint32_t L, uint32_t D, StringRef N)
-      : LineLocation(L, D), CalleeName(N) {}
-  void print(raw_ostream &OS) const;
-  void dump() const;
-
-  StringRef CalleeName;
-};
-
-raw_ostream &operator<<(raw_ostream &OS, const CallsiteLocation &Loc);
-
 /// Representation of a single sample record.
 ///
 /// A sample record is represented by a positive integer value, which
 /// indicates how frequently was the associated line location executed.
 ///
 /// Additionally, if the associated location contains a function call,
 /// the record will hold a list of all the possible called targets. For
 /// direct calls, this will be the exact function being invoked. For
private:
   uint64_t NumSamples;
   CallTargetMap CallTargets;
 };
 
 raw_ostream &operator<<(raw_ostream &OS, const SampleRecord &Sample);
 
 typedef std::map<LineLocation, SampleRecord> BodySampleMap;
 class FunctionSamples;
-typedef std::map<CallsiteLocation, FunctionSamples> CallsiteSampleMap;
+typedef std::map<LineLocation, FunctionSamples> CallsiteSampleMap;
 
 /// Representation of the samples collected for a function.
 ///
 /// This data structure contains all the collected samples for the body
 /// of a function. Each sample corresponds to a LineLocation instance
 /// within the body of the function.
 class FunctionSamples {
 public:
-  FunctionSamples() : TotalSamples(0), TotalHeadSamples(0) {}
+  FunctionSamples() : Name(), TotalSamples(0), TotalHeadSamples(0) {}
   void print(raw_ostream &OS = dbgs(), unsigned Indent = 0) const;
   void dump() const;
   sampleprof_error addTotalSamples(uint64_t Num, uint64_t Weight = 1) {
     bool Overflowed;
     TotalSamples =
         SaturatingMultiplyAdd(Num, Weight, TotalSamples, &Overflowed);
     return Overflowed ? sampleprof_error::counter_overflow
                       : sampleprof_error::success;
ErrorOr<uint64_t> findSamplesAt(uint32_t LineOffset,
     const auto &ret = BodySamples.find(LineLocation(LineOffset, Discriminator));
     if (ret == BodySamples.end())
       return std::error_code();
     else
       return ret->second.getSamples();
   }
 
   /// Return the function samples at the given callsite location.
-  FunctionSamples &functionSamplesAt(const CallsiteLocation &Loc) {
+  FunctionSamples &functionSamplesAt(const LineLocation &Loc) {
     return CallsiteSamples[Loc];
   }
 
   /// Return a pointer to function samples at the given callsite location.
-  const FunctionSamples *
-  findFunctionSamplesAt(const CallsiteLocation &Loc) const {
+  const FunctionSamples *findFunctionSamplesAt(const LineLocation &Loc) const {
     auto iter = CallsiteSamples.find(Loc);
     if (iter == CallsiteSamples.end()) {
       return nullptr;
     } else {
       return &iter->second;
     }
   }
 
public:
   const CallsiteSampleMap &getCallsiteSamples() const {
     return CallsiteSamples;
   }
 
   /// Merge the samples in \p Other into this one.
   /// Optionally scale samples by \p Weight.
   sampleprof_error merge(const FunctionSamples &Other, uint64_t Weight = 1) {
     sampleprof_error Result = sampleprof_error::success;
+    Name = Other.getName();
     MergeResult(Result, addTotalSamples(Other.getTotalSamples(), Weight));
     MergeResult(Result, addHeadSamples(Other.getHeadSamples(), Weight));
     for (const auto &I : Other.getBodySamples()) {
       const LineLocation &Loc = I.first;
       const SampleRecord &Rec = I.second;
       MergeResult(Result, BodySamples[Loc].merge(Rec, Weight));
     }
     for (const auto &I : Other.getCallsiteSamples()) {
-      const CallsiteLocation &Loc = I.first;
+      const LineLocation &Loc = I.first;
       const FunctionSamples &Rec = I.second;
       MergeResult(Result, functionSamplesAt(Loc).merge(Rec, Weight));
     }
     return Result;
   }
 
+  /// Set the name of the function.
+  void setName(StringRef FunctionName) { Name = FunctionName; }
+
+  /// Return the function name.
+  const StringRef &getName() const { return Name; }
+
 private:
+  /// Mangled name of the function.
+  StringRef Name;
+
   /// Total number of samples collected inside this function.
   ///
   /// Samples are cumulative, they include all the samples collected
   /// inside this function and all its inlined callees.
   uint64_t TotalSamples;
 
   /// Total number of samples collected at the head of the function.
   /// This is an approximation of the number of calls made to this function

include/llvm/ProfileData/SampleProfWriter.h

 
 enum SampleProfileFormat { SPF_None = 0, SPF_Text, SPF_Binary, SPF_GCC };
 
 /// \brief Sample-based profile writer. Base class.
 class SampleProfileWriter {
 public:
   virtual ~SampleProfileWriter() {}
 
-  /// Write sample profiles in \p S for function \p FName.
+  /// Write sample profiles in \p S.
   ///
   /// \returns status code of the file update operation.
-  virtual std::error_code write(StringRef FName, const FunctionSamples &S) = 0;
+  virtual std::error_code write(const FunctionSamples &S) = 0;
+
+  /// Keep the old write() interface so that AutoFDO tool does not break.
+  std::error_code write(StringRef FName, const FunctionSamples &S) {
+    return write(S);
+  }
 
   /// Write all the sample profiles in the given map of samples.
   ///
   /// \returns status code of the file update operation.
   std::error_code write(const StringMap<FunctionSamples> &ProfileMap) {
     if (std::error_code EC = writeHeader(ProfileMap))
       return EC;
     for (const auto &I : ProfileMap) {
-      StringRef FName = I.first();
       const FunctionSamples &Profile = I.second;
-      if (std::error_code EC = write(FName, Profile))
+      if (std::error_code EC = write(Profile))
         return EC;
     }
     return sampleprof_error::success;
   }
 
   raw_ostream &getOutputStream() { return *OutputStream; }
 
   /// Profile writer factory.
protected:
 
   /// \brief Compute summary for this profile.
   void computeSummary(const StringMap<FunctionSamples> &ProfileMap);
 };
 
 /// \brief Sample-based profile writer (text format).
 class SampleProfileWriterText : public SampleProfileWriter {
 public:
-  std::error_code write(StringRef FName, const FunctionSamples &S) override;
+  std::error_code write(const FunctionSamples &S) override;
 
 protected:
   SampleProfileWriterText(std::unique_ptr<raw_ostream> &OS)
       : SampleProfileWriter(OS), Indent(0) {}
 
   std::error_code
   writeHeader(const StringMap<FunctionSamples> &ProfileMap) override {
     return sampleprof_error::success;
   }
 
 private:
   /// Indent level to use when writing.
   ///
   /// This is used when printing inlined callees.
   unsigned Indent;
 
   friend ErrorOr<std::unique_ptr<SampleProfileWriter>>
   SampleProfileWriter::create(std::unique_ptr<raw_ostream> &OS,
                               SampleProfileFormat Format);
 };
 
 /// \brief Sample-based profile writer (binary format).
 class SampleProfileWriterBinary : public SampleProfileWriter {
 public:
-  std::error_code write(StringRef F, const FunctionSamples &S) override;
+  std::error_code write(const FunctionSamples &S) override;
 
 protected:
   SampleProfileWriterBinary(std::unique_ptr<raw_ostream> &OS)
       : SampleProfileWriter(OS), NameTable() {}
 
   std::error_code
   writeHeader(const StringMap<FunctionSamples> &ProfileMap) override;
   std::error_code writeSummary();
   std::error_code writeNameIdx(StringRef FName);
-  std::error_code writeBody(StringRef FName, const FunctionSamples &S);
+  std::error_code writeBody(const FunctionSamples &S);
 
 private:
   void addName(StringRef FName);
   void addNames(const FunctionSamples &S);
 
   MapVector<StringRef, uint32_t> NameTable;
 
   friend ErrorOr<std::unique_ptr<SampleProfileWriter>>

lib/ProfileData/SampleProf.cpp

 raw_ostream &llvm::sampleprof::operator<<(raw_ostream &OS,
                                           const LineLocation &Loc) {
   Loc.print(OS);
   return OS;
 }
 
 LLVM_DUMP_METHOD void LineLocation::dump() const { print(dbgs()); }
 
-void CallsiteLocation::print(raw_ostream &OS) const {
-  LineLocation::print(OS);
-  OS << ": inlined callee: " << CalleeName;
-}
-
-LLVM_DUMP_METHOD void CallsiteLocation::dump() const { print(dbgs()); }
-
-inline raw_ostream &llvm::sampleprof::operator<<(raw_ostream &OS,
-                                                 const CallsiteLocation &Loc) {
-  Loc.print(OS);
-  return OS;
-}
-
 /// \brief Print the sample record to the stream \p OS indented by \p Indent.
 void SampleRecord::print(raw_ostream &OS, unsigned Indent) const {
   OS << NumSamples;
   if (hasCalls()) {
     OS << ", calls:";
     for (const auto &I : getCallTargets())
       OS << " " << I.first() << ":" << I.second;
   }
if (BodySamples.size() > 0) {
     OS << "}\n";
   } else {
     OS << "No samples collected in the function's body\n";
   }
 
   OS.indent(Indent);
   if (CallsiteSamples.size() > 0) {
     OS << "Samples collected in inlined callsites {\n";
-    SampleSorter<CallsiteLocation, FunctionSamples> SortedCallsiteSamples(
+    SampleSorter<LineLocation, FunctionSamples> SortedCallsiteSamples(
         CallsiteSamples);
     for (const auto &CS : SortedCallsiteSamples.get()) {
       OS.indent(Indent + 2);
-      OS << CS->first << ": ";
+      OS << CS->first << ": inlined callee: " << CS->second.getName() << ": ";
       CS->second.print(OS, Indent + 4);
     }
     OS << "}\n";
   } else {
     OS << "No inlined callsites in this function\n";
   }
 }
 
 raw_ostream &llvm::sampleprof::operator<<(raw_ostream &OS,
                                           const FunctionSamples &FS) {
   FS.print(OS);
   return OS;
 }
 
 void FunctionSamples::dump(void) const { print(dbgs(), 0); }

lib/ProfileData/SampleProfReader.cpp

static bool ParseHead(const StringRef &Input, StringRef &FName,
   FName = Input.substr(0, n1);
   if (Input.substr(n1 + 1, n2 - n1 - 1).getAsInteger(10, NumSamples))
     return false;
   if (Input.substr(n2 + 1).getAsInteger(10, NumHeadSamples))
     return false;
   return true;
 }
 
-
 /// \brief Returns true if line offset \p L is legal (only has 16 bits).
-static bool isOffsetLegal(unsigned L) {
-  return (L & 0xffff) == L;
-}
+static bool isOffsetLegal(unsigned L) { return (L & 0xffff) == L; }
 
 /// \brief Parse \p Input as line sample.
 ///
 /// \param Input input line.
 /// \param IsCallsite true if the line represents an inlined callsite.
 /// \param Depth the depth of the inline stack.
 /// \param NumSamples total samples of the line/inlined callsite.
 /// \param LineOffset line offset to the start of the function.
if ((*LineIt)[0] != ' ') {
       StringRef FName;
       if (!ParseHead(*LineIt, FName, NumSamples, NumHeadSamples)) {
         reportError(LineIt.line_number(),
                     "Expected 'mangled_name:NUM:NUM', found " + *LineIt);
         return sampleprof_error::malformed;
       }
       Profiles[FName] = FunctionSamples();
       FunctionSamples &FProfile = Profiles[FName];
+      FProfile.setName(FName);
       MergeResult(Result, FProfile.addTotalSamples(NumSamples));
       MergeResult(Result, FProfile.addHeadSamples(NumHeadSamples));
       InlineStack.clear();
       InlineStack.push_back(&FProfile);
     } else {
       uint64_t NumSamples;
       StringRef FName;
       DenseMap<StringRef, uint64_t> TargetCountMap;
       bool IsCallsite;
       uint32_t Depth, LineOffset, Discriminator;
       if (!ParseLine(*LineIt, IsCallsite, Depth, NumSamples, LineOffset,
                      Discriminator, FName, TargetCountMap)) {
         reportError(LineIt.line_number(),
                     "Expected 'NUM[.NUM]: NUM[ mangled_name:NUM]*', found " +
                         *LineIt);
         return sampleprof_error::malformed;
       }
       if (IsCallsite) {
         while (InlineStack.size() > Depth) {
           InlineStack.pop_back();
         }
         FunctionSamples &FSamples = InlineStack.back()->functionSamplesAt(
-            CallsiteLocation(LineOffset, Discriminator, FName));
+            LineLocation(LineOffset, Discriminator));
+        FSamples.setName(FName);
         MergeResult(Result, FSamples.addTotalSamples(NumSamples));
         InlineStack.push_back(&FSamples);
       } else {
         while (InlineStack.size() > Depth) {
           InlineStack.pop_back();
         }
         FunctionSamples &FProfile = *InlineStack.back();
         for (const auto &name_count : TargetCountMap) {
for (uint32_t J = 0; J < *NumCallsites; ++J) {
     auto Discriminator = readNumber<uint64_t>();
     if (std::error_code EC = Discriminator.getError())
       return EC;
 
     auto FName(readStringFromTable());
     if (std::error_code EC = FName.getError())
       return EC;
 
-    FunctionSamples &CalleeProfile = FProfile.functionSamplesAt(
-        CallsiteLocation(*LineOffset, *Discriminator, *FName));
+    FunctionSamples &CalleeProfile =
+        FProfile.functionSamplesAt(LineLocation(*LineOffset, *Discriminator));
+    CalleeProfile.setName(*FName);
     if (std::error_code EC = readProfile(CalleeProfile))
       return EC;
   }
 
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileReaderBinary::read() {
   while (!at_eof()) {
     auto NumHeadSamples = readNumber<uint64_t>();
     if (std::error_code EC = NumHeadSamples.getError())
       return EC;
 
     auto FName(readStringFromTable());
     if (std::error_code EC = FName.getError())
       return EC;
 
     Profiles[*FName] = FunctionSamples();
     FunctionSamples &FProfile = Profiles[*FName];
+    FProfile.setName(*FName);
 
     FProfile.addHeadSamples(*NumHeadSamples);
 
     if (std::error_code EC = readProfile(FProfile))
       return EC;
   }
 
   return sampleprof_error::success;
std::error_code SampleProfileReaderGCC::readOneFunctionProfile(
   } else {
     // Otherwise, we are reading an inlined instance. The top of the
     // inline stack contains the profile of the caller. Insert this
     // callee in the caller's CallsiteMap.
     FunctionSamples *CallerProfile = InlineStack.front();
     uint32_t LineOffset = Offset >> 16;
     uint32_t Discriminator = Offset & 0xffff;
     FProfile = &CallerProfile->functionSamplesAt(
-        CallsiteLocation(LineOffset, Discriminator, Name));
+        LineLocation(LineOffset, Discriminator));
   }
+  FProfile->setName(Name);
 
   for (uint32_t I = 0; I < NumPosCounts; ++I) {
     uint32_t Offset;
     if (!GcovBuffer.readInt(Offset))
       return sampleprof_error::truncated;
 
     uint32_t NumTargets;
     if (!GcovBuffer.readInt(NumTargets))

lib/ProfileData/SampleProfWriter.cpp

 /// \brief Write samples to a text file.
 ///
 /// Note: it may be tempting to implement this in terms of
 /// FunctionSamples::print().  Please don't.  The dump functionality is intended
 /// for debugging and has no specified form.
 ///
 /// The format used here is more structured and deliberate because
 /// it needs to be parsed by the SampleProfileReaderText class.
-std::error_code SampleProfileWriterText::write(StringRef FName,
-                                               const FunctionSamples &S) {
+std::error_code SampleProfileWriterText::write(const FunctionSamples &S) {
   auto &OS = *OutputStream;
-
-  OS << FName << ":" << S.getTotalSamples();
+  OS << S.getName() << ":" << S.getTotalSamples();
   if (Indent == 0)
     OS << ":" << S.getHeadSamples();
   OS << "\n";
 
   SampleSorter<LineLocation, SampleRecord> SortedSamples(S.getBodySamples());
   for (const auto &I : SortedSamples.get()) {
     LineLocation Loc = I->first;
     const SampleRecord &Sample = I->second;
     OS.indent(Indent + 1);
     if (Loc.Discriminator == 0)
       OS << Loc.LineOffset << ": ";
     else
       OS << Loc.LineOffset << "." << Loc.Discriminator << ": ";
 
     OS << Sample.getSamples();
 
     for (const auto &J : Sample.getCallTargets())
       OS << " " << J.first() << ":" << J.second;
     OS << "\n";
   }
 
-  SampleSorter<CallsiteLocation, FunctionSamples> SortedCallsiteSamples(
+  SampleSorter<LineLocation, FunctionSamples> SortedCallsiteSamples(
       S.getCallsiteSamples());
   Indent += 1;
   for (const auto &I : SortedCallsiteSamples.get()) {
-    CallsiteLocation Loc = I->first;
+    LineLocation Loc = I->first;
     const FunctionSamples &CalleeSamples = I->second;
     OS.indent(Indent);
     if (Loc.Discriminator == 0)
       OS << Loc.LineOffset << ": ";
     else
       OS << Loc.LineOffset << "." << Loc.Discriminator << ": ";
-    if (std::error_code EC = write(Loc.CalleeName, CalleeSamples))
+    if (std::error_code EC = write(CalleeSamples))
       return EC;
   }
   Indent -= 1;
 
   return sampleprof_error::success;
 }
 
 std::error_code SampleProfileWriterBinary::writeNameIdx(StringRef FName) {
void SampleProfileWriterBinary::addNames(const FunctionSamples &S) {
   for (const auto &I : S.getBodySamples()) {
     const SampleRecord &Sample = I.second;
     for (const auto &J : Sample.getCallTargets())
       addName(J.first());
   }
 
   // Recursively add all the names for inlined callsites.
   for (const auto &J : S.getCallsiteSamples()) {
-    CallsiteLocation Loc = J.first;
     const FunctionSamples &CalleeSamples = J.second;
-    addName(Loc.CalleeName);
+    addName(CalleeSamples.getName());
     addNames(CalleeSamples);
   }
 }
 
 std::error_code SampleProfileWriterBinary::writeHeader(
     const StringMap<FunctionSamples> &ProfileMap) {
   auto &OS = *OutputStream;
 
std::error_code SampleProfileWriterBinary::writeSummary() {
   encodeULEB128(Entries.size(), OS);
   for (auto Entry : Entries) {
     encodeULEB128(Entry.Cutoff, OS);
     encodeULEB128(Entry.MinCount, OS);
     encodeULEB128(Entry.NumCounts, OS);
   }
   return sampleprof_error::success;
 }
-std::error_code SampleProfileWriterBinary::writeBody(StringRef FName,
-                                                     const FunctionSamples &S) {
+std::error_code SampleProfileWriterBinary::writeBody(const FunctionSamples &S) {
   auto &OS = *OutputStream;
 
-  if (std::error_code EC = writeNameIdx(FName))
+  if (std::error_code EC = writeNameIdx(S.getName()))
     return EC;
 
   encodeULEB128(S.getTotalSamples(), OS);
 
   // Emit all the body samples.
   encodeULEB128(S.getBodySamples().size(), OS);
   for (const auto &I : S.getBodySamples()) {
     LineLocation Loc = I.first;
for (const auto &J : Sample.getCallTargets()) {
         return EC;
       encodeULEB128(CalleeSamples, OS);
     }
   }
 
   // Recursively emit all the callsite samples.
   encodeULEB128(S.getCallsiteSamples().size(), OS);
   for (const auto &J : S.getCallsiteSamples()) {
-    CallsiteLocation Loc = J.first;
+    LineLocation Loc = J.first;
     const FunctionSamples &CalleeSamples = J.second;
     encodeULEB128(Loc.LineOffset, OS);
     encodeULEB128(Loc.Discriminator, OS);
-    if (std::error_code EC = writeBody(Loc.CalleeName, CalleeSamples))
+    if (std::error_code EC = writeBody(CalleeSamples))
       return EC;
   }
 
   return sampleprof_error::success;
 }
 
 /// \brief Write samples of a top-level function to a binary file.
 ///
 /// \returns true if the samples were written successfully, false otherwise.
-std::error_code SampleProfileWriterBinary::write(StringRef FName,
-                                                 const FunctionSamples &S) {
+std::error_code SampleProfileWriterBinary::write(const FunctionSamples &S) {
   encodeULEB128(S.getHeadSamples(), *OutputStream);
-  return writeBody(FName, S);
+  return writeBody(S);
 }
 
 /// \brief Create a sample profile file writer based on the specified format.
 ///
 /// \param Filename The file to create.
 ///
 /// \param Writer The writer to instantiate according to the specified format.
 ///

lib/Transforms/IPO/SampleProfile.cpp

 #include "llvm/Pass.h"
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
-#include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/InstCombine/InstCombine.h"
+#include "llvm/Transforms/Utils/Cloning.h"
 #include <cctype>
 
 using namespace llvm;
 using namespace sampleprof;
 
 #define DEBUG_TYPE "sample-profile"
 
 // Command line option to specify the file to read samples from. This is
bool callsiteIsHot(const FunctionSamples *CallerFS,
   uint64_t CallsiteTotalSamples = CallsiteFS->getTotalSamples();
   if (CallsiteTotalSamples == 0)
     return false; // Callsite is trivially cold.
 
   double PercentSamples =
       (double)CallsiteTotalSamples / (double)ParentTotalSamples * 100.0;
   return PercentSamples >= SampleProfileHotThreshold;
 }
-
 }
 
 /// Mark as used the sample record for the given function samples at
 /// (LineOffset, Discriminator).
 ///
 /// \returns true if this is the first time we mark the given record.
 bool SampleCoverageTracker::markSamplesUsed(const FunctionSamples *FS,
                                             uint32_t LineOffset,
SampleProfileLoader::findCalleeFunctionSamples(const CallInst &Inst) const {
   const DILocation *DIL = Inst.getDebugLoc();
   if (!DIL) {
     return nullptr;
   }
   DISubprogram *SP = DIL->getScope()->getSubprogram();
   if (!SP)
     return nullptr;
 
-  Function *CalleeFunc = Inst.getCalledFunction();
-  if (!CalleeFunc) {
-    return nullptr;
-  }
-
-  StringRef CalleeName = CalleeFunc->getName();
   const FunctionSamples *FS = findFunctionSamples(Inst);
   if (FS == nullptr)
     return nullptr;
 
-  return FS->findFunctionSamplesAt(
-      CallsiteLocation(getOffset(DIL->getLine(), SP->getLine()),
-                       DIL->getDiscriminator(), CalleeName));
+  return FS->findFunctionSamplesAt(LineLocation(
+      getOffset(DIL->getLine(), SP->getLine()), DIL->getDiscriminator()));
 }
 
 /// \brief Get the FunctionSamples for an instruction.
 ///
 /// The FunctionSamples of an instruction \p Inst is the inlined instance
 /// in which that instruction is coming from. We traverse the inline stack
 /// of that instruction, and match it with the tree nodes in the profile.
 ///
 /// \param Inst Instruction to query.
 ///
 /// \returns the FunctionSamples pointer to the inlined instance.
 const FunctionSamples *
 SampleProfileLoader::findFunctionSamples(const Instruction &Inst) const {
-  SmallVector<CallsiteLocation, 10> S;
+  SmallVector<LineLocation, 10> S;
   const DILocation *DIL = Inst.getDebugLoc();
   if (!DIL) {
     return Samples;
   }
   StringRef CalleeName;
   for (const DILocation *DIL = Inst.getDebugLoc(); DIL;
        DIL = DIL->getInlinedAt()) {
     DISubprogram *SP = DIL->getScope()->getSubprogram();
     if (!SP)
       return nullptr;
     if (!CalleeName.empty()) {
-      S.push_back(CallsiteLocation(getOffset(DIL->getLine(), SP->getLine()),
-                                   DIL->getDiscriminator(), CalleeName));
+      S.push_back(LineLocation(getOffset(DIL->getLine(), SP->getLine()),
+                               DIL->getDiscriminator()));
     }
     CalleeName = SP->getLinkageName();
   }
   if (S.size() == 0)
     return Samples;
   const FunctionSamples *FS = Samples;
   for (int i = S.size() - 1; i >= 0 && FS != nullptr; i--) {
     FS = FS->findFunctionSamplesAt(S[i]);

unittests/ProfileData/SampleProfTest.cpp

void readProfile(std::unique_ptr<MemoryBuffer> &Profile) {
     Reader = std::move(ReaderOrErr.get());
   }
 
   void testRoundTrip(SampleProfileFormat Format) {
     createWriter(Format);
 
     StringRef FooName("_Z3fooi");
     FunctionSamples FooSamples;
+    FooSamples.setName(FooName);
     FooSamples.addTotalSamples(7711);
     FooSamples.addHeadSamples(610);
     FooSamples.addBodySamples(1, 0, 610);
     FooSamples.addBodySamples(2, 0, 600);
     FooSamples.addBodySamples(4, 0, 60000);
     FooSamples.addBodySamples(8, 0, 60351);
     FooSamples.addBodySamples(10, 0, 605);
 
     StringRef BarName("_Z3bari");
     FunctionSamples BarSamples;
+    BarSamples.setName(BarName);
     BarSamples.addTotalSamples(20301);
     BarSamples.addHeadSamples(1437);
     BarSamples.addBodySamples(1, 0, 1437);
 
     StringMap<FunctionSamples> Profiles;
     Profiles[FooName] = std::move(FooSamples);
     Profiles[BarName] = std::move(BarSamples);