Implement GetMemoryRegions() for Linux and Mac OSX core files.

[hhellyer]

Summary

This patch fills in the implementation of GetMemoryRegions() on the Linux and Mac OS core file implementations of lldb_private::Process (ProcessElfCore::GetMemoryRegions and ProcessMachCore::GetMemoryRegions.) The GetMemoryRegions API was added under: http://reviews.llvm.org/D20565

The patch re-uses the m_core_range_infos list that was recently added to implement GetMemoryRegionInfo in both ProcessElfCore and ProcessMachCore to ensure the returned regions match the regions returned by Process::GetMemoryRegionInfo(addr_t load_addr, MemoryRegionInfo &region_info).

[hhellyer]

Squashing local commits.

[clayborg]

We shouldn't need to implement this on all process subclasses. Process::GetMemoryRegions(...) could just call the Process::GetMemoryRegionInfo() and fill the stuff in. We would need to modify lldb_private::MemoryRegionInfo to support knowing when no memory exists for a given address. Why? Because Mac programs actually have a __PAGEZERO section that no read/write/execute, but it is actually mapped into memory, but we currently can't tell the difference between something that isn't mapped, and a section that is mapped with no read/write/exe. If we fix this, then lldb_private::Process subclasses only need to override Process::GetMemoryRegionInfo(...) and we can do the rest up in Process::GetMemoryRegions().

[clayborg]

This of course would rely on the fact that each Process subclass the overrides GetMemoryRegionInfo() will follow the following rules:
1 - if no memory is mapped for a given address, set an extra "not_mapped" variable in MemoryRegionInfo and provide the next address that is mapped by setting the end address of the current MemoryRegionInfo correctly.
2 - set values correctly for mapped regions with the correct permissions
3 - For the last entry that is past all mapped entries, set the extra "not_mapped" and set the end address as LLDB_INVALID_ADDRESS

[hhellyer]

Since there’s a list of memory regions already created in the Process implementations for the core fles I thought it made sense just to use that directly, at least when reading from a core file. It meant there was no requirement to change those GetMemoryRegionInfo implementations if they didn’t behave quite the same. That said it is roughly what I planned to do for the live connections as the behaviour of the qMemoryRegionInfo query is more tightly specified and moving to that model would just push that implementation one layer higher.

I will push a revision which follows the approach you suggest, if we find that throws up it’s own problems then I can always revert. As I mentioned the remote connections should (hopefully) all work with that pattern so GetMemoryRegions implemented in fewer commits with that approach.

Is PAGEZERO actually included in Mac core dumps? I can see it as load command 0 when I run otool against an executable but when I look at a core dump from the same executable the first load command looks like load command 1 in the executable. There doesn’t seem to be a load command in the core for address 0. I might just be missing an flag on otool though.

[clayborg]

In D21751#468738, @hhellyer wrote:

Since there’s a list of memory regions already created in the Process implementations for the core fles I thought it made sense just to use that directly, at least when reading from a core file. It meant there was no requirement to change those GetMemoryRegionInfo implementations if they didn’t behave quite the same. That said it is roughly what I planned to do for the live connections as the behaviour of the qMemoryRegionInfo query is more tightly specified and moving to that model would just push that implementation one layer higher.

We should document the Process::GetMemoryRegionInfo() and what we expect of it so that all plug-ins implement it correctly.

I will push a revision which follows the approach you suggest, if we find that throws up it’s own problems then I can always revert. As I mentioned the remote connections should (hopefully) all work with that pattern so GetMemoryRegions implemented in fewer commits with that approach.

Indeed. Since we already expect a behavior from Process::GetMemoryRegionInfo(), I would say lets enforce these requirements by making Process::GetMemoryRegions() just use that API as required. The only time we should see an error from Process::GetMemoryRegionInfo() is when it isn't implemented.

Is PAGEZERO actually included in Mac core dumps? I can see it as load command 0 when I run otool against an executable but when I look at a core dump from the same executable the first load command looks like load command 1 in the executable. There doesn’t seem to be a load command in the core for address 0. I might just be missing an flag on otool though.

