diff options
Diffstat (limited to 'contrib/llvm-project/lldb/include/lldb/Expression/IRMemoryMap.h')
-rw-r--r-- | contrib/llvm-project/lldb/include/lldb/Expression/IRMemoryMap.h | 137 |
1 files changed, 137 insertions, 0 deletions
diff --git a/contrib/llvm-project/lldb/include/lldb/Expression/IRMemoryMap.h b/contrib/llvm-project/lldb/include/lldb/Expression/IRMemoryMap.h new file mode 100644 index 000000000000..abec5442793c --- /dev/null +++ b/contrib/llvm-project/lldb/include/lldb/Expression/IRMemoryMap.h @@ -0,0 +1,137 @@ +//===-- IRMemoryMap.h -------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_EXPRESSION_IRMEMORYMAP_H +#define LLDB_EXPRESSION_IRMEMORYMAP_H + +#include "lldb/Utility/DataBufferHeap.h" +#include "lldb/Utility/UserID.h" +#include "lldb/lldb-public.h" + +#include <map> + +namespace lldb_private { + +/// \class IRMemoryMap IRMemoryMap.h "lldb/Expression/IRMemoryMap.h" +/// Encapsulates memory that may exist in the process but must +/// also be available in the host process. +/// +/// This class encapsulates a group of memory objects that must be readable or +/// writable from the host process regardless of whether the process exists. +/// This allows the IR interpreter as well as JITted code to access the same +/// memory. All allocations made by this class are represented as disjoint +/// intervals. +/// +/// Point queries against this group of memory objects can be made by the +/// address in the tar at which they reside. If the inferior does not exist, +/// allocations still get made-up addresses. If an inferior appears at some +/// point, then those addresses need to be re-mapped. +class IRMemoryMap { +public: + IRMemoryMap(lldb::TargetSP target_sp); + ~IRMemoryMap(); + + enum AllocationPolicy : uint8_t { + eAllocationPolicyInvalid = + 0, ///< It is an error for an allocation to have this policy. + eAllocationPolicyHostOnly, ///< This allocation was created in the host and + ///will never make it into the process. + ///< It is an error to create other types of allocations while such + ///allocations exist. + eAllocationPolicyMirror, ///< The intent is that this allocation exist both + ///in the host and the process and have + ///< the same content in both. + eAllocationPolicyProcessOnly ///< The intent is that this allocation exist + ///only in the process. + }; + + lldb::addr_t Malloc(size_t size, uint8_t alignment, uint32_t permissions, + AllocationPolicy policy, bool zero_memory, Status &error); + void Leak(lldb::addr_t process_address, Status &error); + void Free(lldb::addr_t process_address, Status &error); + + void WriteMemory(lldb::addr_t process_address, const uint8_t *bytes, + size_t size, Status &error); + void WriteScalarToMemory(lldb::addr_t process_address, Scalar &scalar, + size_t size, Status &error); + void WritePointerToMemory(lldb::addr_t process_address, lldb::addr_t address, + Status &error); + void ReadMemory(uint8_t *bytes, lldb::addr_t process_address, size_t size, + Status &error); + void ReadScalarFromMemory(Scalar &scalar, lldb::addr_t process_address, + size_t size, Status &error); + void ReadPointerFromMemory(lldb::addr_t *address, + lldb::addr_t process_address, Status &error); + bool GetAllocSize(lldb::addr_t address, size_t &size); + void GetMemoryData(DataExtractor &extractor, lldb::addr_t process_address, + size_t size, Status &error); + + lldb::ByteOrder GetByteOrder(); + uint32_t GetAddressByteSize(); + + // This function can return NULL. + ExecutionContextScope *GetBestExecutionContextScope() const; + + lldb::TargetSP GetTarget() { return m_target_wp.lock(); } + +protected: + // This function should only be used if you know you are using the JIT. Any + // other cases should use GetBestExecutionContextScope(). + + lldb::ProcessWP &GetProcessWP() { return m_process_wp; } + +private: + struct Allocation { + lldb::addr_t + m_process_alloc; ///< The (unaligned) base for the remote allocation. + lldb::addr_t + m_process_start; ///< The base address of the allocation in the process. + size_t m_size; ///< The size of the requested allocation. + DataBufferHeap m_data; + + /// Flags. Keep these grouped together to avoid structure padding. + AllocationPolicy m_policy; + bool m_leak; + uint8_t m_permissions; ///< The access permissions on the memory in the + /// process. In the host, the memory is always + /// read/write. + uint8_t m_alignment; ///< The alignment of the requested allocation. + + public: + Allocation(lldb::addr_t process_alloc, lldb::addr_t process_start, + size_t size, uint32_t permissions, uint8_t alignment, + AllocationPolicy m_policy); + + Allocation(const Allocation &) = delete; + const Allocation &operator=(const Allocation &) = delete; + }; + + static_assert(sizeof(Allocation) <= + (4 * sizeof(lldb::addr_t)) + sizeof(DataBufferHeap), + "IRMemoryMap::Allocation is larger than expected"); + + lldb::ProcessWP m_process_wp; + lldb::TargetWP m_target_wp; + typedef std::map<lldb::addr_t, Allocation> AllocationMap; + AllocationMap m_allocations; + + lldb::addr_t FindSpace(size_t size); + bool ContainsHostOnlyAllocations(); + AllocationMap::iterator FindAllocation(lldb::addr_t addr, size_t size); + + // Returns true if the given allocation intersects any allocation in the + // memory map. + bool IntersectsAllocation(lldb::addr_t addr, size_t size) const; + + // Returns true if the two given allocations intersect each other. + static bool AllocationsIntersect(lldb::addr_t addr1, size_t size1, + lldb::addr_t addr2, size_t size2); +}; +} + +#endif |