[ProfileData] Read and symbolize raw memprof profiles.

[snehasish]

Summary

This change extends the RawMemProfReader to read all the sections of the
raw profile and symbolize the virtual addresses recorded as part of the
callstack for each allocation. For now the symbolization is used to
display the contents of the profile with llvm-profdata.

[snehasish]

Rebase on parent changes.

[tejohnson]

llvm/include/llvm/ProfileData/MemProf.h

28

Can you elaborate on this and what will change?

llvm/include/llvm/ProfileData/RawMemProfReader.h

82

Where is this defined/called?

97

Suggest comment on what is the map key (the uint64_t).

101

Nit: there are a bunch of locals also named "Next" in various methods. For clarity suggest renaming this to something more unique.

llvm/lib/ProfileData/RawMemProfReader.cpp

183

Why IsText = true for the raw file? Not sure of the implications.

328

What is the implication of "UndefSection"?

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

34

I assume basic.memprofexe == rawprofile.out from above?

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

36

multi.memprofexe == rawprofile.out?

[davidxl]

llvm/include/llvm/ProfileData/MemProf.h

43

To handle deep stacks, perhaps make one line per frame (with indentation to show level)?

51

This TODO needs more explanation.

llvm/include/llvm/ProfileData/RawMemProfReader.h

33

Document key and value in the map?

llvm/lib/ProfileData/RawMemProfReader.cpp

92

document the method.

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

47

Is this line correct? where is the source file to validate?

65

unit of the time?

68

is cpuid this big?

[snehasish]

Rebase on changes, update the YAML output from snake case to LLVM variable naming style.

[snehasish]

Address comments.

[snehasish]

PTAL, thanks!

llvm/include/llvm/ProfileData/MemProf.h

28

I shared D117256 which has the implementation referred to in this TODO. I've added a wrapper around the MemInfoBlock. This wrapper makes it easy to read a prior version of a MemInfoBlock from binary data when the schema is provided. It allows us to specify on a per field basis what to write to (or read from) an indexed profile. PTAL, thanks!

43

That's a neat idea, I found out that YAML supports flow style (like JSON) so I can put Function, LineOffset, Column and Inline on the same line. I've put in a TODO for now since the YAML format is only used in tests (max stack depth = 3) and I don't have a unittest to verify the validity of the YAML we generate.

51

In D117256 I replaced this print with a call to the printYAML method of the MemInfoBlock wrapper (PortableMemInfoBlock). There I used a macro based generation of code for what fields need to be printed out. Let me know if you want me to clarify further or any other changes in this patch.

llvm/include/llvm/ProfileData/RawMemProfReader.h

82

Removed, leftover from code I deleted.

101

Good idea, renamed to Iter (and renamed a local which was Iter to I).

llvm/lib/ProfileData/RawMemProfReader.cpp

183

Good catch, this param controls whether line endings are detected when the file is read [1]. Since we are working with binary files it doesn't seem to have any impact though. Updated to remove the param to default to false.

[1] https://github.com/llvm/llvm-project/blob/345223a7be3c3c93a10f8453d96287a3a03b6754/llvm/lib/Support/MemoryBuffer.cpp#L254

328

It instructs the lookup to use absolute addresses. I believe the line table lookup happens here [1]. I also noticed that the default constructor for SectionedAddress sets it to UndefSection by default so I removed the second param here.

[1] https://github.com/llvm/llvm-project/blob/ee02cf0797712bb3a4b0686f185794fcb0fd3d9e/llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp#L1248

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

34

Also updated the multi test.

47

The callstack contains frames from the user code (provided at the top of this file), the compiler runtime interceptors and/or shared libraries. I can confirm that the line numbers are correct for all locations which are symbolized from the main binary i.e user program and compiler runtime linked in statically. Some locations below have line and column set to 0 which are from shared libs. Let me know if there is anything I can change to make this clearer.

65

The timestamp should be ms. Let me look into this a bit more.

68

It shouldn't be, this is 2^32-1 so let me check whats going on here.

[tejohnson]

llvm/lib/ProfileData/RawMemProfReader.cpp

183

I see the second param removed only for the call to getFileOrSTDIN in create(), not here in hasFormat().

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

61

Do these lines need to be updated to reflect D117256?

65

The runtime reports the lifetimes in ms

[snehasish]

Update the YAML test with LLVM var style tags.
Address comments.

[snehasish]

PTAL, thanks!

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

68

The cpuid is unavailable since the allocation we captured occurs when memprof has not been fully initialized [1].

[1] https://github.com/llvm/llvm-project/blob/c7b71acef2685ca59830b5b59c6214b6dac474a2/compiler-rt/lib/memprof/memprof_allocator.cpp#L45

[tejohnson]

Are you planning to rebase this on top of D117256?

[snehasish]

In D116784#3256775, @tejohnson wrote:

Are you planning to rebase this on top of D117256?

I was not planning on doing so. The changes which succeed this one evolve the MemInfoBlock data structure and aren't necessary to make this work. They are needed for the next patch which adds MemProfRecords to the indexed format. Do you see a particular advantage in having it the other way around?

[tejohnson]

In D116784#3258887, @snehasish wrote:

In D116784#3256775, @tejohnson wrote:

Are you planning to rebase this on top of D117256?

I was not planning on doing so. The changes which succeed this one evolve the MemInfoBlock data structure and aren't necessary to make this work. They are needed for the next patch which adds MemProfRecords to the indexed format. Do you see a particular advantage in having it the other way around?

Ah, I messed up the stack ordering of the patches. This seems fine. LGTM but please wait to see if @davidxl has any follow on comments.

[thakis]

llvm/lib/ProfileData/CMakeLists.txt

21

Object is already present 3 lines further down. Maybe alphabetize this list and remove the dupe :)

[thakis]

llvm/lib/ProfileData/CMakeLists.txt

25