It might not be, but that brings up another thing I was thinking of is that we could start supplementing the Process::GetMemoryRegionInfo() info by also looking in any sections that were found in core file memory that might not be fully described by the core file itself. There is no requirements that if two sections are adjacent in a core file that they show up as different mapped regions, so you might find a mapped section of memory from 0x1000-0x8000 that is actually 0x1000-0x4000 for ".data" and 0x4000-0x8000 that is ".bss". The memory region was mapped read+write, but would it be nice to know about these different regions separately? We don't need to do this now, but this is one place where we could figure out that 0x0-0x100000000 is __PAGEZERO even though it isn't mapped into the current mach-o file's memory regions. Also there are different makers of core files: lldb, the kernel, possibly others. They don't always follow the same rules when making mach-o core files. So it is nice to be flexible.

[labath]

Please also add a test for this in TestLinuxCore.py.

There shouldn't be a need to add a new core file, you can just add an additional check to the do_test method that verifies the right memory regions (which you can pass in the same way as the pid). You can pass in bogus (empty) values for the i386 and s390x test cases, as they are not working now anyway.

[hhellyer]

In D21751#468976, @clayborg wrote:

We should document the Process::GetMemoryRegionInfo() and what we expect of it so that all plug-ins implement it correctly.

I'll add a full comment in Process.h and I'll make sure the description matches the behaviour of qMemoryRegionInfo.

I will push a revision which follows the approach you suggest, if we find that throws up it’s own problems then I can always revert. As I mentioned the remote connections should (hopefully) all work with that pattern so GetMemoryRegions implemented in fewer commits with that approach.

Indeed. Since we already expect a behavior from Process::GetMemoryRegionInfo(), I would say lets enforce these requirements by making Process::GetMemoryRegions() just use that API as required. The only time we should see an error from Process::GetMemoryRegionInfo() is when it isn't implemented.

Ok, I’ve looked at the implementation on a couple of Mac and Linux cores, at the moment it will return an error if the function is unimplemented or you request a load_addr past the last mapped memory range. After the change it will only return an error when unimplemented. As GetMemoryRegionInfo (on Mac and Linux cores) doesn't return an error if you ask for unmapped memory ranges in the middle of the address space this is probably more consistent as the MemoryRange will always be populated for any address that’s queried, there's nothing magic about addresses beyond the last mapped region it should behave the same for those. I’ll go through and check the behaviour elsewhere and update the patch. I will have to update the existing implementations to set the flag that says whether a memory region is mapped or not but that doesn't look complicated.

Is PAGEZERO actually included in Mac core dumps? I can see it as load command 0 when I run otool against an executable but when I look at a core dump from the same executable the first load command looks like load command 1 in the executable. There doesn’t seem to be a load command in the core for address 0. I might just be missing an flag on otool though.

It might not be, but that brings up another thing I was thinking of is that we could start supplementing the Process::GetMemoryRegionInfo() info by also looking in any sections that were found in core file memory that might not be fully described by the core file itself. There is no requirements that if two sections are adjacent in a core file that they show up as different mapped regions, so you might find a mapped section of memory from 0x1000-0x8000 that is actually 0x1000-0x4000 for ".data" and 0x4000-0x8000 that is ".bss". The memory region was mapped read+write, but would it be nice to know about these different regions separately? We don't need to do this now, but this is one place where we could figure out that 0x0-0x100000000 is __PAGEZERO even though it isn't mapped into the current mach-o file's memory regions. Also there are different makers of core files: lldb, the kernel, possibly others. They don't always follow the same rules when making mach-o core files. So it is nice to be flexible.

Another possibility, instead of splitting regions, is providing a way to iterate over all the sections a region contains. I'm not sure which is better. Do you want me to add a "backed" flag, possibly just for cores, that identifies whether there is any data for this region actually in the core dump. (For example a core might be truncated because of a ulimit or have omitted regions because of /proc/[pid]/coredump_filter settings on Linux.)

In D21751#469903, @labath wrote:

Please also add a test for this in TestLinuxCore.py.

There shouldn't be a need to add a new core file, you can just add an additional check to the do_test method that verifies the right memory regions (which you can pass in the same way as the pid). You can pass in bogus (empty) values for the i386 and s390x test cases, as they are not working now anyway.

