contrib/llvm/tools/lldb/include/lldb/Target/Memory.h

   1 //===-- Memory.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 liblldb_Memory_h_
  11 #define liblldb_Memory_h_
  12
  13 // C Includes
  14 // C++ Includes
  15 #include <map>
  16 #include <vector>
  17
  18 // Other libraries and framework includes
  19
  20 // Project includes
  21 #include "lldb/lldb-private.h"
  22 #include "lldb/Core/RangeMap.h"
  23 #include "lldb/Host/Mutex.h"
  24
  25 namespace lldb_private {
  26     //----------------------------------------------------------------------
  27     // A class to track memory that was read from a live process between
  28     // runs.
  29     //----------------------------------------------------------------------
  30     class MemoryCache
  31     {
  32     public:
  33         //------------------------------------------------------------------
  34         // Constructors and Destructors
  35         //------------------------------------------------------------------
  36         MemoryCache (Process &process);
  37
  38         ~MemoryCache ();
  39
  40         void
  41         Clear(bool clear_invalid_ranges = false);
  42
  43         void
  44         Flush (lldb::addr_t addr, size_t size);
  45
  46         size_t
  47         Read (lldb::addr_t addr,
  48               void *dst,
  49               size_t dst_len,
  50               Error &error);
  51
  52         uint32_t
  53         GetMemoryCacheLineSize() const
  54         {
  55             return m_cache_line_byte_size ;
  56         }
  57
  58         void
  59         AddInvalidRange (lldb::addr_t base_addr, lldb::addr_t byte_size);
  60
  61         bool
  62         RemoveInvalidRange (lldb::addr_t base_addr, lldb::addr_t byte_size);
  63
  64     protected:
  65         typedef std::map<lldb::addr_t, lldb::DataBufferSP> BlockMap;
  66         typedef RangeArray<lldb::addr_t, lldb::addr_t, 4> InvalidRanges;
  67         //------------------------------------------------------------------
  68         // Classes that inherit from MemoryCache can see and modify these
  69         //------------------------------------------------------------------
  70         Process &m_process;
  71         uint32_t m_cache_line_byte_size;
  72         Mutex m_mutex;
  73         BlockMap m_cache;
  74         InvalidRanges m_invalid_ranges;
  75     private:
  76         DISALLOW_COPY_AND_ASSIGN (MemoryCache);
  77     };
  78
  79
  80     class AllocatedBlock
  81     {
  82     public:
  83         AllocatedBlock (lldb::addr_t addr,
  84                         uint32_t byte_size,
  85                         uint32_t permissions,
  86                         uint32_t chunk_size);
  87
  88         ~AllocatedBlock ();
  89
  90         lldb::addr_t
  91         ReserveBlock (uint32_t size);
  92
  93         bool
  94         FreeBlock (lldb::addr_t addr);
  95
  96         lldb::addr_t
  97         GetBaseAddress () const
  98         {
  99             return m_addr;
 100         }
 101
 102         uint32_t
 103         GetByteSize () const
 104         {
 105             return m_byte_size;
 106         }
 107
 108         uint32_t
 109         GetPermissions () const
 110         {
 111             return m_permissions;
 112         }
 113
 114         uint32_t
 115         GetChunkSize () const
 116         {
 117             return m_chunk_size;
 118         }
 119
 120         bool
 121         Contains (lldb::addr_t addr) const
 122         {
 123             return ((addr >= m_addr) && addr < (m_addr + m_byte_size));
 124         }
 125     protected:
 126         uint32_t
 127         TotalChunks () const
 128         {
 129             return m_byte_size / m_chunk_size;
 130         }
 131
 132         uint32_t
 133         CalculateChunksNeededForSize (uint32_t size) const
 134         {
 135             return (size + m_chunk_size - 1) / m_chunk_size;
 136         }
 137         const lldb::addr_t m_addr;    // Base address of this block of memory
 138         const uint32_t m_byte_size;   // 4GB of chunk should be enough...
 139         const uint32_t m_permissions; // Permissions for this memory (logical OR of lldb::Permissions bits)
 140         const uint32_t m_chunk_size;  // The size of chunks that the memory at m_addr is divied up into
 141         typedef std::map<uint32_t, uint32_t> OffsetToChunkSize;
 142         OffsetToChunkSize m_offset_to_chunk_size;
 143     };
 144
 145
 146     //----------------------------------------------------------------------
 147     // A class that can track allocated memory and give out allocated memory
 148     // without us having to make an allocate/deallocate call every time we
 149     // need some memory in a process that is being debugged.
 150     //----------------------------------------------------------------------
 151     class AllocatedMemoryCache
 152     {
 153     public:
 154         //------------------------------------------------------------------
 155         // Constructors and Destructors
 156         //------------------------------------------------------------------
 157         AllocatedMemoryCache (Process &process);
 158
 159         ~AllocatedMemoryCache ();
 160
 161         void
 162         Clear();
 163
 164         lldb::addr_t
 165         AllocateMemory (size_t byte_size,
 166                         uint32_t permissions,
 167                         Error &error);
 168
 169         bool
 170         DeallocateMemory (lldb::addr_t ptr);
 171
 172     protected:
 173         typedef std::shared_ptr<AllocatedBlock> AllocatedBlockSP;
 174
 175         AllocatedBlockSP
 176         AllocatePage (uint32_t byte_size,
 177                       uint32_t permissions,
 178                       uint32_t chunk_size,
 179                       Error &error);
 180
 181
 182         //------------------------------------------------------------------
 183         // Classes that inherit from MemoryCache can see and modify these
 184         //------------------------------------------------------------------
 185         Process &m_process;
 186         Mutex m_mutex;
 187         typedef std::multimap<uint32_t, AllocatedBlockSP> PermissionsToBlockMap;
 188         PermissionsToBlockMap m_memory_map;
 189
 190     private:
 191         DISALLOW_COPY_AND_ASSIGN (AllocatedMemoryCache);
 192     };
 193
 194 } // namespace lldb_private
 195
 196 #endif  // liblldb_Memory_h_