Cache memory regions in ProcessMinidump and use the linux maps as the source of the information if available.

[clayborg]

Summary

Breakpad creates minidump files that sometimes have:

• linux maps textual content
• no MemoryInfoList

Right now unless the file has a MemoryInfoList we get no region information.

This patch:

• reads and caches the memory region info one time and sorts it for easy subsequent access
• get the region info from the best source in this order:
  • linux maps info (if available)
  • MemoryInfoList (if available)
  • MemoryList or Memory64List
• returns memory region info for the gaps between regions (before the first and after the last)

This patch is a different patch that would replace: https://reviews.llvm.org/D55472

If we decide to go with this patch, then I will add tests.

[clayborg]

Add sorting functions needed for MemoryRegionInfo

[zturner]

source/Plugins/Process/minidump/MinidumpParser.cpp

409

You can write this as auto text = llvm::toStringRef(data);

411–412

No reason to have both constexpr and const, since the former implies the latter.

As an aside, I find this quite strange. I'm not sure why we don't just use llvm::Optional<bool> and delete MemoryRegionInfo::OptionalBool. The former is an enum, which defaults to int, while sizeof(Optional<bool>) == 2, so it seems strictly better, as well as being more intuitive.

426

line.take_front(4); is a little more idiomatic, but this is fine anyway. If we need to handle these strings being an invalid format we should also check for length before any take, drop, or substr operation

447–449

This is a good example where Optional<bool> would be nice. You could just eliminate the ternary and pass the result of the equality comparison and it would work fine.

504–531

Maybe we could add some member functions to MinidumpMemoryInfo such as isExecutable(), isReadable(), etc

535–536

This condition doesn't seem possible based on the code, because it would imply the list of regions is empty, but then we would either not be in this branch (current code), or have already returned (based on suggestion above).

I think I see what it's trying to do though. I think we need to move this check up in between the previous if/else block. So it should be something like:

if (pos != end && pos->GetRange().Contains(load_addr))
  return *pos;

if (pos == begin)
  return llvm::None;

--pos;
if (pos->GetRange().Contains(load_addr))
  return pos;

However, at this point, haven't we handled every possible case? Either the user passed the exact address of offset 0 of a memory region (case 0), they passed an address that is not in any region (case 2), or they passed an address that is in the middle of a region (case 3).

Can't we just write return llvm::None at this point? What is the rest of the code for?

565–566

Actually, we're already checking if it's empty here before we call the function. Then inside the function we check if it's empty again. Since it's part of the function's private interface, we have full control over the inputs, we should assert inside of the implementation of FindMemoryRegion that it's not empty.

595

Can we early out here if m_regions.empty() is true?

601

Since the previous line is a return statement, we don't need the else.

source/Plugins/Process/minidump/MinidumpParser.h

97–100

Minor nit, but wherever possible, it's nice if we can eliminate private functions from a class's definition and move them to static internal-linkage functions in the implementation file. For example, I'm imagining you could re-write these as:

static bool CreateRegionsCacheFromLinuxMaps(ArrayRef<uint8_t> linux_maps, std::vector<MemoryRegionInfo> &regions) {
}

// etc

in the implementation file. It makes the header file smaller which is helpful when trying to read it and understand the functionality of a class, and also improves link time.

[labath]

This patch certainly provides a more comprehensive treatment of memory region information in minidump. However, there might be some value in removing the excessive shared_ptrs in the other patch. I think that should be evaluated separately.

I was going to write some additional comments, but they largely coincide with the ones Zachary made already.

[clayborg]

Fixed Zach's issues.

[clayborg]

Removed Xcode scheme changes.

[clayborg]

source/Plugins/Process/minidump/MinidumpParser.cpp

412

I agree on the Optional<bool>, but since this enum is exposed via the public API, I would leave it alone for now?

536

Fixed the logic in here to be able to have empty m_regions.

566

I fixed the logic so FindMemoryRegion work with the empty region. And will set a bool to indicate we parsed the memory regions and not rely on m_regions being empty for that.

[clayborg]

In D55522#1325839, @labath wrote:

This patch certainly provides a more comprehensive treatment of memory region information in minidump. However, there might be some value in removing the excessive shared_ptrs in the other patch. I think that should be evaluated separately.

Agreed. I will make that patch following this one.

[tatyana-krasnukha]