This dependency is a problem. At the moment, Symbolize adds a dep to libcurl, and clang transitiviely depends on llvm/lib/ProfileData. So this makes clang depend on libcurl (even in statically linked builds), which is something we want to avoid. See also the discussion on D113717 (in particular, https://reviews.llvm.org/D113717#3295350).

Since this likely has no super quick fix, would you mind reverting this until that dependency can be prevented somehow?

[snehasish]

llvm/lib/ProfileData/CMakeLists.txt

21

I sorted and deduped this list but that broke the clang ppc buildbot so I reverted the change.

https://reviews.llvm.org/rG55de669660cb1523cf83c98e8c0cb133ec279383

25

I assume you mean this patch and not the sort/dedupe suggestion above. Reading through the discussion then we would have to wait for a refactoring to move the libcurl dep to llvm-symbolize instead of debuginfod. Is it possible to split debuginfod out of Symbolize so that we can unblock this patch sooner?

[thakis]

llvm/lib/ProfileData/CMakeLists.txt

25

From what I understand, that refactoring should be fairly small (make Symbolize take a default-noop "FetchSymbols" callback instead of calling Debuginfod directly, change llvm-symbolize to pass in a function that calls Debuginfod instead, remove dep from Symbolize on Debuginfod. For bonus points, tweak the cmake setup so that Debuginfod isn't linked into libllvm by default, but that's not needed for your use case here). I can't think of a much smaller change to unblock things.

llvm/include/llvm/DebugInfo/DIContext.h

struct DILineInfoSpecifier {
   using FunctionNameKind = DINameKind;
 
   FileLineInfoKind FLIKind;
   FunctionNameKind FNKind;
 
   DILineInfoSpecifier(FileLineInfoKind FLIKind = FileLineInfoKind::RawValue,
                       FunctionNameKind FNKind = FunctionNameKind::None)
       : FLIKind(FLIKind), FNKind(FNKind) {}
+
+  inline bool operator==(const DILineInfoSpecifier &RHS) const {
+    return FLIKind == RHS.FLIKind && FNKind == RHS.FNKind;
+  }
 };
 
 /// This is just a helper to programmatically construct DIDumpType.
 enum DIDumpTypeCounter {
 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME, OPTION)        \
   DIDT_ID_##ENUM_NAME,
 #include "llvm/BinaryFormat/Dwarf.def"
 #undef HANDLE_DWARF_SECTION

llvm/include/llvm/ProfileData/MemProf.h

+#ifndef LLVM_PROFILEDATA_MEMPROF_H_
+#define LLVM_PROFILEDATA_MEMPROF_H_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "llvm/ProfileData/MemProfData.inc"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+namespace memprof {
+
+struct MemProfRecord {
+  struct Frame {
+    std::string Function;
+    uint32_t LineOffset;
+    uint32_t Column;
+    bool IsInlineFrame;
+
+    Frame(std::string Str, uint32_t Off, uint32_t Col, bool Inline)
+        : Function(std::move(Str)), LineOffset(Off), Column(Col),
+          IsInlineFrame(Inline) {}
+  };
+
+  std::vector<Frame> CallStack;
+  // TODO: Replace this with the entry format described in the RFC so
+  // that the InstrProfRecord reader and writer do not have to be concerned
+  // about backwards compat.
+  MemInfoBlock Info;
+
+  void clear() {
+    CallStack.clear();
+    Info = MemInfoBlock();
+  }
+
+  // Prints out the contents of the memprof record in YAML.
+  void print(llvm::raw_ostream &OS) const {
+    OS << "    Callstack:\n";
+    // TODO: Print out the frame on one line with to make it easier for deep
+    // callstacks once we have a test to check valid YAML is generated.
+    for (const auto &Frame : CallStack) {
+      OS << "    -\n"
+         << "      Function: " << Frame.Function << "\n"
+         << "      LineOffset: " << Frame.LineOffset << "\n"
+         << "      Column: " << Frame.Column << "\n"
+         << "      Inline: " << Frame.IsInlineFrame << "\n";
+    }
+
+    OS << "    MemInfoBlock:\n";
+
+    // TODO: Replace this once the format is updated to be version agnostic.
+    OS << "      "
+       << "AllocCount: " << Info.alloc_count << "\n";
+    OS << "      "
+       << "TotalAccessCount: " << Info.total_access_count << "\n";
+    OS << "      "
+       << "MinAccessCount: " << Info.min_access_count << "\n";
+    OS << "      "
+       << "MaxAccessCount: " << Info.max_access_count << "\n";
+    OS << "      "
+       << "TotalSize: " << Info.total_size << "\n";
+    OS << "      "
+       << "MinSize: " << Info.min_size << "\n";
+    OS << "      "
+       << "MaxSize: " << Info.max_size << "\n";
+    OS << "      "
+       << "AllocTimestamp: " << Info.alloc_timestamp << "\n";
+    OS << "      "
+       << "DeallocTimestamp: " << Info.dealloc_timestamp << "\n";
+    OS << "      "
+       << "TotalLifetime: " << Info.total_lifetime << "\n";
+    OS << "      "
+       << "MinLifetime: " << Info.min_lifetime << "\n";
+    OS << "      "
+       << "MaxLifetime: " << Info.max_lifetime << "\n";
+    OS << "      "
+       << "AllocCpuId: " << Info.alloc_cpu_id << "\n";
+    OS << "      "
+       << "DeallocCpuId: " << Info.dealloc_cpu_id << "\n";
+    OS << "      "
+       << "NumMigratedCpu: " << Info.num_migrated_cpu << "\n";
+    OS << "      "
+       << "NumLifetimeOverlaps: " << Info.num_lifetime_overlaps << "\n";
+    OS << "      "
+       << "NumSameAllocCpu: " << Info.num_same_alloc_cpu << "\n";
+    OS << "      "
+       << "NumSameDeallocCpu: " << Info.num_same_dealloc_cpu << "\n";
+  }
+};
+
+} // namespace memprof
+} // namespace llvm
+
+#endif // LLVM_PROFILEDATA_MEMPROF_H_

