1 //===-- IRMemoryMap.h -------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef lldb_IRMemoryMap_h_ 10 #define lldb_IRMemoryMap_h_ 11 12 #include "lldb/Utility/DataBufferHeap.h" 13 #include "lldb/Utility/UserID.h" 14 #include "lldb/lldb-public.h" 15 16 #include <map> 17 18 namespace lldb_private { 19 20 /// \class IRMemoryMap IRMemoryMap.h "lldb/Expression/IRMemoryMap.h" 21 /// Encapsulates memory that may exist in the process but must 22 /// also be available in the host process. 23 /// 24 /// This class encapsulates a group of memory objects that must be readable or 25 /// writable from the host process regardless of whether the process exists. 26 /// This allows the IR interpreter as well as JITted code to access the same 27 /// memory. All allocations made by this class are represented as disjoint 28 /// intervals. 29 /// 30 /// Point queries against this group of memory objects can be made by the 31 /// address in the tar at which they reside. If the inferior does not exist, 32 /// allocations still get made-up addresses. If an inferior appears at some 33 /// point, then those addresses need to be re-mapped. 34 class IRMemoryMap { 35 public: 36 IRMemoryMap(lldb::TargetSP target_sp); 37 ~IRMemoryMap(); 38 39 enum AllocationPolicy : uint8_t { 40 eAllocationPolicyInvalid = 41 0, ///< It is an error for an allocation to have this policy. 42 eAllocationPolicyHostOnly, ///< This allocation was created in the host and 43 ///will never make it into the process. 44 ///< It is an error to create other types of allocations while such 45 ///allocations exist. 46 eAllocationPolicyMirror, ///< The intent is that this allocation exist both 47 ///in the host and the process and have 48 ///< the same content in both. 49 eAllocationPolicyProcessOnly ///< The intent is that this allocation exist 50 ///only in the process. 51 }; 52 53 lldb::addr_t Malloc(size_t size, uint8_t alignment, uint32_t permissions, 54 AllocationPolicy policy, bool zero_memory, Status &error); 55 void Leak(lldb::addr_t process_address, Status &error); 56 void Free(lldb::addr_t process_address, Status &error); 57 58 void WriteMemory(lldb::addr_t process_address, const uint8_t *bytes, 59 size_t size, Status &error); 60 void WriteScalarToMemory(lldb::addr_t process_address, Scalar &scalar, 61 size_t size, Status &error); 62 void WritePointerToMemory(lldb::addr_t process_address, lldb::addr_t address, 63 Status &error); 64 void ReadMemory(uint8_t *bytes, lldb::addr_t process_address, size_t size, 65 Status &error); 66 void ReadScalarFromMemory(Scalar &scalar, lldb::addr_t process_address, 67 size_t size, Status &error); 68 void ReadPointerFromMemory(lldb::addr_t *address, 69 lldb::addr_t process_address, Status &error); 70 bool GetAllocSize(lldb::addr_t address, size_t &size); 71 void GetMemoryData(DataExtractor &extractor, lldb::addr_t process_address, 72 size_t size, Status &error); 73 74 lldb::ByteOrder GetByteOrder(); 75 uint32_t GetAddressByteSize(); 76 77 // This function can return NULL. 78 ExecutionContextScope *GetBestExecutionContextScope() const; 79 80 lldb::TargetSP GetTarget() { return m_target_wp.lock(); } 81 82 protected: 83 // This function should only be used if you know you are using the JIT. Any 84 // other cases should use GetBestExecutionContextScope(). 85 86 lldb::ProcessWP &GetProcessWP() { return m_process_wp; } 87 88 private: 89 struct Allocation { 90 lldb::addr_t 91 m_process_alloc; ///< The (unaligned) base for the remote allocation. 92 lldb::addr_t 93 m_process_start; ///< The base address of the allocation in the process. 94 size_t m_size; ///< The size of the requested allocation. 95 DataBufferHeap m_data; 96 97 /// Flags. Keep these grouped together to avoid structure padding. 98 AllocationPolicy m_policy; 99 bool m_leak; 100 uint8_t m_permissions; ///< The access permissions on the memory in the 101 /// process. In the host, the memory is always 102 /// read/write. 103 uint8_t m_alignment; ///< The alignment of the requested allocation. 104 105 public: 106 Allocation(lldb::addr_t process_alloc, lldb::addr_t process_start, 107 size_t size, uint32_t permissions, uint8_t alignment, 108 AllocationPolicy m_policy); 109 110 DISALLOW_COPY_AND_ASSIGN(Allocation); 111 }; 112 113 static_assert(sizeof(Allocation) <= 114 (4 * sizeof(lldb::addr_t)) + sizeof(DataBufferHeap), 115 "IRMemoryMap::Allocation is larger than expected"); 116 117 lldb::ProcessWP m_process_wp; 118 lldb::TargetWP m_target_wp; 119 typedef std::map<lldb::addr_t, Allocation> AllocationMap; 120 AllocationMap m_allocations; 121 122 lldb::addr_t FindSpace(size_t size); 123 bool ContainsHostOnlyAllocations(); 124 AllocationMap::iterator FindAllocation(lldb::addr_t addr, size_t size); 125 126 // Returns true if the given allocation intersects any allocation in the 127 // memory map. 128 bool IntersectsAllocation(lldb::addr_t addr, size_t size) const; 129 130 // Returns true if the two given allocations intersect each other. 131 static bool AllocationsIntersect(lldb::addr_t addr1, size_t size1, 132 lldb::addr_t addr2, size_t size2); 133 }; 134 } 135 136 #endif 137