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 <vector>
14 
15 #include "lldb/Utility/ConstString.h"
16 #include "lldb/Utility/RangeMap.h"
17 #include "llvm/ADT/Optional.h"
18 #include "llvm/Support/FormatProviders.h"
19 
20 namespace lldb_private {
21 class MemoryRegionInfo {
22 public:
23   typedef Range<lldb::addr_t, lldb::addr_t> RangeType;
24 
25   enum OptionalBool { eDontKnow = -1, eNo = 0, eYes = 1 };
26 
27   MemoryRegionInfo() = default;
28   MemoryRegionInfo(RangeType range, OptionalBool read, OptionalBool write,
29                    OptionalBool execute, OptionalBool mapped, ConstString name,
30                    OptionalBool flash, lldb::offset_t blocksize,
31                    OptionalBool memory_tagged, OptionalBool stack_memory)
32       : m_range(range), m_read(read), m_write(write), m_execute(execute),
33         m_mapped(mapped), m_name(name), m_flash(flash), m_blocksize(blocksize),
34         m_memory_tagged(memory_tagged), m_is_stack_memory(stack_memory) {}
35 
36   RangeType &GetRange() { return m_range; }
37 
38   void Clear() { *this = MemoryRegionInfo(); }
39 
40   const RangeType &GetRange() const { return m_range; }
41 
42   OptionalBool GetReadable() const { return m_read; }
43 
44   OptionalBool GetWritable() const { return m_write; }
45 
46   OptionalBool GetExecutable() const { return m_execute; }
47 
48   OptionalBool GetMapped() const { return m_mapped; }
49 
50   ConstString GetName() const { return m_name; }
51 
52   OptionalBool GetMemoryTagged() const { return m_memory_tagged; }
53 
54   void SetReadable(OptionalBool val) { m_read = val; }
55 
56   void SetWritable(OptionalBool val) { m_write = val; }
57 
58   void SetExecutable(OptionalBool val) { m_execute = val; }
59 
60   void SetMapped(OptionalBool val) { m_mapped = val; }
61 
62   void SetName(const char *name) { m_name = ConstString(name); }
63 
64   OptionalBool GetFlash() const { return m_flash; }
65 
66   void SetFlash(OptionalBool val) { m_flash = val; }
67 
68   lldb::offset_t GetBlocksize() const { return m_blocksize; }
69 
70   void SetBlocksize(lldb::offset_t blocksize) { m_blocksize = blocksize; }
71 
72   void SetMemoryTagged(OptionalBool val) { m_memory_tagged = val; }
73 
74   // Get permissions as a uint32_t that is a mask of one or more bits from the
75   // lldb::Permissions
76   uint32_t GetLLDBPermissions() const {
77     uint32_t permissions = 0;
78     if (m_read)
79       permissions |= lldb::ePermissionsReadable;
80     if (m_write)
81       permissions |= lldb::ePermissionsWritable;
82     if (m_execute)
83       permissions |= lldb::ePermissionsExecutable;
84     return permissions;
85   }
86 
87   // Set permissions from a uint32_t that contains one or more bits from the
88   // lldb::Permissions
89   void SetLLDBPermissions(uint32_t permissions) {
90     m_read = (permissions & lldb::ePermissionsReadable) ? eYes : eNo;
91     m_write = (permissions & lldb::ePermissionsWritable) ? eYes : eNo;
92     m_execute = (permissions & lldb::ePermissionsExecutable) ? eYes : eNo;
93   }
94 
95   bool operator==(const MemoryRegionInfo &rhs) const {
96     return m_range == rhs.m_range && m_read == rhs.m_read &&
97            m_write == rhs.m_write && m_execute == rhs.m_execute &&
98            m_mapped == rhs.m_mapped && m_name == rhs.m_name &&
99            m_flash == rhs.m_flash && m_blocksize == rhs.m_blocksize &&
100            m_memory_tagged == rhs.m_memory_tagged &&
101            m_pagesize == rhs.m_pagesize &&
102            m_is_stack_memory == rhs.m_is_stack_memory;
103   }
104 
105   bool operator!=(const MemoryRegionInfo &rhs) const { return !(*this == rhs); }
106 
107   /// Get the target system's VM page size in bytes.
108   /// \return
109   ///     0 is returned if this information is unavailable.
110   int GetPageSize() { return m_pagesize; }
111 
112   /// Get a vector of target VM pages that are dirty -- that have been
113   /// modified -- within this memory region.  This is an Optional return
114   /// value; it will only be available if the remote stub was able to
115   /// detail this.
116   llvm::Optional<std::vector<lldb::addr_t>> &GetDirtyPageList() {
117     return m_dirty_pages;
118   }
119 
120   OptionalBool IsStackMemory() const { return m_is_stack_memory; }
121 
122   void SetIsStackMemory(OptionalBool val) { m_is_stack_memory = val; }
123 
124   void SetPageSize(int pagesize) { m_pagesize = pagesize; }
125 
126   void SetDirtyPageList(std::vector<lldb::addr_t> pagelist) {
127     if (m_dirty_pages.hasValue())
128       m_dirty_pages.getValue().clear();
129     m_dirty_pages = std::move(pagelist);
130   }
131 
132 protected:
133   RangeType m_range;
134   OptionalBool m_read = eDontKnow;
135   OptionalBool m_write = eDontKnow;
136   OptionalBool m_execute = eDontKnow;
137   OptionalBool m_mapped = eDontKnow;
138   ConstString m_name;
139   OptionalBool m_flash = eDontKnow;
140   lldb::offset_t m_blocksize = 0;
141   OptionalBool m_memory_tagged = eDontKnow;
142   OptionalBool m_is_stack_memory = eDontKnow;
143   int m_pagesize = 0;
144   llvm::Optional<std::vector<lldb::addr_t>> m_dirty_pages;
145 };
146 
147 inline bool operator<(const MemoryRegionInfo &lhs,
148                       const MemoryRegionInfo &rhs) {
149   return lhs.GetRange() < rhs.GetRange();
150 }
151 
152 inline bool operator<(const MemoryRegionInfo &lhs, lldb::addr_t rhs) {
153   return lhs.GetRange().GetRangeBase() < rhs;
154 }
155 
156 inline bool operator<(lldb::addr_t lhs, const MemoryRegionInfo &rhs) {
157   return lhs < rhs.GetRange().GetRangeBase();
158 }
159 
160 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
161                               const MemoryRegionInfo &Info);
162 
163 // Forward-declarable wrapper.
164 class MemoryRegionInfos : public std::vector<lldb_private::MemoryRegionInfo> {
165 public:
166   //using std::vector<lldb_private::MemoryRegionInfo>::vector;
167 };
168 
169 }
170 
171 namespace llvm {
172 template <>
173 /// If Options is empty, prints a textual representation of the value. If
174 /// Options is a single character, it uses that character for the "yes" value,
175 /// while "no" is printed as "-", and "don't know" as "?". This can be used to
176 /// print the permissions in the traditional "rwx" form.
177 struct format_provider<lldb_private::MemoryRegionInfo::OptionalBool> {
178   static void format(const lldb_private::MemoryRegionInfo::OptionalBool &B,
179                      raw_ostream &OS, StringRef Options);
180 };
181 }
182 
183 #endif // LLDB_TARGET_MEMORYREGIONINFO_H
184