Ok, I'll add that into this patch unless you prefer test updates as separate commits.

[hhellyer]

I’ve added a test in TestLinuxCore.py. It found a bug which the change in RangeMap.h resolves.

It fills in the implementation of Process::GetMemoryRegions() and makes minor changes to support the mapped attribute in MemoryRegionInfo to the Mac and Linux process implementations. I also updated the documentation for Process::GetMemoryRegionInfo.

Windows will require more changes to support the API correctly, I’m currently getting an environment setup where I can work on those.

[clayborg]

It would be nice to export the is_mapped through the SBMemoryRegionInfo in the public API for completeness.

[hhellyer]

Updated patch to export IsMapped in the C++ and Python APIs.
Updated the test case to verify all the regions returned in the list are mapped.

[clayborg]

Looks good.

include/lldb/API/SBMemoryRegionInfo.h

public:
     /// Check if this memory address is marked executable to the process.
     ///
     /// @return
     ///     true if this memory address is marked executable
     //------------------------------------------------------------------
     bool
     IsExecutable ();
 
+    //------------------------------------------------------------------
+    /// Check if this memory address is mapped into the process address
+    /// space.
+    ///
+    /// @return
+    ///     true if this memory address is in the process address space.
+    //------------------------------------------------------------------
+    bool
+    IsMapped ();
+
     bool
     operator == (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     operator != (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     GetDescription (lldb::SBStream &description);

include/lldb/Core/RangeMap.h

 #ifdef ASSERT_RANGEMAP_ARE_SORTED
             assert(IsSorted());
 #endif
             if (!m_entries.empty())
             {
                 typename Collection::const_iterator end = m_entries.end();
                 typename Collection::const_iterator pos =
                     std::lower_bound(m_entries.begin(), end, addr, [](const Entry &lhs, B rhs_base) -> bool {
-                        return lhs.GetRangeBase() < rhs_base;
+                        return lhs.GetRangeEnd() <= rhs_base;
                     });
 
                 if (pos != end)
                     return &(*pos);
             }
             return nullptr;
         }
 

include/lldb/Target/MemoryRegionInfo.h

public:
             eNo         = 0,
             eYes        = 1
         };
         
         MemoryRegionInfo () :
         m_range (),
         m_read (eDontKnow),
         m_write (eDontKnow),
-        m_execute (eDontKnow)
+        m_execute (eDontKnow),
+        m_mapped (eDontKnow)
         {
         }
         
         ~MemoryRegionInfo ()
         {
         }
         
         RangeType &
public:
         }
         
         OptionalBool
         GetExecutable () const
         {
             return m_execute;
         }
         
+        OptionalBool
+        GetMapped () const
+        {
+            return m_mapped;
+        }
+        
         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;
+        }
+
         //----------------------------------------------------------------------
         // 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;
public:
         }
 
         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_execute == rhs.m_execute &&
+                   m_mapped == rhs.m_mapped;
         }
         
         bool
         operator != (const MemoryRegionInfo &rhs) const
         {
             return !(*this == rhs);
         }
         
     protected:
         RangeType m_range;
         OptionalBool m_read;
         OptionalBool m_write;
         OptionalBool m_execute;
+        OptionalBool m_mapped;
     };
 }
 
 #endif // #ifndef lldb_MemoryRegionInfo_h

include/lldb/Target/Process.h

public:
     ///
     /// @return
     ///     The address of the resolved function.
     ///     LLDB_INVALID_ADDRESS if the resolution failed.
     //------------------------------------------------------------------
     virtual lldb::addr_t
     ResolveIndirectFunction(const Address *address, Error &error);
 
