[lldb-server] Skip shared regions for memory allocation

[DavidSpickett]

lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp

299

I don't see a test for a mapping with "s" for the sharing char, did I miss it?

[emrekultursay]

Added test that covers shared (s) input

[emrekultursay]

Removed redundant comment

[emrekultursay]

PTAL.

lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp

299

I added tests to cover shared (s). Thanks for noticing the missing test.

[labath]

Looks good, thanks for fixing this.

[emrekultursay]

Thanks. Please commit on my behalf.

lldb/include/lldb/Target/MemoryRegionInfo.h

 class MemoryRegionInfo {
 public:
   typedef Range<lldb::addr_t, lldb::addr_t> RangeType;
 
   enum OptionalBool { eDontKnow = -1, eNo = 0, eYes = 1 };
 
   MemoryRegionInfo() = default;
   MemoryRegionInfo(RangeType range, OptionalBool read, OptionalBool write,
-                   OptionalBool execute, OptionalBool mapped, ConstString name,
+                   OptionalBool execute, OptionalBool shared,
+                   OptionalBool mapped, ConstString name,
                    OptionalBool flash, lldb::offset_t blocksize,
                    OptionalBool memory_tagged, OptionalBool stack_memory)
       : m_range(range), m_read(read), m_write(write), m_execute(execute),
-        m_mapped(mapped), m_name(name), m_flash(flash), m_blocksize(blocksize),
-        m_memory_tagged(memory_tagged), m_is_stack_memory(stack_memory) {}
+        m_shared(shared), m_mapped(mapped), m_name(name), m_flash(flash),
+        m_blocksize(blocksize), m_memory_tagged(memory_tagged),
+        m_is_stack_memory(stack_memory) {}
 
   RangeType &GetRange() { return m_range; }
 
   void Clear() { *this = MemoryRegionInfo(); }
 
   const RangeType &GetRange() const { return m_range; }
 
   OptionalBool GetReadable() const { return m_read; }
 
   OptionalBool GetWritable() const { return m_write; }
 
   OptionalBool GetExecutable() const { return m_execute; }
 
+  OptionalBool GetShared() const { return m_shared; }
+
   OptionalBool GetMapped() const { return m_mapped; }
 
   ConstString GetName() const { return m_name; }
 
   OptionalBool GetMemoryTagged() const { return m_memory_tagged; }
 
   void SetReadable(OptionalBool val) { m_read = val; }
 
   void SetWritable(OptionalBool val) { m_write = val; }
 
   void SetExecutable(OptionalBool val) { m_execute = val; }
 
+  void SetShared(OptionalBool val) { m_shared = val; }
+
   void SetMapped(OptionalBool val) { m_mapped = val; }
 
   void SetName(const char *name) { m_name = ConstString(name); }
 
   OptionalBool GetFlash() const { return m_flash; }
 
   void SetFlash(OptionalBool val) { m_flash = val; }
 
void SetLLDBPermissions(uint32_t permissions) {
     m_read = (permissions & lldb::ePermissionsReadable) ? eYes : eNo;
     m_write = (permissions & lldb::ePermissionsWritable) ? eYes : eNo;
     m_execute = (permissions & lldb::ePermissionsExecutable) ? eYes : eNo;
   }
 
   bool operator==(const MemoryRegionInfo &rhs) const {
     return m_range == rhs.m_range && m_read == rhs.m_read &&
            m_write == rhs.m_write && m_execute == rhs.m_execute &&
+           m_shared == rhs.m_shared &&
            m_mapped == rhs.m_mapped && m_name == rhs.m_name &&
            m_flash == rhs.m_flash && m_blocksize == rhs.m_blocksize &&
            m_memory_tagged == rhs.m_memory_tagged &&
            m_pagesize == rhs.m_pagesize &&
            m_is_stack_memory == rhs.m_is_stack_memory;
   }
 
   bool operator!=(const MemoryRegionInfo &rhs) const { return !(*this == rhs); }
void SetDirtyPageList(std::vector<lldb::addr_t> pagelist) {
     m_dirty_pages = std::move(pagelist);
   }
 
 protected:
   RangeType m_range;
   OptionalBool m_read = eDontKnow;
   OptionalBool m_write = eDontKnow;
   OptionalBool m_execute = eDontKnow;
+  OptionalBool m_shared = eDontKnow;
   OptionalBool m_mapped = eDontKnow;
   ConstString m_name;
   OptionalBool m_flash = eDontKnow;
   lldb::offset_t m_blocksize = 0;
   OptionalBool m_memory_tagged = eDontKnow;
   OptionalBool m_is_stack_memory = eDontKnow;
   int m_pagesize = 0;
   llvm::Optional<std::vector<lldb::addr_t>> m_dirty_pages;

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

LLDB_LOG(log, "clearing {0} entries from memory region cache",
            m_mem_region_cache.size());
   m_mem_region_cache.clear();
 }
 
 llvm::Expected<uint64_t>
 NativeProcessLinux::Syscall(llvm::ArrayRef<uint64_t> args) {
   PopulateMemoryRegionCache();
   auto region_it = llvm::find_if(m_mem_region_cache, [](const auto &pair) {
-    return pair.first.GetExecutable() == MemoryRegionInfo::eYes;
+    return pair.first.GetExecutable() == MemoryRegionInfo::eYes &&
+        pair.first.GetShared() != MemoryRegionInfo::eYes;
   });
   if (region_it == m_mem_region_cache.end())
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "No executable memory region found!");
 
   addr_t exe_addr = region_it->first.GetRange().GetRangeBase();
 
   NativeThreadLinux &thread = *GetCurrentThread();

