This is an archive of the discontinued LLVM Phabricator instance.

Differential D55584

[LLDB] Simplify Boolean expressions
ClosedPublic

Authored by JDevlieghere on Dec 11 2018, 2:41 PM.

Details

Reviewers
aprantl
• espindola
shafik
Group Reviewers
Restricted Project
Commits
rGa6682a413d89: Simplify Boolean expressions
rL349215: Simplify Boolean expressions
rLLDB349215: Simplify Boolean expressions
Summary

After creating D55574, clang-tidy was of course fresh in my mind and I noticed another common pattern that can be improved.

https://clang.llvm.org/extra/clang-tidy/checks/readability-simplify-boolean-expr.html

Command used:

run-clang-tidy.py -checks='-*,readability-simplify-boolean-expr' -format -fix $PWD

Diff Detail

Event Timeline

JDevlieghere created this revision.Dec 11 2018, 2:41 PM
Herald added a reviewer: • espindola. · View Herald TranscriptDec 11 2018, 2:41 PM
Herald added a reviewer: shafik. · View Herald Transcript
Herald added subscribers: teemperor, abidh, arphaman and 6 others. · View Herald Transcript
aprantl added a comment.Dec 11 2018, 3:18 PM

This one is probably less controversial than D55574 :-)

include/lldb/Target/ThreadPlanTracer.h
46

is this actually better? Perhaps.

source/DataFormatters/TypeCategoryMap.cpp
122

this probably should be a while loop, or the initializer should go in the for.

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp
363

here the indentation actually got worse

shafik added a comment.Dec 11 2018, 3:19 PM

I find the static_cast<bool> to be a bit too clever, I don't think it helps readability.

This is also too large to digest in a way I would feel satisfied that I did not miss anything.

Eugene.Zelenko retitled this revision from Simplify boolean expressions to [LLDB] Simplify Boolean expressions.Dec 11 2018, 5:13 PM
Eugene.Zelenko added a subscriber: Eugene.Zelenko.Dec 11 2018, 5:17 PM

Thank you for cleanup effort!

I would suggest to also run modernize checks and at least next readability checks:

readability-container-size-empty
readability-isolate-declaration
readability-redundant-control-flow
readability-redundant-member-init
readability-redundant-smartptr-get
readability-redundant-string-cstr
readability-redundant-string-init

Indeed, Clang-tidy offers even more useful checks.

JDevlieghere updated this revision to Diff 177813.Dec 11 2018, 6:47 PM
JDevlieghere marked 3 inline comments as done.

Feedback Adrian

JDevlieghere mentioned this in D55574: Remove else statements after returns.Dec 11 2018, 6:50 PM
labath added a subscriber: labath.Dec 12 2018, 1:34 AM

I also find the static_cast<bool> thingy weird. The rest of the changes seem to be towards the better (based on a pseudo-random sample), but the change is a quite big.

JDevlieghere added a comment.Dec 12 2018, 9:22 AM
In D55584#1328087, @labath wrote:

I also find the static_cast<bool> thingy weird. The rest of the changes seem to be towards the better (based on a pseudo-random sample), but the change is a quite big.

Me and Adrian went through all the changes and I didn't see anything that looked out of the ordinary.

I left the static cast because it was suggested to me before in a review, but happy to remove it as there is a consensus that it's worse :-)

aprantl accepted this revision.Dec 12 2018, 9:25 AM
This revision is now accepted and ready to land.Dec 12 2018, 9:25 AM
JDevlieghere updated this revision to Diff 177869.Dec 12 2018, 9:37 AM

Remove changes that introduced static_cast<bool>

shafik accepted this revision as: shafik.Dec 12 2018, 10:02 AM

LGTM after comment are addressed.

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
5894

This looks like a big chunk of unrelated changes.

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
1725–1728

Not sure if I like this one, the previous form feels more readable.

source/Plugins/Process/mach-core/ProcessMachCore.cpp
305–320

Another big chunk of unrelated changes.

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp
1117

The static_cast feels less readable here.

source/Symbol/LineTable.cpp
217

static_cast

236

static_cast

source/Symbol/Type.cpp
749

Oh, even worse C-style casts ... can we remove these. I am assuming they are triggering a member conversion function.

source/Utility/RegisterValue.cpp
478

Nice one.

Closed by commit rLLDB349215: Simplify Boolean expressions (authored by JDevlieghere). · Explain WhyDec 14 2018, 4:19 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
include/
lldb/
Core/
2 lines
6 lines
DataFormatters/
2 lines
Symbol/
4 lines
Target/
2 lines
4 lines
Utility/
4 lines
source/
API/
6 lines
4 lines
6 lines
8 lines
4 lines
6 lines
6 lines
6 lines
4 lines
6 lines
5 lines
Breakpoint/
5 lines
Commands/
3 lines
4 lines
5 lines
Core/
14 lines
4 lines
4 lines
18 lines
2 lines
27 lines
4 lines
2 lines
6 lines
DataFormatters/
2 lines
4 lines
2 lines
14 lines
2 lines
5 lines
2 lines
2 lines
2 lines
12 lines
Expression/
10 lines
9 lines
2 lines
Host/
common/
2 lines
2 lines
2 lines
2 lines
9 lines
macosx/
6 lines
cfcpp/
6 lines
2 lines
objcxx/
10 lines
Interpreter/
15 lines
15 lines
4 lines
4 lines
6 lines
Plugins/
ABI/
SysV-arm/
5 lines
SysV-s390x/
4 lines
Disassembler/
llvm/
5 lines
DynamicLoader/
Darwin-Kernel/
20 lines
MacOSX-DYLD/
16 lines
5 lines
6 lines
POSIX-DYLD/
12 lines
2 lines
ExpressionParser/
Clang/
9 lines
23 lines
Instruction/
ARM/
92 lines
ARM64/
13 lines
MIPS/
133 lines
MIPS64/
115 lines
Language/
CPlusPlus/
5 lines
ObjC/
2 lines
7 lines
6 lines
13 lines
LanguageRuntime/
CPlusPlus/
ItaniumABI/
5 lines
ObjC/
AppleObjCRuntime/
12 lines
11 lines
2 lines
8 lines
5 lines
RenderScript/
RenderScriptRuntime/
11 lines
ObjectContainer/
BSD-Archive/
2 lines
ObjectFile/
ELF/
29 lines
10 lines
JIT/
2 lines
Mach-O/
92 lines
PECOFF/
2 lines
OperatingSystem/
Python/
2 lines
Platform/
Android/
2 lines
FreeBSD/
2 lines
Kalimba/
2 lines
Linux/
2 lines
MacOSX/
2 lines
2 lines
5 lines
14 lines
2 lines
2 lines
2 lines
objcxx/
2 lines
NetBSD/
2 lines
OpenBSD/
2 lines
Windows/
2 lines
gdb-server/
2 lines
Process/
MacOSX-Kernel/
18 lines
Utility/
2 lines
2 lines
26 lines
2 lines
19 lines
gdb-remote/
2 lines
2 lines
32 lines
4 lines
6 lines
11 lines
mach-core/
63 lines
ScriptInterpreter/
Python/
8 lines
4 lines
SymbolFile/
DWARF/
12 lines
2 lines
2 lines
11 lines
4 lines
11 lines
PDB/
2 lines
SymbolVendor/
MacOSX/
3 lines
SystemRuntime/
MacOSX/
2 lines
2 lines
2 lines
2 lines
UnwindAssembly/
x86/
6 lines
30 lines
Symbol/
6 lines
20 lines
2 lines
8 lines
2 lines
10 lines
2 lines
4 lines
4 lines
14 lines
2 lines
5 lines
2 lines
Target/
6 lines
2 lines
17 lines
4 lines
6 lines
2 lines
5 lines
5 lines
Utility/
10 lines
2 lines
2 lines
tools/
debugserver/
source/
4 lines
MacOSX/
3 lines
12 lines
4 lines
5 lines
i386/
7 lines
x86_64/
7 lines
11 lines
6 lines
2 lines
lldb-mi/
5 lines
5 lines
7 lines
5 lines
5 lines
2 lines
4 lines
5 lines
5 lines
20 lines
lldb-vscode/
4 lines

Diff 177790

include/lldb/Core/MappedHash.h

Context not available.
HashData hash_data; HashData hash_data;
if (ReadHashData(hash_data_offset, hash_data)) { if (ReadHashData(hash_data_offset, hash_data)) {
// If the callback returns false, then we are done and should stop // If the callback returns false, then we are done and should stop
if (callback(hash_data) == false) if (!static_cast<bool>(callback(hash_data)))
return; return;
} }
} }
Context not available.

include/lldb/Core/ModuleSpec.h

Context not available.
if (match_module_spec.GetFileSpecPtr()) { if (match_module_spec.GetFileSpecPtr()) {
const FileSpec &fspec = match_module_spec.GetFileSpec(); const FileSpec &fspec = match_module_spec.GetFileSpec();
if (!FileSpec::Equal(fspec, GetFileSpec(), if (!FileSpec::Equal(fspec, GetFileSpec(),
fspec.GetDirectory().IsEmpty() == false)) !fspec.GetDirectory().IsEmpty()))
return false; return false;
} }
if (GetPlatformFileSpec() && match_module_spec.GetPlatformFileSpecPtr()) { if (GetPlatformFileSpec() && match_module_spec.GetPlatformFileSpecPtr()) {
const FileSpec &fspec = match_module_spec.GetPlatformFileSpec(); const FileSpec &fspec = match_module_spec.GetPlatformFileSpec();
if (!FileSpec::Equal(fspec, GetPlatformFileSpec(), if (!FileSpec::Equal(fspec, GetPlatformFileSpec(),
fspec.GetDirectory().IsEmpty() == false)) !fspec.GetDirectory().IsEmpty()))
return false; return false;
} }
// Only match the symbol file spec if there is one in this ModuleSpec // Only match the symbol file spec if there is one in this ModuleSpec
if (GetSymbolFileSpec() && match_module_spec.GetSymbolFileSpecPtr()) { if (GetSymbolFileSpec() && match_module_spec.GetSymbolFileSpecPtr()) {
const FileSpec &fspec = match_module_spec.GetSymbolFileSpec(); const FileSpec &fspec = match_module_spec.GetSymbolFileSpec();
if (!FileSpec::Equal(fspec, GetSymbolFileSpec(), if (!FileSpec::Equal(fspec, GetSymbolFileSpec(),
fspec.GetDirectory().IsEmpty() == false)) !fspec.GetDirectory().IsEmpty()))
return false; return false;
} }
if (match_module_spec.GetArchitecturePtr()) { if (match_module_spec.GetArchitecturePtr()) {
Context not available.

include/lldb/DataFormatters/TypeCategory.h

Context not available.
bool IsEnabled() const { return m_enabled; } bool IsEnabled() const { return m_enabled; }
uint32_t GetEnabledPosition() { uint32_t GetEnabledPosition() {
if (m_enabled == false) if (!m_enabled)
return UINT32_MAX; return UINT32_MAX;
else else
return m_enabled_position; return m_enabled_position;
Context not available.

include/lldb/Symbol/Symtab.h

Context not available.
Visibility symbol_visibility) const { Visibility symbol_visibility) const {
switch (symbol_debug_type) { switch (symbol_debug_type) {
case eDebugNo: case eDebugNo:
if (m_symbols[idx].IsDebug() == true) if (m_symbols[idx].IsDebug())
return false; return false;
break; break;
case eDebugYes: case eDebugYes:
if (m_symbols[idx].IsDebug() == false) if (!m_symbols[idx].IsDebug())
return false; return false;
break; break;
Context not available.

include/lldb/Target/Thread.h

Context not available.
/// message). /// message).
//------------------------------------------------------------------ //------------------------------------------------------------------
StructuredData::ObjectSP GetExtendedInfo() { StructuredData::ObjectSP GetExtendedInfo() {
if (m_extended_info_fetched == false) { if (!m_extended_info_fetched) {
m_extended_info = FetchThreadExtendedInfo(); m_extended_info = FetchThreadExtendedInfo();
m_extended_info_fetched = true; m_extended_info_fetched = true;
} }
Context not available.

include/lldb/Target/ThreadPlanTracer.h

Context not available.
bool EnableTracing(bool value) { bool EnableTracing(bool value) {
bool old_value = m_enabled; bool old_value = m_enabled;
m_enabled = value; m_enabled = value;
if (old_value == false && value == true) if (!old_value && value)
TracingStarted(); TracingStarted();
else if (old_value == true && value == false) else if (old_value && !value)
aprantlUnsubmitted
Done
ReplyInline Actions

is this actually better? Perhaps.

aprantl: is this actually better? Perhaps.
TracingEnded(); TracingEnded();
return old_value; return old_value;
Context not available.

include/lldb/Utility/StructuredData.h

Context not available.
bool bool
ForEach(std::function<bool(Object *object)> const &foreach_callback) const { ForEach(std::function<bool(Object *object)> const &foreach_callback) const {
for (const auto &object_sp : m_items) { for (const auto &object_sp : m_items) {
if (foreach_callback(object_sp.get()) == false) if (!foreach_callback(object_sp.get()))
return false; return false;
} }
return true; return true;
Context not available.
void ForEach(std::function<bool(ConstString key, Object *object)> const void ForEach(std::function<bool(ConstString key, Object *object)> const
&callback) const { &callback) const {
for (const auto &pair : m_dict) { for (const auto &pair : m_dict) {
if (callback(pair.first, pair.second.get()) == false) if (!callback(pair.first, pair.second.get()))
break; break;
} }
} }
Context not available.

source/API/SBQueue.cpp

Context not available.
} }
void FetchThreads() { void FetchThreads() {
if (m_thread_list_fetched == false) { if (!m_thread_list_fetched) {
lldb::QueueSP queue_sp = m_queue_wp.lock(); lldb::QueueSP queue_sp = m_queue_wp.lock();
if (queue_sp) { if (queue_sp) {
Process::StopLocker stop_locker; Process::StopLocker stop_locker;
Context not available.
} }
void FetchItems() { void FetchItems() {
if (m_pending_items_fetched == false) { if (!m_pending_items_fetched) {
QueueSP queue_sp = m_queue_wp.lock(); QueueSP queue_sp = m_queue_wp.lock();
if (queue_sp) { if (queue_sp) {
Process::StopLocker stop_locker; Process::StopLocker stop_locker;
Context not available.
uint32_t result = 0; uint32_t result = 0;
QueueSP queue_sp = m_queue_wp.lock(); QueueSP queue_sp = m_queue_wp.lock();
if (m_pending_items_fetched == false && queue_sp) { if (!m_pending_items_fetched && queue_sp) {
result = queue_sp->GetNumPendingWorkItems(); result = queue_sp->GetNumPendingWorkItems();
} else { } else {
result = m_pending_items.size(); result = m_pending_items.size();
Context not available.

source/API/SBThread.cpp

Context not available.
success = true; success = true;
} }
if (node->GetType() == eStructuredDataTypeBoolean) { if (node->GetType() == eStructuredDataTypeBoolean) {
if (node->GetAsBoolean()->GetValue() == true) if (node->GetAsBoolean()->GetValue())
strm.Printf("true"); strm.Printf("true");
else else
strm.Printf("false"); strm.Printf("false");
Context not available.
} }
} }
if (log && sb_origin_thread.IsValid() == false) if (log && !sb_origin_thread.IsValid())
log->Printf("SBThread(%p)::GetExtendedBacktraceThread() is not returning a " log->Printf("SBThread(%p)::GetExtendedBacktraceThread() is not returning a "
"Valid thread", "Valid thread",
static_cast<void *>(exe_ctx.GetThreadPtr())); static_cast<void *>(exe_ctx.GetThreadPtr()));
Context not available.

source/API/SBTraceOptions.cpp

Context not available.
m_traceoptions_sp->setMetaDataBufferSize(size); m_traceoptions_sp->setMetaDataBufferSize(size);
} }
bool SBTraceOptions::IsValid() { bool SBTraceOptions::IsValid() { return static_cast<bool>(m_traceoptions_sp); }
if (m_traceoptions_sp)
return true;
return false;
}
void SBTraceOptions::setThreadID(lldb::tid_t thread_id) { void SBTraceOptions::setThreadID(lldb::tid_t thread_id) {
if (m_traceoptions_sp) if (m_traceoptions_sp)
Context not available.

source/API/SBType.cpp

Context not available.
//{} //{}
// //
bool SBType::operator==(SBType &rhs) { bool SBType::operator==(SBType &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
if (rhs.IsValid() == false) if (!rhs.IsValid())
return false; return false;
return *m_opaque_sp.get() == *rhs.m_opaque_sp.get(); return *m_opaque_sp.get() == *rhs.m_opaque_sp.get();
} }
bool SBType::operator!=(SBType &rhs) { bool SBType::operator!=(SBType &rhs) {
if (IsValid() == false) if (!IsValid())
return rhs.IsValid(); return rhs.IsValid();
if (rhs.IsValid() == false) if (!rhs.IsValid())
return true; return true;
return *m_opaque_sp.get() != *rhs.m_opaque_sp.get(); return *m_opaque_sp.get() != *rhs.m_opaque_sp.get();
Context not available.

source/API/SBTypeCategory.cpp

Context not available.
} }
bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) { bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
return m_opaque_sp.get() == rhs.m_opaque_sp.get(); return m_opaque_sp.get() == rhs.m_opaque_sp.get();
} }
bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) { bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {
if (IsValid() == false) if (!IsValid())
return rhs.IsValid(); return rhs.IsValid();
return m_opaque_sp.get() != rhs.m_opaque_sp.get(); return m_opaque_sp.get() != rhs.m_opaque_sp.get();
Context not available.

source/API/SBTypeFilter.cpp

Context not available.
} }
bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) { bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
return m_opaque_sp == rhs.m_opaque_sp; return m_opaque_sp == rhs.m_opaque_sp;
} }
bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) { bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
if (GetNumberOfExpressionPaths() != rhs.GetNumberOfExpressionPaths()) if (GetNumberOfExpressionPaths() != rhs.GetNumberOfExpressionPaths())
Context not available.
} }
bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) { bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
return m_opaque_sp != rhs.m_opaque_sp; return m_opaque_sp != rhs.m_opaque_sp;
Context not available.

source/API/SBTypeFormat.cpp

Context not available.
} }
bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) { bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
return m_opaque_sp == rhs.m_opaque_sp; return m_opaque_sp == rhs.m_opaque_sp;
} }
bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) { bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
if (GetFormat() == rhs.GetFormat()) if (GetFormat() == rhs.GetFormat())
Context not available.
} }
bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) { bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
return m_opaque_sp != rhs.m_opaque_sp; return m_opaque_sp != rhs.m_opaque_sp;
} }
Context not available.

source/API/SBTypeNameSpecifier.cpp

Context not available.
} }
bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) { bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
return m_opaque_sp == rhs.m_opaque_sp; return m_opaque_sp == rhs.m_opaque_sp;
} }
bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) { bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
if (IsRegex() != rhs.IsRegex()) if (IsRegex() != rhs.IsRegex())
Context not available.
} }
bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) { bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
return m_opaque_sp != rhs.m_opaque_sp; return m_opaque_sp != rhs.m_opaque_sp;
} }
Context not available.

source/API/SBTypeSummary.cpp

Context not available.
} }
bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) { bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
return m_opaque_sp == rhs.m_opaque_sp; return m_opaque_sp == rhs.m_opaque_sp;
} }
Context not available.
} }
bool SBTypeSummary::operator!=(lldb::SBTypeSummary &rhs) { bool SBTypeSummary::operator!=(lldb::SBTypeSummary &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
return m_opaque_sp != rhs.m_opaque_sp; return m_opaque_sp != rhs.m_opaque_sp;
} }
Context not available.

source/API/SBTypeSynthetic.cpp

Context not available.
} }
bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) { bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
return m_opaque_sp == rhs.m_opaque_sp; return m_opaque_sp == rhs.m_opaque_sp;
} }
bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) { bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
if (m_opaque_sp->IsScripted() != rhs.m_opaque_sp->IsScripted()) if (m_opaque_sp->IsScripted() != rhs.m_opaque_sp->IsScripted())
Context not available.
} }
bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) { bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) {
if (IsValid() == false) if (!IsValid())
return !rhs.IsValid(); return !rhs.IsValid();
return m_opaque_sp != rhs.m_opaque_sp; return m_opaque_sp != rhs.m_opaque_sp;
} }
Context not available.

source/API/SBValue.cpp

Context not available.
// they depend on. So I have no good way to make that check without // they depend on. So I have no good way to make that check without
// tracking that in all the ValueObject subclasses. // tracking that in all the ValueObject subclasses.
TargetSP target_sp = m_valobj_sp->GetTargetSP(); TargetSP target_sp = m_valobj_sp->GetTargetSP();
if (target_sp && target_sp->IsValid()) return target_sp && target_sp->IsValid();
return true;
else
return false;
} }
} }
Context not available.

source/Breakpoint/Watchpoint.cpp