llvm/include/llvm/ProfileData/RawMemProfReader.h

 #ifndef LLVM_PROFILEDATA_RAWMEMPROFREADER_H_
 #define LLVM_PROFILEDATA_RAWMEMPROFREADER_H_
 //===- MemProfReader.h - Instrumented memory profiling reader ---*- C++ -*-===//
 //
 // 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 "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/MapVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
+#include "llvm/DebugInfo/Symbolize/Symbolize.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/ProfileData/InstrProfReader.h"
+#include "llvm/ProfileData/MemProf.h"
+#include "llvm/ProfileData/MemProfData.inc"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 
+#include <cstddef>
+
 namespace llvm {
 namespace memprof {
 
+// Map from id (recorded from sanitizer stack depot) to virtual addresses for
+// each program counter address in the callstack.
+using CallStackMap = llvm::DenseMap<uint64_t, llvm::SmallVector<uint64_t, 32>>;
+
 class RawMemProfReader {
 public:
   RawMemProfReader(std::unique_ptr<MemoryBuffer> DataBuffer)
       : DataBuffer(std::move(DataBuffer)) {}
+  RawMemProfReader(const RawMemProfReader &) = delete;
+  RawMemProfReader &operator=(const RawMemProfReader &) = delete;
+
   // Prints the contents of the profile in YAML format.
   void printYAML(raw_ostream &OS);
 
   // Return true if the \p DataBuffer starts with magic bytes indicating it is
   // a raw binary memprof profile.
   static bool hasFormat(const MemoryBuffer &DataBuffer);
+  // 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.
-  static Expected<std::unique_ptr<RawMemProfReader>> create(const Twine &Path);
+  // \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);
+
+  Error readNextRecord(MemProfRecord &Record);
+
+  using Iterator = InstrProfIterator<MemProfRecord, RawMemProfReader>;
+  Iterator end() { return Iterator(); }
+  Iterator begin() {
+    Iter = ProfileData.begin();
+    return Iterator(this);
+  }
+
+  // Constructor for unittests only.
+  RawMemProfReader(std::unique_ptr<llvm::symbolize::SymbolizableModule> Sym,
+                   llvm::SmallVectorImpl<SegmentEntry> &Seg,
+                   llvm::MapVector<uint64_t, MemInfoBlock> &Prof,
+                   CallStackMap &SM)
+      : Symbolizer(std::move(Sym)), SegmentInfo(Seg.begin(), Seg.end()),
+        ProfileData(Prof), StackMap(SM) {}
 
 private:
+  RawMemProfReader(std::unique_ptr<MemoryBuffer> DataBuffer,
+                   object::OwningBinary<object::Binary> &&Bin)
+      : DataBuffer(std::move(DataBuffer)), Binary(std::move(Bin)) {}
+  Error initialize();
+  Error readRawProfile();
+
+  object::SectionedAddress getModuleOffset(uint64_t VirtualAddress);
+  Error fillRecord(const uint64_t Id, const MemInfoBlock &MIB,
+                   MemProfRecord &Record);
   // Prints aggregate counts for each raw profile parsed from the DataBuffer in
   // YAML format.
   void printSummaries(raw_ostream &OS) const;
 
   std::unique_ptr<MemoryBuffer> DataBuffer;
+  object::OwningBinary<object::Binary> Binary;
+  std::unique_ptr<llvm::symbolize::SymbolizableModule> Symbolizer;
+
+  // The contents of the raw profile.
+  llvm::SmallVector<SegmentEntry, 16> SegmentInfo;
+  // A map from callstack id (same as key in CallStackMap below) to the heap
+  // information recorded for that allocation context.
+  llvm::MapVector<uint64_t, MemInfoBlock> ProfileData;
+  CallStackMap StackMap;
+
+  // Iterator to read from the ProfileData MapVector.
+  llvm::MapVector<uint64_t, MemInfoBlock>::iterator Iter = ProfileData.end();
 };
 
 } // namespace memprof
 } // namespace llvm
 
 #endif // LLVM_PROFILEDATA_RAWMEMPROFREADER_H_

llvm/lib/ProfileData/CMakeLists.txt

add_llvm_component_library(LLVMProfileData
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ProfileData
 
   DEPENDS
   intrinsics_gen
 
   LINK_COMPONENTS
   Core
+  Object
   Support
   Demangle
   Object
+  Symbolize
   DebugInfoDWARF
   )
 
 add_subdirectory(Coverage)

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 <cstdint>
 #include <type_traits>
 
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
+#include "llvm/DebugInfo/Symbolize/SymbolizableObjectFile.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/ObjectFile.h"
 #include "llvm/ProfileData/InstrProf.h"
+#include "llvm/ProfileData/MemProf.h"
 #include "llvm/ProfileData/MemProfData.inc"
 #include "llvm/ProfileData/RawMemProfReader.h"