Without overriding Process::GetMemoryRegions still does a lot of unnecessary job (FindMemoryRegion for each element in the vector).
With these changes, it may just return m_regions (if not empty), doesn't it?

source/Plugins/Process/minidump/MinidumpParser.cpp

530–531

Here may be m_regions.reserve(mem_info_list.size())

538

You can move region here.

554

m_regions.reserve(memory_list.size()) and m_regions.shrink_to_fit() after the loop.

580

Same

[tatyana-krasnukha]

Don't you mind to take overridden GetMemoryRegions in this patch so that I can remove all minidump-related changes from D55472?

[clayborg]

In D55522#1326035, @tatyana-krasnukha wrote:

Don't you mind to take overridden GetMemoryRegions in this patch so that I can remove all minidump-related changes from D55472?

That is fine with me.

[clayborg]

Add reserve and shrink to fit when parsing memory regions.

[labath]

It just occurred to me that we have another copy of /proc/<pid>/maps -> MemoryRegionInfo conversion code. It lives in NativeProcessLinux.cpp (ParseMemoryRegionInfoFromProcMapsLine). It would be nice to extract this parser into a some place (Plugins/Process/Utility ?), where it can be shared by the two process plugins. As a bonus, that should make it easy to write unit tests for that function.

[clayborg]

In D55522#1326955, @labath wrote:

It just occurred to me that we have another copy of /proc/<pid>/maps -> MemoryRegionInfo conversion code. It lives in NativeProcessLinux.cpp (ParseMemoryRegionInfoFromProcMapsLine). It would be nice to extract this parser into a some place (Plugins/Process/Utility ?), where it can be shared by the two process plugins. As a bonus, that should make it easy to write unit tests for that function.

Nice! I should have looked around. I will move it to Plugins/Process/Utility as suggested

[clayborg]

Fixed errors, fully test, and make static function that are local to MinidumpParser.cpp that parse the region info from linux maps, memory info list, memory list and memory 64 list.

[labath]

Looks good to me. Thanks for moving the function to a more generic place. I can get rid of the copy in NativeProcessLinux once this lands.

source/Plugins/Process/Utility/LinuxProcMaps.cpp

19 ↗

(On Diff #178168)

It doesn't look like this maps_line needs to be a reference.

[clayborg]

Fixed the test inputs CMakeLists.txt file:

$ svn commit
Sending CMakeLists.txt
Transmitting file data .done
Committing transaction...
Committed revision 349183.

include/lldb/Target/MemoryRegionInfo.h

protected:
   OptionalBool m_read;
   OptionalBool m_write;
   OptionalBool m_execute;
   OptionalBool m_mapped;
   ConstString m_name;
   OptionalBool m_flash;
   lldb::offset_t m_blocksize;
 };
