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 Leak (lldb::addr_t process_address, 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 WritePointerToMemory (lldb::addr_t process_address, lldb::addr_t address, Error &error);
59    void ReadMemory (uint8_t *bytes, lldb::addr_t process_address, size_t size, Error &error);
60    void ReadScalarFromMemory (Scalar &scalar, lldb::addr_t process_address, size_t size, Error &error);
61    void ReadPointerFromMemory (lldb::addr_t *address, lldb::addr_t process_address, Error &error);
62
63    void GetMemoryData (DataExtractor &extractor, lldb::addr_t process_address, size_t size, Error &error);
64
65    lldb::ByteOrder GetByteOrder();
66    uint32_t GetAddressByteSize();
67
68    // This function can return NULL.
69    ExecutionContextScope *GetBestExecutionContextScope();
70
71protected:
72    // This function should only be used if you know you are using the JIT.
73    // Any other cases should use GetBestExecutionContextScope().
74    lldb::ProcessWP GetProcessWP ()
75    {
76        return m_process_wp;
77    }
78
79private:
80    struct Allocation
81    {
82        lldb::addr_t    m_process_alloc;    ///< The (unaligned) base for the remote allocation
83        lldb::addr_t    m_process_start;    ///< The base address of the allocation in the process
84        size_t          m_size;             ///< The size of the requested allocation
85        uint32_t        m_permissions;      ///< The access permissions on the memory in the process.  In the host, the memory is always read/write.
86        uint8_t         m_alignment;        ///< The alignment of the requested allocation
87        DataBufferHeap  m_data;
88
89        ///< Flags
90        AllocationPolicy    m_policy;
91        bool                m_leak;
92    public:
93        Allocation (lldb::addr_t process_alloc,
94                    lldb::addr_t process_start,
95                    size_t size,
96                    uint32_t permissions,
97                    uint8_t alignment,
98                    AllocationPolicy m_policy);
99
100        Allocation () :
101            m_process_alloc (LLDB_INVALID_ADDRESS),
102            m_process_start (LLDB_INVALID_ADDRESS),
103            m_size (0),
104            m_permissions (0),
105            m_alignment (0),
106            m_data (),
107            m_policy (eAllocationPolicyInvalid),
108            m_leak (false)
109        {
110        }
111    };
112
113    lldb::ProcessWP                             m_process_wp;
114    lldb::TargetWP                              m_target_wp;
115    typedef std::map<lldb::addr_t, Allocation>  AllocationMap;
116    AllocationMap                               m_allocations;
117
118    lldb::addr_t FindSpace (size_t size);
119    bool ContainsHostOnlyAllocations ();
120    AllocationMap::iterator FindAllocation (lldb::addr_t addr, size_t size);
121    bool IntersectsAllocation (lldb::addr_t addr, size_t size);
122};
123
124}
125
126#endif
127