[lldb][AArch64/Linux] Show memory tagged memory regions

[DavidSpickett]

Summary

This extends the "memory region" command to
show tagged regions on AArch64 Linux when the MTE
extension is enabled.

(lldb) memory region the_page
[0x0000fffff7ff8000-0x0000fffff7ff9000) rw-
memory tagging: enabled

This is done by adding an optional "flags" field to
the qMemoryRegion packet. The only supported flag is
"mt" but this can be extended.

This "mt" flag is read from /proc/{pid}/smaps on Linux,
other platforms will leave out the "flags" field.

Where this "mt" flag is received "memory region" will
show that it is enabled. If it is not or the target
doesn't support memory tagging, the line is not shown.
(since majority of the time tagging will not be enabled)

Testing is added for the existing /proc/{pid}/maps
parsing and the new smaps parsing.
Minidump parsing has been updated where needed,
though it only uses maps not smaps.

Target specific tests can be run with QEMU and I have
added MTE flags to the existing helper scripts.

[DavidSpickett]

This is in support of AArch64 memory tagging support as described here: http://lists.llvm.org/pipermail/lldb-dev/2020-August/016402.html
See "### Extending qMemoryRegion"

smaps format described here: https://man7.org/linux/man-pages/man5/proc.5.html
Support not added to minidumps, this would need doing in breakpad itself first (https://chromium.googlesource.com/breakpad/breakpad/+/refs/heads/master/src/google_breakpad/common/minidump_format.h#348).

General strategy is to keep the flags as strings so that we don't have to invent a new enum/bitfield value each time one is added. Plus we get to give some value by showing them all to the user without special support.

Later, I'll be adding a HasMemoryTagging() method to the region to use for memory tagging commands, something like:

bool HasMemoryTagging() {
  return m_flags && (m_flags->find("mt") != m_flags->end());
}

If BSD/MacOS/Windows had a different naming you could either check for both (if not overlapping with anything else), or add a platform argument to decide what to look for.

[DavidSpickett]

What isn't covered in testing is checking that "memory region" will not print "flags:" if there was no flag info. This would need a way to make a fake lldbserver that didn't reply with the flags field, I could write tests that expect the "flags:" but then when you ran them on a different kernel they might fail.

Perhaps there is a way to replay a gdb comms session to lldb instead?

[omjavaid]

This seems fine to me with some minor nits. Also do you plan on writing a Linux API test for this which test memory regions on Linux? I couldnt locate one already written.

lldb/source/API/SBMemoryRegionInfo.cpp

125

This function always returns true. If there is no other use of HasFlags API function then may be merge GetFlags and HasFlags by returning false in case flags are not available.

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

19

May be consider converting this into a class enum.

lldb/unittests/Process/minidump/MinidumpParserTest.cpp

9

This file apparently requires a clang-format run.

[DavidSpickett]

• clang-format Minidump file
• Remove HasFlags from API, return True/False from GetFlags instead
• Rename MapKind to MapsKind and make it an enum class

[DavidSpickett]

In D87442#2273064, @omjavaid wrote:

This seems fine to me with some minor nits. Also do you plan on writing a Linux API test for this which test memory regions on Linux? I couldnt locate one already written.

There are some tests in test/API/tools/lldb-server/TestLldbGdbServer.py that parse region packets manually (e.g. qMemoryRegionInfo_reports_code_address_as_executable) but they're not using the API.

There is no test for "memory region" or the API. I'll add some to test/API/linux/, one for Kernels with smaps, one without. (so you'll only run one or the other per platform)

[labath]

I think this patch for its test coverage.

The thing I'm not so sure about is the verbatim passing of the os-specific flags. That's nice for the purpose of displaying them to the user, but it can make things messy for programatic use, particularly if multiple platforms start using these. What's do you intend to do with these flags? Like how many of them are you going to actually use, and for what purpose?

lldb/source/API/SBMemoryRegionInfo.cpp

127

strm << m_opaque_up->GetFlags()

lldb/source/Commands/CommandObjectMemory.cpp

1736

drop .c_str()

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

1308

Is this needed. Given that the parsing will stop at the first error, Result should always be empty (success) at this point)...

1319

Just for my own education: Does this mean that we will need to maintain both branches in perpetuity, as it is always possible to build kernels which don't have /smaps ?

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

19

And get rid of the leading e.

133

Compiling the regex for each line is pretty wasteful. I don't think a regex is really needed here. I think you could just split the line on the first : character and check that lhs does not contain spaces.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

2498

drop .c_str()

lldb/source/Target/MemoryRegionInfo.cpp

21

flags = flags.ltrim();

lldb/unittests/Process/Utility/CMakeLists.txt

6

Why is this needed?

9–10

Just include the file as Plugins/Process/Utility/LinuxProcMaps.h

lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp

39

&-capture here is dangerous. Capture what you need (this?) explicitly.

51–52

ASSERT_THAT(std::get<1>(params), testing::ContainerEq(regions));

[DavidSpickett]

The thing I'm not so sure about is the verbatim passing of the os-specific flags. That's nice for the purpose of displaying them to the user, but it can make things messy for programatic use, particularly if multiple platforms start using these. What's do you intend to do with these flags? Like how many of them are you going to actually use, and for what purpose?

At this point I only need to get the "mt" flag that shows whether a region has memory tagging enabled. This will be used by lldb internally and anyone checking for memory tagging with "memory region".

Some background on the design...

With the current implementation:

• We don't have to translate the flags per OS to show them.
• Has<flag>() needs to check for OS specific names, which balances things out. (you've got an OS specific switch either way)
• The gdb protocol packet just contains the names as strings.
• OSes that don't present flags as strings directly in their API have to provide string versions.

At first I did have a generically named bitset of flags internally. This means that:

• In the "memory region" output the user can't tell the difference between an unrecognised flag, or a flag that's not enabled. Since we'd need to update lldb to handle the new flag. (a rare occurrence now that I think about it)
• When "memory region" prints we'd need to translate those flags to OS specific names, or use long generic names like "memory tagging: enabled". (I prefer the former so you could compare it directly to the native tools)
• A region object's Has<Flag>() is the same code regardless of OS.
• The gdb protocol packet would contain generic versions of the flag names.

Now that I wrote that the second idea does look cleaner. New flags are going to be infrequent and internal calls won't have to care about what OS they're on to query flags.

Is that the direction you were thinking of? If so I'll rework this to do that instead.

[DavidSpickett]

• reset flags in MemoryRegionInfo Clear()
• add Linux specific memory region flags test
• address comments from labath

(doing this before any change of approach,
to prevent any confusion)

[DavidSpickett]

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

1319

Unfortunately yes. The good part is that the header lines remain the same so we can share that code.
(gdb already uses smaps and has a similar fallback route)

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

133

Done and merged into ParseLinuxSMapRegions since it was much simpler.

(I couldn't find any hard guarantee that there won't be leading spaces but from reading kernel source it seems
that it might pad values but not names. So "VmFlags: re" could happen but not " VmFlags: re")

lldb/unittests/Process/Utility/CMakeLists.txt

6

It won't link without it. I followed the format of the other tests e.g. unittests/Process/POSIX/CMakeLists.txt
(you header suggestion does work fine though)

[DavidSpickett]

Fix unit test failures due to dereferencing an empty
optional when smaps parsing failed.

To prevent this happening again pass an
Optional<MemoryRegionInfo> to the callback and let
it decide whether to use it or not.

[labath]

In D87442#2300987, @labath wrote:

I think this patch for its test coverage.

And by "think", I meant "like". :)