+  
+inline bool operator<(const MemoryRegionInfo &lhs,
+                      const MemoryRegionInfo &rhs) {
+  return lhs.GetRange() < rhs.GetRange();
+}
+
+inline bool operator<(const MemoryRegionInfo &lhs, lldb::addr_t rhs) {
+  return lhs.GetRange().GetRangeBase() < rhs;
+}
+
+inline bool operator<(lldb::addr_t lhs, const MemoryRegionInfo &rhs) {
+  return lhs < rhs.GetRange().GetRangeBase();
+}
+
 }
 
 namespace llvm {
 template <>
 struct format_provider<lldb_private::MemoryRegionInfo::OptionalBool> {
   static void format(const lldb_private::MemoryRegionInfo::OptionalBool &B,
                      raw_ostream &OS, StringRef Options) {
     switch(B) {

lldb.xcodeproj/xcshareddata/xcschemes/desktop.xcscheme

<TestAction
             BlueprintName = "lldb-tool"
             ReferencedContainer = "container:lldb.xcodeproj">
          </BuildableReference>
       </MacroExpansion>
       <AdditionalOptions>
       </AdditionalOptions>
    </TestAction>
    <LaunchAction
-      buildConfiguration = "DebugClang"
+      buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       launchStyle = "1"
       useCustomWorkingDirectory = "NO"
       ignoresPersistentStateOnLaunch = "NO"
       debugDocumentVersioning = "YES"
       debugServiceExtension = "internal"
       allowLocationSimulation = "YES">

source/Plugins/Process/minidump/MinidumpParser.h

public:
   std::vector<const MinidumpModule *> GetFilteredModuleList();
 
   const MinidumpExceptionStream *GetExceptionStream();
 
   llvm::Optional<Range> FindMemoryRange(lldb::addr_t addr);
 
   llvm::ArrayRef<uint8_t> GetMemory(lldb::addr_t addr, size_t size);
 
-  llvm::Optional<MemoryRegionInfo> GetMemoryRegionInfo(lldb::addr_t);
+  llvm::Optional<MemoryRegionInfo> GetMemoryRegionInfo(lldb::addr_t load_addr);
 
   // Perform consistency checks and initialize internal data structures
   Status Initialize();
 
 private:
   MinidumpParser(const lldb::DataBufferSP &data_buf_sp);
 
+  bool CreateRegionsCacheFromLinuxMaps();
+  bool CreateRegionsCacheFromMemoryInfoList();
+  bool CreateRegionsCacheFromMemoryList();
+  bool CreateRegionsCacheFromMemory64List();
+  llvm::Optional<MemoryRegionInfo>
+      FindMemoryRegion(lldb::addr_t load_addr) const;
+
 private:
   lldb::DataBufferSP m_data_sp;
   llvm::DenseMap<uint32_t, MinidumpLocationDescriptor> m_directory_map;
   ArchSpec m_arch;
+  std::vector<MemoryRegionInfo> m_regions;
+  bool m_parsed_regions = false;
 };
 
 } // end namespace minidump
 } // end namespace lldb_private
 #endif // liblldb_MinidumpParser_h_

source/Plugins/Process/minidump/MinidumpParser.cpp

 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/LLDBAssert.h"
 
 // C includes
 // C++ includes
 #include <algorithm>
 #include <map>
 #include <vector>
+#include <utility>
 
 using namespace lldb_private;
 using namespace minidump;
 
 llvm::Optional<MinidumpParser>
 MinidumpParser::Create(const lldb::DataBufferSP &data_buf_sp) {
   if (data_buf_sp->GetByteSize() < sizeof(MinidumpHeader)) {
     return llvm::None;
llvm::ArrayRef<uint8_t> MinidumpParser::GetMemory(lldb::addr_t addr,
 
   if (addr < range->start || offset >= range->range_ref.size())
     return {};
 
   const size_t overlap = std::min(size, range->range_ref.size() - offset);
   return range->range_ref.slice(offset, overlap);
 }
 
-llvm::Optional<MemoryRegionInfo>
-MinidumpParser::GetMemoryRegionInfo(lldb::addr_t load_addr) {
-  MemoryRegionInfo info;
-  llvm::ArrayRef<uint8_t> data = GetStream(MinidumpStreamType::MemoryInfoList);
+bool MinidumpParser::CreateRegionsCacheFromLinuxMaps() {
+  llvm::ArrayRef<uint8_t> data = GetStream(MinidumpStreamType::LinuxMaps);
   if (data.empty())
-    return llvm::None;
+    return false;
+  auto text = llvm::toStringRef(data);
+  llvm::StringRef line;
+  constexpr auto yes = MemoryRegionInfo::eYes;
+  constexpr auto no = MemoryRegionInfo::eNo;
+  while (!text.empty()) {
+    std::tie(line, text) = text.split('\n');
+    // Parse the linux maps line. Example line is:
+    // 400b3000-400b5000 r-xp 00000000 b3:17 159        /system/bin/app_process
+    uint64_t start_addr, end_addr, offset;
+    uint32_t device_major, device_minor, inode;
+    if (line.consumeInteger(16, start_addr))
+      continue;
+    if (!line.consume_front("-"))
+      continue;
+    if (line.consumeInteger(16, end_addr))
+      continue;
+    line = line.ltrim();
+    llvm::StringRef permissions = line.substr(0, 4);
+    line = line.drop_front(4);
+    line = line.ltrim();
+    if (line.consumeInteger(16, offset))
+      continue;
+    line = line.ltrim();
+    if (line.consumeInteger(16, device_major))
+      continue;
+    if (!line.consume_front(":"))
+      continue;
+    if (line.consumeInteger(16, device_minor))
+      continue;
+    line = line.ltrim();
+    if (line.consumeInteger(16, inode))
+      continue;
+    line = line.ltrim();
+    llvm::StringRef pathname = line;
+    MemoryRegionInfo region;
+    region.GetRange().SetRangeBase(start_addr);
+    region.GetRange().SetRangeEnd(end_addr);
+    region.SetName(pathname.str().c_str());
+    region.SetReadable(permissions[0] == 'r' ? yes : no);
+    region.SetWritable(permissions[1] == 'w' ? yes : no);
+    region.SetExecutable(permissions[2] == 'x' ? yes : no);
+    region.SetMapped(yes);
+    m_regions.push_back(region);
+  }
+  return !m_regions.empty();
+}
 
+bool MinidumpParser::CreateRegionsCacheFromMemoryInfoList() {
+  llvm::ArrayRef<uint8_t> data = GetStream(MinidumpStreamType::MemoryInfoList);
+  if (data.empty())
+    return false;
   std::vector<const MinidumpMemoryInfo *> mem_info_list =
       MinidumpMemoryInfo::ParseMemoryInfoList(data);
   if (mem_info_list.empty())
-    return llvm::None;
+    return false;
   
-  const auto yes = MemoryRegionInfo::eYes;
-  const auto no = MemoryRegionInfo::eNo;
+  constexpr auto yes = MemoryRegionInfo::eYes;
+  constexpr auto no = MemoryRegionInfo::eNo;
 
-  const MinidumpMemoryInfo *next_entry = nullptr;
   for (const auto &entry : mem_info_list) {
-    const auto head = entry->base_address;
-    const auto tail = head + entry->region_size;
+    MemoryRegionInfo region;
+    region.GetRange().SetRangeBase(entry->base_address);
+    region.GetRange().SetByteSize(entry->region_size);
+    region.SetReadable(entry->isReadable() ? yes : no);
+    region.SetWritable(entry->isWritable() ? yes : no);
+    region.SetExecutable(entry->isExecutable() ? yes : no);
+    region.SetMapped(entry->isMapped() ? yes : no);
+    m_regions.push_back(region);
+  }
+  return !m_regions.empty();
+}
+
+bool MinidumpParser::CreateRegionsCacheFromMemoryList() {
+  llvm::ArrayRef<uint8_t> data = GetStream(MinidumpStreamType::MemoryList);
+  
+  if (data.empty())
+    return false;
+  
+  llvm::ArrayRef<MinidumpMemoryDescriptor> memory_list =
+      MinidumpMemoryDescriptor::ParseMemoryList(data);
+    
+  if (memory_list.empty())
+    return false;
     
-    if (head <= load_addr && load_addr < tail) {
-      info.GetRange().SetRangeBase(
-          (entry->state != uint32_t(MinidumpMemoryInfoState::MemFree))
-              ? head
-              : load_addr);
-      info.GetRange().SetRangeEnd(tail);
-
-      const uint32_t PageNoAccess =
-          static_cast<uint32_t>(MinidumpMemoryProtectionContants::PageNoAccess);
-      info.SetReadable((entry->protect & PageNoAccess) == 0 ? yes : no);
-
-      const uint32_t PageWritable =
-          static_cast<uint32_t>(MinidumpMemoryProtectionContants::PageWritable);
-      info.SetWritable((entry->protect & PageWritable) != 0 ? yes : no);
-
-      const uint32_t PageExecutable = static_cast<uint32_t>(
-          MinidumpMemoryProtectionContants::PageExecutable);
-      info.SetExecutable((entry->protect & PageExecutable) != 0 ? yes : no);
-
-      const uint32_t MemFree =
-          static_cast<uint32_t>(MinidumpMemoryInfoState::MemFree);
-      info.SetMapped((entry->state != MemFree) ? yes : no);
-
-      return info;
-    } else if (head > load_addr &&
-               (next_entry == nullptr || head < next_entry->base_address)) {
-      // In case there is no region containing load_addr keep track of the
-      // nearest region after load_addr so we can return the distance to it.
-      next_entry = entry;
-    }
-  }
+  for (const auto &memory_desc : memory_list) {
+    if (memory_desc.memory.data_size == 0)
+      continue;
+    MemoryRegionInfo region;
+    region.GetRange().SetRangeBase(memory_desc.start_of_memory_range);
+    region.GetRange().SetByteSize(memory_desc.memory.data_size);
+    region.SetMapped(MemoryRegionInfo::eYes);
+    m_regions.push_back(region);
+  return !m_regions.empty();
 
-  // No containing region found. Create an unmapped region that extends to the
-  // next region or LLDB_INVALID_ADDRESS
-  info.GetRange().SetRangeBase(load_addr);
-  info.GetRange().SetRangeEnd((next_entry != nullptr) ? next_entry->base_address
-                                                      : LLDB_INVALID_ADDRESS);
-  info.SetReadable(no);
-  info.SetWritable(no);
-  info.SetExecutable(no);
-  info.SetMapped(no);
-
-  // Note that the memory info list doesn't seem to contain ranges in kernel
-  // space, so if you're walking a stack that has kernel frames, the stack may
-  // appear truncated.
-  return info;
+bool MinidumpParser::CreateRegionsCacheFromMemory64List() {
+  llvm::ArrayRef<uint8_t> data = GetStream(MinidumpStreamType::Memory64List);
+  
+  if (data.empty())
+    return false;
+  
+  llvm::ArrayRef<MinidumpMemoryDescriptor64> memory64_list;
+  uint64_t base_rva;
+  std::tie(memory64_list, base_rva) =
+      MinidumpMemoryDescriptor64::ParseMemory64List(data);
+  
+  if (memory64_list.empty())
+    return false;
+    
+  for (const auto &memory_desc : memory64_list) {
+    if (memory_desc.data_size == 0)
+      continue;
+    MemoryRegionInfo region;
+    region.GetRange().SetRangeBase(memory_desc.start_of_memory_range);
+    region.GetRange().SetByteSize(memory_desc.data_size);
+    region.SetMapped(MemoryRegionInfo::eYes);
+    m_regions.push_back(region);
+  }
+  return !m_regions.empty();
+}
+
+llvm::Optional<MemoryRegionInfo>
+MinidumpParser::FindMemoryRegion(lldb::addr_t load_addr) const {
+  auto begin = m_regions.begin();
+  auto end = m_regions.end();
+  auto pos = std::lower_bound(begin, end, load_addr);
+  if (pos != end && pos->GetRange().Contains(load_addr))
+    return *pos;
+  if (pos != begin) {
+    --pos;
+    if (pos->GetRange().Contains(load_addr))
+      return *pos;
+  }
+  
+  MemoryRegionInfo region;
+  if (pos == begin)
+    region.GetRange().SetRangeBase(0);
+  else {
+    auto prev = pos - 1;
+    region.GetRange().SetRangeBase(prev->GetRange().GetRangeEnd());
+  }
+  if (pos == end)
+    region.GetRange().SetRangeEnd(UINT64_MAX);
+  else
+    region.GetRange().SetRangeEnd(pos->GetRange().GetRangeBase());
+  region.SetReadable(MemoryRegionInfo::eNo);
+  region.SetWritable(MemoryRegionInfo::eNo);
+  region.SetExecutable(MemoryRegionInfo::eNo);
+  region.SetMapped(MemoryRegionInfo::eNo);
+  return region;
+}
+
+llvm::Optional<MemoryRegionInfo>
+MinidumpParser::GetMemoryRegionInfo(lldb::addr_t load_addr) {
+  // See if we have cached our memory regions yet?
+  if (m_parsed_regions)
+    return FindMemoryRegion(load_addr);
+
+  // We haven't cached our memory regions yet we will create the region cache
+  // once. We create the region cache using the best source. We start with the
+  // linux maps since they are the most complete and have names for the regions.
+  // Next we try the MemoryInfoList since it has read/write/execute/map data,
+  // and then fall back to the MemoryList and Memory64List to just get a list
+  // of the memory that is mapped in this core file
+  m_parsed_regions = true;
+  if (!CreateRegionsCacheFromLinuxMaps())
+    if (!CreateRegionsCacheFromMemoryInfoList())
+      if (!CreateRegionsCacheFromMemoryList())
+        CreateRegionsCacheFromMemory64List();
+  std::sort(m_regions.begin(), m_regions.end());
+  return FindMemoryRegion(load_addr);
 }
 
 Status MinidumpParser::Initialize() {
   Status error;
 
   lldbassert(m_directory_map.empty());
 
   llvm::ArrayRef<uint8_t> header_data(m_data_sp->GetBytes(),
                                       sizeof(MinidumpHeader));
   const MinidumpHeader *header = MinidumpHeader::Parse(header_data);
   if (header == nullptr) {
     error.SetErrorString("invalid minidump: can't parse the header");
     return error;
   }
 
   // A minidump without at least one stream is clearly ill-formed
   if (header->streams_count == 0) {
     error.SetErrorString("invalid minidump: no streams present");
     return error;
   }
 
   struct FileRange {
     uint32_t offset = 0;
     uint32_t size = 0;
 
     FileRange(uint32_t offset, uint32_t size) : offset(offset), size(size) {}
     uint32_t end() const { return offset + size; }
   };
 

source/Plugins/Process/minidump/MinidumpTypes.h

 struct MinidumpMemoryInfoListHeader {
   llvm::support::ulittle32_t size_of_header;
   llvm::support::ulittle32_t size_of_entry;
   llvm::support::ulittle64_t num_of_entries;
 };
 static_assert(sizeof(MinidumpMemoryInfoListHeader) == 16,
               "sizeof MinidumpMemoryInfoListHeader is not correct!");
 
-// Reference:
-// https://msdn.microsoft.com/en-us/library/windows/desktop/ms680386(v=vs.85).aspx
-struct MinidumpMemoryInfo {
-  llvm::support::ulittle64_t base_address;
-  llvm::support::ulittle64_t allocation_base;
-  llvm::support::ulittle32_t allocation_protect;
-  llvm::support::ulittle32_t alignment1;
-  llvm::support::ulittle64_t region_size;
-  llvm::support::ulittle32_t state;
-  llvm::support::ulittle32_t protect;
-  llvm::support::ulittle32_t type;
-  llvm::support::ulittle32_t alignment2;
-
-  static std::vector<const MinidumpMemoryInfo *>
-  ParseMemoryInfoList(llvm::ArrayRef<uint8_t> &data);
-};
-static_assert(sizeof(MinidumpMemoryInfo) == 48,
-              "sizeof MinidumpMemoryInfo is not correct!");
-
 enum class MinidumpMemoryInfoState : uint32_t {
   MemCommit = 0x1000,
   MemFree = 0x10000,
   MemReserve = 0x2000,
   LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ MemFree)
 };
 
 enum class MinidumpMemoryInfoType : uint32_t {
enum class MinidumpMemoryProtectionContants : uint32_t {
   PageWritable = PageExecuteReadWrite | PageExecuteWriteCopy | PageReadWrite |
                  PageWriteCopy,
   PageExecutable = PageExecute | PageExecuteRead | PageExecuteReadWrite |
                    PageExecuteWriteCopy,
   LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ PageTargetsInvalid)
 };
 
 // Reference:
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms680386(v=vs.85).aspx
+struct MinidumpMemoryInfo {
+  llvm::support::ulittle64_t base_address;
+  llvm::support::ulittle64_t allocation_base;
+  llvm::support::ulittle32_t allocation_protect;
+  llvm::support::ulittle32_t alignment1;
+  llvm::support::ulittle64_t region_size;
+  llvm::support::ulittle32_t state;
+  llvm::support::ulittle32_t protect;
+  llvm::support::ulittle32_t type;
+  llvm::support::ulittle32_t alignment2;
+
+  static std::vector<const MinidumpMemoryInfo *>
+  ParseMemoryInfoList(llvm::ArrayRef<uint8_t> &data);
+
+  bool isReadable() const {
+    const auto mask = MinidumpMemoryProtectionContants::PageNoAccess;
+    return (static_cast<uint32_t>(mask) & protect) == 0;
+  }
+
+  bool isWritable() const {
+    const auto mask = MinidumpMemoryProtectionContants::PageWritable;
+    return (static_cast<uint32_t>(mask) & protect) != 0;
+  }
+
+  bool isExecutable() const {
+    const auto mask = MinidumpMemoryProtectionContants::PageExecutable;
+    return (static_cast<uint32_t>(mask) & protect) != 0;
+  }
+  
+  bool isMapped() const {
+    return state != static_cast<uint32_t>(MinidumpMemoryInfoState::MemFree);
+  }
+};
+
+static_assert(sizeof(MinidumpMemoryInfo) == 48,
+              "sizeof MinidumpMemoryInfo is not correct!");
+
+// Reference:
 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms680517(v=vs.85).aspx
 struct MinidumpThread {
   llvm::support::ulittle32_t thread_id;
   llvm::support::ulittle32_t suspend_count;
   llvm::support::ulittle32_t priority_class;
   llvm::support::ulittle32_t priority;
   llvm::support::ulittle64_t teb;
   MinidumpMemoryDescriptor stack;