[memprof] Extend llvm-profdata to display MemProf profile summaries.

[snehasish]

Summary

This commit adds initial support to llvm-profdata to read and print
summaries of raw memprof profiles.
Summary of changes:

• Refactor shared defs to MemProfData.inc
• Extend show_main to display memprof profile summaries.
• Add a simple raw memprof profile reader.
• Add a couple of tests to tools/llvm-profdata.

[snehasish]

Add a couple of sentences to the tests to clarify expectations.

[davidxl]

Probably better to split out the refactor patch and commit it separately as NFC.

[snehasish]

Add headers to address undefined uint64_t on Windows build.

[snehasish]

In D114286#3144112, @davidxl wrote:

Probably better to split out the refactor patch and commit it separately as NFC.

I tried it out and decided against it for the following reasons:

• IMO we should introduce both shared .inc files in a single commit.
• If I move both refactored inc files into a separate commit, to keep it NFC the file in include/llvm/ProfileData will be unused.

Finally, since the size of the refactored out content isn't large (<50 LOC) I'd like to keep this as is unless you have a strong opinion.

PTAL, thanks!

[davidxl]

llvm/lib/ProfileData/RawMemProfReader.cpp

34

This assumes one Header in the profile, but it is possible to have multiple raw profiles concatenated in the same file?

75

Add checks to Headers here?

[snehasish]

Move the header sanity checks into the loop.

[snehasish]

llvm/lib/ProfileData/RawMemProfReader.cpp

34

This is just a helper which reads some data from 1 raw profile. Start only needs to point to the beginning of a header (see usage in RawMemProfReader::printSummary). Is there anything you recommend to make this usage clearer?

[davidxl]

llvm/lib/ProfileData/RawMemProfReader.cpp

34

I misunderstood - I thought this interface is used to compute the 'combined' summary.

Do we have a need to have the later? For instance, for printSummary, is it helpful to just print out the combined data to the user instead of printing out multiple 'summaries'? Intuitively, summary means the later.

[snehasish]

• Clarify summary function.
• Use llvm::memprof namespace in the MemProfData.inc header.
• Rename memprof enum in llvm-profdata.cpp to avoid conflict with namespace.

[snehasish]

llvm/lib/ProfileData/RawMemProfReader.cpp

34

I renamed the function to printSummaries and added comments to clarify what it does. For now this is just used to test the raw format reader. I don't think there is much value in the combined summary apart from sanity checking - the indexed format conversion step will have to merge the raw profiles prior to processing. At that point I can enhance the printed out summary if it helps us in testing. Wdyt?

[davidxl]

lgtm

[snehasish]

Update MemProfData.inc.

• Add a header guard
• Do not use c typedef-style struct decl (MSVC build fails when included in a cpp file)
• Use appropriate pragmas for packing - clang+gcc vs msvc.

[snehasish]

Thanks for the review David, I've fixed some issues with the Windows build. I'll wait till next week to push this after ensuring CI is green + any comments from @tejohnson.

[tejohnson]

lgtm with a couple of minor comments below (please ignore until after the holiday weekend, forgot to finalize these comments yesterday).

llvm/include/llvm/ProfileData/MemProfData.inc

48

Nit: we're using a combo of coding styles in this file. I.e. underscore separated names (a la sanitizer runtime) in this struct and lower camel case in the SegmentEntry struct (buildId). Looks like InstrProfData.inc in this directory uses the LLVM coding style of upper camel case - perhaps that should be done here too for consistency?

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

36

Is this just dumb luck? Doesn't really matter since you have saved the profile, but might if we ever need to regenerate the profile as described above.

[snehasish]

• Use consistent style for MemProfData.inc
• Update an llvm-profdata error message to mention --memory.

[snehasish]

PTAL, thanks!

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

36

It is deterministic in behaviour if thats what you were implying. I'll take a closer look once I add symbolization support to llvm-profdata.

[davidxl]

lgtm.

llvm/include/llvm/ProfileData/MemProfData.inc

25

It would be ideal to have the macro defined in a common header, but it is probably difficult because the .inc file is for both llvm and runtime.

[tejohnson]

lgtm

[snehasish]

llvm/include/llvm/ProfileData/MemProfData.inc

25

