[memprof] Keep and display symbol names in the RawMemProfReader.

[snehasish]

Summary

Extend the Frame struct to hold the symbol name if requested
when a RawMemProfReader object is constructed. This change updates the
tests and removes the need to pass --debug to obtain the mapping from
GUID to symbol names.

[snehasish]

Remove unnecessary blank lines.

[tejohnson]

llvm/include/llvm/ProfileData/MemProf.h

146

"should not be serialized" (missing "be")

llvm/lib/ProfileData/RawMemProfReader.cpp

419

Why not add the function name into the Frame here rather than waiting for the later call to idToFrame() and filling it from the map then?

[snehasish]

Update comments.

[snehasish]

PTAL, thanks!

llvm/lib/ProfileData/RawMemProfReader.cpp

419

The idea here is to save memory by not duplicating the symbol names since we can have many unique frames (a combination of symbol + location). Also the processing does not require the symbol name today, so we only populate it in the iterator interface where a single MemProfRecord object is instantiated at a time.

[tejohnson]

lgtm

llvm/lib/ProfileData/RawMemProfReader.cpp

419

Another alternative, to avoid the repeated map lookups later on, is to make SymbolName a StringRef and keep a StringSet of the unique strings for ownership.

[snehasish]

Thanks for the review.

llvm/lib/ProfileData/RawMemProfReader.cpp

419

While it would eliminate the map lookup, it would make it very easy to introduce lifetime issues, i.e. if the MemProfRecords outlive the RawMemProfReader the symbol name StringRef would be a dangling pointer. I'll leave it as is for now.

llvm/include/llvm/ProfileData/MemProf.h

 using FrameId = uint64_t;
 // Describes a call frame for a dynamic allocation context. The contents of
 // the frame are populated by symbolizing the stack depot call frame from the
 // compiler runtime.
 struct Frame {
   // A uuid (uint64_t) identifying the function. It is obtained by
   // llvm::md5(FunctionName) which returns the lower 64 bits.
   GlobalValue::GUID Function;
+  // The symbol name for the function. Only populated in the Frame by the reader
+  // if requested during initialization. This field should not be serialized.
+  llvm::Optional<std::string> SymbolName;
   // The source line offset of the call from the beginning of parent function.
   uint32_t LineOffset;
   // The source column number of the call to help distinguish multiple calls
   // on the same line.
   uint32_t Column;
   // Whether the current frame is inlined.
   bool IsInlineFrame;
 
   Frame(const Frame &Other) {
     Function = Other.Function;
+    SymbolName = Other.SymbolName;
     LineOffset = Other.LineOffset;
     Column = Other.Column;
     IsInlineFrame = Other.IsInlineFrame;
   }
 
   Frame(uint64_t Hash, uint32_t Off, uint32_t Col, bool Inline)
       : Function(Hash), LineOffset(Off), Column(Col), IsInlineFrame(Inline) {}
 
   bool operator==(const Frame &Other) const {
+    // Ignore the SymbolName field to avoid a string compare. Comparing the
+    // function hash serves the same purpose.
     return Other.Function == Function && Other.LineOffset == LineOffset &&
            Other.Column == Column && Other.IsInlineFrame == IsInlineFrame;
   }
 
   Frame &operator=(const Frame &Other) {
     Function = Other.Function;
+    SymbolName = Other.SymbolName;
     LineOffset = Other.LineOffset;
     Column = Other.Column;
     IsInlineFrame = Other.IsInlineFrame;
     return *this;
   }
 
   bool operator!=(const Frame &Other) const { return !operator==(Other); }
 
static constexpr size_t serializedSize() {
     return sizeof(Frame::Function) + sizeof(Frame::LineOffset) +
            sizeof(Frame::Column) + sizeof(Frame::IsInlineFrame);
   }
 
   // Print the frame information in YAML format.
   void printYAML(raw_ostream &OS) const {
     OS << "      -\n"
        << "        Function: " << Function << "\n"
+       << "        SymbolName: "
+       << (SymbolName.hasValue() ? SymbolName.getValue() : "<None>") << "\n"
        << "        LineOffset: " << LineOffset << "\n"
        << "        Column: " << Column << "\n"
        << "        Inline: " << IsInlineFrame << "\n";
   }
 
   // Return a hash value based on the contents of the frame. Here we don't use
   // hashing from llvm ADT since we are going to persist the hash id, the hash
   // combine algorithm in ADT uses a new randomized seed each time.

llvm/include/llvm/ProfileData/RawMemProfReader.h

public:
   // Return true if the file at \p Path starts with magic bytes indicating it is
   // a raw binary memprof profile.
   static bool hasFormat(const StringRef Path);
 
   // Create a RawMemProfReader after sanity checking the contents of the file at
   // \p Path. The binary from which the profile has been collected is specified
   // via a path in \p ProfiledBinary.
   static Expected<std::unique_ptr<RawMemProfReader>>
-  create(const Twine &Path, const StringRef ProfiledBinary);
+  create(const Twine &Path, const StringRef ProfiledBinary,
+         bool KeepName = false);
 
   using GuidMemProfRecordPair = std::pair<GlobalValue::GUID, MemProfRecord>;
   using Iterator = InstrProfIterator<GuidMemProfRecordPair, RawMemProfReader>;
   Iterator end() { return Iterator(); }
   Iterator begin() {
     Iter = FunctionProfileData.begin();
     return Iterator(this);
   }
 
   Error readNextRecord(GuidMemProfRecordPair &GuidRecord);
 
   // The RawMemProfReader only holds memory profile information.
   InstrProfKind getProfileKind() const { return InstrProfKind::MemProf; }
 
   // Constructor for unittests only.
   RawMemProfReader(std::unique_ptr<llvm::symbolize::SymbolizableModule> Sym,
                    llvm::SmallVectorImpl<SegmentEntry> &Seg,
                    llvm::MapVector<uint64_t, MemInfoBlock> &Prof,
-                   CallStackMap &SM)
+                   CallStackMap &SM, bool KeepName = false)
       : Symbolizer(std::move(Sym)), SegmentInfo(Seg.begin(), Seg.end()),