+#include "llvm/Support/MD5.h"
 
 namespace llvm {
 namespace memprof {
 namespace {
 
 struct Summary {
   uint64_t Version;
   uint64_t TotalSizeBytes;
return Summary{
       H->Version,
       H->TotalSize,
       alignedRead(Start + H->SegmentOffset),
       alignedRead(Start + H->MIBOffset),
       alignedRead(Start + H->StackOffset),
   };
 }
 
-} // namespace
-
-Expected<std::unique_ptr<RawMemProfReader>>
-RawMemProfReader::create(const Twine &Path) {
-  auto BufferOr = MemoryBuffer::getFileOrSTDIN(Path, /*IsText=*/true);
-  if (std::error_code EC = BufferOr.getError())
-    return errorCodeToError(EC);
-
-  std::unique_ptr<MemoryBuffer> Buffer(BufferOr.get().release());
+Error checkBuffer(const MemoryBuffer &Buffer) {
+  if (!RawMemProfReader::hasFormat(Buffer))
+    return make_error<InstrProfError>(instrprof_error::bad_magic);
 
-  if (Buffer->getBufferSize() == 0)
+  if (Buffer.getBufferSize() == 0)
     return make_error<InstrProfError>(instrprof_error::empty_raw_profile);
 
-  if (!RawMemProfReader::hasFormat(*Buffer))
-    return make_error<InstrProfError>(instrprof_error::bad_magic);
-
-  if (Buffer->getBufferSize() < sizeof(Header)) {
+  if (Buffer.getBufferSize() < sizeof(Header)) {
     return make_error<InstrProfError>(instrprof_error::truncated);
   }
 
   // The size of the buffer can be > header total size since we allow repeated
   // serialization of memprof profiles to the same file.
   uint64_t TotalSize = 0;
-  const char *Next = Buffer->getBufferStart();
-  while (Next < Buffer->getBufferEnd()) {
+  const char *Next = Buffer.getBufferStart();
+  while (Next < Buffer.getBufferEnd()) {
     auto *H = reinterpret_cast<const Header *>(Next);
     if (H->Version != MEMPROF_RAW_VERSION) {
       return make_error<InstrProfError>(instrprof_error::unsupported_version);
     }
 
     TotalSize += H->TotalSize;
     Next += H->TotalSize;
   }
 
-  if (Buffer->getBufferSize() != TotalSize) {
+  if (Buffer.getBufferSize() != TotalSize) {
     return make_error<InstrProfError>(instrprof_error::malformed);
   }
+  return Error::success();
+}
+
+// A generic method to read binary data for type T where the first 8b indicate
+// the number of elements of type T to be read.
+template <typename T> llvm::SmallVector<T, 16> readInfo(const char *Begin) {
+  const uint64_t NumItemsToRead = *reinterpret_cast<const uint64_t *>(Begin);
+  const char *Ptr = Begin + sizeof(uint64_t);
+  llvm::SmallVector<T, 16> Items;
+  for (uint64_t I = 0; I < NumItemsToRead; I++) {
+    Items.emplace_back(*reinterpret_cast<const T *>(Ptr + I * sizeof(T)));
+  }
+  return Items;
+}
+
+CallStackMap readStackInfo(const char *Begin) {
+  const uint64_t NumItemsToRead = *reinterpret_cast<const uint64_t *>(Begin);
+  char *Ptr = const_cast<char *>(Begin) + sizeof(uint64_t);
+  CallStackMap Items;
+
+  uint64_t Count = 0;
+  do {
+    const uint64_t StackId = alignedRead(Ptr);
+    Ptr += sizeof(uint64_t);
+
+    const uint64_t NumPCs = alignedRead(Ptr);
+    Ptr += sizeof(uint64_t);
+
+    SmallVector<uint64_t, 32> CallStack;
+    for (uint64_t I = 0; I < NumPCs; I++) {
+      CallStack.push_back(alignedRead(Ptr));
+      Ptr += sizeof(uint64_t);
+    }
+
+    Items[StackId] = CallStack;
+  } while (++Count < NumItemsToRead);
+  return Items;
+}
+
+// Merges the contents of stack information in \p From to \p To. Returns true if
+// any stack ids observed previously map to a different set of program counter
+// addresses.
+bool mergeStackMap(const CallStackMap &From, CallStackMap &To) {
+  for (const auto &IdStack : From) {
+    auto I = To.find(IdStack.first);
+    if (I == To.end()) {
+      To[IdStack.first] = IdStack.second;
+    } else {
+      // Check that the PCs are the same (in order).
+      if (IdStack.second != I->second)
+        return true;
+    }
+  }
+  return false;
+}
+
+StringRef trimSuffix(const StringRef Name) {
+  const auto Pos = Name.find(".llvm.");
+  return Name.take_front(Pos);
+}
+
+Error report(Error E, const StringRef Context) {
+  return joinErrors(createStringError(inconvertibleErrorCode(), Context),
+                    std::move(E));
+}
+} // namespace
+
+Expected<std::unique_ptr<RawMemProfReader>>
+RawMemProfReader::create(const Twine &Path, const StringRef ProfiledBinary) {
+  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())));
+  if (Error E = Reader->initialize()) {
+    return std::move(E);
+  }
+  return std::move(Reader);
+}
+
+bool RawMemProfReader::hasFormat(const StringRef Path) {
+  auto BufferOr = MemoryBuffer::getFileOrSTDIN(Path);
+  if (!BufferOr)
+    return false;
 
-  return std::make_unique<RawMemProfReader>(std::move(Buffer));
+  std::unique_ptr<MemoryBuffer> Buffer(BufferOr.get().release());
+  return hasFormat(*Buffer);
 }
 
 bool RawMemProfReader::hasFormat(const MemoryBuffer &Buffer) {
   if (Buffer.getBufferSize() < sizeof(uint64_t))
     return false;
   // Aligned read to sanity check that the buffer was allocated with at least 8b
   // alignment.
   const uint64_t Magic = alignedRead(Buffer.getBufferStart());
   return Magic == MEMPROF_RAW_MAGIC_64;
 }
 
 void RawMemProfReader::printYAML(raw_ostream &OS) {
   OS << "MemprofProfile:\n";
   printSummaries(OS);
+  // Print out the merged contents of the profiles.
+  OS << "  Records:\n";
+  for (const auto &Record : *this) {
+    OS << "  -\n";
+    Record.print(OS);
+  }
 }
 
 void RawMemProfReader::printSummaries(raw_ostream &OS) const {
   const char *Next = DataBuffer->getBufferStart();
   while (Next < DataBuffer->getBufferEnd()) {
     auto Summary = computeSummary(Next);
     OS << "  -\n";
     OS << "  Header:\n";
     OS << "    Version: " << Summary.Version << "\n";
     OS << "    TotalSizeBytes: " << Summary.TotalSizeBytes << "\n";
     OS << "    NumSegments: " << Summary.NumSegments << "\n";
     OS << "    NumMibInfo: " << Summary.NumMIBInfo << "\n";
     OS << "    NumStackOffsets: " << Summary.NumStackOffsets << "\n";
     // TODO: Print the build ids once we can record them using the
     // sanitizer_procmaps library for linux.
 
     auto *H = reinterpret_cast<const Header *>(Next);
     Next += H->TotalSize;
   }
 }
 
+Error RawMemProfReader::initialize() {
+  const StringRef FileName = Binary.getBinary()->getFileName();
+
+  auto *ElfObject = dyn_cast<object::ELFObjectFileBase>(Binary.getBinary());
+  if (!ElfObject) {
+    return report(make_error<StringError>(Twine("Not an ELF file: "),
+                                          inconvertibleErrorCode()),
+                  FileName);
+  }
+
+  auto Triple = ElfObject->makeTriple();
+  if (!Triple.isX86())
+    return report(make_error<StringError>(Twine("Unsupported target: ") +
+                                              Triple.getArchName(),
+                                          inconvertibleErrorCode()),
+                  FileName);
+
+  auto *Object = cast<object::ObjectFile>(Binary.getBinary());
+  std::unique_ptr<DIContext> Context = DWARFContext::create(
+      *Object, DWARFContext::ProcessDebugRelocations::Process);
+
+  auto SOFOr = symbolize::SymbolizableObjectFile::create(
+      Object, std::move(Context), /*UntagAddresses=*/false);
+  if (!SOFOr)
+    return report(SOFOr.takeError(), FileName);
+  Symbolizer = std::move(SOFOr.get());
+
+  return readRawProfile();
+}
+
+Error RawMemProfReader::readRawProfile() {
+  const char *Next = DataBuffer->getBufferStart();
+
+  while (Next < DataBuffer->getBufferEnd()) {
+    auto *Header = reinterpret_cast<const memprof::Header *>(Next);
+
+    // Read in the segment information, check whether its the same across all
+    // profiles in this binary file.
+    if (SegmentInfo.empty()) {
+      SegmentInfo = readInfo<SegmentEntry>(Next + Header->SegmentOffset);
+    } else {
+      auto Info = readInfo<SegmentEntry>(Next + Header->SegmentOffset);
+      // We do not expect segment information to change when deserializing from
+      // the same binary profile file. This can happen if dynamic libraries are
+      // loaded/unloaded between profile dumping.
+      if (SegmentInfo != Info) {
+        return make_error<InstrProfError>(instrprof_error::malformed);
+      }
+    }
+
+    // Read in the MemInfoBlocks. Merge them based on stack id - we assume that
+    // raw profiles in the same binary file are from the same process so the
+    // stackdepot ids are the same.
+    PACKED(struct IDAndMIB {
+      uint64_t Id;
+      MemInfoBlock MIB;
+    });
+    for (const auto &Value : readInfo<IDAndMIB>(Next + Header->MIBOffset)) {
+      if (ProfileData.count(Value.Id)) {
+        ProfileData[Value.Id].Merge(Value.MIB);
+      } else {
+        ProfileData[Value.Id] = Value.MIB;
+      }
+    }
+
+    // Read in the callstack for each ids. For multiple raw profiles in the same
+    // file, we expect that the callstack is the same for a unique id.
+    const CallStackMap CSM = readStackInfo(Next + Header->StackOffset);
+    if (StackMap.empty()) {
+      StackMap = CSM;
+    } else {
+      if (mergeStackMap(CSM, StackMap))
+        return make_error<InstrProfError>(instrprof_error::malformed);
+    }
+
+    Next += Header->TotalSize;
+  }
+
+  return Error::success();
+}
+
+object::SectionedAddress
+RawMemProfReader::getModuleOffset(const uint64_t VirtualAddress) {
+  SegmentEntry *ContainingSegment = nullptr;
+  for (auto &SE : SegmentInfo) {
+    if (VirtualAddress > SE.Start && VirtualAddress <= SE.End) {
+      ContainingSegment = &SE;
+    }
+  }
+
+  // Ensure that the virtual address is valid.
+  assert(ContainingSegment && "Could not find a segment entry");
+
+  // TODO: Compute the file offset based on the maps and program headers. For
+  // now this only works for non PIE binaries.
+  return object::SectionedAddress{VirtualAddress};
+}
+
+Error RawMemProfReader::fillRecord(const uint64_t Id, const MemInfoBlock &MIB,
+                                   MemProfRecord &Record) {
+  auto &CallStack = StackMap[Id];
+  DILineInfoSpecifier Specifier(
+      DILineInfoSpecifier::FileLineInfoKind::RawValue,
+      DILineInfoSpecifier::FunctionNameKind::LinkageName);
+  for (const uint64_t Address : CallStack) {
+    Expected<DIInliningInfo> DIOr = Symbolizer->symbolizeInlinedCode(
+        getModuleOffset(Address), Specifier, /*UseSymbolTable=*/false);
+
+    if (!DIOr)
+      return DIOr.takeError();
+    DIInliningInfo DI = DIOr.get();
+
+    for (size_t I = 0; I < DI.getNumberOfFrames(); I++) {
+      const auto &Frame = DI.getFrame(I);
+      Record.CallStack.emplace_back(
+          std::to_string(llvm::MD5Hash(trimSuffix(Frame.FunctionName))),
+          Frame.Line - Frame.StartLine, Frame.Column,
+          // Only the first entry is not an inlined location.
+          I != 0);
+    }
+  }
+  Record.Info = MIB;
+  return Error::success();
+}
+
+Error RawMemProfReader::readNextRecord(MemProfRecord &Record) {
+  if (ProfileData.empty())
+    return make_error<InstrProfError>(instrprof_error::empty_raw_profile);
+
+  if (Iter == ProfileData.end())
+    return make_error<InstrProfError>(instrprof_error::eof);
+
+  Record.clear();
+  if (Error E = fillRecord(Iter->first, Iter->second, Record)) {
+    return E;
+  }
+  Iter++;
+  return Error::success();
+}
+
 } // namespace memprof
 } // namespace llvm

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

 The following commands were used to compile the source to a memprof instrumented
 executable and collect a raw binary format profile. Since the profile contains
 virtual addresses for the callstack, we do not expect the raw binary profile to
 be deterministic. The summary should be deterministic apart from changes to
 the shared libraries linked in which could change the number of segments
 recorded.
 
 ```
-clang -fmemory-profile -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -gline-tables-only -m64 -Wl,-build-id source.c -o rawprofile.out
+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 source.c -o basic.memprofexe 
 
 env MEMPROF_OPTIONS=log_path=stdout ./rawprofile.out > basic.memprofraw
 ```
 