In D87442#2311798, @DavidSpickett wrote:

The thing I'm not so sure about is the verbatim passing of the os-specific flags. That's nice for the purpose of displaying them to the user, but it can make things messy for programatic use, particularly if multiple platforms start using these. What's do you intend to do with these flags? Like how many of them are you going to actually use, and for what purpose?

At this point I only need to get the "mt" flag that shows whether a region has memory tagging enabled. This will be used by lldb internally and anyone checking for memory tagging with "memory region".

Some background on the design...

With the current implementation:

• We don't have to translate the flags per OS to show them.
• Has<flag>() needs to check for OS specific names, which balances things out. (you've got an OS specific switch either way)
• The gdb protocol packet just contains the names as strings.
• OSes that don't present flags as strings directly in their API have to provide string versions.

At first I did have a generically named bitset of flags internally. This means that:

• In the "memory region" output the user can't tell the difference between an unrecognised flag, or a flag that's not enabled. Since we'd need to update lldb to handle the new flag. (a rare occurrence now that I think about it)
• When "memory region" prints we'd need to translate those flags to OS specific names, or use long generic names like "memory tagging: enabled". (I prefer the former so you could compare it directly to the native tools)
• A region object's Has<Flag>() is the same code regardless of OS.
• The gdb protocol packet would contain generic versions of the flag names.

Now that I wrote that the second idea does look cleaner. New flags are going to be infrequent and internal calls won't have to care about what OS they're on to query flags.

Is that the direction you were thinking of? If so I'll rework this to do that instead.

Yes, that's pretty much it. I sympathise with wanting to match the native tools, but that's not something lldb is very good at right now (and there's an opposite drive to make lldb behavior consistent across platforms). For now I'd just put on that and have lldb choose an "os-independent" flag name which "happens" to match the linux name (one of the advantages of being first).

That said, with this and @jasonmolenda's change to memory regions, I think the description of a single memory region becomes too complicated to reasonably fit on a single line. I think we might want to change the output of memory region to span multiple lines, at which point, the string "memory tagging: enabled" might not look too bad (we could add headings for other properties too).

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

1301–1338

If we're changing the signature, we might as well make this Expected<MemoryRegionInfo>.

1323

We normally don't put braces around simple if statements like this: http://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

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

160

name.contains(' ')

[DavidSpickett]

Yes, that's pretty much it.

Great, I will rework this.

[DavidSpickett]

• Move to llvm::Expected for callbacks
• Use flag names based on Linux names but for all platforms
• Show generic names/descriptions in memory region output
• Add minidump cases for error handling

[DavidSpickett]

If you are wondering, the average number of flags for a Linux hello world's memory regions is 8 so 8 lines of output. Here's an example I had that does madvise.

(lldb) memory region addr
[0x00007ffff7ed5000-0x00007ffff7fd5000) rw- /dev/zero (deleted)
flags:
readable
writeable
shared
may read
may write
may execute
may share
soft-dirty
(lldb) n
(lldb) n (over madvise(addr, len, MADV_DONTFORK);)
(lldb) memory region addr
[0x00007ffff7ed5000-0x00007ffff7fd5000) rw- /dev/zero (deleted)
flags:
readable
writeable
shared
may read
may write
may execute
may share
do not copy area on fork
soft-dirty

I could add this as a test case but it only really adds checking that the region cache is updated which I think is covered already.

[labath]

In D87442#2332244, @DavidSpickett wrote:

If you are wondering, the average number of flags for a Linux hello world's memory regions is 8 so 8 lines of output. Here's an example I had that does madvise.

(lldb) memory region addr
[0x00007ffff7ed5000-0x00007ffff7fd5000) rw- /dev/zero (deleted)
flags:
readable
writeable
shared
may read
may write
may execute
may share
soft-dirty
(lldb) n
(lldb) n (over madvise(addr, len, MADV_DONTFORK);)
(lldb) memory region addr
[0x00007ffff7ed5000-0x00007ffff7fd5000) rw- /dev/zero (deleted)
flags:
readable
writeable
shared
may read
may write
may execute
may share
do not copy area on fork
soft-dirty

I could add this as a test case but it only really adds checking that the region cache is updated which I think is covered already.

Woa, back up. I though you were just going to add the one flag you need right now... :(

I'd like to avoid adding flags we don't have any use for. That way we can decide the best course of action on a per-flag basis, and avoid overfitting any particular platform. Having a flag for whether a region supports memory tagging (and calling that flag mt) sounds pretty platform-neutral, but some of the other flags seem very linux specific, and are unlikely to be useful elsewhere...

[DavidSpickett]

Woa, back up. I though you were just going to add the one flag you need right now... :(

I was going for the showing flags as a feature of the "memory region" command then later adding the memory tagging flag to that.
I see your point though and yeah I don't need all the flags to unblock mte.

With the perspective I was coming from, adding a set of getter/setter for 20ish flags wasn't an appealing idea:

bool m_memory_tagged;
OptionalBool GetMemoryTagged() const { return m_memory_tagged; }
void SetMemoryTagged(bool v) { m_memory_tagged = v; }
<x20>

If it's just mt then I just add another set, can always merge it with a flags (plural) interface later if we accumulate more.

So if it makes sense to you, I will:

• add only "mt" flag, with it's own getter/setter
• keep the protocol changes (but only recognise the 1 flag)
• keep the extra testing, use of expected etc. where it still applies
• add tests to run on a memory tagging enabled kernel with qemu

Then we can at least agree in principle, even if this doesn't land until the new tagging commands have also been reviewed. (which is fine by me, but I don't have them ready yet)

Thanks for all your comments so far!

[labath]

In D87442#2334786, @DavidSpickett wrote:

Woa, back up. I though you were just going to add the one flag you need right now... :(

I was going for the showing flags as a feature of the "memory region" command then later adding the memory tagging flag to that.
I see your point though and yeah I don't need all the flags to unblock mte.

With the perspective I was coming from, adding a set of getter/setter for 20ish flags wasn't an appealing idea:

bool m_memory_tagged;
OptionalBool GetMemoryTagged() const { return m_memory_tagged; }
void SetMemoryTagged(bool v) { m_memory_tagged = v; }
<x20>

If it's just mt then I just add another set, can always merge it with a flags (plural) interface later if we accumulate more.

So if it makes sense to you, I will:

• add only "mt" flag, with it's own getter/setter
• keep the protocol changes (but only recognise the 1 flag)
• keep the extra testing, use of expected etc. where it still applies
• add tests to run on a memory tagging enabled kernel with qemu

Then we can at least agree in principle, even if this doesn't land until the new tagging commands have also been reviewed. (which is fine by me, but I don't have them ready yet)

Thanks for all your comments so far!

Yep, that sounds like a plan.

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

20

We don't usually typedef expecteds like this, and the result is not much shorter than the original.

lldb/unittests/Process/Utility/CMakeLists.txt

6

What will not link? This definitely can't be the right solution as lldbPluginProcessLinux is not even being built on non-linux hosts (but Plugins/Process/Utility is).

[DavidSpickett]

• Only "mt" flag supported
• Don't typedef expected MemoryRegionInfo
• Link lldbPluginProcessUtility (not lldbPluginProcessLinux) in proc map tests
• "mt" is now the only supported flag
• "memory tagging: enabled" is printed if it is found for a region
• lldb-server will only send "flags:mt;" or "flags:;"
• lldb will treat flags as a list of flags, but only look for "mt" (so we can expand the flags list later)
• Added target specific test to run via QEMU (future MTE tests can live in API/linux/aarch64/ too)

[DavidSpickett]

• Revert stray change of run-qemu.sh file mode

[labath]

I think this looks pretty good now. Some questions inline...

lldb/source/Target/MemoryRegionInfo.cpp

10

unused?

lldb/test/API/linux/aarch64/mte_memory_region/main.c

9–14 ↗

(On Diff #302845)

Instead of duplicating these checks in dotest, maybe we could use the result of the inferior as a indication to skip the test. Like, if, instead of hitting the breakpoint, the inferior exits with code 47, we know that the required cpu feature is not supported?

lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp

47–49

err_str = toString(Info.takeError());

[DavidSpickett]

• Remove unused assert header
• Simplify error handling in LinuxProcMapsTest

lldb/test/API/linux/aarch64/mte_memory_region/main.c

9–14 ↗

(On Diff #302845)

Sounds good to me.

That would mean defining things like PROT_MTE in the test file, for toolchains that won't have it. I assume that's ok to do.
(I'll probably need to do that for lldb-server code later anyway)

[labath]

lldb/test/API/linux/aarch64/mte_memory_region/main.c

9–14 ↗

(On Diff #302845)

Depends... How likely is the system to support memory tagging if the relevant headers don't define the constants? Do you want to support systems like those?

Maybe you could do something like this:

int main() {
#ifdef HWCAP2_MTE
  // do stuff
#else
  return 47;
#endif
}

[DavidSpickett]

lldb/test/API/linux/aarch64/mte_memory_region/main.c

9–14 ↗

(On Diff #302845)

No I don't think so, if you want to run this test the toolchain should have the constants. I'll do what you suggested.

[DavidSpickett]

Updated the way the test works.

• If you build without MTE in the toolchain the binary just returns the magic failure number.
• If you do have an MTE toolchain but your target doesn't have MTE then it will also fail with the magic return code.

If it does either of those we skip, otherwise we then run
again to do the actual checks.

The vmflags check will be needed for future tests so I've
not moved it into the test itself.

[labath]

Hopefully last round of cosmetic fixes, and then this should be good.

lldb/include/lldb/Target/MemoryRegionInfo.h

15

I guess this is not used anymore..

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

805

I guess you could change this to self.assertIn(needle, haystack)

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

1308–1312

Status has an llvm::Error constructor. Some variation on Result = Info.takeError() should work.

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

200

no braces for simple statements

lldb/source/Plugins/Process/minidump/MinidumpParser.cpp

270–272 ↗

(On Diff #306091)

llvm::consumeError(region.takeError()), though maybe it would be better to actually log it (LLDB_LOG_ERROR)

lldb/test/API/linux/aarch64/mte_memory_region/TestAArch64LinuxMTEMemoryRegion.py

31 ↗

(On Diff #306091)

if self.process().GetState() == lldb.eStateExited and self.process().GetExitStatus() == 47 would be nicer

34–38 ↗

(On Diff #306091)

I think you could just run this once, and then choose to skip the test or not depending on whether the process exited, or hit a breakpoint.

[DavidSpickett]

• Use assertIn
• Cleanup Status/Error handling
• Refactor test so it runs once and we skip based on whether it returns a value or hits a breakpoint.
• Seperated exit codes for non MTE toolchain and non MTE target, for more specific skip reasons.

On the test, hopefully the comment in main.c
makes sense. Here's a cut down demo of what I'm
explaining:
https://godbolt.org/z/rex96b

This means we can always set an exact breakpoint,
we just won't hit it unless you have MTE. Which is
what we want.

[labath]

In D87442#2405681, @DavidSpickett wrote:

• Use assertIn
• Cleanup Status/Error handling
• Refactor test so it runs once and we skip based on whether it returns a value or hits a breakpoint.
• Seperated exit codes for non MTE toolchain and non MTE target, for more specific skip reasons.

On the test, hopefully the comment in main.c
makes sense. Here's a cut down demo of what I'm
explaining:
https://godbolt.org/z/rex96b

This means we can always set an exact breakpoint,
we just won't hit it unless you have MTE. Which is
what we want.

I see.

Maybe a less convoluted pattern would be

void test_mte(void *page) {}

int main() {
#ifdef MTE
  ...
  test_mte(mmap(...));
  return 0;
#else
  return 47;
#endif
}

and setting a breakpoint on test_mte. But this is fine too....

[DavidSpickett]

I'm going to stick with the test format as it is. No doubt I'll need to clean it up based on what future MTE tests look like.

lldb/bindings/interface/SBMemoryRegionInfo.i

public:
 
     bool
     IsMapped ();
 
     const char *
     GetName ();
 
     bool
+    HasFlags ();
+
+    bool
+    GetFlags (lldb::SBStream &flags);
+
+    bool
     operator == (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     operator != (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     GetDescription (lldb::SBStream &description);
 
     STRING_EXTENSION(SBMemoryRegionInfo)
 };
 
 } // namespace lldb

lldb/docs/lldb-gdb-remote.txt

permissions:<permissions>;  // <permissions> is a string that contains one
                                 // or more of the characters from "rwx"
 
     name:<name>; // <name> is a hex encoded string that contains the name of
                  // the memory region mapped at the given address. In case of
                  // regions backed by a file it have to be the absolute path of
                  // the file while for anonymous regions it have to be the name
                  // associated to the region if that is available.
 
+    flags:<flags-string>; // where <flags-string> is a space seperated string
+                          // of flag names. These names are platform specific
+                          // e.g. on Linux it might be "rd ex mr".
+
     error:<ascii-byte-error-string>; // where <ascii-byte-error-string> is
                                      // a hex encoded string value that
                                      // contains an error string
 
 If the address requested is not in a mapped region (e.g. we've jumped through
 a NULL pointer and are at 0x0) currently lldb expects to get back the size
 of the unmapped region -- that is, the distance to the next valid region.
 For instance, with a macOS process which has nothing mapped in the first

lldb/include/lldb/API/SBMemoryRegionInfo.h

 //===-- SBMemoryRegionInfo.h ------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_API_SBMEMORYREGIONINFO_H
 #define LLDB_API_SBMEMORYREGIONINFO_H
 
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
 class LLDB_API SBMemoryRegionInfo {
 public:
   SBMemoryRegionInfo();
 
public:
   /// address.
   ///
   /// \return
   ///     In case of memory mapped files it is the absolute path of
   ///     the file otherwise it is a name associated with the memory
   ///     region. If no name can be determined the returns nullptr.
   const char *GetName();
 
+  /// Check if the flags for this region were read.
+  ///
+  /// \return
+  ///     True if flag information was read, false otherwise.
+  bool HasFlags();
+
+  /// Write a space seperated list of flags into the stream
+  /// "flags". Check HasFlags to see if this string is valid.
+  ///
+  /// \return
+  ///    True
+  bool GetFlags(lldb::SBStream &flags);
+
   bool operator==(const lldb::SBMemoryRegionInfo &rhs) const;
 
   bool operator!=(const lldb::SBMemoryRegionInfo &rhs) const;
 
   bool GetDescription(lldb::SBStream &description);
 
 private:
   friend class SBProcess;

lldb/include/lldb/Target/MemoryRegionInfo.h

 //===-- MemoryRegionInfo.h ---------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_MEMORYREGIONINFO_H
 #define LLDB_TARGET_MEMORYREGIONINFO_H
 
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/RangeMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FormatProviders.h"
+#include <set>
 
 namespace lldb_private {
 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 flash, lldb::offset_t blocksize)
+                   OptionalBool flash, lldb::offset_t blocksize,
+                   llvm::Optional<llvm::StringRef> flags)
       : m_range(range), m_read(read), m_write(write), m_execute(execute),
         m_mapped(mapped), m_name(name), m_flash(flash), m_blocksize(blocksize) {
+    if (flags) {
+      SetFlags(*flags);
+    }
   }
 
   RangeType &GetRange() { return m_range; }
 
   void Clear() {
     m_range.Clear();
     m_read = m_write = m_execute = eDontKnow;
   }
 
   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 GetMapped() const { return m_mapped; }
 
   ConstString GetName() const { return m_name; }
 
+  bool HasFlags() const { return m_flags.hasValue(); }
+
+  // Get space joined string of flags
+  std::string GetFlags() const;
+
   void SetReadable(OptionalBool val) { m_read = val; }
 
   void SetWritable(OptionalBool val) { m_write = val; }
 
   void SetExecutable(OptionalBool val) { m_execute = 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; }
 
   lldb::offset_t GetBlocksize() const { return m_blocksize; }
 
   void SetBlocksize(lldb::offset_t blocksize) { m_blocksize = blocksize; }
 
+  // Init from space seperated list of flags
+  void SetFlags(llvm::StringRef flags);
+
   // Get permissions as a uint32_t that is a mask of one or more bits from the
   // lldb::Permissions
   uint32_t GetLLDBPermissions() const {
     uint32_t permissions = 0;
     if (m_read)
       permissions |= lldb::ePermissionsReadable;
     if (m_write)
       permissions |= lldb::ePermissionsWritable;
void SetLLDBPermissions(uint32_t permissions) {
     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_mapped == rhs.m_mapped && m_name == rhs.m_name &&
-           m_flash == rhs.m_flash && m_blocksize == rhs.m_blocksize;
+           m_flash == rhs.m_flash && m_blocksize == rhs.m_blocksize &&
+           m_flags == rhs.m_flags;
   }
 
   bool operator!=(const MemoryRegionInfo &rhs) const { return !(*this == rhs); }
 
 protected:
   RangeType m_range;
   OptionalBool m_read = eDontKnow;
   OptionalBool m_write = eDontKnow;
   OptionalBool m_execute = eDontKnow;
   OptionalBool m_mapped = eDontKnow;
   ConstString m_name;
   OptionalBool m_flash = eDontKnow;
   lldb::offset_t m_blocksize = 0;
+  llvm::Optional<std::set<std::string>> m_flags;
 };
   
 inline bool operator<(const MemoryRegionInfo &lhs,
                       const MemoryRegionInfo &rhs) {
   return lhs.GetRange() < rhs.GetRange();
 }
 
 inline bool operator<(const MemoryRegionInfo &lhs, lldb::addr_t rhs) {

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def parse_memory_region_packet(self, context):
 
         # Validate keys are known.
         for (key, val) in list(mem_region_dict.items()):
             self.assertTrue(
                 key in [
                     "start",
                     "size",
                     "permissions",
+                    "flags",
                     "name",
-                    "error"])
+                    "error"], "Unexpected key \"%s\"" % key)
             self.assertIsNotNone(val)
 
         mem_region_dict["name"] = seven.unhexlify(mem_region_dict.get("name", ""))
         # Return the dictionary of key-value pairs for the memory region.
         return mem_region_dict
 
     def assert_address_within_memory_region(
             self, test_address, mem_region_dict):

lldb/source/API/SBMemoryRegionInfo.cpp

 //===-- SBMemoryRegionInfo.cpp --------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBMemoryRegionInfo.h"
 #include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/StreamString.h"
 

 }
 
 const char *SBMemoryRegionInfo::GetName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName);
 
   return m_opaque_up->GetName().AsCString();
 }
 
+bool SBMemoryRegionInfo::HasFlags() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, HasFlags);
+
+  return m_opaque_up->HasFlags();
+}
+
+bool SBMemoryRegionInfo::GetFlags(SBStream &flags) {
+  LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetFlags, (lldb::SBStream &),
+                     flags);
+
+  Stream &strm = flags.ref();
+  strm.Printf("%s", m_opaque_up->GetFlags().c_str());
+
+  return true;
+}
+
 bool SBMemoryRegionInfo::GetDescription(SBStream &description) {
   LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription,
                      (lldb::SBStream &), description);
 
   Stream &strm = description.ref();
   const addr_t load_addr = m_opaque_up->GetRange().base;
 
   strm.Printf("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 " ", load_addr,
               load_addr + m_opaque_up->GetRange().size);
   strm.Printf(m_opaque_up->GetReadable() ? "R" : "-");
   strm.Printf(m_opaque_up->GetWritable() ? "W" : "-");
   strm.Printf(m_opaque_up->GetExecutable() ? "X" : "-");
+  if (m_opaque_up->HasFlags())
+    strm.Printf(" flags: %s", m_opaque_up->GetFlags().c_str());
   strm.Printf("]");
 
   return true;
 }
 
 namespace lldb_private {
 namespace repro {
 
LLDB_REGISTER_METHOD_CONST(
       SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &));
   LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase, ());
   LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd, ());
   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsReadable, ());
   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsWritable, ());
   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsExecutable, ());
   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsMapped, ());
   LLDB_REGISTER_METHOD(const char *, SBMemoryRegionInfo, GetName, ());