+    //------------------------------------------------------------------
+    /// Locate the memory region that contains load_addr.
+    ///
+    /// If load_addr is within the address space the process has mapped
+    /// range_info will be filled in with the start and end of that range
+    /// as well as the permissions for that range and range_info.GetMapped
+    /// will return true.
+    ///
+    /// If load_addr is outside any mapped region then range_info will
+    /// have its start address set to load_addr and the end of the
+    /// range will indicate the start of the next mapped range or be
+    /// set to LLDB_INVALID_ADDRESS if there are no valid mapped ranges
+    /// between load_addr and the end of the process address space.
+    ///
+    /// GetMemoryRegionInfo will only return an error if it is
+    /// unimplemented for the current process.
+    ///
+    /// @param[in] load_addr
+    ///     The load address to query the range_info for.
+    ///
+    /// @param[out] range_info
+    ///     An range_info value containing the details of the range.
+    ///
+    /// @return
+    ///     An error value.
+    //------------------------------------------------------------------
     virtual Error
     GetMemoryRegionInfo (lldb::addr_t load_addr,
                          MemoryRegionInfo &range_info)
     {
         Error error;
         error.SetErrorString ("Process::GetMemoryRegionInfo() not supported");
         return error;
     }
 
+    //------------------------------------------------------------------
+    /// Obtain all the mapped memory regions within this process.
+    ///
+    /// @param[out] region_list
+    ///     A vector to contain MemoryRegionInfo objects for all mapped
+    ///     ranges.
+    ///
+    /// @return
+    ///     An error value.
+    //------------------------------------------------------------------
     virtual Error