-RUN: llvm-profdata show --memory %p/Inputs/basic.memprofraw -o - | FileCheck %s
+RUN: llvm-profdata show --memory %p/Inputs/basic.memprofraw --profiled-binary %p/Inputs/basic.memprofexe -o - | FileCheck %s
 
 We expect 3 MIB entries, 1 each for the malloc calls in the program and one
 additional entry from a realloc in glibc/libio/vasprintf.c.
 
 CHECK: MemprofProfile:
 CHECK-NEXT:   -
 CHECK-NEXT:   Header:
 CHECK-NEXT:     Version: 1
 CHECK-NEXT:     TotalSizeBytes: 1016
 CHECK-NEXT:     NumSegments: 9
 CHECK-NEXT:     NumMibInfo: 3
 CHECK-NEXT:     NumStackOffsets: 3
+CHECK-NEXT:   Records:
+CHECK-NEXT:   -
+CHECK-NEXT:     Callstack:
+CHECK-NEXT:     -
+CHECK-NEXT:       Function: {{[0-9]+}}
+CHECK-NEXT:       LineOffset: 73
+CHECK-NEXT:       Column: 3
+CHECK-NEXT:       Inline: 0
+CHECK-NEXT:     -
+CHECK-NEXT:       Function: {{[0-9]+}}
+CHECK-NEXT:       LineOffset: 0
+CHECK-NEXT:       Column: 0
+CHECK-NEXT:       Inline: 0
+CHECK-NEXT:     MemInfoBlock:
+CHECK-NEXT:       AllocCount: 1
+CHECK-NEXT:       TotalAccessCount: 0
+CHECK-NEXT:       MinAccessCount: 0
+CHECK-NEXT:       MaxAccessCount: 0
+CHECK-NEXT:       TotalSize: 53
+CHECK-NEXT:       MinSize: 53
+CHECK-NEXT:       MaxSize: 53
+CHECK-NEXT:       AllocTimestamp: 0
+CHECK-NEXT:       DeallocTimestamp: 987
+CHECK-NEXT:       TotalLifetime: 987
+CHECK-NEXT:       MinLifetime: 987
+CHECK-NEXT:       MaxLifetime: 987
+CHECK-NEXT:       AllocCpuId: 4294967295
+CHECK-NEXT:       DeallocCpuId: 56
+CHECK-NEXT:       NumMigratedCpu: 1
+CHECK-NEXT:       NumLifetimeOverlaps: 0
+CHECK-NEXT:       NumSameAllocCpu: 0
+CHECK-NEXT:       NumSameDeallocCpu: 0
+CHECK-NEXT:   -
+CHECK-NEXT:     Callstack:
+CHECK-NEXT:     -
+CHECK-NEXT:       Function: {{[0-9]+}}
+CHECK-NEXT:       LineOffset: 57
+CHECK-NEXT:       Column: 3
+CHECK-NEXT:       Inline: 0
+CHECK-NEXT:     -
+CHECK-NEXT:       Function: {{[0-9]+}}
+CHECK-NEXT:       LineOffset: 1
+CHECK-NEXT:       Column: 21
+CHECK-NEXT:       Inline: 0
+CHECK-NEXT:     -
+CHECK-NEXT:       Function: {{[0-9]+}}
+CHECK-NEXT:       LineOffset: 0
+CHECK-NEXT:       Column: 0
+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:       TotalSize: 10
+CHECK-NEXT:       MinSize: 10
+CHECK-NEXT:       MaxSize: 10
+CHECK-NEXT:       AllocTimestamp: 986
+CHECK-NEXT:       DeallocTimestamp: 986
+CHECK-NEXT:       TotalLifetime: 0
+CHECK-NEXT:       MinLifetime: 0
+CHECK-NEXT:       MaxLifetime: 0
+CHECK-NEXT:       AllocCpuId: 56
+CHECK-NEXT:       DeallocCpuId: 56
+CHECK-NEXT:       NumMigratedCpu: 0
+CHECK-NEXT:       NumLifetimeOverlaps: 0
+CHECK-NEXT:       NumSameAllocCpu: 0
+CHECK-NEXT:       NumSameDeallocCpu: 0
+CHECK-NEXT:   -
+CHECK-NEXT:     Callstack:
+CHECK-NEXT:     -
+CHECK-NEXT:       Function: {{[0-9]+}}
+CHECK-NEXT:       LineOffset: 57
+CHECK-NEXT:       Column: 3
+CHECK-NEXT:       Inline: 0
+CHECK-NEXT:     -
+CHECK-NEXT:       Function: {{[0-9]+}}
+CHECK-NEXT:       LineOffset: 5
+CHECK-NEXT:       Column: 15
+CHECK-NEXT:       Inline: 0
+CHECK-NEXT:     -
+CHECK-NEXT:       Function: {{[0-9]+}}
+CHECK-NEXT:       LineOffset: 0
+CHECK-NEXT:       Column: 0
+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:       TotalSize: 10
+CHECK-NEXT:       MinSize: 10
+CHECK-NEXT:       MaxSize: 10
+CHECK-NEXT:       AllocTimestamp: 987
+CHECK-NEXT:       DeallocTimestamp: 987
+CHECK-NEXT:       TotalLifetime: 0
+CHECK-NEXT:       MinLifetime: 0
+CHECK-NEXT:       MaxLifetime: 0
+CHECK-NEXT:       AllocCpuId: 56
+CHECK-NEXT:       DeallocCpuId: 56
+CHECK-NEXT:       NumMigratedCpu: 0
+CHECK-NEXT:       NumLifetimeOverlaps: 0
+CHECK-NEXT:       NumSameAllocCpu: 0
+CHECK-NEXT:       NumSameDeallocCpu: 0

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

 The following commands were used to compile the source to a memprof instrumented
 executable and collect a raw binary format profile. Since the profile contains
 virtual addresses for the callstack, we do not expect the raw binary profile to
 be deterministic. The summary should be deterministic apart from changes to
 the shared libraries linked in which could change the number of segments
 recorded.
 
 ```
-clang -fmemory-profile -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-optimize-sibling-calls -gline-tables-only -m64 -Wl,-build-id source.c -o rawprofile.out
+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 source.c -o multi.memprofexe
 
 env MEMPROF_OPTIONS=log_path=stdout ./rawprofile.out > multi.memprofraw
 ```
 