-        CallstackProfileData(Prof), StackMap(SM) {
+        CallstackProfileData(Prof), StackMap(SM), KeepSymbolName(KeepName) {
     // We don't call initialize here since there is no raw profile to read. The
     // test should pass in the raw profile as structured data.
 
     // If there is an error here then the mock symbolizer has not been
     // initialized properly.
     if (Error E = symbolizeAndFilterStackFrames())
       report_fatal_error(std::move(E));
     if (Error E = mapRawProfileToRecords())
       report_fatal_error(std::move(E));
   }
 
   // Return a const reference to the internal Id to Frame mappings.
   const llvm::DenseMap<FrameId, Frame> &getFrameMapping() const {
     return IdToFrame;
   }
 
   // Return a const reference to the internal function profile data.
   const llvm::MapVector<GlobalValue::GUID, IndexedMemProfRecord> &
   getProfileData() const {
     return FunctionProfileData;
   }
 
 private:
   RawMemProfReader(std::unique_ptr<MemoryBuffer> DataBuffer,
-                   object::OwningBinary<object::Binary> &&Bin)
-      : DataBuffer(std::move(DataBuffer)), Binary(std::move(Bin)) {}
+                   object::OwningBinary<object::Binary> &&Bin, bool KeepName)
+      : DataBuffer(std::move(DataBuffer)), Binary(std::move(Bin)),
+        KeepSymbolName(KeepName) {}
   Error initialize();
   Error readRawProfile();
   // Symbolize and cache all the virtual addresses we encounter in the
   // callstacks from the raw profile. Also prune callstack frames which we can't
   // symbolize or those that belong to the runtime. For profile entries where
   // the entire callstack is pruned, we drop the entry from the profile.
   Error symbolizeAndFilterStackFrames();
   // Construct memprof records for each function and store it in the
private:
   CallStackMap StackMap;
 
   // Cached symbolization from PC to Frame.
   llvm::DenseMap<uint64_t, llvm::SmallVector<FrameId>> SymbolizedFrame;
   llvm::DenseMap<FrameId, Frame> IdToFrame;
 
   llvm::MapVector<GlobalValue::GUID, IndexedMemProfRecord> FunctionProfileData;
   llvm::MapVector<GlobalValue::GUID, IndexedMemProfRecord>::iterator Iter;
