Add MemoryRegionInfo to SB API

[hhellyer]

Summary

This adds new SB API calls and classes to allow a user of the SB API to obtain a full list of memory regions accessible within the process. Adding this to the API makes it possible use the API for tasks like scanning memory for blocks allocated with a header and footer to track down memory leaks, otherwise just inspecting every address is impractical especially for 64 bit processes.

These changes only add the API itself and a base implementation of GetMemoryRegions() to lldb_private::Process::GetMemoryRegions.
I will submit separate patches to fill in lldb_private::Process::GetMemoryRegionInfoList and GetMemoryRegionInfo for individual platforms.

The original discussion about this is here:
http://lists.llvm.org/pipermail/lldb-dev/2016-May/010203.html

[clayborg]

Few minor changes, but looks great overall. Thanks for doing this.

include/lldb/Target/MemoryRegionInfo.h

18–19

We don't need to inherit from std::enable_shared_from_this do we? Is there a future patch where you intend on using this? If not, lets leave it out for now and add it later if we need to.

source/API/SBProcess.cpp

1487

Please name "region_info_sp". All variables that are shared pointers should have "_sp" suffixes.

[hhellyer]

Removed std::enable_shared_from_this from MemoryRegionInfo.h (which removes the only change from that file)
Renamed region_info to region_info_sp in SBProcess::GetMemoryRegionInfo in SBProcess.cpp
I also corrected the position of the opening { on the functions in that file to match the standard.

[clayborg]

This looks good as long as SBMemoryRegionInfo and SBMemoryRegionInfoList are ready only and will never have any setter functions. If we plan to ever have the SBMemoryRegionInfo or SBMemoryRegionInfoList be modifiable, then we should make each contain a std::unique_ptr instead of a std::shared_ptr. Then the constructors always create an object and the copy constructor and assignment operators would just copy their contents from one to another instead of sharing the data. If you have code like:

SBMemoryRegionInfo region;
if (process.GetMemoryRegionInfo(0x123, region).Success())
{
    SBMemoryRegionInfo region2(region);
    region2.SetSomething(xxxxx);
}

Would you expect that the variable "region" now has the "SetSomething(xxxxx)" applied to it? I would expect not.

So I propose the following changes:

• make both SBMemoryRegionInfo and SBMemoryRegionInfoList contain std::unique_ptr objects
• have their constructors always create a default object
• change copy constructors to copy the objects instead of sharing a reference
• change assignment operators to copy the objects instead of sharing a reference

[hhellyer]

In D20565#442373, @clayborg wrote:

This looks good as long as SBMemoryRegionInfo and SBMemoryRegionInfoList are ready only and will never have any setter functions. If we plan to ever have the SBMemoryRegionInfo or SBMemoryRegionInfoList be modifiable, then we should make each contain a std::unique_ptr instead of a std::shared_ptr.

I’m not sure if there’s ever going to be a need for any setter methods on the SBMemoryRegionInfo classes. Can you suggest any use cases? In my mind they just reflect the state of the memory in the process, I'm not sure if they allow that state to be changed.

For example a user wouldn’t ever directly create a new memory region by creating an SBMemoryRegionInfo. The process would allocate memory, memory map a file or load a module and a new one (might) be created. Other functions in lldb might cause the process to allocate or free memory and indirectly create or extend a memory region. Similarly changing a regions properties (e.g. making a region read only or changing it’s size) doesn’t necessarily make sense as those changes won't be reflected back in the process.

If SBMemoryRegion had setters, what the desired behaviour would be? The original purpose of SBMemoryInfoList to take a snap shot of memory regions (instead of using GetNumRegions and GetRegionAtIndex which would give unreliable results if the process was allowed to continue) so I'm not sure how it would all fit together if memory regions could be created or updated especially if the process continued.

I guess the other case is setting something on the memory region that changes the behaviour of lldb with respect to it or using an SBMemoryRegionInfo as an argument to another method. Then you might want to create a custom region and there may be some of those that make more sense.

So I propose the following changes:

• make both SBMemoryRegionInfo and SBMemoryRegionInfoList contain std::unique_ptr objects
• have their constructors always create a default object
• change copy constructors to copy the objects instead of sharing a reference
• change assignment operators to copy the objects instead of sharing a reference

I'll make the changes and upload a new patch, it certainly doesn't hurt to enable it as a possibility, I'm just not sure what the behaviour would be with modifiable memory regions. I can always go back to the shared pointer version. (Sorry for the delay in replying, it was a bank holiday here yesterday.)

[clayborg]

In D20565#444223, @hhellyer wrote:

In D20565#442373, @clayborg wrote:

This looks good as long as SBMemoryRegionInfo and SBMemoryRegionInfoList are ready only and will never have any setter functions. If we plan to ever have the SBMemoryRegionInfo or SBMemoryRegionInfoList be modifiable, then we should make each contain a std::unique_ptr instead of a std::shared_ptr.

I’m not sure if there’s ever going to be a need for any setter methods on the SBMemoryRegionInfo classes. Can you suggest any use cases? In my mind they just reflect the state of the memory in the process, I'm not sure if they allow that state to be changed.

For example a user wouldn’t ever directly create a new memory region by creating an SBMemoryRegionInfo. The process would allocate memory, memory map a file or load a module and a new one (might) be created. Other functions in lldb might cause the process to allocate or free memory and indirectly create or extend a memory region. Similarly changing a regions properties (e.g. making a region read only or changing it’s size) doesn’t necessarily make sense as those changes won't be reflected back in the process.

If SBMemoryRegion had setters, what the desired behaviour would be? The original purpose of SBMemoryInfoList to take a snap shot of memory regions (instead of using GetNumRegions and GetRegionAtIndex which would give unreliable results if the process was allowed to continue) so I'm not sure how it would all fit together if memory regions could be created or updated especially if the process continued.

It would be if we expose allocating/deallocating memory regions. User would create a memory region, set read/write/execute and a size, then call:

SBError SBProcess::AllocateMemory(SBMemoryRegionInfo &region);

I guess the other case is setting something on the memory region that changes the behaviour of lldb with respect to it or using an SBMemoryRegionInfo as an argument to another method. Then you might want to create a custom region and there may be some of those that make more sense.

Yes, it is in case we enable calls that would require users to fill out memory regions. If we somehow exposed mmap through the public API, you can also request a certain address for the allocation in some calls.

So I propose the following changes:

• make both SBMemoryRegionInfo and SBMemoryRegionInfoList contain std::unique_ptr objects
• have their constructors always create a default object
• change copy constructors to copy the objects instead of sharing a reference
• change assignment operators to copy the objects instead of sharing a reference

I'll make the changes and upload a new patch, it certainly doesn't hurt to enable it as a possibility, I'm just not sure what the behaviour would be with modifiable memory regions. I can always go back to the shared pointer version. (Sorry for the delay in replying, it was a bank holiday here yesterday.)

My main reason for making sure we use std::unique_ptr is for API compatibility in the future. The size of std::unique_ptr and std::shared_ptr differs and if anyone wrote an IDE or tool that links against the LLDB public API, then we can't switch the layout of a class without breaking our ABI. So it is safest to go with a std::unique_ptr since the backing class is so simple and isn't expensive to copy.

[hhellyer]

I've switch to a unique_ptr from a shared_ptr in SBMemoryRegionInfo.

[hhellyer]

In D20565#444507, @clayborg wrote:

My main reason for making sure we use std::unique_ptr is for API compatibility in the future. The size of std::unique_ptr and std::shared_ptr differs and if anyone wrote an IDE or tool that links against the LLDB public API, then we can't switch the layout of a class without breaking our ABI. So it is safest to go with a std::unique_ptr since the backing class is so simple and isn't expensive to copy.

That's reasonable, the objects themselves aren't so large or numerous that not sharing them will make much difference even if we don't ever need to modify them.
SBMemoryRegionInfoList was already using a unique_ptr to hold a reference to its impl object so that didn't need updating.

[clayborg]

One last thing: we should default construct a MemoryRegionInfo in all SBMemoryRegionInfo::SBMemoryRegionInfo() constructors so we don't have a make sure to call a non-const ref() method before it the pointer is valid. I know there is other code that does this, but any new code we have been updating to always default constructing an object into the std::unique_ptr just to be safe and avoid potential crashes.

[hhellyer]

Made sure an object was always constructed for the std::unique_ptr in SBMemoryRegionInfo.cpp.
Removed unused constructor from SBMemoryRegionInfo.h.

[clayborg]

So a bit more cleanup. We should always have a valid object inside of a SBMemoryRegionInfo or SBMemoryRegionInfoList so there is no need to ever check the m_opaque_ap to see if it contains a valid pointer so all if statements that are doing:

if (m_opaque_ap.get())
    m_opaque_ap->DoSomething();

Can be just:

m_opaque_ap->DoSomething();

Also, no functions should ever call "m_opaque_ap->reset();". All the changes should be easy after that.

source/API/SBMemoryRegionInfo.cpp

46–49

These 4 lines should just be:

ref() = rhs.ref();

We never want m_opaque_ap to contain an invalid pointer or we can crash.

61

We shouldn't check for NULL since the auto pointer should never be invalid. This should just call through and ask the underlying object:

return m_opaque_ap->IsValid();

If there is no IsValid() function on the underlying object, this function can be removed.

67

We should never clear the underlying object, this should just call through:

m_opaque_ap->Clear();

73–75

This should compare the objects:

return ref() == rhs.ref();

81–83

This should compare the objects:

return ref() != rhs.ref();

89–90

You should remove these lines now since m_opaque_ap will never contain an invalid object.

102–105

No need to check the object

111–114

No need to check the object, just call the accessor

source/API/SBMemoryRegionInfoList.cpp

109

No need to check the object, just call the accessor. Remove the if and the other return.

137

No need to check the object, just call the accessor. Remove the if statement.

144

No need to check m_opaque_ap since it will always be valid.

151

No need to check m_opaque_ap since it will always be valid.

158

No need for an IsValid() since the list is always valid, this function can actually be removed.

[hhellyer]

Fix the latest code review comments to remove unnecessary tests for a valid pointer that will always be initialised.

The change to the == operator on SBMemoryRegionInfo required an additional change. It also required adding the == and != operators to MemoryRegionInfo.h, that shouldn't be a problem as far as behaviour goes as nothing can have been comparing MemoryRegionInfo's with == until now. It does mean that SBMemoryRegionInfo's == operator behaves differently to all the other SB* classes operators which do pointer comparison via get() which might not be ideal.

[hhellyer]

Updated to rebase on the latest changes to MemoryRegionInfo.h

[hhellyer]

Should I be able to deliver these changes now? When I try following the
instructions here: http://llvm.org/docs/Phabricator.html the patch
downloads and applies correctly but whether I use arc via the git or svn
commit methods I'm ultimately prompted for a password for subversion. I'm
not sure if I should have a password or if that means the patch doesn't
match what's expected in some way. I don't know how clever phabricator's
svn commit hooks are and whether they check against the patch before
prompting for authentication.

(Or is there a "Land this" button on phabricator I'm missing?)

[hhellyer]

Updating to ensure I have the latest changes.

[hhellyer]

I re-updated the patch via arc diff (rather than a manual patch upload). Phabricator now seems to know which revision my changes are based off and has added the "Next Step: arc commit" status. Do I need to request an svn password to run arc commit or can you (or someone) else land this for me?

include/lldb/API/LLDB.h

 #include "lldb/API/SBFunction.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBInstructionList.h"
 #include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBListener.h"
+#include "lldb/API/SBMemoryRegionInfo.h"
+#include "lldb/API/SBMemoryRegionInfoList.h"
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBModuleSpec.h"
 #include "lldb/API/SBPlatform.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBQueue.h"
 #include "lldb/API/SBQueueItem.h"
 #include "lldb/API/SBSection.h"
 #include "lldb/API/SBSourceManager.h"

include/lldb/API/SBDefines.h

 class LLDB_API SBFunction;
 class LLDB_API SBHostOS;
 class LLDB_API SBInstruction;
 class LLDB_API SBInstructionList;
 class LLDB_API SBLanguageRuntime;
 class LLDB_API SBLaunchInfo;
 class LLDB_API SBLineEntry;
 class LLDB_API SBListener;
+class LLDB_API SBMemoryRegionInfo;
+class LLDB_API SBMemoryRegionInfoList;
 class LLDB_API SBModule;
 class LLDB_API SBModuleSpec;
 class LLDB_API SBModuleSpecList;
 class LLDB_API SBProcess;
 class LLDB_API SBQueue;
 class LLDB_API SBQueueItem;
 class LLDB_API SBSection;
 class LLDB_API SBSourceManager;

include/lldb/API/SBMemoryRegionInfo.h

+//===-- SBMemoryRegionInfo.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBMemoryRegionInfo_h_
+#define LLDB_SBMemoryRegionInfo_h_
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBData.h"
+
+namespace lldb {
+
+class LLDB_API SBMemoryRegionInfo
+{
+public:
+
+    SBMemoryRegionInfo ();
+
+    SBMemoryRegionInfo (const lldb::SBMemoryRegionInfo &rhs);
+
+    ~SBMemoryRegionInfo ();
+
+    const lldb::SBMemoryRegionInfo &
+    operator = (const lldb::SBMemoryRegionInfo &rhs);
+
+    void
+    Clear();
+
+    //------------------------------------------------------------------
+    /// Get the base address of this memory range.
+    ///
+    /// @return
+    ///     The base address of this memory range.
+    //------------------------------------------------------------------
+    lldb::addr_t
+    GetRegionBase ();
+
+    //------------------------------------------------------------------
+    /// Get the end address of this memory range.
+    ///
+    /// @return
+    ///     The base address of this memory range.
+    //------------------------------------------------------------------
+    lldb::addr_t
+    GetRegionEnd ();
+
+    //------------------------------------------------------------------
+    /// Check if this memory address is marked readable to the process.
+    ///
+    /// @return
+    ///     true if this memory address is marked readable
+    //------------------------------------------------------------------
+    bool
+    IsReadable ();
+
+    //------------------------------------------------------------------
+    /// Check if this memory address is marked writable to the process.
+    ///
+    /// @return
+    ///     true if this memory address is marked writable
+    //------------------------------------------------------------------
+    bool
+    IsWritable ();
+
+    //------------------------------------------------------------------
+    /// Check if this memory address is marked executable to the process.
+    ///
+    /// @return
+    ///     true if this memory address is marked executable
+    //------------------------------------------------------------------
+    bool
+    IsExecutable ();
+
+    bool
+    operator == (const lldb::SBMemoryRegionInfo &rhs) const;
+
+    bool
+    operator != (const lldb::SBMemoryRegionInfo &rhs) const;
+
+    bool
+    GetDescription (lldb::SBStream &description);
+
+private:
+
+    friend class SBProcess;
+    friend class SBMemoryRegionInfoList;
+
+    lldb_private::MemoryRegionInfo &
+    ref();
+
+    const lldb_private::MemoryRegionInfo &
+    ref() const;
+
+    SBMemoryRegionInfo (const lldb_private::MemoryRegionInfo *lldb_object_ptr);
+
+    lldb::MemoryRegionInfoUP m_opaque_ap;
+};
+
+
+} // namespace lldb
+
+#endif // LLDB_SBMemoryRegionInfo_h_

include/lldb/API/SBMemoryRegionInfoList.h

+//===-- SBMemoryRegionInfoList.h --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBMemoryRegionInfoList_h_
+#define LLDB_SBMemoryRegionInfoList_h_
+
+#include "lldb/API/SBDefines.h"
+
+class MemoryRegionInfoListImpl;
+
+namespace lldb {
+
+class LLDB_API SBMemoryRegionInfoList
+{
+public:
+
+    SBMemoryRegionInfoList ();
+
+    SBMemoryRegionInfoList (const lldb::SBMemoryRegionInfoList &rhs);
+
+    const SBMemoryRegionInfoList &
+    operator = (const SBMemoryRegionInfoList &rhs);
+
+    ~SBMemoryRegionInfoList ();
+
+    uint32_t
+    GetSize () const;
+
+    bool
+    GetMemoryRegionAtIndex (uint32_t idx, SBMemoryRegionInfo &region_info);
+
+    void
+    Append (lldb::SBMemoryRegionInfo &region);
+
+    void
+    Append (lldb::SBMemoryRegionInfoList &region_list);
+
+    void
+    Clear ();
+
+protected:
+
+    const MemoryRegionInfoListImpl *
+    operator->() const;
+
+    const MemoryRegionInfoListImpl &
+    operator*() const;
+
+private:
+
+    std::unique_ptr<MemoryRegionInfoListImpl> m_opaque_ap;
+
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBMemoryRegionInfoList_h_

include/lldb/API/SBProcess.h

public:
     
     bool
     IsInstrumentationRuntimePresent(InstrumentationRuntimeType type);
 
     // Save the state of the process in a core file (or mini dump on Windows).
     lldb::SBError
     SaveCore(const char *file_name);
 
+    //------------------------------------------------------------------
+    /// Query the address load_addr and store the details of the memory
+    /// region that contains it in the supplied SBMemoryRegionInfo object.
+    /// To iterate over all memory regions use GetMemoryRegionList.
+    ///
+    /// @param[in] load_addr
+    ///     The address to be queried.
+    ///
+    /// @param[out] region_info
+    ///     A reference to an SBMemoryRegionInfo object that will contain
+    ///     the details of the memory region containing load_addr.
+    ///
+    /// @return
+    ///     An error object describes any errors that occurred while
+    ///     querying load_addr.
+    //------------------------------------------------------------------
+    lldb::SBError
+    GetMemoryRegionInfo (lldb::addr_t load_addr, lldb::SBMemoryRegionInfo &region_info);
+
+    //------------------------------------------------------------------
+    /// Return the list of memory regions within the process.
+    ///
+    /// @return
+    ///     A list of all witin the process memory regions.
+    //------------------------------------------------------------------
+    lldb::SBMemoryRegionInfoList
+    GetMemoryRegions();
+
 protected:
     friend class SBAddress;
     friend class SBBreakpoint;
     friend class SBBreakpointLocation;
     friend class SBCommandInterpreter;
     friend class SBDebugger;
     friend class SBExecutionContext;
     friend class SBFunction;

include/lldb/API/SBStream.h

protected:
     friend class SBEvent;
     friend class SBFileSpec;
     friend class SBFileSpecList;
     friend class SBFrame;
     friend class SBFunction;
     friend class SBInstruction;
     friend class SBInstructionList;
     friend class SBLineEntry;
+    friend class SBMemoryRegionInfo;
     friend class SBModule;
     friend class SBModuleSpec;
     friend class SBModuleSpecList;
     friend class SBProcess;
     friend class SBSection;
     friend class SBSourceManager;
     friend class SBSymbol;
     friend class SBSymbolContext;

include/lldb/Target/MemoryRegionInfo.h

 #ifndef lldb_MemoryRegionInfo_h
 #define lldb_MemoryRegionInfo_h
 
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Utility/Range.h"
 
 namespace lldb_private
 {
     class MemoryRegionInfo
     {
     public:
         typedef Range<lldb::addr_t, lldb::addr_t> RangeType;
         
         enum OptionalBool {
             eDontKnow  = -1,
             eNo         = 0,
             eYes        = 1
         };
public:
         void
         SetLLDBPermissions(uint32_t permissions)
         {
             m_read = (permissions & lldb::ePermissionsReadable) ? eYes : eNo;
             m_write = (permissions & lldb::ePermissionsWritable) ? eYes : eNo;
             m_execute = (permissions & lldb::ePermissionsExecutable) ? eYes : eNo;
         }
 
+        bool
+        operator == (const MemoryRegionInfo &rhs) const
+        {
+            return m_range == rhs.m_range &&
+                   m_read == rhs.m_read &&
+                   m_write == rhs.m_write &&
+                   m_execute == rhs.m_execute;
+        }
+        
+        bool
+        operator != (const MemoryRegionInfo &rhs) const
+        {
+            return !(*this == rhs);
+        }
+        
     protected:
         RangeType m_range;
         OptionalBool m_read;
         OptionalBool m_write;
         OptionalBool m_execute;
     };
 }
 
 #endif // #ifndef lldb_MemoryRegionInfo_h

include/lldb/Target/Process.h

GetMemoryRegionInfo (lldb::addr_t load_addr,
                          MemoryRegionInfo &range_info)
     {
         Error error;
         error.SetErrorString ("Process::GetMemoryRegionInfo() not supported");
         return error;
     }
 
     virtual Error
+    GetMemoryRegions (std::vector<lldb::MemoryRegionInfoSP>&)
+    {
+        Error error;
+        error.SetErrorString ("Process::GetMemoryRegions() not supported");
+        return error;
+    }
+
+    virtual Error
     GetWatchpointSupportInfo (uint32_t &num)
     {
         Error error;
         num = 0;
         error.SetErrorString ("Process::GetWatchpointSupportInfo() not supported");
         return error;
     }
 

include/lldb/lldb-forward.h

namespace lldb {
     typedef std::shared_ptr<lldb_private::LanguageRuntime> LanguageRuntimeSP;
     typedef std::shared_ptr<lldb_private::SystemRuntime> SystemRuntimeSP;
     typedef std::unique_ptr<lldb_private::SystemRuntime> SystemRuntimeUP;
     typedef std::shared_ptr<lldb_private::LineTable> LineTableSP;
     typedef std::shared_ptr<lldb_private::Listener> ListenerSP;
     typedef std::weak_ptr<lldb_private::Listener> ListenerWP;
     typedef std::shared_ptr<lldb_private::LogChannel> LogChannelSP;
     typedef std::shared_ptr<lldb_private::MemoryHistory> MemoryHistorySP;
+    typedef std::shared_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoSP;
+    typedef std::unique_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoUP;
     typedef std::shared_ptr<lldb_private::Module> ModuleSP;
     typedef std::weak_ptr<lldb_private::Module> ModuleWP;
     typedef std::shared_ptr<lldb_private::ObjectFile> ObjectFileSP;
     typedef std::weak_ptr<lldb_private::ObjectFile> ObjectFileWP;
     typedef std::shared_ptr<lldb_private::ObjectFileJITDelegate> ObjectFileJITDelegateSP;
     typedef std::weak_ptr<lldb_private::ObjectFileJITDelegate> ObjectFileJITDelegateWP;
     typedef std::unique_ptr<lldb_private::OperatingSystem> OperatingSystemUP;
     typedef std::shared_ptr<lldb_private::OptionValue> OptionValueSP;

source/API/CMakeLists.txt

add_lldb_library(liblldb SHARED
   SBFunction.cpp
   SBHostOS.cpp
   SBInstruction.cpp
   SBInstructionList.cpp
   SBLanguageRuntime.cpp
   SBLaunchInfo.cpp
   SBLineEntry.cpp
   SBListener.cpp
+  SBMemoryRegionInfo.cpp
+  SBMemoryRegionInfoList.cpp
   SBModule.cpp
   SBModuleSpec.cpp
   SBPlatform.cpp
   SBProcess.cpp
   SBQueue.cpp
   SBQueueItem.cpp
   SBSection.cpp
   SBSourceManager.cpp

source/API/SBMemoryRegionInfo.cpp

+//===-- SBMemoryRegionInfo.cpp ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBError.h"
+#include "lldb/API/SBMemoryRegionInfo.h"
+#include "lldb/API/SBStream.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Target/MemoryRegionInfo.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+
+SBMemoryRegionInfo::SBMemoryRegionInfo () :
+    m_opaque_ap (new MemoryRegionInfo())
+{
+}
+
+SBMemoryRegionInfo::SBMemoryRegionInfo (const MemoryRegionInfo *lldb_object_ptr) :
+    m_opaque_ap (new MemoryRegionInfo())
+{
+    if (lldb_object_ptr)
+        ref() = *lldb_object_ptr;
+}
+
+SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs) :
+    m_opaque_ap (new MemoryRegionInfo())
+{
+    ref() = rhs.ref();
+}
+
+const SBMemoryRegionInfo &
+SBMemoryRegionInfo::operator = (const SBMemoryRegionInfo &rhs)
+{
+    if (this != &rhs)
+    {
+        ref() = rhs.ref();
+    }
+    return *this;
+}
+
+SBMemoryRegionInfo::~SBMemoryRegionInfo ()
+{
+}
+
+void
+SBMemoryRegionInfo::Clear()
+{
+    m_opaque_ap->Clear();
+}
+
+bool
+SBMemoryRegionInfo::operator == (const SBMemoryRegionInfo &rhs) const
+{
+    return ref() == rhs.ref();
+}
+
+bool
+SBMemoryRegionInfo::operator != (const SBMemoryRegionInfo &rhs) const
+{
+    return ref() != rhs.ref();
+}
+
+MemoryRegionInfo &
+SBMemoryRegionInfo::ref()
+{
+    return *m_opaque_ap;
+}
+
+const MemoryRegionInfo &
+SBMemoryRegionInfo::ref() const
+{
+    return *m_opaque_ap;
+}
+
+lldb::addr_t
+SBMemoryRegionInfo::GetRegionBase () {
+    return m_opaque_ap->GetRange().GetRangeBase();
+}
+
+lldb::addr_t
+SBMemoryRegionInfo::GetRegionEnd () {
+    return m_opaque_ap->GetRange().GetRangeEnd();
+}
+
+bool
+SBMemoryRegionInfo::IsReadable () {
+    return m_opaque_ap->GetReadable() == MemoryRegionInfo::eYes;
+}
+
+bool
+SBMemoryRegionInfo::IsWritable () {
+    return m_opaque_ap->GetWritable() == MemoryRegionInfo::eYes;
+}
+
+bool
+SBMemoryRegionInfo::IsExecutable () {
+    return m_opaque_ap->GetExecutable() == 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/API/SBMemoryRegionInfoList.cpp

+//===-- SBMemoryRegionInfoList.cpp ------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/API/SBMemoryRegionInfo.h"
+#include "lldb/API/SBMemoryRegionInfoList.h"
+#include "lldb/API/SBStream.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Target/MemoryRegionInfo.h"
+
+#include <vector>
+
+using namespace lldb;
+using namespace lldb_private;
+
+class MemoryRegionInfoListImpl
+{
+public:
+    MemoryRegionInfoListImpl () :
+    m_regions()
+    {
+    }
+
+    MemoryRegionInfoListImpl (const MemoryRegionInfoListImpl& rhs) :
+    m_regions(rhs.m_regions)
+    {
+    }
+
+    MemoryRegionInfoListImpl&
+    operator = (const MemoryRegionInfoListImpl& rhs)
+    {
+        if (this == &rhs)
+            return *this;
+        m_regions = rhs.m_regions;
+        return *this;
+    }
+
+    uint32_t
+    GetSize ()
+    {
+        return m_regions.size();
+    }
+
+    void
+    Append (const lldb::SBMemoryRegionInfo& sb_region)
+    {
+        m_regions.push_back(sb_region);
+    }
+
+    void
+    Append (const MemoryRegionInfoListImpl& list)
+    {
+        for (auto val : list.m_regions)
+            Append (val);
+    }
+
+    void
+    Clear ()
+    {
+        m_regions.clear();
+    }
+
+    bool
+    GetMemoryRegionInfoAtIndex (uint32_t index, SBMemoryRegionInfo &region_info)
+    {
+        if (index >= GetSize())
+            return false;
+        region_info = m_regions[index];
+        return true;
+    }
+
+private:
+    std::vector<lldb::SBMemoryRegionInfo> m_regions;
+};
+
+SBMemoryRegionInfoList::SBMemoryRegionInfoList () :
+    m_opaque_ap (new MemoryRegionInfoListImpl())
+{
+}
+
+SBMemoryRegionInfoList::SBMemoryRegionInfoList (const SBMemoryRegionInfoList& rhs) :
+    m_opaque_ap (new MemoryRegionInfoListImpl(*rhs.m_opaque_ap))
+{
+}
+
+SBMemoryRegionInfoList::~SBMemoryRegionInfoList ()
+{
+}
+
+const SBMemoryRegionInfoList &
+SBMemoryRegionInfoList::operator = (const SBMemoryRegionInfoList &rhs)
+{
+    if (this != &rhs)
+    {
+        *m_opaque_ap = *rhs.m_opaque_ap;
+    }
+    return *this;
+}
+
+uint32_t
+SBMemoryRegionInfoList::GetSize() const
+{
+    return m_opaque_ap->GetSize();
+}
+
+
+bool
+SBMemoryRegionInfoList::GetMemoryRegionAtIndex (uint32_t idx, SBMemoryRegionInfo &region_info)
+{
+    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+
+    bool result = m_opaque_ap->GetMemoryRegionInfoAtIndex(idx, region_info);
+
+    if (log)
+    {
+        SBStream sstr;
+        region_info.GetDescription (sstr);
+        log->Printf ("SBMemoryRegionInfoList::GetMemoryRegionAtIndex (this.ap=%p, idx=%d) => SBMemoryRegionInfo (this.ap=%p, '%s')",
+                     static_cast<void*>(m_opaque_ap.get()), idx,
+                     static_cast<void*>(region_info.m_opaque_ap.get()), sstr.GetData());
+    }
+
+    return result;
+}
+
+void
+SBMemoryRegionInfoList::Clear()
+{
+
+    m_opaque_ap->Clear();
+}
+
+void
+SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region)
+{
+    m_opaque_ap->Append(sb_region);
+}
+
+void
+SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list)
+{
+    m_opaque_ap->Append(*sb_region_list);
+}
+
+const MemoryRegionInfoListImpl *
+SBMemoryRegionInfoList::operator->() const
+{
+    return m_opaque_ap.get();
+}
+
+const MemoryRegionInfoListImpl&
+SBMemoryRegionInfoList::operator*() const
+{
+    assert (m_opaque_ap.get());
+    return *m_opaque_ap.get();
+}
+

source/API/SBProcess.cpp

 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
 // Project includes
 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFileSpec.h"
+#include "lldb/API/SBMemoryRegionInfo.h"
+#include "lldb/API/SBMemoryRegionInfoList.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/API/SBThreadCollection.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBUnixSignals.h"
 
 using namespace lldb;
 using namespace lldb_private;
if (process_sp->GetState() != eStateStopped)
         error.SetErrorString("the process is not stopped");
         return error;
     }
 
     FileSpec core_file(file_name, false);
     error.ref() = PluginManager::SaveCore(process_sp, core_file);
     return error;
 }
+
+lldb::SBError
+SBProcess::GetMemoryRegionInfo (lldb::addr_t load_addr, SBMemoryRegionInfo &sb_region_info)
+{
+    lldb::SBError sb_error;
+    ProcessSP process_sp(GetSP());
+    MemoryRegionInfoSP region_info_sp = std::make_shared<lldb_private::MemoryRegionInfo>();
+    if (process_sp)
+    {
+        Process::StopLocker stop_locker;
+        if (stop_locker.TryLock(&process_sp->GetRunLock()))
+        {
+            std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
+            sb_error.ref() = process_sp->GetMemoryRegionInfo(load_addr, *region_info_sp);
+            if( sb_error.Success() ) {
+                sb_region_info.ref() = *region_info_sp;
+            }
+        }
+        else
+        {
+            Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+            if (log)
+                log->Printf ("SBProcess(%p)::GetMemoryRegionInfo() => error: process is running",
+                             static_cast<void*>(process_sp.get()));
+            sb_error.SetErrorString("process is running");
+        }
+    }
+    else
+    {
+        sb_error.SetErrorString ("SBProcess is invalid");
+    }
+    return sb_error;
+}
+
+lldb::SBMemoryRegionInfoList
+SBProcess::GetMemoryRegions()
+{
+    lldb::SBError sb_error;
+    lldb::SBMemoryRegionInfoList sb_region_list;
+    ProcessSP process_sp(GetSP());
+    if (process_sp)
+    {
+        Process::StopLocker stop_locker;
+        if (stop_locker.TryLock(&process_sp->GetRunLock()))
+        {
+            std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
+            std::vector<MemoryRegionInfoSP> region_list;
+            sb_error.ref() = process_sp->GetMemoryRegions(region_list);
+            if( sb_error.Success() ) {
+                std::vector<MemoryRegionInfoSP>::iterator end = region_list.end();
+                for( std::vector<MemoryRegionInfoSP>::iterator it = region_list.begin(); it != end; it++ ) {
+                    SBMemoryRegionInfo sb_region_info(it->get());
+                    sb_region_list.Append(sb_region_info);
+                }
+            }
+        }
+        else
+        {
+            Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+            if (log)
+                log->Printf ("SBProcess(%p)::GetMemoryRegionInfo() => error: process is running",
+                             static_cast<void*>(process_sp.get()));
+            sb_error.SetErrorString("process is running");
+        }
+    }
+    else
+    {
+        sb_error.SetErrorString ("SBProcess is invalid");
+    }
+    return sb_region_list;
+}