-RUN: llvm-profdata show --memory %p/Inputs/multi.memprofraw -o - | FileCheck %s
+RUN: llvm-profdata show --memory %p/Inputs/multi.memprofraw --profiled-binary %p/Inputs/multi.memprofexe -o - | FileCheck %s
 
 We expect 2 MIB entries, 1 each for the malloc calls in the program. Unlike the
 memprof-basic.test we do not see any allocation from glibc.
 
 CHECK: MemprofProfile:
 CHECK-NEXT:   -
 CHECK-NEXT:   Header:
 CHECK-NEXT:     Version: 1

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

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/ProfileData/InstrProfCorrelator.h"
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/ProfileData/InstrProfWriter.h"
+#include "llvm/ProfileData/MemProf.h"
 #include "llvm/ProfileData/ProfileCommon.h"
 #include "llvm/ProfileData/RawMemProfReader.h"
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/ProfileData/SampleProfWriter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Discriminator.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
static int showSampleProfile(const std::string &Filename, bool ShowCounts,
   }
 
   if (ShowHotFuncList || TopN)
     showHotFunctionList(Reader->getProfiles(), Reader->getSummary(), TopN, OS);
 
   return 0;
 }
 
-static int showMemProfProfile(const std::string &Filename, raw_fd_ostream &OS) {
-  auto ReaderOr = llvm::memprof::RawMemProfReader::create(Filename);
+static int showMemProfProfile(const std::string &Filename,
+                              const std::string &ProfiledBinary,
+                              raw_fd_ostream &OS) {
+  auto ReaderOr =
+      llvm::memprof::RawMemProfReader::create(Filename, ProfiledBinary);
   if (Error E = ReaderOr.takeError())
-    exitWithError(std::move(E), Filename);
+    // 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());
 
   Reader->printYAML(OS);
   return 0;
 }
 
cl::opt<bool> ShowBinaryIds("binary-ids", cl::init(false),
                               cl::desc("Show binary ids in the profile. "));
   cl::opt<std::string> DebugInfoFilename(
       "debug-info", cl::init(""),
       cl::desc("Read and extract profile metadata from debug info and show "
                "the functions it found."));
   cl::opt<bool> ShowCovered(
       "covered", cl::init(false),
       cl::desc("Show only the functions that have been executed."));
+  cl::opt<std::string> ProfiledBinary(
+      "profiled-binary", cl::init(""),
+      cl::desc("Path to binary from which the profile was collected."));
 
   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");
 
   if (Filename.empty() && DebugInfoFilename.empty())
     exitWithError(
         "the positional argument '<profdata-file>' is required unless '--" +
         DebugInfoFilename.ArgStr + "' is provided");
 
return showInstrProfile(
         ShowMemOPSizes, ShowDetailedSummary, DetailedSummaryCutoffs,
         ShowAllFunctions, ShowCS, ValueCutoff, OnlyListBelow, ShowFunction,
         TextFormat, ShowBinaryIds, ShowCovered, OS);
   if (ProfileKind == sample)
     return showSampleProfile(Filename, ShowCounts, TopNFunctions,
                              ShowAllFunctions, ShowDetailedSummary,
                              ShowFunction, ShowProfileSymbolList,
                              ShowSectionInfoOnly, ShowHotFuncList, OS);
-  return showMemProfProfile(Filename, OS);
+  return showMemProfProfile(Filename, ProfiledBinary, OS);
 }
 
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
 
   StringRef ProgName(sys::path::filename(argv[0]));
   if (argc > 1) {
     int (*func)(int, const char *[]) = nullptr;

llvm/unittests/ProfileData/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Core
   Coverage
   ProfileData
   Support
   )
 
 add_llvm_unittest(ProfileDataTests
   CoverageMappingTest.cpp
   InstrProfDataTest.cpp
   InstrProfTest.cpp
   SampleProfTest.cpp
+  MemProfTest.cpp
   )
 
 target_link_libraries(ProfileDataTests PRIVATE LLVMTestingSupport)

