replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Replace MemoryRegionInfoSP with values and cleanup related code 

Differential Revision: https://reviews.llvm.org/D55472

llvm-svn: 349766
This commit is contained in:
Tatyana Krasnukha 2018-12-20 15:02:58 +00:00
parent b208255fe0
commit 36788bbb32
8 changed files with 61 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lldb/include/lldb/API/SBMemoryRegionInfo.h
View File

@ -102,6 +102,7 @@ private:
const lldb_private::MemoryRegionInfo &ref() const;
// Unused.
SBMemoryRegionInfo(const lldb_private::MemoryRegionInfo *lldb_object_ptr);
lldb::MemoryRegionInfoUP m_opaque_ap;

6
lldb/include/lldb/API/SBMemoryRegionInfoList.h
View File

@ -42,6 +42,12 @@ protected:
const MemoryRegionInfoListImpl &operator*() const;
private:
friend class SBProcess;
lldb_private::MemoryRegionInfos &ref();
const lldb_private::MemoryRegionInfos &ref() const;
std::unique_ptr<MemoryRegionInfoListImpl> m_opaque_ap;
};

6
lldb/include/lldb/Target/MemoryRegionInfo.h
View File

@ -123,6 +123,12 @@ inline bool operator<(lldb::addr_t lhs, const MemoryRegionInfo &rhs) {
return lhs < rhs.GetRange().GetRangeBase();
}
// Forward-declarable wrapper.
class MemoryRegionInfos : public std::vector<lldb_private::MemoryRegionInfo> {
public:
using std::vector<lldb_private::MemoryRegionInfo>::vector;
};
}
namespace llvm {

2
lldb/include/lldb/Target/Process.h
View File

@ -2081,7 +2081,7 @@ public:
/// An error value.
//------------------------------------------------------------------
virtual Status
GetMemoryRegions(std::vector<lldb::MemoryRegionInfoSP> &region_list);
GetMemoryRegions(lldb_private::MemoryRegionInfos &region_list);
virtual Status GetWatchpointSupportInfo(uint32_t &num) {
Status error;

4
lldb/include/lldb/lldb-forward.h
View File

@ -125,13 +125,14 @@ class JITLoaderList;
class Language;
class LanguageCategory;
class LanguageRuntime;
class MemoryRegionInfo;
class LineTable;
class Listener;
class Log;
class Mangled;
class Materializer;
class MemoryHistory;
class MemoryRegionInfo;
class MemoryRegionInfos;
class Module;
class ModuleList;
class ModuleSpec;
@ -369,7 +370,6 @@ 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::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;

32
lldb/source/API/SBMemoryRegionInfoList.cpp
View File

@ -32,31 +32,47 @@ public:
return *this;
}
uint32_t GetSize() { return m_regions.size(); }
size_t GetSize() const { return m_regions.size(); }
void Append(const lldb::SBMemoryRegionInfo &sb_region) {
void Reserve(size_t capacity) { return m_regions.reserve(capacity); }
void Append(const MemoryRegionInfo &sb_region) {
m_regions.push_back(sb_region);
}
void Append(const MemoryRegionInfoListImpl &list) {
for (auto val : list.m_regions)
Reserve(GetSize() + list.GetSize());
for (const auto &val : list.m_regions)
Append(val);
}
void Clear() { m_regions.clear(); }
bool GetMemoryRegionInfoAtIndex(uint32_t index,
SBMemoryRegionInfo &region_info) {
bool GetMemoryRegionInfoAtIndex(size_t index,
MemoryRegionInfo &region_info) {
if (index >= GetSize())
return false;
region_info = m_regions[index];
return true;
}
MemoryRegionInfos &Ref() { return m_regions; }
const MemoryRegionInfos &Ref() const { return m_regions; }
private:
std::vector<lldb::SBMemoryRegionInfo> m_regions;
MemoryRegionInfos m_regions;
};
MemoryRegionInfos &SBMemoryRegionInfoList::ref() {
return m_opaque_ap->Ref();
}
const MemoryRegionInfos &SBMemoryRegionInfoList::ref() const {
return m_opaque_ap->Ref();
}
SBMemoryRegionInfoList::SBMemoryRegionInfoList()
: m_opaque_ap(new MemoryRegionInfoListImpl()) {}
@ -82,7 +98,7 @@ bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
uint32_t idx, SBMemoryRegionInfo &region_info) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool result = m_opaque_ap->GetMemoryRegionInfoAtIndex(idx, region_info);
bool result = m_opaque_ap->GetMemoryRegionInfoAtIndex(idx, region_info.ref());
if (log) {
SBStream sstr;
@ -100,7 +116,7 @@ bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
void SBMemoryRegionInfoList::Clear() { m_opaque_ap->Clear(); }
void SBMemoryRegionInfoList::Append(SBMemoryRegionInfo &sb_region) {
m_opaque_ap->Append(sb_region);
m_opaque_ap->Append(sb_region.ref());
}
void SBMemoryRegionInfoList::Append(SBMemoryRegionInfoList &sb_region_list) {

46
lldb/source/API/SBProcess.cpp
View File

@ -1358,18 +1358,14 @@ 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;
}
process_sp->GetMemoryRegionInfo(load_addr, sb_region_info.ref());
} else {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
@ -1385,35 +1381,23 @@ SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
}
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");
}
Process::StopLocker stop_locker;
if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) {
std::lock_guard<std::recursive_mutex> guard(
process_sp->GetTarget().GetAPIMutex());
process_sp->GetMemoryRegions(sb_region_list.ref());
} else {
sb_error.SetErrorString("SBProcess is invalid");
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()));
}
return sb_region_list;
}

12
lldb/source/Target/Process.cpp
View File

@ -6035,7 +6035,7 @@ Process::AdvanceAddressToNextBranchInstruction(Address default_stop_addr,
}
Status
Process::GetMemoryRegions(std::vector<lldb::MemoryRegionInfoSP> &region_list) {
Process::GetMemoryRegions(lldb_private::MemoryRegionInfos &region_list) {
Status error;
@ -6043,17 +6043,17 @@ Process::GetMemoryRegions(std::vector<lldb::MemoryRegionInfoSP> &region_list) {
region_list.clear();
do {
lldb::MemoryRegionInfoSP region_info(new lldb_private::MemoryRegionInfo());
error = GetMemoryRegionInfo(range_end, *region_info);
lldb_private::MemoryRegionInfo region_info;
error = GetMemoryRegionInfo(range_end, region_info);
// GetMemoryRegionInfo should only return an error if it is unimplemented.
if (error.Fail()) {
region_list.clear();
break;
}
range_end = region_info->GetRange().GetRangeEnd();
if (region_info->GetMapped() == MemoryRegionInfo::eYes) {
region_list.push_back(region_info);
range_end = region_info.GetRange().GetRangeEnd();
if (region_info.GetMapped() == MemoryRegionInfo::eYes) {
region_list.push_back(std::move(region_info));
}
} while (range_end != LLDB_INVALID_ADDRESS);