Yes, there are no headers shared between LLVM and compiler-rt so it would have to be duplicated. Since memprof is the only place where this is used I will leave it in the shared .inc files as is.

[kda]

Looks like this is breaking buildbot: fast and ubsan
https://lab.llvm.org/buildbot/#/builders/5/builds/15332
https://lab.llvm.org/buildbot/#/builders/85/builds/7050

[snehasish]

Yes, just shared https://reviews.llvm.org/D114826 to fix the ubsan issue (
https://lab.llvm.org/buildbot/#/builders/5/builds/15332).
The fast config
(https://lab.llvm.org/buildbot/#/builders/85/builds/7050) should
be fixed by
https://reviews.llvm.org/rGa2ce97cc3f99c8af80b2325acf03a4c171ffb48f.

Regards,
Snehasish

compiler-rt/include/CMakeLists.txt

if (COMPILER_RT_BUILD_SANITIZERS)
   set(FUZZER_HEADERS
     fuzzer/FuzzedDataProvider.h
     )
 endif(COMPILER_RT_BUILD_SANITIZERS)
 
 if (COMPILER_RT_BUILD_MEMPROF)
   set(MEMPROF_HEADERS
     sanitizer/memprof_interface.h
+    profile/MemProfData.inc
     )
 endif(COMPILER_RT_BUILD_MEMPROF)
 
 if (COMPILER_RT_BUILD_XRAY)
   set(XRAY_HEADERS
     xray/xray_interface.h
     xray/xray_log_interface.h
     xray/xray_records.h

compiler-rt/include/profile/MemProfData.inc

+#ifndef MEMPROF_DATA_INC
+#define MEMPROF_DATA_INC
+/*===-- MemProfData.inc - MemProf profiling runtime structures -*- 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 is the main file that defines all the data structure, signature,
+ * constant literals that are shared across profiling runtime library,
+ * and host tools (reader/writer).
+ *
+ * This file has two identical copies. The primary copy lives in LLVM and
+ * the other one sits in compiler-rt/include/profile directory. To make changes
+ * in this file, first modify the primary copy and copy it over to compiler-rt.
+ * Testing of any change in this file can start only after the two copies are
+ * synced up.
+ *
+\*===----------------------------------------------------------------------===*/
+
+
+#ifdef _MSC_VER
+#define PACKED(__decl__) __pragma(pack(push,1)) __decl__ __pragma(pack(pop))
+#else
+#define PACKED(__decl__) __decl__ __attribute__((__packed__))
+#endif
+
+// A 64-bit magic number to uniquely identify the raw binary memprof profile file.
+#define MEMPROF_RAW_MAGIC_64                                                                        \
+  ((uint64_t)255 << 56 | (uint64_t)'m' << 48 | (uint64_t)'p' << 40 | (uint64_t)'r' << 32 |          \
+   (uint64_t)'o' << 24 | (uint64_t)'f' << 16 | (uint64_t)'r' << 8 | (uint64_t)129)
+
+// The version number of the raw binary format.
+#define MEMPROF_RAW_VERSION 1ULL
+
+namespace llvm {
+namespace memprof {
+// A struct describing the header used for the raw binary memprof profile format.
+PACKED(struct Header {
+  uint64_t Magic;
+  uint64_t Version;
+  uint64_t TotalSize;
+  uint64_t SegmentOffset;
+  uint64_t MIBOffset;
+  uint64_t StackOffset;
+});
+
+// A struct describing the information necessary to describe a /proc/maps
+// segment entry for a particular binary/library identified by its build id.
+PACKED(struct SegmentEntry {
+  uint64_t Start;
+  uint64_t End;
+  uint64_t Offset;
+  uint8_t BuildId[32];
+});
+} // namespace memprof
+} // namespace llvm
+
+#endif

compiler-rt/lib/memprof/CMakeLists.txt

SET(MEMPROF_HEADERS
   memprof_mibmap.h
   memprof_rawprofile.h
   memprof_stack.h
   memprof_stats.h
   memprof_thread.h
   )
 
 include_directories(..)
+include_directories(../../include)
 
 set(MEMPROF_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 set(MEMPROF_COMMON_DEFINITIONS "")
 
 # Too many existing bugs, needs cleanup.
 append_list_if(COMPILER_RT_HAS_WNO_FORMAT -Wno-format MEMPROF_CFLAGS)
 
 append_rtti_flag(OFF MEMPROF_CFLAGS)

compiler-rt/lib/memprof/memprof_rawprofile.h

 #ifndef MEMPROF_RAWPROFILE_H_
 #define MEMPROF_RAWPROFILE_H_
 
 #include "memprof_mibmap.h"
 #include "sanitizer_common/sanitizer_procmaps.h"
 
 namespace __memprof {
-
-// TODO: pull these in from MemProfData.inc
-#define MEMPROF_RAW_MAGIC_64                                                   \
-  (u64)255 << 56 | (u64)'m' << 48 | (u64)'p' << 40 | (u64)'r' << 32 |          \
-      (u64)'o' << 24 | (u64)'f' << 16 | (u64)'r' << 8 | (u64)129
-
-#define MEMPROF_RAW_VERSION 1ULL
-
+// Serialize the in-memory representation of the memprof profile to the raw
+// binary format. The format itself is documented memprof_rawprofile.cpp.
 u64 SerializeToRawProfile(MIBMapTy &BlockCache, MemoryMappingLayoutBase &Layout,
                           char *&Buffer);
-
 } // namespace __memprof
 
 #endif // MEMPROF_RAWPROFILE_H_

compiler-rt/lib/memprof/memprof_rawprofile.cpp

-#include "memprof_rawprofile.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
 #include "memprof_meminfoblock.h"
+#include "memprof_rawprofile.h"
+#include "profile/MemProfData.inc"
 #include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_linux.h"
 #include "sanitizer_common/sanitizer_procmaps.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_stackdepotbase.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "sanitizer_common/sanitizer_vector.h"
 
-#include <stdlib.h>
-#include <string.h>
-
 namespace __memprof {
 using ::__sanitizer::Vector;
+using SegmentEntry = ::llvm::memprof::SegmentEntry;
+using Header = ::llvm::memprof::Header;
 
 namespace {
-typedef struct __attribute__((__packed__)) {
-  u64 start;
-  u64 end;
-  u64 offset;
-  u8 buildId[32];
-} SegmentEntry;
-
-typedef struct __attribute__((__packed__)) {
-  u64 magic;
-  u64 version;
-  u64 total_size;
-  u64 segment_offset;
-  u64 mib_offset;
-  u64 stack_offset;
-} Header;
-
 template <class T> char *WriteBytes(T Pod, char *&Buffer) {
   *(T *)Buffer = Pod;
   return Buffer + sizeof(T);
 }
 
 void RecordStackId(const uptr Key, UNUSED LockedMemInfoBlock *const &MIB,
                    void *Arg) {
   // No need to touch the MIB value here since we are only recording the key.
void SerializeSegmentsToBuffer(MemoryMappingLayoutBase &Layout,
   // Reserve space for the final count.
   Ptr += sizeof(u64);
 
   u64 NumSegmentsRecorded = 0;
   MemoryMappedSegment segment;
 
   for (Layout.Reset(); Layout.Next(&segment);) {
     if (segment.IsReadable() && segment.IsExecutable()) {
-      SegmentEntry entry{};
-      entry.start = segment.start;
-      entry.end = segment.end;
-      entry.offset = segment.offset;
-      memcpy(entry.buildId, segment.uuid, sizeof(segment.uuid));
-      memcpy(Ptr, &entry, sizeof(SegmentEntry));
+      SegmentEntry Entry{};
+      Entry.Start = segment.start;
+      Entry.End = segment.end;
+      Entry.Offset = segment.offset;
+      memcpy(Entry.BuildId, segment.uuid, sizeof(segment.uuid));
+      memcpy(Ptr, &Entry, sizeof(SegmentEntry));
       Ptr += sizeof(SegmentEntry);
       NumSegmentsRecorded++;
     }
   }
 
   // Store the number of segments we recorded in the space we reserved.
   *((u64 *)Buffer) = NumSegmentsRecorded;
   CHECK(ExpectedNumBytes == static_cast<u64>(Ptr - Buffer) &&

llvm/include/llvm/ProfileData/MemProfData.inc

+#ifndef MEMPROF_DATA_INC
+#define MEMPROF_DATA_INC
+/*===-- MemProfData.inc - MemProf profiling runtime structures -*- 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 is the main file that defines all the data structure, signature,
+ * constant literals that are shared across profiling runtime library,
+ * and host tools (reader/writer).
+ *
+ * This file has two identical copies. The primary copy lives in LLVM and
+ * the other one sits in compiler-rt/include/profile directory. To make changes
+ * in this file, first modify the primary copy and copy it over to compiler-rt.
+ * Testing of any change in this file can start only after the two copies are
+ * synced up.
+ *
+\*===----------------------------------------------------------------------===*/
+
+
+#ifdef _MSC_VER
+#define PACKED(__decl__) __pragma(pack(push,1)) __decl__ __pragma(pack(pop))
+#else
+#define PACKED(__decl__) __decl__ __attribute__((__packed__))
+#endif
+
+// A 64-bit magic number to uniquely identify the raw binary memprof profile file.
+#define MEMPROF_RAW_MAGIC_64                                                                        \
+  ((uint64_t)255 << 56 | (uint64_t)'m' << 48 | (uint64_t)'p' << 40 | (uint64_t)'r' << 32 |          \
+   (uint64_t)'o' << 24 | (uint64_t)'f' << 16 | (uint64_t)'r' << 8 | (uint64_t)129)
+
+// The version number of the raw binary format.
+#define MEMPROF_RAW_VERSION 1ULL
+
+namespace llvm {
+namespace memprof {
+// A struct describing the header used for the raw binary memprof profile format.
+PACKED(struct Header {
+  uint64_t Magic;
+  uint64_t Version;
+  uint64_t TotalSize;
+  uint64_t SegmentOffset;
+  uint64_t MIBOffset;
+  uint64_t StackOffset;
+});
+
+// A struct describing the information necessary to describe a /proc/maps
+// segment entry for a particular binary/library identified by its build id.
+PACKED(struct SegmentEntry {
+  uint64_t Start;
+  uint64_t End;
+  uint64_t Offset;
+  uint8_t BuildId[32];
+});
+} // namespace memprof
+} // namespace llvm
+
+#endif

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/Support/Error.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+namespace llvm {
+namespace memprof {
+
+class RawMemProfReader {
+public:
+  RawMemProfReader(std::unique_ptr<MemoryBuffer> DataBuffer)
+      : DataBuffer(std::move(DataBuffer)) {}
+  // Prints aggregate counts for each raw profile parsed from the DataBuffer.
+  void printSummaries(raw_ostream &OS) const;
+
+  // Return true if the \p DataBuffer starts with magic bytes indicating it is
+  // a raw binary memprof profile.
+  static bool hasFormat(const MemoryBuffer &DataBuffer);
+
+  // Create a RawMemProfReader after sanity checking the contents of the file at
+  // \p Path.
+  static Expected<std::unique_ptr<RawMemProfReader>> create(const Twine &Path);
+
+private:
+  std::unique_ptr<MemoryBuffer> DataBuffer;
+};
+
+} // namespace memprof
+} // namespace llvm
+
+#endif // LLVM_PROFILEDATA_RAWMEMPROFREADER_H_

llvm/lib/ProfileData/CMakeLists.txt

 add_llvm_component_library(LLVMProfileData
   GCOV.cpp
   InstrProf.cpp
   InstrProfReader.cpp
   InstrProfWriter.cpp
   ProfileSummaryBuilder.cpp
   SampleProf.cpp
   SampleProfReader.cpp
   SampleProfWriter.cpp
+  RawMemProfReader.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ProfileData
 
   DEPENDS
   intrinsics_gen
 
   LINK_COMPONENTS
   Core
   Support
   Demangle
   )
 
 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 "llvm/ProfileData/InstrProf.h"
+#include "llvm/ProfileData/MemProfData.inc"
+#include "llvm/ProfileData/RawMemProfReader.h"
+
+namespace llvm {
+namespace memprof {
+namespace {
+
+struct Summary {
+  uint64_t Version;
+  uint64_t TotalSizeBytes;
+  uint64_t NumSegments;
+  uint64_t NumMIBInfo;
+  uint64_t NumStackOffsets;
+};
+
+Summary computeSummary(const char *Start) {
+  auto *H = reinterpret_cast<const Header *>(Start);
+
+  return Summary{
+      H->Version,
+      H->TotalSize,
+      *reinterpret_cast<const uint64_t *>(Start + H->SegmentOffset),
+      *reinterpret_cast<const uint64_t *>(Start + H->MIBOffset),
+      *reinterpret_cast<const uint64_t *>(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());
+
+  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)) {
+    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()) {
+    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) {
+    return make_error<InstrProfError>(instrprof_error::malformed);
+  }
+
+  return std::make_unique<RawMemProfReader>(std::move(Buffer));
+}
+
+bool RawMemProfReader::hasFormat(const MemoryBuffer &Buffer) {
+  if (Buffer.getBufferSize() < sizeof(uint64_t))
+    return false;
+  uint64_t Magic = *reinterpret_cast<const uint64_t *>(Buffer.getBufferStart());
+  return Magic == MEMPROF_RAW_MAGIC_64;
+}
+
+void RawMemProfReader::printSummaries(raw_ostream &OS) const {
+  int Count = 0;
+  const char *Next = DataBuffer->getBufferStart();
+  while (Next < DataBuffer->getBufferEnd()) {
+    auto Summary = computeSummary(Next);
+    OS << "MemProf Profile " << ++Count << "\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;
+  }
+}
+
+} // namespace memprof
+} // namespace llvm

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

+The input raw profile test has been generated from the following source code:
+
+```
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  char *x = (char *)malloc(10);
+  memset(x, 0, 10);
+  free(x);
+  x = (char *)malloc(10);
+  memset(x, 0, 10);
+  free(x);
+  return 0;
+}
+```
+
+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
+
+env MEMPROF_OPTIONS=log_path=stdout ./rawprofile.out > basic.memprofraw
+```
+
+RUN: llvm-profdata show --memory %p/Inputs/basic.memprofraw -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: MemProf Profile 1
+CHECK:   Version: 1
+CHECK:   TotalSizeBytes: 1012
+CHECK:   NumSegments: 9
+CHECK:   NumMIBInfo: 3
+CHECK:   NumStackOffsets: 3

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

+The input raw profile test has been generated from the following source code:
+
+```
+#include <sanitizer/memprof_interface.h>
+#include <stdlib.h>
+#include <string.h>
+int main(int argc, char **argv) {
+  char *x = (char *)malloc(10);
+  memset(x, 0, 10);
+  free(x);
+  __memprof_profile_dump();
+  x = (char *)malloc(10);
+  memset(x, 0, 10);
+  free(x);
+  return 0;
+}
+```
+
+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
+
+env MEMPROF_OPTIONS=log_path=stdout ./rawprofile.out > multi.memprofraw
+```
+
+RUN: llvm-profdata show --memory %p/Inputs/multi.memprofraw -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: MemProf Profile 1
+CHECK:   Version: 1
+CHECK:   TotalSizeBytes: 864
+CHECK:   NumSegments: 9
+CHECK:   NumMIBInfo: 2
+CHECK:   NumStackOffsets: 2
+CHECK: MemProf Profile 2
+CHECK:   Version: 1
+CHECK:   TotalSizeBytes: 864
+CHECK:   NumSegments: 9
+CHECK:   NumMIBInfo: 2
+CHECK:   NumStackOffsets: 2

llvm/test/tools/llvm-profdata/text-format-errors.test

 
 3- Detect no counts
 RUN: not llvm-profdata show %p/Inputs/no-counts.proftext 2>&1 | FileCheck %s --check-prefix=NO-COUNTS
 NO-COUNTS: error: {{.*}}no-counts.proftext: malformed instrumentation profile data
 
 4- Detect binary input
 RUN: not llvm-profdata show %p/Inputs/text-format-errors.text.bin 2>&1 | FileCheck %s --check-prefix=BINARY
 BINARY: error: {{.+}}: unrecognized instrumentation profile encoding format
-BINARY: Perhaps you forgot to use the --sample option?
+BINARY: Perhaps you forgot to use the --sample or --memory option?
 
 5- Detect malformed value profile data
 RUN: not llvm-profdata show %p/Inputs/vp-malform.proftext 2>&1 | FileCheck %s --check-prefix=VP
 RUN: not llvm-profdata show %p/Inputs/vp-malform2.proftext 2>&1 | FileCheck %s --check-prefix=VP
 VP: error: {{.+}}: malformed instrumentation profile data
 
 6- Detect truncated value profile data
 RUN: not llvm-profdata show %p/Inputs/vp-truncate.proftext 2>&1 | FileCheck %s --check-prefix=VPTRUNC
 VPTRUNC: error: {{.+}}: truncated profile data

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

 
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/ProfileData/InstrProfWriter.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"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormattedStream.h"

 }
 
 static void exitWithError(Error E, StringRef Whence = "") {
   if (E.isA<InstrProfError>()) {
     handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
       instrprof_error instrError = IPE.get();
       StringRef Hint = "";
       if (instrError == instrprof_error::unrecognized_format) {
-        // Hint for common error of forgetting --sample for sample profiles.
-        Hint = "Perhaps you forgot to use the --sample option?";
+        // Hint in case user missed specifying the profile type.
+        Hint = "Perhaps you forgot to use the --sample or --memory option?";
       }
       exitWithError(IPE.message(), std::string(Whence), std::string(Hint));
     });
   }
 
   exitWithError(toString(std::move(E)), std::string(Whence));
 }
 
 static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") {
   exitWithError(EC.message(), std::string(Whence));
 }
 
 namespace {
-enum ProfileKinds { instr, sample };
+enum ProfileKinds { instr, sample, memory };
 enum FailureMode { failIfAnyAreInvalid, failIfAllAreInvalid };
 }
 
 static void warnOrExitGivenError(FailureMode FailMode, std::error_code EC,
                                  StringRef Whence = "") {
   if (FailMode == failIfAnyAreInvalid)
     exitWithErrorCode(EC, Whence);
   else
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);
+  if (Error E = ReaderOr.takeError())
+    exitWithError(std::move(E), Filename);
+
+  std::unique_ptr<llvm::memprof::RawMemProfReader> Reader(
+      ReaderOr.get().release());
+  Reader->printSummaries(OS);
+  return 0;
+}
+
 static int show_main(int argc, const char *argv[]) {
   cl::opt<std::string> Filename(cl::Positional, cl::Required,
                                 cl::desc("<profdata-file>"));
 
   cl::opt<bool> ShowCounts("counts", cl::init(false),
                            cl::desc("Show counter values for shown functions"));
   cl::opt<bool> TextFormat(
       "text", cl::init(false),
static int show_main(int argc, const char *argv[]) {
 
   cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
                                       cl::init("-"), cl::desc("Output file"));
   cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
                             cl::aliasopt(OutputFilename));
   cl::opt<ProfileKinds> ProfileKind(
       cl::desc("Profile kind:"), cl::init(instr),
       cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
-                 clEnumVal(sample, "Sample profile")));
+                 clEnumVal(sample, "Sample profile"),
+                 clEnumVal(memory, "MemProf memory access profile")));
   cl::opt<uint32_t> TopNFunctions(
       "topn", cl::init(0),
       cl::desc("Show the list of functions with the largest internal counts"));
   cl::opt<uint32_t> ValueCutoff(
       "value-cutoff", cl::init(0),
       cl::desc("Set the count value cutoff. Functions with the maximum count "
                "less than this value will not be printed out. (Default is 0)"));
   cl::opt<bool> OnlyListBelow(
if (ShowAllFunctions && !ShowFunction.empty())
     WithColor::warning() << "-function argument ignored: showing all functions\n";
 
   if (ProfileKind == instr)
     return showInstrProfile(
         Filename, ShowCounts, TopNFunctions, ShowIndirectCallTargets,
         ShowMemOPSizes, ShowDetailedSummary, DetailedSummaryCutoffs,
         ShowAllFunctions, ShowCS, ValueCutoff, OnlyListBelow, ShowFunction,
         TextFormat, ShowBinaryIds, OS);
-  else
+  if (ProfileKind == sample)
     return showSampleProfile(Filename, ShowCounts, TopNFunctions,
                              ShowAllFunctions, ShowDetailedSummary,
                              ShowFunction, ShowProfileSymbolList,
                              ShowSectionInfoOnly, ShowHotFuncList, OS);
+  return showMemProfProfile(Filename, 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;