Context not available.
bool Watchpoint::ShouldStop(StoppointCallbackContext *context) { bool Watchpoint::ShouldStop(StoppointCallbackContext *context) {
IncrementHitCount(); IncrementHitCount();
if (!IsEnabled()) return IsEnabled();
return false;
return true;
} }
void Watchpoint::GetDescription(Stream *s, lldb::DescriptionLevel level) { void Watchpoint::GetDescription(Stream *s, lldb::DescriptionLevel level) {
Context not available.

source/Commands/CommandObjectExpression.cpp

Context not available.
if (m_command_options.auto_apply_fixits == eLazyBoolCalculate) if (m_command_options.auto_apply_fixits == eLazyBoolCalculate)
auto_apply_fixits = target->GetEnableAutoApplyFixIts(); auto_apply_fixits = target->GetEnableAutoApplyFixIts();
else else
auto_apply_fixits = auto_apply_fixits = m_command_options.auto_apply_fixits == eLazyBoolYes;
m_command_options.auto_apply_fixits == eLazyBoolYes ? true : false;
options.SetAutoApplyFixIts(auto_apply_fixits); options.SetAutoApplyFixIts(auto_apply_fixits);
Context not available.

source/Commands/CommandObjectQuit.cpp

Context not available.
// if all alive processes will be detached when you quit and false if at least // if all alive processes will be detached when you quit and false if at least
// one process will be killed instead // one process will be killed instead
bool CommandObjectQuit::ShouldAskForConfirmation(bool &is_a_detach) { bool CommandObjectQuit::ShouldAskForConfirmation(bool &is_a_detach) {
if (m_interpreter.GetPromptOnQuit() == false) if (!m_interpreter.GetPromptOnQuit())
return false; return false;
bool should_prompt = false; bool should_prompt = false;
is_a_detach = true; is_a_detach = true;
Context not available.
if (process_sp && process_sp->IsValid() && process_sp->IsAlive() && if (process_sp && process_sp->IsValid() && process_sp->IsAlive() &&
process_sp->WarnBeforeDetach()) { process_sp->WarnBeforeDetach()) {
should_prompt = true; should_prompt = true;
if (process_sp->GetShouldDetach() == false) { if (!process_sp->GetShouldDetach()) {
// if we need to kill at least one process, just say so and return // if we need to kill at least one process, just say so and return
is_a_detach = false; is_a_detach = false;
return should_prompt; return should_prompt;
Context not available.

source/Commands/CommandObjectWatchpoint.cpp

Context not available.
wp_ids.push_back(beg); wp_ids.push_back(beg);
} }
// It is an error if after the loop, we're still in_range. // It is an error if after the loop, we're still in_range.
if (in_range) return !in_range; // Success!
return false;
return true; // Success!
} }
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
Context not available.

source/Core/Disassembler.cpp

Context not available.
if (mixed_source_and_assembly && sc.line_entry.IsValid()) { if (mixed_source_and_assembly && sc.line_entry.IsValid()) {
if (sc.symbol != previous_symbol) { if (sc.symbol != previous_symbol) {
SourceLine decl_line = GetFunctionDeclLineEntry(sc); SourceLine decl_line = GetFunctionDeclLineEntry(sc);
if (ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, decl_line) == if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, decl_line))
false)
AddLineToSourceLineTables(decl_line, source_lines_seen); AddLineToSourceLineTables(decl_line, source_lines_seen);
} }
if (sc.line_entry.IsValid()) { if (sc.line_entry.IsValid()) {
Context not available.
this_line.file = sc.line_entry.file; this_line.file = sc.line_entry.file;
this_line.line = sc.line_entry.line; this_line.line = sc.line_entry.line;
this_line.column = sc.line_entry.column; this_line.column = sc.line_entry.column;
if (ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, this_line) == if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, this_line))
false)
AddLineToSourceLineTables(this_line, source_lines_seen); AddLineToSourceLineTables(this_line, source_lines_seen);
} }
} }
Context not available.
previous_symbol = sc.symbol; previous_symbol = sc.symbol;
if (sc.function && sc.line_entry.IsValid()) { if (sc.function && sc.line_entry.IsValid()) {
LineEntry prologue_end_line = sc.line_entry; LineEntry prologue_end_line = sc.line_entry;
if (ElideMixedSourceAndDisassemblyLine( if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc,
exe_ctx, sc, prologue_end_line) == false) { prologue_end_line)) {
FileSpec func_decl_file; FileSpec func_decl_file;
uint32_t func_decl_line; uint32_t func_decl_line;
sc.function->GetStartLineSourceInfo(func_decl_file, sc.function->GetStartLineSourceInfo(func_decl_file,
Context not available.
this_line.file = sc.line_entry.file; this_line.file = sc.line_entry.file;
this_line.line = sc.line_entry.line; this_line.line = sc.line_entry.line;
if (ElideMixedSourceAndDisassemblyLine(exe_ctx, sc, if (!ElideMixedSourceAndDisassemblyLine(exe_ctx, sc,
this_line) == false) { this_line)) {
// Only print this source line if it is different from the // Only print this source line if it is different from the
// last source line we printed. There may have been inlined // last source line we printed. There may have been inlined
// functions between these lines that we elided, resulting in // functions between these lines that we elided, resulting in
Context not available.

source/Core/Listener.cpp

Context not available.
return false; return false;
} }
if (m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType()) return m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType();
return true;
return false;
} }
private: private:
Context not available.

source/Core/Mangled.cpp

Context not available.
return true; return true;
ConstString demangled = GetDemangledName(language); ConstString demangled = GetDemangledName(language);
if (demangled && regex.Execute(demangled.AsCString())) return demangled && regex.Execute(demangled.AsCString());
return true;
return false;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Context not available.

source/Core/SearchFilter.cpp

Context not available.
bool SearchFilterForUnconstrainedSearches::ModulePasses( bool SearchFilterForUnconstrainedSearches::ModulePasses(
const FileSpec &module_spec) { const FileSpec &module_spec) {
if (m_target_sp->ModuleIsExcludedForUnconstrainedSearches(module_spec)) return !m_target_sp->ModuleIsExcludedForUnconstrainedSearches(module_spec);
return false;
else
return true;
} }
bool SearchFilterForUnconstrainedSearches::ModulePasses( bool SearchFilterForUnconstrainedSearches::ModulePasses(
Context not available.
if (m_module_spec_list.GetSize() == 0) if (m_module_spec_list.GetSize() == 0)
return true; return true;
if (module_sp && return module_sp && m_module_spec_list.FindFileIndex(
m_module_spec_list.FindFileIndex(0, module_sp->GetFileSpec(), false) != 0, module_sp->GetFileSpec(), false) != UINT32_MAX;
UINT32_MAX)
return true;
else
return false;
} }
bool SearchFilterByModuleList::ModulePasses(const FileSpec &spec) { bool SearchFilterByModuleList::ModulePasses(const FileSpec &spec) {
if (m_module_spec_list.GetSize() == 0) if (m_module_spec_list.GetSize() == 0)
return true; return true;
if (m_module_spec_list.FindFileIndex(0, spec, true) != UINT32_MAX) return m_module_spec_list.FindFileIndex(0, spec, true) != UINT32_MAX;
return true;
else
return false;
} }
bool SearchFilterByModuleList::AddressPasses(Address &address) { bool SearchFilterByModuleList::AddressPasses(Address &address) {
Context not available.

source/Core/SourceManager.cpp

Context not available.
if (end_offset > start_offset) { if (end_offset > start_offset) {
uint32_t length = end_offset - start_offset; uint32_t length = end_offset - start_offset;
if (include_newline_chars == false) { if (!include_newline_chars) {
const char *line_start = const char *line_start =
(const char *)m_data_sp->GetBytes() + start_offset; (const char *)m_data_sp->GetBytes() + start_offset;
while (length > 0) { while (length > 0) {
Context not available.

source/Core/ValueObject.cpp

Context not available.
if (first_update) if (first_update)
SetValueDidChange(false); SetValueDidChange(false);
else if (!m_value_did_change && success == false) { else if (!m_value_did_change && !success) {
// The value wasn't gotten successfully, so we mark this as changed if // The value wasn't gotten successfully, so we mark this as changed if
// the value used to be valid and now isn't // the value used to be valid and now isn't
SetValueDidChange(value_was_valid); SetValueDidChange(value_was_valid);
Context not available.
switch (is_logical_true) { switch (is_logical_true) {
case eLazyBoolYes: case eLazyBoolYes:
case eLazyBoolNo: case eLazyBoolNo:
return (is_logical_true == true); return (static_cast<bool>(is_logical_true));
case eLazyBoolCalculate: case eLazyBoolCalculate:
break; break;
} }
Context not available.
} }
bool ret; bool ret;
if (scalar_value.ULongLong(1) == 0) ret = scalar_value.ULongLong(1) != 0;
ret = false;
else
ret = true;
error.Clear(); error.Clear();
return ret; return ret;
} }
Context not available.
bool child_is_deref_of_parent = false; bool child_is_deref_of_parent = false;
uint64_t language_flags = 0; uint64_t language_flags = 0;
const bool transparent_pointers = synthetic_array_member == false; const bool transparent_pointers = !synthetic_array_member;
CompilerType child_compiler_type; CompilerType child_compiler_type;
ExecutionContext exe_ctx(GetExecutionContextRef()); ExecutionContext exe_ctx(GetExecutionContextRef());
Context not available.
} }
void ValueObject::CalculateSyntheticValue(bool use_synthetic) { void ValueObject::CalculateSyntheticValue(bool use_synthetic) {
if (use_synthetic == false) if (!use_synthetic)
return; return;
TargetSP target_sp(GetTargetSP()); TargetSP target_sp(GetTargetSP());
if (target_sp && target_sp->GetEnableSyntheticValue() == false) { if (target_sp && !target_sp->GetEnableSyntheticValue()) {
m_synthetic_value = NULL; m_synthetic_value = NULL;
return; return;
} }
Context not available.
lldb::ValueObjectSP ValueObject::GetNonSyntheticValue() { return GetSP(); } lldb::ValueObjectSP ValueObject::GetNonSyntheticValue() { return GetSP(); }
ValueObjectSP ValueObject::GetSyntheticValue(bool use_synthetic) { ValueObjectSP ValueObject::GetSyntheticValue(bool use_synthetic) {
if (use_synthetic == false) if (!use_synthetic)
return ValueObjectSP(); return ValueObjectSP();
CalculateSyntheticValue(use_synthetic); CalculateSyntheticValue(use_synthetic);
Context not available.
CalculateSyntheticValue(true); CalculateSyntheticValue(true);
if (m_synthetic_value) return m_synthetic_value != nullptr;
return true;
else
return false;
} }
bool ValueObject::GetBaseClassPath(Stream &s) { bool ValueObject::GetBaseClassPath(Stream &s) {
Context not available.
ValueObject::FollowParentChain(std::function<bool(ValueObject *)> f) { ValueObject::FollowParentChain(std::function<bool(ValueObject *)> f) {
ValueObject *vo = this; ValueObject *vo = this;
while (vo) { while (vo) {
if (f(vo) == false) if (!f(vo))
break; break;
vo = vo->m_parent; vo = vo->m_parent;
} }
Context not available.
// board debugging scenarios have no notion of types, but still manage to // board debugging scenarios have no notion of types, but still manage to
// have raw numeric values for things like registers. sigh. // have raw numeric values for things like registers. sigh.
const CompilerType &type(GetCompilerType()); const CompilerType &type(GetCompilerType());
return (false == type.IsValid()) || return (!type.IsValid()) || (0 != (type.GetTypeInfo() & eTypeHasValue));
(0 != (type.GetTypeInfo() & eTypeHasValue));
} }
bool ValueObject::IsChecksumEmpty() { return m_value_checksum.empty(); } bool ValueObject::IsChecksumEmpty() { return m_value_checksum.empty(); }
Context not available.

source/Core/ValueObjectChild.cpp

Context not available.
Flags parent_type_flags(parent_type.GetTypeInfo()); Flags parent_type_flags(parent_type.GetTypeInfo());
const bool is_instance_ptr_base = const bool is_instance_ptr_base =
((m_is_base_class == true) && ((m_is_base_class) &&
(parent_type_flags.AnySet(lldb::eTypeInstanceIsPointer))); (parent_type_flags.AnySet(lldb::eTypeInstanceIsPointer)));
if (parent->GetCompilerType().ShouldTreatScalarValueAsAddress()) { if (parent->GetCompilerType().ShouldTreatScalarValueAsAddress()) {
Context not available.
switch (addr_type) { switch (addr_type) {
case eAddressTypeFile: { case eAddressTypeFile: {
lldb::ProcessSP process_sp(GetProcessSP()); lldb::ProcessSP process_sp(GetProcessSP());
if (process_sp && process_sp->IsAlive() == true) if (process_sp && process_sp->IsAlive())
m_value.SetValueType(Value::eValueTypeLoadAddress); m_value.SetValueType(Value::eValueTypeLoadAddress);
else else
m_value.SetValueType(Value::eValueTypeFileAddress); m_value.SetValueType(Value::eValueTypeFileAddress);
Context not available.

source/Core/ValueObjectConstResultImpl.cpp

Context not available.
bool child_is_deref_of_parent = false; bool child_is_deref_of_parent = false;
uint64_t language_flags; uint64_t language_flags;
const bool transparent_pointers = synthetic_array_member == false; const bool transparent_pointers = !synthetic_array_member;
CompilerType compiler_type = m_impl_backend->GetCompilerType(); CompilerType compiler_type = m_impl_backend->GetCompilerType();
CompilerType child_compiler_type; CompilerType child_compiler_type;
Context not available.

source/Core/ValueObjectSyntheticFilter.cpp

Context not available.
if (m_might_have_children == eLazyBoolCalculate) if (m_might_have_children == eLazyBoolCalculate)
m_might_have_children = m_might_have_children =
(m_synth_filter_ap->MightHaveChildren() ? eLazyBoolYes : eLazyBoolNo); (m_synth_filter_ap->MightHaveChildren() ? eLazyBoolYes : eLazyBoolNo);
return (m_might_have_children == eLazyBoolNo ? false : true); return (m_might_have_children != eLazyBoolNo);
} }
uint64_t ValueObjectSynthetic::GetByteSize() { return m_parent->GetByteSize(); } uint64_t ValueObjectSynthetic::GetByteSize() { return m_parent->GetByteSize(); }
Context not available.
} }
// let our backend do its update // let our backend do its update
if (m_synth_filter_ap->Update() == false) { if (!m_synth_filter_ap->Update()) {
if (log) if (log)
log->Printf("[ValueObjectSynthetic::UpdateValue] name=%s, synthetic " log->Printf("[ValueObjectSynthetic::UpdateValue] name=%s, synthetic "
"filter said caches are stale - clearing", "filter said caches are stale - clearing",
Context not available.
UpdateValueIfNeeded(); UpdateValueIfNeeded();
ValueObject *valobj; ValueObject *valobj;
if (m_children_byindex.GetValueForKey(idx, valobj) == false) { if (!m_children_byindex.GetValueForKey(idx, valobj)) {
if (can_create && m_synth_filter_ap.get() != nullptr) { if (can_create && m_synth_filter_ap.get() != nullptr) {
if (log) if (log)
log->Printf("[ValueObjectSynthetic::GetChildAtIndex] name=%s, child at " log->Printf("[ValueObjectSynthetic::GetChildAtIndex] name=%s, child at "
Context not available.

source/DataFormatters/CXXFunctionPointer.cpp

Context not available.
Address so_addr; Address so_addr;
Target *target = exe_ctx.GetTargetPtr(); Target *target = exe_ctx.GetTargetPtr();
if (target && target->GetSectionLoadList().IsEmpty() == false) { if (target && !target->GetSectionLoadList().IsEmpty()) {
if (target->GetSectionLoadList().ResolveLoadAddress(func_ptr_address, if (target->GetSectionLoadList().ResolveLoadAddress(func_ptr_address,
so_addr)) { so_addr)) {
so_addr.Dump(&sstr, exe_ctx.GetBestExecutionContextScope(), so_addr.Dump(&sstr, exe_ctx.GetBestExecutionContextScope(),
Context not available.

source/DataFormatters/DataVisualization.cpp

Context not available.
} }
void DataVisualization::Categories::Disable(const ConstString &category) { void DataVisualization::Categories::Disable(const ConstString &category) {
if (GetFormatManager().GetCategory(category)->IsEnabled() == true) if (GetFormatManager().GetCategory(category)->IsEnabled())
GetFormatManager().DisableCategory(category); GetFormatManager().DisableCategory(category);
} }
Context not available.
void DataVisualization::Categories::Disable( void DataVisualization::Categories::Disable(
const lldb::TypeCategoryImplSP &category) { const lldb::TypeCategoryImplSP &category) {
if (category.get() && category->IsEnabled() == true) if (category.get() && category->IsEnabled())
GetFormatManager().DisableCategory(category); GetFormatManager().DisableCategory(category);
} }
Context not available.

source/DataFormatters/DumpValueObjectOptions.cpp

Context not available.
} }
DumpValueObjectOptions &DumpValueObjectOptions::SetShowSummary(bool show) { DumpValueObjectOptions &DumpValueObjectOptions::SetShowSummary(bool show) {
if (show == false) if (!show)
SetOmitSummaryDepth(UINT32_MAX); SetOmitSummaryDepth(UINT32_MAX);
else else
SetOmitSummaryDepth(0); SetOmitSummaryDepth(0);
Context not available.

source/DataFormatters/FormatManager.cpp

Context not available.
uint32_t prio_category = UINT32_MAX; uint32_t prio_category = UINT32_MAX;
for (uint32_t category_id = 0; category_id < num_categories; category_id++) { for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
category_sp = GetCategoryAtIndex(category_id); category_sp = GetCategoryAtIndex(category_id);
if (category_sp->IsEnabled() == false) if (!category_sp->IsEnabled())
continue; continue;
lldb::TypeFormatImplSP format_current_sp = lldb::TypeFormatImplSP format_current_sp =
category_sp->GetFormatForType(type_sp); category_sp->GetFormatForType(type_sp);
Context not available.
uint32_t prio_category = UINT32_MAX; uint32_t prio_category = UINT32_MAX;
for (uint32_t category_id = 0; category_id < num_categories; category_id++) { for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
category_sp = GetCategoryAtIndex(category_id); category_sp = GetCategoryAtIndex(category_id);
if (category_sp->IsEnabled() == false) if (!category_sp->IsEnabled())
continue; continue;
lldb::TypeSummaryImplSP summary_current_sp = lldb::TypeSummaryImplSP summary_current_sp =
category_sp->GetSummaryForType(type_sp); category_sp->GetSummaryForType(type_sp);
Context not available.
uint32_t prio_category = UINT32_MAX; uint32_t prio_category = UINT32_MAX;
for (uint32_t category_id = 0; category_id < num_categories; category_id++) { for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
category_sp = GetCategoryAtIndex(category_id); category_sp = GetCategoryAtIndex(category_id);
if (category_sp->IsEnabled() == false) if (!category_sp->IsEnabled())
continue; continue;
lldb::TypeFilterImplSP filter_current_sp( lldb::TypeFilterImplSP filter_current_sp(
(TypeFilterImpl *)category_sp->GetFilterForType(type_sp).get()); (TypeFilterImpl *)category_sp->GetFilterForType(type_sp).get());
Context not available.
uint32_t prio_category = UINT32_MAX; uint32_t prio_category = UINT32_MAX;
for (uint32_t category_id = 0; category_id < num_categories; category_id++) { for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
category_sp = GetCategoryAtIndex(category_id); category_sp = GetCategoryAtIndex(category_id);
if (category_sp->IsEnabled() == false) if (!category_sp->IsEnabled())
continue; continue;
lldb::ScriptedSyntheticChildrenSP synth_current_sp( lldb::ScriptedSyntheticChildrenSP synth_current_sp(
(ScriptedSyntheticChildren *)category_sp->GetSyntheticForType(type_sp) (ScriptedSyntheticChildren *)category_sp->GetSyntheticForType(type_sp)
Context not available.
uint32_t prio_category = UINT32_MAX; uint32_t prio_category = UINT32_MAX;
for (uint32_t category_id = 0; category_id < num_categories; category_id++) { for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
category_sp = GetCategoryAtIndex(category_id); category_sp = GetCategoryAtIndex(category_id);
if (category_sp->IsEnabled() == false) if (!category_sp->IsEnabled())
continue; continue;
lldb::TypeValidatorImplSP validator_current_sp( lldb::TypeValidatorImplSP validator_current_sp(
category_sp->GetValidatorForType(type_sp).get()); category_sp->GetValidatorForType(type_sp).get());
Context not available.
bool FormatManager::ShouldPrintAsOneLiner(ValueObject &valobj) { bool FormatManager::ShouldPrintAsOneLiner(ValueObject &valobj) {
// if settings say no oneline whatsoever // if settings say no oneline whatsoever
if (valobj.GetTargetSP().get() && if (valobj.GetTargetSP().get() &&
valobj.GetTargetSP()->GetDebugger().GetAutoOneLineSummaries() == false) !valobj.GetTargetSP()->GetDebugger().GetAutoOneLineSummaries())
return false; // then don't oneline return false; // then don't oneline
// if this object has a summary, then ask the summary // if this object has a summary, then ask the summary
Context not available.
if (!synth_sp) if (!synth_sp)
return false; return false;
// but if we only have them to provide a value, keep going // but if we only have them to provide a value, keep going
if (synth_sp->MightHaveChildren() == false && if (!synth_sp->MightHaveChildren() &&
synth_sp->DoesProvideSyntheticValue()) synth_sp->DoesProvideSyntheticValue())
is_synth_val = true; is_synth_val = true;
else else
Context not available.

source/DataFormatters/StringPrinter.cpp

Context not available.
utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize(); utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
ConvertFunction(&data_ptr, data_end_ptr, &utf8_data_ptr, ConvertFunction(&data_ptr, data_end_ptr, &utf8_data_ptr,
utf8_data_end_ptr, llvm::lenientConversion); utf8_data_end_ptr, llvm::lenientConversion);
if (false == zero_is_terminator) if (!zero_is_terminator)
utf8_data_end_ptr = utf8_data_ptr; utf8_data_end_ptr = utf8_data_ptr;
// needed because the ConvertFunction will change the value of the // needed because the ConvertFunction will change the value of the
// data_ptr. // data_ptr.
Context not available.

source/DataFormatters/TypeCategory.cpp

Context not available.
else /*if (filter_sp.get() && synth.get())*/ else /*if (filter_sp.get() && synth.get())*/
{ {
if (filter_sp->GetRevision() > synth->GetRevision()) pick_synth = filter_sp->GetRevision() <= synth->GetRevision();
pick_synth = false;
else
pick_synth = true;
} }
if (pick_synth) { if (pick_synth) {
if (regex_synth && reason) if (regex_synth && reason)
Context not available.

source/DataFormatters/TypeCategoryMap.cpp

Context not available.
void TypeCategoryMap::DisableAllCategories() { void TypeCategoryMap::DisableAllCategories() {
std::lock_guard<std::recursive_mutex> guard(m_map_mutex); std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
Position p = First; Position p = First;
for (; false == m_active_categories.empty(); p++) { for (; !m_active_categories.empty(); p++) {
aprantlUnsubmitted
Done
ReplyInline Actions

this probably should be a while loop, or the initializer should go in the for.

aprantl: this probably should be a while loop, or the initializer should go in the for.
m_active_categories.front()->SetEnabledPosition(p); m_active_categories.front()->SetEnabledPosition(p);
Disable(m_active_categories.front()); Disable(m_active_categories.front());
} }
Context not available.

source/DataFormatters/TypeFormat.cpp

Context not available.
} }
} else } else
valobj_enum_type = iter->second; valobj_enum_type = iter->second;
if (valobj_enum_type.IsValid() == false) if (!valobj_enum_type.IsValid())
return false; return false;
DataExtractor data; DataExtractor data;
Status error; Status error;
Context not available.

source/DataFormatters/TypeSummary.cpp

Context not available.
const TypeSummaryOptions &options) { const TypeSummaryOptions &options) {
dest.clear(); dest.clear();
StreamString stream; StreamString stream;
if (!m_impl || m_impl(*valobj, stream, options) == false) if (!m_impl || !m_impl(*valobj, stream, options))
return false; return false;
dest = stream.GetString(); dest = stream.GetString();
return true; return true;
Context not available.

source/DataFormatters/ValueObjectPrinter.cpp

Context not available.
} }
if (m_valobj->IsSynthetic()) { if (m_valobj->IsSynthetic()) {
if (m_options.m_use_synthetic == false) { if (!m_options.m_use_synthetic) {
ValueObject *non_synthetic = m_valobj->GetNonSyntheticValue().get(); ValueObject *non_synthetic = m_valobj->GetNonSyntheticValue().get();
if (non_synthetic) if (non_synthetic)
m_valobj = non_synthetic; m_valobj = non_synthetic;
} }
} else { } else {
if (m_options.m_use_synthetic == true) { if (m_options.m_use_synthetic) {
ValueObject *synthetic = m_valobj->GetSyntheticValue().get(); ValueObject *synthetic = m_valobj->GetSyntheticValue().get();
if (synthetic) if (synthetic)
m_valobj = synthetic; m_valobj = synthetic;
Context not available.
bool ValueObjectPrinter::ShouldPrintValueObject() { bool ValueObjectPrinter::ShouldPrintValueObject() {
if (m_should_print == eLazyBoolCalculate) if (m_should_print == eLazyBoolCalculate)
m_should_print = m_should_print =
(m_options.m_flat_output == false || m_type_flags.Test(eTypeHasValue)) (!m_options.m_flat_output || m_type_flags.Test(eTypeHasValue))
? eLazyBoolYes ? eLazyBoolYes
: eLazyBoolNo; : eLazyBoolNo;
return m_should_print == eLazyBoolYes; return m_should_print == eLazyBoolYes;
Context not available.
} }
TypeSummaryImpl *ValueObjectPrinter::GetSummaryFormatter(bool null_if_omitted) { TypeSummaryImpl *ValueObjectPrinter::GetSummaryFormatter(bool null_if_omitted) {
if (m_summary_formatter.second == false) { if (!m_summary_formatter.second) {
TypeSummaryImpl *entry = m_options.m_summary_sp TypeSummaryImpl *entry = m_options.m_summary_sp
? m_options.m_summary_sp.get() ? m_options.m_summary_sp.get()
: m_valobj->GetSummaryFormat().get(); : m_valobj->GetSummaryFormat().get();
Context not available.
else else
m_stream->Printf("%s\n", object_desc); m_stream->Printf("%s\n", object_desc);
return true; return true;
} else if (value_printed == false && summary_printed == false) } else if (!value_printed && !summary_printed)
return true; return true;
else else
return false; return false;
Context not available.
if (!IsAggregate()) if (!IsAggregate())
return false; return false;
if (m_options.m_reveal_empty_aggregates == false) { if (!m_options.m_reveal_empty_aggregates) {
if (value_printed || summary_printed) if (value_printed || summary_printed)
return false; return false;
} }
Context not available.

source/Expression/DWARFExpression.cpp

Context not available.
error_ptr->SetErrorString( error_ptr->SetErrorString(
"Expression stack needs at least 1 item for DW_OP_abs."); "Expression stack needs at least 1 item for DW_OP_abs.");
return false; return false;
} else if (stack.back().ResolveValue(exe_ctx).AbsoluteValue() == false) { } else if (!stack.back().ResolveValue(exe_ctx).AbsoluteValue()) {
if (error_ptr) if (error_ptr)
error_ptr->SetErrorString( error_ptr->SetErrorString(
"Failed to take the absolute value of the first stack item."); "Failed to take the absolute value of the first stack item.");
Context not available.
"Expression stack needs at least 1 item for DW_OP_neg."); "Expression stack needs at least 1 item for DW_OP_neg.");
return false; return false;
} else { } else {
if (stack.back().ResolveValue(exe_ctx).UnaryNegate() == false) { if (!stack.back().ResolveValue(exe_ctx).UnaryNegate()) {
if (error_ptr) if (error_ptr)
error_ptr->SetErrorString("Unary negate failed."); error_ptr->SetErrorString("Unary negate failed.");
return false; return false;
Context not available.
"Expression stack needs at least 1 item for DW_OP_not."); "Expression stack needs at least 1 item for DW_OP_not.");
return false; return false;
} else { } else {
if (stack.back().ResolveValue(exe_ctx).OnesComplement() == false) { if (!stack.back().ResolveValue(exe_ctx).OnesComplement()) {
if (error_ptr) if (error_ptr)
error_ptr->SetErrorString("Logical NOT failed."); error_ptr->SetErrorString("Logical NOT failed.");
return false; return false;
Context not available.
} else { } else {
tmp = stack.back(); tmp = stack.back();
stack.pop_back(); stack.pop_back();
if (stack.back().ResolveValue(exe_ctx).ShiftRightLogical( if (!stack.back().ResolveValue(exe_ctx).ShiftRightLogical(
tmp.ResolveValue(exe_ctx)) == false) { tmp.ResolveValue(exe_ctx))) {
if (error_ptr) if (error_ptr)
error_ptr->SetErrorString("DW_OP_shr failed."); error_ptr->SetErrorString("DW_OP_shr failed.");
return false; return false;
Context not available.

source/Expression/ExpressionSourceCode.cpp

Context not available.
if (m_file_stack.back() != m_current_file) if (m_file_stack.back() != m_current_file)
return true; return true;
if (line >= m_current_file_line) return line < m_current_file_line;
return false;
else
return true;
default: default:
return false; return false;
} }
Context not available.
return false; return false;
start_loc += strlen(start_marker); start_loc += strlen(start_marker);
end_loc = transformed_text.find(end_marker); end_loc = transformed_text.find(end_marker);
if (end_loc == std::string::npos) return end_loc != std::string::npos;
return false;
return true;
} }
Context not available.

source/Expression/Materializer.cpp

Context not available.
if (data.GetByteSize() < m_variable_sp->GetType()->GetByteSize()) { if (data.GetByteSize() < m_variable_sp->GetType()->GetByteSize()) {
if (data.GetByteSize() == 0 && if (data.GetByteSize() == 0 &&
m_variable_sp->LocationExpression().IsValid() == false) { !m_variable_sp->LocationExpression().IsValid()) {
err.SetErrorStringWithFormat("the variable '%s' has no location, " err.SetErrorStringWithFormat("the variable '%s' has no location, "
"it may have been optimized out", "it may have been optimized out",
m_variable_sp->GetName().AsCString()); m_variable_sp->GetName().AsCString());
Context not available.

source/Host/common/Editline.cpp

Context not available.
// Treat moving from the "live" entry differently // Treat moving from the "live" entry differently
if (!m_in_history) { if (!m_in_history) {
if (earlier == false) if (!earlier)
return CC_ERROR; // Can't go newer than the "live" entry return CC_ERROR; // Can't go newer than the "live" entry
if (history_w(pHistory, &history_event, H_FIRST) == -1) if (history_w(pHistory, &history_event, H_FIRST) == -1)
return CC_ERROR; return CC_ERROR;
Context not available.

source/Host/common/FileCache.cpp

Context not available.
} }
FileSP file_sp(new File()); FileSP file_sp(new File());
error = FileSystem::Instance().Open(*file_sp, file_spec, flags, mode); error = FileSystem::Instance().Open(*file_sp, file_spec, flags, mode);
if (file_sp->IsValid() == false) if (!file_sp->IsValid())
return UINT64_MAX; return UINT64_MAX;
lldb::user_id_t fd = file_sp->GetDescriptor(); lldb::user_id_t fd = file_sp->GetDescriptor();
m_cache[fd] = file_sp; m_cache[fd] = file_sp;
Context not available.

source/Host/common/ProcessRunLock.cpp

Context not available.
bool ProcessRunLock::ReadTryLock() { bool ProcessRunLock::ReadTryLock() {
::pthread_rwlock_rdlock(&m_rwlock); ::pthread_rwlock_rdlock(&m_rwlock);
if (m_running == false) { if (!m_running) {
return true; return true;
} }
::pthread_rwlock_unlock(&m_rwlock); ::pthread_rwlock_unlock(&m_rwlock);
Context not available.

source/Host/common/Symbols.cpp

Context not available.
ModuleSpec dsym_module_spec; ModuleSpec dsym_module_spec;
// First try and find the dSYM in the same directory as the executable or in // First try and find the dSYM in the same directory as the executable or in
// an appropriate parent directory // an appropriate parent directory
if (LocateDSYMInVincinityOfExecutable(module_spec, symbol_fspec) == false) { if (!LocateDSYMInVincinityOfExecutable(module_spec, symbol_fspec)) {
// We failed to easily find the dSYM above, so use DebugSymbols // We failed to easily find the dSYM above, so use DebugSymbols
LocateMacOSXFilesUsingDebugSymbols(module_spec, dsym_module_spec); LocateMacOSXFilesUsingDebugSymbols(module_spec, dsym_module_spec);
} else { } else {
Context not available.

source/Host/common/XML.cpp

Context not available.
llvm::StringRef attr_value; llvm::StringRef attr_value;
if (child->content) if (child->content)
attr_value = llvm::StringRef((const char *)child->content); attr_value = llvm::StringRef((const char *)child->content);
if (callback(llvm::StringRef((const char *)attr->name), attr_value) == if (!callback(llvm::StringRef((const char *)attr->name), attr_value))
false)
return; return;
} }
} }
Context not available.
if (IsValid()) { if (IsValid()) {
// iterate through all siblings // iterate through all siblings
for (xmlNodePtr node = m_node; node; node = node->next) { for (xmlNodePtr node = m_node; node; node = node->next) {
if (callback(XMLNode(node)) == false) if (!callback(XMLNode(node)))
return; return;
} }
} }
Context not available.
if (node->type != XML_ELEMENT_NODE) if (node->type != XML_ELEMENT_NODE)
continue; continue;
if (callback(XMLNode(node)) == false) if (!callback(XMLNode(node)))
return; return;
} }
} }
Context not available.
// ignore this one // ignore this one
} }
if (callback(XMLNode(node)) == false) if (!callback(XMLNode(node)))
return; return;
} }
} }
Context not available.

source/Host/macosx/Symbols.cpp

Context not available.
// DBGSourcePath values (the "values" half of key-value path pairs) // DBGSourcePath values (the "values" half of key-value path pairs)
// were wrong. Ignore them and use the universal DBGSourcePath // were wrong. Ignore them and use the universal DBGSourcePath
// string from earlier. // string from earlier.
if (new_style_source_remapping_dictionary == true && if (new_style_source_remapping_dictionary &&
!original_DBGSourcePath_value.empty()) { !original_DBGSourcePath_value.empty()) {
DBGSourcePath = original_DBGSourcePath_value; DBGSourcePath = original_DBGSourcePath_value;
} }
Context not available.
// it once per lldb run and cache the result. // it once per lldb run and cache the result.
static bool g_have_checked_for_dbgshell_command = false; static bool g_have_checked_for_dbgshell_command = false;
static const char *g_dbgshell_command = NULL; static const char *g_dbgshell_command = NULL;
if (g_have_checked_for_dbgshell_command == false) { if (!g_have_checked_for_dbgshell_command) {
g_have_checked_for_dbgshell_command = true; g_have_checked_for_dbgshell_command = true;
CFTypeRef defaults_setting = CFPreferencesCopyAppValue( CFTypeRef defaults_setting = CFPreferencesCopyAppValue(
CFSTR("DBGShellCommands"), CFSTR("com.apple.DebugSymbols")); CFSTR("DBGShellCommands"), CFSTR("com.apple.DebugSymbols"));
Context not available.
// When g_dbgshell_command is NULL, the user has not enabled the use of an // When g_dbgshell_command is NULL, the user has not enabled the use of an
// external program to find the symbols, don't run it for them. // external program to find the symbols, don't run it for them.
if (force_lookup == false && g_dbgshell_command == NULL) { if (!force_lookup && g_dbgshell_command == NULL) {
return false; return false;
} }
Context not available.

source/Host/macosx/cfcpp/CFCMutableArray.cpp

Context not available.
bool CFCMutableArray::AppendValue(const void *value, bool can_create) { bool CFCMutableArray::AppendValue(const void *value, bool can_create) {
CFMutableArrayRef array = get(); CFMutableArrayRef array = get();
if (array == NULL) { if (array == NULL) {
if (can_create == false) if (!can_create)
return false; return false;
array = array =
::CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks); ::CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
Context not available.
bool can_create) { bool can_create) {
CFMutableArrayRef array = get(); CFMutableArrayRef array = get();
if (array == NULL) { if (array == NULL) {
if (can_create == false) if (!can_create)
return false; return false;
array = array =
::CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks); ::CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
Context not available.
const char *s, bool can_create) { const char *s, bool can_create) {
CFMutableArrayRef array = get(); CFMutableArrayRef array = get();
if (array == NULL) { if (array == NULL) {
if (can_create == false) if (!can_create)
return false; return false;
array = array =
::CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks); ::CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
Context not available.

source/Host/macosx/cfcpp/CFCMutableSet.cpp

Context not available.
const void *CFCMutableSet::AddValue(const void *value, bool can_create) { const void *CFCMutableSet::AddValue(const void *value, bool can_create) {
CFMutableSetRef set = get(); CFMutableSetRef set = get();
if (set == NULL) { if (set == NULL) {
if (can_create == false) if (!can_create)
return NULL; return NULL;
set = ::CFSetCreateMutable(kCFAllocatorDefault, 0, &kCFTypeSetCallBacks); set = ::CFSetCreateMutable(kCFAllocatorDefault, 0, &kCFTypeSetCallBacks);
reset(set); reset(set);
Context not available.

source/Host/macosx/objcxx/Host.mm

Context not available.
bool host_cpu_is_64bit; bool host_cpu_is_64bit;
uint32_t is64bit_capable; uint32_t is64bit_capable;
size_t is64bit_capable_len = sizeof(is64bit_capable); size_t is64bit_capable_len = sizeof(is64bit_capable);
if (sysctlbyname("hw.cpu64bit_capable", &is64bit_capable, host_cpu_is_64bit =
&is64bit_capable_len, NULL, 0) == 0) sysctlbyname("hw.cpu64bit_capable", &is64bit_capable,
host_cpu_is_64bit = true; &is64bit_capable_len, NULL, 0) == 0;
else
host_cpu_is_64bit = false;
// if the host is an armv8 device, its cpusubtype will be in // if the host is an armv8 device, its cpusubtype will be in
// CPU_SUBTYPE_ARM64 numbering // CPU_SUBTYPE_ARM64 numbering
Context not available.
if (our_uid == 0) if (our_uid == 0)
kinfo_user_matches = true; kinfo_user_matches = true;
if (kinfo_user_matches == false || // Make sure the user is acceptable if (!kinfo_user_matches || // Make sure the user is acceptable
static_cast<lldb::pid_t>(kinfo.kp_proc.p_pid) == static_cast<lldb::pid_t>(kinfo.kp_proc.p_pid) ==
our_pid || // Skip this process our_pid || // Skip this process
kinfo.kp_proc.p_pid == 0 || // Skip kernel (kernel pid is zero) kinfo.kp_proc.p_pid == 0 || // Skip kernel (kernel pid is zero)
Context not available.

source/Interpreter/CommandInterpreter.cpp

Context not available.
if (!name.empty()) { if (!name.empty()) {
// do not allow replacement of internal commands // do not allow replacement of internal commands
if (CommandExists(name)) { if (CommandExists(name)) {
if (can_replace == false) if (!can_replace)
return false; return false;
if (m_command_dict[name]->IsRemovable() == false) if (!m_command_dict[name]->IsRemovable())
return false; return false;
} }
if (UserCommandExists(name)) { if (UserCommandExists(name)) {
if (can_replace == false) if (!can_replace)
return false; return false;
if (m_user_dict[name]->IsRemovable() == false) if (!m_user_dict[name]->IsRemovable())
return false; return false;
} }
Context not available.
profilePath.AppendPathComponent(".lldbinit"); profilePath.AppendPathComponent(".lldbinit");
std::string init_file_path = profilePath.GetPath(); std::string init_file_path = profilePath.GetPath();
if (m_skip_app_init_files == false) { if (!m_skip_app_init_files) {
FileSpec program_file_spec(HostInfo::GetProgramFileSpec()); FileSpec program_file_spec(HostInfo::GetProgramFileSpec());
const char *program_name = program_file_spec.GetFilename().AsCString(); const char *program_name = program_file_spec.GetFilename().AsCString();
Context not available.
return; return;
const bool is_interactive = io_handler.GetIsInteractive(); const bool is_interactive = io_handler.GetIsInteractive();
if (is_interactive == false) { if (!is_interactive) {
// When we are not interactive, don't execute blank lines. This will happen // When we are not interactive, don't execute blank lines. This will happen
// sourcing a commands file. We don't want blank lines to repeat the // sourcing a commands file. We don't want blank lines to repeat the
// previous command and cause any errors to occur (like redefining an // previous command and cause any errors to occur (like redefining an
Context not available.
bool is_alias = GetAliasFullName(next_word, full_name); bool is_alias = GetAliasFullName(next_word, full_name);
cmd_obj = GetCommandObject(next_word, &matches); cmd_obj = GetCommandObject(next_word, &matches);
bool is_real_command = bool is_real_command =
(is_alias == false) || (!is_alias) || (cmd_obj != nullptr && !cmd_obj->IsAlias());
(cmd_obj != nullptr && cmd_obj->IsAlias() == false);
if (!is_real_command) { if (!is_real_command) {
matches.Clear(); matches.Clear();
std::string alias_result; std::string alias_result;
Context not available.

source/Interpreter/CommandObject.cpp

Context not available.
} }
bool CommandObject::IsPairType(ArgumentRepetitionType arg_repeat_type) { bool CommandObject::IsPairType(ArgumentRepetitionType arg_repeat_type) {
if ((arg_repeat_type == eArgRepeatPairPlain) || return (arg_repeat_type == eArgRepeatPairPlain) ||
(arg_repeat_type == eArgRepeatPairOptional) || (arg_repeat_type == eArgRepeatPairOptional) ||
(arg_repeat_type == eArgRepeatPairPlus) || (arg_repeat_type == eArgRepeatPairPlus) ||
(arg_repeat_type == eArgRepeatPairStar) || (arg_repeat_type == eArgRepeatPairStar) ||
(arg_repeat_type == eArgRepeatPairRange) || (arg_repeat_type == eArgRepeatPairRange) ||
(arg_repeat_type == eArgRepeatPairRangeOptional)) (arg_repeat_type == eArgRepeatPairRangeOptional);
return true;
return false;
} }
static CommandObject::CommandArgumentEntry static CommandObject::CommandArgumentEntry
Context not available.

source/Interpreter/OptionGroupVariable.cpp

Context not available.
if (!str || !str[0]) if (!str || !str[0])
return Status("must specify a valid named summary"); return Status("must specify a valid named summary");
TypeSummaryImplSP summary_sp; TypeSummaryImplSP summary_sp;
if (DataVisualization::NamedSummaryFormats::GetSummaryFormat( if (!DataVisualization::NamedSummaryFormats::GetSummaryFormat(
ConstString(str), summary_sp) == false) ConstString(str), summary_sp))
return Status("must specify a valid named summary"); return Status("must specify a valid named summary");
return Status(); return Status();
} }
Context not available.

source/Interpreter/OptionValueProperties.cpp

Context not available.
for (size_t i = 0; i < num_properties; ++i) { for (size_t i = 0; i < num_properties; ++i) {
// Duplicate any values that are not global when constructing properties // Duplicate any values that are not global when constructing properties
// from a global copy // from a global copy
if (m_properties[i].IsGlobal() == false) { if (!m_properties[i].IsGlobal()) {
lldb::OptionValueSP new_value_sp(m_properties[i].GetValue()->DeepCopy()); lldb::OptionValueSP new_value_sp(m_properties[i].GetValue()->DeepCopy());
m_properties[i].SetOptionValue(new_value_sp); m_properties[i].SetOptionValue(new_value_sp);
} }
Context not available.
else { else {
// Don't set an error if the path contained .experimental. - those are // Don't set an error if the path contained .experimental. - those are
// allowed to be missing and should silently fail. // allowed to be missing and should silently fail.
if (name_contains_experimental == false && error.AsCString() == nullptr) { if (!name_contains_experimental && error.AsCString() == nullptr) {
error.SetErrorStringWithFormat("invalid value path '%s'", name.str().c_str()); error.SetErrorStringWithFormat("invalid value path '%s'", name.str().c_str());
} }
} }
Context not available.

source/Interpreter/Options.cpp

Context not available.
} }
} }
if (options.empty() == false) { if (!options.empty()) {
// We have some required options with no arguments // We have some required options with no arguments
strm.PutCString(" -"); strm.PutCString(" -");
for (i = 0; i < 2; ++i) for (i = 0; i < 2; ++i)
Context not available.
if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) { if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
// Add current option to the end of out_stream. // Add current option to the end of out_stream.
if (def.required == false && if (!def.required &&
def.option_has_arg == OptionParser::eNoArgument) { def.option_has_arg == OptionParser::eNoArgument) {
options.insert(def.short_option); options.insert(def.short_option);
} }
} }
} }
if (options.empty() == false) { if (!options.empty()) {
// We have some required options with no arguments // We have some required options with no arguments
strm.PutCString(" [-"); strm.PutCString(" [-");
for (i = 0; i < 2; ++i) for (i = 0; i < 2; ++i)
Context not available.

source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

Context not available.
~1ull; // clear bit zero since the CPSR will take care of the mode for us ~1ull; // clear bit zero since the CPSR will take care of the mode for us
// Set "pc" to the address requested // Set "pc" to the address requested
if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_num, function_addr)) return reg_ctx->WriteRegisterFromUnsigned(pc_reg_num, function_addr);
return false;
return true;
} }
bool ABISysV_arm::GetArgumentValues(Thread &thread, ValueList &values) const { bool ABISysV_arm::GetArgumentValues(Thread &thread, ValueList &values) const {
Context not available.

source/Plugins/ABI/SysV-s390x/ABISysV_s390x.h

Context not available.
bool CodeAddressIsValid(lldb::addr_t pc) override { bool CodeAddressIsValid(lldb::addr_t pc) override {
// Code addressed must be 2 byte aligned // Code addressed must be 2 byte aligned
if (pc & 1ull) return (pc & 1ull) == 0;
return false;
return true;
} }
const lldb_private::RegisterInfo * const lldb_private::RegisterInfo *
Context not available.

source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp

Context not available.
if (triple.getArch() == llvm::Triple::x86 || if (triple.getArch() == llvm::Triple::x86 ||
triple.getArch() == llvm::Triple::x86_64) { triple.getArch() == llvm::Triple::x86_64) {
if (strcmp(flavor, "intel") == 0 || strcmp(flavor, "att") == 0) return strcmp(flavor, "intel") == 0 || strcmp(flavor, "att") == 0;
return true;
else
return false;
} else } else
return false; return false;
} }
Context not available.

source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

Context not available.
if (::memcmp (&header.magic, &magicks[i], sizeof (uint32_t)) == 0) if (::memcmp (&header.magic, &magicks[i], sizeof (uint32_t)) == 0)
found_matching_pattern = true; found_matching_pattern = true;
if (found_matching_pattern == false) if (!found_matching_pattern)
return false; return false;
if (header.magic == llvm::MachO::MH_CIGAM || if (header.magic == llvm::MachO::MH_CIGAM ||
header.magic == llvm::MachO::MH_CIGAM_64) { header.magic == llvm::MachO::MH_CIGAM_64) {
Context not available.
llvm::MachO::mach_header header; llvm::MachO::mach_header header;
if (ReadMachHeader (addr, process, header) == false) if (!ReadMachHeader(addr, process, header))
return UUID(); return UUID();
// First try a quick test -- read the first 4 bytes and see if there is a // First try a quick test -- read the first 4 bytes and see if there is a
Context not available.
bool DynamicLoaderDarwinKernel::KextImageInfo:: bool DynamicLoaderDarwinKernel::KextImageInfo::
operator==(const KextImageInfo &rhs) { operator==(const KextImageInfo &rhs) {
if (m_uuid.IsValid() || rhs.GetUUID().IsValid()) { if (m_uuid.IsValid() || rhs.GetUUID().IsValid()) {
if (m_uuid == rhs.GetUUID()) { return m_uuid == rhs.GetUUID();
return true;
}
return false;
} }
if (m_name == rhs.GetName() && m_load_address == rhs.GetLoadAddress()) return m_name == rhs.GetName() && m_load_address == rhs.GetLoadAddress();
return true;
return false;
} }
void DynamicLoaderDarwinKernel::KextImageInfo::SetName(const char *name) { void DynamicLoaderDarwinKernel::KextImageInfo::SetName(const char *name) {
Context not available.
} }
bool DynamicLoaderDarwinKernel::KextImageInfo::IsKernel() const { bool DynamicLoaderDarwinKernel::KextImageInfo::IsKernel() const {
return m_kernel_image == true; return m_kernel_image;
} }
void DynamicLoaderDarwinKernel::KextImageInfo::SetIsKernel(bool is_kernel) { void DynamicLoaderDarwinKernel::KextImageInfo::SetIsKernel(bool is_kernel) {
Context not available.
const uint32_t num_of_new_kexts = kext_summaries.size(); const uint32_t num_of_new_kexts = kext_summaries.size();
for (uint32_t new_kext = 0; new_kext < num_of_new_kexts; new_kext++) { for (uint32_t new_kext = 0; new_kext < num_of_new_kexts; new_kext++) {
if (to_be_added[new_kext] == true) { if (to_be_added[new_kext]) {
KextImageInfo &image_info = kext_summaries[new_kext]; KextImageInfo &image_info = kext_summaries[new_kext];
if (load_kexts) { if (load_kexts) {
if (!image_info.LoadImageUsingMemoryModule(m_process)) { if (!image_info.LoadImageUsingMemoryModule(m_process)) {
Context not available.

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

Context not available.
if (image_sp.get() == nullptr || image_sp->GetAsDictionary() == nullptr) if (image_sp.get() == nullptr || image_sp->GetAsDictionary() == nullptr)
return false; return false;
StructuredData::Dictionary *image = image_sp->GetAsDictionary(); StructuredData::Dictionary *image = image_sp->GetAsDictionary();
if (image->HasKey("load_address") == false || if (!image->HasKey("load_address") || !image->HasKey("pathname") ||
image->HasKey("pathname") == false || !image->HasKey("mod_date") || !image->HasKey("mach_header") ||
aprantlUnsubmitted
Done
ReplyInline Actions

here the indentation actually got worse

aprantl: here the indentation actually got worse
image->HasKey("mod_date") == false ||
image->HasKey("mach_header") == false ||
image->GetValueForKey("mach_header")->GetAsDictionary() == nullptr || image->GetValueForKey("mach_header")->GetAsDictionary() == nullptr ||
image->HasKey("segments") == false || !image->HasKey("segments") ||
image->GetValueForKey("segments")->GetAsArray() == nullptr || image->GetValueForKey("segments")->GetAsArray() == nullptr ||
image->HasKey("uuid") == false) { !image->HasKey("uuid")) {
return false; return false;
} }
image_infos[i].address = image_infos[i].address =
Context not available.
return false; return false;
ObjCLanguageRuntime *objc_runtime = m_process->GetObjCLanguageRuntime(); ObjCLanguageRuntime *objc_runtime = m_process->GetObjCLanguageRuntime();
if (objc_runtime != NULL && objc_runtime->IsModuleObjCLibrary(module_sp)) { return objc_runtime != NULL && objc_runtime->IsModuleObjCLibrary(module_sp);
return true;
}
return false;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Context not available.

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp

Context not available.
} }
} }
if (UseDYLDSPI(process) == false) { if (!UseDYLDSPI(process)) {
create = false; create = false;
} }
Context not available.
info_dict->GetValueForKey("shared_cache_uuid")->GetStringValue(); info_dict->GetValueForKey("shared_cache_uuid")->GetStringValue();
if (!uuid_str.empty()) if (!uuid_str.empty())
uuid.SetFromStringRef(uuid_str); uuid.SetFromStringRef(uuid_str);
if (info_dict->GetValueForKey("no_shared_cache")->GetBooleanValue() == if (!info_dict->GetValueForKey("no_shared_cache")->GetBooleanValue())
false)
using_shared_cache = eLazyBoolYes; using_shared_cache = eLazyBoolYes;
else else
using_shared_cache = eLazyBoolNo; using_shared_cache = eLazyBoolNo;
Context not available.

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

Context not available.
} }
} }
if (UseDYLDSPI(process) == true) { if (UseDYLDSPI(process)) {
create = false; create = false;
} }
Context not available.
// value differs from the Process' image info address. When a process // value differs from the Process' image info address. When a process
// execs itself it might cause a change if ASLR is enabled. // execs itself it might cause a change if ASLR is enabled.
const addr_t shlib_addr = m_process->GetImageInfoAddress(); const addr_t shlib_addr = m_process->GetImageInfoAddress();
if (m_process_image_addr_is_all_images_infos == true && if (m_process_image_addr_is_all_images_infos &&
shlib_addr != m_dyld_all_image_infos_addr) { shlib_addr != m_dyld_all_image_infos_addr) {
// The image info address from the process is the // The image info address from the process is the
// 'dyld_all_image_infos' address and it has changed. // 'dyld_all_image_infos' address and it has changed.
did_exec = true; did_exec = true;
} else if (m_process_image_addr_is_all_images_infos == false && } else if (!m_process_image_addr_is_all_images_infos &&
shlib_addr == m_dyld.address) { shlib_addr == m_dyld.address) {
// The image info address from the process is the mach_header address // The image info address from the process is the mach_header address
// for dyld and it has changed. // for dyld and it has changed.
Context not available.

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

Context not available.
// On Android L (API 21, 22) the load address of the "/system/bin/linker" // On Android L (API 21, 22) the load address of the "/system/bin/linker"
// isn't filled in correctly. // isn't filled in correctly.
unsigned os_major = target.GetPlatform()->GetOSVersion().getMajor(); unsigned os_major = target.GetPlatform()->GetOSVersion().getMajor();
if (target.GetArchitecture().GetTriple().isAndroid() && return target.GetArchitecture().GetTriple().isAndroid() &&
(os_major == 21 || os_major == 22) && (os_major == 21 || os_major == 22) &&
(file_path == "/system/bin/linker" || (file_path == "/system/bin/linker" ||
file_path == "/system/bin/linker64")) { file_path == "/system/bin/linker64");
return true;
}
return false;
} }
void DYLDRendezvous::UpdateBaseAddrIfNecessary(SOEntry &entry, void DYLDRendezvous::UpdateBaseAddrIfNecessary(SOEntry &entry,
Context not available.

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

Context not available.
EvalSpecialModulesStatus(); EvalSpecialModulesStatus();
// if we dont have a load address we cant re-base // if we dont have a load address we cant re-base
bool rebase_exec = (load_offset == LLDB_INVALID_ADDRESS) ? false : true; bool rebase_exec = load_offset != LLDB_INVALID_ADDRESS;
// if we have a valid executable // if we have a valid executable
if (executable_sp.get()) { if (executable_sp.get()) {
Context not available.

source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

Context not available.
StringRef name_string_ref = name.GetStringRef(); StringRef name_string_ref = name.GetStringRef();
// The ClangASTSource is not responsible for finding $-names. // The ClangASTSource is not responsible for finding $-names.
if (name_string_ref.empty() || return name_string_ref.empty() ||
(ignore_all_dollar_names && name_string_ref.startswith("$")) || (ignore_all_dollar_names && name_string_ref.startswith("$")) ||
name_string_ref.startswith("_$")) name_string_ref.startswith("_$");
return true;
return false;
} }
void ClangASTSource::FindExternalVisibleDecls( void ClangASTSource::FindExternalVisibleDecls(
Context not available.

source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

Context not available.
static bool IsObjCSelectorRef(Value *value) { static bool IsObjCSelectorRef(Value *value) {
GlobalVariable *global_variable = dyn_cast<GlobalVariable>(value); GlobalVariable *global_variable = dyn_cast<GlobalVariable>(value);
if (!global_variable || !global_variable->hasName() || return !(!global_variable || !global_variable->hasName() ||
!global_variable->getName().startswith("OBJC_SELECTOR_REFERENCES_")) !global_variable->getName().startswith("OBJC_SELECTOR_REFERENCES_"));
return false;
return true;
} }
// This function does not report errors; its callers are responsible. // This function does not report errors; its callers are responsible.
Context not available.
static bool IsObjCClassReference(Value *value) { static bool IsObjCClassReference(Value *value) {
GlobalVariable *global_variable = dyn_cast<GlobalVariable>(value); GlobalVariable *global_variable = dyn_cast<GlobalVariable>(value);
if (!global_variable || !global_variable->hasName() || return !(!global_variable || !global_variable->hasName() ||
!global_variable->getName().startswith("OBJC_CLASS_REFERENCES_")) !global_variable->getName().startswith("OBJC_CLASS_REFERENCES_"));
return false;
return true;
} }
// This function does not report errors; its callers are responsible. // This function does not report errors; its callers are responsible.
Context not available.
llvm::NextPowerOf2(constant_size) * 8); llvm::NextPowerOf2(constant_size) * 8);
lldb_private::Status get_data_error; lldb_private::Status get_data_error;
if (!scalar.GetAsMemoryData(data, constant_size, return scalar.GetAsMemoryData(data, constant_size,
lldb_private::endian::InlHostByteOrder(), lldb_private::endian::InlHostByteOrder(),
get_data_error)) get_data_error) != 0;
return false;
return true;
} else if (ConstantDataArray *array_initializer = } else if (ConstantDataArray *array_initializer =
dyn_cast<ConstantDataArray>(initializer)) { dyn_cast<ConstantDataArray>(initializer)) {
if (array_initializer->isString()) { if (array_initializer->isString()) {
Context not available.

source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp

Context not available.
uint32_t random_data = rand(); uint32_t random_data = rand();
const uint32_t addr_byte_size = GetAddressByteSize(); const uint32_t addr_byte_size = GetAddressByteSize();
if (!MemAWrite(context, address, random_data, addr_byte_size)) return MemAWrite(context, address, random_data, addr_byte_size);
return false;
return true;
} }
// Write "bits (32) UNKNOWN" to register n. Helper function for many ARM // Write "bits (32) UNKNOWN" to register n. Helper function for many ARM
Context not available.
EmulateInstruction::Context context; EmulateInstruction::Context context;
context.type = EmulateInstruction::eContextImmediate; context.type = EmulateInstruction::eContextImmediate;
context.SetNoArgs(); context.SetNoArgs();
if (!WriteFlags(context, res.result, res.carry_out, res.overflow)) return WriteFlags(context, res.result, res.carry_out, res.overflow);
return false;
return true;
} }
// Compare Negative (register) adds a register value and an optionally-shifted // Compare Negative (register) adds a register value and an optionally-shifted
Context not available.
EmulateInstruction::Context context; EmulateInstruction::Context context;
context.type = EmulateInstruction::eContextImmediate; context.type = EmulateInstruction::eContextImmediate;
context.SetNoArgs(); context.SetNoArgs();
if (!WriteFlags(context, res.result, res.carry_out, res.overflow)) return WriteFlags(context, res.result, res.carry_out, res.overflow);
return false;
return true;
} }
// Compare (immediate) subtracts an immediate value from a register value. It // Compare (immediate) subtracts an immediate value from a register value. It
Context not available.
EmulateInstruction::Context context; EmulateInstruction::Context context;
context.type = EmulateInstruction::eContextImmediate; context.type = EmulateInstruction::eContextImmediate;
context.SetNoArgs(); context.SetNoArgs();
if (!WriteFlags(context, res.result, res.carry_out, res.overflow)) return WriteFlags(context, res.result, res.carry_out, res.overflow);
return false;
return true;
} }
// Compare (register) subtracts an optionally-shifted register value from a // Compare (register) subtracts an optionally-shifted register value from a
Context not available.
EmulateInstruction::Context context; EmulateInstruction::Context context;
context.type = EmulateInstruction::eContextImmediate; context.type = EmulateInstruction::eContextImmediate;
context.SetNoArgs(); context.SetNoArgs();
if (!WriteFlags(context, res.result, res.carry_out, res.overflow)) return WriteFlags(context, res.result, res.carry_out, res.overflow);
return false;
return true;
} }
// Arithmetic Shift Right (immediate) shifts a register value right by an // Arithmetic Shift Right (immediate) shifts a register value right by an
Context not available.
context.type = EmulateInstruction::eContextImmediate; context.type = EmulateInstruction::eContextImmediate;
context.SetNoArgs(); context.SetNoArgs();
if (!WriteCoreRegOptionalFlags(context, res.result, Rd, setflags, return WriteCoreRegOptionalFlags(context, res.result, Rd, setflags,
res.carry_out, res.overflow)) res.carry_out, res.overflow);
return false;
return true;
} }
// Reverse Subtract (register) subtracts a register value from an optionally- // Reverse Subtract (register) subtracts a register value from an optionally-
Context not available.
EmulateInstruction::Context context; EmulateInstruction::Context context;
context.type = EmulateInstruction::eContextImmediate; context.type = EmulateInstruction::eContextImmediate;
context.SetNoArgs(); context.SetNoArgs();
if (!WriteCoreRegOptionalFlags(context, res.result, Rd, setflags, return WriteCoreRegOptionalFlags(context, res.result, Rd, setflags,
res.carry_out, res.overflow)) res.carry_out, res.overflow);
return false;
return true;
} }
// Reverse Subtract with Carry (immediate) subtracts a register value and the // Reverse Subtract with Carry (immediate) subtracts a register value and the
Context not available.
context.type = EmulateInstruction::eContextImmediate; context.type = EmulateInstruction::eContextImmediate;
context.SetNoArgs(); context.SetNoArgs();
if (!WriteCoreRegOptionalFlags(context, res.result, Rd, setflags, return WriteCoreRegOptionalFlags(context, res.result, Rd, setflags,
res.carry_out, res.overflow)) res.carry_out, res.overflow);
return false;
return true;
} }
// Reverse Subtract with Carry (register) subtracts a register value and the // Reverse Subtract with Carry (register) subtracts a register value and the
Context not available.
EmulateInstruction::Context context; EmulateInstruction::Context context;
context.type = EmulateInstruction::eContextImmediate; context.type = EmulateInstruction::eContextImmediate;
context.SetNoArgs(); context.SetNoArgs();
if (!WriteCoreRegOptionalFlags(context, res.result, Rd, setflags, return WriteCoreRegOptionalFlags(context, res.result, Rd, setflags,
res.carry_out, res.overflow)) res.carry_out, res.overflow);
return false;
return true;
} }
// Subtract with Carry (immediate) subtracts an immediate value and the value // Subtract with Carry (immediate) subtracts an immediate value and the value
Context not available.
context.type = EmulateInstruction::eContextImmediate; context.type = EmulateInstruction::eContextImmediate;
context.SetNoArgs(); context.SetNoArgs();
if (!WriteCoreRegOptionalFlags(context, res.result, Rd, setflags, return WriteCoreRegOptionalFlags(context, res.result, Rd, setflags,
res.carry_out, res.overflow)) res.carry_out, res.overflow);
return false;
return true;
} }
// Subtract with Carry (register) subtracts an optionally-shifted register // Subtract with Carry (register) subtracts an optionally-shifted register
Context not available.
EmulateInstruction::Context context; EmulateInstruction::Context context;
context.type = EmulateInstruction::eContextImmediate; context.type = EmulateInstruction::eContextImmediate;
context.SetNoArgs(); context.SetNoArgs();
if (!WriteCoreRegOptionalFlags(context, res.result, Rd, setflags, return WriteCoreRegOptionalFlags(context, res.result, Rd, setflags,
res.carry_out, res.overflow)) res.carry_out, res.overflow);
return false;
return true;
} }
// This instruction subtracts an immediate value from a register value, and // This instruction subtracts an immediate value from a register value, and
Context not available.
context.type = EmulateInstruction::eContextImmediate; context.type = EmulateInstruction::eContextImmediate;
context.SetNoArgs(); context.SetNoArgs();
if (!WriteCoreRegOptionalFlags(context, res.result, Rd, setflags, return WriteCoreRegOptionalFlags(context, res.result, Rd, setflags,
res.carry_out, res.overflow)) res.carry_out, res.overflow);
return false;
return true;
} }
// This instruction subtracts an immediate value from a register value, and // This instruction subtracts an immediate value from a register value, and
Context not available.
else else
target = addr & 0xfffffffe; target = addr & 0xfffffffe;
if (!WriteRegisterUnsigned(context, eRegisterKindGeneric, return WriteRegisterUnsigned(context, eRegisterKindGeneric,
LLDB_REGNUM_GENERIC_PC, target)) LLDB_REGNUM_GENERIC_PC, target);
return false;
return true;
} }
// As a side effect, BXWritePC sets context.arg2 to eModeARM or eModeThumb by // As a side effect, BXWritePC sets context.arg2 to eModeARM or eModeThumb by
Context not available.
LLDB_REGNUM_GENERIC_FLAGS, m_new_inst_cpsr)) LLDB_REGNUM_GENERIC_FLAGS, m_new_inst_cpsr))
return false; return false;
} }
if (!WriteRegisterUnsigned(context, eRegisterKindGeneric, return WriteRegisterUnsigned(context, eRegisterKindGeneric,
LLDB_REGNUM_GENERIC_PC, target)) LLDB_REGNUM_GENERIC_PC, target);
return false;
return true;
} }
// Dispatches to either BXWritePC or BranchWritePC based on architecture // Dispatches to either BXWritePC or BranchWritePC based on architecture
Context not available.
evaluate_options & eEmulateInstructionOptionIgnoreConditions; evaluate_options & eEmulateInstructionOptionIgnoreConditions;
bool success = false; bool success = false;
if (m_opcode_cpsr == 0 || m_ignore_conditions == false) { if (m_opcode_cpsr == 0 || !m_ignore_conditions) {
m_opcode_cpsr = m_opcode_cpsr =
ReadRegisterUnsigned(eRegisterKindDWARF, dwarf_cpsr, 0, &success); ReadRegisterUnsigned(eRegisterKindDWARF, dwarf_cpsr, 0, &success);
} }
// Only return false if we are unable to read the CPSR if we care about // Only return false if we are unable to read the CPSR if we care about
// conditions // conditions
if (success == false && m_ignore_conditions == false) if (!success && !m_ignore_conditions)
return false; return false;
uint32_t orig_pc_value = 0; uint32_t orig_pc_value = 0;
Context not available.

source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

Context not available.
// Only return false if we are unable to read the CPSR if we care about // Only return false if we are unable to read the CPSR if we care about
// conditions // conditions
if (success == false && m_ignore_conditions == false) if (!success && !m_ignore_conditions)
return false; return false;
uint32_t orig_pc_value = 0; uint32_t orig_pc_value = 0;
Context not available.
} else } else
return false; return false;
if (!WriteRegisterUnsigned(context, eRegisterKindGeneric, return WriteRegisterUnsigned(context, eRegisterKindGeneric,
LLDB_REGNUM_GENERIC_PC, addr)) LLDB_REGNUM_GENERIC_PC, addr);
return false;
return true;
} }
bool EmulateInstructionARM64::ConditionHolds(const uint32_t cond) { bool EmulateInstructionARM64::ConditionHolds(const uint32_t cond) {
Context not available.
return false; return false;
} }
if (!BranchTo(context, 64, target)) return BranchTo(context, 64, target);
return false;
return true;
} }
bool EmulateInstructionARM64::EmulateBcond(const uint32_t opcode) { bool EmulateInstructionARM64::EmulateBcond(const uint32_t opcode) {
Context not available.

source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp

Context not available.
} }
bool EmulateInstructionMIPS::SetTargetTriple(const ArchSpec &arch) { bool EmulateInstructionMIPS::SetTargetTriple(const ArchSpec &arch) {
if (arch.GetTriple().getArch() == llvm::Triple::mips || return arch.GetTriple().getArch() == llvm::Triple::mips ||
arch.GetTriple().getArch() == llvm::Triple::mipsel) arch.GetTriple().getArch() == llvm::Triple::mipsel;
return true;
return false;
} }
const char *EmulateInstructionMIPS::GetRegisterName(unsigned reg_num, const char *EmulateInstructionMIPS::GetRegisterName(unsigned reg_num,
Context not available.
context.type = eContextPopRegisterOffStack; context.type = eContextPopRegisterOffStack;
context.SetAddress(address); context.SetAddress(address);
if (!WriteRegister(context, &reg_info_src, data_src)) return WriteRegister(context, &reg_info_src, data_src);
return false;
return true;
} }
return false; return false;
Context not available.
context.SetImmediateSigned(imm); context.SetImmediateSigned(imm);
context.type = eContextImmediate; context.type = eContextImmediate;
if (WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_zero_mips + rt, return WriteRegisterUnsigned(context, eRegisterKindDWARF,
imm)) dwarf_zero_mips + rt, imm);
return true;
return false;
} }
bool EmulateInstructionMIPS::Emulate_ADDIUSP(llvm::MCInst &insn) { bool EmulateInstructionMIPS::Emulate_ADDIUSP(llvm::MCInst &insn) {
Context not available.
context.type = eContextPopRegisterOffStack; context.type = eContextPopRegisterOffStack;
context.SetAddress(base_address); context.SetAddress(base_address);
if (!WriteRegister(context, &reg_info_src, data_src)) return WriteRegister(context, &reg_info_src, data_src);
return false;
return true;
} }
return false; return false;
Context not available.
context.type = eContextAdjustStackPointer; context.type = eContextAdjustStackPointer;
// update SP // update SP
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_sp_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_sp_mips,
result)) result);
return false;
return true;
} }
static int IsAdd64bitOverflow(int32_t a, int32_t b) { static int IsAdd64bitOverflow(int32_t a, int32_t b) {
Context not available.
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
context.SetImmediate(offset); context.SetImmediate(offset);
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
/* /*
Context not available.
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
context.SetImmediate(current_inst_size + offset); context.SetImmediate(current_inst_size + offset);
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
/* /*
Context not available.
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
context.SetImmediate(offset); context.SetImmediate(offset);
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
/* /*
Context not available.
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
context.SetImmediate(current_inst_size + offset); context.SetImmediate(current_inst_size + offset);
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS::Emulate_B16_MM(llvm::MCInst &insn) { bool EmulateInstructionMIPS::Emulate_B16_MM(llvm::MCInst &insn) {
Context not available.
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
context.SetImmediate(current_inst_size + offset); context.SetImmediate(current_inst_size + offset);
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
/* /*
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS::Emulate_J(llvm::MCInst &insn) { bool EmulateInstructionMIPS::Emulate_J(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, pc)) return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, pc);
return false;
return true;
} }
bool EmulateInstructionMIPS::Emulate_JAL(llvm::MCInst &insn) { bool EmulateInstructionMIPS::Emulate_JAL(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS::Emulate_JR(llvm::MCInst &insn) { bool EmulateInstructionMIPS::Emulate_JR(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
rs_val)) rs_val);
return false;
return true;
} }
/* /*
Context not available.
} }
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS::Emulate_BC1EQZ(llvm::MCInst &insn) { bool EmulateInstructionMIPS::Emulate_BC1EQZ(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS::Emulate_BC1NEZ(llvm::MCInst &insn) { bool EmulateInstructionMIPS::Emulate_BC1NEZ(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
/* /*
Context not available.
} }
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS::Emulate_BNZB(llvm::MCInst &insn) { bool EmulateInstructionMIPS::Emulate_BNZB(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS::Emulate_BNZV(llvm::MCInst &insn) { bool EmulateInstructionMIPS::Emulate_BNZV(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS::Emulate_LDST_Imm(llvm::MCInst &insn) { bool EmulateInstructionMIPS::Emulate_LDST_Imm(llvm::MCInst &insn) {
Context not available.

source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp

Context not available.
} }
bool EmulateInstructionMIPS64::SetTargetTriple(const ArchSpec &arch) { bool EmulateInstructionMIPS64::SetTargetTriple(const ArchSpec &arch) {
if (arch.GetTriple().getArch() == llvm::Triple::mips64 || return arch.GetTriple().getArch() == llvm::Triple::mips64 ||
arch.GetTriple().getArch() == llvm::Triple::mips64el) arch.GetTriple().getArch() == llvm::Triple::mips64el;
return true;
return false;
} }
const char *EmulateInstructionMIPS64::GetRegisterName(unsigned reg_num, const char *EmulateInstructionMIPS64::GetRegisterName(unsigned reg_num,
Context not available.
Context context; Context context;
context.type = eContextRegisterLoad; context.type = eContextRegisterLoad;
if (!WriteRegister(context, &reg_info_src, data_src)) return WriteRegister(context, &reg_info_src, data_src);
return false;
return true;
} }
return false; return false;
Context not available.
context.SetImmediateSigned(imm); context.SetImmediateSigned(imm);
context.type = eContextImmediate; context.type = eContextImmediate;
if (WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_zero_mips64 + rt, return WriteRegisterUnsigned(context, eRegisterKindDWARF,
imm)) dwarf_zero_mips64 + rt, imm);
return true;
return false;
} }
bool EmulateInstructionMIPS64::Emulate_DSUBU_DADDU(llvm::MCInst &insn) { bool EmulateInstructionMIPS64::Emulate_DSUBU_DADDU(llvm::MCInst &insn) {
Context not available.
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
context.SetImmediate(offset); context.SetImmediate(offset);
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
/* /*
Context not available.
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
context.SetImmediate(offset); context.SetImmediate(offset);
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS64::Emulate_BC(llvm::MCInst &insn) { bool EmulateInstructionMIPS64::Emulate_BC(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
static int IsAdd64bitOverflow(int64_t a, int64_t b) { static int IsAdd64bitOverflow(int64_t a, int64_t b) {
Context not available.
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
context.SetImmediate(current_inst_size + offset); context.SetImmediate(current_inst_size + offset);
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
/* /*
Context not available.
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
context.SetImmediate(current_inst_size + offset); context.SetImmediate(current_inst_size + offset);
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS64::Emulate_J(llvm::MCInst &insn) { bool EmulateInstructionMIPS64::Emulate_J(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, pc)) return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
return false; pc);
return true;
} }
bool EmulateInstructionMIPS64::Emulate_JAL(llvm::MCInst &insn) { bool EmulateInstructionMIPS64::Emulate_JAL(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS64::Emulate_JR(llvm::MCInst &insn) { bool EmulateInstructionMIPS64::Emulate_JR(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
rs_val)) rs_val);
return false;
return true;
} }
/* /*
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS64::Emulate_BC1EQZ(llvm::MCInst &insn) { bool EmulateInstructionMIPS64::Emulate_BC1EQZ(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS64::Emulate_BC1NEZ(llvm::MCInst &insn) { bool EmulateInstructionMIPS64::Emulate_BC1NEZ(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
/* /*
Context not available.
Context context; Context context;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS64::Emulate_BNZB(llvm::MCInst &insn) { bool EmulateInstructionMIPS64::Emulate_BNZB(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS64::Emulate_BNZV(llvm::MCInst &insn) { bool EmulateInstructionMIPS64::Emulate_BNZV(llvm::MCInst &insn) {
Context not available.
Context context; Context context;
context.type = eContextRelativeBranchImmediate; context.type = eContextRelativeBranchImmediate;
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64, return WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_pc_mips64,
target)) target);
return false;
return true;
} }
bool EmulateInstructionMIPS64::Emulate_LDST_Imm(llvm::MCInst &insn) { bool EmulateInstructionMIPS64::Emulate_LDST_Imm(llvm::MCInst &insn) {
Context not available.

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

Context not available.
} }
// We processed all characters. It is a vaild basename. // We processed all characters. It is a vaild basename.
if (idx == basename.size()) return idx == basename.size();
return true;
return false;
} }
bool CPlusPlusLanguage::MethodName::TrySimplifiedParse() { bool CPlusPlusLanguage::MethodName::TrySimplifiedParse() {
Context not available.

source/Plugins/Language/ObjC/CF.cpp

Context not available.
} }
} }
if (is_type_ok == false) if (!is_type_ok)
return false; return false;
Status error; Status error;
Context not available.

source/Plugins/Language/ObjC/NSException.cpp

Context not available.
m_userinfo_sp.reset(); m_userinfo_sp.reset();
m_reserved_sp.reset(); m_reserved_sp.reset();
if (!ExtractFields(m_backend, &m_name_sp, &m_reason_sp, &m_userinfo_sp, return ExtractFields(m_backend, &m_name_sp, &m_reason_sp, &m_userinfo_sp,
&m_reserved_sp)) { &m_reserved_sp);
return false;
}
return true;
} }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
Context not available.

source/Plugins/Language/ObjC/NSIndexPath.cpp

Context not available.
return false; return false;
} }
bool MightHaveChildren() override { bool MightHaveChildren() override { return m_impl.m_mode != Mode::Invalid; }
if (m_impl.m_mode == Mode::Invalid)
return false;
return true;
}
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(const ConstString &name) override {
const char *item_name = name.GetCString(); const char *item_name = name.GetCString();
Context not available.

source/Plugins/Language/ObjC/NSString.cpp

Context not available.
options.SetStream(&stream); options.SetStream(&stream);
options.SetQuote('"'); options.SetQuote('"');
options.SetSourceSize(explicit_length); options.SetSourceSize(explicit_length);
options.SetNeedsZeroTermination(has_explicit_length == false); options.SetNeedsZeroTermination(!has_explicit_length);
options.SetIgnoreMaxLength(summary_options.GetCapping() == options.SetIgnoreMaxLength(summary_options.GetCapping() ==
TypeSummaryCapping::eTypeSummaryUncapped); TypeSummaryCapping::eTypeSummaryUncapped);
options.SetBinaryZeroIsTerminator(has_explicit_length == false); options.SetBinaryZeroIsTerminator(!has_explicit_length);
options.SetLanguage(summary_options.GetLanguage()); options.SetLanguage(summary_options.GetLanguage());
return StringPrinter::ReadStringAndDumpToStream< return StringPrinter::ReadStringAndDumpToStream<
StringPrinter::StringElementType::UTF16>(options); StringPrinter::StringElementType::UTF16>(options);
Context not available.
options.SetStream(&stream); options.SetStream(&stream);
options.SetQuote('"'); options.SetQuote('"');
options.SetSourceSize(explicit_length); options.SetSourceSize(explicit_length);
options.SetNeedsZeroTermination(has_explicit_length == false); options.SetNeedsZeroTermination(!has_explicit_length);
options.SetIgnoreMaxLength(summary_options.GetCapping() == options.SetIgnoreMaxLength(summary_options.GetCapping() ==
TypeSummaryCapping::eTypeSummaryUncapped); TypeSummaryCapping::eTypeSummaryUncapped);
options.SetBinaryZeroIsTerminator(has_explicit_length == false); options.SetBinaryZeroIsTerminator(!has_explicit_length);
options.SetLanguage(summary_options.GetLanguage()); options.SetLanguage(summary_options.GetLanguage());
return StringPrinter::ReadStringAndDumpToStream< return StringPrinter::ReadStringAndDumpToStream<
StringPrinter::StringElementType::UTF16>(options); StringPrinter::StringElementType::UTF16>(options);
Context not available.
Status error; Status error;
explicit_length = explicit_length =
process_sp->ReadUnsignedIntegerFromMemory(location, 1, 0, error); process_sp->ReadUnsignedIntegerFromMemory(location, 1, 0, error);
if (error.Fail() || explicit_length == 0) has_explicit_length = !(error.Fail() || explicit_length == 0);
has_explicit_length = false;
else
has_explicit_length = true;
location++; location++;
} }
options.SetLocation(location); options.SetLocation(location);
Context not available.

source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

Context not available.
return false; return false;
// Can we maybe ask Clang about this? // Can we maybe ask Clang about this?
if (strstr(name, "_vptr$") == name) return strstr(name, "_vptr$") == name;
return true;
else
return false;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
Context not available.

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp

Context not available.
} }
process->ReadCStringFromMemory(m_types_ptr, m_types, error); process->ReadCStringFromMemory(m_types_ptr, m_types, error);
if (error.Fail()) { return !error.Fail();
return false;
}
return true;
} }
bool ClassDescriptorV2::ivar_list_t::Read(Process *process, lldb::addr_t addr) { bool ClassDescriptorV2::ivar_list_t::Read(Process *process, lldb::addr_t addr) {
Context not available.
} }
process->ReadCStringFromMemory(m_type_ptr, m_type, error); process->ReadCStringFromMemory(m_type_ptr, m_type, error);
if (error.Fail()) { return !error.Fail();
return false;
}
return true;
} }
bool ClassDescriptorV2::Describe( bool ClassDescriptorV2::Describe(
Context not available.

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

Context not available.
SymbolContextList sc_list; SymbolContextList sc_list;
if (target.GetImages().FindSymbolsWithNameAndType(s_method_signature, return target.GetImages().FindSymbolsWithNameAndType(
eSymbolTypeCode, sc_list) || s_method_signature, eSymbolTypeCode, sc_list) ||
target.GetImages().FindSymbolsWithNameAndType(s_arclite_method_signature, target.GetImages().FindSymbolsWithNameAndType(
eSymbolTypeCode, sc_list)) s_arclite_method_signature, eSymbolTypeCode, sc_list);
return true;
else
return false;
} }
lldb::SearchFilterSP AppleObjCRuntime::CreateExceptionSearchFilter() { lldb::SearchFilterSP AppleObjCRuntime::CreateExceptionSearchFilter() {
Context not available.

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

Context not available.
class_type_or_name.SetName(class_descriptor->GetClassName()); class_type_or_name.SetName(class_descriptor->GetClassName());
} }
} }
return class_type_or_name.IsEmpty() == false; return !class_type_or_name.IsEmpty();
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
Context not available.

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

Context not available.
} }
} }
} }
return class_type_or_name.IsEmpty() == false; return !class_type_or_name.IsEmpty();
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
Context not available.
// warn if: // warn if:
// - we could not run either expression // - we could not run either expression
// - we found fewer than num_classes_to_warn_at classes total // - we found fewer than num_classes_to_warn_at classes total
if ((false == shared_cache_update_result.m_update_ran) || if ((!shared_cache_update_result.m_update_ran) ||
(false == dynamic_update_result.m_update_ran)) (!dynamic_update_result.m_update_ran))
WarnIfNoClassesCached( WarnIfNoClassesCached(
SharedCacheWarningReason::eExpressionExecutionFailure); SharedCacheWarningReason::eExpressionExecutionFailure);
else if (dynamic_update_result.m_num_found + else if (dynamic_update_result.m_num_found +
Context not available.
ObjCLanguageRuntime::ClassDescriptorSP ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::NonPointerISACache::GetClassDescriptor(ObjCISA isa) { AppleObjCRuntimeV2::NonPointerISACache::GetClassDescriptor(ObjCISA isa) {
ObjCISA real_isa = 0; ObjCISA real_isa = 0;
if (EvaluateNonPointerISA(isa, real_isa) == false) if (!EvaluateNonPointerISA(isa, real_isa))
return ObjCLanguageRuntime::ClassDescriptorSP(); return ObjCLanguageRuntime::ClassDescriptorSP();
auto cache_iter = m_cache.find(real_isa); auto cache_iter = m_cache.find(real_isa);
if (cache_iter != m_cache.end()) if (cache_iter != m_cache.end())
Context not available.

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp

Context not available.
// The base class MischiefManaged does some cleanup - so you have to call it in // The base class MischiefManaged does some cleanup - so you have to call it in
// your MischiefManaged derived class. // your MischiefManaged derived class.
bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() { bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() {
if (IsPlanComplete()) return IsPlanComplete();
return true;
else
return false;
} }
bool AppleThreadPlanStepThroughObjCTrampoline::WillStop() { return true; } bool AppleThreadPlanStepThroughObjCTrampoline::WillStop() { return true; }
Context not available.

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

Context not available.
// If this Element has subelements then JIT rsaElementGetSubElements() for // If this Element has subelements then JIT rsaElementGetSubElements() for
// details about its fields // details about its fields
if (*elem.field_count.get() > 0 && !JITSubelements(elem, context, frame_ptr)) return !(*elem.field_count.get() > 0 &&
return false; !JITSubelements(elem, context, frame_ptr));
return true;
} }
// JITs the RS runtime for information about the subelements/fields of a struct // JITs the RS runtime for information about the subelements/fields of a struct
Context not available.
SetElementSize(alloc->element); SetElementSize(alloc->element);
// Use GetOffsetPointer() to infer size of the allocation // Use GetOffsetPointer() to infer size of the allocation
if (!JITAllocationSize(alloc, frame_ptr)) return JITAllocationSize(alloc, frame_ptr);
return false;
return true;
} }
// Function attempts to set the type_name member of the paramaterised Element // Function attempts to set the type_name member of the paramaterised Element
Context not available.

source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

Context not available.
while (pos != archive_map.end() && pos->first == file) { while (pos != archive_map.end() && pos->first == file) {
bool match = true; bool match = true;
if (arch.IsValid() && if (arch.IsValid() &&
pos->second->GetArchitecture().IsCompatibleMatch(arch) == false) !pos->second->GetArchitecture().IsCompatibleMatch(arch))
match = false; match = false;
else if (file_offset != LLDB_INVALID_OFFSET && else if (file_offset != LLDB_INVALID_OFFSET &&
pos->second->GetFileOffset() != file_offset) pos->second->GetFileOffset() != file_offset)
Context not available.

source/Plugins/ObjectFile/ELF/ELFHeader.cpp

Context not available.
lldb::offset_t saved_offset = *offset; lldb::offset_t saved_offset = *offset;
for (uint32_t i = 0; i < count; ++i, ++value) { for (uint32_t i = 0; i < count; ++i, ++value) {
if (GetMaxU64(data, offset, value, byte_size) == false) { if (!GetMaxU64(data, offset, value, byte_size)) {
*offset = saved_offset; *offset = saved_offset;
return false; return false;
} }
Context not available.
lldb::offset_t saved_offset = *offset; lldb::offset_t saved_offset = *offset;
for (uint32_t i = 0; i < count; ++i, ++value) { for (uint32_t i = 0; i < count; ++i, ++value) {
if (GetMaxS64(data, offset, value, byte_size) == false) { if (!GetMaxS64(data, offset, value, byte_size)) {
*offset = saved_offset; *offset = saved_offset;
return false; return false;
} }
Context not available.
return false; return false;
// Read e_entry, e_phoff and e_shoff. // Read e_entry, e_phoff and e_shoff.
if (GetMaxU64(data, offset, &e_entry, byte_size, 3) == false) if (!GetMaxU64(data, offset, &e_entry, byte_size, 3))
return false; return false;
// Read e_flags. // Read e_flags.
Context not available.
return false; return false;
// Read sh_flags. // Read sh_flags.
if (GetMaxU64(data, offset, &sh_flags, byte_size) == false) if (!GetMaxU64(data, offset, &sh_flags, byte_size))
return false; return false;
// Read sh_addr, sh_off and sh_size. // Read sh_addr, sh_off and sh_size.
if (GetMaxU64(data, offset, &sh_addr, byte_size, 3) == false) if (!GetMaxU64(data, offset, &sh_addr, byte_size, 3))
return false; return false;
// Read sh_link and sh_info. // Read sh_link and sh_info.
Context not available.
return false; return false;
// Read sh_addralign and sh_entsize. // Read sh_addralign and sh_entsize.
if (GetMaxU64(data, offset, &sh_addralign, byte_size, 2) == false) if (!GetMaxU64(data, offset, &sh_addralign, byte_size, 2))
return false; return false;
return true; return true;
Context not available.
if (parsing_32) { if (parsing_32) {
// Read st_value and st_size. // Read st_value and st_size.
if (GetMaxU64(data, offset, &st_value, byte_size, 2) == false) if (!GetMaxU64(data, offset, &st_value, byte_size, 2))
return false; return false;
// Read st_info and st_other. // Read st_info and st_other.
Context not available.
if (parsing_32) { if (parsing_32) {
// Read p_offset, p_vaddr, p_paddr, p_filesz and p_memsz. // Read p_offset, p_vaddr, p_paddr, p_filesz and p_memsz.
if (GetMaxU64(data, offset, &p_offset, byte_size, 5) == false) if (!GetMaxU64(data, offset, &p_offset, byte_size, 5))
return false; return false;
// Read p_flags. // Read p_flags.
Context not available.
return false; return false;
// Read p_align. // Read p_align.
if (GetMaxU64(data, offset, &p_align, byte_size) == false) if (!GetMaxU64(data, offset, &p_align, byte_size))
return false; return false;
} else { } else {
// Read p_flags. // Read p_flags.
Context not available.
return false; return false;
// Read p_offset, p_vaddr, p_paddr, p_filesz, p_memsz and p_align. // Read p_offset, p_vaddr, p_paddr, p_filesz, p_memsz and p_align.
if (GetMaxU64(data, offset, &p_offset, byte_size, 6) == false) if (!GetMaxU64(data, offset, &p_offset, byte_size, 6))
return false; return false;
} }
Context not available.
const unsigned byte_size = data.GetAddressByteSize(); const unsigned byte_size = data.GetAddressByteSize();
// Read r_offset and r_info. // Read r_offset and r_info.
if (GetMaxU64(data, offset, &r_offset, byte_size, 2) == false) return GetMaxU64(data, offset, &r_offset, byte_size, 2) != false;
return false;
return true;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Context not available.
const unsigned byte_size = data.GetAddressByteSize(); const unsigned byte_size = data.GetAddressByteSize();
// Read r_offset and r_info. // Read r_offset and r_info.
if (GetMaxU64(data, offset, &r_offset, byte_size, 2) == false) if (!GetMaxU64(data, offset, &r_offset, byte_size, 2))
return false; return false;
// Read r_addend; // Read r_addend;
if (GetMaxS64(data, offset, &r_addend, byte_size) == false) if (!GetMaxS64(data, offset, &r_addend, byte_size))
return false; return false;
return true; return true;
Context not available.

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

Context not available.
uint32_t idx; uint32_t idx;
lldb::offset_t offset; lldb::offset_t offset;
for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) { for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) {
if (program_headers[idx].Parse(data, &offset) == false) if (!program_headers[idx].Parse(data, &offset))
break; break;
} }
Context not available.
uint32_t idx; uint32_t idx;
lldb::offset_t offset; lldb::offset_t offset;
for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) { for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) {
if (section_headers[idx].Parse(sh_data, &offset) == false) if (!section_headers[idx].Parse(sh_data, &offset))
break; break;
} }
if (idx < section_headers.size()) if (idx < section_headers.size())
Context not available.
unsigned i; unsigned i;
for (i = 0; i < num_symbols; ++i) { for (i = 0; i < num_symbols; ++i) {
if (symbol.Parse(symtab_data, &offset) == false) if (!symbol.Parse(symtab_data, &offset))
break; break;
const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
Context not available.
unsigned slot_type = hdr->GetRelocationJumpSlotType(); unsigned slot_type = hdr->GetRelocationJumpSlotType();
unsigned i; unsigned i;
for (i = 0; i < num_relocations; ++i) { for (i = 0; i < num_relocations; ++i) {
if (rel.Parse(rel_data, &offset) == false) if (!rel.Parse(rel_data, &offset))
break; break;
if (reloc_type(rel) != slot_type) if (reloc_type(rel) != slot_type)
Context not available.
} }
for (unsigned i = 0; i < num_relocations; ++i) { for (unsigned i = 0; i < num_relocations; ++i) {
if (rel.Parse(rel_data, &offset) == false) if (!rel.Parse(rel_data, &offset))
break; break;
Symbol *symbol = NULL; Symbol *symbol = NULL;
Context not available.

source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

Context not available.
// that size on disk (to avoid __PAGEZERO) and load them // that size on disk (to avoid __PAGEZERO) and load them
SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx)); SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
if (section_sp && section_sp->GetFileSize() > 0 && if (section_sp && section_sp->GetFileSize() > 0 &&
section_sp->IsThreadSpecific() == false) { !section_sp->IsThreadSpecific()) {
if (target.GetSectionLoadList().SetSectionLoadAddress( if (target.GetSectionLoadList().SetSectionLoadAddress(
section_sp, section_sp->GetFileAddress() + value)) section_sp, section_sp->GetFileAddress() + value))
++num_loaded_sections; ++num_loaded_sections;
Context not available.

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

Context not available.
symbol_value -= section_file_addr; symbol_value -= section_file_addr;
} }
if (is_debug == false) { if (!is_debug) {
if (type == eSymbolTypeCode) { if (type == eSymbolTypeCode) {
// See if we can find a N_FUN entry for any code symbols. If we // See if we can find a N_FUN entry for any code symbols. If we
// do find a match, and the name matches, then we can merge the // do find a match, and the name matches, then we can merge the
Context not available.
if (function_starts_count > 0) { if (function_starts_count > 0) {
uint32_t num_synthetic_function_symbols = 0; uint32_t num_synthetic_function_symbols = 0;
for (i = 0; i < function_starts_count; ++i) { for (i = 0; i < function_starts_count; ++i) {
if (function_starts.GetEntryRef(i).data == false) if (!function_starts.GetEntryRef(i).data)
++num_synthetic_function_symbols; ++num_synthetic_function_symbols;
} }
Context not available.
for (i = 0; i < function_starts_count; ++i) { for (i = 0; i < function_starts_count; ++i) {
const FunctionStarts::Entry *func_start_entry = const FunctionStarts::Entry *func_start_entry =
function_starts.GetEntryAtIndex(i); function_starts.GetEntryAtIndex(i);
if (func_start_entry->data == false) { if (!func_start_entry->data) {
addr_t symbol_file_addr = func_start_entry->addr; addr_t symbol_file_addr = func_start_entry->addr;
uint32_t symbol_flags = 0; uint32_t symbol_flags = 0;
if (is_arm) { if (is_arm) {
Context not available.
if (m_sdk_versions.empty()) { if (m_sdk_versions.empty()) {
lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic); lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
bool success = false; bool success = false;
for (uint32_t i = 0; success == false && i < m_header.ncmds; ++i) { for (uint32_t i = 0; !success && i < m_header.ncmds; ++i) {
const lldb::offset_t load_cmd_offset = offset; const lldb::offset_t load_cmd_offset = offset;
version_min_command lc; version_min_command lc;
Context not available.
offset = load_cmd_offset + lc.cmdsize; offset = load_cmd_offset + lc.cmdsize;
} }
if (success == false) if (!success) {
{ offset = MachHeaderSizeFromMagic(m_header.magic);
shafikUnsubmitted
Not Done
ReplyInline Actions

This looks like a big chunk of unrelated changes.

shafik: This looks like a big chunk of unrelated changes.
offset = MachHeaderSizeFromMagic(m_header.magic); for (uint32_t i = 0; !success && i < m_header.ncmds; ++i) {
for (uint32_t i = 0; success == false && i < m_header.ncmds; ++i) const lldb::offset_t load_cmd_offset = offset;
{
const lldb::offset_t load_cmd_offset = offset;
version_min_command lc; version_min_command lc;
if (m_data.GetU32(&offset, &lc.cmd, 2) == NULL) if (m_data.GetU32(&offset, &lc.cmd, 2) == NULL)
break; break;
if (lc.cmd == llvm::MachO::LC_BUILD_VERSION) if (lc.cmd == llvm::MachO::LC_BUILD_VERSION) {
{ // struct build_version_command {
// struct build_version_command { // uint32_t cmd; /* LC_BUILD_VERSION */
// uint32_t cmd; /* LC_BUILD_VERSION */ // uint32_t cmdsize; /* sizeof(struct
// uint32_t cmdsize; /* sizeof(struct build_version_command) plus */ // build_version_command) plus */
// /* ntools * sizeof(struct build_tool_version) */ // /* ntools * sizeof(struct
// uint32_t platform; /* platform */ // build_tool_version) */
// uint32_t minos; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ // uint32_t platform; /* platform */
// uint32_t sdk; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ // uint32_t minos; /* X.Y.Z is encoded in nibbles
// uint32_t ntools; /* number of tool entries following this */ // xxxx.yy.zz */ uint32_t sdk; /* X.Y.Z is encoded
// }; // in nibbles xxxx.yy.zz */ uint32_t ntools; /* number
// of tool entries following this */
offset += 4; // skip platform // };
uint32_t minos = m_data.GetU32(&offset);
offset += 4; // skip platform
const uint32_t xxxx = minos >> 16; uint32_t minos = m_data.GetU32(&offset);
const uint32_t yy = (minos >> 8) & 0xffu;
const uint32_t zz = minos & 0xffu; const uint32_t xxxx = minos >> 16;
if (xxxx) const uint32_t yy = (minos >> 8) & 0xffu;
{ const uint32_t zz = minos & 0xffu;
m_sdk_versions.push_back (xxxx); if (xxxx) {
m_sdk_versions.push_back (yy); m_sdk_versions.push_back(xxxx);
m_sdk_versions.push_back (zz); m_sdk_versions.push_back(yy);
success = true; m_sdk_versions.push_back(zz);
} success = true;
} }
offset = load_cmd_offset + lc.cmdsize;
} }
offset = load_cmd_offset + lc.cmdsize;
}
} }
if (success == false) { if (!success) {
// Push an invalid value so we don't try to find // Push an invalid value so we don't try to find
// the version # again on the next call to this // the version # again on the next call to this
// method. // method.
Context not available.
++sect_idx) { ++sect_idx) {
Section *section = section_list->GetSectionAtIndex(sect_idx).get(); Section *section = section_list->GetSectionAtIndex(sect_idx).get();
if (section && section->GetFileSize() > 0 && if (section && section->GetFileSize() > 0 &&
section->GetFileOffset() == 0 && section->GetFileOffset() == 0 && !section->IsThreadSpecific() &&
section->IsThreadSpecific() == false &&
module_sp.get() == section->GetModule().get()) { module_sp.get() == section->GetModule().get()) {
return section; return section;
} }
Context not available.
lldb::addr_t mach_header_file_addr = mach_header_section->GetFileAddress(); lldb::addr_t mach_header_file_addr = mach_header_section->GetFileAddress();
if (mach_header_file_addr != LLDB_INVALID_ADDRESS) { if (mach_header_file_addr != LLDB_INVALID_ADDRESS) {
if (section && section->GetFileSize() > 0 && if (section && section->GetFileSize() > 0 &&
section->IsThreadSpecific() == false && !section->IsThreadSpecific() &&
module_sp.get() == section->GetModule().get()) { module_sp.get() == section->GetModule().get()) {
// Ignore __LINKEDIT and __DWARF segments // Ignore __LINKEDIT and __DWARF segments
if (section->GetName() == GetSegmentNameLINKEDIT()) { if (section->GetName() == GetSegmentNameLINKEDIT()) {
Context not available.
// kernel binary like a kext or mach_kernel. // kernel binary like a kext or mach_kernel.
const bool is_memory_image = (bool)m_process_wp.lock(); const bool is_memory_image = (bool)m_process_wp.lock();
const Strata strata = GetStrata(); const Strata strata = GetStrata();
if (is_memory_image == false || strata == eStrataKernel) if (!is_memory_image || strata == eStrataKernel)
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
} }
return section->GetFileAddress() - mach_header_file_addr + return section->GetFileAddress() - mach_header_file_addr +
Context not available.
// sections that size on disk (to avoid __PAGEZERO) and load them // sections that size on disk (to avoid __PAGEZERO) and load them
SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx)); SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
if (section_sp && section_sp->GetFileSize() > 0 && if (section_sp && section_sp->GetFileSize() > 0 &&
section_sp->IsThreadSpecific() == false && !section_sp->IsThreadSpecific() &&
module_sp.get() == section_sp->GetModule().get()) { module_sp.get() == section_sp->GetModule().get()) {
// Ignore __LINKEDIT and __DWARF segments // Ignore __LINKEDIT and __DWARF segments
if (section_sp->GetName() == GetSegmentNameLINKEDIT()) { if (section_sp->GetName() == GetSegmentNameLINKEDIT()) {
Context not available.
// isn't a kernel binary like a kext or mach_kernel. // isn't a kernel binary like a kext or mach_kernel.
const bool is_memory_image = (bool)m_process_wp.lock(); const bool is_memory_image = (bool)m_process_wp.lock();
const Strata strata = GetStrata(); const Strata strata = GetStrata();
if (is_memory_image == false || strata == eStrataKernel) if (!is_memory_image || strata == eStrataKernel)
continue; continue;
} }
if (target.GetSectionLoadList().SetSectionLoadAddress( if (target.GetSectionLoadList().SetSectionLoadAddress(
Context not available.

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

Context not available.
} }
} }
return m_sect_headers.empty() == false; return !m_sect_headers.empty();
} }
bool ObjectFilePECOFF::GetSectionName(std::string &sect_name, bool ObjectFilePECOFF::GetSectionName(std::string &sect_name,
Context not available.

source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

Context not available.
// beginning of the list // beginning of the list
uint32_t insert_idx = 0; uint32_t insert_idx = 0;
for (uint32_t core_idx = 0; core_idx < num_cores; ++core_idx) { for (uint32_t core_idx = 0; core_idx < num_cores; ++core_idx) {
if (core_used_map[core_idx] == false) { if (!core_used_map[core_idx]) {
new_thread_list.InsertThread( new_thread_list.InsertThread(
core_thread_list.GetThreadAtIndex(core_idx, false), insert_idx); core_thread_list.GetThreadAtIndex(core_idx, false), insert_idx);
++insert_idx; ++insert_idx;
Context not available.

source/Plugins/Platform/Android/PlatformAndroid.cpp

Context not available.
} }
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
const llvm::Triple &triple = arch->GetTriple(); const llvm::Triple &triple = arch->GetTriple();
switch (triple.getVendor()) { switch (triple.getVendor()) {
case llvm::Triple::PC: case llvm::Triple::PC:
Context not available.

source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

Context not available.
arch ? arch->GetTriple().getTriple() : "<null>"); arch ? arch->GetTriple().getTriple() : "<null>");
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
const llvm::Triple &triple = arch->GetTriple(); const llvm::Triple &triple = arch->GetTriple();
switch (triple.getOS()) { switch (triple.getOS()) {
case llvm::Triple::FreeBSD: case llvm::Triple::FreeBSD:
Context not available.

source/Plugins/Platform/Kalimba/PlatformKalimba.cpp

Context not available.
PlatformSP PlatformKalimba::CreateInstance(bool force, const ArchSpec *arch) { PlatformSP PlatformKalimba::CreateInstance(bool force, const ArchSpec *arch) {
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
const llvm::Triple &triple = arch->GetTriple(); const llvm::Triple &triple = arch->GetTriple();
switch (triple.getVendor()) { switch (triple.getVendor()) {
case llvm::Triple::CSR: case llvm::Triple::CSR:
Context not available.

source/Plugins/Platform/Linux/PlatformLinux.cpp

Context not available.
arch ? arch->GetTriple().getTriple() : "<null>"); arch ? arch->GetTriple().getTriple() : "<null>");
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
const llvm::Triple &triple = arch->GetTriple(); const llvm::Triple &triple = arch->GetTriple();
switch (triple.getOS()) { switch (triple.getOS()) {
case llvm::Triple::Linux: case llvm::Triple::Linux:
Context not available.

source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp

Context not available.
} }
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
switch (arch->GetMachine()) { switch (arch->GetMachine()) {
case llvm::Triple::x86_64: { case llvm::Triple::x86_64: {
const llvm::Triple &triple = arch->GetTriple(); const llvm::Triple &triple = arch->GetTriple();
Context not available.

source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp

Context not available.
} }
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
switch (arch->GetMachine()) { switch (arch->GetMachine()) {
case llvm::Triple::x86_64: { case llvm::Triple::x86_64: {
const llvm::Triple &triple = arch->GetTriple(); const llvm::Triple &triple = arch->GetTriple();
Context not available.

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

Context not available.
return false; return false;
ObjectFile::Type obj_type = obj_file->GetType(); ObjectFile::Type obj_type = obj_file->GetType();
if (obj_type == ObjectFile::eTypeDynamicLinker) return obj_type == ObjectFile::eTypeDynamicLinker;
return true;
else
return false;
} }
bool PlatformDarwin::x86GetSupportedArchitectureAtIndex(uint32_t idx, bool PlatformDarwin::x86GetSupportedArchitectureAtIndex(uint32_t idx,
Context not available.

source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

Context not available.
// ArchSpec for normal userland debugging. It is only useful in kernel debug // ArchSpec for normal userland debugging. It is only useful in kernel debug
// sessions and the DynamicLoaderDarwinPlugin (or a user doing 'platform // sessions and the DynamicLoaderDarwinPlugin (or a user doing 'platform
// select') will force the creation of this Platform plugin. // select') will force the creation of this Platform plugin.
if (force == false) { if (!force) {
if (log) if (log)
log->Printf("PlatformDarwinKernel::%s() aborting creation of platform " log->Printf("PlatformDarwinKernel::%s() aborting creation of platform "
"because force == false", "because force == false",
Context not available.
bool create = force; bool create = force;
LazyBool is_ios_debug_session = eLazyBoolCalculate; LazyBool is_ios_debug_session = eLazyBoolCalculate;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
const llvm::Triple &triple = arch->GetTriple(); const llvm::Triple &triple = arch->GetTriple();
switch (triple.getVendor()) { switch (triple.getVendor()) {
case llvm::Triple::Apple: case llvm::Triple::Apple:
Context not available.
shallow_bundle_str += ".dSYM"; shallow_bundle_str += ".dSYM";
dsym_fspec.SetFile(shallow_bundle_str, FileSpec::Style::native); dsym_fspec.SetFile(shallow_bundle_str, FileSpec::Style::native);
FileSystem::Instance().Resolve(dsym_fspec); FileSystem::Instance().Resolve(dsym_fspec);
if (FileSystem::Instance().IsDirectory(dsym_fspec)) { return FileSystem::Instance().IsDirectory(dsym_fspec);
return true;
}
return false;
} }
// Given a FileSpec of /dir/dir/mach.development.t7004 Return true if a dSYM // Given a FileSpec of /dir/dir/mach.development.t7004 Return true if a dSYM
Context not available.
std::string filename = kernel_binary.GetFilename().AsCString(); std::string filename = kernel_binary.GetFilename().AsCString();
filename += ".dSYM"; filename += ".dSYM";
kernel_dsym.GetFilename() = ConstString(filename); kernel_dsym.GetFilename() = ConstString(filename);
if (FileSystem::Instance().IsDirectory(kernel_dsym)) { return FileSystem::Instance().IsDirectory(kernel_dsym);
return true;
}
return false;
} }
Status PlatformDarwinKernel::GetSharedModule( Status PlatformDarwinKernel::GetSharedModule(
Context not available.

source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

Context not available.
const bool is_host = false; const bool is_host = false;
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
const llvm::Triple &triple = arch->GetTriple(); const llvm::Triple &triple = arch->GetTriple();
switch (triple.getVendor()) { switch (triple.getVendor()) {
case llvm::Triple::Apple: case llvm::Triple::Apple:
Context not available.

source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp

Context not available.
} }
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
switch (arch->GetMachine()) { switch (arch->GetMachine()) {
case llvm::Triple::arm: case llvm::Triple::arm:
case llvm::Triple::aarch64: case llvm::Triple::aarch64:
Context not available.

source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

Context not available.
} }
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
switch (arch->GetMachine()) { switch (arch->GetMachine()) {
case llvm::Triple::x86_64: case llvm::Triple::x86_64:
case llvm::Triple::x86: { case llvm::Triple::x86: {
Context not available.

source/Plugins/Platform/MacOSX/objcxx/PlatformiOSSimulatorCoreSimulatorSupport.mm

Context not available.
std::function<bool(const Device &)> f) { std::function<bool(const Device &)> f) {
const size_t n = GetNumDevices(); const size_t n = GetNumDevices();
for (NSUInteger i = 0; i < n; ++i) { for (NSUInteger i = 0; i < n; ++i) {
if (f(GetDeviceAtIndex(i)) == false) if (!f(GetDeviceAtIndex(i)))
break; break;
} }
} }
Context not available.

source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

Context not available.
arch ? arch->GetTriple().getTriple() : "<null>"); arch ? arch->GetTriple().getTriple() : "<null>");
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
const llvm::Triple &triple = arch->GetTriple(); const llvm::Triple &triple = arch->GetTriple();
switch (triple.getOS()) { switch (triple.getOS()) {
case llvm::Triple::NetBSD: case llvm::Triple::NetBSD:
Context not available.

source/Plugins/Platform/OpenBSD/PlatformOpenBSD.cpp

Context not available.
arch ? arch->GetTriple().getTriple() : "<null>"); arch ? arch->GetTriple().getTriple() : "<null>");
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
const llvm::Triple &triple = arch->GetTriple(); const llvm::Triple &triple = arch->GetTriple();
switch (triple.getOS()) { switch (triple.getOS()) {
case llvm::Triple::OpenBSD: case llvm::Triple::OpenBSD:
Context not available.

source/Plugins/Platform/Windows/PlatformWindows.cpp

Context not available.
const bool is_host = false; const bool is_host = false;
bool create = force; bool create = force;
if (create == false && arch && arch->IsValid()) { if (!create && arch && arch->IsValid()) {
const llvm::Triple &triple = arch->GetTriple(); const llvm::Triple &triple = arch->GetTriple();
switch (triple.getVendor()) { switch (triple.getVendor()) {
case llvm::Triple::PC: case llvm::Triple::PC:
Context not available.

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

Context not available.
void PlatformRemoteGDBServer::Initialize() { void PlatformRemoteGDBServer::Initialize() {
Platform::Initialize(); Platform::Initialize();
if (g_initialized == false) { if (!g_initialized) {
g_initialized = true; g_initialized = true;
PluginManager::RegisterPlugin( PluginManager::RegisterPlugin(
PlatformRemoteGDBServer::GetPluginNameStatic(), PlatformRemoteGDBServer::GetPluginNameStatic(),
Context not available.

source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp

Context not available.
bool CommunicationKDP::RemoteIsEFI() { bool CommunicationKDP::RemoteIsEFI() {
if (GetKernelVersion() == NULL) if (GetKernelVersion() == NULL)
return false; return false;
if (strncmp(m_kernel_version.c_str(), "EFI", 3) == 0) return strncmp(m_kernel_version.c_str(), "EFI", 3) == 0;
return true;
else
return false;
} }
bool CommunicationKDP::RemoteIsDarwinKernel() { bool CommunicationKDP::RemoteIsDarwinKernel() {
if (GetKernelVersion() == NULL) if (GetKernelVersion() == NULL)
return false; return false;
if (m_kernel_version.find("Darwin Kernel") != std::string::npos) return m_kernel_version.find("Darwin Kernel") != std::string::npos;
return true;
else
return false;
} }
lldb::addr_t CommunicationKDP::GetLoadAddress() { lldb::addr_t CommunicationKDP::GetLoadAddress() {
Context not available.
request_packet.PutHex32(GetCPUMask()); request_packet.PutHex32(GetCPUMask());
DataExtractor reply_packet; DataExtractor reply_packet;
if (SendRequestAndGetReply(command, request_packet, reply_packet)) return SendRequestAndGetReply(command, request_packet, reply_packet);
return true;
return false;
} }
bool CommunicationKDP::SendRequestBreakpoint(bool set, addr_t addr) { bool CommunicationKDP::SendRequestBreakpoint(bool set, addr_t addr) {
Context not available.
const uint32_t command_length = 8; const uint32_t command_length = 8;
MakeRequestPacketHeader(command, request_packet, command_length); MakeRequestPacketHeader(command, request_packet, command_length);
DataExtractor reply_packet; DataExtractor reply_packet;
if (SendRequestAndGetReply(command, request_packet, reply_packet)) return SendRequestAndGetReply(command, request_packet, reply_packet);
return true;
return false;
} }
Context not available.

source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp

Context not available.
return LLDB_INVALID_INDEX32; return LLDB_INVALID_INDEX32;
// We must watch for either read or write // We must watch for either read or write
if (read == false && write == false) if (!read && !write)
return LLDB_INVALID_INDEX32; return LLDB_INVALID_INDEX32;
// Can't watch more than 4 bytes per WVR/WCR pair // Can't watch more than 4 bytes per WVR/WCR pair
Context not available.

source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp

Context not available.
return LLDB_INVALID_INDEX32; return LLDB_INVALID_INDEX32;
// We must watch for either read or write // We must watch for either read or write
if (read == false && write == false) if (!read && !write)
return LLDB_INVALID_INDEX32; return LLDB_INVALID_INDEX32;
// Can't watch more than 4 bytes per WVR/WCR pair // Can't watch more than 4 bytes per WVR/WCR pair
Context not available.

source/Plugins/Process/Utility/RegisterContextLLDB.cpp

Context not available.
above_trap_handler = true; above_trap_handler = true;
if (pc == 0 || pc == 0x1) { if (pc == 0 || pc == 0x1) {
if (above_trap_handler == false) { if (!above_trap_handler) {
m_frame_type = eNotAValidFrame; m_frame_type = eNotAValidFrame;
UnwindLogMsg("this frame has a pc of 0x0"); UnwindLogMsg("this frame has a pc of 0x0");
return; return;
Context not available.
bool decr_pc_and_recompute_addr_range = false; bool decr_pc_and_recompute_addr_range = false;
// If the symbol lookup failed... // If the symbol lookup failed...
if (m_sym_ctx_valid == false) if (!m_sym_ctx_valid)
decr_pc_and_recompute_addr_range = true; decr_pc_and_recompute_addr_range = true;
// Or if we're in the middle of the stack (and not "above" an asynchronous // Or if we're in the middle of the stack (and not "above" an asynchronous
Context not available.
// Address register and it hasn't been saved anywhere yet -- that is, // Address register and it hasn't been saved anywhere yet -- that is,
// it's still live in the actual register. Handle this specially. // it's still live in the actual register. Handle this specially.
if (have_unwindplan_regloc == false && return_address_reg.IsValid() && if (!have_unwindplan_regloc && return_address_reg.IsValid() &&
IsFrameZero()) { IsFrameZero()) {
if (return_address_reg.GetAsKind(eRegisterKindLLDB) != if (return_address_reg.GetAsKind(eRegisterKindLLDB) !=
LLDB_INVALID_REGNUM) { LLDB_INVALID_REGNUM) {
Context not available.
} }
} }
if (can_fetch_pc_value && can_fetch_cfa) { have_unwindplan_regloc = can_fetch_pc_value && can_fetch_cfa;
have_unwindplan_regloc = true;
} else {
have_unwindplan_regloc = false;
}
} else { } else {
// We were unable to fall back to another unwind plan // We were unable to fall back to another unwind plan
have_unwindplan_regloc = false; have_unwindplan_regloc = false;
Context not available.
ExecutionContext exe_ctx(m_thread.shared_from_this()); ExecutionContext exe_ctx(m_thread.shared_from_this());
Process *process = exe_ctx.GetProcessPtr(); Process *process = exe_ctx.GetProcessPtr();
if (have_unwindplan_regloc == false) { if (!have_unwindplan_regloc) {
// If the UnwindPlan failed to give us an unwind location for this // If the UnwindPlan failed to give us an unwind location for this
// register, we may be able to fall back to some ABI-defined default. For // register, we may be able to fall back to some ABI-defined default. For
// example, some ABIs allow to determine the caller's SP via the CFA. Also, // example, some ABIs allow to determine the caller's SP via the CFA. Also,
Context not available.
} }
} }
if (have_unwindplan_regloc == false) { if (!have_unwindplan_regloc) {
if (IsFrameZero()) { if (IsFrameZero()) {
// This is frame 0 - we should return the actual live register context // This is frame 0 - we should return the actual live register context
// value // value
Context not available.
} }
if (unwindplan_regloc.IsSame()) { if (unwindplan_regloc.IsSame()) {
if (IsFrameZero() == false && if (!IsFrameZero() &&
(regnum.GetAsKind(eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_PC || (regnum.GetAsKind(eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_PC ||
regnum.GetAsKind(eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_RA)) { regnum.GetAsKind(eRegisterKindGeneric) == LLDB_REGNUM_GENERIC_RA)) {
UnwindLogMsg("register %s (%d) is marked as 'IsSame' - it is a pc or " UnwindLogMsg("register %s (%d) is marked as 'IsSame' - it is a pc or "
Context not available.
pc = abi->FixCodeAddress(pc); pc = abi->FixCodeAddress(pc);
} }
if (m_all_registers_available == false && above_trap_handler == false && return !(m_all_registers_available == false &&
(pc == 0 || pc == 1)) { above_trap_handler == false && (pc == 0 || pc == 1));
return false;
}
return true;
} else { } else {
return false; return false;
} }
Context not available.

source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp

Context not available.
if (m_fpr_type == eNotValid) { if (m_fpr_type == eNotValid) {
// TODO: Use assembly to call cpuid on the inferior and query ebx or ecx // TODO: Use assembly to call cpuid on the inferior and query ebx or ecx
m_fpr_type = eXSAVE; // extended floating-point registers, if available m_fpr_type = eXSAVE; // extended floating-point registers, if available
if (false == ReadFPR()) if (!ReadFPR())
m_fpr_type = eFXSAVE; // assume generic floating-point registers m_fpr_type = eFXSAVE; // assume generic floating-point registers
} }
return m_fpr_type; return m_fpr_type;
Context not available.

source/Plugins/Process/Utility/UnwindLLDB.cpp

Context not available.
// On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not // On Mac OS X, the _sigtramp asynchronous signal trampoline frame may not
// have its (constructed) CFA aligned correctly -- don't do the abi // have its (constructed) CFA aligned correctly -- don't do the abi
// alignment check for these. // alignment check for these.
if (reg_ctx_sp->IsTrapHandlerFrame() == false) { if (!reg_ctx_sp->IsTrapHandlerFrame()) {
// See if we can find a fallback unwind plan for THIS frame. It may be // See if we can find a fallback unwind plan for THIS frame. It may be
// that the UnwindPlan we're using for THIS frame was bad and gave us a // that the UnwindPlan we're using for THIS frame was bad and gave us a
// bad CFA. If that's not it, then see if we can change the UnwindPlan // bad CFA. If that's not it, then see if we can change the UnwindPlan
// for the frame below us ("NEXT") -- see if using that other UnwindPlan // for the frame below us ("NEXT") -- see if using that other UnwindPlan
// gets us a better unwind state. // gets us a better unwind state.
if (reg_ctx_sp->TryFallbackUnwindPlan() == false || if (!reg_ctx_sp->TryFallbackUnwindPlan() ||
reg_ctx_sp->GetCFA(cursor_sp->cfa) == false || !reg_ctx_sp->GetCFA(cursor_sp->cfa) ||
abi->CallFrameAddressIsValid(cursor_sp->cfa) == false) { !abi->CallFrameAddressIsValid(cursor_sp->cfa)) {
if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) { if (prev_frame->reg_ctx_lldb_sp->TryFallbackUnwindPlan()) {
// TryFallbackUnwindPlan for prev_frame succeeded and updated // TryFallbackUnwindPlan for prev_frame succeeded and updated
// reg_ctx_lldb_sp field of prev_frame. However, cfa field of // reg_ctx_lldb_sp field of prev_frame. However, cfa field of
Context not available.
// Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was already // Cursor::m_frames[m_frames.size() - 2], reg_ctx_lldb_sp field was already
// updated during TryFallbackUnwindPlan call above. However, cfa field // updated during TryFallbackUnwindPlan call above. However, cfa field
// still needs to be updated. Hence updating it here and then returning. // still needs to be updated. Hence updating it here and then returning.
if (!(m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA( return m_frames[m_frames.size() - 2]->reg_ctx_lldb_sp->GetCFA(
m_frames[m_frames.size() - 2]->cfa))) m_frames[m_frames.size() - 2]->cfa);
return false;
return true;
} }
// The new frame hasn't helped in unwinding. Fall back to the original one as // The new frame hasn't helped in unwinding. Fall back to the original one as
Context not available.
UnwindLLDB::RegisterSearchResult result; UnwindLLDB::RegisterSearchResult result;
result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister( result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister(
lldb_regnum, regloc); lldb_regnum, regloc);
if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound) return result == UnwindLLDB::RegisterSearchResult::eRegisterFound;
return true;
else
return false;
} }
while (frame_num >= 0) { while (frame_num >= 0) {
UnwindLLDB::RegisterSearchResult result; UnwindLLDB::RegisterSearchResult result;
Context not available.

source/Plugins/Process/gdb-remote/GDBRemoteClientBase.cpp

Context not available.
log->PutCString("GDBRemoteClientBase::Lock::Lock sent packet: \\x03"); log->PutCString("GDBRemoteClientBase::Lock::Lock sent packet: \\x03");
m_comm.m_interrupt_time = steady_clock::now(); m_comm.m_interrupt_time = steady_clock::now();
} }
m_comm.m_cv.wait(lock, [this] { return m_comm.m_is_running == false; }); m_comm.m_cv.wait(lock, [this] { return !m_comm.m_is_running; });
m_did_interrupt = true; m_did_interrupt = true;
} }
m_acquired = true; m_acquired = true;
Context not available.

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

Context not available.
// Size of packet before it is decompressed, for logging purposes // Size of packet before it is decompressed, for logging purposes
size_t original_packet_size = m_bytes.size(); size_t original_packet_size = m_bytes.size();
if (CompressionIsEnabled()) { if (CompressionIsEnabled()) {
if (DecompressPacket() == false) { if (!DecompressPacket()) {
packet.Clear(); packet.Clear();
return GDBRemoteCommunication::PacketType::Standard; return GDBRemoteCommunication::PacketType::Standard;
} }
Context not available.

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

Context not available.
m_attach_or_wait_reply = eLazyBoolYes; m_attach_or_wait_reply = eLazyBoolYes;
} }
} }
if (m_attach_or_wait_reply == eLazyBoolYes) return m_attach_or_wait_reply == eLazyBoolYes;
return true;
else
return false;
} }
bool GDBRemoteCommunicationClient::GetSyncThreadStateSupported() { bool GDBRemoteCommunicationClient::GetSyncThreadStateSupported() {
Context not available.
m_prepare_for_reg_writing_reply = eLazyBoolYes; m_prepare_for_reg_writing_reply = eLazyBoolYes;
} }
} }
if (m_prepare_for_reg_writing_reply == eLazyBoolYes) return m_prepare_for_reg_writing_reply == eLazyBoolYes;
return true;
else
return false;
} }
void GDBRemoteCommunicationClient::ResetDiscoverableSettings(bool did_exec) { void GDBRemoteCommunicationClient::ResetDiscoverableSettings(bool did_exec) {
if (did_exec == false) { if (!did_exec) {
// Hard reset everything, this is when we first connect to a GDB server // Hard reset everything, this is when we first connect to a GDB server
m_supports_not_sending_acks = eLazyBoolCalculate; m_supports_not_sending_acks = eLazyBoolCalculate;
m_supports_thread_suffix = eLazyBoolCalculate; m_supports_thread_suffix = eLazyBoolCalculate;
Context not available.
bool sequence_mutex_unavailable; bool sequence_mutex_unavailable;
size_t size; size_t size;
size = GetCurrentThreadIDs(thread_ids, sequence_mutex_unavailable); size = GetCurrentThreadIDs(thread_ids, sequence_mutex_unavailable);
if (size && sequence_mutex_unavailable == false) { if (size && !sequence_mutex_unavailable) {
m_curr_pid = thread_ids.front(); m_curr_pid = thread_ids.front();
m_curr_pid_is_valid = eLazyBoolYes; m_curr_pid_is_valid = eLazyBoolYes;
return m_curr_pid; return m_curr_pid;
Context not available.
if (name_equal_value && name_equal_value[0]) { if (name_equal_value && name_equal_value[0]) {
StreamString packet; StreamString packet;
bool send_hex_encoding = false; bool send_hex_encoding = false;
for (const char *p = name_equal_value; for (const char *p = name_equal_value; *p != '\0' && !send_hex_encoding;
*p != '\0' && send_hex_encoding == false; ++p) { ++p) {
if (isprint(*p)) { if (isprint(*p)) {
switch (*p) { switch (*p) {
case '$': case '$':
Context not available.
found_num_field = true; found_num_field = true;
} }
} }
if (found_num_field == false) { if (!found_num_field) {
m_supports_watchpoint_support_info = eLazyBoolNo; m_supports_watchpoint_support_info = eLazyBoolNo;
} }
} else { } else {
Context not available.
// On targets like MIPS and ppc64le, watchpoint exceptions are always // On targets like MIPS and ppc64le, watchpoint exceptions are always
// generated before the instruction is executed. The connected target may // generated before the instruction is executed. The connected target may
// not support qHostInfo or qWatchpointSupportInfo packets. // not support qHostInfo or qWatchpointSupportInfo packets.
if (atype == llvm::Triple::mips || atype == llvm::Triple::mipsel || after =
atype == llvm::Triple::mips64 || atype == llvm::Triple::mips64el || !(atype == llvm::Triple::mips || atype == llvm::Triple::mipsel ||
atype == llvm::Triple::ppc64le) atype == llvm::Triple::mips64 || atype == llvm::Triple::mips64el ||
after = false; atype == llvm::Triple::ppc64le);
shafikUnsubmitted
Not Done
ReplyInline Actions

Not sure if I like this one, the previous form feels more readable.

shafik: Not sure if I like this one, the previous form feels more readable.
else
after = true;
} else { } else {
// For MIPS and ppc64le, set m_watchpoints_trigger_after_instruction to // For MIPS and ppc64le, set m_watchpoints_trigger_after_instruction to
// eLazyBoolNo if it is not calculated before. // eLazyBoolNo if it is not calculated before.
Context not available.
// Is this the initial qSymbol:: packet? // Is this the initial qSymbol:: packet?
bool first_qsymbol_query = true; bool first_qsymbol_query = true;
if (m_supports_qSymbol && m_qSymbol_requests_done == false) { if (m_supports_qSymbol && !m_qSymbol_requests_done) {
Lock lock(*this, false); Lock lock(*this, false);
if (lock) { if (lock) {
StreamString packet; StreamString packet;
Context not available.

source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

Context not available.
((ProcessGDBRemote *)process)->GetGDBRemote()); ((ProcessGDBRemote *)process)->GetGDBRemote());
const bool use_g_packet = const bool use_g_packet =
gdb_comm.AvoidGPackets((ProcessGDBRemote *)process) == false; !gdb_comm.AvoidGPackets((ProcessGDBRemote *)process);
GDBRemoteClientBase::Lock lock(gdb_comm, false); GDBRemoteClientBase::Lock lock(gdb_comm, false);
if (lock) { if (lock) {
Context not available.
((ProcessGDBRemote *)process)->GetGDBRemote()); ((ProcessGDBRemote *)process)->GetGDBRemote());
const bool use_g_packet = const bool use_g_packet =
gdb_comm.AvoidGPackets((ProcessGDBRemote *)process) == false; !gdb_comm.AvoidGPackets((ProcessGDBRemote *)process);
GDBRemoteClientBase::Lock lock(gdb_comm, false); GDBRemoteClientBase::Lock lock(gdb_comm, false);
if (lock) { if (lock) {
Context not available.

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

Context not available.
new EventDataBytes(continue_packet.GetString().data(), new EventDataBytes(continue_packet.GetString().data(),
continue_packet.GetSize())); continue_packet.GetSize()));
if (listener_sp->GetEvent(event_sp, std::chrono::seconds(5)) == false) { if (!listener_sp->GetEvent(event_sp, std::chrono::seconds(5))) {
error.SetErrorString("Resume timed out."); error.SetErrorString("Resume timed out.");
if (log) if (log)
log->Printf("ProcessGDBRemote::DoResume: Resume timed out."); log->Printf("ProcessGDBRemote::DoResume: Resume timed out.");
Context not available.
} }
} }
if (!handled && signo && did_exec == false) { if (!handled && signo && !did_exec) {
if (signo == SIGTRAP) { if (signo == SIGTRAP) {
// Currently we are going to assume SIGTRAP means we are either // Currently we are going to assume SIGTRAP means we are either
// hitting a breakpoint or hardware single stepping. // hitting a breakpoint or hardware single stepping.
Context not available.
// We are are not using non-stop mode, there can only be one last stop // We are are not using non-stop mode, there can only be one last stop
// reply packet, so clear the list. // reply packet, so clear the list.
if (GetTarget().GetNonStopModeEnabled() == false) if (!GetTarget().GetNonStopModeEnabled())
m_stop_packet_stack.clear(); m_stop_packet_stack.clear();
// Add this stop packet to the stop packet stack This stack will get popped // Add this stop packet to the stop packet stack This stack will get popped
Context not available.

source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp

Context not available.
} }
bool ThreadGDBRemote::ThreadHasQueueInformation() const { bool ThreadGDBRemote::ThreadHasQueueInformation() const {
if (m_thread_dispatch_qaddr != 0 && return m_thread_dispatch_qaddr != 0 &&
m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS &&
m_dispatch_queue_t != LLDB_INVALID_ADDRESS && m_dispatch_queue_t != LLDB_INVALID_ADDRESS &&
m_queue_kind != eQueueKindUnknown && m_queue_serial_number != 0) { m_queue_kind != eQueueKindUnknown && m_queue_serial_number != 0;
return true;
}
return false;
} }
LazyBool ThreadGDBRemote::GetAssociatedWithLibdispatchQueue() { LazyBool ThreadGDBRemote::GetAssociatedWithLibdispatchQueue() {
Context not available.

source/Plugins/Process/mach-core/ProcessMachCore.cpp

Context not available.
// LC_IDENT is very obsolete and should not be used in new code, but if the // LC_IDENT is very obsolete and should not be used in new code, but if the
// load command is present, let's use the contents. // load command is present, let's use the contents.
std::string corefile_identifier = core_objfile->GetIdentifierString(); std::string corefile_identifier = core_objfile->GetIdentifierString();
if (found_main_binary_definitively == false if (!found_main_binary_definitively &&
&& corefile_identifier.find("Darwin Kernel") != std::string::npos) { corefile_identifier.find("Darwin Kernel") != std::string::npos) {
UUID uuid; UUID uuid;
addr_t addr = LLDB_INVALID_ADDRESS; addr_t addr = LLDB_INVALID_ADDRESS;
if (corefile_identifier.find("UUID=") != std::string::npos) { if (corefile_identifier.find("UUID=") != std::string::npos) {
size_t p = corefile_identifier.find("UUID=") + strlen("UUID="); size_t p = corefile_identifier.find("UUID=") + strlen("UUID=");
std::string uuid_str = corefile_identifier.substr(p, 36); std::string uuid_str = corefile_identifier.substr(p, 36);
uuid.SetFromStringRef(uuid_str); uuid.SetFromStringRef(uuid_str);
} }
if (corefile_identifier.find("stext=") != std::string::npos) { if (corefile_identifier.find("stext=") != std::string::npos) {
size_t p = corefile_identifier.find("stext=") + strlen("stext="); size_t p = corefile_identifier.find("stext=") + strlen("stext=");
if (corefile_identifier[p] == '0' && corefile_identifier[p + 1] == 'x') { if (corefile_identifier[p] == '0' && corefile_identifier[p + 1] == 'x') {
errno = 0; errno = 0;
addr = ::strtoul(corefile_identifier.c_str() + p, NULL, 16); addr = ::strtoul(corefile_identifier.c_str() + p, NULL, 16);
if (errno != 0 || addr == 0) if (errno != 0 || addr == 0)
addr = LLDB_INVALID_ADDRESS; addr = LLDB_INVALID_ADDRESS;
shafikUnsubmitted
Not Done
ReplyInline Actions

Another big chunk of unrelated changes.

shafik: Another big chunk of unrelated changes.
}
}
if (uuid.IsValid() && addr != LLDB_INVALID_ADDRESS) {
m_mach_kernel_addr = addr;
found_main_binary_definitively = true;
if (log)
log->Printf("ProcessMachCore::DoLoadCore: Using the kernel address 0x%" PRIx64
" from LC_IDENT/LC_NOTE 'kern ver str' string: '%s'", addr, corefile_identifier.c_str());
} }
}
if (uuid.IsValid() && addr != LLDB_INVALID_ADDRESS) {
m_mach_kernel_addr = addr;
found_main_binary_definitively = true;
if (log)
log->Printf(
"ProcessMachCore::DoLoadCore: Using the kernel address 0x%" PRIx64
" from LC_IDENT/LC_NOTE 'kern ver str' string: '%s'",
addr, corefile_identifier.c_str());
}
} }
if (found_main_binary_definitively == false if (!found_main_binary_definitively &&
&& (m_dyld_addr == LLDB_INVALID_ADDRESS (m_dyld_addr == LLDB_INVALID_ADDRESS ||
|| m_mach_kernel_addr == LLDB_INVALID_ADDRESS)) { m_mach_kernel_addr == LLDB_INVALID_ADDRESS)) {
// We need to locate the main executable in the memory ranges we have in // We need to locate the main executable in the memory ranges we have in
// the core file. We need to search for both a user-process dyld binary // the core file. We need to search for both a user-process dyld binary
// and a kernel binary in memory; we must look at all the pages in the // and a kernel binary in memory; we must look at all the pages in the
Context not available.
} }
} }
if (found_main_binary_definitively == false if (!found_main_binary_definitively &&
&& m_mach_kernel_addr != LLDB_INVALID_ADDRESS) { m_mach_kernel_addr != LLDB_INVALID_ADDRESS) {
// In the case of multiple kernel images found in the core file via // In the case of multiple kernel images found in the core file via
// exhaustive search, we may not pick the correct one. See if the // exhaustive search, we may not pick the correct one. See if the
// DynamicLoaderDarwinKernel's search heuristics might identify the correct // DynamicLoaderDarwinKernel's search heuristics might identify the correct
// one. Most of the time, I expect the address from SearchForDarwinKernel() // one. Most of the time, I expect the address from SearchForDarwinKernel()
// will be the same as the address we found via exhaustive search. // will be the same as the address we found via exhaustive search.
if (GetTarget().GetArchitecture().IsValid() == false && if (!GetTarget().GetArchitecture().IsValid() && m_core_module_sp.get()) {
m_core_module_sp.get()) {
GetTarget().SetArchitecture(m_core_module_sp->GetArchitecture()); GetTarget().SetArchitecture(m_core_module_sp->GetArchitecture());
} }
Context not available.

source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

Context not available.
bool PythonBytes::Check(PyObject *py_obj) { bool PythonBytes::Check(PyObject *py_obj) {
if (!py_obj) if (!py_obj)
return false; return false;
if (PyBytes_Check(py_obj)) return PyBytes_Check(py_obj);
return true;
return false;
} }
void PythonBytes::Reset(PyRefType type, PyObject *py_obj) { void PythonBytes::Reset(PyRefType type, PyObject *py_obj) {
Context not available.
bool PythonByteArray::Check(PyObject *py_obj) { bool PythonByteArray::Check(PyObject *py_obj) {
if (!py_obj) if (!py_obj)
return false; return false;
if (PyByteArray_Check(py_obj)) return PyByteArray_Check(py_obj);
return true;
return false;
} }
void PythonByteArray::Reset(PyRefType type, PyObject *py_obj) { void PythonByteArray::Reset(PyRefType type, PyObject *py_obj) {
Context not available.

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

Context not available.
m_python_interpreter(py_interpreter) { m_python_interpreter(py_interpreter) {
DoAcquireLock(); DoAcquireLock();
if ((on_entry & InitSession) == InitSession) { if ((on_entry & InitSession) == InitSession) {
if (DoInitSession(on_entry, in, out, err) == false) { if (!DoInitSession(on_entry, in, out, err)) {
// Don't teardown the session if we didn't init it. // Don't teardown the session if we didn't init it.
m_teardown_session = false; m_teardown_session = false;
} }
Context not available.
bool was_imported = (was_imported_globally || was_imported_locally); bool was_imported = (was_imported_globally || was_imported_locally);
if (was_imported == true && can_reload == false) { if (was_imported && !can_reload) {
error.SetErrorString("module already imported"); error.SetErrorString("module already imported");
return false; return false;
} }
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

Context not available.
} }
if (byte_size_valid && byte_size == 0 && type_name_cstr && if (byte_size_valid && byte_size == 0 && type_name_cstr &&
die.HasChildren() == false && !die.HasChildren() &&
sc.comp_unit->GetLanguage() == eLanguageTypeObjC) { sc.comp_unit->GetLanguage() == eLanguageTypeObjC) {
// Work around an issue with clang at the moment where forward // Work around an issue with clang at the moment where forward
// declarations for objective C classes are emitted as: // declarations for objective C classes are emitted as:
Context not available.
// has child classes or types that require the class to be created // has child classes or types that require the class to be created
// for use as their decl contexts the class will be ready to accept // for use as their decl contexts the class will be ready to accept
// these child definitions. // these child definitions.
if (die.HasChildren() == false) { if (!die.HasChildren()) {
// No children for this struct/union/class, lets finish it // No children for this struct/union/class, lets finish it
if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) { if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
ClangASTContext::CompleteTagDeclarationDefinition(clang_type); ClangASTContext::CompleteTagDeclarationDefinition(clang_type);
Context not available.
element_type->GetForwardCompilerType(); element_type->GetForwardCompilerType();
if (ClangASTContext::IsCXXClassType(array_element_type) && if (ClangASTContext::IsCXXClassType(array_element_type) &&
array_element_type.GetCompleteType() == false) { !array_element_type.GetCompleteType()) {
ModuleSP module_sp = die.GetModule(); ModuleSP module_sp = die.GetModule();
if (module_sp) { if (module_sp) {
if (die.GetCU()->GetProducer() == eProducerClang) if (die.GetCU()->GetProducer() == eProducerClang)
Context not available.
if (type_source_info) { if (type_source_info) {
CompilerType base_class_type( CompilerType base_class_type(
&m_ast, type_source_info->getType().getAsOpaquePtr()); &m_ast, type_source_info->getType().getAsOpaquePtr());
if (base_class_type.GetCompleteType() == false) { if (!base_class_type.GetCompleteType()) {
auto module = dwarf->GetObjectFile()->GetModule(); auto module = dwarf->GetObjectFile()->GetModule();
module->ReportError(":: Class '%s' has a base class '%s' which " module->ReportError(":: Class '%s' has a base class '%s' which "
"does not have a complete definition.", "does not have a complete definition.",
Context not available.
break; break;
} }
if (is_artificial == false) { if (!is_artificial) {
Type *member_type = die.ResolveTypeUID(DIERef(encoding_form)); Type *member_type = die.ResolveTypeUID(DIERef(encoding_form));
clang::FieldDecl *field_decl = NULL; clang::FieldDecl *field_decl = NULL;
Context not available.
} }
if (ClangASTContext::IsCXXClassType(member_clang_type) && if (ClangASTContext::IsCXXClassType(member_clang_type) &&
member_clang_type.GetCompleteType() == false) { !member_clang_type.GetCompleteType()) {
if (die.GetCU()->GetProducer() == eProducerClang) if (die.GetCU()->GetProducer() == eProducerClang)
module_sp->ReportError( module_sp->ReportError(
"DWARF DIE at 0x%8.8x (class %s) has a member variable " "DWARF DIE at 0x%8.8x (class %s) has a member variable "
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

Context not available.
state_coll.insert(range.first, state); state_coll.insert(range.first, state);
} else { } else {
if ((distance(range.first, range.second) == 1) && if ((distance(range.first, range.second) == 1) &&
range.first->end_sequence == true) { static_cast<bool>(range.first->end_sequence)) {
shafikUnsubmitted
Not Done
ReplyInline Actions

The static_cast feels less readable here.

shafik: The `static_cast` feels less readable here.
*range.first = state; *range.first = state;
} else { } else {
state_coll.insert(range.second, state); state_coll.insert(range.second, state);
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFDebugMacro.cpp

Context not available.
header.m_version = debug_macro_data.GetU16(offset); header.m_version = debug_macro_data.GetU16(offset);
uint8_t flags = debug_macro_data.GetU8(offset); uint8_t flags = debug_macro_data.GetU8(offset);
header.m_offset_is_64_bit = flags & OFFSET_SIZE_MASK ? true : false; header.m_offset_is_64_bit = (flags & OFFSET_SIZE_MASK) != 0;
if (flags & DEBUG_LINE_OFFSET_MASK) { if (flags & DEBUG_LINE_OFFSET_MASK) {
if (header.m_offset_is_64_bit) if (header.m_offset_is_64_bit)
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

Context not available.
} }
bool DWARFUnit::Supports_DW_AT_APPLE_objc_complete_type() { bool DWARFUnit::Supports_DW_AT_APPLE_objc_complete_type() {
if (GetProducer() == eProducerLLVMGCC) return GetProducer() != eProducerLLVMGCC;
return false;
return true;
} }
bool DWARFUnit::DW_AT_decl_file_attributes_are_invalid() { bool DWARFUnit::DW_AT_decl_file_attributes_are_invalid() {
Context not available.
bool DWARFUnit::Supports_unnamed_objc_bitfields() { bool DWARFUnit::Supports_unnamed_objc_bitfields() {
if (GetProducer() == eProducerClang) { if (GetProducer() == eProducerClang) {
const uint32_t major_version = GetProducerVersionMajor(); const uint32_t major_version = GetProducerVersionMajor();
if (major_version > 425 || return major_version > 425 ||
(major_version == 425 && GetProducerVersionUpdate() >= 13)) (major_version == 425 && GetProducerVersionUpdate() >= 13);
return true;
else
return false;
} }
return true; // Assume all other compilers didn't have incorrect ObjC bitfield return true; // Assume all other compilers didn't have incorrect ObjC bitfield
// info // info
Context not available.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Context not available.
DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx); DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
const DWARFBaseDIE die = dwarf_cu->GetUnitDIEOnly(); const DWARFBaseDIE die = dwarf_cu->GetUnitDIEOnly();
if (die && die.HasChildren() == false) { if (die && !die.HasChildren()) {
const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr); const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr);
if (name) { if (name) {
Context not available.
sc.block = function_block.FindBlockByID(inlined_die.GetID()); sc.block = function_block.FindBlockByID(inlined_die.GetID());
if (sc.block == NULL) if (sc.block == NULL)
sc.block = function_block.FindBlockByID(inlined_die.GetOffset()); sc.block = function_block.FindBlockByID(inlined_die.GetOffset());
if (sc.block == NULL || sc.block->GetStartAddress(addr) == false) if (sc.block == NULL || !sc.block->GetStartAddress(addr))
addr.Clear(); addr.Clear();
} else { } else {
sc.block = NULL; sc.block = NULL;
Context not available.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

Context not available.
idx < oso_end_idx; ++idx) { idx < oso_end_idx; ++idx) {
Symbol *exe_symbol = exe_symtab->SymbolAtIndex(idx); Symbol *exe_symbol = exe_symtab->SymbolAtIndex(idx);
if (exe_symbol) { if (exe_symbol) {
if (exe_symbol->IsDebug() == false) if (!exe_symbol->IsDebug())
continue; continue;
switch (exe_symbol->GetType()) { switch (exe_symbol->GetType()) {
Context not available.
GetSymbolVendor(bool can_create = true, GetSymbolVendor(bool can_create = true,
lldb_private::Stream *feedback_strm = NULL) override { lldb_private::Stream *feedback_strm = NULL) override {
// Scope for locker // Scope for locker
if (m_symfile_ap.get() || can_create == false) if (m_symfile_ap.get() || !can_create)
return m_symfile_ap.get(); return m_symfile_ap.get();
ModuleSP exe_module_sp(m_exe_module_wp.lock()); ModuleSP exe_module_sp(m_exe_module_wp.lock());
Context not available.
// Only search all .o files for the definition if we don't need the // Only search all .o files for the definition if we don't need the
// implementation because otherwise, with a valid debug map we should have // implementation because otherwise, with a valid debug map we should have
// the ObjC class symbol and the code above should have found it. // the ObjC class symbol and the code above should have found it.
if (must_be_implementation == false) { if (!must_be_implementation) {
TypeSP type_sp; TypeSP type_sp;
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
Context not available.
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
oso_dwarf->FindTypes(sc, name, parent_decl_ctx, append, max_matches, oso_dwarf->FindTypes(sc, name, parent_decl_ctx, append, max_matches,
searched_symbol_files, types); searched_symbol_files, types);
if (types.GetSize() >= max_matches) return types.GetSize() >= max_matches;
return true;
else
return false;
}); });
} }
Context not available.

source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

Context not available.
CompilerType element_ast_type = element_type->GetForwardCompilerType(); CompilerType element_ast_type = element_type->GetForwardCompilerType();
// If element type is UDT, it needs to be complete. // If element type is UDT, it needs to be complete.
if (ClangASTContext::IsCXXClassType(element_ast_type) && if (ClangASTContext::IsCXXClassType(element_ast_type) &&
element_ast_type.GetCompleteType() == false) { !element_ast_type.GetCompleteType()) {
if (ClangASTContext::StartTagDeclarationDefinition(element_ast_type)) { if (ClangASTContext::StartTagDeclarationDefinition(element_ast_type)) {
ClangASTContext::CompleteTagDeclarationDefinition(element_ast_type); ClangASTContext::CompleteTagDeclarationDefinition(element_ast_type);
} else { } else {
Context not available.

source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp

Context not available.
// object is DBGSourcePath // object is DBGSourcePath
std::string DBGSourcePath = std::string DBGSourcePath =
object->GetStringValue(); object->GetStringValue();
if (new_style_source_remapping_dictionary == if (!new_style_source_remapping_dictionary &&
false &&
!original_DBGSourcePath_value.empty()) { !original_DBGSourcePath_value.empty()) {
DBGSourcePath = original_DBGSourcePath_value; DBGSourcePath = original_DBGSourcePath_value;
} }
Context not available.

source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp

Context not available.
error.Clear(); error.Clear();
if (thread.SafeToCallFunctions() == false) { if (!thread.SafeToCallFunctions()) {
if (log) if (log)
log->Printf("Not safe to call functions on thread 0x%" PRIx64, log->Printf("Not safe to call functions on thread 0x%" PRIx64,
thread.GetID()); thread.GetID());
Context not available.

source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp

Context not available.
error.Clear(); error.Clear();
if (thread.SafeToCallFunctions() == false) { if (!thread.SafeToCallFunctions()) {
if (log) if (log)
log->Printf("Not safe to call functions on thread 0x%" PRIx64, log->Printf("Not safe to call functions on thread 0x%" PRIx64,
thread.GetID()); thread.GetID());
Context not available.

source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp

Context not available.
error.Clear(); error.Clear();
if (thread.SafeToCallFunctions() == false) { if (!thread.SafeToCallFunctions()) {
if (log) if (log)
log->Printf("Not safe to call functions on thread 0x%" PRIx64, log->Printf("Not safe to call functions on thread 0x%" PRIx64,
thread.GetID()); thread.GetID());
Context not available.

source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp

Context not available.
error.Clear(); error.Clear();
if (thread.SafeToCallFunctions() == false) { if (!thread.SafeToCallFunctions()) {
if (log) if (log)
log->Printf("Not safe to call functions on thread 0x%" PRIx64, log->Printf("Not safe to call functions on thread 0x%" PRIx64,
thread.GetID()); thread.GetID());
Context not available.

source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp

Context not available.
return false; return false;
} }
UnwindPlan::Row::RegisterLocation first_row_pc_loc; UnwindPlan::Row::RegisterLocation first_row_pc_loc;
if (first_row->GetRegisterInfo( if (!first_row->GetRegisterInfo(
pc_regnum.GetAsKind(unwind_plan.GetRegisterKind()), pc_regnum.GetAsKind(unwind_plan.GetRegisterKind()),
first_row_pc_loc) == false || first_row_pc_loc) ||
first_row_pc_loc.IsAtCFAPlusOffset() == false || !first_row_pc_loc.IsAtCFAPlusOffset() ||
first_row_pc_loc.GetOffset() != -wordsize) { first_row_pc_loc.GetOffset() != -wordsize) {
return false; return false;
} }
Context not available.

source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp

Context not available.
// pushq %rbp [0x55] // pushq %rbp [0x55]
bool x86AssemblyInspectionEngine::push_rbp_pattern_p() { bool x86AssemblyInspectionEngine::push_rbp_pattern_p() {
uint8_t *p = m_cur_insn; uint8_t *p = m_cur_insn;
if (*p == 0x55) return *p == 0x55;
return true;
return false;
} }
// pushq $0 ; the first instruction in start() [0x6a 0x00] // pushq $0 ; the first instruction in start() [0x6a 0x00]
bool x86AssemblyInspectionEngine::push_0_pattern_p() { bool x86AssemblyInspectionEngine::push_0_pattern_p() {
uint8_t *p = m_cur_insn; uint8_t *p = m_cur_insn;
if (*p == 0x6a && *(p + 1) == 0x0) return *p == 0x6a && *(p + 1) == 0x0;
return true;
return false;
} }
// pushq $0 // pushq $0
// pushl $0 // pushl $0
bool x86AssemblyInspectionEngine::push_imm_pattern_p() { bool x86AssemblyInspectionEngine::push_imm_pattern_p() {
uint8_t *p = m_cur_insn; uint8_t *p = m_cur_insn;
if (*p == 0x68 || *p == 0x6a) return *p == 0x68 || *p == 0x6a;
return true;
return false;
} }
// pushl imm8(%esp) // pushl imm8(%esp)
Context not available.
// ret [0xc9] or [0xc2 imm8] or [0xca imm8] // ret [0xc9] or [0xc2 imm8] or [0xca imm8]
bool x86AssemblyInspectionEngine::ret_pattern_p() { bool x86AssemblyInspectionEngine::ret_pattern_p() {
uint8_t *p = m_cur_insn; uint8_t *p = m_cur_insn;
if (*p == 0xc9 || *p == 0xc2 || *p == 0xca || *p == 0xc3) return *p == 0xc9 || *p == 0xc2 || *p == 0xca || *p == 0xc3;
return true;
return false;
} }
uint32_t x86AssemblyInspectionEngine::extract_4(uint8_t *b) { uint32_t x86AssemblyInspectionEngine::extract_4(uint8_t *b) {
Context not available.
if (data == nullptr || size == 0) if (data == nullptr || size == 0)
return false; return false;
if (m_register_map_initialized == false) if (!m_register_map_initialized)
return false; return false;
addr_t current_func_text_offset = 0; addr_t current_func_text_offset = 0;
Context not available.
// on the stack // on the stack
if (nonvolatile_reg_p(machine_regno) && if (nonvolatile_reg_p(machine_regno) &&
machine_regno_to_lldb_regno(machine_regno, lldb_regno) && machine_regno_to_lldb_regno(machine_regno, lldb_regno) &&
saved_registers[machine_regno] == false) { !saved_registers[machine_regno]) {
UnwindPlan::Row::RegisterLocation regloc; UnwindPlan::Row::RegisterLocation regloc;
if (is_aligned) if (is_aligned)
regloc.SetAtAFAPlusOffset(-current_sp_bytes_offset_from_fa); regloc.SetAtAFAPlusOffset(-current_sp_bytes_offset_from_fa);
Context not available.
if (nonvolatile_reg_p(machine_regno) && if (nonvolatile_reg_p(machine_regno) &&
machine_regno_to_lldb_regno(machine_regno, lldb_regno) && machine_regno_to_lldb_regno(machine_regno, lldb_regno) &&
saved_registers[machine_regno] == true) { saved_registers[machine_regno]) {
saved_registers[machine_regno] = false; saved_registers[machine_regno] = false;
row->RemoveRegisterInfo(lldb_regno); row->RemoveRegisterInfo(lldb_regno);
Context not available.
else if (mov_reg_to_local_stack_frame_p(machine_regno, stack_offset) && else if (mov_reg_to_local_stack_frame_p(machine_regno, stack_offset) &&
nonvolatile_reg_p(machine_regno) && nonvolatile_reg_p(machine_regno) &&
machine_regno_to_lldb_regno(machine_regno, lldb_regno) && machine_regno_to_lldb_regno(machine_regno, lldb_regno) &&
saved_registers[machine_regno] == false) { !saved_registers[machine_regno]) {
saved_registers[machine_regno] = true; saved_registers[machine_regno] = true;
UnwindPlan::Row::RegisterLocation regloc; UnwindPlan::Row::RegisterLocation regloc;
Context not available.
} }
} }
if (in_epilogue == false && row_updated) { if (!in_epilogue && row_updated) {
// If we're not in an epilogue sequence, save the updated Row // If we're not in an epilogue sequence, save the updated Row
UnwindPlan::Row *newrow = new UnwindPlan::Row; UnwindPlan::Row *newrow = new UnwindPlan::Row;
*newrow = *row.get(); *newrow = *row.get();
Context not available.
// We may change the sp value without adding a new Row necessarily -- keep // We may change the sp value without adding a new Row necessarily -- keep
// track of it either way. // track of it either way.
if (in_epilogue == false) { if (!in_epilogue) {
prologue_completed_sp_bytes_offset_from_cfa = prologue_completed_sp_bytes_offset_from_cfa =
current_sp_bytes_offset_from_fa; current_sp_bytes_offset_from_fa;
prologue_completed_is_aligned = is_aligned; prologue_completed_is_aligned = is_aligned;
Context not available.
uint8_t *data, size_t size, size_t &offset) { uint8_t *data, size_t size, size_t &offset) {
offset = 0; offset = 0;
if (m_register_map_initialized == false) if (!m_register_map_initialized)
return false; return false;
while (offset < size) { while (offset < size) {
Context not available.

source/Symbol/Block.cpp

Context not available.
size_t num_ranges = m_ranges.GetSize(); size_t num_ranges = m_ranges.GetSize();
for (size_t i = 0; i < num_ranges; ++i) { for (size_t i = 0; i < num_ranges; ++i) {
const Range &range = m_ranges.GetEntryRef(i); const Range &range = m_ranges.GetEntryRef(i);
if (parent_block != nullptr && parent_block->Contains(range) == false) if (parent_block != nullptr && !parent_block->Contains(range))
*s << '!'; *s << '!';
else else
*s << ' '; *s << ' ';
Context not available.
} }
VariableListSP Block::GetBlockVariableList(bool can_create) { VariableListSP Block::GetBlockVariableList(bool can_create) {
if (m_parsed_block_variables == false) { if (!m_parsed_block_variables) {
if (m_variable_list_sp.get() == nullptr && can_create) { if (m_variable_list_sp.get() == nullptr && can_create) {
m_parsed_block_variables = true; m_parsed_block_variables = true;
SymbolContext sc; SymbolContext sc;
Context not available.
collection::const_iterator pos, end = m_children.end(); collection::const_iterator pos, end = m_children.end();
for (pos = m_children.begin(); pos != end; ++pos) { for (pos = m_children.begin(); pos != end; ++pos) {
Block *child_block = pos->get(); Block *child_block = pos->get();
if (stop_if_child_block_is_inlined_function == false || if (!stop_if_child_block_is_inlined_function ||
child_block->GetInlinedFunctionInfo() == nullptr) { child_block->GetInlinedFunctionInfo() == nullptr) {
num_variables_added += child_block->AppendBlockVariables( num_variables_added += child_block->AppendBlockVariables(
can_create, get_child_block_variables, can_create, get_child_block_variables,
Context not available.

source/Symbol/ClangASTContext.cpp

Context not available.
static inline bool QualTypeMatchesBitSize(const uint64_t bit_size, static inline bool QualTypeMatchesBitSize(const uint64_t bit_size,
ASTContext *ast, QualType qual_type) { ASTContext *ast, QualType qual_type) {
uint64_t qual_type_bit_size = ast->getTypeSize(qual_type); uint64_t qual_type_bit_size = ast->getTypeSize(qual_type);
if (qual_type_bit_size == bit_size) return qual_type_bit_size == bit_size;
return true;
return false;
} }
CompilerType CompilerType
Context not available.
} }
static inline bool BaseSpecifierIsEmpty(const CXXBaseSpecifier *b) { static inline bool BaseSpecifierIsEmpty(const CXXBaseSpecifier *b) {
return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == return !ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl());
false;
} }
uint32_t uint32_t
Context not available.
return false; return false;
clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
if (!qual_type.isNull() && qual_type->getAsCXXRecordDecl() != nullptr) return !qual_type.isNull() && qual_type->getAsCXXRecordDecl() != nullptr;
return true;
return false;
} }
bool ClangASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) { bool ClangASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) {
Context not available.
->getDecl()); ->getDecl());
// Skip empty base classes // Skip empty base classes
if (ClangASTContext::RecordHasFields(base_class_decl) == false) if (!ClangASTContext::RecordHasFields(base_class_decl))
continue; continue;
num_children++; num_children++;
Context not available.
if (omit_empty_base_classes) { if (omit_empty_base_classes) {
base_class_decl = llvm::cast<clang::CXXRecordDecl>( base_class_decl = llvm::cast<clang::CXXRecordDecl>(
base_class->getType()->getAs<clang::RecordType>()->getDecl()); base_class->getType()->getAs<clang::RecordType>()->getDecl());
if (ClangASTContext::RecordHasFields(base_class_decl) == false) if (!ClangASTContext::RecordHasFields(base_class_decl))
continue; continue;
} }
Context not available.
->getAs<clang::RecordType>() ->getAs<clang::RecordType>()
->getDecl()); ->getDecl());
if (omit_empty_base_classes && if (omit_empty_base_classes &&
ClangASTContext::RecordHasFields(base_class_decl) == false) !ClangASTContext::RecordHasFields(base_class_decl))
continue; continue;
CompilerType base_class_clang_type(getASTContext(), CompilerType base_class_clang_type(getASTContext(),
Context not available.
base_class->getType()->getAs<clang::RecordType>()->getDecl()); base_class->getType()->getAs<clang::RecordType>()->getDecl());
// Skip empty base classes // Skip empty base classes
if (verbose == false && if (!verbose && !ClangASTContext::RecordHasFields(base_class_decl))
ClangASTContext::RecordHasFields(base_class_decl) == false)
continue; continue;
if (base_class->isVirtual()) if (base_class->isVirtual())
Context not available.

source/Symbol/ClangASTImporter.cpp

Context not available.
if (isa<TagDecl>(to) || isa<ObjCInterfaceDecl>(to)) { if (isa<TagDecl>(to) || isa<ObjCInterfaceDecl>(to)) {
RecordDecl *from_record_decl = dyn_cast<RecordDecl>(from); RecordDecl *from_record_decl = dyn_cast<RecordDecl>(from);
if (from_record_decl == nullptr || if (from_record_decl == nullptr ||
from_record_decl->isInjectedClassName() == false) { !from_record_decl->isInjectedClassName()) {
NamedDecl *to_named_decl = dyn_cast<NamedDecl>(to); NamedDecl *to_named_decl = dyn_cast<NamedDecl>(to);
if (!m_decls_already_deported->count(to_named_decl)) if (!m_decls_already_deported->count(to_named_decl))
Context not available.

source/Symbol/CompactUnwindInfo.cpp

Context not available.
m_objfile.GetModule()->LogMessage( m_objfile.GetModule()->LogMessage(
log, "Reading compact unwind first-level indexes"); log, "Reading compact unwind first-level indexes");
if (m_unwindinfo_data_computed == false) { if (!m_unwindinfo_data_computed) {
if (m_section_sp->IsEncrypted()) { if (m_section_sp->IsEncrypted()) {
// Can't get section contents of a protected/encrypted section until we // Can't get section contents of a protected/encrypted section until we
// have a live process and can read them out of memory. // have a live process and can read them out of memory.
Context not available.
--it; --it;
} }
if (it->sentinal_entry == true) { if (it->sentinal_entry) {
return false; return false;
} }
Context not available.
for (uint32_t i = 0; i < register_count; i++) { for (uint32_t i = 0; i < register_count; i++) {
int renum = 0; int renum = 0;
for (int j = 1; j < 7; j++) { for (int j = 1; j < 7; j++) {
if (used[j] == false) { if (!used[j]) {
if (renum == permunreg[i]) { if (renum == permunreg[i]) {
registers[i] = j; registers[i] = j;
used[j] = true; used[j] = true;
Context not available.
for (uint32_t i = 0; i < register_count; i++) { for (uint32_t i = 0; i < register_count; i++) {
int renum = 0; int renum = 0;
for (int j = 1; j < 7; j++) { for (int j = 1; j < 7; j++) {
if (used[j] == false) { if (!used[j]) {
if (renum == permunreg[i]) { if (renum == permunreg[i]) {
registers[i] = j; registers[i] = j;
used[j] = true; used[j] = true;
Context not available.

source/Symbol/CompileUnit.cpp

Context not available.
// If we are not looking for inlined functions and our file spec doesn't // If we are not looking for inlined functions and our file spec doesn't
// match then we are done... // match then we are done...
if (file_spec_matches_cu_file_spec == false && check_inlines == false) if (!file_spec_matches_cu_file_spec && !check_inlines)
return 0; return 0;
uint32_t file_idx = uint32_t file_idx =
Context not available.

source/Symbol/DWARFCallFrameInfo.cpp

Context not available.
module_sp->GetObjectFile() != &m_objfile) module_sp->GetObjectFile() != &m_objfile)
return false; return false;
if (GetFDEEntryByFileAddress(addr.GetFileAddress(), fde_entry) == false) if (!GetFDEEntryByFileAddress(addr.GetFileAddress(), fde_entry))
return false; return false;
return FDEToUnwindPlan(fde_entry.data, addr, unwind_plan); return FDEToUnwindPlan(fde_entry.data, addr, unwind_plan);
} }
Context not available.
DWARFCallFrameInfo::ParseCIE(const dw_offset_t cie_offset) { DWARFCallFrameInfo::ParseCIE(const dw_offset_t cie_offset) {
CIESP cie_sp(new CIE(cie_offset)); CIESP cie_sp(new CIE(cie_offset));
lldb::offset_t offset = cie_offset; lldb::offset_t offset = cie_offset;
if (m_cfi_data_initialized == false) if (!m_cfi_data_initialized)
GetCFIData(); GetCFIData();
uint32_t length = m_cfi_data.GetU32(&offset); uint32_t length = m_cfi_data.GetU32(&offset);
dw_offset_t cie_id, end_offset; dw_offset_t cie_id, end_offset;
Context not available.
} }
void DWARFCallFrameInfo::GetCFIData() { void DWARFCallFrameInfo::GetCFIData() {
if (m_cfi_data_initialized == false) { if (!m_cfi_data_initialized) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND)); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
if (log) if (log)
m_objfile.GetModule()->LogMessage(log, "Reading EH frame info"); m_objfile.GetModule()->LogMessage(log, "Reading EH frame info");
Context not available.
} }
lldb::offset_t offset = 0; lldb::offset_t offset = 0;
if (m_cfi_data_initialized == false) if (!m_cfi_data_initialized)
GetCFIData(); GetCFIData();
while (m_cfi_data.ValidOffsetForDataOfSize(offset, 8)) { while (m_cfi_data.ValidOffsetForDataOfSize(offset, 8)) {
const dw_offset_t current_entry = offset; const dw_offset_t current_entry = offset;
Context not available.
if (m_section_sp.get() == nullptr || m_section_sp->IsEncrypted()) if (m_section_sp.get() == nullptr || m_section_sp->IsEncrypted())
return false; return false;
if (m_cfi_data_initialized == false) if (!m_cfi_data_initialized)
GetCFIData(); GetCFIData();
uint32_t length = m_cfi_data.GetU32(&offset); uint32_t length = m_cfi_data.GetU32(&offset);
Context not available.

source/Symbol/FuncUnwinders.cpp

Context not available.
int current_offset) { int current_offset) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (m_unwind_plan_assembly_sp.get() || m_tried_unwind_plan_assembly || if (m_unwind_plan_assembly_sp.get() || m_tried_unwind_plan_assembly ||
m_unwind_table.GetAllowAssemblyEmulationUnwindPlans() == false) { !m_unwind_table.GetAllowAssemblyEmulationUnwindPlans()) {
return m_unwind_plan_assembly_sp; return m_unwind_plan_assembly_sp;
} }
Context not available.

source/Symbol/LineTable.cpp

Context not available.
while (pos != begin_pos) { while (pos != begin_pos) {
entry_collection::const_iterator prev_pos = pos - 1; entry_collection::const_iterator prev_pos = pos - 1;
if (prev_pos->file_addr == search_entry.file_addr && if (prev_pos->file_addr == search_entry.file_addr &&
prev_pos->is_terminal_entry == false) !static_cast<bool>(prev_pos->is_terminal_entry))
shafikUnsubmitted
Not Done
ReplyInline Actions

static_cast

shafik: static_cast
--pos; --pos;
else else
break; break;
Context not available.
// Make sure we have a valid match and that the match isn't a // Make sure we have a valid match and that the match isn't a
// terminating entry for a previous line... // terminating entry for a previous line...
if (pos != end_pos && pos->is_terminal_entry == false) { if (pos != end_pos && !static_cast<bool>(pos->is_terminal_entry)) {
shafikUnsubmitted
Not Done
ReplyInline Actions

static_cast

shafik: static_cast
uint32_t match_idx = std::distance(begin_pos, pos); uint32_t match_idx = std::distance(begin_pos, pos);
success = ConvertEntryAtIndexToLineEntry(match_idx, line_entry); success = ConvertEntryAtIndexToLineEntry(match_idx, line_entry);
if (index_ptr != nullptr && success) if (index_ptr != nullptr && success)
Context not available.

source/Symbol/ObjectFile.cpp

Context not available.
regex_match.GetMatchAtIndex(path_with_object, 2, obj)) { regex_match.GetMatchAtIndex(path_with_object, 2, obj)) {
archive_file.SetFile(path, FileSpec::Style::native); archive_file.SetFile(path, FileSpec::Style::native);
archive_object.SetCString(obj.c_str()); archive_object.SetCString(obj.c_str());
if (must_exist && !FileSystem::Instance().Exists(archive_file)) return !(must_exist && !FileSystem::Instance().Exists(archive_file));
return false;
return true;
} }
} }
return false; return false;
Context not available.

source/Symbol/SymbolContext.cpp

Context not available.
if (function != nullptr) { if (function != nullptr) {
SymbolContext inline_parent_sc; SymbolContext inline_parent_sc;
Address inline_parent_addr; Address inline_parent_addr;
if (show_function_name == false) { if (!show_function_name) {
s->Printf("<"); s->Printf("<");
dumped_something = true; dumped_something = true;
} else { } else {
ConstString name; ConstString name;
if (show_function_arguments == false) if (!show_function_arguments)
name = function->GetNameNoArguments(); name = function->GetNameNoArguments();
if (!name) if (!name)
name = function->GetName(); name = function->GetName();
Context not available.
const addr_t function_offset = const addr_t function_offset =
addr.GetOffset() - addr.GetOffset() -
function->GetAddressRange().GetBaseAddress().GetOffset(); function->GetAddressRange().GetBaseAddress().GetOffset();
if (show_function_name == false) { if (!show_function_name) {
// Print +offset even if offset is 0 // Print +offset even if offset is 0
dumped_something = true; dumped_something = true;
s->Printf("+%" PRIu64 ">", function_offset); s->Printf("+%" PRIu64 ">", function_offset);
Context not available.
} }
} }
} else if (symbol != nullptr) { } else if (symbol != nullptr) {
if (show_function_name == false) { if (!show_function_name) {
s->Printf("<"); s->Printf("<");
dumped_something = true; dumped_something = true;
} else if (symbol->GetName()) { } else if (symbol->GetName()) {
Context not available.
if (addr.IsValid() && symbol->ValueIsAddress()) { if (addr.IsValid() && symbol->ValueIsAddress()) {
const addr_t symbol_offset = const addr_t symbol_offset =
addr.GetOffset() - symbol->GetAddressRef().GetOffset(); addr.GetOffset() - symbol->GetAddressRef().GetOffset();
if (show_function_name == false) { if (!show_function_name) {
// Print +offset even if offset is 0 // Print +offset even if offset is 0
dumped_something = true; dumped_something = true;
s->Printf("+%" PRIu64 ">", symbol_offset); s->Printf("+%" PRIu64 ">", symbol_offset);
Context not available.
} }
if (merge_symbol_into_function && sc.symbol != nullptr && if (merge_symbol_into_function && sc.symbol != nullptr &&
sc.comp_unit == nullptr && sc.function == nullptr && sc.comp_unit == nullptr && sc.function == nullptr &&
sc.block == nullptr && sc.line_entry.IsValid() == false) { sc.block == nullptr && !sc.line_entry.IsValid()) {
if (sc.symbol->ValueIsAddress()) { if (sc.symbol->ValueIsAddress()) {
for (pos = m_symbol_contexts.begin(); pos != end; ++pos) { for (pos = m_symbol_contexts.begin(); pos != end; ++pos) {
// Don't merge symbols into inlined function symbol contexts // Don't merge symbols into inlined function symbol contexts
Context not available.
const SymbolContext &symbol_sc, uint32_t start_idx, uint32_t stop_idx) { const SymbolContext &symbol_sc, uint32_t start_idx, uint32_t stop_idx) {
if (symbol_sc.symbol != nullptr && symbol_sc.comp_unit == nullptr && if (symbol_sc.symbol != nullptr && symbol_sc.comp_unit == nullptr &&
symbol_sc.function == nullptr && symbol_sc.block == nullptr && symbol_sc.function == nullptr && symbol_sc.block == nullptr &&
symbol_sc.line_entry.IsValid() == false) { !symbol_sc.line_entry.IsValid()) {
if (symbol_sc.symbol->ValueIsAddress()) { if (symbol_sc.symbol->ValueIsAddress()) {
const size_t end = std::min<size_t>(m_symbol_contexts.size(), stop_idx); const size_t end = std::min<size_t>(m_symbol_contexts.size(), stop_idx);
for (size_t i = start_idx; i < end; ++i) { for (size_t i = start_idx; i < end; ++i) {
Context not available.

source/Symbol/Symtab.cpp

Context not available.
for (uint32_t i = 0; i < sym_end; i++) { for (uint32_t i = 0; i < sym_end; i++) {
if (symbol_type == eSymbolTypeAny || if (symbol_type == eSymbolTypeAny ||
m_symbols[i].GetType() == symbol_type) { m_symbols[i].GetType() == symbol_type) {
if (CheckSymbolAtIndex(i, symbol_debug_type, symbol_visibility) == false) if (!CheckSymbolAtIndex(i, symbol_debug_type, symbol_visibility))
continue; continue;
const char *name = m_symbols[i].GetName().AsCString(); const char *name = m_symbols[i].GetName().AsCString();
Context not available.

source/Symbol/Type.cpp

Context not available.
} }
bool TypeAndOrName::IsEmpty() const { bool TypeAndOrName::IsEmpty() const {
if ((bool)m_type_name || (bool)m_type_pair) return !((bool)m_type_name || (bool)m_type_pair);
shafikUnsubmitted
Not Done
ReplyInline Actions

Oh, even worse C-style casts ... can we remove these. I am assuming they are triggering a member conversion function.

shafik: Oh, even worse C-style casts ... can we remove these. I am assuming they are triggering a…
return false;
else
return true;
} }
void TypeAndOrName::Clear() { void TypeAndOrName::Clear() {
Context not available.

source/Symbol/TypeSystem.cpp

Context not available.
TypeSystem *type_system = pair.second.get(); TypeSystem *type_system = pair.second.get();
if (type_system && !visited.count(type_system)) { if (type_system && !visited.count(type_system)) {
visited.insert(type_system); visited.insert(type_system);
if (callback(type_system) == false) if (!callback(type_system))
break; break;
} }
} }
Context not available.

source/Target/Platform.cpp

Context not available.
if (process->GetModuleSpec(module_spec.GetFileSpec(), if (process->GetModuleSpec(module_spec.GetFileSpec(),
module_spec.GetArchitecture(), module_spec.GetArchitecture(),
resolved_module_spec)) { resolved_module_spec)) {
if (module_spec.GetUUID().IsValid() == false || if (!module_spec.GetUUID().IsValid() ||
module_spec.GetUUID() == resolved_module_spec.GetUUID()) { module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
got_module_spec = true; got_module_spec = true;
} }
} }
} }
if (module_spec.GetArchitecture().IsValid() == false) { if (!module_spec.GetArchitecture().IsValid()) {
Status error; Status error;
// No valid architecture was specified, ask the platform for the // No valid architecture was specified, ask the platform for the
// architectures that we should be using (in the correct order) and see if // architectures that we should be using (in the correct order) and see if
Context not available.
// Get module information from a target. // Get module information from a target.
if (!GetModuleSpec(module_spec.GetFileSpec(), module_spec.GetArchitecture(), if (!GetModuleSpec(module_spec.GetFileSpec(), module_spec.GetArchitecture(),
resolved_module_spec)) { resolved_module_spec)) {
if (module_spec.GetUUID().IsValid() == false || if (!module_spec.GetUUID().IsValid() ||
module_spec.GetUUID() == resolved_module_spec.GetUUID()) { module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
return module_resolver(module_spec); return module_resolver(module_spec);
} }
Context not available.

source/Target/QueueItem.cpp

Context not available.
ProcessSP QueueItem::GetProcessSP() { return m_process_wp.lock(); } ProcessSP QueueItem::GetProcessSP() { return m_process_wp.lock(); }
void QueueItem::FetchEntireItem() { void QueueItem::FetchEntireItem() {
if (m_have_fetched_entire_item == true) if (m_have_fetched_entire_item)
return; return;
ProcessSP process_sp = m_process_wp.lock(); ProcessSP process_sp = m_process_wp.lock();
if (process_sp) { if (process_sp) {
Context not available.

source/Target/RegisterNumber.cpp

Context not available.
return false; return false;
if (m_kind == rhs.m_kind) { if (m_kind == rhs.m_kind) {
if (m_regnum == rhs.m_regnum) return m_regnum == rhs.m_regnum;
return true;
else
return false;
} }
uint32_t rhs_regnum = rhs.GetAsKind(m_kind); uint32_t rhs_regnum = rhs.GetAsKind(m_kind);
if (rhs_regnum != LLDB_INVALID_REGNUM) { if (rhs_regnum != LLDB_INVALID_REGNUM) {
if (m_regnum == rhs_regnum) return m_regnum == rhs_regnum;
return true;
else
return false;
} }
uint32_t lhs_regnum = GetAsKind(rhs.m_kind); uint32_t lhs_regnum = GetAsKind(rhs.m_kind);
{ { return lhs_regnum == rhs.m_regnum; }
if (lhs_regnum == rhs.m_regnum)
return true;
else
return false;
}
return false; return false;
} }
Context not available.

source/Target/StackFrame.cpp

Context not available.
m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress( m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(
exe_ctx.GetTargetPtr()); exe_ctx.GetTargetPtr());
if (m_sc.function->GetFrameBaseExpression().Evaluate( if (!m_sc.function->GetFrameBaseExpression().Evaluate(
&exe_ctx, nullptr, loclist_base_addr, nullptr, nullptr, &exe_ctx, nullptr, loclist_base_addr, nullptr, nullptr,
expr_value, &m_frame_base_error) == false) { expr_value, &m_frame_base_error)) {
// We should really have an error if evaluate returns, but in case we // We should really have an error if evaluate returns, but in case we
// don't, lets set the error to something at least. // don't, lets set the error to something at least.
if (m_frame_base_error.Success()) if (m_frame_base_error.Success())
Context not available.

source/Target/StopInfo.cpp

Context not available.
__FUNCTION__, m_value); __FUNCTION__, m_value);
} }
if ((m_should_stop == false || internal_breakpoint) if ((!m_should_stop || internal_breakpoint) &&
&& thread_sp->CompletedPlanOverridesBreakpoint()) { thread_sp->CompletedPlanOverridesBreakpoint()) {
// Override should_stop decision when we have completed step plan // Override should_stop decision when we have completed step plan
// additionally to the breakpoint // additionally to the breakpoint
m_should_stop = true; m_should_stop = true;
Context not available.

source/Target/TargetList.cpp

Context not available.
// All platforms for all modules in the executable match, so we can // All platforms for all modules in the executable match, so we can
// select this platform // select this platform
platform_sp = platforms.front(); platform_sp = platforms.front();
} else if (more_than_one_platforms == false) { } else if (!more_than_one_platforms) {
// No platforms claim to support this file // No platforms claim to support this file
error.SetErrorString("No matching platforms found for this file, " error.SetErrorString("No matching platforms found for this file, "
"specify one with the --platform option"); "specify one with the --platform option");
Context not available.

source/Target/ThreadPlanBase.cpp

Context not available.
bool ThreadPlanBase::DoPlanExplainsStop(Event *event_ptr) { bool ThreadPlanBase::DoPlanExplainsStop(Event *event_ptr) {
// The base plan should defer to its tracer, since by default it always // The base plan should defer to its tracer, since by default it always
// handles the stop. // handles the stop.
if (TracerExplainsStop()) return !TracerExplainsStop();
return false;
else
return true;
} }
Vote ThreadPlanBase::ShouldReportStop(Event *event_ptr) { Vote ThreadPlanBase::ShouldReportStop(Event *event_ptr) {
Context not available.

source/Target/ThreadPlanStepOverRange.cpp

Context not available.
} }
} }
// Fall back to symbol if we have no decision from comp_unit/function/block. // Fall back to symbol if we have no decision from comp_unit/function/block.
if (m_addr_context.symbol && m_addr_context.symbol == context.symbol) { return m_addr_context.symbol && m_addr_context.symbol == context.symbol;
return true;
}
return false;
} }
bool ThreadPlanStepOverRange::ShouldStop(Event *event_ptr) { bool ThreadPlanStepOverRange::ShouldStop(Event *event_ptr) {
Context not available.

source/Utility/ArchSpec.cpp

Context not available.
bool ArchSpec::IsMIPS() const { bool ArchSpec::IsMIPS() const {
const llvm::Triple::ArchType machine = GetMachine(); const llvm::Triple::ArchType machine = GetMachine();
if (machine == llvm::Triple::mips || machine == llvm::Triple::mipsel || return machine == llvm::Triple::mips || machine == llvm::Triple::mipsel ||
machine == llvm::Triple::mips64 || machine == llvm::Triple::mips64el) machine == llvm::Triple::mips64 || machine == llvm::Triple::mips64el;
return true;
return false;
} }
std::string ArchSpec::GetTargetABI() const { std::string ArchSpec::GetTargetABI() const {
Context not available.
const llvm::Triple::EnvironmentType rhs_triple_env = const llvm::Triple::EnvironmentType rhs_triple_env =
rhs_triple.getEnvironment(); rhs_triple.getEnvironment();
if (!IsCompatibleEnvironment(lhs_triple_env, rhs_triple_env)) return IsCompatibleEnvironment(lhs_triple_env, rhs_triple_env);
return false;
return true;
} }
return false; return false;
} }
Context not available.

source/Utility/RegisterValue.cpp

Context not available.
bool RegisterValue::CopyValue(const RegisterValue &rhs) { bool RegisterValue::CopyValue(const RegisterValue &rhs) {
if (this == &rhs) if (this == &rhs)
return rhs.m_type == eTypeInvalid ? false : true; return rhs.m_type != eTypeInvalid;
shafikUnsubmitted
Not Done
ReplyInline Actions

Nice one.

shafik: Nice one.
m_type = rhs.m_type; m_type = rhs.m_type;
switch (m_type) { switch (m_type) {
Context not available.

source/Utility/StructuredData.cpp

Context not available.
} }
void StructuredData::Boolean::Dump(Stream &s, bool pretty_print) const { void StructuredData::Boolean::Dump(Stream &s, bool pretty_print) const {
if (m_value == true) if (m_value)
s.PutCString("true"); s.PutCString("true");
else else
s.PutCString("false"); s.PutCString("false");
Context not available.

tools/debugserver/source/JSONGenerator.h

Context not available.
void SetValue(bool value) { m_value = value; } void SetValue(bool value) { m_value = value; }
void Dump(std::ostream &s) const override { void Dump(std::ostream &s) const override {
if (m_value == true) if (m_value)
s << "true"; s << "true";
else else
s << "false"; s << "false";
Context not available.
s << "{"; s << "{";
for (collection::const_iterator iter = m_dict.begin(); for (collection::const_iterator iter = m_dict.begin();
iter != m_dict.end(); ++iter) { iter != m_dict.end(); ++iter) {
if (have_printed_one_elem == false) { if (!have_printed_one_elem) {
have_printed_one_elem = true; have_printed_one_elem = true;
} else { } else {
s << ","; s << ",";
Context not available.

tools/debugserver/source/MacOSX/Genealogy.cpp

Context not available.
// (else we'll need to hit the timeout for every thread we're asked about.) // (else we'll need to hit the timeout for every thread we're asked about.)
// We'll try again at the next public stop. // We'll try again at the next public stop.
if (m_thread_activities.size() == 0 && if (m_thread_activities.size() == 0 && !m_diagnosticd_call_timed_out) {
m_diagnosticd_call_timed_out == false) {
GetActivities(pid, thread_list, task); GetActivities(pid, thread_list, task);
} }
std::map<nub_thread_t, ThreadActivitySP>::const_iterator search; std::map<nub_thread_t, ThreadActivitySP>::const_iterator search;
Context not available.

tools/debugserver/source/MacOSX/MachProcess.mm

Context not available.
uuid_unparse_upper(image_infos[i].macho_info.uuid, uuidstr); uuid_unparse_upper(image_infos[i].macho_info.uuid, uuidstr);
image_info_dict_sp->AddStringItem("uuid", uuidstr); image_info_dict_sp->AddStringItem("uuid", uuidstr);
if (image_infos[i].macho_info.min_version_os_name.empty() == false && if (!image_infos[i].macho_info.min_version_os_name.empty() &&
image_infos[i].macho_info.min_version_os_version.empty() == false) { !image_infos[i].macho_info.min_version_os_version.empty()) {
image_info_dict_sp->AddStringItem( image_info_dict_sp->AddStringItem(
"min_version_os_name", image_infos[i].macho_info.min_version_os_name); "min_version_os_name", image_infos[i].macho_info.min_version_os_name);
image_info_dict_sp->AddStringItem( image_info_dict_sp->AddStringItem(
Context not available.
void MachProcess::ReplyToAllExceptions() { void MachProcess::ReplyToAllExceptions() {
PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex); PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
if (m_exception_messages.empty() == false) { if (!m_exception_messages.empty()) {
MachException::Message::iterator pos; MachException::Message::iterator pos;
MachException::Message::iterator begin = m_exception_messages.begin(); MachException::Message::iterator begin = m_exception_messages.begin();
MachException::Message::iterator end = m_exception_messages.end(); MachException::Message::iterator end = m_exception_messages.end();
Context not available.
if (bp->IsHardware()) { if (bp->IsHardware()) {
bool hw_disable_result = m_thread_list.DisableHardwareBreakpoint(bp); bool hw_disable_result = m_thread_list.DisableHardwareBreakpoint(bp);
if (hw_disable_result == true) { if (hw_disable_result) {
bp->SetEnabled(false); bp->SetEnabled(false);
// Let the thread list know that a breakpoint has been modified // Let the thread list know that a breakpoint has been modified
if (remove) { if (remove) {
Context not available.
if (wp->IsHardware()) { if (wp->IsHardware()) {
bool hw_disable_result = m_thread_list.DisableHardwareWatchpoint(wp); bool hw_disable_result = m_thread_list.DisableHardwareWatchpoint(wp);
if (hw_disable_result == true) { if (hw_disable_result) {
wp->SetEnabled(false); wp->SetEnabled(false);
if (remove) if (remove)
m_watchpoints.Remove(addr); m_watchpoints.Remove(addr);
Context not available.
m_thread_list.Dump(); m_thread_list.Dump();
bool step_more = false; bool step_more = false;
if (m_thread_list.ShouldStop(step_more) && auto_resume == false) { if (m_thread_list.ShouldStop(step_more) && !auto_resume) {
// Wait for the eEventProcessRunningStateChanged event to be reset // Wait for the eEventProcessRunningStateChanged event to be reset
// before changing state to stopped to avoid race condition with // before changing state to stopped to avoid race condition with
// very fast start/stops // very fast start/stops
Context not available.

tools/debugserver/source/MacOSX/MachThread.cpp

Context not available.
DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )", DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )",
__FUNCTION__); __FUNCTION__);
DNBError err; DNBError err;
if (MachPortNumberIsValid(m_mach_port_number) == false) if (!MachPortNumberIsValid(m_mach_port_number))
return false; return false;
integer_t times_to_resume; integer_t times_to_resume;
Context not available.
DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )", DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )",
__FUNCTION__); __FUNCTION__);
DNBError err; DNBError err;
if (MachPortNumberIsValid(m_mach_port_number) == false) if (!MachPortNumberIsValid(m_mach_port_number))
return false; return false;
if (m_suspend_count > 0) { if (m_suspend_count > 0) {
Context not available.

tools/debugserver/source/MacOSX/MachVMRegion.cpp

Context not available.
// doesn't mean that "addr" is in the range. The data in this object will // doesn't mean that "addr" is in the range. The data in this object will
// be valid though, so you could see where the next region begins. So we // be valid though, so you could see where the next region begins. So we
// return false, yet leave "m_err" with a successfull return code. // return false, yet leave "m_err" with a successfull return code.
if ((addr < m_start) || (addr >= (m_start + m_size))) return !((addr < m_start) || (addr >= (m_start + m_size)));
return false;
return true;
} }
uint32_t MachVMRegion::GetDNBPermissions() const { uint32_t MachVMRegion::GetDNBPermissions() const {
Context not available.

tools/debugserver/source/MacOSX/i386/DNBArchImplI386.cpp

Context not available.
LOG_WATCHPOINTS, LOG_WATCHPOINTS,
"DNBArchImplI386::RollbackTransForHWP() SetDBGState() => 0x%8.8x.", kret); "DNBArchImplI386::RollbackTransForHWP() SetDBGState() => 0x%8.8x.", kret);
if (kret == KERN_SUCCESS) return kret == KERN_SUCCESS;
return true;
else
return false;
} }
bool DNBArchImplI386::FinishTransForHWP() { bool DNBArchImplI386::FinishTransForHWP() {
m_2pc_trans_state = Trans_Done; m_2pc_trans_state = Trans_Done;
Context not available.
return INVALID_NUB_HW_INDEX; return INVALID_NUB_HW_INDEX;
// We must watch for either read or write // We must watch for either read or write
if (read == false && write == false) if (!read && !write)
return INVALID_NUB_HW_INDEX; return INVALID_NUB_HW_INDEX;
// Read the debug state // Read the debug state
Context not available.

tools/debugserver/source/MacOSX/x86_64/DNBArchImplX86_64.cpp

Context not available.
"DNBArchImplX86_64::RollbackTransForHWP() SetDBGState() => 0x%8.8x.", "DNBArchImplX86_64::RollbackTransForHWP() SetDBGState() => 0x%8.8x.",
kret); kret);
if (kret == KERN_SUCCESS) return kret == KERN_SUCCESS;
return true;
else
return false;
} }
bool DNBArchImplX86_64::FinishTransForHWP() { bool DNBArchImplX86_64::FinishTransForHWP() {
m_2pc_trans_state = Trans_Done; m_2pc_trans_state = Trans_Done;
Context not available.
return INVALID_NUB_HW_INDEX; return INVALID_NUB_HW_INDEX;
// We must watch for either read or write // We must watch for either read or write
if (read == false && write == false) if (!read && !write)
return INVALID_NUB_HW_INDEX; return INVALID_NUB_HW_INDEX;
// Read the debug state // Read the debug state
Context not available.

tools/debugserver/source/RNBRemote.cpp

Context not available.
RNBRemoteSP remoteSP(g_remoteSP); RNBRemoteSP remoteSP(g_remoteSP);
if (remoteSP.get() != NULL) { if (remoteSP.get() != NULL) {
RNBRemote *remote = remoteSP.get(); RNBRemote *remote = remoteSP.get();
if (remote->Comm().IsConnected()) return !remote->Comm().IsConnected();
return false;
else
return true;
} }
return true; return true;
} }
Context not available.
attach_failed_due_to_sip = true; attach_failed_due_to_sip = true;
} }
if (attach_failed_due_to_sip == false) { if (!attach_failed_due_to_sip) {
int csops_flags = 0; int csops_flags = 0;
int retval = ::csops(pid_attaching_to, CS_OPS_STATUS, &csops_flags, int retval = ::csops(pid_attaching_to, CS_OPS_STATUS, &csops_flags,
sizeof(csops_flags)); sizeof(csops_flags));
Context not available.
thread_dict_sp->AddStringItem("reason", reason_value); thread_dict_sp->AddStringItem("reason", reason_value);
if (threads_with_valid_stop_info_only == false) { if (!threads_with_valid_stop_info_only) {
const char *thread_name = DNBThreadGetName(pid, tid); const char *thread_name = DNBThreadGetName(pid, tid);
if (thread_name && thread_name[0]) if (thread_name && thread_name[0])
thread_dict_sp->AddStringItem("name", thread_name); thread_dict_sp->AddStringItem("name", thread_name);
Context not available.
bool need_to_print_comma = false; bool need_to_print_comma = false;
if (thread_activity_sp && timed_out == false) { if (thread_activity_sp && !timed_out) {
const Genealogy::Activity *activity = const Genealogy::Activity *activity =
&thread_activity_sp->current_activity; &thread_activity_sp->current_activity;
bool need_vouchers_comma_sep = false; bool need_vouchers_comma_sep = false;
Context not available.

tools/debugserver/source/RNBServices.cpp

Context not available.
const pid_t pid = proc_info.kp_proc.p_pid; const pid_t pid = proc_info.kp_proc.p_pid;
// Skip zombie processes and processes with unset status // Skip zombie processes and processes with unset status
if (kinfo_user_matches == false || // User is acceptable if (!kinfo_user_matches || // User is acceptable
pid == our_pid || // Skip this process pid == our_pid || // Skip this process
pid == 0 || // Skip kernel (kernel pid is zero) pid == 0 || // Skip kernel (kernel pid is zero)
proc_info.kp_proc.p_stat == proc_info.kp_proc.p_stat ==
SZOMB || // Zombies are bad, they like brains... SZOMB || // Zombies are bad, they like brains...
proc_info.kp_proc.p_flag & P_TRACED || // Being debugged? proc_info.kp_proc.p_flag & P_TRACED || // Being debugged?
Context not available.

tools/debugserver/source/libdebugserver.cpp

Context not available.
case eStateSuspended: case eStateSuspended:
case eStateCrashed: case eStateCrashed:
case eStateStopped: case eStateStopped:
if (initialize == false) { if (!initialize) {
// Compare the last stop count to our current notion of a stop count // Compare the last stop count to our current notion of a stop count
// to make sure we don't notify more than once for a given stop. // to make sure we don't notify more than once for a given stop.
nub_size_t prev_pid_stop_count = ctx.GetProcessStopCount(); nub_size_t prev_pid_stop_count = ctx.GetProcessStopCount();
Context not available.

tools/lldb-mi/MICmdArgValFile.cpp

Context not available.
return false; return false;
const bool bValidChars = IsValidChars(vrFileNamePath); const bool bValidChars = IsValidChars(vrFileNamePath);
if (bValidChars || bHavePosSlash || bHaveBckSlash) return bValidChars || bHavePosSlash || bHaveBckSlash;
return true;
return false;
} }
//++ //++
Context not available.

tools/lldb-mi/MICmdArgValOptionLong.cpp

Context not available.
return false; return false;
const CMIUtilString strArg = vrTxt.substr(2); const CMIUtilString strArg = vrTxt.substr(2);
if (strArg.IsNumber()) return !strArg.IsNumber();
return false;
return true;
} }
//++ //++
Context not available.

tools/lldb-mi/MICmdArgValString.cpp

Context not available.
// Throws: None. // Throws: None.
//-- //--
CMICmdArgValString::CMICmdArgValString(const bool vbAnything) CMICmdArgValString::CMICmdArgValString(const bool vbAnything)
: m_bHandleQuotedString(vbAnything ? true : false), m_bAcceptNumbers(false), : m_bHandleQuotedString(vbAnything), m_bAcceptNumbers(false),
m_bHandleDirPaths(false), m_bHandleAnything(vbAnything) {} m_bHandleDirPaths(false), m_bHandleAnything(vbAnything) {}
//++ //++
Context not available.
return false; return false;
const size_t nLen = vrTxt.length(); const size_t nLen = vrTxt.length();
if ((nLen > 5) && ((nPos + 2) == (nPos2 - 2))) return !((nLen > 5) && ((nPos + 2) == (nPos2 - 2)));
return false;
return true;
} }
Context not available.

tools/lldb-mi/MICmdArgValThreadGrp.cpp

Context not available.
return false; return false;
const CMIUtilString strNum = vrTxt.substr(1); const CMIUtilString strNum = vrTxt.substr(1);
if (!strNum.IsNumber()) return strNum.IsNumber();
return false;
return true;
} }
//++ //++
Context not available.

tools/lldb-mi/MICmdFactory.cpp

Context not available.
bool CMICmdFactory::HaveAlready(const CMIUtilString &vMiCmd) const { bool CMICmdFactory::HaveAlready(const CMIUtilString &vMiCmd) const {
const MapMiCmdToCmdCreatorFn_t::const_iterator it = const MapMiCmdToCmdCreatorFn_t::const_iterator it =
m_mapMiCmdToCmdCreatorFn.find(vMiCmd); m_mapMiCmdToCmdCreatorFn.find(vMiCmd);
if (it != m_mapMiCmdToCmdCreatorFn.end()) return it != m_mapMiCmdToCmdCreatorFn.end();
return true;
return false;
} }
//++ //++
Context not available.

tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

Context not available.
const bool vbInSimpleForm, const bool vbInSimpleForm,
CMIUtilString &vwrStrValue) { CMIUtilString &vwrStrValue) {
const CMICmnLLDBUtilSBValue utilValue(vrValue, true, false); const CMICmnLLDBUtilSBValue utilValue(vrValue, true, false);
const bool bExpandAggregates = vbInSimpleForm ? false : true; const bool bExpandAggregates = !vbInSimpleForm;
vwrStrValue = utilValue.GetValue(bExpandAggregates); vwrStrValue = utilValue.GetValue(bExpandAggregates);
return MIstatus::success; return MIstatus::success;
} }
Context not available.

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

Context not available.
sBrkPtInfo.m_nIgnore = brkPt.GetIgnoreCount(); sBrkPtInfo.m_nIgnore = brkPt.GetIgnoreCount();
sBrkPtInfo.m_bPending = false; sBrkPtInfo.m_bPending = false;
const char *pStrCondition = brkPt.GetCondition(); const char *pStrCondition = brkPt.GetCondition();
sBrkPtInfo.m_bCondition = (pStrCondition != nullptr) ? true : false; sBrkPtInfo.m_bCondition = pStrCondition != nullptr;
sBrkPtInfo.m_strCondition = sBrkPtInfo.m_strCondition =
(pStrCondition != nullptr) ? pStrCondition : "??"; (pStrCondition != nullptr) ? pStrCondition : "??";
sBrkPtInfo.m_bBrkPtThreadId = (brkPt.GetThreadID() != 0) ? true : false; sBrkPtInfo.m_bBrkPtThreadId = brkPt.GetThreadID() != 0;
sBrkPtInfo.m_nBrkPtThreadId = brkPt.GetThreadID(); sBrkPtInfo.m_nBrkPtThreadId = brkPt.GetThreadID();
} }
Context not available.

tools/lldb-mi/MICmnLog.cpp

Context not available.
bool CMICmnLog::HaveMediumAlready(const IMedium &vrMedium) const { bool CMICmnLog::HaveMediumAlready(const IMedium &vrMedium) const {
IMedium *pMedium = const_cast<IMedium *>(&vrMedium); IMedium *pMedium = const_cast<IMedium *>(&vrMedium);
const MapMediumToName_t::const_iterator it = m_mapMediumToName.find(pMedium); const MapMediumToName_t::const_iterator it = m_mapMediumToName.find(pMedium);
if (it != m_mapMediumToName.end()) return it != m_mapMediumToName.end();
return true;
return false;
} }
//++ //++
Context not available.

tools/lldb-mi/MIUtilMapIdToVariant.cpp

Context not available.
bool CMIUtilMapIdToVariant::HaveAlready(const CMIUtilString &vId) const { bool CMIUtilMapIdToVariant::HaveAlready(const CMIUtilString &vId) const {
const MapKeyToVariantValue_t::const_iterator it = const MapKeyToVariantValue_t::const_iterator it =
m_mapKeyToVariantValue.find(vId); m_mapKeyToVariantValue.find(vId);
if (it != m_mapKeyToVariantValue.end()) return it != m_mapKeyToVariantValue.end();
return true;
return false;
} }
//++ //++
Context not available.

tools/lldb-mi/MIUtilString.cpp

Context not available.
return false; return false;
const size_t nPos = find_first_not_of("-.0123456789"); const size_t nPos = find_first_not_of("-.0123456789");
if (nPos != std::string::npos) return nPos == std::string::npos;
return false;
return true;
} }
//++ //++
Context not available.
// Skip '0x..' prefix // Skip '0x..' prefix
const size_t nPos = find_first_not_of("01234567890ABCDEFabcedf", 2); const size_t nPos = find_first_not_of("01234567890ABCDEFabcedf", 2);
if (nPos != std::string::npos) return nPos == std::string::npos;
return false;
return true;
} }
//++ //++
Context not available.
vwrNumber = 0; vwrNumber = 0;
if (!IsNumber()) { if (!IsNumber()) {
if (ExtractNumberFromHexadecimal(vwrNumber)) return ExtractNumberFromHexadecimal(vwrNumber);
return true;
return false;
} }
std::stringstream ss(const_cast<CMIUtilString &>(*this)); std::stringstream ss(const_cast<CMIUtilString &>(*this));
Context not available.
return false; return false;
const size_t nLen = length(); const size_t nLen = length();
if ((nLen > 0) && (at(nLen - 1) != cQuote)) return !((nLen > 0) && (at(nLen - 1) != cQuote));
return false;
return true;
} }
//++ //++
Context not available.

tools/lldb-vscode/JSONUtils.cpp

Context not available.
} }
bool ObjectContainsKey(const llvm::json::Object &obj, llvm::StringRef key) { bool ObjectContainsKey(const llvm::json::Object &obj, llvm::StringRef key) {
if (obj.find(key) != obj.end()) return obj.find(key) != obj.end();
return true;
return false;
} }
std::vector<std::string> GetStrings(const llvm::json::Object *obj, std::vector<std::string> GetStrings(const llvm::json::Object *obj,
Context not available.