-    GetMemoryRegions (std::vector<lldb::MemoryRegionInfoSP>&)
-    {
-        Error error;
-        error.SetErrorString ("Process::GetMemoryRegions() not supported");
-        return error;
-    }
+    GetMemoryRegions (std::vector<lldb::MemoryRegionInfoSP>& region_list);
 
     virtual Error
     GetWatchpointSupportInfo (uint32_t &num)
     {
         Error error;
         num = 0;
         error.SetErrorString ("Process::GetWatchpointSupportInfo() not supported");
         return error;

packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/TestLinuxCore.py

class LinuxCoreTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     mydir = TestBase.compute_mydir(__file__)
 
     _i386_pid   = 32306
     _x86_64_pid = 32259
     _s390x_pid  = 1045
 
+    _i386_regions   = 4
+    _x86_64_regions = 5
+    _s390x_regions  = 2
+
     @skipIf(bugnumber="llvm.org/pr26947")
     def test_i386(self):
         """Test that lldb can read the process information from an i386 linux core file."""
-        self.do_test("i386", self._i386_pid)
+        self.do_test("i386", self._i386_pid, self._i386_regions)
 
     def test_x86_64(self):
         """Test that lldb can read the process information from an x86_64 linux core file."""
-        self.do_test("x86_64", self._x86_64_pid)
+        self.do_test("x86_64", self._x86_64_pid, self._x86_64_regions)
 
     # This seems to hang on non-s390x platforms for some reason.  Disabling for now.
     @skipIf(archs=no_match(['s390x'])) 
     def test_s390x(self):
         """Test that lldb can read the process information from an s390x linux core file."""
-        self.do_test("s390x", self._s390x_pid)
+        self.do_test("s390x", self._s390x_pid, self._s390x_regions)
 
     def test_same_pid_running(self):
         """Test that we read the information from the core correctly even if we have a running
         process with the same PID around"""
         try:
             shutil.copyfile("x86_64.out",  "x86_64-pid.out")
             shutil.copyfile("x86_64.core", "x86_64-pid.core")
             with open("x86_64-pid.core", "r+b") as f:
                 # These are offsets into the NT_PRSTATUS and NT_PRPSINFO structures in the note
                 # segment of the core file. If you update the file, these offsets may need updating
                 # as well. (Notes can be viewed with readelf --notes.)
                 for pid_offset in [0x1c4, 0x320]:
                     f.seek(pid_offset)
                     self.assertEqual(struct.unpack("<I", f.read(4))[0], self._x86_64_pid)
 
                     # We insert our own pid, and make sure the test still works.
                     f.seek(pid_offset)
                     f.write(struct.pack("<I", os.getpid()))
-            self.do_test("x86_64-pid", os.getpid())
+            self.do_test("x86_64-pid", os.getpid(), self._x86_64_regions)
         finally:
             self.RemoveTempFile("x86_64-pid.out")
             self.RemoveTempFile("x86_64-pid.core")
 
     def test_two_cores_same_pid(self):
         """Test that we handle the situation if we have two core files with the same PID
         around"""
         alttarget = self.dbg.CreateTarget("altmain.out")
         altprocess = alttarget.LoadCore("altmain.core")
         self.assertTrue(altprocess, PROCESS_IS_VALID)
         self.assertEqual(altprocess.GetNumThreads(), 1)
         self.assertEqual(altprocess.GetProcessID(), self._x86_64_pid)
 
         altframe = altprocess.GetSelectedThread().GetFrameAtIndex(0)
         self.assertEqual(altframe.GetFunctionName(), "_start")
         self.assertEqual(altframe.GetLineEntry().GetLine(), line_number("altmain.c", "Frame _start"))
 
         error = lldb.SBError()
         F = altprocess.ReadCStringFromMemory(altframe.FindVariable("F").GetValueAsUnsigned(), 256, error)
         self.assertTrue(error.Success())
         self.assertEqual(F, "_start")
 
         # without destroying this process, run the test which opens another core file with the
         # same pid
-        self.do_test("x86_64", self._x86_64_pid)
+        self.do_test("x86_64", self._x86_64_pid, self._x86_64_regions)
+
+    def check_memory_regions(self, process, region_count):
+        region_list = process.GetMemoryRegions()
+        self.assertEqual(region_list.GetSize(), region_count)
+
+        region = lldb.SBMemoryRegionInfo()
+
+        # Check we have the right number of regions.
+        self.assertEqual(region_list.GetSize(), region_count);
+
+        # Check that getting a region beyond the last in the list fails.
+        self.assertFalse(region_list.GetMemoryRegionAtIndex(region_count, region));
+
+        # Check each region is valid.
+        for i in range(region_list.GetSize()):
+            # Check we can actually get this region.
+            self.assertTrue(region_list.GetMemoryRegionAtIndex(i, region))
+
+            #Every region in the list should be mapped.
+            self.assertTrue(region.IsMapped())
+
+            # Test the address at the start of a region returns it's enclosing region.
+            begin_address = region.GetRegionBase()
+            region_at_begin = lldb.SBMemoryRegionInfo()
+            error = process.GetMemoryRegionInfo(begin_address, region_at_begin)
+            self.assertEqual(region, region_at_begin)
+
+            # Test an address in the middle of a region returns it's enclosing region.
+            middle_address = (region.GetRegionBase() + region.GetRegionEnd()) / 2l
+            region_at_middle = lldb.SBMemoryRegionInfo()
+            error = process.GetMemoryRegionInfo(middle_address, region_at_middle)
+            self.assertEqual(region, region_at_middle)
+
+            # Test the address at the end of a region returns it's enclosing region.
+            end_address = region.GetRegionEnd() - 1l
+            region_at_end = lldb.SBMemoryRegionInfo()
+            error = process.GetMemoryRegionInfo(end_address, region_at_end)
+            self.assertEqual(region, region_at_end)
+
+            # Check that quering the end address does not return this region but
+            # the next one.
+            next_region = lldb.SBMemoryRegionInfo()
+            error = process.GetMemoryRegionInfo(region.GetRegionEnd(), next_region)
+            self.assertNotEqual(region, next_region)
+            self.assertEqual(region.GetRegionEnd(), next_region.GetRegionBase())
+
+        # Check that query beyond the last region returns an unmapped region
+        # that ends at LLDB_INVALID_ADDRESS
+        last_region = lldb.SBMemoryRegionInfo()
+        region_list.GetMemoryRegionAtIndex(region_count - 1, last_region)
+        end_region = lldb.SBMemoryRegionInfo()
+        error = process.GetMemoryRegionInfo(last_region.GetRegionEnd(), end_region)
+        self.assertFalse(end_region.IsMapped())
+        self.assertEqual(last_region.GetRegionEnd(), end_region.GetRegionBase())
+        self.assertEqual(end_region.GetRegionEnd(), lldb.LLDB_INVALID_ADDRESS)
 
-    def do_test(self, filename, pid):
+    def do_test(self, filename, pid, region_count):
         target = self.dbg.CreateTarget(filename + ".out")
         process = target.LoadCore(filename + ".core")
         self.assertTrue(process, PROCESS_IS_VALID)
         self.assertEqual(process.GetNumThreads(), 1)
         self.assertEqual(process.GetProcessID(), pid)
 
         thread = process.GetSelectedThread()
         self.assertTrue(thread)
         self.assertEqual(thread.GetThreadID(), pid)
         backtrace = ["bar", "foo", "_start"]
         self.assertEqual(thread.GetNumFrames(), len(backtrace))
         for i in range(len(backtrace)):
             frame = thread.GetFrameAtIndex(i)
             self.assertTrue(frame)
             self.assertEqual(frame.GetFunctionName(), backtrace[i])
             self.assertEqual(frame.GetLineEntry().GetLine(),
                     line_number("main.c", "Frame " + backtrace[i]))
             self.assertEqual(frame.FindVariable("F").GetValueAsUnsigned(), ord(backtrace[i][0]))
 
+        self.check_memory_regions(process, region_count)
+
         self.dbg.DeleteTarget(target)

scripts/interface/SBMemoryRegionInfo.i

public:
 
     bool
     IsWritable ();
 
     bool
     IsExecutable ();
 
     bool
+    IsMapped ();
+
+    bool
     operator == (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     operator != (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     GetDescription (lldb::SBStream &description);
 
 };
 
 } // namespace lldb

source/API/SBMemoryRegionInfo.cpp

 }
 
 bool
 SBMemoryRegionInfo::IsExecutable () {
     return m_opaque_ap->GetExecutable() == MemoryRegionInfo::eYes;
 }
 
 bool