+  LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, HasFlags, ());
+  LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetFlags, (lldb::SBStream &));
   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetDescription,
                        (lldb::SBStream &));
 }
 
 }
 }

lldb/source/Commands/CommandObjectMemory.cpp

 //===-- CommandObjectMemory.cpp -------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
if (process_sp) {
             if (section_sp) {
               // Got the top most section, not the deepest section
               while (section_sp->GetParent())
                 section_sp = section_sp->GetParent();
               section_name = section_sp->GetName();
             }
           }
           result.AppendMessageWithFormatv(
-              "[{0:x16}-{1:x16}) {2:r}{3:w}{4:x}{5}{6}{7}{8}\n",
+              "[{0:x16}-{1:x16}) {2:r}{3:w}{4:x}{5}{6}{7}{8}",
               range_info.GetRange().GetRangeBase(),
               range_info.GetRange().GetRangeEnd(), range_info.GetReadable(),
               range_info.GetWritable(), range_info.GetExecutable(),
               name ? " " : "", name, section_name ? " " : "", section_name);
+          if (range_info.HasFlags()) {
+            result.AppendMessageWithFormatv("flags: {0}",
+                                            range_info.GetFlags().c_str());
+          }
+
           m_prev_end_addr = range_info.GetRange().GetRangeEnd();
           result.SetStatus(eReturnStatusSuccessFinishResult);
         } else {
           result.SetStatus(eReturnStatusFailed);
           result.AppendErrorWithFormat("%s\n", error.AsCString());
         }
       }
     } else {

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

 //===-- NativeProcessLinux.cpp --------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
Status NativeProcessLinux::PopulateMemoryRegionCache() {
   // If our cache is empty, pull the latest.  There should always be at least
   // one memory region if memory region handling is supported.
   if (!m_mem_region_cache.empty()) {
     LLDB_LOG(log, "reusing {0} cached memory region entries",
              m_mem_region_cache.size());
     return Status();
   }
 
-  auto BufferOrError = getProcFile(GetID(), "maps");
-  if (!BufferOrError) {
-    m_supports_mem_region = LazyBool::eLazyBoolNo;
-    return BufferOrError.getError();
-  }
   Status Result;
-  ParseLinuxMapRegions(BufferOrError.get()->getBuffer(),
-                       [&](const MemoryRegionInfo &Info, const Status &ST) {
-                         if (ST.Success()) {
-                           FileSpec file_spec(Info.GetName().GetCString());
-                           FileSystem::Instance().Resolve(file_spec);
-                           m_mem_region_cache.emplace_back(Info, file_spec);
-                           return true;
-                         } else {
-                           m_supports_mem_region = LazyBool::eLazyBoolNo;
-                           LLDB_LOG(log, "failed to parse proc maps: {0}", ST);
-                           Result = ST;
-                           return false;
-                         }
-                       });
-  if (Result.Fail())
+  Result.SetErrorToGenericError();
+  LinuxMapCallback callback = [&](const MemoryRegionInfo &Info,
+                                  const Status &ST) {
+      Result = ST;
+  };
+
+  // Linux kernel since 2.6.14 has /proc/{pid}/smaps
+  // if CONFIG_PROC_PAGE_MONITOR is enabled
+  auto BufferOrError = getProcFile(GetID(), "smaps");
+  if (BufferOrError) {
+    ParseLinuxSMapRegions(BufferOrError.get()->getBuffer(), callback);
+    if (Result.Fail()) {
+      return Result;
+    }
+  } else {
+    BufferOrError = getProcFile(GetID(), "maps");
+    if (!BufferOrError) {
+      m_supports_mem_region = LazyBool::eLazyBoolNo;
+      return BufferOrError.getError();
+    }
+
+    ParseLinuxMapRegions(BufferOrError.get()->getBuffer(), callback);
+    if (Result.Fail()) {
       return Result;
+    }
+  }
 
   if (m_mem_region_cache.empty()) {
     // No entries after attempting to read them.  This shouldn't happen if
     // /proc/{pid}/maps is supported. Assume we don't support map entries via
     // procfs.
     m_supports_mem_region = LazyBool::eLazyBoolNo;
     LLDB_LOG(log,
              "failed to find any procfs maps entries, assuming no support "
              "for memory region metadata retrieval");

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

 //===-- LinuxProcMaps.h -----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_LINUXPROCMAPS_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_LINUXPROCMAPS_H
 
 #include "lldb/lldb-forward.h"
 #include "llvm/ADT/StringRef.h"
 #include <functional>
 
 
 namespace lldb_private {
 
 typedef std::function<bool(const lldb_private::MemoryRegionInfo &,
                            const lldb_private::Status &)> LinuxMapCallback;
 
 void ParseLinuxMapRegions(llvm::StringRef linux_map,
                           LinuxMapCallback const &callback);
+void ParseLinuxSMapRegions(llvm::StringRef linux_smap,
+                           LinuxMapCallback const &callback);
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_LINUXPROCMAPS_H

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

 //===-- LinuxProcMaps.cpp -------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "LinuxProcMaps.h"
-#include "llvm/ADT/StringRef.h"
 #include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StringExtractor.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 
 using namespace lldb_private;
 
+enum MapKind { eMaps, eSMaps };
+
+static Status ProcMapError(const char *msg, MapKind kind) {
+  return Status(msg, kind == eMaps ? "maps" : "smaps");
+}
+
 static Status
 ParseMemoryRegionInfoFromProcMapsLine(llvm::StringRef maps_line,
-                                      MemoryRegionInfo &memory_region_info) {
+                                      MemoryRegionInfo &memory_region_info,
+                                      MapKind map_kind) {
   memory_region_info.Clear();
   
   StringExtractor line_extractor(maps_line);
   
   // Format: {address_start_hex}-{address_end_hex} perms offset  dev   inode
   // pathname perms: rwxp   (letter is present if set, '-' if not, final
   // character is p=private, s=shared).
   
   // Parse out the starting address
   lldb::addr_t start_address = line_extractor.GetHexMaxU64(false, 0);
   
   // Parse out hyphen separating start and end address from range.
   if (!line_extractor.GetBytesLeft() || (line_extractor.GetChar() != '-'))
-    return Status(
-        "malformed /proc/{pid}/maps entry, missing dash between address range");
-  
+    return ProcMapError(
+        "malformed /proc/{pid}/%s entry, missing dash between address range",
+        map_kind);
   // Parse out the ending address
   lldb::addr_t end_address = line_extractor.GetHexMaxU64(false, start_address);
   
   // Parse out the space after the address.
   if (!line_extractor.GetBytesLeft() || (line_extractor.GetChar() != ' '))
-    return Status(
-        "malformed /proc/{pid}/maps entry, missing space after range");
-  
+    return ProcMapError(
+        "malformed /proc/{pid}/%s entry, missing space after range", map_kind);
   // Save the range.
   memory_region_info.GetRange().SetRangeBase(start_address);
   memory_region_info.GetRange().SetRangeEnd(end_address);
-  
-  // Any memory region in /proc/{pid}/maps is by definition mapped into the
-  // process.
+  // Any memory region in /proc/{pid}/(maps|smaps) is by definition mapped
+  // into the process.
   memory_region_info.SetMapped(MemoryRegionInfo::OptionalBool::eYes);
   
   // Parse out each permission entry.
   if (line_extractor.GetBytesLeft() < 4)
-    return Status("malformed /proc/{pid}/maps entry, missing some portion of "
-                  "permissions");
-  
+    return ProcMapError(
+        "malformed /proc/{pid}/%s entry, missing some portion of "
+        "permissions",
+        map_kind);
   // Handle read permission.
   const char read_perm_char = line_extractor.GetChar();
   if (read_perm_char == 'r')
     memory_region_info.SetReadable(MemoryRegionInfo::OptionalBool::eYes);
   else if (read_perm_char == '-')
     memory_region_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
   else
-    return Status("unexpected /proc/{pid}/maps read permission char");
-  
+    return ProcMapError("unexpected /proc/{pid}/%s read permission char",
+                        map_kind);
   // Handle write permission.
   const char write_perm_char = line_extractor.GetChar();
   if (write_perm_char == 'w')
     memory_region_info.SetWritable(MemoryRegionInfo::OptionalBool::eYes);
   else if (write_perm_char == '-')
     memory_region_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
   else
-    return Status("unexpected /proc/{pid}/maps write permission char");
-  
+    return ProcMapError("unexpected /proc/{pid}/%s write permission char",
+                        map_kind);
   // Handle execute permission.
   const char exec_perm_char = line_extractor.GetChar();
   if (exec_perm_char == 'x')
     memory_region_info.SetExecutable(MemoryRegionInfo::OptionalBool::eYes);
   else if (exec_perm_char == '-')
     memory_region_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
   else
-    return Status("unexpected /proc/{pid}/maps exec permission char");
-  
+    return ProcMapError("unexpected /proc/{pid}/%s exec permission char",
+                        map_kind);
   line_extractor.GetChar();              // Read the private bit
   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
   
   line_extractor.SkipSpaces();
   const char *name = line_extractor.Peek();
   if (name)
     memory_region_info.SetName(name);
   
   return Status();
 }
 
 void lldb_private::ParseLinuxMapRegions(llvm::StringRef linux_map,
                                         LinuxMapCallback const &callback) {
   llvm::StringRef lines(linux_map);
   llvm::StringRef line;
   while (!lines.empty()) {
     std::tie(line, lines) = lines.split('\n');
     MemoryRegionInfo region;
-    Status error = ParseMemoryRegionInfoFromProcMapsLine(line, region);
+    Status error = ParseMemoryRegionInfoFromProcMapsLine(line, region, eMaps);
     if (!callback(region, error))
       break;
   }
 }
+
+static bool IsRegionPropertyLine(llvm::StringRef line, llvm::StringRef &name,
+                                 llvm::StringRef &value) {
+  llvm::SmallVector<llvm::StringRef, 3> matches;
+  // Note: llvm::regex doesn't do character classes
+  RegularExpression expr("^[ ]*([A-za-z0-9_]+)[ ]*:(.*)");
+  if (expr.Execute(line, &matches)) {
+    name = matches[1];
+    value = matches[2];
+    return true;
+  }
+  return false;
+}
+
+void lldb_private::ParseLinuxSMapRegions(llvm::StringRef linux_smap,
+                                         LinuxMapCallback const &callback) {
+  // Entries in /smaps look like:
+  // 00400000-0048a000 r-xp 00000000 fd:03 960637
+  // Size:                552 kB
+  // Rss:                 460 kB
+  // <...>
+  // VmFlags: rd ex mr mw me dw
+  // 00500000-0058a000 rwxp 00000000 fd:03 960637
+  // <...>
+  //
+  // Where the first line is identical to the /maps format
+  // And VmFlags is only printed for kernels >= 3.8
+
+  llvm::StringRef lines(linux_smap);
+  llvm::StringRef line;
+  llvm::Optional<MemoryRegionInfo> region;
+  Status error;
+
+  while (!lines.empty()) {
+    std::tie(line, lines) = lines.split('\n');
+
+    llvm::StringRef name;
+    llvm::StringRef value;
+    if (IsRegionPropertyLine(line, name, value)) {
+      if (region) {
+        if (name == "VmFlags")
+          region->SetFlags(value);
+        // Ignore anything else
+      } else {
+        // Orphaned settings line
+        error = Status("Found a property line without a corresponding mapping "
+                       "in /proc/{pid}/smaps");
+        region = MemoryRegionInfo();
+        callback(*region, error);
+        return;
+      }
+    } else {
+      // Must be a new region header
+      if (region) {
+        // Save current region (error will always be Success here)
+        callback(*region, error);
+        region.reset();
+      }
+
+      // Try to start a new region
+      MemoryRegionInfo new_region;
+      error = ParseMemoryRegionInfoFromProcMapsLine(line, new_region, eSMaps);
+      if (error.Fail()) {
+        // Stop at first invalid region header
+        callback(*region, error);
+        return;
+      } else {
+        region = new_region;
+      }
+    }
+  }
+
+  // Catch last region (error will always be Success here)
+  if (region) {
+    callback(*region, error);
+  }
+}

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

 //===-- GDBRemoteCommunicationClient.cpp ----------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
if (SendPacketAndWaitForResponse(packet, response, false) ==
             region_info.SetExecutable(MemoryRegionInfo::eNo);
             region_info.SetMapped(MemoryRegionInfo::eNo);
           }
         } else if (name.equals("name")) {
           StringExtractorGDBRemote name_extractor(value);
           std::string name;
           name_extractor.GetHexByteString(name);
           region_info.SetName(name.c_str());
+        } else if (name.equals("flags")) {
+          region_info.SetFlags(value);
         } else if (name.equals("error")) {
           StringExtractorGDBRemote error_extractor(value);
           std::string error_string;
           // Now convert the HEX bytes into a string value
           error_extractor.GetHexByteString(error_string);
           error.SetErrorString(error_string.c_str());
         }
       }

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 //===-- GDBRemoteCommunicationServerLLGS.cpp ------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <errno.h>
 
 #include "lldb/Host/Config.h"
 
 #include "GDBRemoteCommunicationServerLLGS.h"
 #include "lldb/Utility/GDBRemote.h"
 
 #include <chrono>
 #include <cstring>
 #include <thread>
 
if (region_info.GetReadable() || region_info.GetWritable() ||
       if (region_info.GetWritable())
         response.PutChar('w');
       if (region_info.GetExecutable())
         response.PutChar('x');
 
       response.PutChar(';');
     }
 
+    // Flags
+    if (region_info.HasFlags()) {
+      std::string flags_str = region_info.GetFlags();
+      response.PutCString("flags:");
+      response.PutCString(flags_str.c_str());
+      response.PutChar(';');
+    }
+
     // Name
     ConstString name = region_info.GetName();
     if (name) {
       response.PutCString("name:");
       response.PutStringAsRawHex8(name.GetStringRef());
       response.PutChar(';');
     }
   }

lldb/source/Target/MemoryRegionInfo.cpp

 //===-- MemoryRegionInfo.cpp ----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/MemoryRegionInfo.h"
+#include <cctype>
 
 using namespace lldb_private;
 
+void MemoryRegionInfo::SetFlags(llvm::StringRef flags) {
+  // Assuming a line of the format:
+  // <flag><spaces><flag><spaces>...
+  // E.g. "rd wr ex"
+  m_flags = std::set<std::string>();
+  llvm::StringRef flag;
+  while (flags.size()) {
+    flags = flags.drop_while(iswspace);
+    std::tie(flag, flags) = flags.split(' ');
+    // Account for trailing whitespace
+    if (flag.size()) {
+      m_flags->insert(flag.str());
+    }
+  }
+}
+
+std::string MemoryRegionInfo::GetFlags() const {
+  if (HasFlags())
+    return llvm::join(m_flags.getValue(), " ");
+  return "?";
+}
+
 llvm::raw_ostream &lldb_private::operator<<(llvm::raw_ostream &OS,
                                             const MemoryRegionInfo &Info) {
   return OS << llvm::formatv("MemoryRegionInfo([{0}, {1}), {2:r}{3:w}{4:x}, "
-                             "{5}, `{6}`, {7}, {8})",
+                             "{5}, `{6}`, {7}, {8}, {9})",
                              Info.GetRange().GetRangeBase(),
                              Info.GetRange().GetRangeEnd(), Info.GetReadable(),
                              Info.GetWritable(), Info.GetExecutable(),
                              Info.GetMapped(), Info.GetName(), Info.GetFlash(),
-                             Info.GetBlocksize());
+                             Info.GetBlocksize(), Info.GetFlags());
 }
 
 void llvm::format_provider<MemoryRegionInfo::OptionalBool>::format(
     const MemoryRegionInfo::OptionalBool &B, raw_ostream &OS,
     StringRef Options) {
   assert(Options.size() <= 1);
   bool Empty = Options.empty();
   switch (B) {

lldb/unittests/Process/CMakeLists.txt

 add_subdirectory(gdb-remote)
 if (CMAKE_SYSTEM_NAME MATCHES "Linux|Android")
   add_subdirectory(Linux)
   add_subdirectory(POSIX)
 endif()
 add_subdirectory(minidump)
+add_subdirectory(Utility)
 
 add_lldb_unittest(ProcessEventDataTests
   ProcessEventDataTest.cpp
 
   LINK_LIBS
       lldbCore
       lldbHost
       lldbTarget
       lldbSymbol
       lldbUtility
       lldbUtilityHelpers
       lldbInterpreter
       lldbPluginPlatformMacOSX
   )

lldb/unittests/Process/Utility/CMakeLists.txt

+add_lldb_unittest(LinuxProcMapsTests
+  LinuxProcMapsTest.cpp
+
+  LINK_LIBS
+     lldbPluginProcessLinux
+  )
+
+target_include_directories(LinuxProcMapsTests PRIVATE
+  ${LLDB_SOURCE_DIR}/source/Plugins/Process/Utility)

lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp

+//===-- LinuxProcMapsTest.cpp ---------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "LinuxProcMaps.h"
+#include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Utility/Status.h"
+#include <tuple>
+
+using namespace lldb_private;
+
+typedef std::tuple<const char *, MemoryRegionInfos, const char *>
+    LinuxProcMapsTestParams;
+
+// Wrapper for convenience because Range is usually begin, size
+static MemoryRegionInfo::RangeType make_range(lldb::addr_t begin,
+                                              lldb::addr_t end) {
+  MemoryRegionInfo::RangeType range(begin, 0);
+  range.SetRangeEnd(end);
+  return range;
+}
+
+class LinuxProcMapsTestFixture
+    : public ::testing::TestWithParam<LinuxProcMapsTestParams> {
+protected:
+  Status error;
+  std::string err_str;
+  MemoryRegionInfos regions;
+  LinuxMapCallback callback;
+
+  void SetUp() override {
+    callback = [&](const MemoryRegionInfo &Info, const Status &ST) {
+      if (ST.Success()) {
+        err_str.clear();
+        regions.push_back(Info);
+        return true;
+      }
+      err_str = ST.AsCString();
+      return false;
+    };
+  }
+
+  void check_regions(LinuxProcMapsTestParams params) {
+    ASSERT_EQ(std::get<1>(params).size(), regions.size());
+    ASSERT_EQ(std::get<1>(params), regions);
+    ASSERT_EQ(std::get<2>(params), err_str);
+  }
+};
+
+TEST_P(LinuxProcMapsTestFixture, ParseMapRegions) {
+  auto params = GetParam();
+  ParseLinuxMapRegions(std::get<0>(params), callback);
+  check_regions(params);
+}
+
+// Note: ConstString("") != ConstString(nullptr)
+// When a region has no name, it will have the latter in the MemoryRegionInfo
+INSTANTIATE_TEST_CASE_P(
+    ProcMapTests, LinuxProcMapsTestFixture,
+    ::testing::Values(
+        // Nothing in nothing out
+        std::make_tuple("", MemoryRegionInfos{}, ""),
+        // Various formatting error conditions
+        std::make_tuple("55a4512f7000/55a451b68000 rw-p 00000000 00:00 0",
+                        MemoryRegionInfos{},
+                        "malformed /proc/{pid}/maps entry, missing dash "
+                        "between address range"),
+        std::make_tuple("0-0 rw", MemoryRegionInfos{},
+                        "malformed /proc/{pid}/maps entry, missing some "
+                        "portion of permissions"),
+        std::make_tuple("0-0 z--p 00000000 00:00 0", MemoryRegionInfos{},
+                        "unexpected /proc/{pid}/maps read permission char"),
+        std::make_tuple("0-0 rz-p 00000000 00:00 0", MemoryRegionInfos{},
+                        "unexpected /proc/{pid}/maps write permission char"),
+        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::eYes, ConstString("[abc]"),
+                                 MemoryRegionInfo::eDontKnow, 0, llvm::None),
+            },
+            "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,
+                                 ConstString("[heap]"),
+                                 MemoryRegionInfo::eDontKnow, 0, llvm::None),
+            },
+            ""),
+        // Multiple entries
+        std::make_tuple(
+            "7fc090021000-7fc094000000 ---p 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,
+                                 ConstString(nullptr),
+                                 MemoryRegionInfo::eDontKnow, 0, llvm::None),
+                MemoryRegionInfo(make_range(0xffffffffff600000,
+                                            0xffffffffff601000),
+                                 MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                                 MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
+                                 ConstString("[vsyscall]"),
+                                 MemoryRegionInfo::eDontKnow, 0, llvm::None),
+            },
+            "")), );
+
+class LinuxProcSMapsTestFixture : public LinuxProcMapsTestFixture {};
+
+INSTANTIATE_TEST_CASE_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, MemoryRegionInfo::eYes,
+                                 ConstString("[foo]"),
+                                 MemoryRegionInfo::eDontKnow, 0, llvm::None),
+            },
+            "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, MemoryRegionInfo::eYes,
+                                 ConstString("[foo]"),
+                                 MemoryRegionInfo::eDontKnow, 0, llvm::None),
+            },
+            ""),
+        // 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: rd wr ab cd",
+                        MemoryRegionInfos{
+                            MemoryRegionInfo(
+                                make_range(0x1111, 0x2222),
+                                MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
+                                MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
+                                ConstString("[foo]"),
+                                MemoryRegionInfo::eDontKnow, 0,
+                                llvm::Optional<llvm::StringRef>("rd wr ab cd")),
+                        },
+                        ""),
+        // Whitespace in flags line ignored, any number of chars per flag
+        std::make_tuple("0-0 rw-p 00000000 00:00 0\n"
+                        "VmFlags: rd      abc x yz      ",
+                        MemoryRegionInfos{
+                            MemoryRegionInfo(
+                                make_range(0, 0), MemoryRegionInfo::eYes,
+                                MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                                MemoryRegionInfo::eYes, ConstString(nullptr),
+                                MemoryRegionInfo::eDontKnow, 0,
+                                llvm::Optional<llvm::StringRef>("rd abc x yz")),
+                        },
+                        ""),
+        // VmFlags line means it has flag info, but nothing is set
+        // Also leading whitespace is ignored for property lines
+        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::eYes, ConstString(nullptr),
+                                 MemoryRegionInfo::eDontKnow, 0,
+                                 llvm::Optional<llvm::StringRef>("")),
+            },
+            ""),
+        // 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: rd wr ab cd",
+            MemoryRegionInfos{
+                MemoryRegionInfo(make_range(0x1111, 0x2222),
+                                 MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
+                                 MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
+                                 ConstString("[foo]"),
+                                 MemoryRegionInfo::eDontKnow, 0, llvm::None),
+                MemoryRegionInfo(
+                    make_range(0x3333, 0x4444), MemoryRegionInfo::eYes,
+                    MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
+                    MemoryRegionInfo::eYes, ConstString("[bar]"),
+                    MemoryRegionInfo::eDontKnow, 0,
+                    llvm::Optional<llvm::StringRef>("rd wr ab cd")),
+            },
+            ""),
+        // 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, MemoryRegionInfo::eYes,
+                                 ConstString(nullptr),
+                                 MemoryRegionInfo::eDontKnow, 0, llvm::None),
+                MemoryRegionInfo(make_range(0x3333, 0x4444),
+                                 MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
+                                 MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
+                                 ConstString(nullptr),
+                                 MemoryRegionInfo::eDontKnow, 0, llvm::None),
+            },
+            "")), );
+
+TEST_P(LinuxProcSMapsTestFixture, ParseSMapRegions) {
+  auto params = GetParam();
+  ParseLinuxSMapRegions(std::get<0>(params), callback);
+  check_regions(params);
+}

lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

 //===-- GDBRemoteCommunicationClientTest.cpp ------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h"
 #include "GDBRemoteTestUtils.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/TraceOptions.h"
 #include "lldb/lldb-enumerations.h"
TEST_F(GDBRemoteCommunicationClientTest, GetMemoryRegionInfo) {
   }
   EXPECT_TRUE(result.get().Success());
   EXPECT_EQ(addr, region_info.GetRange().GetRangeBase());
   EXPECT_EQ(0x2000u, region_info.GetRange().GetByteSize());
   EXPECT_EQ(MemoryRegionInfo::eYes, region_info.GetReadable());
   EXPECT_EQ(MemoryRegionInfo::eNo, region_info.GetWritable());
   EXPECT_EQ(MemoryRegionInfo::eYes, region_info.GetExecutable());
   EXPECT_EQ("/foo/bar.so", region_info.GetName().GetStringRef());
+  EXPECT_FALSE(region_info.HasFlags());
+  EXPECT_EQ("?", region_info.GetFlags());
+
+  result = std::async(std::launch::async, [&] {
+    return client.GetMemoryRegionInfo(addr, region_info);
+  });
+
+  HandlePacket(server, "qMemoryRegionInfo:a000",
+               "start:a000;size:2000;flags:;");
+  EXPECT_TRUE(result.get().Success());
+  EXPECT_TRUE(region_info.HasFlags());
+  EXPECT_EQ("", region_info.GetFlags());
+
+  result = std::async(std::launch::async, [&] {
+    return client.GetMemoryRegionInfo(addr, region_info);
+  });
+
+  HandlePacket(server, "qMemoryRegionInfo:a000",
+               "start:a000;size:2000;flags: me  mr mw  ;");
+  EXPECT_TRUE(result.get().Success());
+  EXPECT_TRUE(region_info.HasFlags());
+  EXPECT_EQ("me mr mw", region_info.GetFlags());
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, GetMemoryRegionInfoInvalidResponse) {
   const lldb::addr_t addr = 0x4000;
   MemoryRegionInfo region_info;
   std::future<Status> result = std::async(std::launch::async, [&] {
     return client.GetMemoryRegionInfo(addr, region_info);
   });

lldb/unittests/Process/minidump/MinidumpParserTest.cpp

 //===-- MinidumpTypesTest.cpp ---------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/Process/minidump/MinidumpParser.h"
 #include "Plugins/Process/minidump/MinidumpTypes.h"
 #include "Plugins/Process/minidump/RegisterContextMinidump_x86_32.h"
 #include "Plugins/Process/minidump/RegisterContextMinidump_x86_64.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
Memory Ranges:
         Region Size:     0x000000000000F000
         State:           [ MEM_RESERVE ]
         Protect:         [ PAGE_NO_ACCESS ]
         Type:            [ MEM_PRIVATE ]
 ...
 )"),
                     llvm::Succeeded());
 
   EXPECT_THAT(
       parser->BuildMemoryRegions(),
       testing::Pair(testing::ElementsAre(
                         MemoryRegionInfo({0x0, 0x10000}, no, no, no, no,
-                                         ConstString(), unknown, 0),
+                                         ConstString(), unknown, 0, llvm::None),
                         MemoryRegionInfo({0x10000, 0x21000}, yes, yes, no, yes,
-                                         ConstString(), unknown, 0),
+                                         ConstString(), unknown, 0, llvm::None),
                         MemoryRegionInfo({0x40000, 0x1000}, yes, no, no, yes,
-                                         ConstString(), unknown, 0),
+                                         ConstString(), unknown, 0, llvm::None),
                         MemoryRegionInfo({0x7ffe0000, 0x1000}, yes, no, no, yes,
-                                         ConstString(), unknown, 0),
+                                         ConstString(), unknown, 0, llvm::None),
                         MemoryRegionInfo({0x7ffe1000, 0xf000}, no, no, no, yes,
-                                         ConstString(), unknown, 0)),
+                                         ConstString(), unknown, 0, llvm::None)),
                     true));
 }
 
 TEST_F(MinidumpParserTest, GetMemoryRegionInfoFromMemoryList) {
   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 --- !minidump
 Streams:
   - Type:            MemoryList
     Memory Ranges:
       - Start of Memory Range: 0x0000000000001000
         Content:         '31313131313131313131313131313131'
       - Start of Memory Range: 0x0000000000002000
         Content:         '3333333333333333333333333333333333333333333333333333333333333333'
 ...
 )"),
                     llvm::Succeeded());
 
   // 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, ConstString(), unknown, 0),