lldb/source/Plugins/Process/Utility/LinuxProcMaps.cpp

ParseMemoryRegionInfoFromProcMapsLine(llvm::StringRef maps_line,
   if (exec_perm_char == 'x')
     region.SetExecutable(MemoryRegionInfo::OptionalBool::eYes);
   else if (exec_perm_char == '-')
     region.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
   else
     return ProcMapError("unexpected /proc/{pid}/%s exec permission char",
                         maps_kind);
 
-  line_extractor.GetChar();              // Read the private bit
+  // Handle sharing status (private/shared).
+  const char sharing_char = line_extractor.GetChar();
+  if (sharing_char == 's')
+    region.SetShared(MemoryRegionInfo::OptionalBool::eYes);
+  else if (sharing_char == 'p')
+    region.SetShared(MemoryRegionInfo::OptionalBool::eNo);
+  else
+    region.SetShared(MemoryRegionInfo::OptionalBool::eDontKnow);
+
   line_extractor.SkipSpaces();           // Skip the separator
   line_extractor.GetHexMaxU64(false, 0); // Read the offset
   line_extractor.GetHexMaxU64(false, 0); // Read the major device number
   line_extractor.GetChar();              // Read the device id separator
   line_extractor.GetHexMaxU64(false, 0); // Read the major device number
   line_extractor.SkipSpaces();           // Skip the separator
   line_extractor.GetU64(0, 10);          // Read the inode number
 

lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp

::testing::Values(
         std::make_tuple("0-0 rwzp 00000000 00:00 0", MemoryRegionInfos{},
                         "unexpected /proc/{pid}/maps exec permission char"),
         // Stops at first parsing error
         std::make_tuple(
             "0-1 rw-p 00000000 00:00 0 [abc]\n"
             "0-0 rwzp 00000000 00:00 0\n"
             "2-3 r-xp 00000000 00:00 0 [def]\n",
             MemoryRegionInfos{
-                MemoryRegionInfo(make_range(0, 1), MemoryRegionInfo::eYes,
-                                 MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                MemoryRegionInfo(make_range(0, 1), MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                                 MemoryRegionInfo::eNo,
                                  MemoryRegionInfo::eYes, ConstString("[abc]"),
                                  MemoryRegionInfo::eDontKnow, 0,
                                  MemoryRegionInfo::eDontKnow,
                                  MemoryRegionInfo::eDontKnow),
             },
             "unexpected /proc/{pid}/maps exec permission char"),
         // Single entry
         std::make_tuple(
             "55a4512f7000-55a451b68000 rw-p 00000000 00:00 0    [heap]",
             MemoryRegionInfos{
                 MemoryRegionInfo(
                     make_range(0x55a4512f7000, 0x55a451b68000),
-                    MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
-                    MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
+                    MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eYes,
                     ConstString("[heap]"), MemoryRegionInfo::eDontKnow, 0,
                     MemoryRegionInfo::eDontKnow, MemoryRegionInfo::eDontKnow),
             },
             ""),
         // Multiple entries
         std::make_tuple(
             "7fc090021000-7fc094000000 ---p 00000000 00:00 0\n"
+            "7fc094000000-7fc094a00000 ---s 00000000 00:00 0\n"
             "ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 "
             "[vsyscall]",
             MemoryRegionInfos{
                 MemoryRegionInfo(
                     make_range(0x7fc090021000, 0x7fc094000000),
-                    MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
-                    MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
+                    MemoryRegionInfo::eNo, MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eYes,
+                    ConstString(nullptr), MemoryRegionInfo::eDontKnow, 0,
+                    MemoryRegionInfo::eDontKnow, MemoryRegionInfo::eDontKnow),
+                MemoryRegionInfo(
+                    make_range(0x7fc094000000, 0x7fc094a00000),
+                    MemoryRegionInfo::eNo, MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eYes,
+                    MemoryRegionInfo::eYes,
                     ConstString(nullptr), MemoryRegionInfo::eDontKnow, 0,
                     MemoryRegionInfo::eDontKnow, MemoryRegionInfo::eDontKnow),
                 MemoryRegionInfo(
                     make_range(0xffffffffff600000, 0xffffffffff601000),
-                    MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
-                    MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
+                    MemoryRegionInfo::eYes, MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
+                    MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eYes,
                     ConstString("[vsyscall]"), MemoryRegionInfo::eDontKnow, 0,
                     MemoryRegionInfo::eDontKnow, MemoryRegionInfo::eDontKnow),
             },
             "")));
 
 class LinuxProcSMapsTestFixture : public LinuxProcMapsTestFixture {};
 
 INSTANTIATE_TEST_SUITE_P(
     ProcSMapTests, LinuxProcSMapsTestFixture,
     ::testing::Values(
         // Nothing in nothing out
         std::make_tuple("", MemoryRegionInfos{}, ""),
         // Uses the same parsing for first line, so same errors but referring to
         // smaps
         std::make_tuple("0/0 rw-p 00000000 00:00 0", MemoryRegionInfos{},
                         "malformed /proc/{pid}/smaps entry, missing dash "
                         "between address range"),
         // Stop parsing at first error
         std::make_tuple(
             "1111-2222 rw-p 00000000 00:00 0 [foo]\n"
             "0/0 rw-p 00000000 00:00 0",
             MemoryRegionInfos{
                 MemoryRegionInfo(
-                    make_range(0x1111, 0x2222), MemoryRegionInfo::eYes,
-                    MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    make_range(0x1111, 0x2222),
+                    MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eNo,
                     MemoryRegionInfo::eYes, ConstString("[foo]"),
                     MemoryRegionInfo::eDontKnow, 0, MemoryRegionInfo::eDontKnow,
                     MemoryRegionInfo::eDontKnow),
             },
             "malformed /proc/{pid}/smaps entry, missing dash between address "
             "range"),
         // Property line without a region is an error
         std::make_tuple("Referenced:         2188 kB\n"
                         "1111-2222 rw-p 00000000 00:00 0    [foo]\n"
                         "3333-4444 rw-p 00000000 00:00 0    [bar]\n",
                         MemoryRegionInfos{},
                         "Found a property line without a corresponding mapping "
                         "in /proc/{pid}/smaps"),
         // Single region parses, has no flags
         std::make_tuple(
             "1111-2222 rw-p 00000000 00:00 0    [foo]",
             MemoryRegionInfos{
                 MemoryRegionInfo(
-                    make_range(0x1111, 0x2222), MemoryRegionInfo::eYes,
-                    MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    make_range(0x1111, 0x2222),
+                    MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eYes, ConstString("[foo]"),
+                    MemoryRegionInfo::eDontKnow, 0, MemoryRegionInfo::eDontKnow,
+                    MemoryRegionInfo::eDontKnow),
+            },
+            ""),
+        // Single shared region parses, has no flags
+        std::make_tuple(
+            "1111-2222 rw-s 00000000 00:00 0    [foo]",
+            MemoryRegionInfos{
+                MemoryRegionInfo(
+                    make_range(0x1111, 0x2222),
+                    MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eYes,
                     MemoryRegionInfo::eYes, ConstString("[foo]"),
                     MemoryRegionInfo::eDontKnow, 0, MemoryRegionInfo::eDontKnow,
                     MemoryRegionInfo::eDontKnow),
             },
             ""),
         // Single region with flags, other lines ignored
         std::make_tuple(
             "1111-2222 rw-p 00000000 00:00 0    [foo]\n"
             "Referenced:         2188 kB\n"
             "AnonHugePages:         0 kB\n"
             "VmFlags: mt",
             MemoryRegionInfos{
                 MemoryRegionInfo(
-                    make_range(0x1111, 0x2222), MemoryRegionInfo::eYes,
-                    MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    make_range(0x1111, 0x2222),
+                    MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eNo,
                     MemoryRegionInfo::eYes, ConstString("[foo]"),
                     MemoryRegionInfo::eDontKnow, 0, MemoryRegionInfo::eYes,
                     MemoryRegionInfo::eDontKnow),
             },
             ""),
         // Whitespace ignored
         std::make_tuple(
             "0-0 rw-p 00000000 00:00 0\n"
             "VmFlags:      mt      ",
             MemoryRegionInfos{
-                MemoryRegionInfo(make_range(0, 0), MemoryRegionInfo::eYes,
-                                 MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                MemoryRegionInfo(make_range(0, 0),
+                                 MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                                 MemoryRegionInfo::eNo,
                                  MemoryRegionInfo::eYes, ConstString(nullptr),
                                  MemoryRegionInfo::eDontKnow, 0,
                                  MemoryRegionInfo::eYes,
                                  MemoryRegionInfo::eDontKnow),
             },
             ""),
         // VmFlags line means it has flag info, but nothing is set
         std::make_tuple(
             "0-0 rw-p 00000000 00:00 0\n"
             "VmFlags:         ",
             MemoryRegionInfos{
-                MemoryRegionInfo(make_range(0, 0), MemoryRegionInfo::eYes,
-                                 MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                MemoryRegionInfo(make_range(0, 0),
+                                 MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                                 MemoryRegionInfo::eNo,
                                  MemoryRegionInfo::eYes, ConstString(nullptr),
                                  MemoryRegionInfo::eDontKnow, 0,
                                  MemoryRegionInfo::eNo,
                                  MemoryRegionInfo::eDontKnow),
             },
             ""),
         // Handle some pages not having a flags line
         std::make_tuple(
             "1111-2222 rw-p 00000000 00:00 0    [foo]\n"
             "Referenced:         2188 kB\n"
             "AnonHugePages:         0 kB\n"
             "3333-4444 r-xp 00000000 00:00 0    [bar]\n"
             "VmFlags: mt",
             MemoryRegionInfos{
                 MemoryRegionInfo(
-                    make_range(0x1111, 0x2222), MemoryRegionInfo::eYes,
-                    MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    make_range(0x1111, 0x2222),
+                    MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eNo,
                     MemoryRegionInfo::eYes, ConstString("[foo]"),
                     MemoryRegionInfo::eDontKnow, 0, MemoryRegionInfo::eDontKnow,
                     MemoryRegionInfo::eDontKnow),
                 MemoryRegionInfo(
-                    make_range(0x3333, 0x4444), MemoryRegionInfo::eYes,
-                    MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
+                    make_range(0x3333, 0x4444), MemoryRegionInfo::eYes, MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
+                    MemoryRegionInfo::eNo,
                     MemoryRegionInfo::eYes, ConstString("[bar]"),
                     MemoryRegionInfo::eDontKnow, 0, MemoryRegionInfo::eYes,
                     MemoryRegionInfo::eDontKnow),
             },
             ""),
         // Handle no pages having a flags line (older kernels)
         std::make_tuple(
             "1111-2222 rw-p 00000000 00:00 0\n"
             "Referenced:         2188 kB\n"
             "AnonHugePages:         0 kB\n"
             "3333-4444 r-xp 00000000 00:00 0\n"
             "KernelPageSize:        4 kB\n"
             "MMUPageSize:           4 kB\n",
             MemoryRegionInfos{
                 MemoryRegionInfo(
-                    make_range(0x1111, 0x2222), MemoryRegionInfo::eYes,
-                    MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    make_range(0x1111, 0x2222),
+                    MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                    MemoryRegionInfo::eNo,
                     MemoryRegionInfo::eYes, ConstString(nullptr),
                     MemoryRegionInfo::eDontKnow, 0, MemoryRegionInfo::eDontKnow,
                     MemoryRegionInfo::eDontKnow),
                 MemoryRegionInfo(
-                    make_range(0x3333, 0x4444), MemoryRegionInfo::eYes,
-                    MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
+                    make_range(0x3333, 0x4444),
+                    MemoryRegionInfo::eYes, MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
+                    MemoryRegionInfo::eNo,
                     MemoryRegionInfo::eYes, ConstString(nullptr),
                     MemoryRegionInfo::eDontKnow, 0, MemoryRegionInfo::eDontKnow,
                     MemoryRegionInfo::eDontKnow),
             },
             "")));
 
 TEST_P(LinuxProcSMapsTestFixture, ParseSMapRegions) {
   auto params = GetParam();
   ParseLinuxSMapRegions(std::get<0>(params), callback);
   check_regions(params);
 }

lldb/unittests/Process/Utility/MemoryTagManagerAArch64MTETest.cpp

TEST(MemoryTagManagerAArch64MTETest, ExpandToGranule) {
   ASSERT_EQ(
       MemoryTagManagerAArch64MTE::TagRange(16, 16),
       manager.ExpandToGranule(MemoryTagManagerAArch64MTE::TagRange(18, 4)));
 }
 
 static MemoryRegionInfo MakeRegionInfo(lldb::addr_t base, lldb::addr_t size,
                                        bool tagged) {
   return MemoryRegionInfo(
-      MemoryRegionInfo::RangeType(base, size), MemoryRegionInfo::eYes,
+      MemoryRegionInfo::RangeType(base, size),
       MemoryRegionInfo::eYes, MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
+      MemoryRegionInfo::eNo,
+      MemoryRegionInfo::eYes,
       ConstString(), MemoryRegionInfo::eNo, 0,
       /*memory_tagged=*/
       tagged ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo,
       MemoryRegionInfo::eDontKnow);
 }
 
 TEST(MemoryTagManagerAArch64MTETest, MakeTaggedRange) {
   MemoryTagManagerAArch64MTE manager;

lldb/unittests/Process/minidump/MinidumpParserTest.cpp

 ...
 )"),
                     llvm::Succeeded());
 
   EXPECT_THAT(
       parser->BuildMemoryRegions(),
       testing::Pair(
           testing::ElementsAre(
-              MemoryRegionInfo({0x0, 0x10000}, no, no, no, no, ConstString(),
+              MemoryRegionInfo({0x0, 0x10000}, no, no, no, unknown, no, ConstString(),
                                unknown, 0, unknown, unknown),
-              MemoryRegionInfo({0x10000, 0x21000}, yes, yes, no, yes,
+              MemoryRegionInfo({0x10000, 0x21000}, yes, yes, no, unknown, yes,
                                ConstString(), unknown, 0, unknown, unknown),
-              MemoryRegionInfo({0x40000, 0x1000}, yes, no, no, yes,
+              MemoryRegionInfo({0x40000, 0x1000}, yes, no, no, unknown, yes,
                                ConstString(), unknown, 0, unknown, unknown),
-              MemoryRegionInfo({0x7ffe0000, 0x1000}, yes, no, no, yes,
+              MemoryRegionInfo({0x7ffe0000, 0x1000}, yes, no, no, unknown, yes,
                                ConstString(), unknown, 0, unknown, unknown),
-              MemoryRegionInfo({0x7ffe1000, 0xf000}, no, no, no, yes,
+              MemoryRegionInfo({0x7ffe1000, 0xf000}, no, no, no, unknown, yes,
                                ConstString(), unknown, 0, unknown, unknown)),
           true));
 }
 
 TEST_F(MinidumpParserTest, GetMemoryRegionInfoFromMemoryList) {
   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 --- !minidump
 Streams:
)"),
 
   // Test we can get memory regions from the MINIDUMP_MEMORY_LIST stream when
   // we don't have a MemoryInfoListStream.
 
   EXPECT_THAT(
       parser->BuildMemoryRegions(),
       testing::Pair(
           testing::ElementsAre(
-              MemoryRegionInfo({0x1000, 0x10}, yes, unknown, unknown, yes,
+              MemoryRegionInfo({0x1000, 0x10}, yes, unknown, unknown, unknown, yes,
                                ConstString(), unknown, 0, unknown, unknown),
-              MemoryRegionInfo({0x2000, 0x20}, yes, unknown, unknown, yes,
+              MemoryRegionInfo({0x2000, 0x20}, yes, unknown, unknown, unknown, yes,
                                ConstString(), unknown, 0, unknown, unknown)),
           false));
 }
 
 TEST_F(MinidumpParserTest, GetMemoryRegionInfoFromMemory64List) {
   SetUpData("regions-memlist64.dmp");
 
   // Test we can get memory regions from the MINIDUMP_MEMORY64_LIST stream when
   // we don't have a MemoryInfoListStream.
   EXPECT_THAT(
       parser->BuildMemoryRegions(),
       testing::Pair(
           testing::ElementsAre(
-              MemoryRegionInfo({0x1000, 0x10}, yes, unknown, unknown, yes,
+              MemoryRegionInfo({0x1000, 0x10}, yes, unknown, unknown, unknown, yes,
                                ConstString(), unknown, 0, unknown, unknown),
-              MemoryRegionInfo({0x2000, 0x20}, yes, unknown, unknown, yes,
+              MemoryRegionInfo({0x2000, 0x20}, yes, unknown, unknown, unknown, yes,
                                ConstString(), unknown, 0, unknown, unknown)),
           false));
 }
 
 TEST_F(MinidumpParserTest, GetMemoryRegionInfoLinuxMaps) {
   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 --- !minidump
 Streams:
)"),
   // we don't have a MemoryInfoListStream.
   ConstString app_process("/system/bin/app_process");
   ConstString linker("/system/bin/linker");
   ConstString liblog("/system/lib/liblog.so");
   EXPECT_THAT(
       parser->BuildMemoryRegions(),
       testing::Pair(
           testing::ElementsAre(
-              MemoryRegionInfo({0x400d9000, 0x2000}, yes, no, yes, yes,
+              MemoryRegionInfo({0x400d9000, 0x2000}, yes, no, yes, no, yes,
                                app_process, unknown, 0, unknown, unknown),
-              MemoryRegionInfo({0x400db000, 0x1000}, yes, no, no, yes,
+              MemoryRegionInfo({0x400db000, 0x1000}, yes, no, no, no, yes,
                                app_process, unknown, 0, unknown, unknown),
-              MemoryRegionInfo({0x400dc000, 0x1000}, yes, yes, no, yes,
+              MemoryRegionInfo({0x400dc000, 0x1000}, yes, yes, no, no, yes,
                                ConstString(), unknown, 0, unknown, unknown),
-              MemoryRegionInfo({0x400ec000, 0x1000}, yes, no, no, yes,
+              MemoryRegionInfo({0x400ec000, 0x1000}, yes, no, no, no, yes,
                                ConstString(), unknown, 0, unknown, unknown),
-              MemoryRegionInfo({0x400ee000, 0x1000}, yes, yes, no, yes, linker,
+              MemoryRegionInfo({0x400ee000, 0x1000}, yes, yes, no, no, yes, linker,
                                unknown, 0, unknown, unknown),
-              MemoryRegionInfo({0x400fc000, 0x1000}, yes, yes, yes, yes, liblog,
+              MemoryRegionInfo({0x400fc000, 0x1000}, yes, yes, yes, no, yes, liblog,
                                unknown, 0, unknown, unknown)),
           true));
 }
 
 TEST_F(MinidumpParserTest, GetMemoryRegionInfoLinuxMapsError) {
   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 --- !minidump
 Streams:
   - Type:            LinuxMaps
     Text:             |
       400d9000-400db000 r?xp 00000000 b3:04 227
       400fc000-400fd000 rwxp 00001000 b3:04 1096
 ...
 )"),
                     llvm::Succeeded());
   // Test that when a /proc/maps region fails to parse
   // we handle the error and continue with the rest.
   EXPECT_THAT(
       parser->BuildMemoryRegions(),
       testing::Pair(testing::ElementsAre(MemoryRegionInfo(
-                        {0x400fc000, 0x1000}, yes, yes, yes, yes,
+                        {0x400fc000, 0x1000}, yes, yes, yes, no, yes,
                         ConstString(nullptr), unknown, 0, unknown, unknown)),
                     true));
 }
 
 // Windows Minidump tests
 TEST_F(MinidumpParserTest, GetArchitectureWindows) {
   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 --- !minidump