32 AllocationMap::iterator iter;
38 if (iter->second.m_leak)
41 Free(iter->first, err);
62 const bool process_is_alive = process_sp && process_sp->IsAlive();
68 if (process_is_alive && process_sp->CanJIT()) {
71 ret = process_sp->AllocateMemory(size, lldb::ePermissionsReadable |
72 lldb::ePermissionsWritable,
91 size_t alloc_size = back->second.m_size;
92 ret = llvm::alignTo(addr + alloc_size, 4096);
95 uint64_t end_of_memory;
98 end_of_memory = 0xffffull;
101 end_of_memory = 0xffffffffull;
104 end_of_memory = 0xffffffffffffffffull;
114 if (process_is_alive) {
116 Status err = process_sp->GetMemoryRegionInfo(ret, region_info);
143 err = process_sp->GetMemoryRegionInfo(
146 lldbassert(0 &&
"GetMemoryRegionInfo() succeeded, then failed");
158 uint64_t alloc_address = target_sp->GetExprAllocAddress();
159 if (alloc_address > 0) {
160 if (alloc_address >= end_of_memory) {
161 lldbassert(0 &&
"The allocation address for expression evaluation must "
162 "be within process address space");
169 switch (address_byte_size) {
177 ret = 0xdead0fff00000000ull;
188 size_t alloc_size = back->second.m_size;
189 uint64_t align = target_sp->GetExprAllocAlign();
192 ret = llvm::alignTo(addr + alloc_size, align);
198IRMemoryMap::AllocationMap::iterator
203 AllocationMap::iterator iter =
m_allocations.lower_bound(addr);
211 if (iter->first <= addr && iter->first + iter->second.m_size >= addr + size)
221 AllocationMap::const_iterator iter =
m_allocations.lower_bound(addr);
232 iter->second.m_size))
239 iter->second.m_size))
258 return (addr2 < (addr1 + size1)) && (addr1 < (addr2 + size2));
265 return process_sp->GetByteOrder();
270 return target_sp->GetArchitecture().GetByteOrder();
279 return process_sp->GetAddressByteSize();
284 return target_sp->GetArchitecture().GetAddressByteSize();
293 return process_sp.get();
298 return target_sp.get();
305 uint32_t permissions, uint8_t alignment,
312 llvm_unreachable(
"Invalid AllocationPolicy");
322llvm::Expected<lldb::addr_t>
332 size_t allocation_size;
337 allocation_size = alignment;
340 allocation_size = llvm::alignTo(size, alignment);
345 allocation_size += alignment - 1;
350 return llvm::createStringError(
351 llvm::inconvertibleErrorCode(),
352 "Couldn't malloc: invalid allocation policy");
354 allocation_address =
FindSpace(allocation_size);
356 return llvm::createStringError(llvm::inconvertibleErrorCode(),
357 "Couldn't malloc: address space is full");
362 "IRMemoryMap::%s process_sp=0x%" PRIxPTR
363 ", process_sp->CanJIT()=%s, process_sp->IsAlive()=%s",
364 __FUNCTION__,
reinterpret_cast<uintptr_t
>(process_sp.get()),
365 process_sp && process_sp->CanJIT() ?
"true" :
"false",
366 process_sp && process_sp->IsAlive() ?
"true" :
"false");
367 if (process_sp && process_sp->CanJIT() && process_sp->IsAlive()) {
371 process_sp->AllocateMemory(allocation_size, permissions,
error);
374 process_sp->CallocateMemory(allocation_size, permissions,
error);
376 if (!
error.Success())
377 return error.takeError();
380 "IRMemoryMap::%s switching to eAllocationPolicyHostOnly "
381 "due to failed condition (see previous expr log message)",
384 allocation_address =
FindSpace(allocation_size);
386 return llvm::createStringError(
387 llvm::inconvertibleErrorCode(),
388 "Couldn't malloc: address space is full");
394 if (process_sp->CanJIT() && process_sp->IsAlive()) {
398 process_sp->AllocateMemory(allocation_size, permissions,
error);
401 process_sp->CallocateMemory(allocation_size, permissions,
error);
403 if (!
error.Success())
404 return error.takeError();
406 return llvm::createStringError(
407 llvm::inconvertibleErrorCode(),
408 "Couldn't malloc: process doesn't support allocating memory");
411 return llvm::createStringError(llvm::inconvertibleErrorCode(),
412 "Couldn't malloc: process doesn't exist, "
413 "and this memory must be in the process");
419 aligned_address = (allocation_address + mask) & (~mask);
422 std::piecewise_construct, std::forward_as_tuple(aligned_address),
423 std::forward_as_tuple(allocation_address, aligned_address,
424 allocation_size, permissions, alignment, policy));
428 std::vector<uint8_t> zero_buf(size, 0);
429 WriteMemory(aligned_address, zero_buf.data(), size, write_error);
433 const char *policy_string;
437 policy_string =
"<invalid policy>";
440 policy_string =
"eAllocationPolicyHostOnly";
443 policy_string =
"eAllocationPolicyProcessOnly";
446 policy_string =
"eAllocationPolicyMirror";
451 "IRMemoryMap::Malloc (%" PRIu64
", 0x%" PRIx64
", 0x%" PRIx64
452 ", %s) -> 0x%" PRIx64,
453 (uint64_t)allocation_size, (uint64_t)alignment,
454 (uint64_t)permissions, policy_string, aligned_address);
458 *used_policy = policy;
460 return aligned_address;
466 AllocationMap::iterator iter =
m_allocations.find(process_address);
481 AllocationMap::iterator iter =
m_allocations.find(process_address);
495 if (process_sp->CanJIT() && process_sp->IsAlive())
496 process_sp->DeallocateMemory(
512 "IRMemoryMap::Free (0x%" PRIx64
") freed [0x%" PRIx64
514 (uint64_t)process_address, iter->second.m_process_start,
515 iter->second.m_process_start + iter->second.m_size);
544 const uint8_t *bytes,
size_t size,
548 AllocationMap::iterator iter =
FindAllocation(process_address, size);
554 process_sp->WriteMemory(process_address, bytes, size,
error);
559 "Couldn't write: no allocation contains the target "
560 "range and the process doesn't exist");
590 process_sp->WriteMemory(process_address, bytes, size,
error);
591 if (!
error.Success())
598 process_sp->WriteMemory(process_address, bytes, size,
error);
599 if (!
error.Success())
607 "IRMemoryMap::WriteMemory (0x%" PRIx64
", 0x%" PRIxPTR
608 ", 0x%" PRId64
") went to [0x%" PRIx64
"..0x%" PRIx64
")",
609 (uint64_t)process_address,
reinterpret_cast<uintptr_t
>(bytes), (uint64_t)size,
612 (uint64_t)allocation.
m_size);
617 Scalar &scalar,
size_t size,
626 const size_t mem_size =
632 "Couldn't write scalar: failed to get scalar as memory data");
650 pointer = process_sp->FixAnyAddress(pointer);
661 AllocationMap::iterator iter =
FindAllocation(process_address, size);
667 process_sp->ReadMemory(process_address, bytes, size,
error);
674 Address absolute_address(process_address);
675 target_sp->ReadMemory(absolute_address, bytes, size,
error,
true);
680 "Couldn't read: no allocation contains the target "
681 "range, and neither the process nor the target exist");
689 if (offset > allocation.
m_size) {
717 process_sp->ReadMemory(process_address, bytes, size,
error);
718 if (!
error.Success())
731 process_sp->ReadMemory(process_address, bytes, size,
error);
732 if (!
error.Success())
740 "IRMemoryMap::ReadMemory (0x%" PRIx64
", 0x%" PRIxPTR
741 ", 0x%" PRId64
") came from [0x%" PRIx64
"..0x%" PRIx64
")",
742 (uint64_t)process_address,
reinterpret_cast<uintptr_t
>(bytes), (uint64_t)size,
745 (uint64_t)allocation.
m_size);
758 if (!
error.Success())
769 "Couldn't read scalar: unsupported size %" PRIu64, (uint64_t)size);
772 scalar = extractor.
GetU8(&offset);
775 scalar = extractor.
GetU16(&offset);
778 scalar = extractor.
GetU32(&offset);
781 scalar = extractor.
GetU64(&offset);
798 if (!
error.Success())
810 AllocationMap::iterator iter =
FindAllocation(process_address, size);
814 "Couldn't find an allocation containing [0x%" PRIx64
"..0x%" PRIx64
816 process_address, process_address + size);
825 "Couldn't get memory data: invalid allocation policy");
829 "Couldn't get memory data: memory is only in the target");
836 "Couldn't get memory data: data buffer is empty");
843 if (!
error.Success())
854 "Couldn't get memory data: data buffer is empty");
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
A section + offset based address class.
A subclass of DataBuffer that stores a data buffer on the heap.
lldb::offset_t GetByteSize() const override
Get the number of bytes in the data buffer.
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
lldb::TargetWP m_target_wp
void Free(lldb::addr_t process_address, Status &error)
lldb::ByteOrder GetByteOrder()
llvm::Expected< lldb::addr_t > Malloc(size_t size, uint8_t alignment, uint32_t permissions, AllocationPolicy policy, bool zero_memory, AllocationPolicy *used_policy=nullptr)
void ReadPointerFromMemory(lldb::addr_t *address, lldb::addr_t process_address, Status &error)
lldb::ProcessWP m_process_wp
AllocationMap m_allocations
bool IntersectsAllocation(lldb::addr_t addr, size_t size) const
ExecutionContextScope * GetBestExecutionContextScope() const
static bool AllocationsIntersect(lldb::addr_t addr1, size_t size1, lldb::addr_t addr2, size_t size2)
void GetMemoryData(DataExtractor &extractor, lldb::addr_t process_address, size_t size, Status &error)
lldb::ProcessWP & GetProcessWP()
AllocationMap::iterator FindAllocation(lldb::addr_t addr, size_t size)
uint32_t GetAddressByteSize()
void WritePointerToMemory(lldb::addr_t process_address, lldb::addr_t pointer, Status &error)
IRMemoryMap(lldb::TargetSP target_sp)
void ReadScalarFromMemory(Scalar &scalar, lldb::addr_t process_address, size_t size, Status &error)
lldb::addr_t FindSpace(size_t size)
void WriteScalarToMemory(lldb::addr_t process_address, Scalar &scalar, size_t size, Status &error)
bool GetAllocSize(lldb::addr_t address, size_t &size)
void Leak(lldb::addr_t process_address, Status &error)
void WriteMemory(lldb::addr_t process_address, const uint8_t *bytes, size_t size, Status &error)
void ReadMemory(uint8_t *bytes, lldb::addr_t process_address, size_t size, Status &error)
@ eAllocationPolicyProcessOnly
The intent is that this allocation exist only in the process.
@ eAllocationPolicyHostOnly
This allocation was created in the host and will never make it into the process.
@ eAllocationPolicyMirror
The intent is that this allocation exist both in the host and the process and have the same content i...
OptionalBool GetWritable() const
OptionalBool GetReadable() const
OptionalBool GetExecutable() const
size_t GetByteSize() const
unsigned long long ULongLong(unsigned long long fail_value=0) const
size_t GetAsMemoryData(void *dst, size_t dst_len, lldb::ByteOrder dst_byte_order, Status &error) const
void Clear()
Clear the object state.
static Status FromErrorStringWithFormat(const char *format,...) __attribute__((format(printf
static Status FromErrorString(const char *str)
bool Fail() const
Test for error condition.
bool Success() const
Test for success condition.
uint8_t * GetBytes()
Get a pointer to the data.
#define LLDB_INVALID_ADDRESS
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
std::shared_ptr< lldb_private::Process > ProcessSP
ByteOrder
Byte ordering definitions.
std::shared_ptr< lldb_private::Target > TargetSP
size_t m_size
The size of the requested allocation.
lldb::addr_t m_process_alloc
The (unaligned) base for the remote allocation.
AllocationPolicy m_policy
Flags. Keep these grouped together to avoid structure padding.
uint8_t m_permissions
The access permissions on the memory in the process.
Allocation(lldb::addr_t process_alloc, lldb::addr_t process_start, size_t size, uint32_t permissions, uint8_t alignment, AllocationPolicy m_policy)
lldb::addr_t m_process_start
The base address of the allocation in the process.
uint8_t m_alignment
The alignment of the requested allocation.
BaseType GetRangeBase() const
BaseType GetRangeEnd() const