+SBMemoryRegionInfo::IsMapped () {
+    return m_opaque_ap->GetMapped() == MemoryRegionInfo::eYes;
+}
+
+bool
 SBMemoryRegionInfo::GetDescription (SBStream &description)
 {
     Stream &strm = description.ref();
     const addr_t load_addr = m_opaque_ap->GetRange().base;
 
     strm.Printf ("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 " ", load_addr, load_addr + m_opaque_ap->GetRange().size);
     strm.Printf (m_opaque_ap->GetReadable() ? "R" : "-");
     strm.Printf (m_opaque_ap->GetWritable() ? "W" : "-");
     strm.Printf (m_opaque_ap->GetExecutable() ? "X" : "-");
     strm.Printf ("]");
 
     return true;
 }

source/Plugins/Process/Linux/NativeProcessLinux.cpp

ParseMemoryRegionInfoFromProcMapsLine (const std::string &maps_line, MemoryRegionInfo &memory_region_info)
     // Parse out the space after the address.
     if (!line_extractor.GetBytesLeft () || (line_extractor.GetChar () != ' '))
         return Error ("malformed /proc/{pid}/maps entry, missing space after range");
 
     // 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.
+    memory_region_info.SetMapped(MemoryRegionInfo::OptionalBool::eYes);
+
     // Parse out each permission entry.
     if (line_extractor.GetBytesLeft () < 4)
         return Error ("malformed /proc/{pid}/maps entry, missing some portion of permissions");
 
     // Handle read permission.
     const char read_perm_char = line_extractor.GetChar ();
     if (read_perm_char == 'r')
         memory_region_info.SetReadable (MemoryRegionInfo::OptionalBool::eYes);
for (auto it = m_mem_region_cache.begin(); it != m_mem_region_cache.end (); ++it)
         // If the target address comes before this entry, indicate distance to next region.
         if (load_addr < proc_entry_info.GetRange ().GetRangeBase ())
         {
             range_info.GetRange ().SetRangeBase (load_addr);
             range_info.GetRange ().SetByteSize (proc_entry_info.GetRange ().GetRangeBase () - load_addr);
             range_info.SetReadable (MemoryRegionInfo::OptionalBool::eNo);
             range_info.SetWritable (MemoryRegionInfo::OptionalBool::eNo);
             range_info.SetExecutable (MemoryRegionInfo::OptionalBool::eNo);
+            range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
 
             return error;
         }
         else if (proc_entry_info.GetRange ().Contains (load_addr))
         {
             // The target address is within the memory region we're processing here.
             range_info = proc_entry_info;
             return error;
         }
 
         // The target memory address comes somewhere after the region we just parsed.
     }
 
     // If we made it here, we didn't find an entry that contained the given address. Return the
     // load_addr as start and the amount of bytes betwwen load address and the end of the memory as
     // size.
     range_info.GetRange ().SetRangeBase (load_addr);
