IRMemoryMap.h revision 102b2c2681c9a830afe25bfea35557421905e42c 
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::TargetSP target_sp);
41    ~IRMemoryMap ();
42
43    enum AllocationPolicy {
44        eAllocationPolicyInvalid        = 0,    ///< It is an error for an allocation to have this policy.
45        eAllocationPolicyHostOnly,              ///< This allocation was created in the host and will never make it into the process.
46                                                ///< It is an error to create other types of allocations while such allocations exist.
47        eAllocationPolicyMirror,                ///< The intent is that this allocation exist both in the host and the process and have
48                                                ///< the same content in both.
49        eAllocationPolicyProcessOnly            ///< The intent is that this allocation exist only in the process.
50    };
51
52    lldb::addr_t Malloc (size_t size, uint8_t alignment, uint32_t permissions, AllocationPolicy policy, Error &error);
53    void Free (lldb::addr_t process_address, Error &error);
54
55    void WriteMemory (lldb::addr_t process_address, const uint8_t *bytes, size_t size, Error &error);
56    void WriteScalarToMemory (lldb::addr_t process_address, Scalar &scalar, size_t size, Error &error);
57    void WritePointerToMemory (lldb::addr_t process_address, lldb::addr_t address, 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    void ReadPointerFromMemory (lldb::addr_t *address, lldb::addr_t process_address, Error &error);
61
62    void GetMemoryData (DataExtractor &extractor, lldb::addr_t process_address, size_t size, Error &error);
63
64    lldb::ByteOrder GetByteOrder();
65    uint32_t GetAddressByteSize();
66
67    // This function can return NULL.
68    ExecutionContextScope *GetBestExecutionContextScope();
69
70protected:
71    // This function should only be used if you know you are using the JIT.
72    // Any other cases should use GetBestExecutionContextScope().
73    lldb::ProcessWP GetProcessWP ()
74    {
75        return m_process_wp;
76    }
77
78private:
79    struct Allocation
80    {
81        lldb::addr_t    m_process_alloc;    ///< The (unaligned) base for the remote allocation
82        lldb::addr_t    m_process_start;    ///< The base address of the allocation in the process
83        size_t          m_size;             ///< The size of the requested allocation
84        uint32_t        m_permissions;      ///< The access permissions on the memory in the process.  In the host, the memory is always read/write.
85        uint8_t         m_alignment;        ///< The alignment of the requested allocation
86        std::unique_ptr<DataBufferHeap> m_data_ap;
87        AllocationPolicy    m_policy;
88
89        Allocation () :
90            m_process_alloc (LLDB_INVALID_ADDRESS),
91            m_process_start (LLDB_INVALID_ADDRESS),
92            m_size (0),
93            m_permissions (0),
94            m_alignment (0),
95            m_data_ap (),
96            m_policy (eAllocationPolicyInvalid)
97        {
98        }
99    };
100
101    lldb::ProcessWP                             m_process_wp;
102    lldb::TargetWP                              m_target_wp;
103    typedef std::map<lldb::addr_t, Allocation>  AllocationMap;
104    AllocationMap                               m_allocations;
105
106    lldb::addr_t FindSpace (size_t size);
107    bool ContainsHostOnlyAllocations ();
108    AllocationMap::iterator FindAllocation (lldb::addr_t addr, size_t size);
109};
110
111}
112
113#endif
114