LLDB mainline
MemoryRegionInfo.h
Go to the documentation of this file.
1//===-- MemoryRegionInfo.h ---------------------------------------*- C++
2//-*-===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef LLDB_TARGET_MEMORYREGIONINFO_H
11#define LLDB_TARGET_MEMORYREGIONINFO_H
12
13#include <optional>
14#include <vector>
15
18#include "llvm/Support/FormatProviders.h"
19
20namespace lldb_private {
22public:
24
25 enum OptionalBool { eDontKnow = -1, eNo = 0, eYes = 1 };
26
27 MemoryRegionInfo() = default;
29 OptionalBool execute, OptionalBool shared,
30 OptionalBool mapped, ConstString name,
31 OptionalBool flash, lldb::offset_t blocksize,
32 OptionalBool memory_tagged, OptionalBool stack_memory)
33 : m_range(range), m_read(read), m_write(write), m_execute(execute),
34 m_shared(shared), m_mapped(mapped), m_name(name), m_flash(flash),
35 m_blocksize(blocksize), m_memory_tagged(memory_tagged),
36 m_is_stack_memory(stack_memory) {}
37
38 RangeType &GetRange() { return m_range; }
39
40 void Clear() { *this = MemoryRegionInfo(); }
41
42 const RangeType &GetRange() const { return m_range; }
43
44 OptionalBool GetReadable() const { return m_read; }
45
46 OptionalBool GetWritable() const { return m_write; }
47
49
50 OptionalBool GetShared() const { return m_shared; }
51
52 OptionalBool GetMapped() const { return m_mapped; }
53
54 ConstString GetName() const { return m_name; }
55
57
58 void SetReadable(OptionalBool val) { m_read = val; }
59
60 void SetWritable(OptionalBool val) { m_write = val; }
61
63
64 void SetShared(OptionalBool val) { m_shared = val; }
65
66 void SetMapped(OptionalBool val) { m_mapped = val; }
67
68 void SetName(const char *name) { m_name = ConstString(name); }
69
70 OptionalBool GetFlash() const { return m_flash; }
71
72 void SetFlash(OptionalBool val) { m_flash = val; }
73
75
76 void SetBlocksize(lldb::offset_t blocksize) { m_blocksize = blocksize; }
77
79
80 // Get permissions as a uint32_t that is a mask of one or more bits from the
81 // lldb::Permissions
82 uint32_t GetLLDBPermissions() const {
83 uint32_t permissions = 0;
84 if (m_read == eYes)
85 permissions |= lldb::ePermissionsReadable;
86 if (m_write == eYes)
87 permissions |= lldb::ePermissionsWritable;
88 if (m_execute == eYes)
89 permissions |= lldb::ePermissionsExecutable;
90 return permissions;
91 }
92
93 // Set permissions from a uint32_t that contains one or more bits from the
94 // lldb::Permissions
95 void SetLLDBPermissions(uint32_t permissions) {
96 m_read = (permissions & lldb::ePermissionsReadable) ? eYes : eNo;
97 m_write = (permissions & lldb::ePermissionsWritable) ? eYes : eNo;
98 m_execute = (permissions & lldb::ePermissionsExecutable) ? eYes : eNo;
99 }
100
101 bool operator==(const MemoryRegionInfo &rhs) const {
102 return m_range == rhs.m_range && m_read == rhs.m_read &&
103 m_write == rhs.m_write && m_execute == rhs.m_execute &&
104 m_shared == rhs.m_shared &&
105 m_mapped == rhs.m_mapped && m_name == rhs.m_name &&
106 m_flash == rhs.m_flash && m_blocksize == rhs.m_blocksize &&
108 m_pagesize == rhs.m_pagesize &&
110 }
111
112 bool operator!=(const MemoryRegionInfo &rhs) const { return !(*this == rhs); }
113
114 /// Get the target system's VM page size in bytes.
115 /// \return
116 /// 0 is returned if this information is unavailable.
117 int GetPageSize() const { return m_pagesize; }
118
119 /// Get a vector of target VM pages that are dirty -- that have been
120 /// modified -- within this memory region. This is an Optional return
121 /// value; it will only be available if the remote stub was able to
122 /// detail this.
123 const std::optional<std::vector<lldb::addr_t>> &GetDirtyPageList() const {
124 return m_dirty_pages;
125 }
126
128
130
131 void SetPageSize(int pagesize) { m_pagesize = pagesize; }
132
133 void SetDirtyPageList(std::vector<lldb::addr_t> pagelist) {
134 if (m_dirty_pages)
135 m_dirty_pages->clear();
136 m_dirty_pages = std::move(pagelist);
137 }
138
139protected:
151 int m_pagesize = 0;
152 std::optional<std::vector<lldb::addr_t>> m_dirty_pages;
153};
154
155inline bool operator<(const MemoryRegionInfo &lhs,
156 const MemoryRegionInfo &rhs) {
157 return lhs.GetRange() < rhs.GetRange();
158}
159
160inline bool operator<(const MemoryRegionInfo &lhs, lldb::addr_t rhs) {
161 return lhs.GetRange().GetRangeBase() < rhs;
162}
163
164inline bool operator<(lldb::addr_t lhs, const MemoryRegionInfo &rhs) {
165 return lhs < rhs.GetRange().GetRangeBase();
166}
167
168llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
169 const MemoryRegionInfo &Info);
170
171// Forward-declarable wrapper.
172class MemoryRegionInfos : public std::vector<lldb_private::MemoryRegionInfo> {
173public:
174 using std::vector<lldb_private::MemoryRegionInfo>::vector;
175};
176
177}
178
179namespace llvm {
180template <>
181/// If Options is empty, prints a textual representation of the value. If
182/// Options is a single character, it uses that character for the "yes" value,
183/// while "no" is printed as "-", and "don't know" as "?". This can be used to
184/// print the permissions in the traditional "rwx" form.
185struct format_provider<lldb_private::MemoryRegionInfo::OptionalBool> {
187 raw_ostream &OS, StringRef Options);
188};
189}
190
191#endif // LLDB_TARGET_MEMORYREGIONINFO_H
A uniqued constant string class.
Definition: ConstString.h:40
void SetFlash(OptionalBool val)
OptionalBool GetWritable() const
void SetMapped(OptionalBool val)
OptionalBool GetMapped() const
int GetPageSize() const
Get the target system's VM page size in bytes.
MemoryRegionInfo(RangeType range, OptionalBool read, OptionalBool write, OptionalBool execute, OptionalBool shared, OptionalBool mapped, ConstString name, OptionalBool flash, lldb::offset_t blocksize, OptionalBool memory_tagged, OptionalBool stack_memory)
void SetBlocksize(lldb::offset_t blocksize)
bool operator!=(const MemoryRegionInfo &rhs) const
void SetMemoryTagged(OptionalBool val)
void SetReadable(OptionalBool val)
void SetExecutable(OptionalBool val)
std::optional< std::vector< lldb::addr_t > > m_dirty_pages
void SetIsStackMemory(OptionalBool val)
OptionalBool GetMemoryTagged() const
void SetName(const char *name)
bool operator==(const MemoryRegionInfo &rhs) const
Range< lldb::addr_t, lldb::addr_t > RangeType
void SetWritable(OptionalBool val)
lldb::offset_t GetBlocksize() const
OptionalBool IsStackMemory() const
const RangeType & GetRange() const
const std::optional< std::vector< lldb::addr_t > > & GetDirtyPageList() const
Get a vector of target VM pages that are dirty – that have been modified – within this memory region.
void SetDirtyPageList(std::vector< lldb::addr_t > pagelist)
OptionalBool GetReadable() const
OptionalBool GetExecutable() const
void SetLLDBPermissions(uint32_t permissions)
OptionalBool GetShared() const
OptionalBool GetFlash() const
void SetShared(OptionalBool val)
A class that represents a running process on the host machine.
Stream & operator<<(Stream &s, const Mangled &obj)
bool operator<(const Address &lhs, const Address &rhs)
Definition: Address.cpp:992
uint64_t offset_t
Definition: lldb-types.h:85
uint64_t addr_t
Definition: lldb-types.h:80
Definition: Debugger.h:54
BaseType GetRangeBase() const
Definition: RangeMap.h:45
static void format(const lldb_private::MemoryRegionInfo::OptionalBool &B, raw_ostream &OS, StringRef Options)