1 //===-- SBMemoryRegionInfo.cpp --------------------------------------------===//
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 #include "lldb/API/SBMemoryRegionInfo.h"
10 #include "SBReproducerPrivate.h"
11 #include "Utils.h"
12 #include "lldb/API/SBDefines.h"
13 #include "lldb/API/SBError.h"
14 #include "lldb/API/SBStream.h"
15 #include "lldb/Target/MemoryRegionInfo.h"
16 #include "lldb/Utility/StreamString.h"
17
18 using namespace lldb;
19 using namespace lldb_private;
20
SBMemoryRegionInfo()21 SBMemoryRegionInfo::SBMemoryRegionInfo() : m_opaque_up(new MemoryRegionInfo()) {
22 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfo);
23 }
24
SBMemoryRegionInfo(const MemoryRegionInfo * lldb_object_ptr)25 SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr)
26 : m_opaque_up(new MemoryRegionInfo()) {
27 if (lldb_object_ptr)
28 ref() = *lldb_object_ptr;
29 }
30
SBMemoryRegionInfo(const SBMemoryRegionInfo & rhs)31 SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs)
32 : m_opaque_up() {
33 LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfo,
34 (const lldb::SBMemoryRegionInfo &), rhs);
35 m_opaque_up = clone(rhs.m_opaque_up);
36 }
37
38 const SBMemoryRegionInfo &SBMemoryRegionInfo::
operator =(const SBMemoryRegionInfo & rhs)39 operator=(const SBMemoryRegionInfo &rhs) {
40 LLDB_RECORD_METHOD(
41 const lldb::SBMemoryRegionInfo &,
42 SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &), rhs);
43
44 if (this != &rhs)
45 m_opaque_up = clone(rhs.m_opaque_up);
46 return LLDB_RECORD_RESULT(*this);
47 }
48
49 SBMemoryRegionInfo::~SBMemoryRegionInfo() = default;
50
Clear()51 void SBMemoryRegionInfo::Clear() {
52 LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfo, Clear);
53
54 m_opaque_up->Clear();
55 }
56
operator ==(const SBMemoryRegionInfo & rhs) const57 bool SBMemoryRegionInfo::operator==(const SBMemoryRegionInfo &rhs) const {
58 LLDB_RECORD_METHOD_CONST(
59 bool, SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &),
60 rhs);
61
62 return ref() == rhs.ref();
63 }
64
operator !=(const SBMemoryRegionInfo & rhs) const65 bool SBMemoryRegionInfo::operator!=(const SBMemoryRegionInfo &rhs) const {
66 LLDB_RECORD_METHOD_CONST(
67 bool, SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &),
68 rhs);
69
70 return ref() != rhs.ref();
71 }
72
ref()73 MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_up; }
74
ref() const75 const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; }
76
GetRegionBase()77 lldb::addr_t SBMemoryRegionInfo::GetRegionBase() {
78 LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase);
79
80 return m_opaque_up->GetRange().GetRangeBase();
81 }
82
GetRegionEnd()83 lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() {
84 LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd);
85
86 return m_opaque_up->GetRange().GetRangeEnd();
87 }
88
IsReadable()89 bool SBMemoryRegionInfo::IsReadable() {
90 LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsReadable);
91
92 return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes;
93 }
94
IsWritable()95 bool SBMemoryRegionInfo::IsWritable() {
96 LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsWritable);
97
98 return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes;
99 }
100
IsExecutable()101 bool SBMemoryRegionInfo::IsExecutable() {
102 LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsExecutable);
103
104 return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes;
105 }
106
IsMapped()107 bool SBMemoryRegionInfo::IsMapped() {
108 LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsMapped);
109
110 return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes;
111 }
112
GetName()113 const char *SBMemoryRegionInfo::GetName() {
114 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName);
115
116 return m_opaque_up->GetName().AsCString();
117 }
118
HasDirtyMemoryPageList()119 bool SBMemoryRegionInfo::HasDirtyMemoryPageList() {
120 LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, HasDirtyMemoryPageList);
121
122 return m_opaque_up->GetDirtyPageList().hasValue();
123 }
124
GetNumDirtyPages()125 uint32_t SBMemoryRegionInfo::GetNumDirtyPages() {
126 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBMemoryRegionInfo, GetNumDirtyPages);
127
128 uint32_t num_dirty_pages = 0;
129 llvm::Optional<std::vector<addr_t>> dirty_page_list =
130 m_opaque_up->GetDirtyPageList();
131 if (dirty_page_list.hasValue())
132 num_dirty_pages = dirty_page_list.getValue().size();
133
134 return num_dirty_pages;
135 }
136
GetDirtyPageAddressAtIndex(uint32_t idx)137 addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) {
138 LLDB_RECORD_METHOD(addr_t, SBMemoryRegionInfo, GetDirtyPageAddressAtIndex,
139 (uint32_t), idx);
140
141 addr_t dirty_page_addr = LLDB_INVALID_ADDRESS;
142 const llvm::Optional<std::vector<addr_t>> &dirty_page_list =
143 m_opaque_up->GetDirtyPageList();
144 if (dirty_page_list.hasValue() && idx < dirty_page_list.getValue().size())
145 dirty_page_addr = dirty_page_list.getValue()[idx];
146
147 return dirty_page_addr;
148 }
149
GetPageSize()150 int SBMemoryRegionInfo::GetPageSize() {
151 LLDB_RECORD_METHOD_NO_ARGS(int, SBMemoryRegionInfo, GetPageSize);
152 return m_opaque_up->GetPageSize();
153 }
154
GetDescription(SBStream & description)155 bool SBMemoryRegionInfo::GetDescription(SBStream &description) {
156 LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription,
157 (lldb::SBStream &), description);
158
159 Stream &strm = description.ref();
160 const addr_t load_addr = m_opaque_up->GetRange().base;
161
162 strm.Printf("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 " ", load_addr,
163 load_addr + m_opaque_up->GetRange().size);
164 strm.Printf(m_opaque_up->GetReadable() ? "R" : "-");
165 strm.Printf(m_opaque_up->GetWritable() ? "W" : "-");
166 strm.Printf(m_opaque_up->GetExecutable() ? "X" : "-");
167 strm.Printf("]");
168
169 return true;
170 }
171
172 namespace lldb_private {
173 namespace repro {
174
175 template <>
RegisterMethods(Registry & R)176 void RegisterMethods<SBMemoryRegionInfo>(Registry &R) {
177 LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ());
178 LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo,
179 (const lldb::SBMemoryRegionInfo &));
180 LLDB_REGISTER_METHOD(
181 const lldb::SBMemoryRegionInfo &,
182 SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &));
183 LLDB_REGISTER_METHOD(void, SBMemoryRegionInfo, Clear, ());
184 LLDB_REGISTER_METHOD_CONST(
185 bool,
186 SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &));
187 LLDB_REGISTER_METHOD_CONST(
188 bool,
189 SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &));
190 LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase, ());
191 LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd, ());
192 LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsReadable, ());
193 LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsWritable, ());
194 LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsExecutable, ());
195 LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsMapped, ());
196 LLDB_REGISTER_METHOD(const char *, SBMemoryRegionInfo, GetName, ());
197 LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetDescription,
198 (lldb::SBStream &));
199 }
200
201 }
202 }
203