Skip to content

[lldb] Replace OptionalBool with LazyBool #189652

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
DavidSpickett merged 2 commits into from
Apr 1, 2026
Merged

[lldb] Replace OptionalBool with LazyBool #189652

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
1970d28
[lldb] Replace OptionalBool with LazyBool
DavidSpickett Mar 31, 2026
61f528d
format
DavidSpickett Mar 31, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
83 changes: 42 additions & 41 deletions lldb/include/lldb/Target/MemoryRegionInfo.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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) {}

Expand All @@ -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;
}
Expand All @@ -87,21 +85,24 @@ 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;
}

// 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 {
Expand Down Expand Up @@ -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; }

Expand All @@ -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;
};
Expand Down Expand Up @@ -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

Expand Down
11 changes: 10 additions & 1 deletion lldb/include/lldb/lldb-private-enumerations.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand Down
14 changes: 6 additions & 8 deletions lldb/source/API/SBMemoryRegionInfo.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down Expand Up @@ -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() {
Expand Down
8 changes: 4 additions & 4 deletions lldb/source/Commands/CommandObjectMemory.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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 =
Expand Down
9 changes: 3 additions & 6 deletions lldb/source/Expression/IRMemoryMap.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down
2 changes: 1 addition & 1 deletion lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down
30 changes: 15 additions & 15 deletions lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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.
Expand All @@ -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;
}

Expand Down Expand Up @@ -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);
Expand Down
20 changes: 10 additions & 10 deletions lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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)) {
Expand All @@ -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;
}

Expand Down Expand Up @@ -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(),
Expand Down
Loading
Loading