llvm/unittests/ProfileData/MemProfTest.cpp

+#include "llvm/ProfileData/MemProf.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/MapVector.h"
+#include "llvm/DebugInfo/DIContext.h"
+#include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/ProfileData/InstrProf.h"
+#include "llvm/ProfileData/MemProfData.inc"
+#include "llvm/ProfileData/RawMemProfReader.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MD5.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include <initializer_list>
+
+namespace {
+
+using ::llvm::DIGlobal;
+using ::llvm::DIInliningInfo;
+using ::llvm::DILineInfo;
+using ::llvm::DILineInfoSpecifier;
+using ::llvm::DILocal;
+using ::llvm::memprof::CallStackMap;
+using ::llvm::memprof::MemInfoBlock;
+using ::llvm::memprof::MemProfRecord;
+using ::llvm::memprof::RawMemProfReader;
+using ::llvm::memprof::SegmentEntry;
+using ::llvm::object::SectionedAddress;
+using ::llvm::symbolize::SymbolizableModule;
+using ::testing::Return;
+
+class MockSymbolizer : public SymbolizableModule {
+public:
+  MOCK_METHOD(DIInliningInfo, symbolizeInlinedCode,
+              (SectionedAddress, DILineInfoSpecifier, bool), (const, override));
+  // Most of the methods in the interface are unused. We only mock the
+  // method that we expect to be called from the memprof reader.
+  virtual DILineInfo symbolizeCode(SectionedAddress, DILineInfoSpecifier,
+                                   bool) const override {
+    llvm_unreachable("unused");
+  }
+  virtual DIGlobal symbolizeData(SectionedAddress) const override {
+    llvm_unreachable("unused");
+  }
+  virtual std::vector<DILocal> symbolizeFrame(SectionedAddress) const override {
+    llvm_unreachable("unused");
+  }
+  virtual bool isWin32Module() const override { llvm_unreachable("unused"); }
+  virtual uint64_t getModulePreferredBase() const override {
+    llvm_unreachable("unused");
+  }
+};
+
+struct MockInfo {
+  std::string FunctionName;
+  uint32_t Line;
+  uint32_t StartLine;
+  uint32_t Column;
+};
+DIInliningInfo makeInliningInfo(std::initializer_list<MockInfo> MockFrames) {
+  DIInliningInfo Result;
+  for (const auto &Item : MockFrames) {
+    DILineInfo Frame;
+    Frame.FunctionName = Item.FunctionName;
+    Frame.Line = Item.Line;
+    Frame.StartLine = Item.StartLine;
+    Frame.Column = Item.Column;
+    Result.addFrame(Frame);
+  }
+  return Result;
+}
+
+llvm::SmallVector<SegmentEntry, 4> makeSegments() {
+  llvm::SmallVector<SegmentEntry, 4> Result;
+  // Mimic an entry for a non position independent executable.
+  Result.emplace_back(0x0, 0x40000, 0x0);
+  return Result;
+}
+
+const DILineInfoSpecifier specifier() {
+  return DILineInfoSpecifier(
+      DILineInfoSpecifier::FileLineInfoKind::RawValue,
+      DILineInfoSpecifier::FunctionNameKind::LinkageName);
+}
+
+MATCHER_P4(FrameContains, Function, LineOffset, Column, Inline, "") {
+  const std::string ExpectedHash = std::to_string(llvm::MD5Hash(Function));
+  if (arg.Function != ExpectedHash) {
+    *result_listener << "Hash mismatch";
+    return false;
+  }
+  if (arg.LineOffset == LineOffset && arg.Column == Column &&
+      arg.IsInlineFrame == Inline) {
+    return true;
+  }
+  *result_listener << "LineOffset, Column or Inline mismatch";
+  return false;
+}
+
+TEST(MemProf, FillsValue) {
+  std::unique_ptr<MockSymbolizer> Symbolizer(new MockSymbolizer());
+
+  EXPECT_CALL(*Symbolizer, symbolizeInlinedCode(SectionedAddress{0x2000},
+                                                specifier(), false))
+      .Times(2)
+      .WillRepeatedly(Return(makeInliningInfo({
+          {"foo", 10, 5, 30},
+          {"bar", 201, 150, 20},
+      })));
+
+  EXPECT_CALL(*Symbolizer, symbolizeInlinedCode(SectionedAddress{0x6000},
+                                                specifier(), false))
+      .Times(1)
+      .WillRepeatedly(Return(makeInliningInfo({
+          {"baz", 10, 5, 30},
+          {"qux.llvm.12345", 75, 70, 10},
+      })));
+
+  CallStackMap CSM;
+  CSM[0x1] = {0x2000};
+  CSM[0x2] = {0x6000, 0x2000};
+
+  llvm::MapVector<uint64_t, MemInfoBlock> Prof;
+  Prof[0x1].alloc_count = 1;
+  Prof[0x2].alloc_count = 2;
+
+  auto Seg = makeSegments();
+
+  RawMemProfReader Reader(std::move(Symbolizer), Seg, Prof, CSM);
+
+  std::vector<MemProfRecord> Records;
+  for (const MemProfRecord &R : Reader) {
+    Records.push_back(R);
+  }
+  EXPECT_EQ(Records.size(), 2U);
+
+  EXPECT_EQ(Records[0].Info.alloc_count, 1U);
+  EXPECT_EQ(Records[1].Info.alloc_count, 2U);
+  EXPECT_THAT(Records[0].CallStack[0], FrameContains("foo", 5U, 30U, false));
+  EXPECT_THAT(Records[0].CallStack[1], FrameContains("bar", 51U, 20U, true));
+
+  EXPECT_THAT(Records[1].CallStack[0], FrameContains("baz", 5U, 30U, false));
+  EXPECT_THAT(Records[1].CallStack[1], FrameContains("qux", 5U, 10U, true));
+  EXPECT_THAT(Records[1].CallStack[2], FrameContains("foo", 5U, 30U, false));
+  EXPECT_THAT(Records[1].CallStack[3], FrameContains("bar", 51U, 20U, true));
+}
+
+} // namespace