-};
 
+  // Whether to keep the symbol name for each frame after hashing.
+  bool KeepSymbolName = false;
+  // A mapping of the hash to symbol name, only used if KeepSymbolName is true.
+  llvm::DenseMap<uint64_t, std::string> GuidToSymbolName;
+};
 } // namespace memprof
 } // namespace llvm
 
 #endif // LLVM_PROFILEDATA_RAWMEMPROFREADER_H_

llvm/lib/ProfileData/RawMemProfReader.cpp

 //===- RawMemProfReader.cpp - Instrumented memory profiling reader --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for reading MemProf profiling data.
 //
 //===----------------------------------------------------------------------===//
 
 #include <algorithm>
 #include <cstdint>
+#include <memory>
 #include <type_traits>
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
 #include "llvm/DebugInfo/Symbolize/SymbolizableObjectFile.h"

 
 bool isRuntimePath(const StringRef Path) {
   return StringRef(llvm::sys::path::convert_to_slash(Path))
       .contains("memprof/memprof_");
 }
 } // namespace
 
 Expected<std::unique_ptr<RawMemProfReader>>
-RawMemProfReader::create(const Twine &Path, const StringRef ProfiledBinary) {
+RawMemProfReader::create(const Twine &Path, const StringRef ProfiledBinary,
+                         bool KeepName) {
   auto BufferOr = MemoryBuffer::getFileOrSTDIN(Path);
   if (std::error_code EC = BufferOr.getError())
     return report(errorCodeToError(EC), Path.getSingleStringRef());
 
   std::unique_ptr<MemoryBuffer> Buffer(BufferOr.get().release());
   if (Error E = checkBuffer(*Buffer))
     return report(std::move(E), Path.getSingleStringRef());
 
   if (ProfiledBinary.empty())
     return report(
         errorCodeToError(make_error_code(std::errc::invalid_argument)),
         "Path to profiled binary is empty!");
 
   auto BinaryOr = llvm::object::createBinary(ProfiledBinary);
   if (!BinaryOr) {
     return report(BinaryOr.takeError(), ProfiledBinary);
   }
 
-  std::unique_ptr<RawMemProfReader> Reader(
-      new RawMemProfReader(std::move(Buffer), std::move(BinaryOr.get())));
+  // Use new here since constructor is private.
+  std::unique_ptr<RawMemProfReader> Reader(new RawMemProfReader(
+      std::move(Buffer), std::move(BinaryOr.get()), KeepName));
   if (Error E = Reader->initialize()) {
     return std::move(E);
   }
   return std::move(Reader);
 }
 
 bool RawMemProfReader::hasFormat(const StringRef Path) {
   auto BufferOr = MemoryBuffer::getFileOrSTDIN(Path);
for (const uint64_t VAddr : Entry.getSecond()) {
           isRuntimePath(DI.getFrame(0).FileName)) {
         AllVAddrsToDiscard.insert(VAddr);
         continue;
       }
 
       for (size_t I = 0, NumFrames = DI.getNumberOfFrames(); I < NumFrames;
            I++) {
         const auto &DIFrame = DI.getFrame(I);
-        LLVM_DEBUG(
-            // Print out the name to guid mapping for debugging.
-            llvm::dbgs() << "FunctionName: " << DIFrame.FunctionName
-                         << " GUID: "
-                         << IndexedMemProfRecord::getGUID(DIFrame.FunctionName)
-                         << "\n";);
-
-        const Frame F(IndexedMemProfRecord::getGUID(DIFrame.FunctionName),
-                      DIFrame.Line - DIFrame.StartLine, DIFrame.Column,
+        const uint64_t Guid =
+            IndexedMemProfRecord::getGUID(DIFrame.FunctionName);
+        const Frame F(Guid, DIFrame.Line - DIFrame.StartLine, DIFrame.Column,
                       // Only the last entry is not an inlined location.
                       I != NumFrames - 1);
-
-        const FrameId Id = F.hash();
-        IdToFrame.insert({Id, F});
-        SymbolizedFrame[VAddr].push_back(Id);
+        // Here we retain a mapping from the GUID to symbol name instead of
+        // adding it to the frame object directly to reduce memory overhead.
+        // This is because there can be many unique frames, particularly for
+        // callsite frames.
+        if (KeepSymbolName)
+          GuidToSymbolName.insert({Guid, DIFrame.FunctionName});
+
+        const FrameId Hash = F.hash();
+        IdToFrame.insert({Hash, F});
+        SymbolizedFrame[VAddr].push_back(Hash);
       }
     }
 
     auto &CallStack = Entry.getSecond();
     CallStack.erase(std::remove_if(CallStack.begin(), CallStack.end(),
                                    [&AllVAddrsToDiscard](const uint64_t A) {
                                      return AllVAddrsToDiscard.contains(A);
                                    }),

 Error RawMemProfReader::readNextRecord(GuidMemProfRecordPair &GuidRecord) {
   if (FunctionProfileData.empty())
     return make_error<InstrProfError>(instrprof_error::empty_raw_profile);
 
   if (Iter == FunctionProfileData.end())
     return make_error<InstrProfError>(instrprof_error::eof);
 
   auto IdToFrameCallback = [this](const FrameId Id) {
-    return this->idToFrame(Id);
+    Frame F = this->idToFrame(Id);
+    if (!this->KeepSymbolName)
+      return F;
+    auto Iter = this->GuidToSymbolName.find(F.Function);
+    assert(Iter != this->GuidToSymbolName.end());
+    F.SymbolName = Iter->getSecond();
+    return F;
   };
+
   const IndexedMemProfRecord &IndexedRecord = Iter->second;
   GuidRecord = {Iter->first, MemProfRecord(IndexedRecord, IdToFrameCallback)};
   Iter++;
   return Error::success();
 }
 } // namespace memprof
 } // namespace llvm

llvm/test/tools/llvm-profdata/memprof-basic.test

 CHECK-NEXT:   Records:
 CHECK-NEXT:   -
 CHECK-NEXT:     FunctionGUID: {{[0-9]+}}
 CHECK-NEXT:     AllocSites:
 CHECK-NEXT:     -
 CHECK-NEXT:       Callstack:
 CHECK-NEXT:       -
 CHECK-NEXT:         Function: {{[0-9]+}}
+CHECK-NEXT:         SymbolName: main
 CHECK-NEXT:         LineOffset: 1
 CHECK-NEXT:         Column: 21
 CHECK-NEXT:         Inline: 0
 CHECK-NEXT:       MemInfoBlock:
 CHECK-NEXT:         AllocCount: 1
 CHECK-NEXT:         TotalAccessCount: 2
 CHECK-NEXT:         MinAccessCount: 2
 CHECK-NEXT:         MaxAccessCount: 2

 CHECK-NEXT:         NumLifetimeOverlaps: 0
 CHECK-NEXT:         NumSameAllocCpu: 0
 CHECK-NEXT:         NumSameDeallocCpu: 0
 CHECK-NEXT:         DataTypeId: {{[0-9]+}}
 CHECK-NEXT:     -
 CHECK-NEXT:       Callstack:
 CHECK-NEXT:       -
 CHECK-NEXT:         Function: {{[0-9]+}}
+CHECK-NEXT:         SymbolName: main
 CHECK-NEXT:         LineOffset: 5
 CHECK-NEXT:         Column: 15
 CHECK-NEXT:         Inline: 0
 CHECK-NEXT:       MemInfoBlock:
 CHECK-NEXT:         AllocCount: 1
 CHECK-NEXT:         TotalAccessCount: 2
 CHECK-NEXT:         MinAccessCount: 2
 CHECK-NEXT:         MaxAccessCount: 2

llvm/test/tools/llvm-profdata/memprof-inline.test

 ```
 bin/clang -fuse-ld=lld -Wl,--no-rosegment -gmlt -fdebug-info-for-profiling \
           -fmemory-profile -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer \
           -fno-optimize-sibling-calls -m64 -Wl,-build-id inline.c -o memprof-inline.exe
 
 env MEMPROF_OPTIONS=log_path=stdout ./memprof-inline.exe > inline.memprofraw
 ```
 
-From a debug run we collect the name to guid mappings to ensure that the
-ordering we observe is as expected.
-
-```
-build-dbg/bin/llvm-profdata show --memory --debug-only=memprof \
-          inline.memprofraw --profiled-binary memprof-inline.exe
-
-FunctionName: qux GUID: 15505678318020221912
-FunctionName: foo GUID: 6699318081062747564
-FunctionName: bar GUID: 16434608426314478903
-FunctionName: main GUID: 15822663052811949562
-
-[..omit output here which is checked below..]
-```
-
 RUN: llvm-profdata show --memory %p/Inputs/inline.memprofraw --profiled-binary %p/Inputs/inline.memprofexe | FileCheck %s
 
 CHECK:  MemprofProfile:
 CHECK-NEXT:  -
 CHECK-NEXT:  Header:
 CHECK-NEXT:    Version: 1
 CHECK-NEXT:    TotalSizeBytes: 880
 CHECK-NEXT:    NumSegments: 9
 CHECK-NEXT:    NumMibInfo: 2
 CHECK-NEXT:    NumStackOffsets: 2
 CHECK-NEXT:  Records:
 CHECK-NEXT:  -
 CHECK-NEXT:    FunctionGUID: 15505678318020221912
 CHECK-NEXT:    AllocSites:
 CHECK-NEXT:    -
 CHECK-NEXT:      Callstack:
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 15505678318020221912
+CHECK-NEXT:        SymbolName: qux
 CHECK-NEXT:        LineOffset: 1
 CHECK-NEXT:        Column: 15
 CHECK-NEXT:        Inline: 1
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 6699318081062747564
+CHECK-NEXT:        SymbolName: foo
 CHECK-NEXT:        LineOffset: 0
 CHECK-NEXT:        Column: 18
 CHECK-NEXT:        Inline: 0
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 16434608426314478903
+CHECK-NEXT:        SymbolName: bar
 CHECK-NEXT:        LineOffset: 0
 CHECK-NEXT:        Column: 19
 CHECK-NEXT:        Inline: 0
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 15822663052811949562
+CHECK-NEXT:        SymbolName: main
 CHECK-NEXT:        LineOffset: 1
 CHECK-NEXT:        Column: 3
 CHECK-NEXT:        Inline: 0
 CHECK-NEXT:      MemInfoBlock:
 CHECK-NEXT:        AllocCount: 1
 CHECK-NEXT:        TotalAccessCount: 1
 CHECK-NEXT:        MinAccessCount: 1
 CHECK-NEXT:        MaxAccessCount: 1

 CHECK-NEXT:        DataTypeId: {{[0-9]+}}
 CHECK-NEXT:  -
 CHECK-NEXT:    FunctionGUID: 6699318081062747564
 CHECK-NEXT:    AllocSites:
 CHECK-NEXT:    -
 CHECK-NEXT:      Callstack:
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 15505678318020221912
+CHECK-NEXT:        SymbolName: qux
 CHECK-NEXT:        LineOffset: 1
 CHECK-NEXT:        Column: 15
 CHECK-NEXT:        Inline: 1
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 6699318081062747564
+CHECK-NEXT:        SymbolName: foo
 CHECK-NEXT:        LineOffset: 0
 CHECK-NEXT:        Column: 18
 CHECK-NEXT:        Inline: 0
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 16434608426314478903
+CHECK-NEXT:        SymbolName: bar
 CHECK-NEXT:        LineOffset: 0
 CHECK-NEXT:        Column: 19
 CHECK-NEXT:        Inline: 0
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 15822663052811949562
+CHECK-NEXT:        SymbolName: main
 CHECK-NEXT:        LineOffset: 1
 CHECK-NEXT:        Column: 3
 CHECK-NEXT:        Inline: 0
 CHECK-NEXT:      MemInfoBlock:
 CHECK-NEXT:        AllocCount: 1
 CHECK-NEXT:        TotalAccessCount: 1
 CHECK-NEXT:        MinAccessCount: 1
 CHECK-NEXT:        MaxAccessCount: 1

 CHECK-NEXT:        NumLifetimeOverlaps: 0
 CHECK-NEXT:        NumSameAllocCpu: 0
 CHECK-NEXT:        NumSameDeallocCpu: 0
 CHECK-NEXT:        DataTypeId: {{[0-9]+}}
 CHECK-NEXT:    CallSites:
 CHECK-NEXT:    -
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 15505678318020221912
+CHECK-NEXT:        SymbolName: qux
 CHECK-NEXT:        LineOffset: 1
 CHECK-NEXT:        Column: 15
 CHECK-NEXT:        Inline: 1
 CHECK-NEXT:    -
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 6699318081062747564
+CHECK-NEXT:        SymbolName: foo
 CHECK-NEXT:        LineOffset: 0
 CHECK-NEXT:        Column: 18
 CHECK-NEXT:        Inline: 0
 CHECK-NEXT:  -
 CHECK-NEXT:    FunctionGUID: 15822663052811949562
 CHECK-NEXT:    CallSites:
 CHECK-NEXT:    -
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 15822663052811949562
+CHECK-NEXT:        SymbolName: main
 CHECK-NEXT:        LineOffset: 1
 CHECK-NEXT:        Column: 3
 CHECK-NEXT:        Inline: 0
 CHECK-NEXT:  -
 CHECK-NEXT:    FunctionGUID: 16434608426314478903
 CHECK-NEXT:    CallSites:
 CHECK-NEXT:    -
 CHECK-NEXT:      -
 CHECK-NEXT:        Function: 16434608426314478903
+CHECK-NEXT:        SymbolName: bar
 CHECK-NEXT:        LineOffset: 0
 CHECK-NEXT:        Column: 19
 CHECK-NEXT:        Inline: 0

llvm/tools/llvm-profdata/llvm-profdata.cpp

if (ShowHotFuncList || TopN)
     showHotFunctionList(Reader->getProfiles(), Reader->getSummary(), TopN, OS);
 
   return 0;
 }
 
 static int showMemProfProfile(const std::string &Filename,
                               const std::string &ProfiledBinary,
                               raw_fd_ostream &OS) {
-  auto ReaderOr =
-      llvm::memprof::RawMemProfReader::create(Filename, ProfiledBinary);
+  auto ReaderOr = llvm::memprof::RawMemProfReader::create(
+      Filename, ProfiledBinary, /*KeepNames=*/true);
   if (Error E = ReaderOr.takeError())
     // Since the error can be related to the profile or the binary we do not
     // pass whence. Instead additional context is provided where necessary in
     // the error message.
     exitWithError(std::move(E), /*Whence*/ "");
 
   std::unique_ptr<llvm::memprof::RawMemProfReader> Reader(
       ReaderOr.get().release());

llvm/unittests/ProfileData/MemProfTest.cpp

 MATCHER_P4(FrameContains, FunctionName, LineOffset, Column, Inline, "") {
   const Frame &F = arg;
 
   const uint64_t ExpectedHash = llvm::Function::getGUID(FunctionName);
   if (F.Function != ExpectedHash) {
     *result_listener << "Hash mismatch";
     return false;
   }
+  if (F.SymbolName.hasValue() && F.SymbolName.getValue() != FunctionName) {
+    *result_listener << "SymbolName mismatch\nWant: " << FunctionName
+                     << "\nGot: " << F.SymbolName.getValue();
+    return false;
+  }
   if (F.LineOffset == LineOffset && F.Column == Column &&
       F.IsInlineFrame == Inline) {
     return true;
   }
   *result_listener << "LineOffset, Column or Inline mismatch";
   return false;
 }
 
TEST(MemProf, FillsValue) {
   CallStackMap CSM;
   CSM[0x1] = {0x1000, 0x2000, 0x3000};
 
   llvm::MapVector<uint64_t, MemInfoBlock> Prof;
   Prof[0x1].AllocCount = 1;
 
   auto Seg = makeSegments();
 
-  RawMemProfReader Reader(std::move(Symbolizer), Seg, Prof, CSM);
+  RawMemProfReader Reader(std::move(Symbolizer), Seg, Prof, CSM,
+                          /*KeepName=*/true);
 
   llvm::DenseMap<llvm::GlobalValue::GUID, MemProfRecord> Records;
   for (const auto &Pair : Reader) {
     Records.insert({Pair.first, Pair.second});
   }
 
   // Mock program psuedocode and expected memprof record contents.
   //