summaryrefslogtreecommitdiffstats
path: root/lldb/source/Expression/IRMemoryMap.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'lldb/source/Expression/IRMemoryMap.cpp')
-rw-r--r--lldb/source/Expression/IRMemoryMap.cpp1432
1 files changed, 681 insertions, 751 deletions
diff --git a/lldb/source/Expression/IRMemoryMap.cpp b/lldb/source/Expression/IRMemoryMap.cpp
index aa165722c43..008838d5aab 100644
--- a/lldb/source/Expression/IRMemoryMap.cpp
+++ b/lldb/source/Expression/IRMemoryMap.cpp
@@ -7,12 +7,12 @@
//
//===----------------------------------------------------------------------===//
+#include "lldb/Expression/IRMemoryMap.h"
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/Scalar.h"
-#include "lldb/Expression/IRMemoryMap.h"
#include "lldb/Target/MemoryRegionInfo.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
@@ -20,223 +20,204 @@
using namespace lldb_private;
-IRMemoryMap::IRMemoryMap (lldb::TargetSP target_sp) :
- m_target_wp(target_sp)
-{
- if (target_sp)
- m_process_wp = target_sp->GetProcessSP();
+IRMemoryMap::IRMemoryMap(lldb::TargetSP target_sp) : m_target_wp(target_sp) {
+ if (target_sp)
+ m_process_wp = target_sp->GetProcessSP();
}
-IRMemoryMap::~IRMemoryMap ()
-{
- lldb::ProcessSP process_sp = m_process_wp.lock();
+IRMemoryMap::~IRMemoryMap() {
+ lldb::ProcessSP process_sp = m_process_wp.lock();
- if (process_sp)
- {
- AllocationMap::iterator iter;
-
- Error err;
-
- while ((iter = m_allocations.begin()) != m_allocations.end())
- {
- err.Clear();
- if (iter->second.m_leak)
- m_allocations.erase(iter);
- else
- Free(iter->first, err);
- }
- }
-}
+ if (process_sp) {
+ AllocationMap::iterator iter;
-lldb::addr_t
-IRMemoryMap::FindSpace (size_t size)
-{
- // The FindSpace algorithm's job is to find a region of memory that the
- // underlying process is unlikely to be using.
- //
- // The memory returned by this function will never be written to. The only
- // point is that it should not shadow process memory if possible, so that
- // expressions processing real values from the process do not use the
- // wrong data.
- //
- // If the process can in fact allocate memory (CanJIT() lets us know this)
- // then this can be accomplished just be allocating memory in the inferior.
- // Then no guessing is required.
+ Error err;
- lldb::TargetSP target_sp = m_target_wp.lock();
- lldb::ProcessSP process_sp = m_process_wp.lock();
-
- const bool process_is_alive = process_sp && process_sp->IsAlive();
+ while ((iter = m_allocations.begin()) != m_allocations.end()) {
+ err.Clear();
+ if (iter->second.m_leak)
+ m_allocations.erase(iter);
+ else
+ Free(iter->first, err);
+ }
+ }
+}
- lldb::addr_t ret = LLDB_INVALID_ADDRESS;
- if (size == 0)
- return ret;
+lldb::addr_t IRMemoryMap::FindSpace(size_t size) {
+ // The FindSpace algorithm's job is to find a region of memory that the
+ // underlying process is unlikely to be using.
+ //
+ // The memory returned by this function will never be written to. The only
+ // point is that it should not shadow process memory if possible, so that
+ // expressions processing real values from the process do not use the
+ // wrong data.
+ //
+ // If the process can in fact allocate memory (CanJIT() lets us know this)
+ // then this can be accomplished just be allocating memory in the inferior.
+ // Then no guessing is required.
+
+ lldb::TargetSP target_sp = m_target_wp.lock();
+ lldb::ProcessSP process_sp = m_process_wp.lock();
+
+ const bool process_is_alive = process_sp && process_sp->IsAlive();
+
+ lldb::addr_t ret = LLDB_INVALID_ADDRESS;
+ if (size == 0)
+ return ret;
- if (process_is_alive && process_sp->CanJIT())
- {
- Error alloc_error;
+ if (process_is_alive && process_sp->CanJIT()) {
+ Error alloc_error;
- ret = process_sp->AllocateMemory(size, lldb::ePermissionsReadable | lldb::ePermissionsWritable, alloc_error);
+ ret = process_sp->AllocateMemory(size, lldb::ePermissionsReadable |
+ lldb::ePermissionsWritable,
+ alloc_error);
- if (!alloc_error.Success())
- return LLDB_INVALID_ADDRESS;
- else
- return ret;
- }
-
- // At this point we know that we need to hunt.
- //
- // First, go to the end of the existing allocations we've made if there are
- // any allocations. Otherwise start at the beginning of memory.
-
- if (m_allocations.empty())
- {
- ret = 0x0;
- }
+ if (!alloc_error.Success())
+ return LLDB_INVALID_ADDRESS;
else
- {
- auto back = m_allocations.rbegin();
- lldb::addr_t addr = back->first;
- size_t alloc_size = back->second.m_size;
- ret = llvm::alignTo(addr+alloc_size, 4096);
- }
-
- // Now, if it's possible to use the GetMemoryRegionInfo API to detect mapped
- // regions, walk forward through memory until a region is found that
- // has adequate space for our allocation.
- if (process_is_alive)
- {
- const uint64_t end_of_memory = process_sp->GetAddressByteSize() == 8 ?
- 0xffffffffffffffffull : 0xffffffffull;
-
- lldbassert(process_sp->GetAddressByteSize() == 4 || end_of_memory != 0xffffffffull);
-
- MemoryRegionInfo region_info;
- Error err = process_sp->GetMemoryRegionInfo(ret, region_info);
- if (err.Success())
- {
- while (true)
- {
- if (region_info.GetReadable() != MemoryRegionInfo::OptionalBool::eNo ||
- region_info.GetWritable() != MemoryRegionInfo::OptionalBool::eNo ||
- region_info.GetExecutable() != MemoryRegionInfo::OptionalBool::eNo)
- {
- if (region_info.GetRange().GetRangeEnd() - 1 >= end_of_memory)
- {
- ret = LLDB_INVALID_ADDRESS;
- break;
- }
- else
- {
- ret = region_info.GetRange().GetRangeEnd();
- }
- }
- else if (ret + size < region_info.GetRange().GetRangeEnd())
- {
- return ret;
- }
- else
- {
- // ret stays the same. We just need to walk a bit further.
- }
-
- err = process_sp->GetMemoryRegionInfo(region_info.GetRange().GetRangeEnd(), region_info);
- if (err.Fail())
- {
- lldbassert(!"GetMemoryRegionInfo() succeeded, then failed");
- ret = LLDB_INVALID_ADDRESS;
- break;
- }
- }
+ return ret;
+ }
+
+ // At this point we know that we need to hunt.
+ //
+ // First, go to the end of the existing allocations we've made if there are
+ // any allocations. Otherwise start at the beginning of memory.
+
+ if (m_allocations.empty()) {
+ ret = 0x0;
+ } else {
+ auto back = m_allocations.rbegin();
+ lldb::addr_t addr = back->first;
+ size_t alloc_size = back->second.m_size;
+ ret = llvm::alignTo(addr + alloc_size, 4096);
+ }
+
+ // Now, if it's possible to use the GetMemoryRegionInfo API to detect mapped
+ // regions, walk forward through memory until a region is found that
+ // has adequate space for our allocation.
+ if (process_is_alive) {
+ const uint64_t end_of_memory = process_sp->GetAddressByteSize() == 8
+ ? 0xffffffffffffffffull
+ : 0xffffffffull;
+
+ lldbassert(process_sp->GetAddressByteSize() == 4 ||
+ end_of_memory != 0xffffffffull);
+
+ MemoryRegionInfo region_info;
+ Error err = process_sp->GetMemoryRegionInfo(ret, region_info);
+ if (err.Success()) {
+ while (true) {
+ if (region_info.GetReadable() != MemoryRegionInfo::OptionalBool::eNo ||
+ region_info.GetWritable() != MemoryRegionInfo::OptionalBool::eNo ||
+ region_info.GetExecutable() !=
+ MemoryRegionInfo::OptionalBool::eNo) {
+ if (region_info.GetRange().GetRangeEnd() - 1 >= end_of_memory) {
+ ret = LLDB_INVALID_ADDRESS;
+ break;
+ } else {
+ ret = region_info.GetRange().GetRangeEnd();
+ }
+ } else if (ret + size < region_info.GetRange().GetRangeEnd()) {
+ return ret;
+ } else {
+ // ret stays the same. We just need to walk a bit further.
}
- }
-
- // We've tried our algorithm, and it didn't work. Now we have to reset back
- // to the end of the allocations we've already reported, or use a 'sensible'
- // default if this is our first allocation.
-
- if (m_allocations.empty())
- {
- uint32_t address_byte_size = GetAddressByteSize();
- if (address_byte_size != UINT32_MAX)
- {
- switch (address_byte_size)
- {
- case 8:
- ret = 0xffffffff00000000ull;
- break;
- case 4:
- ret = 0xee000000ull;
- break;
- default:
- break;
- }
+
+ err = process_sp->GetMemoryRegionInfo(
+ region_info.GetRange().GetRangeEnd(), region_info);
+ if (err.Fail()) {
+ lldbassert(!"GetMemoryRegionInfo() succeeded, then failed");
+ ret = LLDB_INVALID_ADDRESS;
+ break;
}
+ }
}
- else
- {
- auto back = m_allocations.rbegin();
- lldb::addr_t addr = back->first;
- size_t alloc_size = back->second.m_size;
- ret = llvm::alignTo(addr+alloc_size, 4096);
+ }
+
+ // We've tried our algorithm, and it didn't work. Now we have to reset back
+ // to the end of the allocations we've already reported, or use a 'sensible'
+ // default if this is our first allocation.
+
+ if (m_allocations.empty()) {
+ uint32_t address_byte_size = GetAddressByteSize();
+ if (address_byte_size != UINT32_MAX) {
+ switch (address_byte_size) {
+ case 8:
+ ret = 0xffffffff00000000ull;
+ break;
+ case 4:
+ ret = 0xee000000ull;
+ break;
+ default:
+ break;
+ }
}
+ } else {
+ auto back = m_allocations.rbegin();
+ lldb::addr_t addr = back->first;
+ size_t alloc_size = back->second.m_size;
+ ret = llvm::alignTo(addr + alloc_size, 4096);
+ }
- return ret;
+ return ret;
}
IRMemoryMap::AllocationMap::iterator
-IRMemoryMap::FindAllocation (lldb::addr_t addr, size_t size)
-{
- if (addr == LLDB_INVALID_ADDRESS)
- return m_allocations.end();
-
- AllocationMap::iterator iter = m_allocations.lower_bound (addr);
-
- if (iter == m_allocations.end() ||
- iter->first > addr)
- {
- if (iter == m_allocations.begin())
- return m_allocations.end();
- iter--;
- }
+IRMemoryMap::FindAllocation(lldb::addr_t addr, size_t size) {
+ if (addr == LLDB_INVALID_ADDRESS)
+ return m_allocations.end();
- if (iter->first <= addr && iter->first + iter->second.m_size >= addr + size)
- return iter;
+ AllocationMap::iterator iter = m_allocations.lower_bound(addr);
- return m_allocations.end();
-}
+ if (iter == m_allocations.end() || iter->first > addr) {
+ if (iter == m_allocations.begin())
+ return m_allocations.end();
+ iter--;
+ }
-bool
-IRMemoryMap::IntersectsAllocation (lldb::addr_t addr, size_t size) const
-{
- if (addr == LLDB_INVALID_ADDRESS)
- return false;
-
- AllocationMap::const_iterator iter = m_allocations.lower_bound (addr);
-
- // Since we only know that the returned interval begins at a location greater than or
- // equal to where the given interval begins, it's possible that the given interval
- // intersects either the returned interval or the previous interval. Thus, we need to
- // check both. Note that we only need to check these two intervals. Since all intervals
- // are disjoint it is not possible that an adjacent interval does not intersect, but a
- // non-adjacent interval does intersect.
- if (iter != m_allocations.end()) {
- if (AllocationsIntersect(addr, size, iter->second.m_process_start, iter->second.m_size))
- return true;
- }
+ if (iter->first <= addr && iter->first + iter->second.m_size >= addr + size)
+ return iter;
- if (iter != m_allocations.begin()) {
- --iter;
- if (AllocationsIntersect(addr, size, iter->second.m_process_start, iter->second.m_size))
- return true;
- }
+ return m_allocations.end();
+}
+bool IRMemoryMap::IntersectsAllocation(lldb::addr_t addr, size_t size) const {
+ if (addr == LLDB_INVALID_ADDRESS)
return false;
+
+ AllocationMap::const_iterator iter = m_allocations.lower_bound(addr);
+
+ // Since we only know that the returned interval begins at a location greater
+ // than or
+ // equal to where the given interval begins, it's possible that the given
+ // interval
+ // intersects either the returned interval or the previous interval. Thus, we
+ // need to
+ // check both. Note that we only need to check these two intervals. Since all
+ // intervals
+ // are disjoint it is not possible that an adjacent interval does not
+ // intersect, but a
+ // non-adjacent interval does intersect.
+ if (iter != m_allocations.end()) {
+ if (AllocationsIntersect(addr, size, iter->second.m_process_start,
+ iter->second.m_size))
+ return true;
+ }
+
+ if (iter != m_allocations.begin()) {
+ --iter;
+ if (AllocationsIntersect(addr, size, iter->second.m_process_start,
+ iter->second.m_size))
+ return true;
+ }
+
+ return false;
}
-bool
-IRMemoryMap::AllocationsIntersect(lldb::addr_t addr1, size_t size1, lldb::addr_t addr2, size_t size2) {
- // Given two half open intervals [A, B) and [X, Y), the only 6 permutations that satisfy
+bool IRMemoryMap::AllocationsIntersect(lldb::addr_t addr1, size_t size1,
+ lldb::addr_t addr2, size_t size2) {
+ // Given two half open intervals [A, B) and [X, Y), the only 6 permutations
+ // that satisfy
// A<B and X<Y are the following:
// A B X Y
// A X B Y (intersects)
@@ -249,666 +230,615 @@ IRMemoryMap::AllocationsIntersect(lldb::addr_t addr1, size_t size1, lldb::addr_t
return (addr2 < (addr1 + size1)) && (addr1 < (addr2 + size2));
}
-lldb::ByteOrder
-IRMemoryMap::GetByteOrder()
-{
- lldb::ProcessSP process_sp = m_process_wp.lock();
+lldb::ByteOrder IRMemoryMap::GetByteOrder() {
+ lldb::ProcessSP process_sp = m_process_wp.lock();
- if (process_sp)
- return process_sp->GetByteOrder();
+ if (process_sp)
+ return process_sp->GetByteOrder();
- lldb::TargetSP target_sp = m_target_wp.lock();
+ lldb::TargetSP target_sp = m_target_wp.lock();
- if (target_sp)
- return target_sp->GetArchitecture().GetByteOrder();
+ if (target_sp)
+ return target_sp->GetArchitecture().GetByteOrder();
- return lldb::eByteOrderInvalid;
+ return lldb::eByteOrderInvalid;
}
-uint32_t
-IRMemoryMap::GetAddressByteSize()
-{
- lldb::ProcessSP process_sp = m_process_wp.lock();
+uint32_t IRMemoryMap::GetAddressByteSize() {
+ lldb::ProcessSP process_sp = m_process_wp.lock();
- if (process_sp)
- return process_sp->GetAddressByteSize();
+ if (process_sp)
+ return process_sp->GetAddressByteSize();
- lldb::TargetSP target_sp = m_target_wp.lock();
+ lldb::TargetSP target_sp = m_target_wp.lock();
- if (target_sp)
- return target_sp->GetArchitecture().GetAddressByteSize();
+ if (target_sp)
+ return target_sp->GetArchitecture().GetAddressByteSize();
- return UINT32_MAX;
+ return UINT32_MAX;
}
-ExecutionContextScope *
-IRMemoryMap::GetBestExecutionContextScope() const
-{
- lldb::ProcessSP process_sp = m_process_wp.lock();
+ExecutionContextScope *IRMemoryMap::GetBestExecutionContextScope() const {
+ lldb::ProcessSP process_sp = m_process_wp.lock();
- if (process_sp)
- return process_sp.get();
+ if (process_sp)
+ return process_sp.get();
- lldb::TargetSP target_sp = m_target_wp.lock();
+ lldb::TargetSP target_sp = m_target_wp.lock();
- if (target_sp)
- return target_sp.get();
+ if (target_sp)
+ return target_sp.get();
- return NULL;
+ return NULL;
}
-IRMemoryMap::Allocation::Allocation (lldb::addr_t process_alloc,
- lldb::addr_t process_start,
- size_t size,
- uint32_t permissions,
- uint8_t alignment,
- AllocationPolicy policy) :
- m_process_alloc (process_alloc),
- m_process_start (process_start),
- m_size (size),
- m_permissions (permissions),
- m_alignment (alignment),
- m_policy (policy),
- m_leak (false)
-{
- switch (policy)
- {
- default:
- assert (0 && "We cannot reach this!");
- case eAllocationPolicyHostOnly:
- m_data.SetByteSize(size);
- memset(m_data.GetBytes(), 0, size);
- break;
- case eAllocationPolicyProcessOnly:
- break;
- case eAllocationPolicyMirror:
- m_data.SetByteSize(size);
- memset(m_data.GetBytes(), 0, size);
- break;
- }
+IRMemoryMap::Allocation::Allocation(lldb::addr_t process_alloc,
+ lldb::addr_t process_start, size_t size,
+ uint32_t permissions, uint8_t alignment,
+ AllocationPolicy policy)
+ : m_process_alloc(process_alloc), m_process_start(process_start),
+ m_size(size), m_permissions(permissions), m_alignment(alignment),
+ m_policy(policy), m_leak(false) {
+ switch (policy) {
+ default:
+ assert(0 && "We cannot reach this!");
+ case eAllocationPolicyHostOnly:
+ m_data.SetByteSize(size);
+ memset(m_data.GetBytes(), 0, size);
+ break;
+ case eAllocationPolicyProcessOnly:
+ break;
+ case eAllocationPolicyMirror:
+ m_data.SetByteSize(size);
+ memset(m_data.GetBytes(), 0, size);
+ break;
+ }
}
-lldb::addr_t
-IRMemoryMap::Malloc (size_t size, uint8_t alignment, uint32_t permissions, AllocationPolicy policy, bool zero_memory, Error &error)
-{
- lldb_private::Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
- error.Clear();
-
- lldb::ProcessSP process_sp;
- lldb::addr_t allocation_address = LLDB_INVALID_ADDRESS;
- lldb::addr_t aligned_address = LLDB_INVALID_ADDRESS;
-
- size_t alignment_mask = alignment - 1;
- size_t allocation_size;
-
- if (size == 0)
- allocation_size = alignment;
- else
- allocation_size = (size & alignment_mask) ? ((size + alignment) & (~alignment_mask)) : size;
-
- switch (policy)
- {
- default:
+lldb::addr_t IRMemoryMap::Malloc(size_t size, uint8_t alignment,
+ uint32_t permissions, AllocationPolicy policy,
+ bool zero_memory, Error &error) {
+ lldb_private::Log *log(
+ lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+ error.Clear();
+
+ lldb::ProcessSP process_sp;
+ lldb::addr_t allocation_address = LLDB_INVALID_ADDRESS;
+ lldb::addr_t aligned_address = LLDB_INVALID_ADDRESS;
+
+ size_t alignment_mask = alignment - 1;
+ size_t allocation_size;
+
+ if (size == 0)
+ allocation_size = alignment;
+ else
+ allocation_size = (size & alignment_mask)
+ ? ((size + alignment) & (~alignment_mask))
+ : size;
+
+ switch (policy) {
+ default:
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't malloc: invalid allocation policy");
+ return LLDB_INVALID_ADDRESS;
+ case eAllocationPolicyHostOnly:
+ allocation_address = FindSpace(allocation_size);
+ if (allocation_address == LLDB_INVALID_ADDRESS) {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't malloc: address space is full");
+ return LLDB_INVALID_ADDRESS;
+ }
+ break;
+ case eAllocationPolicyMirror:
+ process_sp = m_process_wp.lock();
+ if (log)
+ log->Printf("IRMemoryMap::%s process_sp=0x%" PRIx64
+ ", process_sp->CanJIT()=%s, process_sp->IsAlive()=%s",
+ __FUNCTION__, (lldb::addr_t)process_sp.get(),
+ process_sp && process_sp->CanJIT() ? "true" : "false",
+ process_sp && process_sp->IsAlive() ? "true" : "false");
+ if (process_sp && process_sp->CanJIT() && process_sp->IsAlive()) {
+ if (!zero_memory)
+ allocation_address =
+ process_sp->AllocateMemory(allocation_size, permissions, error);
+ else
+ allocation_address =
+ process_sp->CallocateMemory(allocation_size, permissions, error);
+
+ if (!error.Success())
+ return LLDB_INVALID_ADDRESS;
+ } else {
+ if (log)
+ log->Printf("IRMemoryMap::%s switching to eAllocationPolicyHostOnly "
+ "due to failed condition (see previous expr log message)",
+ __FUNCTION__);
+ policy = eAllocationPolicyHostOnly;
+ allocation_address = FindSpace(allocation_size);
+ if (allocation_address == LLDB_INVALID_ADDRESS) {
error.SetErrorToGenericError();
- error.SetErrorString("Couldn't malloc: invalid allocation policy");
+ error.SetErrorString("Couldn't malloc: address space is full");
return LLDB_INVALID_ADDRESS;
- case eAllocationPolicyHostOnly:
- allocation_address = FindSpace(allocation_size);
- if (allocation_address == LLDB_INVALID_ADDRESS)
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't malloc: address space is full");
- return LLDB_INVALID_ADDRESS;
- }
- break;
- case eAllocationPolicyMirror:
- process_sp = m_process_wp.lock();
- if (log)
- log->Printf ("IRMemoryMap::%s process_sp=0x%" PRIx64 ", process_sp->CanJIT()=%s, process_sp->IsAlive()=%s", __FUNCTION__, (lldb::addr_t) process_sp.get (), process_sp && process_sp->CanJIT () ? "true" : "false", process_sp && process_sp->IsAlive () ? "true" : "false");
- if (process_sp && process_sp->CanJIT() && process_sp->IsAlive())
- {
- if (!zero_memory)
- allocation_address = process_sp->AllocateMemory(allocation_size, permissions, error);
- else
- allocation_address = process_sp->CallocateMemory(allocation_size, permissions, error);
-
- if (!error.Success())
- return LLDB_INVALID_ADDRESS;
- }
- else
- {
- if (log)
- log->Printf ("IRMemoryMap::%s switching to eAllocationPolicyHostOnly due to failed condition (see previous expr log message)", __FUNCTION__);
- policy = eAllocationPolicyHostOnly;
- allocation_address = FindSpace(allocation_size);
- if (allocation_address == LLDB_INVALID_ADDRESS)
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't malloc: address space is full");
- return LLDB_INVALID_ADDRESS;
- }
- }
- break;
- case eAllocationPolicyProcessOnly:
- process_sp = m_process_wp.lock();
- if (process_sp)
- {
- if (process_sp->CanJIT() && process_sp->IsAlive())
- {
- if (!zero_memory)
- allocation_address = process_sp->AllocateMemory(allocation_size, permissions, error);
- else
- allocation_address = process_sp->CallocateMemory(allocation_size, permissions, error);
-
- if (!error.Success())
- return LLDB_INVALID_ADDRESS;
- }
- else
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't malloc: process doesn't support allocating memory");
- return LLDB_INVALID_ADDRESS;
- }
- }
+ }
+ }
+ break;
+ case eAllocationPolicyProcessOnly:
+ process_sp = m_process_wp.lock();
+ if (process_sp) {
+ if (process_sp->CanJIT() && process_sp->IsAlive()) {
+ if (!zero_memory)
+ allocation_address =
+ process_sp->AllocateMemory(allocation_size, permissions, error);
else
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't malloc: process doesn't exist, and this memory must be in the process");
- return LLDB_INVALID_ADDRESS;
- }
- break;
- }
+ allocation_address =
+ process_sp->CallocateMemory(allocation_size, permissions, error);
+ if (!error.Success())
+ return LLDB_INVALID_ADDRESS;
+ } else {
+ error.SetErrorToGenericError();
+ error.SetErrorString(
+ "Couldn't malloc: process doesn't support allocating memory");
+ return LLDB_INVALID_ADDRESS;
+ }
+ } else {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't malloc: process doesn't exist, and this "
+ "memory must be in the process");
+ return LLDB_INVALID_ADDRESS;
+ }
+ break;
+ }
- lldb::addr_t mask = alignment - 1;
- aligned_address = (allocation_address + mask) & (~mask);
+ lldb::addr_t mask = alignment - 1;
+ aligned_address = (allocation_address + mask) & (~mask);
- m_allocations[aligned_address] = Allocation(allocation_address,
- aligned_address,
- allocation_size,
- permissions,
- alignment,
- policy);
+ m_allocations[aligned_address] =
+ Allocation(allocation_address, aligned_address, allocation_size,
+ permissions, alignment, policy);
- if (zero_memory)
- {
- Error write_error;
- std::vector<uint8_t> zero_buf(size, 0);
- WriteMemory(aligned_address, zero_buf.data(), size, write_error);
- }
+ if (zero_memory) {
+ Error write_error;
+ std::vector<uint8_t> zero_buf(size, 0);
+ WriteMemory(aligned_address, zero_buf.data(), size, write_error);
+ }
- if (log)
- {
- const char * policy_string;
+ if (log) {
+ const char *policy_string;
- switch (policy)
- {
- default:
- policy_string = "<invalid policy>";
- break;
- case eAllocationPolicyHostOnly:
- policy_string = "eAllocationPolicyHostOnly";
- break;
- case eAllocationPolicyProcessOnly:
- policy_string = "eAllocationPolicyProcessOnly";
- break;
- case eAllocationPolicyMirror:
- policy_string = "eAllocationPolicyMirror";
- break;
- }
-
- log->Printf("IRMemoryMap::Malloc (%" PRIu64 ", 0x%" PRIx64 ", 0x%" PRIx64 ", %s) -> 0x%" PRIx64,
- (uint64_t)allocation_size,
- (uint64_t)alignment,
- (uint64_t)permissions,
- policy_string,
- aligned_address);
+ switch (policy) {
+ default:
+ policy_string = "<invalid policy>";
+ break;
+ case eAllocationPolicyHostOnly:
+ policy_string = "eAllocationPolicyHostOnly";
+ break;
+ case eAllocationPolicyProcessOnly:
+ policy_string = "eAllocationPolicyProcessOnly";
+ break;
+ case eAllocationPolicyMirror:
+ policy_string = "eAllocationPolicyMirror";
+ break;
}
- return aligned_address;
+ log->Printf("IRMemoryMap::Malloc (%" PRIu64 ", 0x%" PRIx64 ", 0x%" PRIx64
+ ", %s) -> 0x%" PRIx64,
+ (uint64_t)allocation_size, (uint64_t)alignment,
+ (uint64_t)permissions, policy_string, aligned_address);
+ }
+
+ return aligned_address;
}
-void
-IRMemoryMap::Leak (lldb::addr_t process_address, Error &error)
-{
- error.Clear();
+void IRMemoryMap::Leak(lldb::addr_t process_address, Error &error) {
+ error.Clear();
- AllocationMap::iterator iter = m_allocations.find(process_address);
+ AllocationMap::iterator iter = m_allocations.find(process_address);
- if (iter == m_allocations.end())
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't leak: allocation doesn't exist");
- return;
- }
+ if (iter == m_allocations.end()) {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't leak: allocation doesn't exist");
+ return;
+ }
- Allocation &allocation = iter->second;
+ Allocation &allocation = iter->second;
- allocation.m_leak = true;
+ allocation.m_leak = true;
}
-void
-IRMemoryMap::Free (lldb::addr_t process_address, Error &error)
-{
- error.Clear();
+void IRMemoryMap::Free(lldb::addr_t process_address, Error &error) {
+ error.Clear();
- AllocationMap::iterator iter = m_allocations.find(process_address);
+ AllocationMap::iterator iter = m_allocations.find(process_address);
- if (iter == m_allocations.end())
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't free: allocation doesn't exist");
- return;
- }
-
- Allocation &allocation = iter->second;
+ if (iter == m_allocations.end()) {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't free: allocation doesn't exist");
+ return;
+ }
- switch (allocation.m_policy)
- {
- default:
- case eAllocationPolicyHostOnly:
- {
- lldb::ProcessSP process_sp = m_process_wp.lock();
- if (process_sp)
- {
- if (process_sp->CanJIT() && process_sp->IsAlive())
- process_sp->DeallocateMemory(allocation.m_process_alloc); // FindSpace allocated this for real
- }
+ Allocation &allocation = iter->second;
- break;
- }
- case eAllocationPolicyMirror:
- case eAllocationPolicyProcessOnly:
- {
- lldb::ProcessSP process_sp = m_process_wp.lock();
- if (process_sp)
- process_sp->DeallocateMemory(allocation.m_process_alloc);
- }
- }
-
- if (lldb_private::Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
- {
- log->Printf("IRMemoryMap::Free (0x%" PRIx64 ") freed [0x%" PRIx64 "..0x%" PRIx64 ")",
- (uint64_t)process_address,
- iter->second.m_process_start,
- iter->second.m_process_start + iter->second.m_size);
+ switch (allocation.m_policy) {
+ default:
+ case eAllocationPolicyHostOnly: {
+ lldb::ProcessSP process_sp = m_process_wp.lock();
+ if (process_sp) {
+ if (process_sp->CanJIT() && process_sp->IsAlive())
+ process_sp->DeallocateMemory(
+ allocation.m_process_alloc); // FindSpace allocated this for real
}
- m_allocations.erase(iter);
+ break;
+ }
+ case eAllocationPolicyMirror:
+ case eAllocationPolicyProcessOnly: {
+ lldb::ProcessSP process_sp = m_process_wp.lock();
+ if (process_sp)
+ process_sp->DeallocateMemory(allocation.m_process_alloc);
+ }
+ }
+
+ if (lldb_private::Log *log =
+ lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
+ log->Printf("IRMemoryMap::Free (0x%" PRIx64 ") freed [0x%" PRIx64
+ "..0x%" PRIx64 ")",
+ (uint64_t)process_address, iter->second.m_process_start,
+ iter->second.m_process_start + iter->second.m_size);
+ }
+
+ m_allocations.erase(iter);
}
-bool
-IRMemoryMap::GetAllocSize(lldb::addr_t address, size_t &size)
-{
- AllocationMap::iterator iter = FindAllocation(address, size);
- if (iter == m_allocations.end())
- return false;
-
- Allocation &al = iter->second;
+bool IRMemoryMap::GetAllocSize(lldb::addr_t address, size_t &size) {
+ AllocationMap::iterator iter = FindAllocation(address, size);
+ if (iter == m_allocations.end())
+ return false;
- if (address > (al.m_process_start + al.m_size))
- {
- size = 0;
- return false;
- }
+ Allocation &al = iter->second;
- if (address > al.m_process_start)
- {
- int dif = address - al.m_process_start;
- size = al.m_size - dif;
- return true;
- }
+ if (address > (al.m_process_start + al.m_size)) {
+ size = 0;
+ return false;
+ }
- size = al.m_size;
+ if (address > al.m_process_start) {
+ int dif = address - al.m_process_start;
+ size = al.m_size - dif;
return true;
-}
+ }
-void
-IRMemoryMap::WriteMemory (lldb::addr_t process_address, const uint8_t *bytes, size_t size, Error &error)
-{
- error.Clear();
+ size = al.m_size;
+ return true;
+}
- AllocationMap::iterator iter = FindAllocation(process_address, size);
+void IRMemoryMap::WriteMemory(lldb::addr_t process_address,
+ const uint8_t *bytes, size_t size, Error &error) {
+ error.Clear();
- if (iter == m_allocations.end())
- {
- lldb::ProcessSP process_sp = m_process_wp.lock();
+ AllocationMap::iterator iter = FindAllocation(process_address, size);
- if (process_sp)
- {
- process_sp->WriteMemory(process_address, bytes, size, error);
- return;
- }
+ if (iter == m_allocations.end()) {
+ lldb::ProcessSP process_sp = m_process_wp.lock();
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't write: no allocation contains the target range and the process doesn't exist");
- return;
+ if (process_sp) {
+ process_sp->WriteMemory(process_address, bytes, size, error);
+ return;
}
- Allocation &allocation = iter->second;
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't write: no allocation contains the target "
+ "range and the process doesn't exist");
+ return;
+ }
- uint64_t offset = process_address - allocation.m_process_start;
+ Allocation &allocation = iter->second;
- lldb::ProcessSP process_sp;
+ uint64_t offset = process_address - allocation.m_process_start;
- switch (allocation.m_policy)
- {
- default:
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't write: invalid allocation policy");
+ lldb::ProcessSP process_sp;
+
+ switch (allocation.m_policy) {
+ default:
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't write: invalid allocation policy");
+ return;
+ case eAllocationPolicyHostOnly:
+ if (!allocation.m_data.GetByteSize()) {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't write: data buffer is empty");
+ return;
+ }
+ ::memcpy(allocation.m_data.GetBytes() + offset, bytes, size);
+ break;
+ case eAllocationPolicyMirror:
+ if (!allocation.m_data.GetByteSize()) {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't write: data buffer is empty");
+ return;
+ }
+ ::memcpy(allocation.m_data.GetBytes() + offset, bytes, size);
+ process_sp = m_process_wp.lock();
+ if (process_sp) {
+ process_sp->WriteMemory(process_address, bytes, size, error);
+ if (!error.Success())
return;
- case eAllocationPolicyHostOnly:
- if (!allocation.m_data.GetByteSize())
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't write: data buffer is empty");
- return;
- }
- ::memcpy (allocation.m_data.GetBytes() + offset, bytes, size);
- break;
- case eAllocationPolicyMirror:
- if (!allocation.m_data.GetByteSize())
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't write: data buffer is empty");
- return;
- }
- ::memcpy (allocation.m_data.GetBytes() + offset, bytes, size);
- process_sp = m_process_wp.lock();
- if (process_sp)
- {
- process_sp->WriteMemory(process_address, bytes, size, error);
- if (!error.Success())
- return;
- }
- break;
- case eAllocationPolicyProcessOnly:
- process_sp = m_process_wp.lock();
- if (process_sp)
- {
- process_sp->WriteMemory(process_address, bytes, size, error);
- if (!error.Success())
- return;
- }
- break;
}
-
- if (lldb_private::Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
- {
- log->Printf("IRMemoryMap::WriteMemory (0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRId64 ") went to [0x%" PRIx64 "..0x%" PRIx64 ")",
- (uint64_t)process_address,
- (uint64_t)bytes,
- (uint64_t)size,
- (uint64_t)allocation.m_process_start,
- (uint64_t)allocation.m_process_start + (uint64_t)allocation.m_size);
+ break;
+ case eAllocationPolicyProcessOnly:
+ process_sp = m_process_wp.lock();
+ if (process_sp) {
+ process_sp->WriteMemory(process_address, bytes, size, error);
+ if (!error.Success())
+ return;
}
+ break;
+ }
+
+ if (lldb_private::Log *log =
+ lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
+ log->Printf("IRMemoryMap::WriteMemory (0x%" PRIx64 ", 0x%" PRIx64
+ ", 0x%" PRId64 ") went to [0x%" PRIx64 "..0x%" PRIx64 ")",
+ (uint64_t)process_address, (uint64_t)bytes, (uint64_t)size,
+ (uint64_t)allocation.m_process_start,
+ (uint64_t)allocation.m_process_start +
+ (uint64_t)allocation.m_size);
+ }
}
-void
-IRMemoryMap::WriteScalarToMemory (lldb::addr_t process_address, Scalar &scalar, size_t size, Error &error)
-{
- error.Clear();
-
- if (size == UINT32_MAX)
- size = scalar.GetByteSize();
-
- if (size > 0)
- {
- uint8_t buf[32];
- const size_t mem_size = scalar.GetAsMemoryData (buf, size, GetByteOrder(), error);
- if (mem_size > 0)
- {
- return WriteMemory(process_address, buf, mem_size, error);
- }
- else
- {
- error.SetErrorToGenericError();
- error.SetErrorString ("Couldn't write scalar: failed to get scalar as memory data");
- }
- }
- else
- {
- error.SetErrorToGenericError();
- error.SetErrorString ("Couldn't write scalar: its size was zero");
- }
- return;
+void IRMemoryMap::WriteScalarToMemory(lldb::addr_t process_address,
+ Scalar &scalar, size_t size,
+ Error &error) {
+ error.Clear();
+
+ if (size == UINT32_MAX)
+ size = scalar.GetByteSize();
+
+ if (size > 0) {
+ uint8_t buf[32];
+ const size_t mem_size =
+ scalar.GetAsMemoryData(buf, size, GetByteOrder(), error);
+ if (mem_size > 0) {
+ return WriteMemory(process_address, buf, mem_size, error);
+ } else {
+ error.SetErrorToGenericError();
+ error.SetErrorString(
+ "Couldn't write scalar: failed to get scalar as memory data");
+ }
+ } else {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't write scalar: its size was zero");
+ }
+ return;
}
-void
-IRMemoryMap::WritePointerToMemory (lldb::addr_t process_address, lldb::addr_t address, Error &error)
-{
- error.Clear();
+void IRMemoryMap::WritePointerToMemory(lldb::addr_t process_address,
+ lldb::addr_t address, Error &error) {
+ error.Clear();
- Scalar scalar(address);
+ Scalar scalar(address);
- WriteScalarToMemory(process_address, scalar, GetAddressByteSize(), error);
+ WriteScalarToMemory(process_address, scalar, GetAddressByteSize(), error);
}
-void
-IRMemoryMap::ReadMemory (uint8_t *bytes, lldb::addr_t process_address, size_t size, Error &error)
-{
- error.Clear();
+void IRMemoryMap::ReadMemory(uint8_t *bytes, lldb::addr_t process_address,
+ size_t size, Error &error) {
+ error.Clear();
- AllocationMap::iterator iter = FindAllocation(process_address, size);
-
- if (iter == m_allocations.end())
- {
- lldb::ProcessSP process_sp = m_process_wp.lock();
+ AllocationMap::iterator iter = FindAllocation(process_address, size);
- if (process_sp)
- {
- process_sp->ReadMemory(process_address, bytes, size, error);
- return;
- }
+ if (iter == m_allocations.end()) {
+ lldb::ProcessSP process_sp = m_process_wp.lock();
- lldb::TargetSP target_sp = m_target_wp.lock();
+ if (process_sp) {
+ process_sp->ReadMemory(process_address, bytes, size, error);
+ return;
+ }
- if (target_sp)
- {
- Address absolute_address(process_address);
- target_sp->ReadMemory(absolute_address, false, bytes, size, error);
- return;
- }
+ lldb::TargetSP target_sp = m_target_wp.lock();
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't read: no allocation contains the target range, and neither the process nor the target exist");
- return;
+ if (target_sp) {
+ Address absolute_address(process_address);
+ target_sp->ReadMemory(absolute_address, false, bytes, size, error);
+ return;
}
- Allocation &allocation = iter->second;
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't read: no allocation contains the target "
+ "range, and neither the process nor the target exist");
+ return;
+ }
- uint64_t offset = process_address - allocation.m_process_start;
+ Allocation &allocation = iter->second;
- if (offset > allocation.m_size)
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't read: data is not in the allocation");
- return;
- }
+ uint64_t offset = process_address - allocation.m_process_start;
- lldb::ProcessSP process_sp;
+ if (offset > allocation.m_size) {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't read: data is not in the allocation");
+ return;
+ }
- switch (allocation.m_policy)
- {
- default:
+ lldb::ProcessSP process_sp;
+
+ switch (allocation.m_policy) {
+ default:
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't read: invalid allocation policy");
+ return;
+ case eAllocationPolicyHostOnly:
+ if (!allocation.m_data.GetByteSize()) {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't read: data buffer is empty");
+ return;
+ }
+ if (allocation.m_data.GetByteSize() < offset + size) {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't read: not enough underlying data");
+ return;
+ }
+
+ ::memcpy(bytes, allocation.m_data.GetBytes() + offset, size);
+ break;
+ case eAllocationPolicyMirror:
+ process_sp = m_process_wp.lock();
+ if (process_sp) {
+ process_sp->ReadMemory(process_address, bytes, size, error);
+ if (!error.Success())
+ return;
+ } else {
+ if (!allocation.m_data.GetByteSize()) {
error.SetErrorToGenericError();
- error.SetErrorString("Couldn't read: invalid allocation policy");
+ error.SetErrorString("Couldn't read: data buffer is empty");
+ return;
+ }
+ ::memcpy(bytes, allocation.m_data.GetBytes() + offset, size);
+ }
+ break;
+ case eAllocationPolicyProcessOnly:
+ process_sp = m_process_wp.lock();
+ if (process_sp) {
+ process_sp->ReadMemory(process_address, bytes, size, error);
+ if (!error.Success())
return;
- case eAllocationPolicyHostOnly:
- if (!allocation.m_data.GetByteSize())
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't read: data buffer is empty");
- return;
- }
- if (allocation.m_data.GetByteSize() < offset + size)
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't read: not enough underlying data");
- return;
- }
-
- ::memcpy (bytes, allocation.m_data.GetBytes() + offset, size);
- break;
- case eAllocationPolicyMirror:
- process_sp = m_process_wp.lock();
- if (process_sp)
- {
- process_sp->ReadMemory(process_address, bytes, size, error);
- if (!error.Success())
- return;
- }
- else
- {
- if (!allocation.m_data.GetByteSize())
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't read: data buffer is empty");
- return;
- }
- ::memcpy (bytes, allocation.m_data.GetBytes() + offset, size);
- }
- break;
- case eAllocationPolicyProcessOnly:
- process_sp = m_process_wp.lock();
- if (process_sp)
- {
- process_sp->ReadMemory(process_address, bytes, size, error);
- if (!error.Success())
- return;
- }
- break;
- }
-
- if (lldb_private::Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
- {
- log->Printf("IRMemoryMap::ReadMemory (0x%" PRIx64 ", 0x%" PRIx64 ", 0x%" PRId64 ") came from [0x%" PRIx64 "..0x%" PRIx64 ")",
- (uint64_t)process_address,
- (uint64_t)bytes,
- (uint64_t)size,
- (uint64_t)allocation.m_process_start,
- (uint64_t)allocation.m_process_start + (uint64_t)allocation.m_size);
}
+ break;
+ }
+
+ if (lldb_private::Log *log =
+ lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
+ log->Printf("IRMemoryMap::ReadMemory (0x%" PRIx64 ", 0x%" PRIx64
+ ", 0x%" PRId64 ") came from [0x%" PRIx64 "..0x%" PRIx64 ")",
+ (uint64_t)process_address, (uint64_t)bytes, (uint64_t)size,
+ (uint64_t)allocation.m_process_start,
+ (uint64_t)allocation.m_process_start +
+ (uint64_t)allocation.m_size);
+ }
}
-void
-IRMemoryMap::ReadScalarFromMemory (Scalar &scalar, lldb::addr_t process_address, size_t size, Error &error)
-{
- error.Clear();
+void IRMemoryMap::ReadScalarFromMemory(Scalar &scalar,
+ lldb::addr_t process_address,
+ size_t size, Error &error) {
+ error.Clear();
- if (size > 0)
- {
- DataBufferHeap buf(size, 0);
- ReadMemory(buf.GetBytes(), process_address, size, error);
+ if (size > 0) {
+ DataBufferHeap buf(size, 0);
+ ReadMemory(buf.GetBytes(), process_address, size, error);
- if (!error.Success())
- return;
-
- DataExtractor extractor(buf.GetBytes(), buf.GetByteSize(), GetByteOrder(), GetAddressByteSize());
-
- lldb::offset_t offset = 0;
-
- switch (size)
- {
- default:
- error.SetErrorToGenericError();
- error.SetErrorStringWithFormat("Couldn't read scalar: unsupported size %" PRIu64, (uint64_t)size);
- return;
- case 1: scalar = extractor.GetU8(&offset); break;
- case 2: scalar = extractor.GetU16(&offset); break;
- case 4: scalar = extractor.GetU32(&offset); break;
- case 8: scalar = extractor.GetU64(&offset); break;
- }
- }
- else
- {
- error.SetErrorToGenericError();
- error.SetErrorString ("Couldn't read scalar: its size was zero");
- }
- return;
-}
+ if (!error.Success())
+ return;
-void
-IRMemoryMap::ReadPointerFromMemory (lldb::addr_t *address, lldb::addr_t process_address, Error &error)
-{
- error.Clear();
+ DataExtractor extractor(buf.GetBytes(), buf.GetByteSize(), GetByteOrder(),
+ GetAddressByteSize());
- Scalar pointer_scalar;
- ReadScalarFromMemory(pointer_scalar, process_address, GetAddressByteSize(), error);
+ lldb::offset_t offset = 0;
- if (!error.Success())
- return;
+ switch (size) {
+ default:
+ error.SetErrorToGenericError();
+ error.SetErrorStringWithFormat(
+ "Couldn't read scalar: unsupported size %" PRIu64, (uint64_t)size);
+ return;
+ case 1:
+ scalar = extractor.GetU8(&offset);
+ break;
+ case 2:
+ scalar = extractor.GetU16(&offset);
+ break;
+ case 4:
+ scalar = extractor.GetU32(&offset);
+ break;
+ case 8:
+ scalar = extractor.GetU64(&offset);
+ break;
+ }
+ } else {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't read scalar: its size was zero");
+ }
+ return;
+}
+
+void IRMemoryMap::ReadPointerFromMemory(lldb::addr_t *address,
+ lldb::addr_t process_address,
+ Error &error) {
+ error.Clear();
- *address = pointer_scalar.ULongLong();
+ Scalar pointer_scalar;
+ ReadScalarFromMemory(pointer_scalar, process_address, GetAddressByteSize(),
+ error);
+ if (!error.Success())
return;
-}
-void
-IRMemoryMap::GetMemoryData (DataExtractor &extractor, lldb::addr_t process_address, size_t size, Error &error)
-{
- error.Clear();
+ *address = pointer_scalar.ULongLong();
- if (size > 0)
- {
- AllocationMap::iterator iter = FindAllocation(process_address, size);
+ return;
+}
- if (iter == m_allocations.end())
- {
- error.SetErrorToGenericError();
- error.SetErrorStringWithFormat("Couldn't find an allocation containing [0x%" PRIx64 "..0x%" PRIx64 ")", process_address, process_address + size);
- return;
- }
+void IRMemoryMap::GetMemoryData(DataExtractor &extractor,
+ lldb::addr_t process_address, size_t size,
+ Error &error) {
+ error.Clear();
- Allocation &allocation = iter->second;
-
- switch (allocation.m_policy)
- {
- default:
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't get memory data: invalid allocation policy");
- return;
- case eAllocationPolicyProcessOnly:
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't get memory data: memory is only in the target");
- return;
- case eAllocationPolicyMirror:
- {
- lldb::ProcessSP process_sp = m_process_wp.lock();
-
- if (!allocation.m_data.GetByteSize())
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't get memory data: data buffer is empty");
- return;
- }
- if (process_sp)
- {
- process_sp->ReadMemory(allocation.m_process_start, allocation.m_data.GetBytes(), allocation.m_data.GetByteSize(), error);
- if (!error.Success())
- return;
- uint64_t offset = process_address - allocation.m_process_start;
- extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size, GetByteOrder(), GetAddressByteSize());
- return;
- }
- }
- break;
- case eAllocationPolicyHostOnly:
- if (!allocation.m_data.GetByteSize())
- {
- error.SetErrorToGenericError();
- error.SetErrorString("Couldn't get memory data: data buffer is empty");
- return;
- }
- uint64_t offset = process_address - allocation.m_process_start;
- extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size, GetByteOrder(), GetAddressByteSize());
- return;
- }
+ if (size > 0) {
+ AllocationMap::iterator iter = FindAllocation(process_address, size);
+
+ if (iter == m_allocations.end()) {
+ error.SetErrorToGenericError();
+ error.SetErrorStringWithFormat(
+ "Couldn't find an allocation containing [0x%" PRIx64 "..0x%" PRIx64
+ ")",
+ process_address, process_address + size);
+ return;
}
- else
- {
+
+ Allocation &allocation = iter->second;
+
+ switch (allocation.m_policy) {
+ default:
+ error.SetErrorToGenericError();
+ error.SetErrorString(
+ "Couldn't get memory data: invalid allocation policy");
+ return;
+ case eAllocationPolicyProcessOnly:
+ error.SetErrorToGenericError();
+ error.SetErrorString(
+ "Couldn't get memory data: memory is only in the target");
+ return;
+ case eAllocationPolicyMirror: {
+ lldb::ProcessSP process_sp = m_process_wp.lock();
+
+ if (!allocation.m_data.GetByteSize()) {
error.SetErrorToGenericError();
- error.SetErrorString ("Couldn't get memory data: its size was zero");
+ error.SetErrorString("Couldn't get memory data: data buffer is empty");
return;
- }
+ }
+ if (process_sp) {
+ process_sp->ReadMemory(allocation.m_process_start,
+ allocation.m_data.GetBytes(),
+ allocation.m_data.GetByteSize(), error);
+ if (!error.Success())
+ return;
+ uint64_t offset = process_address - allocation.m_process_start;
+ extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size,
+ GetByteOrder(), GetAddressByteSize());
+ return;
+ }
+ } break;
+ case eAllocationPolicyHostOnly:
+ if (!allocation.m_data.GetByteSize()) {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't get memory data: data buffer is empty");
+ return;
+ }
+ uint64_t offset = process_address - allocation.m_process_start;
+ extractor = DataExtractor(allocation.m_data.GetBytes() + offset, size,
+ GetByteOrder(), GetAddressByteSize());
+ return;
+ }
+ } else {
+ error.SetErrorToGenericError();
+ error.SetErrorString("Couldn't get memory data: its size was zero");
+ return;
+ }
}
OpenPOWER on IntegriCloud