-    switch (m_arch.GetAddressByteSize())
-    {
-        case 4:
-            range_info.GetRange ().SetByteSize (0x100000000ull - load_addr);
-            break;
-        case 8:
-            range_info.GetRange ().SetByteSize (0ull - load_addr);
-            break;
-        default:
-            assert(false && "Unrecognized data byte size");
-            break;
-    }
+    range_info.GetRange ().SetRangeEnd(LLDB_INVALID_ADDRESS);
     range_info.SetReadable (MemoryRegionInfo::OptionalBool::eNo);
     range_info.SetWritable (MemoryRegionInfo::OptionalBool::eNo);
     range_info.SetExecutable (MemoryRegionInfo::OptionalBool::eNo);
+    range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
     return error;
 }
 
 void
 NativeProcessLinux::DoStopIDBumped (uint32_t newBumpId)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log)

source/Plugins/Process/elf-core/ProcessElfCore.cpp

if (permission_entry)
             region_info.GetRange().SetRangeEnd(permission_entry->GetRangeEnd());
             const Flags permissions(permission_entry->data);
             region_info.SetReadable(permissions.Test(lldb::ePermissionsReadable) ? MemoryRegionInfo::eYes
                                                                                  : MemoryRegionInfo::eNo);
             region_info.SetWritable(permissions.Test(lldb::ePermissionsWritable) ? MemoryRegionInfo::eYes
                                                                                  : MemoryRegionInfo::eNo);
             region_info.SetExecutable(permissions.Test(lldb::ePermissionsExecutable) ? MemoryRegionInfo::eYes
                                                                                      : MemoryRegionInfo::eNo);
+            region_info.SetMapped(MemoryRegionInfo::eYes);
         }
         else if (load_addr < permission_entry->GetRangeBase())
         {
             region_info.GetRange().SetRangeBase(load_addr);
             region_info.GetRange().SetRangeEnd(permission_entry->GetRangeBase());
             region_info.SetReadable(MemoryRegionInfo::eNo);
             region_info.SetWritable(MemoryRegionInfo::eNo);
             region_info.SetExecutable(MemoryRegionInfo::eNo);
+            region_info.SetMapped(MemoryRegionInfo::eNo);
         }
         return Error();
     }
-    return Error("invalid address");
+
+    region_info.GetRange().SetRangeBase(load_addr);
+    region_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
+    region_info.SetReadable(MemoryRegionInfo::eNo);
+    region_info.SetWritable(MemoryRegionInfo::eNo);
+    region_info.SetExecutable(MemoryRegionInfo::eNo);
+    region_info.SetMapped(MemoryRegionInfo::eNo);
+    return Error();
 }
 
 size_t
 ProcessElfCore::DoReadMemory (lldb::addr_t addr, void *buf, size_t size, Error &error)
 {
     ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
 
     if (core_objfile == NULL)

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

if (m_supports_memory_region_info != eLazyBoolNo)
                             region_info.SetWritable (MemoryRegionInfo::eYes);
                         else
                             region_info.SetWritable (MemoryRegionInfo::eNo);
 
                         if (value.find('x') != std::string::npos)
                             region_info.SetExecutable (MemoryRegionInfo::eYes);
                         else
                             region_info.SetExecutable (MemoryRegionInfo::eNo);
+
+                        region_info.SetMapped(MemoryRegionInfo::eYes);
                     }
                     else
                     {
                         // The reported region does not contain this address -- we're looking at an unmapped page
                         region_info.SetReadable (MemoryRegionInfo::eNo);
                         region_info.SetWritable (MemoryRegionInfo::eNo);
                         region_info.SetExecutable (MemoryRegionInfo::eNo);
+                        region_info.SetMapped(MemoryRegionInfo::eNo);
                     }
                 }
                 else if (name.compare ("error") == 0)
                 {
                     StringExtractorGDBRemote name_extractor;
                     // Swap "value" over into "name_extractor"
                     name_extractor.GetStringRef().swap(value);
                     // Now convert the HEX bytes into a string value
                     name_extractor.GetHexByteString (value);
                     error.SetErrorString(value.c_str());
                 }
             }
 
             // We got a valid address range back but no permissions -- which means this is an unmapped page
             if (region_info.GetRange().IsValid() && saw_permissions == false)
             {
                 region_info.SetReadable (MemoryRegionInfo::eNo);
                 region_info.SetWritable (MemoryRegionInfo::eNo);
                 region_info.SetExecutable (MemoryRegionInfo::eNo);
+                region_info.SetMapped(MemoryRegionInfo::eNo);
             }
         }
         else
         {
             m_supports_memory_region_info = eLazyBoolNo;
         }
     }
 

