IRMemoryMap.h revision f4b59480e8d1056b1638141a6a627b252f657db0 
1//===-- IRExecutionUnit.h ---------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef lldb_IRMemoryMap_h_
11#define lldb_IRMemoryMap_h_
12
13#include "lldb/lldb-public.h"
14#include "lldb/Core/DataBufferHeap.h"
15#include "lldb/Core/UserID.h"
16
17#include <map>
18
19namespace lldb_private
20{
21
22//----------------------------------------------------------------------
23/// @class IRMemoryMap IRMemoryMap.h "lldb/Expression/IRMemoryMap.h"
24/// @brief Encapsulates memory that may exist in the process but must
25///     also be available in the host process.
26///
27/// This class encapsulates a group of memory objects that must be readable
28/// or writable from the host process regardless of whether the process
29/// exists.  This allows the IR interpreter as well as JITted code to access
30/// the same memory.
31///
32/// Point queries against this group of memory objects can be made by the
33/// address in the tar at which they reside.  If the inferior does not
34/// exist, allocations still get made-up addresses.  If an inferior appears
35/// at some point, then those addresses need to be re-mapped.
36//----------------------------------------------------------------------
37class IRMemoryMap
38{
39public:
40    IRMemoryMap (lldb::ProcessSP process_sp);
41    IRMemoryMap (lldb::TargetSP target_sp);
42    ~IRMemoryMap ();
43
44    enum AllocationPolicy {
45        eAllocationPolicyInvalid        = 0,    ///< It is an error for an allocation to have this policy.
46        eAllocationPolicyHostOnly,              ///< This allocation was created in the host and will never make it into the process.
47                                                ///< It is an error to create other types of allocations while such allocations exist.
48        eAllocationPolicyMirror,                ///< The intent is that this allocation exist both in the host and the process and have
49                                                ///< the same content in both.
50        eAllocationPolicyProcessOnly            ///< The intent is that this allocation exist only in the process.
51    };
52
53    lldb::addr_t Malloc (size_t size, uint8_t alignment, uint32_t permissions, AllocationPolicy policy, Error &error);
54    void Free (lldb::addr_t process_address, Error &error);
55
56    void WriteMemory (lldb::addr_t process_address, const uint8_t *bytes, size_t size, Error &error);
57    void WriteScalarToMemory (lldb::addr_t process_address, Scalar &scalar, size_t size, Error &error);
58    void ReadMemory (uint8_t *bytes, lldb::addr_t process_address, size_t size, Error &error);
59    void ReadScalarFromMemory (Scalar &scalar, lldb::addr_t process_address, size_t size, Error &error);
60
61    lldb::ByteOrder GetByteOrder();
62    uint32_t GetAddressByteSize();
63
64    ExecutionContextScope *GetBestExecutionContextScope();
65
66protected:
67    lldb::ProcessWP GetProcessWP ()
68    {
69        return m_process_wp;
70    }
71
72private:
73    struct Allocation
74    {
75        lldb::addr_t    m_process_alloc;    ///< The (unaligned) base for the remote allocation
76        lldb::addr_t    m_process_start;    ///< The base address of the allocation in the process
77        size_t          m_size;             ///< The size of the requested allocation
78        uint32_t        m_permissions;      ///< The access permissions on the memory in the process.  In the host, the memory is always read/write.
79        uint8_t         m_alignment;        ///< The alignment of the requested allocation
80
81        std::unique_ptr<DataBufferHeap> m_data;
82
83        AllocationPolicy    m_policy;
84    };
85
86    lldb::ProcessWP                             m_process_wp;
87    lldb::TargetWP                              m_target_wp;
88    typedef std::map<lldb::addr_t, Allocation>  AllocationMap;
89    AllocationMap                               m_allocations;
90
91    lldb::addr_t FindSpace (size_t size);
92    bool ContainsHostOnlyAllocations ();
93    AllocationMap::iterator FindAllocation (lldb::addr_t addr, size_t size);
94};
95
96}
97
98#endif
99