LLDB  mainline
Memory.h
Go to the documentation of this file.
1 //===-- Memory.h ------------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef LLDB_TARGET_MEMORY_H
10 #define LLDB_TARGET_MEMORY_H
11 
12 #include "lldb/Utility/RangeMap.h"
13 #include "lldb/lldb-private.h"
14 #include <map>
15 #include <mutex>
16 #include <vector>
17 
18 namespace lldb_private {
19 // A class to track memory that was read from a live process between
20 // runs.
21 class MemoryCache {
22 public:
23  // Constructors and Destructors
24  MemoryCache(Process &process);
25 
26  ~MemoryCache();
27 
28  void Clear(bool clear_invalid_ranges = false);
29 
30  void Flush(lldb::addr_t addr, size_t size);
31 
32  size_t Read(lldb::addr_t addr, void *dst, size_t dst_len, Status &error);
33 
35 
36  void AddInvalidRange(lldb::addr_t base_addr, lldb::addr_t byte_size);
37 
38  bool RemoveInvalidRange(lldb::addr_t base_addr, lldb::addr_t byte_size);
39 
40  // Allow external sources to populate data into the L1 memory cache
41  void AddL1CacheData(lldb::addr_t addr, const void *src, size_t src_len);
42 
43  void AddL1CacheData(lldb::addr_t addr,
44  const lldb::DataBufferSP &data_buffer_sp);
45 
46 protected:
47  typedef std::map<lldb::addr_t, lldb::DataBufferSP> BlockMap;
50  // Classes that inherit from MemoryCache can see and modify these
51  std::recursive_mutex m_mutex;
52  BlockMap m_L1_cache; // A first level memory cache whose chunk sizes vary that
53  // will be used only if the memory read fits entirely in
54  // a chunk
55  BlockMap m_L2_cache; // A memory cache of fixed size chinks
56  // (m_L2_cache_line_byte_size bytes in size each)
57  InvalidRanges m_invalid_ranges;
60 
61 private:
62  MemoryCache(const MemoryCache &) = delete;
63  const MemoryCache &operator=(const MemoryCache &) = delete;
64 };
65 
66 
67 
69 public:
70  AllocatedBlock(lldb::addr_t addr, uint32_t byte_size, uint32_t permissions,
71  uint32_t chunk_size);
72 
73  ~AllocatedBlock();
74 
75  lldb::addr_t ReserveBlock(uint32_t size);
76 
77  bool FreeBlock(lldb::addr_t addr);
78 
79  lldb::addr_t GetBaseAddress() const { return m_range.GetRangeBase(); }
80 
81  uint32_t GetByteSize() const { return m_range.GetByteSize(); }
82 
83  uint32_t GetPermissions() const { return m_permissions; }
84 
85  uint32_t GetChunkSize() const { return m_chunk_size; }
86 
87  bool Contains(lldb::addr_t addr) const {
88  return m_range.Contains(addr);
89  }
90 
91 protected:
92  uint32_t TotalChunks() const { return GetByteSize() / GetChunkSize(); }
93 
95  return (size + m_chunk_size - 1) / m_chunk_size;
96  }
97  // Base address of this block of memory 4GB of chunk should be enough.
99  // Permissions for this memory (logical OR of lldb::Permissions bits)
101  // The size of chunks that the memory at m_addr is divied up into.
103  // A sorted list of free address ranges.
105  // A sorted list of reserved address.
107 };
108 
109 // A class that can track allocated memory and give out allocated memory
110 // without us having to make an allocate/deallocate call every time we need
111 // some memory in a process that is being debugged.
113 public:
114  // Constructors and Destructors
115  AllocatedMemoryCache(Process &process);
116 
118 
119  void Clear();
120 
121  lldb::addr_t AllocateMemory(size_t byte_size, uint32_t permissions,
122  Status &error);
123 
124  bool DeallocateMemory(lldb::addr_t ptr);
125 
126 protected:
127  typedef std::shared_ptr<AllocatedBlock> AllocatedBlockSP;
128 
129  AllocatedBlockSP AllocatePage(uint32_t byte_size, uint32_t permissions,
130  uint32_t chunk_size, Status &error);
131 
132  // Classes that inherit from MemoryCache can see and modify these
134  std::recursive_mutex m_mutex;
135  typedef std::multimap<uint32_t, AllocatedBlockSP> PermissionsToBlockMap;
136  PermissionsToBlockMap m_memory_map;
137 
138 private:
139  AllocatedMemoryCache(const AllocatedMemoryCache &) = delete;
140  const AllocatedMemoryCache &operator=(const AllocatedMemoryCache &) = delete;
141 };
142 
143 } // namespace lldb_private
144 
145 #endif // LLDB_TARGET_MEMORY_H
RangeVector< lldb::addr_t, uint32_t > m_free_blocks
Definition: Memory.h:104
bool RemoveInvalidRange(lldb::addr_t base_addr, lldb::addr_t byte_size)
Definition: Memory.cpp:110
A class that represents a running process on the host machine.
void AddInvalidRange(lldb::addr_t base_addr, lldb::addr_t byte_size)
Definition: Memory.cpp:100
uint32_t CalculateChunksNeededForSize(uint32_t size) const
Definition: Memory.h:94
const uint32_t m_chunk_size
Definition: Memory.h:102
void Flush(lldb::addr_t addr, size_t size)
Definition: Memory.cpp:52
std::map< lldb::addr_t, lldb::DataBufferSP > BlockMap
Definition: Memory.h:47
const uint32_t m_permissions
Definition: Memory.h:100
const MemoryCache & operator=(const MemoryCache &)=delete
std::recursive_mutex m_mutex
Definition: Memory.h:51
uint32_t GetPermissions() const
Definition: Memory.h:83
uint32_t GetMemoryCacheLineSize() const
Definition: Memory.h:34
void Clear(bool clear_invalid_ranges=false)
Definition: Memory.cpp:31
static llvm::raw_ostream & error(Stream &strm)
size_t Read(lldb::addr_t addr, void *dst, size_t dst_len, Status &error)
Definition: Memory.cpp:125
MemoryCache(Process &process)
Definition: Memory.cpp:23
bool Contains(lldb::addr_t addr) const
Definition: Memory.h:87
InvalidRanges m_invalid_ranges
Definition: Memory.h:57
RangeVector< lldb::addr_t, lldb::addr_t, 4 > InvalidRanges
Definition: Memory.h:48
A plug-in interface definition class for debugging a process.
Definition: Process.h:362
std::shared_ptr< AllocatedBlock > AllocatedBlockSP
Definition: Memory.h:127
RangeVector< lldb::addr_t, uint32_t > m_reserved_blocks
Definition: Memory.h:106
lldb::addr_t GetBaseAddress() const
Definition: Memory.h:79
PermissionsToBlockMap m_memory_map
Definition: Memory.h:136
uint64_t addr_t
Definition: lldb-types.h:83
uint32_t TotalChunks() const
Definition: Memory.h:92
std::multimap< uint32_t, AllocatedBlockSP > PermissionsToBlockMap
Definition: Memory.h:135
Range< lldb::addr_t, uint32_t > m_range
Definition: Memory.h:98
uint32_t m_L2_cache_line_byte_size
Definition: Memory.h:59
void AddL1CacheData(lldb::addr_t addr, const void *src, size_t src_len)
Definition: Memory.cpp:40
Range< lldb::addr_t, lldb::addr_t > AddrRange
Definition: Memory.h:49
std::recursive_mutex m_mutex
Definition: Memory.h:134
uint32_t GetChunkSize() const
Definition: Memory.h:85
uint32_t GetByteSize() const
Definition: Memory.h:81
An error handling class.
Definition: Status.h:44