source/Plugins/Process/mach-core/ProcessMachCore.cpp

if (permission_entry)
             region_info.GetRange().SetRangeEnd(permission_entry->GetRangeEnd());
             const Flags permissions(permission_entry->data);
             region_info.SetReadable(permissions.Test(ePermissionsReadable) ? MemoryRegionInfo::eYes
                                                                            : MemoryRegionInfo::eNo);
             region_info.SetWritable(permissions.Test(ePermissionsWritable) ? MemoryRegionInfo::eYes
                                                                            : MemoryRegionInfo::eNo);
             region_info.SetExecutable(permissions.Test(ePermissionsExecutable) ? MemoryRegionInfo::eYes
                                                                                : MemoryRegionInfo::eNo);
+            region_info.SetMapped(MemoryRegionInfo::eYes);
         }
         else if (load_addr < permission_entry->GetRangeBase())
         {
             region_info.GetRange().SetRangeBase(load_addr);
             region_info.GetRange().SetRangeEnd(permission_entry->GetRangeBase());
             region_info.SetReadable(MemoryRegionInfo::eNo);
             region_info.SetWritable(MemoryRegionInfo::eNo);
             region_info.SetExecutable(MemoryRegionInfo::eNo);
+            region_info.SetMapped(MemoryRegionInfo::eNo);
         }
         return Error();
     }
 
-    return Error("invalid address");
+    region_info.GetRange().SetRangeBase(load_addr);
+    region_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
+    region_info.SetReadable(MemoryRegionInfo::eNo);
+    region_info.SetWritable(MemoryRegionInfo::eNo);
+    region_info.SetExecutable(MemoryRegionInfo::eNo);
+    region_info.SetMapped(MemoryRegionInfo::eNo);
+    return Error();
 }
 
 void
 ProcessMachCore::Clear()
 {
     m_thread_list.Clear();
 }
 

source/Target/Process.cpp

if (branch_index > insn_offset)
         if (next_branch_insn_address.IsValid() && range_bounds.ContainsFileAddress (next_branch_insn_address))
         {
             retval = next_branch_insn_address;
         }
     }
 
     return retval;
 }
+
+Error
+Process::GetMemoryRegions (std::vector<lldb::MemoryRegionInfoSP>& region_list)
+{
+
+    Error error;
+
+    lldb::addr_t range_base = 0;
+    lldb::addr_t range_end = 0;
+
+    region_list.clear();
+    do
+    {
+        lldb::MemoryRegionInfoSP region_info( new lldb_private::MemoryRegionInfo() );
+        error = GetMemoryRegionInfo (range_end, *region_info);
+        // GetMemoryRegionInfo should only return an error if it is unimplemented.
+        if (error.Fail())
+        {
+            region_list.clear();
+            break;
+        }
+
+        range_base = region_info->GetRange().GetRangeBase();
+        range_end = region_info->GetRange().GetRangeEnd();
+        if( region_info->GetMapped() == MemoryRegionInfo::eYes )
+        {
+            region_list.push_back(region_info);
+        }
+    } while (range_end != LLDB_INVALID_ADDRESS);
+
+    return error;
+
+}