contrib/llvm/tools/lldb/include/lldb/Expression/IRMemoryMap.h

   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
  19 namespace 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 //----------------------------------------------------------------------
  37 class IRMemoryMap
  38 {
  39 public:
  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
  71 protected:
  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
  79 private:
  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