[Lldb-commits] [lldb] 2e51fda - [lldb] Replace OptionalBool with LazyBool (#189652)
via lldb-commits
lldb-commits at lists.llvm.org
Wed Apr 1 01:26:08 PDT 2026
Author: David Spickett
Date: 2026-04-01T09:26:02+01:00
New Revision: 2e51fdaa774be8e0d6b4d6743a2f77cdb3a71e3c
URL: https://github.com/llvm/llvm-project/commit/2e51fdaa774be8e0d6b4d6743a2f77cdb3a71e3c
DIFF: https://github.com/llvm/llvm-project/commit/2e51fdaa774be8e0d6b4d6743a2f77cdb3a71e3c.diff
LOG: [lldb] Replace OptionalBool with LazyBool (#189652)
The only difference between them is that OptionalBool's third state
is "unknown" and LazyBool's is "calculate". We don't need to tell
the difference in a single context, so I've made a new eLazyBoolDontKnow
which is an alias of eLazyBoolCalculate.
Added:
Modified:
lldb/include/lldb/Target/MemoryRegionInfo.h
lldb/include/lldb/lldb-private-enumerations.h
lldb/source/API/SBMemoryRegionInfo.cpp
lldb/source/Commands/CommandObjectMemory.cpp
lldb/source/Expression/IRMemoryMap.cpp
lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp
lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp
lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp
lldb/source/Plugins/Process/Utility/LinuxProcMaps.cpp
lldb/source/Plugins/Process/Utility/MemoryTagManagerAArch64MTE.cpp
lldb/source/Plugins/Process/Windows/Common/ProcessDebugger.cpp
lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp
lldb/source/Plugins/Process/minidump/MinidumpParser.cpp
lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp
lldb/source/Target/MemoryRegionInfo.cpp
lldb/source/Target/Process.cpp
lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp
lldb/unittests/Process/Utility/MemoryTagManagerAArch64MTETest.cpp
lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
lldb/unittests/Process/minidump/MinidumpParserTest.cpp
lldb/unittests/Target/MemoryRegionInfoTest.cpp
Removed:
################################################################################
diff --git a/lldb/include/lldb/Target/MemoryRegionInfo.h b/lldb/include/lldb/Target/MemoryRegionInfo.h
index 527461dd91e91..d6bbe92e0ab58 100644
--- a/lldb/include/lldb/Target/MemoryRegionInfo.h
+++ b/lldb/include/lldb/Target/MemoryRegionInfo.h
@@ -22,12 +22,10 @@ class MemoryRegionInfo {
public:
typedef Range<lldb::addr_t, lldb::addr_t> RangeType;
- enum OptionalBool { eDontKnow = -1, eNo = 0, eYes = 1 };
-
MemoryRegionInfo() = default;
- MemoryRegionInfo(RangeType range, OptionalBool read, OptionalBool write,
- OptionalBool execute, OptionalBool shared,
- OptionalBool mapped, ConstString name)
+ MemoryRegionInfo(RangeType range, LazyBool read, LazyBool write,
+ LazyBool execute, LazyBool shared, LazyBool mapped,
+ ConstString name)
: m_range(range), m_read(read), m_write(write), m_execute(execute),
m_shared(shared), m_mapped(mapped), m_name(name) {}
@@ -37,48 +35,48 @@ class MemoryRegionInfo {
const RangeType &GetRange() const { return m_range; }
- OptionalBool GetReadable() const { return m_read; }
+ LazyBool GetReadable() const { return m_read; }
- OptionalBool GetWritable() const { return m_write; }
+ LazyBool GetWritable() const { return m_write; }
- OptionalBool GetExecutable() const { return m_execute; }
+ LazyBool GetExecutable() const { return m_execute; }
- OptionalBool GetShared() const { return m_shared; }
+ LazyBool GetShared() const { return m_shared; }
- OptionalBool GetMapped() const { return m_mapped; }
+ LazyBool GetMapped() const { return m_mapped; }
ConstString GetName() const { return m_name; }
- OptionalBool GetMemoryTagged() const { return m_memory_tagged; }
+ LazyBool GetMemoryTagged() const { return m_memory_tagged; }
- OptionalBool IsShadowStack() const { return m_is_shadow_stack; }
+ LazyBool IsShadowStack() const { return m_is_shadow_stack; }
- void SetReadable(OptionalBool val) { m_read = val; }
+ void SetReadable(LazyBool val) { m_read = val; }
- void SetWritable(OptionalBool val) { m_write = val; }
+ void SetWritable(LazyBool val) { m_write = val; }
- void SetExecutable(OptionalBool val) { m_execute = val; }
+ void SetExecutable(LazyBool val) { m_execute = val; }
- void SetShared(OptionalBool val) { m_shared = val; }
+ void SetShared(LazyBool val) { m_shared = val; }
- void SetMapped(OptionalBool val) { m_mapped = val; }
+ void SetMapped(LazyBool val) { m_mapped = val; }
void SetName(const char *name) { m_name = ConstString(name); }
- OptionalBool GetFlash() const { return m_flash; }
+ LazyBool GetFlash() const { return m_flash; }
- void SetFlash(OptionalBool val) { m_flash = val; }
+ void SetFlash(LazyBool val) { m_flash = val; }
lldb::offset_t GetBlocksize() const { return m_blocksize; }
void SetBlocksize(lldb::offset_t blocksize) { m_blocksize = blocksize; }
- MemoryRegionInfo &SetMemoryTagged(OptionalBool val) {
+ MemoryRegionInfo &SetMemoryTagged(LazyBool val) {
m_memory_tagged = val;
return *this;
}
- MemoryRegionInfo &SetIsShadowStack(OptionalBool val) {
+ MemoryRegionInfo &SetIsShadowStack(LazyBool val) {
m_is_shadow_stack = val;
return *this;
}
@@ -87,11 +85,11 @@ class MemoryRegionInfo {
// lldb::Permissions
uint32_t GetLLDBPermissions() const {
uint32_t permissions = 0;
- if (m_read == eYes)
+ if (m_read == eLazyBoolYes)
permissions |= lldb::ePermissionsReadable;
- if (m_write == eYes)
+ if (m_write == eLazyBoolYes)
permissions |= lldb::ePermissionsWritable;
- if (m_execute == eYes)
+ if (m_execute == eLazyBoolYes)
permissions |= lldb::ePermissionsExecutable;
return permissions;
}
@@ -99,9 +97,12 @@ class MemoryRegionInfo {
// Set permissions from a uint32_t that contains one or more bits from the
// lldb::Permissions
void SetLLDBPermissions(uint32_t permissions) {
- m_read = (permissions & lldb::ePermissionsReadable) ? eYes : eNo;
- m_write = (permissions & lldb::ePermissionsWritable) ? eYes : eNo;
- m_execute = (permissions & lldb::ePermissionsExecutable) ? eYes : eNo;
+ m_read =
+ (permissions & lldb::ePermissionsReadable) ? eLazyBoolYes : eLazyBoolNo;
+ m_write =
+ (permissions & lldb::ePermissionsWritable) ? eLazyBoolYes : eLazyBoolNo;
+ m_execute = (permissions & lldb::ePermissionsExecutable) ? eLazyBoolYes
+ : eLazyBoolNo;
}
bool operator==(const MemoryRegionInfo &rhs) const {
@@ -131,9 +132,9 @@ class MemoryRegionInfo {
return m_dirty_pages;
}
- OptionalBool IsStackMemory() const { return m_is_stack_memory; }
+ LazyBool IsStackMemory() const { return m_is_stack_memory; }
- void SetIsStackMemory(OptionalBool val) { m_is_stack_memory = val; }
+ void SetIsStackMemory(LazyBool val) { m_is_stack_memory = val; }
void SetPageSize(int pagesize) { m_pagesize = pagesize; }
@@ -145,17 +146,17 @@ class MemoryRegionInfo {
protected:
RangeType m_range;
- OptionalBool m_read = eDontKnow;
- OptionalBool m_write = eDontKnow;
- OptionalBool m_execute = eDontKnow;
- OptionalBool m_shared = eDontKnow;
- OptionalBool m_mapped = eDontKnow;
+ LazyBool m_read = eLazyBoolDontKnow;
+ LazyBool m_write = eLazyBoolDontKnow;
+ LazyBool m_execute = eLazyBoolDontKnow;
+ LazyBool m_shared = eLazyBoolDontKnow;
+ LazyBool m_mapped = eLazyBoolDontKnow;
ConstString m_name;
- OptionalBool m_flash = eDontKnow;
+ LazyBool m_flash = eLazyBoolDontKnow;
lldb::offset_t m_blocksize = 0;
- OptionalBool m_memory_tagged = eDontKnow;
- OptionalBool m_is_stack_memory = eDontKnow;
- OptionalBool m_is_shadow_stack = eDontKnow;
+ LazyBool m_memory_tagged = eLazyBoolDontKnow;
+ LazyBool m_is_stack_memory = eLazyBoolDontKnow;
+ LazyBool m_is_shadow_stack = eLazyBoolDontKnow;
int m_pagesize = 0;
std::optional<std::vector<lldb::addr_t>> m_dirty_pages;
};
@@ -190,9 +191,9 @@ template <>
/// Options is a single character, it uses that character for the "yes" value,
/// while "no" is printed as "-", and "don't know" as "?". This can be used to
/// print the permissions in the traditional "rwx" form.
-struct format_provider<lldb_private::MemoryRegionInfo::OptionalBool> {
- static void format(const lldb_private::MemoryRegionInfo::OptionalBool &B,
- raw_ostream &OS, StringRef Options);
+struct format_provider<lldb_private::LazyBool> {
+ static void format(const lldb_private::LazyBool &B, raw_ostream &OS,
+ StringRef Options);
};
} // namespace llvm
diff --git a/lldb/include/lldb/lldb-private-enumerations.h b/lldb/include/lldb/lldb-private-enumerations.h
index cc4657c87cb0f..a6965657f5bc9 100644
--- a/lldb/include/lldb/lldb-private-enumerations.h
+++ b/lldb/include/lldb/lldb-private-enumerations.h
@@ -120,7 +120,16 @@ enum SortOrder {
// LazyBool is for boolean values that need to be calculated lazily. Values
// start off set to eLazyBoolCalculate, and then they can be calculated once
// and set to eLazyBoolNo or eLazyBoolYes.
-enum LazyBool { eLazyBoolCalculate = -1, eLazyBoolNo = 0, eLazyBoolYes = 1 };
+//
+// eLazyBoolDontKnow is the same value as eLazyBoolCalculate but is used in
+// contexts where the calculation is always attempted, but may turn out to not
+// be possible.
+enum LazyBool {
+ eLazyBoolCalculate = -1,
+ eLazyBoolDontKnow = eLazyBoolCalculate,
+ eLazyBoolNo = 0,
+ eLazyBoolYes = 1
+};
/// Instruction types
enum InstructionType {
diff --git a/lldb/source/API/SBMemoryRegionInfo.cpp b/lldb/source/API/SBMemoryRegionInfo.cpp
index cd25be5d52769..df85b5eb6e289 100644
--- a/lldb/source/API/SBMemoryRegionInfo.cpp
+++ b/lldb/source/API/SBMemoryRegionInfo.cpp
@@ -32,10 +32,8 @@ SBMemoryRegionInfo::SBMemoryRegionInfo(const char *name, lldb::addr_t begin,
m_opaque_up->GetRange().SetRangeBase(begin);
m_opaque_up->GetRange().SetRangeEnd(end);
m_opaque_up->SetLLDBPermissions(permissions);
- m_opaque_up->SetMapped(mapped ? MemoryRegionInfo::eYes
- : MemoryRegionInfo::eNo);
- m_opaque_up->SetIsStackMemory(stack_memory ? MemoryRegionInfo::eYes
- : MemoryRegionInfo::eNo);
+ m_opaque_up->SetMapped(mapped ? eLazyBoolYes : eLazyBoolNo);
+ m_opaque_up->SetIsStackMemory(stack_memory ? eLazyBoolYes : eLazyBoolNo);
}
SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr)
@@ -97,25 +95,25 @@ lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() {
bool SBMemoryRegionInfo::IsReadable() {
LLDB_INSTRUMENT_VA(this);
- return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes;
+ return m_opaque_up->GetReadable() == eLazyBoolYes;
}
bool SBMemoryRegionInfo::IsWritable() {
LLDB_INSTRUMENT_VA(this);
- return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes;
+ return m_opaque_up->GetWritable() == eLazyBoolYes;
}
bool SBMemoryRegionInfo::IsExecutable() {
LLDB_INSTRUMENT_VA(this);
- return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes;
+ return m_opaque_up->GetExecutable() == eLazyBoolYes;
}
bool SBMemoryRegionInfo::IsMapped() {
LLDB_INSTRUMENT_VA(this);
- return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes;
+ return m_opaque_up->GetMapped() == eLazyBoolYes;
}
const char *SBMemoryRegionInfo::GetName() {
diff --git a/lldb/source/Commands/CommandObjectMemory.cpp b/lldb/source/Commands/CommandObjectMemory.cpp
index 21ee0f21b8e0e..f8d9d027bdff0 100644
--- a/lldb/source/Commands/CommandObjectMemory.cpp
+++ b/lldb/source/Commands/CommandObjectMemory.cpp
@@ -1688,11 +1688,11 @@ class CommandObjectMemoryRegion : public CommandObjectParsed {
range_info.GetRange().GetRangeEnd(), range_info.GetReadable(),
range_info.GetWritable(), range_info.GetExecutable(), name ? " " : "",
name, section_name ? " " : "", section_name);
- MemoryRegionInfo::OptionalBool memory_tagged = range_info.GetMemoryTagged();
- if (memory_tagged == MemoryRegionInfo::OptionalBool::eYes)
+ LazyBool memory_tagged = range_info.GetMemoryTagged();
+ if (memory_tagged == eLazyBoolYes)
result.AppendMessage("memory tagging: enabled");
- MemoryRegionInfo::OptionalBool is_shadow_stack = range_info.IsShadowStack();
- if (is_shadow_stack == MemoryRegionInfo::OptionalBool::eYes)
+ LazyBool is_shadow_stack = range_info.IsShadowStack();
+ if (is_shadow_stack == eLazyBoolYes)
result.AppendMessage("shadow stack: yes");
const std::optional<std::vector<addr_t>> &dirty_page_list =
diff --git a/lldb/source/Expression/IRMemoryMap.cpp b/lldb/source/Expression/IRMemoryMap.cpp
index f978217fa8f2b..38921bc91d591 100644
--- a/lldb/source/Expression/IRMemoryMap.cpp
+++ b/lldb/source/Expression/IRMemoryMap.cpp
@@ -122,12 +122,9 @@ lldb::addr_t IRMemoryMap::FindSpace(size_t size) {
// it can make it harder to debug null dereference crashes
// in the inferior.
ret = region_info.GetRange().GetRangeEnd();
- } else if (region_info.GetReadable() !=
- MemoryRegionInfo::OptionalBool::eNo ||
- region_info.GetWritable() !=
- MemoryRegionInfo::OptionalBool::eNo ||
- region_info.GetExecutable() !=
- MemoryRegionInfo::OptionalBool::eNo) {
+ } else if (region_info.GetReadable() != eLazyBoolNo ||
+ region_info.GetWritable() != eLazyBoolNo ||
+ region_info.GetExecutable() != eLazyBoolNo) {
if (region_info.GetRange().GetRangeEnd() - 1 >= end_of_memory) {
ret = LLDB_INVALID_ADDRESS;
break;
diff --git a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
index 5e7c44d796bb9..8e920f4e127a3 100644
--- a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
+++ b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
@@ -625,7 +625,7 @@ ModuleSP DynamicLoaderPOSIXDYLD::LoadInterpreterModule() {
MemoryRegionInfo info;
Target &target = m_process->GetTarget();
Status status = m_process->GetMemoryRegionInfo(m_interpreter_base, info);
- if (status.Fail() || info.GetMapped() != MemoryRegionInfo::eYes ||
+ if (status.Fail() || info.GetMapped() != eLazyBoolYes ||
info.GetName().IsEmpty()) {
Log *log = GetLog(LLDBLog::DynamicLoader);
LLDB_LOG(log, "Failed to get interpreter region info: {0}", status);
diff --git a/lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp b/lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp
index 293471e4278a8..ab8f8a426d9f9 100644
--- a/lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp
+++ b/lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp
@@ -615,10 +615,10 @@ Status NativeProcessFreeBSD::GetMemoryRegionInfo(lldb::addr_t load_addr,
range_info.GetRange().SetRangeBase(load_addr);
range_info.GetRange().SetByteSize(
proc_entry_info.GetRange().GetRangeBase() - load_addr);
- range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
+ range_info.SetReadable(eLazyBoolNo);
+ range_info.SetWritable(eLazyBoolNo);
+ range_info.SetExecutable(eLazyBoolNo);
+ range_info.SetMapped(eLazyBoolNo);
return error;
} else if (proc_entry_info.GetRange().Contains(load_addr)) {
// The target address is within the memory region we're processing here.
@@ -633,10 +633,10 @@ Status NativeProcessFreeBSD::GetMemoryRegionInfo(lldb::addr_t load_addr,
// load address and the end of the memory as size.
range_info.GetRange().SetRangeBase(load_addr);
range_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
- range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
+ range_info.SetReadable(eLazyBoolNo);
+ range_info.SetWritable(eLazyBoolNo);
+ range_info.SetExecutable(eLazyBoolNo);
+ range_info.SetMapped(eLazyBoolNo);
return error;
}
@@ -680,22 +680,22 @@ Status NativeProcessFreeBSD::PopulateMemoryRegionCache() {
info.Clear();
info.GetRange().SetRangeBase(kv->kve_start);
info.GetRange().SetRangeEnd(kv->kve_end);
- info.SetMapped(MemoryRegionInfo::OptionalBool::eYes);
+ info.SetMapped(eLazyBoolYes);
if (kv->kve_protection & VM_PROT_READ)
- info.SetReadable(MemoryRegionInfo::OptionalBool::eYes);
+ info.SetReadable(eLazyBoolYes);
else
- info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
+ info.SetReadable(eLazyBoolNo);
if (kv->kve_protection & VM_PROT_WRITE)
- info.SetWritable(MemoryRegionInfo::OptionalBool::eYes);
+ info.SetWritable(eLazyBoolYes);
else
- info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
+ info.SetWritable(eLazyBoolNo);
if (kv->kve_protection & VM_PROT_EXECUTE)
- info.SetExecutable(MemoryRegionInfo::OptionalBool::eYes);
+ info.SetExecutable(eLazyBoolYes);
else
- info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
+ info.SetExecutable(eLazyBoolNo);
if (kv->kve_path[0])
info.SetName(kv->kve_path);
diff --git a/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp b/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp
index fe8e56b527a61..a40a66e838a89 100644
--- a/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp
+++ b/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp
@@ -1222,10 +1222,10 @@ Status NativeProcessLinux::GetMemoryRegionInfo(lldb::addr_t load_addr,
range_info.GetRange().SetRangeBase(load_addr);
range_info.GetRange().SetByteSize(
proc_entry_info.GetRange().GetRangeBase() - load_addr);
- range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
+ range_info.SetReadable(eLazyBoolNo);
+ range_info.SetWritable(eLazyBoolNo);
+ range_info.SetExecutable(eLazyBoolNo);
+ range_info.SetMapped(eLazyBoolNo);
return error;
} else if (proc_entry_info.GetRange().Contains(load_addr)) {
@@ -1243,10 +1243,10 @@ Status NativeProcessLinux::GetMemoryRegionInfo(lldb::addr_t load_addr,
// load address and the end of the memory as size.
range_info.GetRange().SetRangeBase(load_addr);
range_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
- range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
+ range_info.SetReadable(eLazyBoolNo);
+ range_info.SetWritable(eLazyBoolNo);
+ range_info.SetExecutable(eLazyBoolNo);
+ range_info.SetMapped(eLazyBoolNo);
return error;
}
@@ -1325,8 +1325,8 @@ llvm::Expected<uint64_t>
NativeProcessLinux::Syscall(llvm::ArrayRef<uint64_t> args) {
PopulateMemoryRegionCache();
auto region_it = llvm::find_if(m_mem_region_cache, [](const auto &pair) {
- return pair.first.GetExecutable() == MemoryRegionInfo::eYes &&
- pair.first.GetShared() != MemoryRegionInfo::eYes;
+ return pair.first.GetExecutable() == eLazyBoolYes &&
+ pair.first.GetShared() != eLazyBoolYes;
});
if (region_it == m_mem_region_cache.end())
return llvm::createStringError(llvm::inconvertibleErrorCode(),
diff --git a/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp b/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp
index 8695019c85d46..e4de3fab3a0fa 100644
--- a/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp
+++ b/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp
@@ -647,10 +647,10 @@ Status NativeProcessNetBSD::GetMemoryRegionInfo(lldb::addr_t load_addr,
range_info.GetRange().SetRangeBase(load_addr);
range_info.GetRange().SetByteSize(
proc_entry_info.GetRange().GetRangeBase() - load_addr);
- range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
+ range_info.SetReadable(eLazyBoolNo);
+ range_info.SetWritable(eLazyBoolNo);
+ range_info.SetExecutable(eLazyBoolNo);
+ range_info.SetMapped(eLazyBoolNo);
return error;
} else if (proc_entry_info.GetRange().Contains(load_addr)) {
// The target address is within the memory region we're processing here.
@@ -665,10 +665,10 @@ Status NativeProcessNetBSD::GetMemoryRegionInfo(lldb::addr_t load_addr,
// load address and the end of the memory as size.
range_info.GetRange().SetRangeBase(load_addr);
range_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
- range_info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
- range_info.SetMapped(MemoryRegionInfo::OptionalBool::eNo);
+ range_info.SetReadable(eLazyBoolNo);
+ range_info.SetWritable(eLazyBoolNo);
+ range_info.SetExecutable(eLazyBoolNo);
+ range_info.SetMapped(eLazyBoolNo);
return error;
}
@@ -696,22 +696,22 @@ Status NativeProcessNetBSD::PopulateMemoryRegionCache() {
info.Clear();
info.GetRange().SetRangeBase(vm[i].kve_start);
info.GetRange().SetRangeEnd(vm[i].kve_end);
- info.SetMapped(MemoryRegionInfo::OptionalBool::eYes);
+ info.SetMapped(eLazyBoolYes);
if (vm[i].kve_protection & VM_PROT_READ)
- info.SetReadable(MemoryRegionInfo::OptionalBool::eYes);
+ info.SetReadable(eLazyBoolYes);
else
- info.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
+ info.SetReadable(eLazyBoolNo);
if (vm[i].kve_protection & VM_PROT_WRITE)
- info.SetWritable(MemoryRegionInfo::OptionalBool::eYes);
+ info.SetWritable(eLazyBoolYes);
else
- info.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
+ info.SetWritable(eLazyBoolNo);
if (vm[i].kve_protection & VM_PROT_EXECUTE)
- info.SetExecutable(MemoryRegionInfo::OptionalBool::eYes);
+ info.SetExecutable(eLazyBoolYes);
else
- info.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
+ info.SetExecutable(eLazyBoolNo);
if (vm[i].kve_path[0])
info.SetName(vm[i].kve_path);
diff --git a/lldb/source/Plugins/Process/Utility/LinuxProcMaps.cpp b/lldb/source/Plugins/Process/Utility/LinuxProcMaps.cpp
index 2ed896327a2f8..74142ce0f00be 100644
--- a/lldb/source/Plugins/Process/Utility/LinuxProcMaps.cpp
+++ b/lldb/source/Plugins/Process/Utility/LinuxProcMaps.cpp
@@ -56,7 +56,7 @@ ParseMemoryRegionInfoFromProcMapsLine(llvm::StringRef maps_line,
// Any memory region in /proc/{pid}/(maps|smaps) is by definition mapped
// into the process.
- region.SetMapped(MemoryRegionInfo::OptionalBool::eYes);
+ region.SetMapped(eLazyBoolYes);
// Parse out each permission entry.
if (line_extractor.GetBytesLeft() < 4)
@@ -68,9 +68,9 @@ ParseMemoryRegionInfoFromProcMapsLine(llvm::StringRef maps_line,
// Handle read permission.
const char read_perm_char = line_extractor.GetChar();
if (read_perm_char == 'r')
- region.SetReadable(MemoryRegionInfo::OptionalBool::eYes);
+ region.SetReadable(eLazyBoolYes);
else if (read_perm_char == '-')
- region.SetReadable(MemoryRegionInfo::OptionalBool::eNo);
+ region.SetReadable(eLazyBoolNo);
else
return ProcMapError("unexpected /proc/{pid}/%s read permission char",
maps_kind);
@@ -78,9 +78,9 @@ ParseMemoryRegionInfoFromProcMapsLine(llvm::StringRef maps_line,
// Handle write permission.
const char write_perm_char = line_extractor.GetChar();
if (write_perm_char == 'w')
- region.SetWritable(MemoryRegionInfo::OptionalBool::eYes);
+ region.SetWritable(eLazyBoolYes);
else if (write_perm_char == '-')
- region.SetWritable(MemoryRegionInfo::OptionalBool::eNo);
+ region.SetWritable(eLazyBoolNo);
else
return ProcMapError("unexpected /proc/{pid}/%s write permission char",
maps_kind);
@@ -88,9 +88,9 @@ ParseMemoryRegionInfoFromProcMapsLine(llvm::StringRef maps_line,
// Handle execute permission.
const char exec_perm_char = line_extractor.GetChar();
if (exec_perm_char == 'x')
- region.SetExecutable(MemoryRegionInfo::OptionalBool::eYes);
+ region.SetExecutable(eLazyBoolYes);
else if (exec_perm_char == '-')
- region.SetExecutable(MemoryRegionInfo::OptionalBool::eNo);
+ region.SetExecutable(eLazyBoolNo);
else
return ProcMapError("unexpected /proc/{pid}/%s exec permission char",
maps_kind);
@@ -98,11 +98,11 @@ ParseMemoryRegionInfoFromProcMapsLine(llvm::StringRef maps_line,
// Handle sharing status (private/shared).
const char sharing_char = line_extractor.GetChar();
if (sharing_char == 's')
- region.SetShared(MemoryRegionInfo::OptionalBool::eYes);
+ region.SetShared(eLazyBoolYes);
else if (sharing_char == 'p')
- region.SetShared(MemoryRegionInfo::OptionalBool::eNo);
+ region.SetShared(eLazyBoolNo);
else
- region.SetShared(MemoryRegionInfo::OptionalBool::eDontKnow);
+ region.SetShared(eLazyBoolDontKnow);
line_extractor.SkipSpaces(); // Skip the separator
line_extractor.GetHexMaxU64(false, 0); // Read the offset
@@ -164,16 +164,16 @@ void lldb_private::ParseLinuxSMapRegions(llvm::StringRef linux_smap,
if (!name.contains(' ')) {
if (region) {
if (name == "VmFlags") {
- region->SetMemoryTagged(MemoryRegionInfo::eNo);
- region->SetIsShadowStack(MemoryRegionInfo::eNo);
+ region->SetMemoryTagged(eLazyBoolNo);
+ region->SetIsShadowStack(eLazyBoolNo);
llvm::SmallVector<llvm::StringRef> flags;
value.split(flags, ' ', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
for (llvm::StringRef flag : flags)
if (flag == "mt")
- region->SetMemoryTagged(MemoryRegionInfo::eYes);
+ region->SetMemoryTagged(eLazyBoolYes);
else if (flag == "ss")
- region->SetIsShadowStack(MemoryRegionInfo::eYes);
+ region->SetIsShadowStack(eLazyBoolYes);
}
} else {
// Orphaned settings line
diff --git a/lldb/source/Plugins/Process/Utility/MemoryTagManagerAArch64MTE.cpp b/lldb/source/Plugins/Process/Utility/MemoryTagManagerAArch64MTE.cpp
index 9f60675e51904..7b27dd35f680c 100644
--- a/lldb/source/Plugins/Process/Utility/MemoryTagManagerAArch64MTE.cpp
+++ b/lldb/source/Plugins/Process/Utility/MemoryTagManagerAArch64MTE.cpp
@@ -107,7 +107,7 @@ MemoryTagManagerAArch64MTE::MakeTaggedRange(
});
if (region == memory_regions.cend() ||
- region->GetMemoryTagged() != MemoryRegionInfo::eYes) {
+ region->GetMemoryTagged() != eLazyBoolYes) {
// Some part of this range is untagged (or unmapped) so error
return llvm::createStringError(llvm::inconvertibleErrorCode(),
"Address range 0x%" PRIx64 ":0x%" PRIx64
diff --git a/lldb/source/Plugins/Process/Windows/Common/ProcessDebugger.cpp b/lldb/source/Plugins/Process/Windows/Common/ProcessDebugger.cpp
index 234b99a6466d9..51b2dfcb74d86 100644
--- a/lldb/source/Plugins/Process/Windows/Common/ProcessDebugger.cpp
+++ b/lldb/source/Plugins/Process/Windows/Common/ProcessDebugger.cpp
@@ -288,7 +288,7 @@ Status ProcessDebugger::ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
error = Status(GetLastError(), eErrorTypeWin32);
MemoryRegionInfo info;
if (GetMemoryRegionInfo(vm_addr, info).Fail() ||
- info.GetMapped() != MemoryRegionInfo::OptionalBool::eYes)
+ info.GetMapped() != eLazyBoolYes)
return error;
size = info.GetRange().GetRangeEnd() - vm_addr;
LLDB_LOG(log, "retrying the read with size {0:x}", size);
@@ -421,10 +421,10 @@ Status ProcessDebugger::GetMemoryRegionInfo(lldb::addr_t vm_addr,
// range from the vm_addr to LLDB_INVALID_ADDRESS
info.GetRange().SetRangeBase(vm_addr);
info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
- info.SetReadable(MemoryRegionInfo::eNo);
- info.SetExecutable(MemoryRegionInfo::eNo);
- info.SetWritable(MemoryRegionInfo::eNo);
- info.SetMapped(MemoryRegionInfo::eNo);
+ info.SetReadable(eLazyBoolNo);
+ info.SetExecutable(eLazyBoolNo);
+ info.SetWritable(eLazyBoolNo);
+ info.SetMapped(eLazyBoolNo);
return error;
} else {
error = Status(last_error, eErrorTypeWin32);
@@ -441,14 +441,13 @@ Status ProcessDebugger::GetMemoryRegionInfo(lldb::addr_t vm_addr,
const bool readable = IsPageReadable(mem_info.Protect);
const bool executable = IsPageExecutable(mem_info.Protect);
const bool writable = IsPageWritable(mem_info.Protect);
- info.SetReadable(readable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
- info.SetExecutable(executable ? MemoryRegionInfo::eYes
- : MemoryRegionInfo::eNo);
- info.SetWritable(writable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
+ info.SetReadable(readable ? eLazyBoolYes : eLazyBoolNo);
+ info.SetExecutable(executable ? eLazyBoolYes : eLazyBoolNo);
+ info.SetWritable(writable ? eLazyBoolYes : eLazyBoolNo);
} else {
- info.SetReadable(MemoryRegionInfo::eNo);
- info.SetExecutable(MemoryRegionInfo::eNo);
- info.SetWritable(MemoryRegionInfo::eNo);
+ info.SetReadable(eLazyBoolNo);
+ info.SetExecutable(eLazyBoolNo);
+ info.SetWritable(eLazyBoolNo);
}
// AllocationBase is defined for MEM_COMMIT and MEM_RESERVE but not MEM_FREE.
@@ -457,7 +456,7 @@ Status ProcessDebugger::GetMemoryRegionInfo(lldb::addr_t vm_addr,
reinterpret_cast<addr_t>(mem_info.BaseAddress));
info.GetRange().SetRangeEnd(reinterpret_cast<addr_t>(mem_info.BaseAddress) +
mem_info.RegionSize);
- info.SetMapped(MemoryRegionInfo::eYes);
+ info.SetMapped(eLazyBoolYes);
} else {
// In the unmapped case we need to return the distance to the next block of
// memory. VirtualQueryEx nearly does that except that it gives the
@@ -467,7 +466,7 @@ Status ProcessDebugger::GetMemoryRegionInfo(lldb::addr_t vm_addr,
DWORD page_offset = vm_addr % data.dwPageSize;
info.GetRange().SetRangeBase(vm_addr);
info.GetRange().SetByteSize(mem_info.RegionSize - page_offset);
- info.SetMapped(MemoryRegionInfo::eNo);
+ info.SetMapped(eLazyBoolNo);
}
LLDB_LOG_VERBOSE(log,
diff --git a/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp b/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp
index 448c4f752758d..cf9e253af7f25 100644
--- a/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp
+++ b/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp
@@ -400,43 +400,43 @@ Status ProcessElfCore::DoGetMemoryRegionInfo(lldb::addr_t load_addr,
region_info.GetRange().SetRangeEnd(permission_entry->GetRangeEnd());
const Flags permissions(permission_entry->data);
region_info.SetReadable(permissions.Test(lldb::ePermissionsReadable)
- ? MemoryRegionInfo::eYes
- : MemoryRegionInfo::eNo);
+ ? eLazyBoolYes
+ : eLazyBoolNo);
region_info.SetWritable(permissions.Test(lldb::ePermissionsWritable)
- ? MemoryRegionInfo::eYes
- : MemoryRegionInfo::eNo);
+ ? eLazyBoolYes
+ : eLazyBoolNo);
region_info.SetExecutable(permissions.Test(lldb::ePermissionsExecutable)
- ? MemoryRegionInfo::eYes
- : MemoryRegionInfo::eNo);
- region_info.SetMapped(MemoryRegionInfo::eYes);
+ ? eLazyBoolYes
+ : eLazyBoolNo);
+ region_info.SetMapped(eLazyBoolYes);
// A region is memory tagged if there is a memory tag segment that covers
// the exact same range.
- region_info.SetMemoryTagged(MemoryRegionInfo::eNo);
+ region_info.SetMemoryTagged(eLazyBoolNo);
const VMRangeToFileOffset::Entry *tag_entry =
m_core_tag_ranges.FindEntryStartsAt(permission_entry->GetRangeBase());
if (tag_entry &&
tag_entry->GetRangeEnd() == permission_entry->GetRangeEnd())
- region_info.SetMemoryTagged(MemoryRegionInfo::eYes);
+ region_info.SetMemoryTagged(eLazyBoolYes);
} else if (load_addr < permission_entry->GetRangeBase()) {
region_info.GetRange().SetRangeBase(load_addr);
region_info.GetRange().SetRangeEnd(permission_entry->GetRangeBase());
- region_info.SetReadable(MemoryRegionInfo::eNo);
- region_info.SetWritable(MemoryRegionInfo::eNo);
- region_info.SetExecutable(MemoryRegionInfo::eNo);
- region_info.SetMapped(MemoryRegionInfo::eNo);
- region_info.SetMemoryTagged(MemoryRegionInfo::eNo);
+ region_info.SetReadable(eLazyBoolNo);
+ region_info.SetWritable(eLazyBoolNo);
+ region_info.SetExecutable(eLazyBoolNo);
+ region_info.SetMapped(eLazyBoolNo);
+ region_info.SetMemoryTagged(eLazyBoolNo);
}
return Status();
}
region_info.GetRange().SetRangeBase(load_addr);
region_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
- region_info.SetReadable(MemoryRegionInfo::eNo);
- region_info.SetWritable(MemoryRegionInfo::eNo);
- region_info.SetExecutable(MemoryRegionInfo::eNo);
- region_info.SetMapped(MemoryRegionInfo::eNo);
- region_info.SetMemoryTagged(MemoryRegionInfo::eNo);
+ region_info.SetReadable(eLazyBoolNo);
+ region_info.SetWritable(eLazyBoolNo);
+ region_info.SetExecutable(eLazyBoolNo);
+ region_info.SetMapped(eLazyBoolNo);
+ region_info.SetMemoryTagged(eLazyBoolNo);
return Status();
}
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
index ac475f4091e6f..9ec0b07b592f7 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
@@ -1610,28 +1610,28 @@ Status GDBRemoteCommunicationClient::GetMemoryRegionInfo(
saw_permissions = true;
if (region_info.GetRange().Contains(addr)) {
if (value.contains('r'))
- region_info.SetReadable(MemoryRegionInfo::eYes);
+ region_info.SetReadable(eLazyBoolYes);
else
- region_info.SetReadable(MemoryRegionInfo::eNo);
+ region_info.SetReadable(eLazyBoolNo);
if (value.contains('w'))
- region_info.SetWritable(MemoryRegionInfo::eYes);
+ region_info.SetWritable(eLazyBoolYes);
else
- region_info.SetWritable(MemoryRegionInfo::eNo);
+ region_info.SetWritable(eLazyBoolNo);
if (value.contains('x'))
- region_info.SetExecutable(MemoryRegionInfo::eYes);
+ region_info.SetExecutable(eLazyBoolYes);
else
- region_info.SetExecutable(MemoryRegionInfo::eNo);
+ region_info.SetExecutable(eLazyBoolNo);
- region_info.SetMapped(MemoryRegionInfo::eYes);
+ region_info.SetMapped(eLazyBoolYes);
} else {
// The reported region does not contain this address -- we're
// looking at an unmapped page
- region_info.SetReadable(MemoryRegionInfo::eNo);
- region_info.SetWritable(MemoryRegionInfo::eNo);
- region_info.SetExecutable(MemoryRegionInfo::eNo);
- region_info.SetMapped(MemoryRegionInfo::eNo);
+ region_info.SetReadable(eLazyBoolNo);
+ region_info.SetWritable(eLazyBoolNo);
+ region_info.SetExecutable(eLazyBoolNo);
+ region_info.SetMapped(eLazyBoolNo);
}
} else if (name == "name") {
StringExtractorGDBRemote name_extractor(value);
@@ -1639,8 +1639,8 @@ Status GDBRemoteCommunicationClient::GetMemoryRegionInfo(
name_extractor.GetHexByteString(name);
region_info.SetName(name.c_str());
} else if (name == "flags") {
- region_info.SetMemoryTagged(MemoryRegionInfo::eNo);
- region_info.SetIsShadowStack(MemoryRegionInfo::eNo);
+ region_info.SetMemoryTagged(eLazyBoolNo);
+ region_info.SetIsShadowStack(eLazyBoolNo);
llvm::StringRef flags = value;
llvm::StringRef flag;
@@ -1650,17 +1650,17 @@ Status GDBRemoteCommunicationClient::GetMemoryRegionInfo(
// To account for trailing whitespace
if (flag.size()) {
if (flag == "mt")
- region_info.SetMemoryTagged(MemoryRegionInfo::eYes);
+ region_info.SetMemoryTagged(eLazyBoolYes);
else if (flag == "ss")
- region_info.SetIsShadowStack(MemoryRegionInfo::eYes);
+ region_info.SetIsShadowStack(eLazyBoolYes);
}
}
} else if (name == "type") {
for (llvm::StringRef entry : llvm::split(value, ',')) {
if (entry == "stack")
- region_info.SetIsStackMemory(MemoryRegionInfo::eYes);
+ region_info.SetIsStackMemory(eLazyBoolYes);
else if (entry == "heap")
- region_info.SetIsStackMemory(MemoryRegionInfo::eNo);
+ region_info.SetIsStackMemory(eLazyBoolNo);
}
} else if (name == "error") {
StringExtractorGDBRemote error_extractor(value);
@@ -1687,10 +1687,10 @@ Status GDBRemoteCommunicationClient::GetMemoryRegionInfo(
// We got a valid address range back but no permissions -- which means
// this is an unmapped page
if (!saw_permissions) {
- region_info.SetReadable(MemoryRegionInfo::eNo);
- region_info.SetWritable(MemoryRegionInfo::eNo);
- region_info.SetExecutable(MemoryRegionInfo::eNo);
- region_info.SetMapped(MemoryRegionInfo::eNo);
+ region_info.SetReadable(eLazyBoolNo);
+ region_info.SetWritable(eLazyBoolNo);
+ region_info.SetExecutable(eLazyBoolNo);
+ region_info.SetMapped(eLazyBoolNo);
}
} else {
// We got an invalid address range back
@@ -1799,14 +1799,14 @@ Status GDBRemoteCommunicationClient::LoadQXferMemoryMap() {
region.GetRange().SetRangeBase(start);
region.GetRange().SetByteSize(length);
if (type == "rom") {
- region.SetReadable(MemoryRegionInfo::eYes);
+ region.SetReadable(eLazyBoolYes);
this->m_qXfer_memory_map.push_back(region);
} else if (type == "ram") {
- region.SetReadable(MemoryRegionInfo::eYes);
- region.SetWritable(MemoryRegionInfo::eYes);
+ region.SetReadable(eLazyBoolYes);
+ region.SetWritable(eLazyBoolYes);
this->m_qXfer_memory_map.push_back(region);
} else if (type == "flash") {
- region.SetFlash(MemoryRegionInfo::eYes);
+ region.SetFlash(eLazyBoolYes);
memory_node.ForEachChildElement(
[®ion](const XMLNode &prop_node) -> bool {
if (!prop_node.IsElement())
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
index c8b0acfe59096..48f6648292c2c 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
@@ -2873,18 +2873,16 @@ GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo(
}
// Flags
- MemoryRegionInfo::OptionalBool memory_tagged =
- region_info.GetMemoryTagged();
- MemoryRegionInfo::OptionalBool is_shadow_stack =
- region_info.IsShadowStack();
+ LazyBool memory_tagged = region_info.GetMemoryTagged();
+ LazyBool is_shadow_stack = region_info.IsShadowStack();
- if (memory_tagged != MemoryRegionInfo::eDontKnow ||
- is_shadow_stack != MemoryRegionInfo::eDontKnow) {
+ if (memory_tagged != eLazyBoolDontKnow ||
+ is_shadow_stack != eLazyBoolDontKnow) {
response.PutCString("flags:");
// Space is the separator.
- if (memory_tagged == MemoryRegionInfo::eYes)
+ if (memory_tagged == eLazyBoolYes)
response.PutCString("mt ");
- if (is_shadow_stack == MemoryRegionInfo::eYes)
+ if (is_shadow_stack == eLazyBoolYes)
response.PutCString("ss ");
response.PutChar(';');
diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index 631bda1d24537..dad705a857903 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -3115,8 +3115,7 @@ size_t ProcessGDBRemote::DoWriteMemory(addr_t addr, const void *buf,
MemoryRegionInfo region;
Status region_status = GetMemoryRegionInfo(addr, region);
- bool is_flash =
- region_status.Success() && region.GetFlash() == MemoryRegionInfo::eYes;
+ bool is_flash = region_status.Success() && region.GetFlash() == eLazyBoolYes;
if (is_flash) {
if (!m_allow_flash_writes) {
diff --git a/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp b/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp
index eed1e9e93a5b7..d0b9de0091511 100644
--- a/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp
+++ b/lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp
@@ -780,23 +780,21 @@ Status ProcessMachCore::DoGetMemoryRegionInfo(addr_t load_addr,
region_info.GetRange().SetRangeBase(permission_entry->GetRangeBase());
region_info.GetRange().SetRangeEnd(permission_entry->GetRangeEnd());
const Flags permissions(permission_entry->data);
- region_info.SetReadable(permissions.Test(ePermissionsReadable)
- ? MemoryRegionInfo::eYes
- : MemoryRegionInfo::eNo);
- region_info.SetWritable(permissions.Test(ePermissionsWritable)
- ? MemoryRegionInfo::eYes
- : MemoryRegionInfo::eNo);
+ region_info.SetReadable(
+ permissions.Test(ePermissionsReadable) ? eLazyBoolYes : eLazyBoolNo);
+ region_info.SetWritable(
+ permissions.Test(ePermissionsWritable) ? eLazyBoolYes : eLazyBoolNo);
region_info.SetExecutable(permissions.Test(ePermissionsExecutable)
- ? MemoryRegionInfo::eYes
- : MemoryRegionInfo::eNo);
- region_info.SetMapped(MemoryRegionInfo::eYes);
+ ? eLazyBoolYes
+ : eLazyBoolNo);
+ region_info.SetMapped(eLazyBoolYes);
} else if (load_addr < permission_entry->GetRangeBase()) {
region_info.GetRange().SetRangeBase(load_addr);
region_info.GetRange().SetRangeEnd(permission_entry->GetRangeBase());
- region_info.SetReadable(MemoryRegionInfo::eNo);
- region_info.SetWritable(MemoryRegionInfo::eNo);
- region_info.SetExecutable(MemoryRegionInfo::eNo);
- region_info.SetMapped(MemoryRegionInfo::eNo);
+ region_info.SetReadable(eLazyBoolNo);
+ region_info.SetWritable(eLazyBoolNo);
+ region_info.SetExecutable(eLazyBoolNo);
+ region_info.SetMapped(eLazyBoolNo);
}
return Status();
} else {
@@ -820,10 +818,10 @@ Status ProcessMachCore::DoGetMemoryRegionInfo(addr_t load_addr,
region_info.GetRange().SetRangeBase(load_addr);
region_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
- region_info.SetReadable(MemoryRegionInfo::eNo);
- region_info.SetWritable(MemoryRegionInfo::eNo);
- region_info.SetExecutable(MemoryRegionInfo::eNo);
- region_info.SetMapped(MemoryRegionInfo::eNo);
+ region_info.SetReadable(eLazyBoolNo);
+ region_info.SetWritable(eLazyBoolNo);
+ region_info.SetExecutable(eLazyBoolNo);
+ region_info.SetMapped(eLazyBoolNo);
return Status();
}
diff --git a/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp b/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp
index 58ebb7be11994..1334f69dad6dc 100644
--- a/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp
+++ b/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp
@@ -353,7 +353,7 @@ static bool CheckForLinuxExecutable(ConstString path,
lldb::addr_t addr = base_of_image;
MemoryRegionInfo region = MinidumpParser::GetMemoryRegionInfo(regions, addr);
while (region.GetName() == path) {
- if (region.GetExecutable() == MemoryRegionInfo::eYes)
+ if (region.GetExecutable() == eLazyBoolYes)
return true;
addr += region.GetRange().GetByteSize();
region = MinidumpParser::GetMemoryRegionInfo(regions, addr);
@@ -535,8 +535,8 @@ CreateRegionsCacheFromMemoryInfoList(MinidumpParser &parser,
"Failed to read memory info list: {0}");
return false;
}
- constexpr auto yes = MemoryRegionInfo::eYes;
- constexpr auto no = MemoryRegionInfo::eNo;
+ constexpr auto yes = eLazyBoolYes;
+ constexpr auto no = eLazyBoolNo;
for (const MemoryInfo &entry : *ExpectedInfo) {
MemoryRegionInfo region;
region.GetRange().SetRangeBase(entry.BaseAddress);
@@ -579,8 +579,8 @@ CreateRegionsCacheFromMemoryList(MinidumpParser &parser,
MemoryRegionInfo region;
region.GetRange().SetRangeBase(memory_desc.StartOfMemoryRange);
region.GetRange().SetByteSize(memory_desc.Memory.DataSize);
- region.SetReadable(MemoryRegionInfo::eYes);
- region.SetMapped(MemoryRegionInfo::eYes);
+ region.SetReadable(eLazyBoolYes);
+ region.SetMapped(eLazyBoolYes);
regions.push_back(region);
}
}
@@ -593,8 +593,8 @@ CreateRegionsCacheFromMemoryList(MinidumpParser &parser,
MemoryRegionInfo region;
region.GetRange().SetRangeBase(memory_desc.first.StartOfMemoryRange);
region.GetRange().SetByteSize(memory_desc.first.DataSize);
- region.SetReadable(MemoryRegionInfo::eYes);
- region.SetMapped(MemoryRegionInfo::eYes);
+ region.SetReadable(eLazyBoolYes);
+ region.SetMapped(eLazyBoolYes);
regions.push_back(region);
}
@@ -705,9 +705,9 @@ MinidumpParser::GetMemoryRegionInfo(const MemoryRegionInfos ®ions,
else
region.GetRange().SetRangeEnd(pos->GetRange().GetRangeBase());
- region.SetReadable(MemoryRegionInfo::eNo);
- region.SetWritable(MemoryRegionInfo::eNo);
- region.SetExecutable(MemoryRegionInfo::eNo);
- region.SetMapped(MemoryRegionInfo::eNo);
+ region.SetReadable(eLazyBoolNo);
+ region.SetWritable(eLazyBoolNo);
+ region.SetExecutable(eLazyBoolNo);
+ region.SetMapped(eLazyBoolNo);
return region;
}
diff --git a/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp b/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp
index df0a7a11a754a..ac33470bb1c23 100644
--- a/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp
+++ b/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp
@@ -394,13 +394,13 @@ void ProcessMinidump::BuildMemoryRegions() {
section_sp->GetByteSize());
MemoryRegionInfo region =
MinidumpParser::GetMemoryRegionInfo(*m_memory_regions, load_addr);
- if (region.GetMapped() != MemoryRegionInfo::eYes &&
+ if (region.GetMapped() != eLazyBoolYes &&
region.GetRange().GetRangeBase() <= section_range.GetRangeBase() &&
section_range.GetRangeEnd() <= region.GetRange().GetRangeEnd()) {
to_add.emplace_back();
to_add.back().GetRange() = section_range;
to_add.back().SetLLDBPermissions(section_sp->GetPermissions());
- to_add.back().SetMapped(MemoryRegionInfo::eYes);
+ to_add.back().SetMapped(eLazyBoolYes);
to_add.back().SetName(module_sp->GetFileSpec().GetPath().c_str());
}
}
diff --git a/lldb/source/Target/MemoryRegionInfo.cpp b/lldb/source/Target/MemoryRegionInfo.cpp
index 979e45ad023af..683ea20e7596e 100644
--- a/lldb/source/Target/MemoryRegionInfo.cpp
+++ b/lldb/source/Target/MemoryRegionInfo.cpp
@@ -22,19 +22,18 @@ llvm::raw_ostream &lldb_private::operator<<(llvm::raw_ostream &OS,
Info.IsStackMemory(), Info.IsShadowStack());
}
-void llvm::format_provider<MemoryRegionInfo::OptionalBool>::format(
- const MemoryRegionInfo::OptionalBool &B, raw_ostream &OS,
- StringRef Options) {
+void llvm::format_provider<LazyBool>::format(const LazyBool &B, raw_ostream &OS,
+ StringRef Options) {
assert(Options.size() <= 1);
bool Empty = Options.empty();
switch (B) {
- case lldb_private::MemoryRegionInfo::eNo:
+ case lldb_private::eLazyBoolNo:
OS << (Empty ? "no" : "-");
return;
- case lldb_private::MemoryRegionInfo::eYes:
+ case lldb_private::eLazyBoolYes:
OS << (Empty ? "yes" : Options);
return;
- case lldb_private::MemoryRegionInfo::eDontKnow:
+ case lldb_private::eLazyBoolDontKnow:
OS << (Empty ? "don't know" : "?");
return;
}
diff --git a/lldb/source/Target/Process.cpp b/lldb/source/Target/Process.cpp
index 7333365070061..34d8b91a42833 100644
--- a/lldb/source/Target/Process.cpp
+++ b/lldb/source/Target/Process.cpp
@@ -2623,9 +2623,9 @@ bool Process::GetLoadAddressPermissions(lldb::addr_t load_addr,
Status error(GetMemoryRegionInfo(load_addr, range_info));
if (!error.Success())
return false;
- if (range_info.GetReadable() == MemoryRegionInfo::eDontKnow ||
- range_info.GetWritable() == MemoryRegionInfo::eDontKnow ||
- range_info.GetExecutable() == MemoryRegionInfo::eDontKnow) {
+ if (range_info.GetReadable() == eLazyBoolDontKnow ||
+ range_info.GetWritable() == eLazyBoolDontKnow ||
+ range_info.GetExecutable() == eLazyBoolDontKnow) {
return false;
}
permissions = range_info.GetLLDBPermissions();
@@ -6374,7 +6374,7 @@ Status Process::GetMemoryRegions(lldb_private::MemoryRegionInfos ®ion_list) {
// region, the last mappable region, will have non-address bits in its end
// address.
range_end = region_info.GetRange().GetRangeEnd();
- if (region_info.GetMapped() == MemoryRegionInfo::eYes) {
+ if (region_info.GetMapped() == eLazyBoolYes) {
region_list.push_back(std::move(region_info));
}
} while (
@@ -6795,7 +6795,7 @@ static void GetCoreFileSaveRangesDirtyOnly(Process &process,
const bool try_dirty_pages = false;
for (const auto ®ion : regions)
if (stack_ends.count(region.GetRange().GetRangeEnd()) == 0 &&
- region.GetWritable() == MemoryRegionInfo::eYes)
+ region.GetWritable() == eLazyBoolYes)
AddRegion(region, try_dirty_pages, ranges);
}
}
@@ -6819,7 +6819,7 @@ static void GetCoreFileSaveRangesStackOnly(Process &process,
for (const auto ®ion : regions) {
// Save all the stack memory ranges not associated with a stack pointer.
if (stack_ends.count(region.GetRange().GetRangeEnd()) == 0 &&
- region.IsStackMemory() == MemoryRegionInfo::eYes)
+ region.IsStackMemory() == eLazyBoolYes)
AddRegion(region, try_dirty_pages, ranges);
}
}
diff --git a/lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp b/lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp
index 9c99117f1fe7c..a6663cbd1b04b 100644
--- a/lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp
+++ b/lldb/unittests/Process/Utility/LinuxProcMapsTest.cpp
@@ -82,25 +82,24 @@ INSTANTIATE_TEST_SUITE_P(
std::make_tuple("0-0 rwzp 00000000 00:00 0", MemoryRegionInfos{},
"unexpected /proc/{pid}/maps exec permission char"),
// Stops at first parsing error
- std::make_tuple(
- "0-1 rw-p 00000000 00:00 0 [abc]\n"
- "0-0 rwzp 00000000 00:00 0\n"
- "2-3 r-xp 00000000 00:00 0 [def]\n",
- MemoryRegionInfos{
- MemoryRegionInfo(make_range(0, 1), MemoryRegionInfo::eYes,
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
- ConstString("[abc]")),
- },
- "unexpected /proc/{pid}/maps exec permission char"),
+ std::make_tuple("0-1 rw-p 00000000 00:00 0 [abc]\n"
+ "0-0 rwzp 00000000 00:00 0\n"
+ "2-3 r-xp 00000000 00:00 0 [def]\n",
+ MemoryRegionInfos{
+ MemoryRegionInfo(make_range(0, 1), eLazyBoolYes,
+ eLazyBoolYes, eLazyBoolNo,
+ eLazyBoolNo, eLazyBoolYes,
+ ConstString("[abc]")),
+ },
+ "unexpected /proc/{pid}/maps exec permission char"),
// Single entry
std::make_tuple(
"55a4512f7000-55a451b68000 rw-p 00000000 00:00 0 [heap]",
MemoryRegionInfos{
MemoryRegionInfo(make_range(0x55a4512f7000, 0x55a451b68000),
- MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, ConstString("[heap]")),
+ eLazyBoolYes, eLazyBoolYes, eLazyBoolNo,
+ eLazyBoolNo, eLazyBoolYes,
+ ConstString("[heap]")),
},
""),
// Multiple entries
@@ -111,18 +110,17 @@ INSTANTIATE_TEST_SUITE_P(
"[vsyscall]",
MemoryRegionInfos{
MemoryRegionInfo(make_range(0x7fc090021000, 0x7fc094000000),
- MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, ConstString(nullptr)),
+ eLazyBoolNo, eLazyBoolNo, eLazyBoolNo,
+ eLazyBoolNo, eLazyBoolYes,
+ ConstString(nullptr)),
MemoryRegionInfo(make_range(0x7fc094000000, 0x7fc094a00000),
- MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
- MemoryRegionInfo::eYes, ConstString(nullptr)),
+ eLazyBoolNo, eLazyBoolNo, eLazyBoolNo,
+ eLazyBoolYes, eLazyBoolYes,
+ ConstString(nullptr)),
MemoryRegionInfo(
make_range(0xffffffffff600000, 0xffffffffff601000),
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, ConstString("[vsyscall]")),
+ eLazyBoolYes, eLazyBoolNo, eLazyBoolYes, eLazyBoolNo,
+ eLazyBoolYes, ConstString("[vsyscall]")),
},
"")));
@@ -143,10 +141,9 @@ INSTANTIATE_TEST_SUITE_P(
"1111-2222 rw-p 00000000 00:00 0 [foo]\n"
"0/0 rw-p 00000000 00:00 0",
MemoryRegionInfos{
- MemoryRegionInfo(make_range(0x1111, 0x2222),
- MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, ConstString("[foo]")),
+ MemoryRegionInfo(make_range(0x1111, 0x2222), eLazyBoolYes,
+ eLazyBoolYes, eLazyBoolNo, eLazyBoolNo,
+ eLazyBoolYes, ConstString("[foo]")),
},
"malformed /proc/{pid}/smaps entry, missing dash between address "
"range"),
@@ -161,63 +158,58 @@ INSTANTIATE_TEST_SUITE_P(
std::make_tuple(
"1111-2222 rw-p 00000000 00:00 0 [foo]",
MemoryRegionInfos{
- MemoryRegionInfo(make_range(0x1111, 0x2222),
- MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, ConstString("[foo]")),
+ MemoryRegionInfo(make_range(0x1111, 0x2222), eLazyBoolYes,
+ eLazyBoolYes, eLazyBoolNo, eLazyBoolNo,
+ eLazyBoolYes, ConstString("[foo]")),
},
""),
// Single shared region parses, has no flags
std::make_tuple(
"1111-2222 rw-s 00000000 00:00 0 [foo]",
MemoryRegionInfos{
- MemoryRegionInfo(make_range(0x1111, 0x2222),
- MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
- MemoryRegionInfo::eYes, ConstString("[foo]")),
+ MemoryRegionInfo(make_range(0x1111, 0x2222), eLazyBoolYes,
+ eLazyBoolYes, eLazyBoolNo, eLazyBoolYes,
+ eLazyBoolYes, ConstString("[foo]")),
},
""),
// Single region with flags, other lines ignored
- std::make_tuple(
- "1111-2222 rw-p 00000000 00:00 0 [foo]\n"
- "Referenced: 2188 kB\n"
- "AnonHugePages: 0 kB\n"
- "VmFlags: mt",
- MemoryRegionInfos{
- MemoryRegionInfo(make_range(0x1111, 0x2222),
- MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, ConstString("[foo]"))
- .SetIsShadowStack(MemoryRegionInfo::eNo)
- .SetMemoryTagged(MemoryRegionInfo::eYes),
- },
- ""),
+ std::make_tuple("1111-2222 rw-p 00000000 00:00 0 [foo]\n"
+ "Referenced: 2188 kB\n"
+ "AnonHugePages: 0 kB\n"
+ "VmFlags: mt",
+ MemoryRegionInfos{
+ MemoryRegionInfo(make_range(0x1111, 0x2222),
+ eLazyBoolYes, eLazyBoolYes,
+ eLazyBoolNo, eLazyBoolNo,
+ eLazyBoolYes, ConstString("[foo]"))
+ .SetIsShadowStack(eLazyBoolNo)
+ .SetMemoryTagged(eLazyBoolYes),
+ },
+ ""),
// Whitespace ignored
- std::make_tuple(
- "0-0 rw-p 00000000 00:00 0\n"
- "VmFlags: mt ",
- MemoryRegionInfos{
- MemoryRegionInfo(make_range(0, 0), MemoryRegionInfo::eYes,
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
- ConstString(nullptr))
- .SetIsShadowStack(MemoryRegionInfo::eNo)
- .SetMemoryTagged(MemoryRegionInfo::eYes),
- },
- ""),
+ std::make_tuple("0-0 rw-p 00000000 00:00 0\n"
+ "VmFlags: mt ",
+ MemoryRegionInfos{
+ MemoryRegionInfo(make_range(0, 0), eLazyBoolYes,
+ eLazyBoolYes, eLazyBoolNo,
+ eLazyBoolNo, eLazyBoolYes,
+ ConstString(nullptr))
+ .SetIsShadowStack(eLazyBoolNo)
+ .SetMemoryTagged(eLazyBoolYes),
+ },
+ ""),
// VmFlags line means it has flag info, but nothing is set
- std::make_tuple(
- "0-0 rw-p 00000000 00:00 0\n"
- "VmFlags: ",
- MemoryRegionInfos{
- MemoryRegionInfo(make_range(0, 0), MemoryRegionInfo::eYes,
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
- ConstString(nullptr))
- .SetIsShadowStack(MemoryRegionInfo::eNo)
- .SetMemoryTagged(MemoryRegionInfo::eNo),
- },
- ""),
+ std::make_tuple("0-0 rw-p 00000000 00:00 0\n"
+ "VmFlags: ",
+ MemoryRegionInfos{
+ MemoryRegionInfo(make_range(0, 0), eLazyBoolYes,
+ eLazyBoolYes, eLazyBoolNo,
+ eLazyBoolNo, eLazyBoolYes,
+ ConstString(nullptr))
+ .SetIsShadowStack(eLazyBoolNo)
+ .SetMemoryTagged(eLazyBoolNo),
+ },
+ ""),
// Handle some pages not having a flags line
std::make_tuple(
"1111-2222 rw-p 00000000 00:00 0 [foo]\n"
@@ -226,16 +218,14 @@ INSTANTIATE_TEST_SUITE_P(
"3333-4444 r-xp 00000000 00:00 0 [bar]\n"
"VmFlags: mt",
MemoryRegionInfos{
- MemoryRegionInfo(make_range(0x1111, 0x2222),
- MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, ConstString("[foo]")),
- MemoryRegionInfo(make_range(0x3333, 0x4444),
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, ConstString("[bar]"))
- .SetIsShadowStack(MemoryRegionInfo::eNo)
- .SetMemoryTagged(MemoryRegionInfo::eYes),
+ MemoryRegionInfo(make_range(0x1111, 0x2222), eLazyBoolYes,
+ eLazyBoolYes, eLazyBoolNo, eLazyBoolNo,
+ eLazyBoolYes, ConstString("[foo]")),
+ MemoryRegionInfo(make_range(0x3333, 0x4444), eLazyBoolYes,
+ eLazyBoolNo, eLazyBoolYes, eLazyBoolNo,
+ eLazyBoolYes, ConstString("[bar]"))
+ .SetIsShadowStack(eLazyBoolNo)
+ .SetMemoryTagged(eLazyBoolYes),
},
""),
// Handle no pages having a flags line (older kernels)
@@ -247,43 +237,39 @@ INSTANTIATE_TEST_SUITE_P(
"KernelPageSize: 4 kB\n"
"MMUPageSize: 4 kB\n",
MemoryRegionInfos{
- MemoryRegionInfo(make_range(0x1111, 0x2222),
- MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, ConstString(nullptr)),
- MemoryRegionInfo(make_range(0x3333, 0x4444),
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, ConstString(nullptr)),
+ MemoryRegionInfo(make_range(0x1111, 0x2222), eLazyBoolYes,
+ eLazyBoolYes, eLazyBoolNo, eLazyBoolNo,
+ eLazyBoolYes, ConstString(nullptr)),
+ MemoryRegionInfo(make_range(0x3333, 0x4444), eLazyBoolYes,
+ eLazyBoolNo, eLazyBoolYes, eLazyBoolNo,
+ eLazyBoolYes, ConstString(nullptr)),
},
""),
// We must look for exact flag strings, ignoring substrings of longer
// flag names.
- std::make_tuple(
- "0-0 rw-p 00000000 00:00 0\n"
- "VmFlags: amt mtb amtb",
- MemoryRegionInfos{
- MemoryRegionInfo(make_range(0, 0), MemoryRegionInfo::eYes,
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
- ConstString(nullptr))
- .SetIsShadowStack(MemoryRegionInfo::eNo)
- .SetMemoryTagged(MemoryRegionInfo::eNo),
- },
- ""),
+ std::make_tuple("0-0 rw-p 00000000 00:00 0\n"
+ "VmFlags: amt mtb amtb",
+ MemoryRegionInfos{
+ MemoryRegionInfo(make_range(0, 0), eLazyBoolYes,
+ eLazyBoolYes, eLazyBoolNo,
+ eLazyBoolNo, eLazyBoolYes,
+ ConstString(nullptr))
+ .SetIsShadowStack(eLazyBoolNo)
+ .SetMemoryTagged(eLazyBoolNo),
+ },
+ ""),
// "ss" means shadow stack.
- std::make_tuple(
- "0-0 rw-p 00000000 00:00 0\n"
- "VmFlags: ss",
- MemoryRegionInfos{
- MemoryRegionInfo(make_range(0, 0), MemoryRegionInfo::eYes,
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eNo, MemoryRegionInfo::eYes,
- ConstString(nullptr))
- .SetIsShadowStack(MemoryRegionInfo::eYes)
- .SetMemoryTagged(MemoryRegionInfo::eNo),
- },
- "")));
+ std::make_tuple("0-0 rw-p 00000000 00:00 0\n"
+ "VmFlags: ss",
+ MemoryRegionInfos{
+ MemoryRegionInfo(make_range(0, 0), eLazyBoolYes,
+ eLazyBoolYes, eLazyBoolNo,
+ eLazyBoolNo, eLazyBoolYes,
+ ConstString(nullptr))
+ .SetIsShadowStack(eLazyBoolYes)
+ .SetMemoryTagged(eLazyBoolNo),
+ },
+ "")));
TEST_P(LinuxProcSMapsTestFixture, ParseSMapRegions) {
auto params = GetParam();
diff --git a/lldb/unittests/Process/Utility/MemoryTagManagerAArch64MTETest.cpp b/lldb/unittests/Process/Utility/MemoryTagManagerAArch64MTETest.cpp
index 08a7a7331fa71..51adaec0e3ec1 100644
--- a/lldb/unittests/Process/Utility/MemoryTagManagerAArch64MTETest.cpp
+++ b/lldb/unittests/Process/Utility/MemoryTagManagerAArch64MTETest.cpp
@@ -230,11 +230,10 @@ TEST(MemoryTagManagerAArch64MTETest, ExpandToGranule) {
static MemoryRegionInfo MakeRegionInfo(lldb::addr_t base, lldb::addr_t size,
bool tagged) {
- return MemoryRegionInfo(MemoryRegionInfo::RangeType(base, size),
- MemoryRegionInfo::eYes, MemoryRegionInfo::eYes,
- MemoryRegionInfo::eYes, MemoryRegionInfo::eNo,
- MemoryRegionInfo::eYes, ConstString())
- .SetMemoryTagged(tagged ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
+ return MemoryRegionInfo(MemoryRegionInfo::RangeType(base, size), eLazyBoolYes,
+ eLazyBoolYes, eLazyBoolYes, eLazyBoolNo, eLazyBoolYes,
+ ConstString())
+ .SetMemoryTagged(tagged ? eLazyBoolYes : eLazyBoolNo);
}
TEST(MemoryTagManagerAArch64MTETest, MakeTaggedRange) {
@@ -304,7 +303,7 @@ TEST(MemoryTagManagerAArch64MTETest, MakeTaggedRange) {
llvm::FailedWithMessage(err_msg));
// If we tag that first part it succeeds
- memory_regions.back().SetMemoryTagged(MemoryRegionInfo::eYes);
+ memory_regions.back().SetMemoryTagged(eLazyBoolYes);
expected_range = MemoryTagManagerAArch64MTE::TagRange(0x0, 0x1000);
got = manager.MakeTaggedRange(0, 0x1000, memory_regions);
ASSERT_THAT_EXPECTED(got, llvm::Succeeded());
@@ -324,7 +323,7 @@ TEST(MemoryTagManagerAArch64MTETest, MakeTaggedRange) {
llvm::FailedWithMessage(err_msg));
// If we tag the last part it succeeds
- memory_regions.back().SetMemoryTagged(MemoryRegionInfo::eYes);
+ memory_regions.back().SetMemoryTagged(eLazyBoolYes);
got = manager.MakeTaggedRange(0, 0x1000, memory_regions);
ASSERT_THAT_EXPECTED(got, llvm::Succeeded());
ASSERT_EQ(*got, expected_range);
@@ -344,7 +343,7 @@ TEST(MemoryTagManagerAArch64MTETest, MakeTaggedRange) {
llvm::FailedWithMessage(err_msg));
// If we tag the middle part it succeeds
- memory_regions.back().SetMemoryTagged(MemoryRegionInfo::eYes);
+ memory_regions.back().SetMemoryTagged(eLazyBoolYes);
got = manager.MakeTaggedRange(0, 0x1000, memory_regions);
ASSERT_THAT_EXPECTED(got, llvm::Succeeded());
ASSERT_EQ(*got, expected_range);
@@ -379,7 +378,7 @@ TEST(MemoryTagManagerAArch64MTETest, MakeTaggedRanges) {
ASSERT_EQ(*got, std::vector<MemoryTagManager::TagRange>{});
// Make the region tagged and it'll be the one range returned.
- memory_regions.back().SetMemoryTagged(MemoryRegionInfo::eYes);
+ memory_regions.back().SetMemoryTagged(eLazyBoolYes);
got = manager.MakeTaggedRanges(0, 0x20, memory_regions);
ASSERT_THAT_EXPECTED(got, llvm::Succeeded());
ASSERT_EQ(*got, std::vector<MemoryTagManager::TagRange>{
diff --git a/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp b/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
index a5156326a1447..b6082b6acbd7c 100644
--- a/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
+++ b/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
@@ -391,16 +391,13 @@ TEST_F(GDBRemoteCommunicationClientTest, GetMemoryRegionInfo) {
EXPECT_TRUE(result.get().Success());
EXPECT_EQ(addr, region_info.GetRange().GetRangeBase());
EXPECT_EQ(0x2000u, region_info.GetRange().GetByteSize());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eYes, region_info.GetReadable());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eNo, region_info.GetWritable());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eYes, region_info.GetExecutable());
+ EXPECT_EQ(lldb_private::eLazyBoolYes, region_info.GetReadable());
+ EXPECT_EQ(lldb_private::eLazyBoolNo, region_info.GetWritable());
+ EXPECT_EQ(lldb_private::eLazyBoolYes, region_info.GetExecutable());
EXPECT_EQ("/foo/bar.so", region_info.GetName().GetStringRef());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eDontKnow,
- region_info.GetMemoryTagged());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eDontKnow,
- region_info.IsStackMemory());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eDontKnow,
- region_info.IsShadowStack());
+ EXPECT_EQ(lldb_private::eLazyBoolDontKnow, region_info.GetMemoryTagged());
+ EXPECT_EQ(lldb_private::eLazyBoolDontKnow, region_info.IsStackMemory());
+ EXPECT_EQ(lldb_private::eLazyBoolDontKnow, region_info.IsShadowStack());
result = std::async(std::launch::async, [&] {
return client.GetMemoryRegionInfo(addr, region_info);
@@ -409,9 +406,9 @@ TEST_F(GDBRemoteCommunicationClientTest, GetMemoryRegionInfo) {
HandlePacket(server, "qMemoryRegionInfo:a000",
"start:a000;size:2000;flags:;type:stack;");
EXPECT_TRUE(result.get().Success());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eNo, region_info.GetMemoryTagged());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eYes, region_info.IsStackMemory());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eNo, region_info.IsShadowStack());
+ EXPECT_EQ(lldb_private::eLazyBoolNo, region_info.GetMemoryTagged());
+ EXPECT_EQ(lldb_private::eLazyBoolYes, region_info.IsStackMemory());
+ EXPECT_EQ(lldb_private::eLazyBoolNo, region_info.IsShadowStack());
result = std::async(std::launch::async, [&] {
return client.GetMemoryRegionInfo(addr, region_info);
@@ -420,10 +417,9 @@ TEST_F(GDBRemoteCommunicationClientTest, GetMemoryRegionInfo) {
HandlePacket(server, "qMemoryRegionInfo:a000",
"start:a000;size:2000;flags: mt zz mt ss ;type:ha,ha,stack;");
EXPECT_TRUE(result.get().Success());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eYes,
- region_info.GetMemoryTagged());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eYes, region_info.IsStackMemory());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eYes, region_info.IsShadowStack());
+ EXPECT_EQ(lldb_private::eLazyBoolYes, region_info.GetMemoryTagged());
+ EXPECT_EQ(lldb_private::eLazyBoolYes, region_info.IsStackMemory());
+ EXPECT_EQ(lldb_private::eLazyBoolYes, region_info.IsShadowStack());
result = std::async(std::launch::async, [&] {
return client.GetMemoryRegionInfo(addr, region_info);
@@ -432,7 +428,7 @@ TEST_F(GDBRemoteCommunicationClientTest, GetMemoryRegionInfo) {
HandlePacket(server, "qMemoryRegionInfo:a000",
"start:a000;size:2000;type:heap;");
EXPECT_TRUE(result.get().Success());
- EXPECT_EQ(lldb_private::MemoryRegionInfo::eNo, region_info.IsStackMemory());
+ EXPECT_EQ(lldb_private::eLazyBoolNo, region_info.IsStackMemory());
}
TEST_F(GDBRemoteCommunicationClientTest, GetMemoryRegionInfoInvalidResponse) {
diff --git a/lldb/unittests/Process/minidump/MinidumpParserTest.cpp b/lldb/unittests/Process/minidump/MinidumpParserTest.cpp
index 085d617bc72b6..a5986eafda83e 100644
--- a/lldb/unittests/Process/minidump/MinidumpParserTest.cpp
+++ b/lldb/unittests/Process/minidump/MinidumpParserTest.cpp
@@ -337,9 +337,9 @@ TEST_F(MinidumpParserTest, FindMemoryRangeWithFullMemoryMinidump) {
EXPECT_FALSE(parser->FindMemoryRange(0x7ffe0000 + 4096).has_value());
}
-constexpr auto yes = MemoryRegionInfo::eYes;
-constexpr auto no = MemoryRegionInfo::eNo;
-constexpr auto unknown = MemoryRegionInfo::eDontKnow;
+constexpr auto yes = eLazyBoolYes;
+constexpr auto no = eLazyBoolNo;
+constexpr auto unknown = eLazyBoolDontKnow;
TEST_F(MinidumpParserTest, GetMemoryRegionInfo) {
ASSERT_THAT_ERROR(SetUpFromYaml(R"(
diff --git a/lldb/unittests/Target/MemoryRegionInfoTest.cpp b/lldb/unittests/Target/MemoryRegionInfoTest.cpp
index c272b23b23309..959984afaa9ad 100644
--- a/lldb/unittests/Target/MemoryRegionInfoTest.cpp
+++ b/lldb/unittests/Target/MemoryRegionInfoTest.cpp
@@ -13,7 +13,7 @@
using namespace lldb_private;
TEST(MemoryRegionInfoTest, Formatv) {
- EXPECT_EQ("yes", llvm::formatv("{0}", MemoryRegionInfo::eYes).str());
- EXPECT_EQ("no", llvm::formatv("{0}", MemoryRegionInfo::eNo).str());
- EXPECT_EQ("don't know", llvm::formatv("{0}", MemoryRegionInfo::eDontKnow).str());
+ EXPECT_EQ("yes", llvm::formatv("{0}", eLazyBoolYes).str());
+ EXPECT_EQ("no", llvm::formatv("{0}", eLazyBoolNo).str());
+ EXPECT_EQ("don't know", llvm::formatv("{0}", eLazyBoolDontKnow).str());
}
More information about the lldb-commits
mailing list