+                                         yes, ConstString(), unknown, 0, llvm::None),
                         MemoryRegionInfo({0x2000, 0x20}, yes, unknown, unknown,
-                                         yes, ConstString(), unknown, 0)),
+                                         yes, ConstString(), unknown, 0, llvm::None)),
                     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, ConstString(), unknown, 0),
+                                         yes, ConstString(), unknown, 0, llvm::None),
                         MemoryRegionInfo({0x2000, 0x20}, yes, unknown, unknown,
-                                         yes, ConstString(), unknown, 0)),
+                                         yes, ConstString(), unknown, 0, llvm::None)),
                     false));
 }
 
 TEST_F(MinidumpParserTest, GetMemoryRegionInfoLinuxMaps) {
   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 --- !minidump
 Streams:
   - Type:            LinuxMaps
     Text:             |
       400d9000-400db000 r-xp 00000000 b3:04 227        /system/bin/app_process
       400db000-400dc000 r--p 00001000 b3:04 227        /system/bin/app_process
       400dc000-400dd000 rw-p 00000000 00:00 0
       400ec000-400ed000 r--p 00000000 00:00 0
       400ee000-400ef000 rw-p 00010000 b3:04 300        /system/bin/linker
       400fc000-400fd000 rwxp 00001000 b3:04 1096       /system/lib/liblog.so
 
 ...
 )"),
                     llvm::Succeeded());
   // Test we can get memory regions from the linux /proc/<pid>/maps stream when
   // 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, app_process, unknown, 0),
+                                         yes, app_process, unknown, 0, llvm::None),
                         MemoryRegionInfo({0x400db000, 0x1000}, yes, no, no, yes,
-                                         app_process, unknown, 0),
+                                         app_process, unknown, 0, llvm::None),
                         MemoryRegionInfo({0x400dc000, 0x1000}, yes, yes, no,
-                                         yes, ConstString(), unknown, 0),
+                                         yes, ConstString(), unknown, 0, llvm::None),
                         MemoryRegionInfo({0x400ec000, 0x1000}, yes, no, no, yes,
-                                         ConstString(), unknown, 0),
+                                         ConstString(), unknown, 0, llvm::None),
                         MemoryRegionInfo({0x400ee000, 0x1000}, yes, yes, no,
-                                         yes, linker, unknown, 0),
+                                         yes, linker, unknown, 0, llvm::None),
                         MemoryRegionInfo({0x400fc000, 0x1000}, yes, yes, yes,
-                                         yes, liblog, unknown, 0)),
+                                         yes, liblog, unknown, 0, llvm::None)),
                     true));
 }
 
 // Windows Minidump tests
 TEST_F(MinidumpParserTest, GetArchitectureWindows) {
   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 --- !minidump
 Streams: