This is an archive of the discontinued LLVM Phabricator instance.

Differential D55574

Remove else statements after returns
AbandonedPublic

Authored by JDevlieghere on Dec 11 2018, 1:08 PM.

Details

Reviewers
• espindola
jfb
shafik
aprantl
Group Reviewers
Restricted Project
Summary

While writing a patch I noticed myself removing a few else statements after return statements. Rather than doing this ad-hoc I remembered there's a clang-tidy pass that does this.

https://clang.llvm.org/extra/clang-tidy/checks/readability-else-after-return.html

So essentially what I did was run the following command over the LLDB code base:

run-clang-tidy.py -checks='-*,readability-else-after-return' -format -fix $PWD

I'm not sure if it's worth the churn, but I do believe lldb could benefit from some reduced indentation.

PS: Diff is without context, otherwise it exceeds the Phabricator limit of 8 megabytes.

Diff Detail

Event Timeline

JDevlieghere created this revision.Dec 11 2018, 1:08 PM
Herald added a reviewer: • espindola. · View Herald TranscriptDec 11 2018, 1:08 PM
Herald added a reviewer: jfb. · View Herald Transcript
Herald added a reviewer: shafik. · View Herald Transcript
Herald added subscribers: jsji, teemperor, abidh and 11 others. · View Herald Transcript
JDevlieghere mentioned this in D55584: [LLDB] Simplify Boolean expressions.Dec 11 2018, 2:41 PM
JDevlieghere added a reviewer: aprantl.
aprantl added a comment.Dec 11 2018, 2:52 PM

I'm mostly on board with making these changes, as it's good LLVM style to do this. I highlighted a couple changes that might warrant a closer look.

source/API/SBProcess.cpp
1233

This function probably could use some manual refactoring, too.

source/Commands/CommandObjectTarget.cpp
2569

Can you manually double-check this one?

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp
3818

what's going on here with the indentation?

source/Target/Process.cpp
1930

this also looks suspicious

5235

wouldn't hurt to manually check this one, too

source/Target/ThreadPlanStepRange.cpp
329

weird indentation again

source/Target/ThreadPlanStepUntil.cpp
246

again

vsk added a subscriber: vsk.Dec 11 2018, 2:54 PM

+ 1 to this. If there's a tidy plugin for misleading indention, that might address some of Adrian's concerns.

aprantl added inline comments.Dec 11 2018, 3:19 PM
source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp
994

This is inconsistent (do you need to re-run it until it reaches a fixpoint?

zturner added a subscriber: zturner.Dec 11 2018, 3:20 PM
zturner added inline comments.
source/Commands/CommandObjectTarget.cpp
2569

For large complex cases like this, it might make sense to convert them to early returns first. That makes the size of the if blocks smaller so less chance of messing up.

2601–2607

Something is wrong with indentation here.

jingham added a subscriber: jingham.Dec 11 2018, 6:43 PM

When one or the other side of the if/else test is trivial, then this rewrite is fine. When both the if and the else have a decent bit of code in them, however, removing the "} else {" and the concluding "}" obscures the fact that these are two coequal branches in the code. Before, regardless of whether I'm reading from the bottom of the function up or the top down, the structure is obvious. But when the else removed, particularly when reading from the bottom up, I can't tell this till I get to the } which happens to have a return just before it to know that. So that sort of change doesn't improve readability to my mind.

JDevlieghere abandoned this revision.Dec 11 2018, 6:50 PM

I'm going to abandon this for now until we have better tooling to address Jim's concerns here. I'm also not super happy with the formatting, which seems to be off in quite a few locations. The problem is that clang-tidy knows to reformat the source range it touched, but in this case the code below is affected. I hacked this up by having clang-format looking one line below the lines that were changed, but looks like that was not sufficient. Also a few case are covered by D55584 so definitely want to land that first.

Revision Contents

PathSize
include/
lldb/
Breakpoint/
4 lines
Core/
20 lines
8 lines
3 lines
34 lines
4 lines
3 lines
2 lines
DataFormatters/
11 lines
21 lines
4 lines
Host/
4 lines
Interpreter/
2 lines
Symbol/
10 lines
16 lines
4 lines
9 lines
16 lines
Target/
10 lines
4 lines
4 lines
4 lines
8 lines
4 lines
12 lines
source/
API/
4 lines
18 lines
20 lines
6 lines
3 lines
24 lines
4 lines
4 lines
8 lines
43 lines
17 lines
35 lines
31 lines
24 lines
11 lines
11 lines
18 lines
4 lines
63 lines
8 lines
Breakpoint/
28 lines
4 lines
30 lines
4 lines
10 lines
7 lines
15 lines
4 lines
3 lines
8 lines
4 lines
Commands/
6 lines
6 lines
3 lines
6 lines
8 lines
44 lines
43 lines
26 lines
13 lines
55 lines
6 lines
17 lines
537 lines
73 lines
40 lines
4 lines
Core/
17 lines
3 lines
35 lines
6 lines
3 lines
3 lines
8 lines
12 lines
480 lines
194 lines
40 lines
9 lines
8 lines
4 lines
69 lines
22 lines
27 lines
12 lines
4 lines
424 lines
4 lines
16 lines
12 lines
41 lines
23 lines
DataFormatters/
4 lines
4 lines
71 lines
4 lines
18 lines
14 lines
Expression/
72 lines
4 lines
4 lines
4 lines
20 lines
27 lines
16 lines
7 lines
8 lines
Host/
common/
12 lines
2 lines
4 lines
8 lines
66 lines
4 lines
35 lines
macosx/
19 lines
objcxx/
10 lines
posix/
42 lines
Interpreter/
145 lines
33 lines
4 lines
24 lines
4 lines
8 lines
4 lines
23 lines
18 lines
Plugins/
ABI/
MacOSX-arm/
15 lines
MacOSX-arm64/
15 lines
SysV-arm/
24 lines
SysV-arm64/
15 lines
SysV-ppc/
3 lines
SysV-ppc64/
12 lines
SysV-x86_64/
3 lines
Architecture/
Mips/
2 lines
Disassembler/
llvm/
45 lines
DynamicLoader/
Hexagon-DYLD/
14 lines
9 lines
MacOSX-DYLD/
4 lines
20 lines
POSIX-DYLD/
4 lines
2 lines
4 lines
ExpressionParser/
Clang/
12 lines
2 lines
77 lines
9 lines
8 lines
4 lines
4 lines
9 lines
18 lines
Instruction/
ARM/
102 lines
7 lines
ARM64/
2 lines
MIPS/
18 lines
MIPS64/
3 lines
PPC64/
2 lines
InstrumentationRuntime/
ASan/
4 lines
TSan/
7 lines
JITLoader/
GDB/
4 lines
Language/
CPlusPlus/
15 lines
3 lines
74 lines
33 lines
5 lines
8 lines
ClangCommon/
3 lines
ObjC/
17 lines
13 lines
7 lines
6 lines
12 lines
34 lines
2 lines
LanguageRuntime/
CPlusPlus/
ItaniumABI/
15 lines
ObjC/
AppleObjCRuntime/
21 lines
15 lines
4 lines
55 lines
3 lines
41 lines
18 lines
RenderScript/
RenderScriptRuntime/
59 lines
ObjectContainer/
BSD-Archive/
26 lines
ObjectFile/
ELF/
45 lines
Mach-O/
73 lines
PECOFF/
6 lines
Platform/
Android/
3 lines
9 lines
FreeBSD/
12 lines
Linux/
17 lines
MacOSX/
11 lines
4 lines
4 lines
21 lines
33 lines
32 lines
4 lines
7 lines
objcxx/
30 lines
NetBSD/
17 lines
OpenBSD/
9 lines
POSIX/
66 lines
Windows/
30 lines
gdb-server/
16 lines
Process/
MacOSX-Kernel/
16 lines
18 lines
Utility/
33 lines
4 lines
2 lines
2 lines
6 lines
6 lines
75 lines
4 lines
4 lines
4 lines
8 lines
8 lines
4 lines
4 lines
8 lines
15 lines
elf-core/
5 lines
13 lines
2 lines
gdb-remote/
29 lines
237 lines
8 lines
4 lines
59 lines
4 lines
41 lines
29 lines
4 lines
mach-core/
9 lines
minidump/
9 lines
ScriptInterpreter/
Python/
27 lines
StructuredData/
DarwinLog/
11 lines
SymbolFile/
DWARF/
4 lines
64 lines
5 lines
60 lines
68 lines
7 lines
4 lines
225 lines
4 lines
4 lines
3 lines
2 lines
5 lines
12 lines
3 lines
20 lines
64 lines
4 lines
4 lines
Symbol/
25 lines
4 lines
349 lines
19 lines
7 lines
11 lines
20 lines
222 lines
5 lines
4 lines
6 lines
34 lines
12 lines
31 lines
7 lines
3 lines
27 lines
15 lines
Target/
15 lines
2 lines
4 lines
4 lines
8 lines
8 lines
87 lines
357 lines
8 lines
3 lines
12 lines
23 lines
21 lines
31 lines
7 lines
26 lines
36 lines
106 lines
4 lines
7 lines
8 lines
49 lines
3 lines
10 lines
4 lines
11 lines
42 lines
17 lines
17 lines
15 lines
87 lines
23 lines
110 lines
14 lines
30 lines
Utility/
7 lines
25 lines
59 lines
6 lines
16 lines
8 lines
8 lines
5 lines
4 lines
6 lines
6 lines
2 lines
tools/
debugserver/
source/
89 lines
6 lines
64 lines
MacOSX/
DarwinLog/
5 lines
3 lines
100 lines
31 lines
23 lines
18 lines
4 lines
31 lines
i386/
33 lines
x86_64/
59 lines
8 lines
149 lines
6 lines
22 lines
10 lines
lldb-mi/
8 lines
4 lines
8 lines
9 lines
4 lines
8 lines
3 lines
3 lines
4 lines
12 lines
14 lines
5 lines
lldb-server/
10 lines
unittests/
Host/
4 lines

Diff 177765

include/lldb/Breakpoint/BreakpointResolver.h

Context not available.
enum ResolverTy GetResolverTy() { enum ResolverTy GetResolverTy() {
if (SubclassID > ResolverTy::LastKnownResolverType) if (SubclassID > ResolverTy::LastKnownResolverType)
return ResolverTy::UnknownResolver; return ResolverTy::UnknownResolver;
else
return (enum ResolverTy)SubclassID; return (enum ResolverTy)SubclassID;
} }
const char *GetResolverName() { return ResolverTyToName(GetResolverTy()); } const char *GetResolverName() { return ResolverTyToName(GetResolverTy()); }
Context not available.

include/lldb/Core/Broadcaster.h

Context not available.
uint32_t in_bits = in_spec.GetEventBits(); uint32_t in_bits = in_spec.GetEventBits();
if (in_bits == m_event_bits) if (in_bits == m_event_bits)
return true; return true;
else {
if ((m_event_bits & in_bits) != 0 && (m_event_bits & ~in_bits) == 0) if ((m_event_bits & in_bits) != 0 && (m_event_bits & ~in_bits) == 0)
return true; return true;
}
return false; return false;
} }
Context not available.
bool operator()(const event_listener_key input) const { bool operator()(const event_listener_key input) const {
if (input.second == m_listener_sp) if (input.second == m_listener_sp)
return true; return true;
else
return false; return false;
} }
private: private:
Context not available.
bool operator()(const event_listener_key input) const { bool operator()(const event_listener_key input) const {
if (input.second.get() == m_listener) if (input.second.get() == m_listener)
return true; return true;
else
return false; return false;
} }
bool operator()(const lldb::ListenerSP input) const { bool operator()(const lldb::ListenerSP input) const {
if (input.get() == m_listener) if (input.get() == m_listener)
return true; return true;
else
return false; return false;
} }
private: private:
Context not available.

include/lldb/Core/Event.h

Context not available.
m_broadcaster_wp.lock(); m_broadcaster_wp.lock();
if (broadcaster_impl_sp) if (broadcaster_impl_sp)
return broadcaster_impl_sp->GetBroadcaster(); return broadcaster_impl_sp->GetBroadcaster();
else
return nullptr; return nullptr;
} }
bool BroadcasterIs(Broadcaster *broadcaster) { bool BroadcasterIs(Broadcaster *broadcaster) {
Context not available.
m_broadcaster_wp.lock(); m_broadcaster_wp.lock();
if (broadcaster_impl_sp) if (broadcaster_impl_sp)
return broadcaster_impl_sp->GetBroadcaster() == broadcaster; return broadcaster_impl_sp->GetBroadcaster() == broadcaster;
else
return false; return false;
} }
void Clear() { m_data_sp.reset(); } void Clear() { m_data_sp.reset(); }
Context not available.

include/lldb/Core/FileSpecList.h

Context not available.
if (idx < m_files.size()) { if (idx < m_files.size()) {
m_files.insert(m_files.begin() + idx, file); m_files.insert(m_files.begin() + idx, file);
return true; return true;
} else if (idx == m_files.size()) { }
if (idx == m_files.size()) {
m_files.push_back(file); m_files.push_back(file);
return true; return true;
} }
Context not available.

include/lldb/Core/RangeMap.h

Context not available.
if (pos != end && pos->Contains(addr)) { if (pos != end && pos->Contains(addr)) {
return std::distance(begin, pos); return std::distance(begin, pos);
} else if (pos != begin) { }
if (pos != begin) {
--pos; --pos;
if (pos->Contains(addr)) if (pos->Contains(addr))
return std::distance(begin, pos); return std::distance(begin, pos);
Context not available.
if (pos != end && pos->Contains(addr)) { if (pos != end && pos->Contains(addr)) {
return &(*pos); return &(*pos);
} else if (pos != begin) { }
if (pos != begin) {
--pos; --pos;
if (pos->Contains(addr)) { if (pos->Contains(addr)) {
return &(*pos); return &(*pos);
Context not available.
if (pos != end && pos->Contains(range)) { if (pos != end && pos->Contains(range)) {
return &(*pos); return &(*pos);
} else if (pos != begin) { }
if (pos != begin) {
--pos; --pos;
if (pos->Contains(range)) { if (pos->Contains(range)) {
return &(*pos); return &(*pos);
Context not available.
if (pos != end && pos->Contains(addr)) { if (pos != end && pos->Contains(addr)) {
return std::distance(begin, pos); return std::distance(begin, pos);
} else if (pos != begin) { }
if (pos != begin) {
--pos; --pos;
if (pos->Contains(addr)) if (pos->Contains(addr))
return std::distance(begin, pos); return std::distance(begin, pos);
Context not available.
if (pos != end && pos->Contains(addr)) { if (pos != end && pos->Contains(addr)) {
return &(*pos); return &(*pos);
} else if (pos != begin) { }
if (pos != begin) {
--pos; --pos;
if (pos->Contains(addr)) { if (pos->Contains(addr)) {
return &(*pos); return &(*pos);
Context not available.
if (pos != end && pos->Contains(range)) { if (pos != end && pos->Contains(range)) {
return &(*pos); return &(*pos);
} else if (pos != begin) { }
if (pos != begin) {
--pos; --pos;
if (pos->Contains(range)) { if (pos->Contains(range)) {
return &(*pos); return &(*pos);
Context not available.
if (this->base == rhs.base) { if (this->base == rhs.base) {
if (this->size == rhs.size) if (this->size == rhs.size)
return this->data < rhs.data; return this->data < rhs.data;
else
return this->size < rhs.size; return this->size < rhs.size;
} }
return this->base < rhs.base; return this->base < rhs.base;
} }
Context not available.
if (pos != end && pos->Contains(addr)) { if (pos != end && pos->Contains(addr)) {
return std::distance(begin, pos); return std::distance(begin, pos);
} else if (pos != begin) { }
if (pos != begin) {
--pos; --pos;
if (pos->Contains(addr)) if (pos->Contains(addr))
return std::distance(begin, pos); return std::distance(begin, pos);
Context not available.
if (pos != end && pos->Contains(addr)) { if (pos != end && pos->Contains(addr)) {
return &(*pos); return &(*pos);
} else if (pos != begin) { }
if (pos != begin) {
--pos; --pos;
if (pos->Contains(addr)) { if (pos->Contains(addr)) {
return &(*pos); return &(*pos);
Context not available.
if (pos != end && pos->Contains(addr)) { if (pos != end && pos->Contains(addr)) {
return &(*pos); return &(*pos);
} else if (pos != begin) { }
if (pos != begin) {
--pos; --pos;
if (pos->Contains(addr)) { if (pos->Contains(addr)) {
return &(*pos); return &(*pos);
Context not available.
if (pos != end && pos->Contains(range)) { if (pos != end && pos->Contains(range)) {
return &(*pos); return &(*pos);
} else if (pos != begin) { }
if (pos != begin) {
--pos; --pos;
if (pos->Contains(range)) { if (pos->Contains(range)) {
return &(*pos); return &(*pos);
Context not available.

include/lldb/Core/SearchFilter.h

Context not available.
enum FilterTy GetFilterTy() { enum FilterTy GetFilterTy() {
if (SubclassID > FilterTy::LastKnownFilterType) if (SubclassID > FilterTy::LastKnownFilterType)
return FilterTy::UnknownFilter; return FilterTy::UnknownFilter;
else
return (enum FilterTy)SubclassID; return (enum FilterTy)SubclassID;
} }
const char *GetFilterName() { return FilterTyToName(GetFilterTy()); } const char *GetFilterName() { return FilterTyToName(GetFilterTy()); }
Context not available.

include/lldb/Core/StructuredDataImpl.h

Context not available.
if (m_data_sp->GetType() == lldb::eStructuredDataTypeDictionary) { if (m_data_sp->GetType() == lldb::eStructuredDataTypeDictionary) {
auto dict = m_data_sp->GetAsDictionary(); auto dict = m_data_sp->GetAsDictionary();
return (dict->GetSize()); return (dict->GetSize());
} else if (m_data_sp->GetType() == lldb::eStructuredDataTypeArray) { }
if (m_data_sp->GetType() == lldb::eStructuredDataTypeArray) {
auto array = m_data_sp->GetAsArray(); auto array = m_data_sp->GetAsArray();
return (array->GetSize()); return (array->GetSize());
} else } else
Context not available.

include/lldb/Core/ValueObject.h

Context not available.
const bool accept_invalid_exe_ctx = false; const bool accept_invalid_exe_ctx = false;
if (!m_mod_id.IsValid()) if (!m_mod_id.IsValid())
return false; return false;
else if (SyncWithProcessState(accept_invalid_exe_ctx)) { if (SyncWithProcessState(accept_invalid_exe_ctx)) {
if (!m_mod_id.IsValid()) if (!m_mod_id.IsValid())
return false; return false;
} }
Context not available.

include/lldb/DataFormatters/FormattersContainer.h

Context not available.
if (key) if (key)
return lldb::TypeNameSpecifierImplSP( return lldb::TypeNameSpecifierImplSP(
new TypeNameSpecifierImpl(key.AsCString(), false)); new TypeNameSpecifierImpl(key.AsCString(), false));
else
return lldb::TypeNameSpecifierImplSP(); return lldb::TypeNameSpecifierImplSP();
} }
lldb::TypeNameSpecifierImplSP lldb::TypeNameSpecifierImplSP
Context not available.
if (candidate.IsMatch(entry) == false) { if (candidate.IsMatch(entry) == false) {
entry.reset(); entry.reset();
continue; continue;
} else {
if (reason)
*reason = candidate.GetReason();
return true;
} }
if (reason)
*reason = candidate.GetReason();
return true;
} }
} }
return false; return false;
Context not available.

include/lldb/DataFormatters/FormattersHelpers.h

Context not available.
bool IsNegative() const { bool IsNegative() const {
if (ptr_size == 4) if (ptr_size == 4)
return ((int32_t)thirty_two) < 0; return ((int32_t)thirty_two) < 0;
else
return ((int64_t)sixty_four) < 0; return ((int64_t)sixty_four) < 0;
} }
bool IsZero() const { bool IsZero() const {
if (ptr_size == 4) if (ptr_size == 4)
return thirty_two == 0; return thirty_two == 0;
else
return sixty_four == 0; return sixty_four == 0;
} }
static InferiorSizedWord GetMaximum(Process &process) { static InferiorSizedWord GetMaximum(Process &process) {
if (process.GetAddressByteSize() == 4) if (process.GetAddressByteSize() == 4)
return InferiorSizedWord(UINT32_MAX, 4); return InferiorSizedWord(UINT32_MAX, 4);
else
return InferiorSizedWord(UINT64_MAX, 8); return InferiorSizedWord(UINT64_MAX, 8);
} }
InferiorSizedWord operator>>(int rhs) const { InferiorSizedWord operator>>(int rhs) const {
Context not available.
if (ptr_size == 4) { if (ptr_size == 4) {
memcpy(buffer, &thirty_two, 4); memcpy(buffer, &thirty_two, 4);
return buffer + 4; return buffer + 4;
} else {
memcpy(buffer, &sixty_four, 8);
return buffer + 8;
} }
memcpy(buffer, &sixty_four, 8);
return buffer + 8;
} }
DataExtractor DataExtractor
GetAsData(lldb::ByteOrder byte_order = lldb::eByteOrderInvalid) const { GetAsData(lldb::ByteOrder byte_order = lldb::eByteOrderInvalid) const {
if (ptr_size == 4) if (ptr_size == 4)
return DataExtractor(&thirty_two, 4, byte_order, 4); return DataExtractor(&thirty_two, 4, byte_order, 4);
else
return DataExtractor(&sixty_four, 8, byte_order, 8); return DataExtractor(&sixty_four, 8, byte_order, 8);
} }
private: private:
Context not available.

include/lldb/DataFormatters/TypeCategory.h

Context not available.
uint32_t GetEnabledPosition() { uint32_t GetEnabledPosition() {
if (m_enabled == false) if (m_enabled == false)
return UINT32_MAX; return UINT32_MAX;
else
return m_enabled_position; return m_enabled_position;
} }
bool Get(ValueObject &valobj, const FormattersMatchVector &candidates, bool Get(ValueObject &valobj, const FormattersMatchVector &candidates,
Context not available.

include/lldb/Host/ProcessRunLock.h

Context not available.
if (m_lock) { if (m_lock) {
if (m_lock == lock) if (m_lock == lock)
return true; // We already have this lock locked return true; // We already have this lock locked
else
Unlock(); Unlock();
} }
if (lock) { if (lock) {
if (lock->ReadTryLock()) { if (lock->ReadTryLock()) {
Context not available.

include/lldb/Interpreter/CommandObject.h

Context not available.
if (m_command_override_callback) if (m_command_override_callback)
return m_command_override_callback(m_command_override_baton, argv, return m_command_override_callback(m_command_override_baton, argv,
result); result);
else if (m_deprecated_command_override_callback) if (m_deprecated_command_override_callback)
return m_deprecated_command_override_callback(m_command_override_baton, return m_deprecated_command_override_callback(m_command_override_baton,
argv); argv);
else else
Context not available.

include/lldb/Symbol/ClangASTImporter.h

Context not available.
ASTContextMetadataSP(new ASTContextMetadata(dst_ctx)); ASTContextMetadataSP(new ASTContextMetadata(dst_ctx));
m_metadata_map[dst_ctx] = context_md; m_metadata_map[dst_ctx] = context_md;
return context_md; return context_md;
} else {
return context_md_iter->second;
} }
return context_md_iter->second;
} }
ASTContextMetadataSP MaybeGetContextMetadata(clang::ASTContext *dst_ctx) { ASTContextMetadataSP MaybeGetContextMetadata(clang::ASTContext *dst_ctx) {
Context not available.
if (context_md_iter != m_metadata_map.end()) if (context_md_iter != m_metadata_map.end())
return context_md_iter->second; return context_md_iter->second;
else
return ASTContextMetadataSP(); return ASTContextMetadataSP();
} }
MinionSP GetMinion(clang::ASTContext *dst_ctx, clang::ASTContext *src_ctx) { MinionSP GetMinion(clang::ASTContext *dst_ctx, clang::ASTContext *src_ctx) {
Context not available.
MinionSP minion = MinionSP(new Minion(*this, dst_ctx, src_ctx)); MinionSP minion = MinionSP(new Minion(*this, dst_ctx, src_ctx));
minions[src_ctx] = minion; minions[src_ctx] = minion;
return minion; return minion;
} else {
return minion_iter->second;
} }
return minion_iter->second;
} }
DeclOrigin GetDeclOrigin(const clang::Decl *decl); DeclOrigin GetDeclOrigin(const clang::Decl *decl);
Context not available.

include/lldb/Symbol/ClangExternalASTSourceCommon.h

Context not available.
lldb::user_id_t GetUserID() const { lldb::user_id_t GetUserID() const {
if (m_union_is_user_id) if (m_union_is_user_id)
return m_user_id; return m_user_id;
else
return LLDB_INVALID_UID; return LLDB_INVALID_UID;
} }
void SetISAPtr(uint64_t isa_ptr) { void SetISAPtr(uint64_t isa_ptr) {
Context not available.
uint64_t GetISAPtr() const { uint64_t GetISAPtr() const {
if (m_union_is_isa_ptr) if (m_union_is_isa_ptr)
return m_isa_ptr; return m_isa_ptr;
else
return 0; return 0;
} }
void SetObjectPtrName(const char *name) { void SetObjectPtrName(const char *name) {
Context not available.
if (m_has_object_ptr) { if (m_has_object_ptr) {
if (m_is_self) if (m_is_self)
return lldb::eLanguageTypeObjC; return lldb::eLanguageTypeObjC;
else
return lldb::eLanguageTypeC_plus_plus; return lldb::eLanguageTypeC_plus_plus;
} }
return lldb::eLanguageTypeUnknown; return lldb::eLanguageTypeUnknown;
} }
Context not available.
if (m_has_object_ptr) { if (m_has_object_ptr) {
if (m_is_self) if (m_is_self)
return "self"; return "self";
else
return "this"; return "this";
} else } else
return nullptr; return nullptr;
} }
Context not available.

include/lldb/Symbol/DebugMacros.h

Context not available.
DebugMacroEntry GetMacroEntryAtIndex(const size_t index) const { DebugMacroEntry GetMacroEntryAtIndex(const size_t index) const {
if (index < m_macro_entries.size()) if (index < m_macro_entries.size())
return m_macro_entries[index]; return m_macro_entries[index];
else
return DebugMacroEntry(); return DebugMacroEntry();
} }
private: private:
Context not available.

include/lldb/Symbol/Symbol.h

Context not available.
// symbol's value isn't an address. // symbol's value isn't an address.
if (ValueIsAddress()) if (ValueIsAddress())
return m_addr_range.GetBaseAddress(); return m_addr_range.GetBaseAddress();
else
return Address(); return Address();
} }
// When a symbol's value isn't an address, we need to access the raw value. // When a symbol's value isn't an address, we need to access the raw value.
Context not available.
// This symbol's value is an address. Use Symbol::GetAddress() to get the // This symbol's value is an address. Use Symbol::GetAddress() to get the
// address. // address.
return fail_value; return fail_value;
} else {
// The value is stored in the base address' offset
return m_addr_range.GetBaseAddress().GetOffset();
} }
// The value is stored in the base address' offset
return m_addr_range.GetBaseAddress().GetOffset();
} }
lldb::addr_t ResolveCallableAddress(Target &target) const; lldb::addr_t ResolveCallableAddress(Target &target) const;
Context not available.

include/lldb/Symbol/Type.h

Context not available.
CompilerType GetReferenceType() const { CompilerType GetReferenceType() const {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType().GetLValueReferenceType(); return type_sp->GetForwardCompilerType().GetLValueReferenceType();
else
return compiler_type.GetLValueReferenceType(); return compiler_type.GetLValueReferenceType();
} }
CompilerType GetTypedefedType() const { CompilerType GetTypedefedType() const {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType().GetTypedefedType(); return type_sp->GetForwardCompilerType().GetTypedefedType();
else
return compiler_type.GetTypedefedType(); return compiler_type.GetTypedefedType();
} }
CompilerType GetDereferencedType() const { CompilerType GetDereferencedType() const {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType().GetNonReferenceType(); return type_sp->GetForwardCompilerType().GetNonReferenceType();
else
return compiler_type.GetNonReferenceType(); return compiler_type.GetNonReferenceType();
} }
CompilerType GetUnqualifiedType() const { CompilerType GetUnqualifiedType() const {
if (type_sp) if (type_sp)
return type_sp->GetForwardCompilerType().GetFullyUnqualifiedType(); return type_sp->GetForwardCompilerType().GetFullyUnqualifiedType();
else
return compiler_type.GetFullyUnqualifiedType(); return compiler_type.GetFullyUnqualifiedType();
} }
CompilerType GetCanonicalType() const { CompilerType GetCanonicalType() const {
Context not available.

include/lldb/Target/ObjCLanguageRuntime.h

Context not available.
bool operator==(const ClassAndSel &rhs) { bool operator==(const ClassAndSel &rhs) {
if (class_addr == rhs.class_addr && sel_addr == rhs.sel_addr) if (class_addr == rhs.class_addr && sel_addr == rhs.sel_addr)
return true; return true;
else
return false; return false;
} }
bool operator<(const ClassAndSel &rhs) const { bool operator<(const ClassAndSel &rhs) const {
if (class_addr < rhs.class_addr) if (class_addr < rhs.class_addr)
return true; return true;
else if (class_addr > rhs.class_addr) if (class_addr > rhs.class_addr)
return false; return false;
else { else {
if (sel_addr < rhs.sel_addr) if (sel_addr < rhs.sel_addr)
return true; return true;
else
return false; return false;
} }
} }
Context not available.

include/lldb/Target/Process.h

Context not available.
inline bool operator==(const ProcessModID &lhs, const ProcessModID &rhs) { inline bool operator==(const ProcessModID &lhs, const ProcessModID &rhs) {
if (lhs.StopIDEqual(rhs) && lhs.MemoryIDEqual(rhs)) if (lhs.StopIDEqual(rhs) && lhs.MemoryIDEqual(rhs))
return true; return true;
else
return false; return false;
} }
inline bool operator!=(const ProcessModID &lhs, const ProcessModID &rhs) { inline bool operator!=(const ProcessModID &lhs, const ProcessModID &rhs) {
Context not available.

include/lldb/Target/StackFrameList.h

Context not available.
uint32_t GetVisibleStackFrameIndex(uint32_t idx) { uint32_t GetVisibleStackFrameIndex(uint32_t idx) {
if (m_current_inlined_depth < UINT32_MAX) if (m_current_inlined_depth < UINT32_MAX)
return idx - m_current_inlined_depth; return idx - m_current_inlined_depth;
else
return idx; return idx;
} }
/// Calculate and set the current inline depth. This may be used to update /// Calculate and set the current inline depth. This may be used to update
Context not available.

include/lldb/Target/StopInfo.h

Context not available.
virtual bool ShouldNotify(Event *event_ptr) { virtual bool ShouldNotify(Event *event_ptr) {
if (m_override_should_notify == eLazyBoolCalculate) if (m_override_should_notify == eLazyBoolCalculate)
return DoShouldNotify(event_ptr); return DoShouldNotify(event_ptr);
else
return m_override_should_notify == eLazyBoolYes; return m_override_should_notify == eLazyBoolYes;
} }
virtual void WillResume(lldb::StateType resume_state) { virtual void WillResume(lldb::StateType resume_state) {
Context not available.

include/lldb/Target/ThreadPlan.h

Context not available.
bool TracerExplainsStop() { bool TracerExplainsStop() {
if (!m_tracer_sp) if (!m_tracer_sp)
return false; return false;
else
return m_tracer_sp->TracerExplainsStop(); return m_tracer_sp->TracerExplainsStop();
} }
lldb::StateType RunState(); lldb::StateType RunState();
Context not available.
virtual size_t GetIterationCount() { virtual size_t GetIterationCount() {
if (!m_takes_iteration_count) if (!m_takes_iteration_count)
return 0; return 0;
else
return m_iteration_count; return m_iteration_count;
} }
protected: protected:
Context not available.

include/lldb/Target/ThreadPlanCallFunction.h

Context not available.
lldb::StopInfoSP GetRealStopInfo() override { lldb::StopInfoSP GetRealStopInfo() override {
if (m_real_stop_info_sp) if (m_real_stop_info_sp)
return m_real_stop_info_sp; return m_real_stop_info_sp;
else
return GetPrivateStopInfo(); return GetPrivateStopInfo();
} }
lldb::addr_t GetStopAddress() { return m_stop_address; } lldb::addr_t GetStopAddress() { return m_stop_address; }
Context not available.

include/lldb/Target/ThreadSpec.h

Context not available.
bool TIDMatches(lldb::tid_t thread_id) const { bool TIDMatches(lldb::tid_t thread_id) const {
if (m_tid == LLDB_INVALID_THREAD_ID || thread_id == LLDB_INVALID_THREAD_ID) if (m_tid == LLDB_INVALID_THREAD_ID || thread_id == LLDB_INVALID_THREAD_ID)
return true; return true;
else
return thread_id == m_tid; return thread_id == m_tid;
} }
bool TIDMatches(Thread &thread) const; bool TIDMatches(Thread &thread) const;
Context not available.
bool IndexMatches(uint32_t index) const { bool IndexMatches(uint32_t index) const {
if (m_index == UINT32_MAX || index == UINT32_MAX) if (m_index == UINT32_MAX || index == UINT32_MAX)
return true; return true;
else
return index == m_index; return index == m_index;
} }
bool IndexMatches(Thread &thread) const; bool IndexMatches(Thread &thread) const;
Context not available.
bool NameMatches(const char *name) const { bool NameMatches(const char *name) const {
if (m_name.empty()) if (m_name.empty())
return true; return true;
else if (name == nullptr) if (name == nullptr)
return false; return false;
else else
return m_name == name; return m_name == name;
Context not available.
bool QueueNameMatches(const char *queue_name) const { bool QueueNameMatches(const char *queue_name) const {
if (m_queue_name.empty()) if (m_queue_name.empty())
return true; return true;
else if (queue_name == nullptr) if (queue_name == nullptr)
return false; return false;
else else
return m_queue_name == queue_name; return m_queue_name == queue_name;
Context not available.

source/API/SBAddress.cpp

Context not available.
lldb::addr_t SBAddress::GetFileAddress() const { lldb::addr_t SBAddress::GetFileAddress() const {
if (m_opaque_ap->IsValid()) if (m_opaque_ap->IsValid())
return m_opaque_ap->GetFileAddress(); return m_opaque_ap->GetFileAddress();
else
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
} }
lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const { lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
Context not available.

source/API/SBBreakpoint.cpp

Context not available.
BreakpointSP bkpt_sp = GetSP(); BreakpointSP bkpt_sp = GetSP();
if (!bkpt_sp) if (!bkpt_sp)
return false; return false;
else if (bkpt_sp->GetTarget().GetBreakpointByID(bkpt_sp->GetID())) if (bkpt_sp->GetTarget().GetBreakpointByID(bkpt_sp->GetID()))
return true; return true;
else else
return false; return false;
Context not available.
std::lock_guard<std::recursive_mutex> guard( std::lock_guard<std::recursive_mutex> guard(
bkpt_sp->GetTarget().GetAPIMutex()); bkpt_sp->GetTarget().GetAPIMutex());
return bkpt_sp->IsEnabled(); return bkpt_sp->IsEnabled();
} else }
return false; return false;
} }
void SBBreakpoint::SetOneShot(bool one_shot) { void SBBreakpoint::SetOneShot(bool one_shot) {
Context not available.
std::lock_guard<std::recursive_mutex> guard( std::lock_guard<std::recursive_mutex> guard(
bkpt_sp->GetTarget().GetAPIMutex()); bkpt_sp->GetTarget().GetAPIMutex());
return bkpt_sp->IsOneShot(); return bkpt_sp->IsOneShot();
} else }
return false; return false;
} }
bool SBBreakpoint::IsInternal() { bool SBBreakpoint::IsInternal() {
Context not available.
std::lock_guard<std::recursive_mutex> guard( std::lock_guard<std::recursive_mutex> guard(
bkpt_sp->GetTarget().GetAPIMutex()); bkpt_sp->GetTarget().GetAPIMutex());
return bkpt_sp->IsInternal(); return bkpt_sp->IsInternal();
} else }
return false; return false;
} }
void SBBreakpoint::SetIgnoreCount(uint32_t count) { void SBBreakpoint::SetIgnoreCount(uint32_t count) {
Context not available.
size_t SBBreakpointList::GetSize() const { size_t SBBreakpointList::GetSize() const {
if (!m_opaque_sp) if (!m_opaque_sp)
return 0; return 0;
else
return m_opaque_sp->GetSize(); return m_opaque_sp->GetSize();
} }
SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) { SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
Context not available.

source/API/SBBreakpointLocation.cpp

Context not available.
BreakpointLocationSP loc_sp = GetSP(); BreakpointLocationSP loc_sp = GetSP();
if (loc_sp) if (loc_sp)
return SBAddress(&loc_sp->GetAddress()); return SBAddress(&loc_sp->GetAddress());
else
return SBAddress(); return SBAddress();
} }
addr_t SBBreakpointLocation::GetLoadAddress() { addr_t SBBreakpointLocation::GetLoadAddress() {
Context not available.
std::lock_guard<std::recursive_mutex> guard( std::lock_guard<std::recursive_mutex> guard(
loc_sp->GetTarget().GetAPIMutex()); loc_sp->GetTarget().GetAPIMutex());
return loc_sp->IsEnabled(); return loc_sp->IsEnabled();
} else }
return false; return false;
} }
uint32_t SBBreakpointLocation::GetHitCount() { uint32_t SBBreakpointLocation::GetHitCount() {
Context not available.
std::lock_guard<std::recursive_mutex> guard( std::lock_guard<std::recursive_mutex> guard(
loc_sp->GetTarget().GetAPIMutex()); loc_sp->GetTarget().GetAPIMutex());
return loc_sp->GetHitCount(); return loc_sp->GetHitCount();
} else }
return 0; return 0;
} }
uint32_t SBBreakpointLocation::GetIgnoreCount() { uint32_t SBBreakpointLocation::GetIgnoreCount() {
Context not available.
std::lock_guard<std::recursive_mutex> guard( std::lock_guard<std::recursive_mutex> guard(
loc_sp->GetTarget().GetAPIMutex()); loc_sp->GetTarget().GetAPIMutex());
return loc_sp->GetIgnoreCount(); return loc_sp->GetIgnoreCount();
} else }
return 0; return 0;
} }
void SBBreakpointLocation::SetIgnoreCount(uint32_t n) { void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
Context not available.
std::lock_guard<std::recursive_mutex> guard( std::lock_guard<std::recursive_mutex> guard(
loc_sp->GetTarget().GetAPIMutex()); loc_sp->GetTarget().GetAPIMutex());
return loc_sp->GetID(); return loc_sp->GetID();
} else }
return LLDB_INVALID_BREAK_ID; return LLDB_INVALID_BREAK_ID;
} }
SBBreakpoint SBBreakpointLocation::GetBreakpoint() { SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
Context not available.

source/API/SBBreakpointName.cpp

Context not available.
{ {
if (!rhs.m_impl_up) if (!rhs.m_impl_up)
return; return;
else
m_impl_up.reset(new SBBreakpointNameImpl(rhs.m_impl_up->GetTarget(), m_impl_up.reset(new SBBreakpointNameImpl(rhs.m_impl_up->GetTarget(),
rhs.m_impl_up->GetName())); rhs.m_impl_up->GetName()));
} }
SBBreakpointName::~SBBreakpointName() = default; SBBreakpointName::~SBBreakpointName() = default;
Context not available.

source/API/SBCommandReturnObject.cpp

Context not available.
if (m_opaque_ap) { if (m_opaque_ap) {
if (len == 0 || string == nullptr || *string == 0) { if (len == 0 || string == nullptr || *string == 0) {
return; return;
} else if (len > 0) { }
if (len > 0) {
std::string buffer(string, len); std::string buffer(string, len);
m_opaque_ap->AppendMessage(buffer.c_str()); m_opaque_ap->AppendMessage(buffer.c_str());
} else } else
Context not available.

source/API/SBDebugger.cpp

Context not available.
if (init_func) { if (init_func) {
if (init_func(debugger_sb)) if (init_func(debugger_sb))
return dynlib; return dynlib;
else
error.SetErrorString("plug-in refused to load " error.SetErrorString("plug-in refused to load "
"(lldb::PluginInitialize(lldb::SBDebugger) " "(lldb::PluginInitialize(lldb::SBDebugger) "
"returned false)"); "returned false)");
} else { } else {
error.SetErrorString("plug-in is missing the required initialization: " error.SetErrorString("plug-in is missing the required initialization: "
"lldb::PluginInitialize(lldb::SBDebugger)"); "lldb::PluginInitialize(lldb::SBDebugger)");
Context not available.
if (DataVisualization::Categories::GetCategory(ConstString(category_name), if (DataVisualization::Categories::GetCategory(ConstString(category_name),
category_sp, false)) category_sp, false))
return SBTypeCategory(category_sp); return SBTypeCategory(category_sp);
else
return SBTypeCategory(); return SBTypeCategory();
} }
SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) { SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
TypeCategoryImplSP category_sp; TypeCategoryImplSP category_sp;
if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) if (DataVisualization::Categories::GetCategory(lang_type, category_sp))
return SBTypeCategory(category_sp); return SBTypeCategory(category_sp);
else
return SBTypeCategory(); return SBTypeCategory();
} }
SBTypeCategory SBDebugger::CreateCategory(const char *category_name) { SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
Context not available.
if (DataVisualization::Categories::GetCategory(ConstString(category_name), if (DataVisualization::Categories::GetCategory(ConstString(category_name),
category_sp, true)) category_sp, true))
return SBTypeCategory(category_sp); return SBTypeCategory(category_sp);
else
return SBTypeCategory(); return SBTypeCategory();
} }
bool SBDebugger::DeleteCategory(const char *category_name) { bool SBDebugger::DeleteCategory(const char *category_name) {
Context not available.
llvm::raw_string_ostream error_stream(error); llvm::raw_string_ostream error_stream(error);
return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "", return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "",
log_options, error_stream); log_options, error_stream);
} else }
return false; return false;
} }
void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback, void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
Context not available.

source/API/SBEvent.cpp

Context not available.
const Event *lldb_event = get(); const Event *lldb_event = get();
if (lldb_event) if (lldb_event)
return lldb_event->GetBroadcaster()->GetBroadcasterClass().AsCString(); return lldb_event->GetBroadcaster()->GetBroadcasterClass().AsCString();
else
return "unknown class"; return "unknown class";
} }
bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) { bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
Context not available.

source/API/SBInstruction.cpp

Context not available.
lldb::InstructionSP SBInstruction::GetOpaque() { lldb::InstructionSP SBInstruction::GetOpaque() {
if (m_opaque_sp) if (m_opaque_sp)
return m_opaque_sp->GetSP(); return m_opaque_sp->GetSP();
else
return lldb::InstructionSP(); return lldb::InstructionSP();
} }
void SBInstruction::SetOpaque(const lldb::DisassemblerSP &disasm_sp, void SBInstruction::SetOpaque(const lldb::DisassemblerSP &disasm_sp,
Context not available.

source/API/SBListener.cpp

Context not available.
BroadcastEventSpec event_spec(ConstString(broadcaster_class), event_mask); BroadcastEventSpec event_spec(ConstString(broadcaster_class), event_mask);
return m_opaque_sp->StartListeningForEventSpec( return m_opaque_sp->StartListeningForEventSpec(
lldb_debugger->GetBroadcasterManager(), event_spec); lldb_debugger->GetBroadcasterManager(), event_spec);
} else }
return 0; return 0;
} }
bool SBListener::StopListeningForEventClass(SBDebugger &debugger, bool SBListener::StopListeningForEventClass(SBDebugger &debugger,
Context not available.
BroadcastEventSpec event_spec(ConstString(broadcaster_class), event_mask); BroadcastEventSpec event_spec(ConstString(broadcaster_class), event_mask);
return m_opaque_sp->StopListeningForEventSpec( return m_opaque_sp->StopListeningForEventSpec(
lldb_debugger->GetBroadcasterManager(), event_spec); lldb_debugger->GetBroadcasterManager(), event_spec);
} else }
return false; return false;
} }
uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster, uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster,
Context not available.

source/API/SBProcess.cpp

Context not available.
process_sp->GetTarget().GetAPIMutex()); process_sp->GetTarget().GetAPIMutex());
if (include_expression_stops) if (include_expression_stops)
return process_sp->GetStopID(); return process_sp->GetStopID();
else
return process_sp->GetLastNaturalStopID(); return process_sp->GetLastNaturalStopID();
} }
return 0; return 0;
} }
Context not available.
PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec, return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec,
*sb_remote_image_spec, sb_error.ref()); *sb_remote_image_spec, sb_error.ref());
} else {
if (log)
log->Printf("SBProcess(%p)::LoadImage() => error: process is running",
static_cast<void *>(process_sp.get()));
sb_error.SetErrorString("process is running");
} }
} else { if (log)
log->Printf("SBProcess(%p)::LoadImage() => error: process is running",
static_cast<void *>(process_sp.get()));
sb_error.SetErrorString("process is running");
} else {
if (log) if (log)
log->Printf("SBProcess(%p)::LoadImage() => error: called with invalid" log->Printf("SBProcess(%p)::LoadImage() => error: called with invalid"
" process", " process",
Context not available.
if (token != LLDB_INVALID_IMAGE_TOKEN) if (token != LLDB_INVALID_IMAGE_TOKEN)
loaded_path = loaded_spec; loaded_path = loaded_spec;
return token; return token;
} else {
if (log)
log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: "
"process is running",
static_cast<void *>(process_sp.get()));
error.SetErrorString("process is running");
} }
} else { if (log)
log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: "
"process is running",
static_cast<void *>(process_sp.get()));
error.SetErrorString("process is running");
} else {
if (log) if (log)
log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: " log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: "
"called with invalid process", "called with invalid process",
static_cast<void *>(process_sp.get())); static_cast<void *>(process_sp.get()));
error.SetErrorString("process is invalid"); error.SetErrorString("process is invalid");
} }
aprantlUnsubmitted
Not Done
ReplyInline Actions

This function probably could use some manual refactoring, too.

aprantl: This function probably could use some manual refactoring, too.
return LLDB_INVALID_IMAGE_TOKEN; return LLDB_INVALID_IMAGE_TOKEN;
} }
Context not available.
runtime->GetExtendedBacktraceTypes(); runtime->GetExtendedBacktraceTypes();
if (idx < names.size()) { if (idx < names.size()) {
return names[idx].AsCString(); return names[idx].AsCString();
} else {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBProcess(%p)::GetExtendedBacktraceTypeAtIndex() => "
"error: requested extended backtrace name out of bounds",
static_cast<void *>(process_sp.get()));
} }
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBProcess(%p)::GetExtendedBacktraceTypeAtIndex() => "
"error: requested extended backtrace name out of bounds",
static_cast<void *>(process_sp.get()));
} }
return NULL; return NULL;
} }
Context not available.

source/API/SBSourceManager.cpp

Context not available.
return target_sp->GetSourceManager().DisplaySourceLinesWithLineNumbers( return target_sp->GetSourceManager().DisplaySourceLinesWithLineNumbers(
file, line, column, context_before, context_after, current_line_cstr, file, line, column, context_before, context_after, current_line_cstr,
s); s);
} else {
lldb::DebuggerSP debugger_sp(m_debugger_wp.lock());
if (debugger_sp) {
return debugger_sp->GetSourceManager()
.DisplaySourceLinesWithLineNumbers(file, line, column,
context_before, context_after,
current_line_cstr, s);
}
} }
return 0; lldb::DebuggerSP debugger_sp(m_debugger_wp.lock());
if (debugger_sp) {
return debugger_sp->GetSourceManager().DisplaySourceLinesWithLineNumbers(
file, line, column, context_before, context_after, current_line_cstr,
s);
}
return 0;
} }
private: private:
Context not available.

source/API/SBThread.cpp

Context not available.
Process::StopLocker stop_locker; Process::StopLocker stop_locker;
if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
return exe_ctx.GetThreadPtr()->GetStopReason(); return exe_ctx.GetThreadPtr()->GetStopReason();
} else {
if (log)
log->Printf(
"SBThread(%p)::GetStopReason() => error: process is running",
static_cast<void *>(exe_ctx.GetThreadPtr()));
} }
if (log)
log->Printf("SBThread(%p)::GetStopReason() => error: process is running",
static_cast<void *>(exe_ctx.GetThreadPtr()));
} }
if (log) if (log)
Context not available.
site_id)); site_id));
if (bp_site_sp) if (bp_site_sp)
return bp_site_sp->GetNumberOfOwners() * 2; return bp_site_sp->GetNumberOfOwners() * 2;
else
return 0; // Breakpoint must have cleared itself... return 0; // Breakpoint must have cleared itself...
} break; } break;
case eStopReasonWatchpoint: case eStopReasonWatchpoint:
Context not available.
if (idx & 1) { if (idx & 1) {
// Odd idx, return the breakpoint location ID // Odd idx, return the breakpoint location ID
return bp_loc_sp->GetID(); return bp_loc_sp->GetID();
} else {
// Even idx, return the breakpoint ID
return bp_loc_sp->GetBreakpoint().GetID();
} }
// Even idx, return the breakpoint ID
return bp_loc_sp->GetBreakpoint().GetID();
} }
} }
return LLDB_INVALID_BREAK_ID; return LLDB_INVALID_BREAK_ID;
Context not available.
static_cast<void *>(exe_ctx.GetThreadPtr()), stop_desc); static_cast<void *>(exe_ctx.GetThreadPtr()), stop_desc);
if (dst) if (dst)
return ::snprintf(dst, dst_len, "%s", stop_desc); return ::snprintf(dst, dst_len, "%s", stop_desc);
else {
// NULL dst passed in, return the length needed to contain the // NULL dst passed in, return the length needed to contain the
// description // description
return ::strlen(stop_desc) + 1; // Include the NULL byte for size return ::strlen(stop_desc) + 1; // Include the NULL byte for size
}
} else { } else {
size_t stop_desc_len = 0; size_t stop_desc_len = 0;
switch (stop_info_sp->GetStopReason()) { switch (stop_info_sp->GetStopReason()) {
Context not available.
ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp) if (thread_sp)
return thread_sp.get(); return thread_sp.get();
else
return NULL; return NULL;
} }
lldb_private::Thread *SBThread::get() { lldb_private::Thread *SBThread::get() {
ThreadSP thread_sp(m_opaque_sp->GetThreadSP()); ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
if (thread_sp) if (thread_sp)
return thread_sp.get(); return thread_sp.get();
else
return NULL; return NULL;
} }
Context not available.

source/API/SBThreadPlan.cpp

Context not available.
SBThread SBThreadPlan::GetThread() const { SBThread SBThreadPlan::GetThread() const {
if (m_opaque_sp) { if (m_opaque_sp) {
return SBThread(m_opaque_sp->GetThread().shared_from_this()); return SBThread(m_opaque_sp->GetThread().shared_from_this());
} else }
return SBThread(); return SBThread();
} }
bool SBThreadPlan::GetDescription(lldb::SBStream &description) const { bool SBThreadPlan::GetDescription(lldb::SBStream &description) const {
Context not available.
bool SBThreadPlan::IsPlanComplete() { bool SBThreadPlan::IsPlanComplete() {
if (m_opaque_sp) if (m_opaque_sp)
return m_opaque_sp->IsPlanComplete(); return m_opaque_sp->IsPlanComplete();
else
return true; return true;
} }
bool SBThreadPlan::IsPlanStale() { bool SBThreadPlan::IsPlanStale() {
if (m_opaque_sp) if (m_opaque_sp)
return m_opaque_sp->IsPlanStale(); return m_opaque_sp->IsPlanStale();
else
return true; return true;
} }
bool SBThreadPlan::IsValid() { bool SBThreadPlan::IsValid() {
if (m_opaque_sp) if (m_opaque_sp)
return m_opaque_sp->ValidatePlan(nullptr); return m_opaque_sp->ValidatePlan(nullptr);
else
return false; return false;
} }
// This section allows an SBThreadPlan to push another of the common types of // This section allows an SBThreadPlan to push another of the common types of
Context not available.
error.SetErrorString(plan_status.AsCString()); error.SetErrorString(plan_status.AsCString());
return plan; return plan;
} else {
return SBThreadPlan();
} }
return SBThreadPlan();
} }
SBThreadPlan SBThreadPlan
Context not available.
error.SetErrorString(plan_status.AsCString()); error.SetErrorString(plan_status.AsCString());
return plan; return plan;
} else {
return SBThreadPlan();
} }
return SBThreadPlan();
} }
SBThreadPlan SBThreadPlan
Context not available.
error.SetErrorString(plan_status.AsCString()); error.SetErrorString(plan_status.AsCString());
return plan; return plan;
} else {
return SBThreadPlan();
} }
return SBThreadPlan();
} }
SBThreadPlan SBThreadPlan
Context not available.
error.SetErrorString(plan_status.AsCString()); error.SetErrorString(plan_status.AsCString());
return plan; return plan;
} else {
return SBThreadPlan();
} }
return SBThreadPlan();
} }
SBThreadPlan SBThreadPlan
Context not available.
error.SetErrorString(plan_status.AsCString()); error.SetErrorString(plan_status.AsCString());
return plan; return plan;
} else {
return SBThreadPlan();
} }
return SBThreadPlan();
} }
Context not available.

source/API/SBTypeCategory.cpp

Context not available.
if (type_name.IsRegex()) if (type_name.IsRegex())
return m_opaque_sp->GetRegexTypeFormatsContainer()->Delete( return m_opaque_sp->GetRegexTypeFormatsContainer()->Delete(
ConstString(type_name.GetName())); ConstString(type_name.GetName()));
else
return m_opaque_sp->GetTypeFormatsContainer()->Delete( return m_opaque_sp->GetTypeFormatsContainer()->Delete(
ConstString(type_name.GetName())); ConstString(type_name.GetName()));
} }
#ifndef LLDB_DISABLE_PYTHON #ifndef LLDB_DISABLE_PYTHON
Context not available.
if (type_name.IsRegex()) if (type_name.IsRegex())
return m_opaque_sp->GetRegexTypeSummariesContainer()->Delete( return m_opaque_sp->GetRegexTypeSummariesContainer()->Delete(
ConstString(type_name.GetName())); ConstString(type_name.GetName()));
else
return m_opaque_sp->GetTypeSummariesContainer()->Delete( return m_opaque_sp->GetTypeSummariesContainer()->Delete(
ConstString(type_name.GetName())); ConstString(type_name.GetName()));
} }
bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name, bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
Context not available.
if (type_name.IsRegex()) if (type_name.IsRegex())
return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete( return m_opaque_sp->GetRegexTypeFiltersContainer()->Delete(
ConstString(type_name.GetName())); ConstString(type_name.GetName()));
else
return m_opaque_sp->GetTypeFiltersContainer()->Delete( return m_opaque_sp->GetTypeFiltersContainer()->Delete(
ConstString(type_name.GetName())); ConstString(type_name.GetName()));
} }
#ifndef LLDB_DISABLE_PYTHON #ifndef LLDB_DISABLE_PYTHON
Context not available.
if (type_name.IsRegex()) if (type_name.IsRegex())
return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete( return m_opaque_sp->GetRegexTypeSyntheticsContainer()->Delete(
ConstString(type_name.GetName())); ConstString(type_name.GetName()));
else
return m_opaque_sp->GetTypeSyntheticsContainer()->Delete( return m_opaque_sp->GetTypeSyntheticsContainer()->Delete(
ConstString(type_name.GetName())); ConstString(type_name.GetName()));
} }
#endif // LLDB_DISABLE_PYTHON #endif // LLDB_DISABLE_PYTHON
Context not available.

source/API/SBTypeFilter.cpp

Context not available.
lldb::DescriptionLevel description_level) { lldb::DescriptionLevel description_level) {
if (!IsValid()) if (!IsValid())
return false; return false;
else {
description.Printf("%s\n", m_opaque_sp->GetDescription().c_str()); description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
return true; return true;
}
} }
void SBTypeFilter::Clear() { void SBTypeFilter::Clear() {
Context not available.
bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) { bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
if (CopyOnWrite_Impl()) if (CopyOnWrite_Impl())
return m_opaque_sp->SetExpressionPathAtIndex(i, item); return m_opaque_sp->SetExpressionPathAtIndex(i, item);
else
return false; return false;
} }
void SBTypeFilter::AppendExpressionPath(const char *item) { void SBTypeFilter::AppendExpressionPath(const char *item) {
Context not available.

source/API/SBTypeFormat.cpp

Context not available.
lldb::DescriptionLevel description_level) { lldb::DescriptionLevel description_level) {
if (!IsValid()) if (!IsValid())
return false; return false;
else {
description.Printf("%s\n", m_opaque_sp->GetDescription().c_str()); description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
return true; return true;
}
} }
lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) { lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
Context not available.
if (GetFormat() == rhs.GetFormat()) if (GetFormat() == rhs.GetFormat())
return GetOptions() == rhs.GetOptions(); return GetOptions() == rhs.GetOptions();
else
return false; return false;
} }
bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) { bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) {
Context not available.

source/API/SBTypeSummary.cpp

Context not available.
if (ftext && *ftext) if (ftext && *ftext)
return ftext; return ftext;
return fname; return fname;
} else if (StringSummaryFormat *string_summary_ptr = }
llvm::dyn_cast<StringSummaryFormat>(m_opaque_sp.get())) if (StringSummaryFormat *string_summary_ptr =
llvm::dyn_cast<StringSummaryFormat>(m_opaque_sp.get()))
return string_summary_ptr->GetSummaryString(); return string_summary_ptr->GetSummaryString();
return nullptr; return nullptr;
} }
Context not available.
lldb::DescriptionLevel description_level) { lldb::DescriptionLevel description_level) {
if (!CopyOnWrite_Impl()) if (!CopyOnWrite_Impl())
return false; return false;
else {
description.Printf("%s\n", m_opaque_sp->GetDescription().c_str()); description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
return true; return true;
}
} }
bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) { bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) {
Context not available.
// invalid and valid are different // invalid and valid are different
if (rhs.IsValid()) if (rhs.IsValid())
return false; return false;
else
// both invalid are the same // both invalid are the same
return true; return true;
} }
if (m_opaque_sp->GetKind() != rhs.m_opaque_sp->GetKind()) if (m_opaque_sp->GetKind() != rhs.m_opaque_sp->GetKind())
Context not available.

source/API/SBTypeSynthetic.cpp

Context not available.
return NULL; return NULL;
if (IsClassCode()) if (IsClassCode())
return m_opaque_sp->GetPythonCode(); return m_opaque_sp->GetPythonCode();
else
return m_opaque_sp->GetPythonClassName(); return m_opaque_sp->GetPythonClassName();
} }
void SBTypeSynthetic::SetClassName(const char *data) { void SBTypeSynthetic::SetClassName(const char *data) {
Context not available.

source/API/SBValue.cpp

Context not available.
bool IsValid() { bool IsValid() {
if (m_valobj_sp.get() == NULL) if (m_valobj_sp.get() == NULL)
return false; return false;
else {
// FIXME: This check is necessary but not sufficient. We for sure don't // FIXME: This check is necessary but not sufficient. We for sure don't
// want to touch SBValues whose owning // want to touch SBValues whose owning
// targets have gone away. This check is a little weak in that it // targets have gone away. This check is a little weak in that it
// enforces that restriction when you call IsValid, but since IsValid // enforces that restriction when you call IsValid, but since IsValid
// doesn't lock the target, you have no guarantee that the SBValue won't // doesn't lock the target, you have no guarantee that the SBValue won't
// go invalid after you call this... Also, an SBValue could depend on // go invalid after you call this... Also, an SBValue could depend on
// data from one of the modules in the target, and those could go away // data from one of the modules in the target, and those could go away
// independently of the target, for instance if a module is unloaded. // independently of the target, for instance if a module is unloaded.
// But right now, neither SBValues nor ValueObjects know which modules // But right now, neither SBValues nor ValueObjects know which modules
// 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()) if (target_sp && target_sp->IsValid())
return true; return true;
else
return false; return false;
}
} }
lldb::ValueObjectSP GetRootSP() { return m_valobj_sp; } lldb::ValueObjectSP GetRootSP() { return m_valobj_sp; }
Context not available.
TargetSP GetTargetSP() { TargetSP GetTargetSP() {
if (m_valobj_sp) if (m_valobj_sp)
return m_valobj_sp->GetTargetSP(); return m_valobj_sp->GetTargetSP();
else
return TargetSP(); return TargetSP();
} }
ProcessSP GetProcessSP() { ProcessSP GetProcessSP() {
if (m_valobj_sp) if (m_valobj_sp)
return m_valobj_sp->GetProcessSP(); return m_valobj_sp->GetProcessSP();
else
return ProcessSP(); return ProcessSP();
} }
ThreadSP GetThreadSP() { ThreadSP GetThreadSP() {
if (m_valobj_sp) if (m_valobj_sp)
return m_valobj_sp->GetThreadSP(); return m_valobj_sp->GetThreadSP();
else
return ThreadSP(); return ThreadSP();
} }
StackFrameSP GetFrameSP() { StackFrameSP GetFrameSP() {
if (m_valobj_sp) if (m_valobj_sp)
return m_valobj_sp->GetFrameSP(); return m_valobj_sp->GetFrameSP();
else
return StackFrameSP(); return StackFrameSP();
} }
private: private:
Context not available.
if (!success) if (!success)
error.SetErrorString("could not resolve value"); error.SetErrorString("could not resolve value");
return ret_val; return ret_val;
} else }
error.SetErrorStringWithFormat("could not get SBValue: %s", error.SetErrorStringWithFormat("could not get SBValue: %s",
locker.GetError().AsCString()); locker.GetError().AsCString());
return fail_value; return fail_value;
} }
Context not available.
if (!success) if (!success)
error.SetErrorString("could not resolve value"); error.SetErrorString("could not resolve value");
return ret_val; return ret_val;
} else }
error.SetErrorStringWithFormat("could not get SBValue: %s", error.SetErrorStringWithFormat("could not get SBValue: %s",
locker.GetError().AsCString()); locker.GetError().AsCString());
return fail_value; return fail_value;
} }
Context not available.

source/API/SBWatchpoint.cpp

Context not available.
std::lock_guard<std::recursive_mutex> guard( std::lock_guard<std::recursive_mutex> guard(
watchpoint_sp->GetTarget().GetAPIMutex()); watchpoint_sp->GetTarget().GetAPIMutex());
return watchpoint_sp->IsEnabled(); return watchpoint_sp->IsEnabled();
} else }
return false; return false;
} }
uint32_t SBWatchpoint::GetHitCount() { uint32_t SBWatchpoint::GetHitCount() {
Context not available.
std::lock_guard<std::recursive_mutex> guard( std::lock_guard<std::recursive_mutex> guard(
watchpoint_sp->GetTarget().GetAPIMutex()); watchpoint_sp->GetTarget().GetAPIMutex());
return watchpoint_sp->GetIgnoreCount(); return watchpoint_sp->GetIgnoreCount();
} else }
return 0; return 0;
} }
void SBWatchpoint::SetIgnoreCount(uint32_t n) { void SBWatchpoint::SetIgnoreCount(uint32_t n) {
Context not available.

source/Breakpoint/Breakpoint.cpp

Context not available.
// to find & decrement it, we only have to decrement our own ignore count. // to find & decrement it, we only have to decrement our own ignore count.
DecrementIgnoreCount(); DecrementIgnoreCount();
return false; return false;
} else }
return true; return true;
} }
uint32_t Breakpoint::GetHitCount() const { return m_hit_count; } uint32_t Breakpoint::GetHitCount() const { return m_hit_count; }
Context not available.
lldb::tid_t Breakpoint::GetThreadID() const { lldb::tid_t Breakpoint::GetThreadID() const {
if (m_options_up->GetThreadSpecNoCreate() == nullptr) if (m_options_up->GetThreadSpecNoCreate() == nullptr)
return LLDB_INVALID_THREAD_ID; return LLDB_INVALID_THREAD_ID;
else
return m_options_up->GetThreadSpecNoCreate()->GetTID(); return m_options_up->GetThreadSpecNoCreate()->GetTID();
} }
void Breakpoint::SetThreadIndex(uint32_t index) { void Breakpoint::SetThreadIndex(uint32_t index) {
Context not available.
uint32_t Breakpoint::GetThreadIndex() const { uint32_t Breakpoint::GetThreadIndex() const {
if (m_options_up->GetThreadSpecNoCreate() == nullptr) if (m_options_up->GetThreadSpecNoCreate() == nullptr)
return 0; return 0;
else
return m_options_up->GetThreadSpecNoCreate()->GetIndex(); return m_options_up->GetThreadSpecNoCreate()->GetIndex();
} }
void Breakpoint::SetThreadName(const char *thread_name) { void Breakpoint::SetThreadName(const char *thread_name) {
Context not available.
const char *Breakpoint::GetThreadName() const { const char *Breakpoint::GetThreadName() const {
if (m_options_up->GetThreadSpecNoCreate() == nullptr) if (m_options_up->GetThreadSpecNoCreate() == nullptr)
return nullptr; return nullptr;
else
return m_options_up->GetThreadSpecNoCreate()->GetName(); return m_options_up->GetThreadSpecNoCreate()->GetName();
} }
void Breakpoint::SetQueueName(const char *queue_name) { void Breakpoint::SetQueueName(const char *queue_name) {
Context not available.
const char *Breakpoint::GetQueueName() const { const char *Breakpoint::GetQueueName() const {
if (m_options_up->GetThreadSpecNoCreate() == nullptr) if (m_options_up->GetThreadSpecNoCreate() == nullptr)
return nullptr; return nullptr;
else
return m_options_up->GetThreadSpecNoCreate()->GetQueueName(); return m_options_up->GetThreadSpecNoCreate()->GetQueueName();
} }
void Breakpoint::SetCondition(const char *condition) { void Breakpoint::SetCondition(const char *condition) {
Context not available.
if (level == eDescriptionLevelBrief) { if (level == eDescriptionLevelBrief) {
s->PutCString(GetBreakpointKind()); s->PutCString(GetBreakpointKind());
return; return;
} else }
s->Printf("Kind: %s\n", GetBreakpointKind()); s->Printf("Kind: %s\n", GetBreakpointKind());
} }
const size_t num_locations = GetNumLocations(); const size_t num_locations = GetNumLocations();
Context not available.
if (data == nullptr) if (data == nullptr)
return eBreakpointEventTypeInvalidType; return eBreakpointEventTypeInvalidType;
else
return data->GetBreakpointEventType(); return data->GetBreakpointEventType();
} }
BreakpointSP Breakpoint::BreakpointEventData::GetBreakpointFromEvent( BreakpointSP Breakpoint::BreakpointEventData::GetBreakpointFromEvent(
Context not available.

source/Breakpoint/BreakpointIDList.cpp

Context not available.
result.AppendError(error.AsCString()); result.AppendError(error.AsCString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return; return;
} else }
names_found.insert(current_arg); names_found.insert(current_arg);
} else if ((i + 2 < old_args.size()) && } else if ((i + 2 < old_args.size()) &&
BreakpointID::IsRangeIdentifier(old_args[i + 1].ref) && BreakpointID::IsRangeIdentifier(old_args[i + 1].ref) &&
BreakpointID::IsValidIDExpression(current_arg) && BreakpointID::IsValidIDExpression(current_arg) &&
Context not available.

source/Breakpoint/BreakpointLocation.cpp

Context not available.
const { const {
if (m_options_ap && m_options_ap->IsOptionSet(kind)) if (m_options_ap && m_options_ap->IsOptionSet(kind))
return m_options_ap.get(); return m_options_ap.get();
else
return m_owner.GetOptions(); return m_owner.GetOptions();
} }
Address &BreakpointLocation::GetAddress() { return m_address; } Address &BreakpointLocation::GetAddress() { return m_address; }
Context not available.
bool BreakpointLocation::IsEnabled() const { bool BreakpointLocation::IsEnabled() const {
if (!m_owner.IsEnabled()) if (!m_owner.IsEnabled())
return false; return false;
else if (m_options_ap.get() != nullptr) if (m_options_ap.get() != nullptr)
return m_options_ap->IsEnabled(); return m_options_ap->IsEnabled();
else else
return true; return true;
Context not available.
if (m_options_ap if (m_options_ap
&& m_options_ap->IsOptionSet(BreakpointOptions::eAutoContinue)) && m_options_ap->IsOptionSet(BreakpointOptions::eAutoContinue))
return m_options_ap->IsAutoContinue(); return m_options_ap->IsAutoContinue();
else
return m_owner.IsAutoContinue(); return m_owner.IsAutoContinue();
} }
void BreakpointLocation::SetAutoContinue(bool auto_continue) { void BreakpointLocation::SetAutoContinue(bool auto_continue) {
Context not available.
->GetThreadSpecNoCreate(); ->GetThreadSpecNoCreate();
if (thread_spec) if (thread_spec)
return thread_spec->GetTID(); return thread_spec->GetTID();
else
return LLDB_INVALID_THREAD_ID; return LLDB_INVALID_THREAD_ID;
} }
void BreakpointLocation::SetThreadIndex(uint32_t index) { void BreakpointLocation::SetThreadIndex(uint32_t index) {
Context not available.
->GetThreadSpecNoCreate(); ->GetThreadSpecNoCreate();
if (thread_spec) if (thread_spec)
return thread_spec->GetIndex(); return thread_spec->GetIndex();
else
return 0; return 0;
} }
void BreakpointLocation::SetThreadName(const char *thread_name) { void BreakpointLocation::SetThreadName(const char *thread_name) {
Context not available.
->GetThreadSpecNoCreate(); ->GetThreadSpecNoCreate();
if (thread_spec) if (thread_spec)
return thread_spec->GetName(); return thread_spec->GetName();
else
return nullptr; return nullptr;
} }
void BreakpointLocation::SetQueueName(const char *queue_name) { void BreakpointLocation::SetQueueName(const char *queue_name) {
Context not available.
->GetThreadSpecNoCreate(); ->GetThreadSpecNoCreate();
if (thread_spec) if (thread_spec)
return thread_spec->GetQueueName(); return thread_spec->GetQueueName();
else
return nullptr; return nullptr;
} }
bool BreakpointLocation::InvokeCallback(StoppointCallbackContext *context) { bool BreakpointLocation::InvokeCallback(StoppointCallbackContext *context) {
if (m_options_ap.get() != nullptr && m_options_ap->HasCallback()) if (m_options_ap.get() != nullptr && m_options_ap->HasCallback())
return m_options_ap->InvokeCallback(context, m_owner.GetID(), GetID()); return m_options_ap->InvokeCallback(context, m_owner.GetID(), GetID());
else
return m_owner.InvokeCallback(context, GetID()); return m_owner.InvokeCallback(context, GetID());
} }
void BreakpointLocation::SetCallback(BreakpointHitCallback callback, void BreakpointLocation::SetCallback(BreakpointHitCallback callback,
Context not available.

source/Breakpoint/BreakpointLocationList.cpp

Context not available.
std::lower_bound(m_locations.begin(), end, break_id, Compare); std::lower_bound(m_locations.begin(), end, break_id, Compare);
if (pos != end && (*pos)->GetID() == break_id) if (pos != end && (*pos)->GetID() == break_id)
return *(pos); return *(pos);
else
return BreakpointLocationSP(); return BreakpointLocationSP();
} }
size_t BreakpointLocationList::FindInModule( size_t BreakpointLocationList::FindInModule(
Context not available.

source/Breakpoint/BreakpointOptions.cpp

Context not available.
if (found_something) if (found_something)
return data_up; return data_up;
else
return std::unique_ptr<BreakpointOptions::CommandData>(); return std::unique_ptr<BreakpointOptions::CommandData>();
} }
const char *BreakpointOptions::g_option_names[( const char *BreakpointOptions::g_option_names[(
Context not available.
return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data() return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data()
: nullptr, : nullptr,
context, break_id, break_loc_id); context, break_id, break_loc_id);
} else if (IsCallbackSynchronous()) { }
if (IsCallbackSynchronous()) {
// If a synchronous callback is called at async time, it should not say // If a synchronous callback is called at async time, it should not say
// to stop. // to stop.
return false; return false;
Context not available.
*hash = m_condition_text_hash; *hash = m_condition_text_hash;
return m_condition_text.c_str(); return m_condition_text.c_str();
} else {
return nullptr;
} }
return nullptr;
} }
const ThreadSpec *BreakpointOptions::GetThreadSpecNoCreate() const { const ThreadSpec *BreakpointOptions::GetThreadSpecNoCreate() const {
Context not available.

source/Breakpoint/BreakpointResolver.cpp

Context not available.
if (!error.Success()) { if (!error.Success()) {
return result_sp; return result_sp;
} else {
// Add on the global offset option:
resolver->SetOffset(offset);
return BreakpointResolverSP(resolver);
} }
// Add on the global offset option:
resolver->SetOffset(offset);
return BreakpointResolverSP(resolver);
} }
StructuredData::DictionarySP BreakpointResolver::WrapOptionsDict( StructuredData::DictionarySP BreakpointResolver::WrapOptionsDict(
Context not available.

source/Breakpoint/BreakpointResolverName.cpp

Context not available.
RegularExpression regex(regex_text); RegularExpression regex(regex_text);
return new BreakpointResolverName(bkpt, regex, language, offset, return new BreakpointResolverName(bkpt, regex, language, offset,
skip_prologue); skip_prologue);
} else { }
StructuredData::Array *names_array; StructuredData::Array *names_array;
success = options_dict.GetValueForKeyAsArray( success = options_dict.GetValueForKeyAsArray(
GetKey(OptionNames::SymbolNameArray), names_array); GetKey(OptionNames::SymbolNameArray), names_array);
if (!success) { if (!success) {
error.SetErrorStringWithFormat("BRN::CFSD: Missing symbol names entry."); error.SetErrorStringWithFormat("BRN::CFSD: Missing symbol names entry.");
return nullptr; return nullptr;
} }
StructuredData::Array *names_mask_array; StructuredData::Array *names_mask_array;
success = options_dict.GetValueForKeyAsArray( success = options_dict.GetValueForKeyAsArray(
Context not available.
resolver->AddNameLookup(ConstString(names[i]), name_masks[i]); resolver->AddNameLookup(ConstString(names[i]), name_masks[i]);
} }
return resolver; return resolver;
}
} }
StructuredData::ObjectSP BreakpointResolverName::SerializeToStructuredData() { StructuredData::ObjectSP BreakpointResolverName::SerializeToStructuredData() {
Context not available.

source/Breakpoint/BreakpointResolverScripted.cpp

Context not available.
&context); &context);
if (should_continue) if (should_continue)
return Searcher::eCallbackReturnContinue; return Searcher::eCallbackReturnContinue;
else
return Searcher::eCallbackReturnStop; return Searcher::eCallbackReturnStop;
} }
lldb::SearchDepth lldb::SearchDepth
Context not available.

source/Breakpoint/BreakpointSiteList.cpp

Context not available.
if (iter == m_bp_site_list.end()) { if (iter == m_bp_site_list.end()) {
m_bp_site_list.insert(iter, collection::value_type(bp_site_load_addr, bp)); m_bp_site_list.insert(iter, collection::value_type(bp_site_load_addr, bp));
return bp->GetID(); return bp->GetID();
} else {
return LLDB_INVALID_BREAK_ID;
} }
return LLDB_INVALID_BREAK_ID;
} }
bool BreakpointSiteList::ShouldStop(StoppointCallbackContext *context, bool BreakpointSiteList::ShouldStop(StoppointCallbackContext *context,
Context not available.

source/Breakpoint/Watchpoint.cpp

Context not available.
const char *Watchpoint::GetConditionText() const { const char *Watchpoint::GetConditionText() const {
if (m_condition_ap.get()) if (m_condition_ap.get())
return m_condition_ap->GetUserText(); return m_condition_ap->GetUserText();
else
return nullptr; return nullptr;
} }
void Watchpoint::SendWatchpointChangedEvent( void Watchpoint::SendWatchpointChangedEvent(
Context not available.
if (data == nullptr) if (data == nullptr)
return eWatchpointEventTypeInvalidType; return eWatchpointEventTypeInvalidType;
else
return data->GetWatchpointEventType(); return data->GetWatchpointEventType();
} }
WatchpointSP Watchpoint::WatchpointEventData::GetWatchpointFromEvent( WatchpointSP Watchpoint::WatchpointEventData::GetWatchpointFromEvent(
Context not available.

source/Breakpoint/WatchpointOptions.cpp

Context not available.
return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data() return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data()
: nullptr, : nullptr,
context, watch_id); context, watch_id);
} else }
return true; return true;
} }
bool WatchpointOptions::HasCallback() { bool WatchpointOptions::HasCallback() {
Context not available.

source/Commands/CommandCompletions.cpp

Context not available.
for (int i = 0;; i++) { for (int i = 0;; i++) {
if (g_common_completions[i].type == eNoCompletion) if (g_common_completions[i].type == eNoCompletion)
break; break;
else if ((g_common_completions[i].type & completion_mask) == if ((g_common_completions[i].type & completion_mask) ==
g_common_completions[i].type && g_common_completions[i].type &&
g_common_completions[i].callback != nullptr) { g_common_completions[i].callback != nullptr) {
handled = true; handled = true;
g_common_completions[i].callback(interpreter, request, searcher); g_common_completions[i].callback(interpreter, request, searcher);
} }
Context not available.

source/Commands/CommandObjectBreakpoint.cpp

Context not available.
"No files provided and could not find default file."); "No files provided and could not find default file.");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else {
m_options.m_filenames.Append(file);
} }
m_options.m_filenames.Append(file);
} }
RegularExpression regexp(m_options.m_source_text_regexp); RegularExpression regexp(m_options.m_source_text_regexp);
Context not available.
"No selected frame to use to find the default file."); "No selected frame to use to find the default file.");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else if (!cur_frame->HasDebugInformation()) { }
if (!cur_frame->HasDebugInformation()) {
result.AppendError("Cannot use the selected frame to find the default " result.AppendError("Cannot use the selected frame to find the default "
"file, it has no debug info."); "file, it has no debug info.");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
Context not available.

source/Commands/CommandObjectCommands.cpp

Context not available.
original_raw_command_string.str().c_str()); original_raw_command_string.str().c_str());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else if (!cmd_obj->WantsRawCommandString()) { }
if (!cmd_obj->WantsRawCommandString()) {
// Note that args was initialized with the original command, and has not // Note that args was initialized with the original command, and has not
// been updated to this point. Therefore can we pass it to the version of // been updated to this point. Therefore can we pass it to the version of
// Execute that does not need/expect raw input in the alias. // Execute that does not need/expect raw input in the alias.
Context not available.

source/Commands/CommandObjectDisassemble.cpp

Context not available.
m_options.arch.GetArchitectureName()); m_options.arch.GetArchitectureName());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else if (flavor_string != nullptr && }
!disassembler->FlavorValidForArchSpec(m_options.arch, if (flavor_string != nullptr &&
flavor_string)) !disassembler->FlavorValidForArchSpec(m_options.arch, flavor_string))
result.AppendWarningWithFormat( result.AppendWarningWithFormat(
"invalid disassembler flavor \"%s\", using default.\n", flavor_string); "invalid disassembler flavor \"%s\", using default.\n", flavor_string);
Context not available.

source/Commands/CommandObjectFrame.cpp

Context not available.
result.AppendError("Already at the bottom of the stack."); result.AppendError("Already at the bottom of the stack.");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else }
frame_idx = 0; frame_idx = 0;
} }
} else if (m_options.relative_frame_offset > 0) { } else if (m_options.relative_frame_offset > 0) {
// I don't want "up 20" where "20" takes you past the top of the stack // I don't want "up 20" where "20" takes you past the top of the stack
Context not available.
result.AppendError("Already at the top of the stack."); result.AppendError("Already at the top of the stack.");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else }
frame_idx = num_frames - 1; frame_idx = num_frames - 1;
} }
} }
} else { } else {
Context not available.

source/Commands/CommandObjectHelp.cpp

Context not available.
if (!sub_cmd_obj->IsMultiwordObject()) { if (!sub_cmd_obj->IsMultiwordObject()) {
all_okay = false; all_okay = false;
break; break;
} else {
CommandObject *found_cmd;
found_cmd =
sub_cmd_obj->GetSubcommandObject(sub_command.c_str(), &matches);
if (found_cmd == nullptr || matches.GetSize() > 1) {
all_okay = false;
break;
} else
sub_cmd_obj = found_cmd;
} }
CommandObject *found_cmd;
found_cmd =
sub_cmd_obj->GetSubcommandObject(sub_command.c_str(), &matches);
if (found_cmd == nullptr || matches.GetSize() > 1) {
all_okay = false;
break;
}
sub_cmd_obj = found_cmd;
} }
if (!all_okay || (sub_cmd_obj == nullptr)) { if (!all_okay || (sub_cmd_obj == nullptr)) {
Context not available.
result.AppendError(s.GetString()); result.AppendError(s.GetString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else if (!sub_cmd_obj) { }
if (!sub_cmd_obj) {
StreamString error_msg_stream; StreamString error_msg_stream;
GenerateAdditionalHelpAvenuesMessage( GenerateAdditionalHelpAvenuesMessage(
&error_msg_stream, cmd_string.c_str(), &error_msg_stream, cmd_string.c_str(),
Context not available.
// Return the completions of the commands in the help system: // Return the completions of the commands in the help system:
if (request.GetCursorIndex() == 0) { if (request.GetCursorIndex() == 0) {
return m_interpreter.HandleCompletionMatches(request); return m_interpreter.HandleCompletionMatches(request);
} else { }
CommandObject *cmd_obj = CommandObject *cmd_obj =
m_interpreter.GetCommandObject(request.GetParsedLine()[0].ref); m_interpreter.GetCommandObject(request.GetParsedLine()[0].ref);
// The command that they are getting help on might be ambiguous, in which // The command that they are getting help on might be ambiguous, in which
// case we should complete that, otherwise complete with the command the // case we should complete that, otherwise complete with the command the
// user is getting help on... // user is getting help on...
if (cmd_obj) { if (cmd_obj) {
request.GetParsedLine().Shift(); request.GetParsedLine().Shift();
request.SetCursorIndex(request.GetCursorIndex() - 1); request.SetCursorIndex(request.GetCursorIndex() - 1);
return cmd_obj->HandleCompletion(request); return cmd_obj->HandleCompletion(request);
} else {
return m_interpreter.HandleCompletionMatches(request);
} }
} return m_interpreter.HandleCompletionMatches(request);
} }
Context not available.

source/Commands/CommandObjectMemory.cpp

Context not available.
view_as_type_cstr); view_as_type_cstr);
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else {
TypeSP type_sp(type_list.GetTypeAtIndex(0));
clang_ast_type = type_sp->GetFullCompilerType();
} }
TypeSP type_sp(type_list.GetTypeAtIndex(0));
clang_ast_type = type_sp->GetFullCompilerType();
} }
while (pointer_count > 0) { while (pointer_count > 0) {
Context not available.
result.AppendError(error.AsCString()); result.AppendError(error.AsCString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else if (end_addr <= addr) { }
if (end_addr <= addr) {
result.AppendErrorWithFormat( result.AppendErrorWithFormat(
"end address (0x%" PRIx64 "end address (0x%" PRIx64
") must be greater that the start address (0x%" PRIx64 ").\n", ") must be greater that the start address (0x%" PRIx64 ").\n",
Context not available.
"%zi bytes %s to '%s'\n", bytes_written, "%zi bytes %s to '%s'\n", bytes_written,
append ? "appended" : "written", path.c_str()); append ? "appended" : "written", path.c_str());
return true; return true;
} else {
result.AppendErrorWithFormat("Failed to write %" PRIu64
" bytes to '%s'.\n",
(uint64_t)bytes_read, path.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
} }
result.AppendErrorWithFormat("Failed to write %" PRIu64
" bytes to '%s'.\n",
(uint64_t)bytes_read, path.c_str());
result.SetStatus(eReturnStatusFailed);
return false;
} else { } else {
// We are going to write ASCII to the file just point the // We are going to write ASCII to the file just point the
// output_stream to our outfile_stream... // output_stream to our outfile_stream...
Context not available.
j--; j--;
if (j < 0) if (j < 0)
return low + s; return low + s;
else
s += bad_char_heuristic[iterator[s + buffer_size - 1]]; s += bad_char_heuristic[iterator[s + buffer_size - 1]];
} }
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
Context not available.
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
} }
return result.Succeeded(); return result.Succeeded();
} else if (item_byte_size == 0) { }
if (item_byte_size == 0) {
if (m_format_options.GetFormat() == eFormatPointer) if (m_format_options.GetFormat() == eFormatPointer)
item_byte_size = buffer.GetAddressByteSize(); item_byte_size = buffer.GetAddressByteSize();
else else
Context not available.
"'%s' is not a valid hex string value.\n", entry.c_str()); "'%s' is not a valid hex string value.\n", entry.c_str());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else if (!UIntValueIsValidForSize(uval64, item_byte_size)) { }
if (!UIntValueIsValidForSize(uval64, item_byte_size)) {
result.AppendErrorWithFormat("Value 0x%" PRIx64 result.AppendErrorWithFormat("Value 0x%" PRIx64
" is too large to fit in a %" PRIu64 " is too large to fit in a %" PRIu64
" byte unsigned integer value.\n", " byte unsigned integer value.\n",
Context not available.
buffer.GetString().size(), buffer.GetString().size(),
error) == buffer.GetString().size()) error) == buffer.GetString().size())
return true; return true;
else {
result.AppendErrorWithFormat("Memory write to 0x%" PRIx64 result.AppendErrorWithFormat("Memory write to 0x%" PRIx64
" failed: %s.\n", " failed: %s.\n",
addr, error.AsCString()); addr, error.AsCString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
}
} }
return true; return true;
} }
Context not available.

source/Commands/CommandObjectMultiword.cpp

Context not available.
} }
} }
return new_matches.GetSize(); return new_matches.GetSize();
} else {
StringList new_matches;
CommandObject *sub_command_object = GetSubcommandObject(arg0, &new_matches);
if (sub_command_object == nullptr) {
request.AddCompletions(new_matches);
return request.GetNumberOfMatches();
} else {
// Remove the one match that we got from calling GetSubcommandObject.
new_matches.DeleteStringAtIndex(0);
request.AddCompletions(new_matches);
request.GetParsedLine().Shift();
request.SetCursorIndex(request.GetCursorIndex() - 1);
return sub_command_object->HandleCompletion(request);
}
} }
StringList new_matches;
CommandObject *sub_command_object = GetSubcommandObject(arg0, &new_matches);
if (sub_command_object == nullptr) {
request.AddCompletions(new_matches);
return request.GetNumberOfMatches();
}
// Remove the one match that we got from calling GetSubcommandObject.
new_matches.DeleteStringAtIndex(0);
request.AddCompletions(new_matches);
request.GetParsedLine().Shift();
request.SetCursorIndex(request.GetCursorIndex() - 1);
return sub_command_object->HandleCompletion(request);
} }
const char *CommandObjectMultiword::GetRepeatCommand(Args &current_command_args, const char *CommandObjectMultiword::GetRepeatCommand(Args &current_command_args,
Context not available.

source/Commands/CommandObjectPlatform.cpp

Context not available.
entry.ref.str().c_str()); entry.ref.str().c_str());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
break; break;
} else { }
ProcessInstanceInfo proc_info; ProcessInstanceInfo proc_info;
if (platform_sp->GetProcessInfo(pid, proc_info)) { if (platform_sp->GetProcessInfo(pid, proc_info)) {
ostrm.Printf("Process information for process %" PRIu64 ":\n", ostrm.Printf("Process information for process %" PRIu64 ":\n",
pid); pid);
proc_info.Dump(ostrm, platform_sp.get()); proc_info.Dump(ostrm, platform_sp.get());
} else { } else {
ostrm.Printf("error: no process information is available for " ostrm.Printf("error: no process information is available for "
"process %" PRIu64 "\n", "process %" PRIu64 "\n",
pid); pid);
} }
ostrm.EOL(); ostrm.EOL();
}
} }
} else { } else {
// Not connected... // Not connected...
Context not available.

source/Commands/CommandObjectProcess.cpp

Context not available.
if (!m_interpreter.Confirm(message, true)) { if (!m_interpreter.Confirm(message, true)) {
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
}
if (process->GetShouldDetach()) {
bool keep_stopped = false;
Status detach_error(process->Detach(keep_stopped));
if (detach_error.Success()) {
result.SetStatus(eReturnStatusSuccessFinishResult);
process = nullptr;
} else {
result.AppendErrorWithFormat("Failed to detach from process: %s\n",
detach_error.AsCString());
result.SetStatus(eReturnStatusFailed);
}
} else { } else {
if (process->GetShouldDetach()) { Status destroy_error(process->Destroy(false));
bool keep_stopped = false; if (destroy_error.Success()) {
Status detach_error(process->Detach(keep_stopped)); result.SetStatus(eReturnStatusSuccessFinishResult);
if (detach_error.Success()) { process = nullptr;
result.SetStatus(eReturnStatusSuccessFinishResult);
process = nullptr;
} else {
result.AppendErrorWithFormat(
"Failed to detach from process: %s\n",
detach_error.AsCString());
result.SetStatus(eReturnStatusFailed);
}
} else { } else {
Status destroy_error(process->Destroy(false)); result.AppendErrorWithFormat("Failed to kill process: %s\n",
if (destroy_error.Success()) { destroy_error.AsCString());
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusFailed);
process = nullptr;
} else {
result.AppendErrorWithFormat("Failed to kill process: %s\n",
destroy_error.AsCString());
result.SetStatus(eReturnStatusFailed);
}
} }
} }
} }
Context not available.
entry.ref.str().c_str()); entry.ref.str().c_str());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
break; break;
} else { }
Status error(process->GetTarget().GetPlatform()->UnloadImage( Status error(process->GetTarget().GetPlatform()->UnloadImage(
process, image_token)); process, image_token));
if (error.Success()) { if (error.Success()) {
result.AppendMessageWithFormat( result.AppendMessageWithFormat(
"Unloading shared library with index %u...ok\n", image_token); "Unloading shared library with index %u...ok\n", image_token);
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
} else { } else {
result.AppendErrorWithFormat("failed to unload image: %s", result.AppendErrorWithFormat("failed to unload image: %s",
error.AsCString()); error.AsCString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
break; break;
} }
}
} }
return result.Succeeded(); return result.Succeeded();
} }
Context not available.

source/Commands/CommandObjectSettings.cpp

Context not available.
result.AppendError(error.AsCString()); result.AppendError(error.AsCString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else {
result.SetStatus(eReturnStatusSuccessFinishResult);
} }
result.SetStatus(eReturnStatusSuccessFinishResult);
return result.Succeeded(); return result.Succeeded();
} }
Context not available.
result.AppendError(error.AsCString()); result.AppendError(error.AsCString());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else {
result.SetStatus(eReturnStatusSuccessFinishNoResult);
} }
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded(); return result.Succeeded();
} }
Context not available.

source/Commands/CommandObjectSource.cpp

Context not available.
result.AppendError( result.AppendError(
"No selected frame to use to find the default source."); "No selected frame to use to find the default source.");
return false; return false;
} else if (!cur_frame->HasDebugInformation()) { }
if (!cur_frame->HasDebugInformation()) {
result.AppendError("No debug info for the selected frame."); result.AppendError("No debug info for the selected frame.");
return false; return false;
} else { } else {
Context not available.
return target->GetSourceManager().DisplaySourceLinesWithLineNumbers( return target->GetSourceManager().DisplaySourceLinesWithLineNumbers(
start_file, line_no, column, 0, m_options.num_lines, "", start_file, line_no, column, 0, m_options.num_lines, "",
&result.GetOutputStream(), GetBreakpointLocations()); &result.GetOutputStream(), GetBreakpointLocations());
} else {
result.AppendErrorWithFormat(
"Could not find function info for: \"%s\".\n",
m_options.symbol_name.c_str());
} }
result.AppendErrorWithFormat("Could not find function info for: \"%s\".\n",
m_options.symbol_name.c_str());
return 0; return 0;
} }
Context not available.
} }
} }
return result.Succeeded(); return result.Succeeded();
} else if (m_options.address != LLDB_INVALID_ADDRESS) { }
if (m_options.address != LLDB_INVALID_ADDRESS) {
Address so_addr; Address so_addr;
StreamString error_strm; StreamString error_strm;
SymbolContextList sc_list; SymbolContextList sc_list;
Context not available.
if (test_cu_spec != static_cast<FileSpec *>(sc.comp_unit)) if (test_cu_spec != static_cast<FileSpec *>(sc.comp_unit))
got_multiple = true; got_multiple = true;
break; break;
} else }
test_cu_spec = sc.comp_unit; test_cu_spec = sc.comp_unit;
} }
} }
if (got_multiple) { if (got_multiple) {
Context not available.

source/Commands/CommandObjectTarget.cpp

Context not available.
error.AsCString("can't find plug-in for core file")); error.AsCString("can't find plug-in for core file"));
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else {
result.AppendMessageWithFormat(
"Core file '%s' (%s) was loaded.\n", core_path,
target_sp->GetArchitecture().GetArchitectureName());
result.SetStatus(eReturnStatusSuccessFinishNoResult);
} }
result.AppendMessageWithFormat(
"Core file '%s' (%s) was loaded.\n", core_path,
target_sp->GetArchitecture().GetArchitectureName());
result.SetStatus(eReturnStatusSuccessFinishNoResult);
} else { } else {
result.AppendErrorWithFormat( result.AppendErrorWithFormat(
"Unable to find process plug-in for core file '%s'\n", "Unable to find process plug-in for core file '%s'\n",
Context not available.
"error: can't find global variable '%s'\n", arg); "error: can't find global variable '%s'\n", arg);
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else { }
for (uint32_t global_idx = 0; global_idx < matches; ++global_idx) { for (uint32_t global_idx = 0; global_idx < matches; ++global_idx) {
VariableSP var_sp(variable_list.GetVariableAtIndex(global_idx)); VariableSP var_sp(variable_list.GetVariableAtIndex(global_idx));
if (var_sp) { if (var_sp) {
ValueObjectSP valobj_sp( ValueObjectSP valobj_sp(
valobj_list.GetValueObjectAtIndex(global_idx)); valobj_list.GetValueObjectAtIndex(global_idx));
if (!valobj_sp) if (!valobj_sp)
valobj_sp = ValueObjectVariable::Create( valobj_sp = ValueObjectVariable::Create(
m_exe_ctx.GetBestExecutionContextScope(), var_sp); m_exe_ctx.GetBestExecutionContextScope(), var_sp);
if (valobj_sp) if (valobj_sp)
DumpValueObject(s, var_sp, valobj_sp, DumpValueObject(s, var_sp, valobj_sp,
use_var_name ? var_sp->GetName().GetCString() use_var_name ? var_sp->GetName().GetCString()
: arg); : arg);
}
} }
} }
} }
Context not available.
std::string fullpath = file_spec_ptr->GetPath(); std::string fullpath = file_spec_ptr->GetPath();
strm.Printf("%-*s", width, fullpath.c_str()); strm.Printf("%-*s", width, fullpath.c_str());
return; return;
} else {
file_spec_ptr->Dump(&strm);
return;
} }
file_spec_ptr->Dump(&strm);
return;
} }
// Keep the width spacing correct if things go wrong... // Keep the width spacing correct if things go wrong...
if (width > 0) if (width > 0)
Context not available.
if (target && !target->GetSectionLoadList().IsEmpty()) { if (target && !target->GetSectionLoadList().IsEmpty()) {
if (!target->GetSectionLoadList().ResolveLoadAddress(addr, so_addr)) if (!target->GetSectionLoadList().ResolveLoadAddress(addr, so_addr))
return false; return false;
else if (so_addr.GetModule().get() != module) if (so_addr.GetModule().get() != module)
return false; return false;
} else { } else {
if (!module->ResolveFileAddress(addr, so_addr)) if (!module->ResolveFileAddress(addr, so_addr))
Context not available.
"'target create' command"); "'target create' command");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else { }
uint32_t num_dumped = 0; uint32_t num_dumped = 0;
uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize(); uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
result.GetOutputStream().SetAddressByteSize(addr_byte_size); result.GetOutputStream().SetAddressByteSize(addr_byte_size);
result.GetErrorStream().SetAddressByteSize(addr_byte_size); result.GetErrorStream().SetAddressByteSize(addr_byte_size);
if (command.GetArgumentCount() == 0) { if (command.GetArgumentCount() == 0) {
// Dump all sections for all modules images // Dump all sections for all modules images
std::lock_guard<std::recursive_mutex> guard( std::lock_guard<std::recursive_mutex> guard(
target->GetImages().GetMutex()); target->GetImages().GetMutex());
const size_t num_modules = target->GetImages().GetSize(); const size_t num_modules = target->GetImages().GetSize();
if (num_modules > 0) { if (num_modules > 0) {
result.GetOutputStream().Printf("Dumping symbol table for %" PRIu64 result.GetOutputStream().Printf("Dumping symbol table for %" PRIu64
" modules.\n", " modules.\n",
(uint64_t)num_modules); (uint64_t)num_modules);
for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) { for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
if (num_dumped > 0) { if (num_dumped > 0) {
result.GetOutputStream().EOL(); result.GetOutputStream().EOL();
result.GetOutputStream().EOL(); result.GetOutputStream().EOL();
}
if (m_interpreter.WasInterrupted())
break;
num_dumped++;
DumpModuleSymtab(
m_interpreter, result.GetOutputStream(),
target->GetImages().GetModulePointerAtIndexUnlocked(image_idx),
m_options.m_sort_order);
} }
} else { if (m_interpreter.WasInterrupted())
result.AppendError("the target has no associated executable images"); break;
result.SetStatus(eReturnStatusFailed); num_dumped++;
return false; DumpModuleSymtab(
m_interpreter, result.GetOutputStream(),
target->GetImages().GetModulePointerAtIndexUnlocked(image_idx),
m_options.m_sort_order);
} }
} else {
result.AppendError("the target has no associated executable images");
result.SetStatus(eReturnStatusFailed);
return false;
}
} else { } else {
// Dump specified images (by basename or fullpath) // Dump specified images (by basename or fullpath)
const char *arg_cstr; const char *arg_cstr;
Context not available.
result.AppendError("no matching executable images found"); result.AppendError("no matching executable images found");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
} }
}
return result.Succeeded(); return result.Succeeded();
} }
CommandOptions m_options; CommandOptions m_options;
Context not available.
"'target create' command"); "'target create' command");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else { }
uint32_t num_dumped = 0; uint32_t num_dumped = 0;
uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize(); uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
result.GetOutputStream().SetAddressByteSize(addr_byte_size); result.GetOutputStream().SetAddressByteSize(addr_byte_size);
result.GetErrorStream().SetAddressByteSize(addr_byte_size); result.GetErrorStream().SetAddressByteSize(addr_byte_size);
if (command.GetArgumentCount() == 0) { if (command.GetArgumentCount() == 0) {
// Dump all sections for all modules images // Dump all sections for all modules images
const size_t num_modules = target->GetImages().GetSize(); const size_t num_modules = target->GetImages().GetSize();
if (num_modules > 0) { if (num_modules > 0) {
result.GetOutputStream().Printf("Dumping sections for %" PRIu64 result.GetOutputStream().Printf("Dumping sections for %" PRIu64
" modules.\n", " modules.\n",
(uint64_t)num_modules); (uint64_t)num_modules);
for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) { for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
if (m_interpreter.WasInterrupted()) if (m_interpreter.WasInterrupted())
break; break;
num_dumped++; num_dumped++;
DumpModuleSections( DumpModuleSections(
m_interpreter, result.GetOutputStream(), m_interpreter, result.GetOutputStream(),
target->GetImages().GetModulePointerAtIndex(image_idx)); target->GetImages().GetModulePointerAtIndex(image_idx));
}
} else {
result.AppendError("the target has no associated executable images");
result.SetStatus(eReturnStatusFailed);
return false;
} }
} else {
result.AppendError("the target has no associated executable images");
result.SetStatus(eReturnStatusFailed);
return false;
}
} else { } else {
// Dump specified images (by basename or fullpath) // Dump specified images (by basename or fullpath)
const char *arg_cstr; const char *arg_cstr;
Context not available.
result.AppendError("no matching executable images found"); result.AppendError("no matching executable images found");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
} }
}
return result.Succeeded(); return result.Succeeded();
} }
}; };
Context not available.
"'target create' command"); "'target create' command");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else { }
uint32_t num_dumped = 0; uint32_t num_dumped = 0;
uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize(); uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
result.GetOutputStream().SetAddressByteSize(addr_byte_size); result.GetOutputStream().SetAddressByteSize(addr_byte_size);
result.GetErrorStream().SetAddressByteSize(addr_byte_size); result.GetErrorStream().SetAddressByteSize(addr_byte_size);
if (command.GetArgumentCount() == 0) { if (command.GetArgumentCount() == 0) {
// Dump all sections for all modules images // Dump all sections for all modules images
const ModuleList &target_modules = target->GetImages(); const ModuleList &target_modules = target->GetImages();
std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex()); std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
const size_t num_modules = target_modules.GetSize(); const size_t num_modules = target_modules.GetSize();
if (num_modules > 0) { if (num_modules > 0) {
result.GetOutputStream().Printf("Dumping debug symbols for %" PRIu64 result.GetOutputStream().Printf("Dumping debug symbols for %" PRIu64
" modules.\n", " modules.\n",
(uint64_t)num_modules); (uint64_t)num_modules);
for (uint32_t image_idx = 0; image_idx < num_modules; ++image_idx) { for (uint32_t image_idx = 0; image_idx < num_modules; ++image_idx) {
if (m_interpreter.WasInterrupted()) if (m_interpreter.WasInterrupted())
break; break;
if (DumpModuleSymbolVendor( if (DumpModuleSymbolVendor(
result.GetOutputStream(), result.GetOutputStream(),
target_modules.GetModulePointerAtIndexUnlocked(image_idx))) target_modules.GetModulePointerAtIndexUnlocked(image_idx)))
num_dumped++; num_dumped++;
}
} else {
result.AppendError("the target has no associated executable images");
result.SetStatus(eReturnStatusFailed);
return false;
} }
} else {
result.AppendError("the target has no associated executable images");
result.SetStatus(eReturnStatusFailed);
return false;
}
} else { } else {
// Dump specified images (by basename or fullpath) // Dump specified images (by basename or fullpath)
const char *arg_cstr; const char *arg_cstr;
Context not available.
result.AppendError("no matching executable images found"); result.AppendError("no matching executable images found");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
} }
}
return result.Succeeded(); return result.Succeeded();
} }
}; };
Context not available.
result.AppendError("file option must be specified."); result.AppendError("file option must be specified.");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return result.Succeeded(); return result.Succeeded();
} else { }
// Dump specified images (by basename or fullpath) // Dump specified images (by basename or fullpath)
const char *arg_cstr; const char *arg_cstr;
for (int arg_idx = 0; for (int arg_idx = 0;
(arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr; (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != nullptr;
++arg_idx) { ++arg_idx) {
FileSpec file_spec(arg_cstr); FileSpec file_spec(arg_cstr);
const ModuleList &target_modules = target->GetImages(); const ModuleList &target_modules = target->GetImages();
std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex()); std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
const size_t num_modules = target_modules.GetSize(); const size_t num_modules = target_modules.GetSize();
if (num_modules > 0) { if (num_modules > 0) {
uint32_t num_dumped = 0; uint32_t num_dumped = 0;
for (uint32_t i = 0; i < num_modules; ++i) { for (uint32_t i = 0; i < num_modules; ++i) {
if (m_interpreter.WasInterrupted()) if (m_interpreter.WasInterrupted())
break; break;
if (DumpCompileUnitLineTable( if (DumpCompileUnitLineTable(
m_interpreter, result.GetOutputStream(), m_interpreter, result.GetOutputStream(),
target_modules.GetModulePointerAtIndexUnlocked(i), target_modules.GetModulePointerAtIndexUnlocked(i), file_spec,
file_spec, m_exe_ctx.GetProcessPtr() && m_exe_ctx.GetProcessPtr() &&
m_exe_ctx.GetProcessRef().IsAlive())) m_exe_ctx.GetProcessRef().IsAlive()))
num_dumped++; num_dumped++;
}
if (num_dumped == 0)
result.AppendWarningWithFormat(
"No source filenames matched '%s'.\n", arg_cstr);
else
total_num_dumped += num_dumped;
} }
if (num_dumped == 0)
result.AppendWarningWithFormat("No source filenames matched '%s'.\n",
arg_cstr);
else
total_num_dumped += num_dumped;
}
} }
}
if (total_num_dumped > 0) if (total_num_dumped > 0)
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
Context not available.
"'target create' command"); "'target create' command");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else { }
bool flush = false; bool flush = false;
const size_t argc = args.GetArgumentCount(); const size_t argc = args.GetArgumentCount();
if (argc == 0) { if (argc == 0) {
if (m_uuid_option_group.GetOptionValue().OptionWasSet()) { if (m_uuid_option_group.GetOptionValue().OptionWasSet()) {
// We are given a UUID only, go locate the file // We are given a UUID only, go locate the file
ModuleSpec module_spec; ModuleSpec module_spec;
module_spec.GetUUID() = module_spec.GetUUID() =
m_uuid_option_group.GetOptionValue().GetCurrentValue(); m_uuid_option_group.GetOptionValue().GetCurrentValue();
if (m_symbol_file.GetOptionValue().OptionWasSet()) if (m_symbol_file.GetOptionValue().OptionWasSet())
module_spec.GetSymbolFileSpec() = module_spec.GetSymbolFileSpec() =
m_symbol_file.GetOptionValue().GetCurrentValue(); m_symbol_file.GetOptionValue().GetCurrentValue();
if (Symbols::DownloadObjectAndSymbolFile(module_spec)) { if (Symbols::DownloadObjectAndSymbolFile(module_spec)) {
ModuleSP module_sp(target->GetSharedModule(module_spec)); ModuleSP module_sp(target->GetSharedModule(module_spec));
if (module_sp) { if (module_sp) {
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
return true; return true;
}
StreamString strm;
aprantlUnsubmitted
Not Done
ReplyInline Actions

Can you manually double-check this one?

aprantl: Can you manually double-check this one?
zturnerUnsubmitted
Not Done
ReplyInline Actions

For large complex cases like this, it might make sense to convert them to early returns first. That makes the size of the if blocks smaller so less chance of messing up.

zturner: For large complex cases like this, it might make sense to convert them to early returns first.
module_spec.GetUUID().Dump(&strm);
if (module_spec.GetFileSpec()) {
if (module_spec.GetSymbolFileSpec()) {
result.AppendErrorWithFormat(
"Unable to create the executable or symbol file with "
"UUID %s with path %s and symbol file %s",
strm.GetData(), module_spec.GetFileSpec().GetPath().c_str(),
module_spec.GetSymbolFileSpec().GetPath().c_str());
} else { } else {
StreamString strm; result.AppendErrorWithFormat(
module_spec.GetUUID().Dump(&strm); "Unable to create the executable or symbol file with "
if (module_spec.GetFileSpec()) { "UUID %s with path %s",
if (module_spec.GetSymbolFileSpec()) { strm.GetData(), module_spec.GetFileSpec().GetPath().c_str());
result.AppendErrorWithFormat(
"Unable to create the executable or symbol file with "
"UUID %s with path %s and symbol file %s",
strm.GetData(),
module_spec.GetFileSpec().GetPath().c_str(),
module_spec.GetSymbolFileSpec().GetPath().c_str());
} else {
result.AppendErrorWithFormat(
"Unable to create the executable or symbol file with "
"UUID %s with path %s",
strm.GetData(),
module_spec.GetFileSpec().GetPath().c_str());
}
} else {
result.AppendErrorWithFormat("Unable to create the executable "
"or symbol file with UUID %s",
strm.GetData());
}
result.SetStatus(eReturnStatusFailed);
return false;
} }
} else { } else {
StreamString strm; result.AppendErrorWithFormat("Unable to create the executable "
module_spec.GetUUID().Dump(&strm); "or symbol file with UUID %s",
result.AppendErrorWithFormat( strm.GetData());
"Unable to locate the executable or symbol file with UUID %s",
strm.GetData());
result.SetStatus(eReturnStatusFailed);
return false;
} }
result.SetStatus(eReturnStatusFailed);
return false;
} else { } else {
result.AppendError( StreamString strm;
"one or more executable image paths must be specified"); module_spec.GetUUID().Dump(&strm);
result.AppendErrorWithFormat(
"Unable to locate the executable or symbol file with UUID %s",
strm.GetData());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} }
} else {
result.AppendError(
"one or more executable image paths must be specified");
result.SetStatus(eReturnStatusFailed);
return false;
}
} else { } else {
zturnerUnsubmitted
Not Done
ReplyInline Actions

Something is wrong with indentation here.

zturner: Something is wrong with indentation here.
for (auto &entry : args.entries()) { for (auto &entry : args.entries()) {
if (entry.ref.empty()) if (entry.ref.empty())
Context not available.
entry.c_str()); entry.c_str());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else {
flush = true;
} }
flush = true;
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
} else { } else {
std::string resolved_path = file_spec.GetPath(); std::string resolved_path = file_spec.GetPath();
Context not available.
if (process) if (process)
process->Flush(); process->Flush();
} }
}
return result.Succeeded(); return result.Succeeded();
} }
Context not available.
"'target create' command"); "'target create' command");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else { }
const size_t argc = args.GetArgumentCount(); const size_t argc = args.GetArgumentCount();
ModuleSpec module_spec; ModuleSpec module_spec;
bool search_using_module_spec = false; bool search_using_module_spec = false;
// Allow "load" option to work without --file or --uuid option. // Allow "load" option to work without --file or --uuid option.
if (load) { if (load) {
if (!m_file_option.GetOptionValue().OptionWasSet() && if (!m_file_option.GetOptionValue().OptionWasSet() &&
!m_uuid_option_group.GetOptionValue().OptionWasSet()) { !m_uuid_option_group.GetOptionValue().OptionWasSet()) {
ModuleList &module_list = target->GetImages(); ModuleList &module_list = target->GetImages();
if (module_list.GetSize() == 1) { if (module_list.GetSize() == 1) {
search_using_module_spec = true; search_using_module_spec = true;
module_spec.GetFileSpec() = module_spec.GetFileSpec() =
module_list.GetModuleAtIndex(0)->GetFileSpec(); module_list.GetModuleAtIndex(0)->GetFileSpec();
}
} }
} }
}
if (m_file_option.GetOptionValue().OptionWasSet()) { if (m_file_option.GetOptionValue().OptionWasSet()) {
search_using_module_spec = true; search_using_module_spec = true;
Context not available.
sect_name); sect_name);
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
break; break;
} else {
if (target->GetSectionLoadList()
.SetSectionLoadAddress(section_sp,
load_addr))
changed = true;
result.AppendMessageWithFormat(
"section '%s' loaded at 0x%" PRIx64 "\n",
sect_name, load_addr);
} }
if (target->GetSectionLoadList()
.SetSectionLoadAddress(section_sp, load_addr))
changed = true;
result.AppendMessageWithFormat(
"section '%s' loaded at 0x%" PRIx64 "\n",
sect_name, load_addr);
} else { } else {
result.AppendErrorWithFormat("no section found that " result.AppendErrorWithFormat("no section found that "
"matches the section " "matches the section "
Context not available.
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} }
}
return result.Succeeded(); return result.Succeeded();
} }
OptionGroupOptions m_option_group; OptionGroupOptions m_option_group;
Context not available.
"'target create' command"); "'target create' command");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else { }
if (target) { if (target) {
uint32_t addr_byte_size = uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
target->GetArchitecture().GetAddressByteSize(); result.GetOutputStream().SetAddressByteSize(addr_byte_size);
result.GetOutputStream().SetAddressByteSize(addr_byte_size); result.GetErrorStream().SetAddressByteSize(addr_byte_size);
result.GetErrorStream().SetAddressByteSize(addr_byte_size); }
}
// Dump all sections for all modules images // Dump all sections for all modules images
Stream &strm = result.GetOutputStream(); Stream &strm = result.GetOutputStream();
Context not available.
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} }
}
return result.Succeeded(); return result.Succeeded();
} }
void PrintModule(Target *target, Module *module, int indent, Stream &strm) { void PrintModule(Target *target, Module *module, int indent, Stream &strm) {
Context not available.
"'target create' command"); "'target create' command");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else { }
bool syntax_error = false; bool syntax_error = false;
uint32_t i; uint32_t i;
uint32_t num_successful_lookups = 0; uint32_t num_successful_lookups = 0;
uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize(); uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
result.GetOutputStream().SetAddressByteSize(addr_byte_size); result.GetOutputStream().SetAddressByteSize(addr_byte_size);
result.GetErrorStream().SetAddressByteSize(addr_byte_size); result.GetErrorStream().SetAddressByteSize(addr_byte_size);
// Dump all sections for all modules images // Dump all sections for all modules images
if (command.GetArgumentCount() == 0) {
ModuleSP current_module;
// Where it is possible to look in the current symbol context first, if (command.GetArgumentCount() == 0) {
// try that. If this search was successful and --all was not passed, ModuleSP current_module;
// don't print anything else.
if (LookupHere(m_interpreter, result, syntax_error)) { // Where it is possible to look in the current symbol context first,
result.GetOutputStream().EOL(); // try that. If this search was successful and --all was not passed,
num_successful_lookups++; // don't print anything else.
if (!m_options.m_print_all) { if (LookupHere(m_interpreter, result, syntax_error)) {
result.SetStatus(eReturnStatusSuccessFinishResult); result.GetOutputStream().EOL();
return result.Succeeded(); num_successful_lookups++;
} if (!m_options.m_print_all) {
result.SetStatus(eReturnStatusSuccessFinishResult);
return result.Succeeded();
} }
}
// Dump all sections for all other modules // Dump all sections for all other modules
const ModuleList &target_modules = target->GetImages(); const ModuleList &target_modules = target->GetImages();
std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex()); std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
const size_t num_modules = target_modules.GetSize(); const size_t num_modules = target_modules.GetSize();
if (num_modules > 0) { if (num_modules > 0) {
for (i = 0; i < num_modules && !syntax_error; ++i) { for (i = 0; i < num_modules && !syntax_error; ++i) {
Module *module_pointer = Module *module_pointer =
target_modules.GetModulePointerAtIndexUnlocked(i); target_modules.GetModulePointerAtIndexUnlocked(i);
if (module_pointer != current_module.get() && if (module_pointer != current_module.get() &&
LookupInModule( LookupInModule(m_interpreter,
m_interpreter, target_modules.GetModulePointerAtIndexUnlocked(i),
target_modules.GetModulePointerAtIndexUnlocked(i), result, result, syntax_error)) {
syntax_error)) { result.GetOutputStream().EOL();
result.GetOutputStream().EOL(); num_successful_lookups++;
num_successful_lookups++;
}
} }
} else {
result.AppendError("the target has no associated executable images");
result.SetStatus(eReturnStatusFailed);
return false;
} }
} else {
result.AppendError("the target has no associated executable images");
result.SetStatus(eReturnStatusFailed);
return false;
}
} else { } else {
// Dump specified images (by basename or fullpath) // Dump specified images (by basename or fullpath)
const char *arg_cstr; const char *arg_cstr;
Context not available.
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
else else
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
}
return result.Succeeded(); return result.Succeeded();
} }
CommandOptions m_options; CommandOptions m_options;
Context not available.
if (!m_interpreter.Confirm("Delete all stop hooks?", true)) { if (!m_interpreter.Confirm("Delete all stop hooks?", true)) {
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else {
target->RemoveAllStopHooks();
} }
target->RemoveAllStopHooks();
} else { } else {
bool success; bool success;
for (size_t i = 0; i < num_args; i++) { for (size_t i = 0; i < num_args; i++) {
Context not available.

source/Commands/CommandObjectThread.cpp

Context not available.
if (!thread || !HandleOneThread(thread->GetID(), result)) if (!thread || !HandleOneThread(thread->GetID(), result))
return false; return false;
return result.Succeeded(); return result.Succeeded();
} else if (command.GetArgumentCount() == 1) { }
if (command.GetArgumentCount() == 1) {
all_threads = ::strcmp(command.GetArgumentAtIndex(0), "all") == 0; all_threads = ::strcmp(command.GetArgumentAtIndex(0), "all") == 0;
m_unique_stacks = ::strcmp(command.GetArgumentAtIndex(0), "unique") == 0; m_unique_stacks = ::strcmp(command.GetArgumentAtIndex(0), "unique") == 0;
} }
Context not available.
result.AppendErrorWithFormat("empty class name for scripted step."); result.AppendErrorWithFormat("empty class name for scripted step.");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else if (!m_interpreter.GetScriptInterpreter()->CheckObjectExists( }
m_options.m_class_name.c_str())) { if (!m_interpreter.GetScriptInterpreter()->CheckObjectExists(
m_options.m_class_name.c_str())) {
result.AppendErrorWithFormat( result.AppendErrorWithFormat(
"class for scripted step: \"%s\" does not exist.", "class for scripted step: \"%s\" does not exist.",
m_options.m_class_name.c_str()); m_options.m_class_name.c_str());
Context not available.
result.AppendError("no valid thread indexes were specified"); result.AppendError("no valid thread indexes were specified");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else { }
if (resume_threads.size() == 1) if (resume_threads.size() == 1)
result.AppendMessageWithFormat("Resuming thread: "); result.AppendMessageWithFormat("Resuming thread: ");
else else
result.AppendMessageWithFormat("Resuming threads: "); result.AppendMessageWithFormat("Resuming threads: ");
for (uint32_t idx = 0; idx < num_threads; ++idx) {
Thread *thread =
process->GetThreadList().GetThreadAtIndex(idx).get();
std::vector<Thread *>::iterator this_thread_pos =
find(resume_threads.begin(), resume_threads.end(), thread);
if (this_thread_pos != resume_threads.end()) {
resume_threads.erase(this_thread_pos);
if (!resume_threads.empty())
result.AppendMessageWithFormat("%u, ", thread->GetIndexID());
else
result.AppendMessageWithFormat("%u ", thread->GetIndexID());
const bool override_suspend = true; for (uint32_t idx = 0; idx < num_threads; ++idx) {
thread->SetResumeState(eStateRunning, override_suspend); Thread *thread = process->GetThreadList().GetThreadAtIndex(idx).get();
} else { std::vector<Thread *>::iterator this_thread_pos =
thread->SetResumeState(eStateSuspended); find(resume_threads.begin(), resume_threads.end(), thread);
}
if (this_thread_pos != resume_threads.end()) {
resume_threads.erase(this_thread_pos);
if (!resume_threads.empty())
result.AppendMessageWithFormat("%u, ", thread->GetIndexID());
else
result.AppendMessageWithFormat("%u ", thread->GetIndexID());
const bool override_suspend = true;
thread->SetResumeState(eStateRunning, override_suspend);
} else {
thread->SetResumeState(eStateSuspended);
}
} }
result.AppendMessageWithFormat("in process %" PRIu64 "\n", result.AppendMessageWithFormat("in process %" PRIu64 "\n",
process->GetID()); process->GetID());
}
} else { } else {
// These two lines appear at the beginning of both blocks in this // These two lines appear at the beginning of both blocks in this
// if..else, but that is because we need to release the lock before // if..else, but that is because we need to release the lock before
Context not available.
command.GetArgumentAtIndex(i)); command.GetArgumentAtIndex(i));
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else }
line_numbers.push_back(line_number); line_numbers.push_back(line_number);
} }
} else if (m_options.m_until_addrs.empty()) { } else if (m_options.m_until_addrs.empty()) {
result.AppendErrorWithFormat("No line number or address provided:\n%s", result.AppendErrorWithFormat("No line number or address provided:\n%s",
Context not available.
result.AppendError("no process"); result.AppendError("no process");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else if (command.GetArgumentCount() != 1) { }
if (command.GetArgumentCount() != 1) {
result.AppendErrorWithFormat( result.AppendErrorWithFormat(
"'%s' takes exactly one thread index argument:\nUsage: %s\n", "'%s' takes exactly one thread index argument:\nUsage: %s\n",
m_cmd_name.c_str(), m_cmd_syntax.c_str()); m_cmd_name.c_str(), m_cmd_syntax.c_str());
Context not available.
if (thread->DiscardUserThreadPlansUpToIndex(thread_plan_idx)) { if (thread->DiscardUserThreadPlansUpToIndex(thread_plan_idx)) {
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
return true; return true;
} else {
result.AppendErrorWithFormat(
"Could not find User thread plan with index %s.",
args.GetArgumentAtIndex(0));
result.SetStatus(eReturnStatusFailed);
return false;
} }
result.AppendErrorWithFormat(
"Could not find User thread plan with index %s.",
args.GetArgumentAtIndex(0));
result.SetStatus(eReturnStatusFailed);
return false;
} }
}; };
Context not available.

source/Commands/CommandObjectType.cpp

Context not available.
if (m_options.handwrite_python) if (m_options.handwrite_python)
return Execute_HandwritePython(command, result); return Execute_HandwritePython(command, result);
else if (m_options.is_class_based) if (m_options.is_class_based)
return Execute_PythonClass(command, result); return Execute_PythonClass(command, result);
else { else {
result.AppendError("must either provide a children list, a Python class " result.AppendError("must either provide a children list, a Python class "
Context not available.
if (delete_category || extra_deletion) { if (delete_category || extra_deletion) {
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
return result.Succeeded(); return result.Succeeded();
} else {
result.AppendErrorWithFormat("no custom formatter for %s.\n", typeA);
result.SetStatus(eReturnStatusFailed);
return false;
} }
result.AppendErrorWithFormat("no custom formatter for %s.\n", typeA);
result.SetStatus(eReturnStatusFailed);
return false;
} }
}; };
Context not available.
category->GetRegexTypeSummariesContainer()->Add(typeRX, entry); category->GetRegexTypeSummariesContainer()->Add(typeRX, entry);
return true; return true;
} else if (type == eNamedSummary) { }
if (type == eNamedSummary) {
// system named summaries do not exist (yet?) // system named summaries do not exist (yet?)
DataVisualization::NamedSummaryFormats::Add(type_name, entry); DataVisualization::NamedSummaryFormats::Add(type_name, entry);
return true; return true;
Context not available.
if (success) { if (success) {
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
return result.Succeeded(); return result.Succeeded();
} else {
result.AppendError("cannot delete one or more categories\n");
result.SetStatus(eReturnStatusFailed);
return false;
} }
result.AppendError("cannot delete one or more categories\n");
result.SetStatus(eReturnStatusFailed);
return false;
} }
}; };
Context not available.
category->GetRegexTypeSyntheticsContainer()->Delete(type_name); category->GetRegexTypeSyntheticsContainer()->Delete(type_name);
category->GetRegexTypeSyntheticsContainer()->Add(typeRX, entry); category->GetRegexTypeSyntheticsContainer()->Add(typeRX, entry);
return true;
} else {
category->GetTypeSyntheticsContainer()->Add(type_name, entry);
return true; return true;
} }
category->GetTypeSyntheticsContainer()->Add(type_name, entry);
return true;
} }
#endif // LLDB_DISABLE_PYTHON #endif // LLDB_DISABLE_PYTHON
Context not available.
category->GetRegexTypeFiltersContainer()->Delete(type_name); category->GetRegexTypeFiltersContainer()->Delete(type_name);
category->GetRegexTypeFiltersContainer()->Add(typeRX, entry); category->GetRegexTypeFiltersContainer()->Add(typeRX, entry);
return true;
} else {
category->GetTypeFiltersContainer()->Add(type_name, entry);
return true; return true;
} }
category->GetTypeFiltersContainer()->Add(type_name, entry);
return true;
} }
public: public:
Context not available.
// this is "type lookup SomeName" and we did find a match, so get out // this is "type lookup SomeName" and we did find a match, so get out
if (any_found && is_global_search) if (any_found && is_global_search)
break; break;
else if (is_first_language && is_global_search && if (is_first_language && is_global_search &&
guessed_language != lldb::eLanguageTypeUnknown) { guessed_language != lldb::eLanguageTypeUnknown) {
is_first_language = false; is_first_language = false;
result.GetOutputStream().Printf( result.GetOutputStream().Printf(
"no type was found in the current language %s matching '%s'; " "no type was found in the current language %s matching '%s'; "
Context not available.
result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult); result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
} }
return true; return true;
} else {
result.AppendError("failed to evaluate expression");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
} }
result.AppendError("failed to evaluate expression");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
} }
private: private:
Context not available.

source/Commands/CommandObjectWatchpoint.cpp

Context not available.
if (watch_sp) { if (watch_sp) {
wp_ids.push_back(watch_sp->GetID()); wp_ids.push_back(watch_sp->GetID());
return true; return true;
} else }
return false; return false;
} }
llvm::StringRef Minus("-"); llvm::StringRef Minus("-");
Context not available.

source/Core/Address.cpp

Context not available.
// We have a valid file range, so we can return the file based address by // We have a valid file range, so we can return the file based address by
// adding the file base address to our offset // adding the file base address to our offset
return sect_file_addr + m_offset; return sect_file_addr + m_offset;
} else if (SectionWasDeletedPrivate()) { }
if (SectionWasDeletedPrivate()) {
// Used to have a valid section but it got deleted so the offset doesn't // Used to have a valid section but it got deleted so the offset doesn't
// mean anything without the section // mean anything without the section
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
Context not available.
if (lhs_module == rhs_module) { if (lhs_module == rhs_module) {
// Addresses are in the same module, just compare the file addresses // Addresses are in the same module, just compare the file addresses
return lhs.GetFileAddress() < rhs.GetFileAddress(); return lhs.GetFileAddress() < rhs.GetFileAddress();
} else {
// The addresses are from different modules, just use the module pointer
// value to get consistent ordering
return lhs_module < rhs_module;
} }
// The addresses are from different modules, just use the module pointer
// value to get consistent ordering
return lhs_module < rhs_module;
} }
bool lldb_private::operator>(const Address &lhs, const Address &rhs) { bool lldb_private::operator>(const Address &lhs, const Address &rhs) {
Context not available.
if (lhs_module == rhs_module) { if (lhs_module == rhs_module) {
// Addresses are in the same module, just compare the file addresses // Addresses are in the same module, just compare the file addresses
return lhs.GetFileAddress() > rhs.GetFileAddress(); return lhs.GetFileAddress() > rhs.GetFileAddress();
} else {
// The addresses are from different modules, just use the module pointer
// value to get consistent ordering
return lhs_module > rhs_module;
} }
// The addresses are from different modules, just use the module pointer
// value to get consistent ordering
return lhs_module > rhs_module;
} }
// The operator == checks for exact equality only (same section, same offset) // The operator == checks for exact equality only (same section, same offset)
Context not available.

source/Core/AddressRange.cpp

Context not available.
} }
s->AddressRange(vmaddr, vmaddr + GetByteSize(), addr_size); s->AddressRange(vmaddr, vmaddr + GetByteSize(), addr_size);
return true; return true;
} else if (fallback_style != Address::DumpStyleInvalid) { }
if (fallback_style != Address::DumpStyleInvalid) {
return Dump(s, target, fallback_style, Address::DumpStyleInvalid); return Dump(s, target, fallback_style, Address::DumpStyleInvalid);
} }
Context not available.

source/Core/Broadcaster.cpp

Context not available.
const char *Broadcaster::BroadcasterImpl::GetHijackingListenerName() { const char *Broadcaster::BroadcasterImpl::GetHijackingListenerName() {
if (m_hijacking_listeners.size()) { if (m_hijacking_listeners.size()) {
return m_hijacking_listeners.back()->GetName(); return m_hijacking_listeners.back()->GetName();
} else {
return nullptr;
} }
return nullptr;
} }
void Broadcaster::BroadcasterImpl::RestoreBroadcaster() { void Broadcaster::BroadcasterImpl::RestoreBroadcaster() {
Context not available.
bool BroadcastEventSpec::operator<(const BroadcastEventSpec &rhs) const { bool BroadcastEventSpec::operator<(const BroadcastEventSpec &rhs) const {
if (GetBroadcasterClass() == rhs.GetBroadcasterClass()) { if (GetBroadcasterClass() == rhs.GetBroadcasterClass()) {
return GetEventBits() < rhs.GetEventBits(); return GetEventBits() < rhs.GetEventBits();
} else {
return GetBroadcasterClass() < rhs.GetBroadcasterClass();
} }
return GetBroadcasterClass() < rhs.GetBroadcasterClass();
} }
BroadcastEventSpec &BroadcastEventSpec:: BroadcastEventSpec &BroadcastEventSpec::
Context not available.
iter = find_if(m_event_map.begin(), end_iter, predicate); iter = find_if(m_event_map.begin(), end_iter, predicate);
if (iter == end_iter) { if (iter == end_iter) {
break; break;
} else { }
uint32_t iter_event_bits = (*iter).first.GetEventBits(); uint32_t iter_event_bits = (*iter).first.GetEventBits();
removed_some = true; removed_some = true;
if (event_bits_to_remove != iter_event_bits) { if (event_bits_to_remove != iter_event_bits) {
uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove; uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
to_be_readded.push_back(BroadcastEventSpec( to_be_readded.push_back(
event_spec.GetBroadcasterClass(), new_event_bits)); BroadcastEventSpec(event_spec.GetBroadcasterClass(), new_event_bits));
} }
m_event_map.erase(iter); m_event_map.erase(iter);
}
} }
// Okay now add back the bits that weren't completely removed: // Okay now add back the bits that weren't completely removed:
Context not available.
BroadcastEventSpecMatches(event_spec)); BroadcastEventSpecMatches(event_spec));
if (iter != end_iter) if (iter != end_iter)
return (*iter).second; return (*iter).second;
else
return nullptr; return nullptr;
} }
void BroadcasterManager::RemoveListener(Listener *listener) { void BroadcasterManager::RemoveListener(Listener *listener) {
Context not available.
iter = find_if(m_event_map.begin(), end_iter, predicate); iter = find_if(m_event_map.begin(), end_iter, predicate);
if (iter == end_iter) if (iter == end_iter)
break; break;
else
m_event_map.erase(iter); m_event_map.erase(iter);
} }
} }
Context not available.
iter = find_if(m_event_map.begin(), end_iter, predicate); iter = find_if(m_event_map.begin(), end_iter, predicate);
if (iter == end_iter) if (iter == end_iter)
break; break;
else
m_event_map.erase(iter); m_event_map.erase(iter);
} }
} }
Context not available.

source/Core/Debugger.cpp

Context not available.
debugger->LoadPlugin(plugin_file_spec, plugin_load_error); debugger->LoadPlugin(plugin_file_spec, plugin_load_error);
return FileSystem::eEnumerateDirectoryResultNext; return FileSystem::eEnumerateDirectoryResultNext;
} else if (ft == fs::file_type::directory_file || }
ft == fs::file_type::symlink_file || if (ft == fs::file_type::directory_file ||
ft == fs::file_type::type_unknown) { ft == fs::file_type::symlink_file || ft == fs::file_type::type_unknown) {
// Try and recurse into anything that a directory or symbolic link. We must // Try and recurse into anything that a directory or symbolic link. We must
// also do this for unknown as sometimes the directory enumeration might be // also do this for unknown as sometimes the directory enumeration might be
// enumerating a file system that doesn't have correct file type // enumerating a file system that doesn't have correct file type
Context not available.

source/Core/Disassembler.cpp

Context not available.
const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS; const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
return DecodeInstructions(range.GetBaseAddress(), data, 0, UINT32_MAX, return DecodeInstructions(range.GetBaseAddress(), data, 0, UINT32_MAX,
false, data_from_file); false, data_from_file);
} else if (error_strm_ptr) { }
if (error_strm_ptr) {
const char *error_cstr = error.AsCString(); const char *error_cstr = error.AsCString();
if (error_cstr) { if (error_cstr) {
error_strm_ptr->Printf("error: %s\n", error_cstr); error_strm_ptr->Printf("error: %s\n", error_cstr);
Context not available.

source/Core/DumpDataExtractor.cpp

Context not available.
} }
result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array)); result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array));
return true; return true;
} else if (byte_order == lldb::eByteOrderBig) { }
if (byte_order == lldb::eByteOrderBig) {
lldb::offset_t be_offset = *offset_ptr + byte_size; lldb::offset_t be_offset = *offset_ptr + byte_size;
lldb::offset_t temp_offset; lldb::offset_t temp_offset;
while (bytes_left > 0) { while (bytes_left > 0) {
Context not available.

source/Core/DynamicLoader.cpp

Context not available.
m_process->ReadUnsignedIntegerFromMemory(addr, size_in_bytes, 0, error); m_process->ReadUnsignedIntegerFromMemory(addr, size_in_bytes, 0, error);
if (error.Fail()) if (error.Fail())
return -1; return -1;
else
return (int64_t)value; return (int64_t)value;
} }
addr_t DynamicLoader::ReadPointer(addr_t addr) { addr_t DynamicLoader::ReadPointer(addr_t addr) {
Context not available.
addr_t value = m_process->ReadPointerFromMemory(addr, error); addr_t value = m_process->ReadPointerFromMemory(addr, error);
if (error.Fail()) if (error.Fail())
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
else
return value; return value;
} }
void DynamicLoader::LoadOperatingSystemPlugin(bool flush) void DynamicLoader::LoadOperatingSystemPlugin(bool flush)
Context not available.

source/Core/Event.cpp

Context not available.
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr); auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
if (event_data) if (event_data)
return event_data->GetProcess(); return event_data->GetProcess();
else
return ProcessSP(); return ProcessSP();
} }
StructuredData::ObjectSP StructuredData::ObjectSP
Context not available.
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr); auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
if (event_data) if (event_data)
return event_data->GetObject(); return event_data->GetObject();
else
return StructuredData::ObjectSP(); return StructuredData::ObjectSP();
} }
lldb::StructuredDataPluginSP lldb::StructuredDataPluginSP
Context not available.
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr); auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
if (event_data) if (event_data)
return event_data->GetStructuredDataPlugin(); return event_data->GetStructuredDataPlugin();
else
return StructuredDataPluginSP(); return StructuredDataPluginSP();
} }
const ConstString &EventDataStructuredData::GetFlavorString() { const ConstString &EventDataStructuredData::GetFlavorString() {
Context not available.

source/Core/FormatEntity.cpp

Context not available.
error.Success()) { error.Success()) {
s.Printf("%s", script_output.c_str()); s.Printf("%s", script_output.c_str());
return true; return true;
} else {
s.Printf("<error: %s>", error.AsCString());
} }
s.Printf("<error: %s>", error.AsCString());
} }
} }
return false; return false;
Context not available.
func_file_addr - addr_file_addr); func_file_addr - addr_file_addr);
} }
return true; return true;
} else {
Target *target = Target::GetTargetFromContexts(exe_ctx, sc);
if (target) {
addr_t func_load_addr = func_addr.GetLoadAddress(target);
addr_t addr_load_addr = format_addr.GetLoadAddress(target);
if (addr_load_addr > func_load_addr ||
(addr_load_addr == func_load_addr && print_zero_offsets)) {
s.Printf("%s+%s%" PRIu64, addr_offset_padding, addr_offset_padding,
addr_load_addr - func_load_addr);
} else if (addr_load_addr < func_load_addr) {
s.Printf("%s-%s%" PRIu64, addr_offset_padding, addr_offset_padding,
func_load_addr - addr_load_addr);
}
return true;
}
} }
Target *target = Target::GetTargetFromContexts(exe_ctx, sc);
if (target) {
addr_t func_load_addr = func_addr.GetLoadAddress(target);
addr_t addr_load_addr = format_addr.GetLoadAddress(target);
if (addr_load_addr > func_load_addr ||
(addr_load_addr == func_load_addr && print_zero_offsets)) {
s.Printf("%s+%s%" PRIu64, addr_offset_padding, addr_offset_padding,
addr_load_addr - func_load_addr);
} else if (addr_load_addr < func_load_addr) {
s.Printf("%s-%s%" PRIu64, addr_offset_padding, addr_offset_padding,
func_load_addr - addr_load_addr);
}
return true;
}
} }
} }
return false; return false;
Context not available.
if (log) if (log)
log->Printf("[ScanBracketedRange] no bracketed range, skipping entirely"); log->Printf("[ScanBracketedRange] no bracketed range, skipping entirely");
return false; return false;
} else { }
var_name_final_if_array_range = subpath.data() + open_bracket_index; var_name_final_if_array_range = subpath.data() + open_bracket_index;
if (close_bracket_index - open_bracket_index == 1) { if (close_bracket_index - open_bracket_index == 1) {
if (log) if (log)
log->Printf( log->Printf(
"[ScanBracketedRange] '[]' detected.. going from 0 to end of data"); "[ScanBracketedRange] '[]' detected.. going from 0 to end of data");
index_lower = 0; index_lower = 0;
} else { } else {
const size_t separator_index = subpath.find('-', open_bracket_index + 1); const size_t separator_index = subpath.find('-', open_bracket_index + 1);
Context not available.
index_higher = temp; index_higher = temp;
} }
} }
}
return true; return true;
} }
static bool DumpFile(Stream &s, const FileSpec &file, FileKind file_kind) { static bool DumpFile(Stream &s, const FileSpec &file, FileKind file_kind) {
Context not available.
" final_value_type %d", " final_value_type %d",
reason_to_stop, final_value_type); reason_to_stop, final_value_type);
return false; return false;
} else {
if (log)
log->Printf("[Debugger::FormatPrompt] ALL RIGHT: why stopping = %d,"
" final_value_type %d",
reason_to_stop, final_value_type);
target = target
->GetQualifiedRepresentationIfAvailable(
target->GetDynamicValueType(), true)
.get();
} }
if (log)
log->Printf("[Debugger::FormatPrompt] ALL RIGHT: why stopping = %d,"
" final_value_type %d",
reason_to_stop, final_value_type);
target = target
->GetQualifiedRepresentationIfAvailable(
target->GetDynamicValueType(), true)
.get();
} }
is_array_range = is_array_range =
Context not available.
if (success) if (success)
s << str_temp.GetString(); s << str_temp.GetString();
return true; return true;
} else {
if (was_plain_var) // if ${var}
{
s << target->GetTypeName() << " @ " << target->GetLocationAsCString();
} else if (is_pointer) // if pointer, value is the address stored
{
target->DumpPrintableRepresentation(
s, val_obj_display, custom_format,
ValueObject::PrintableRepresentationSpecialCases::eDisable);
}
return true;
} }
if (was_plain_var) // if ${var}
{
s << target->GetTypeName() << " @ " << target->GetLocationAsCString();
} else if (is_pointer) // if pointer, value is the address stored
{
target->DumpPrintableRepresentation(
s, val_obj_display, custom_format,
ValueObject::PrintableRepresentationSpecialCases::eDisable);
}
return true;
} }
// if directly trying to print ${var}, and this is an aggregate, display a // if directly trying to print ${var}, and this is an aggregate, display a
Context not available.
log->Printf("[Debugger::FormatPrompt] dumping ordinary printable output"); log->Printf("[Debugger::FormatPrompt] dumping ordinary printable output");
return target->DumpPrintableRepresentation(s, val_obj_display, return target->DumpPrintableRepresentation(s, val_obj_display,
custom_format); custom_format);
} else { }
if (log) if (log)
log->Printf("[Debugger::FormatPrompt] checking if I can handle as array"); log->Printf("[Debugger::FormatPrompt] checking if I can handle as array");
if (!is_array && !is_pointer) if (!is_array && !is_pointer)
return false; return false;
if (log) if (log)
log->Printf("[Debugger::FormatPrompt] handle as array"); log->Printf("[Debugger::FormatPrompt] handle as array");
StreamString special_directions_stream; StreamString special_directions_stream;
llvm::StringRef special_directions; llvm::StringRef special_directions;
if (close_bracket_index != llvm::StringRef::npos && if (close_bracket_index != llvm::StringRef::npos &&
subpath.size() > close_bracket_index) { subpath.size() > close_bracket_index) {
ConstString additional_data(subpath.drop_front(close_bracket_index + 1)); ConstString additional_data(subpath.drop_front(close_bracket_index + 1));
special_directions_stream.Printf("${%svar%s", do_deref_pointer ? "*" : "", special_directions_stream.Printf("${%svar%s", do_deref_pointer ? "*" : "",
additional_data.GetCString()); additional_data.GetCString());
if (entry.fmt != eFormatDefault) { if (entry.fmt != eFormatDefault) {
const char format_char = const char format_char = FormatManager::GetFormatAsFormatChar(entry.fmt);
FormatManager::GetFormatAsFormatChar(entry.fmt); if (format_char != '\0')
if (format_char != '\0') special_directions_stream.Printf("%%%c", format_char);
special_directions_stream.Printf("%%%c", format_char); else {
else { const char *format_cstr = FormatManager::GetFormatAsCString(entry.fmt);
const char *format_cstr = special_directions_stream.Printf("%%%s", format_cstr);
FormatManager::GetFormatAsCString(entry.fmt);
special_directions_stream.Printf("%%%s", format_cstr);
}
} else if (entry.number != 0) {
const char style_char = ConvertValueObjectStyleToChar(
(ValueObject::ValueObjectRepresentationStyle)entry.number);
if (style_char)
special_directions_stream.Printf("%%%c", style_char);
} }
special_directions_stream.PutChar('}'); } else if (entry.number != 0) {
special_directions = const char style_char = ConvertValueObjectStyleToChar(
llvm::StringRef(special_directions_stream.GetString()); (ValueObject::ValueObjectRepresentationStyle)entry.number);
if (style_char)
special_directions_stream.Printf("%%%c", style_char);
}
special_directions_stream.PutChar('}');
special_directions = llvm::StringRef(special_directions_stream.GetString());
} }
// let us display items index_lower thru index_higher of this array // let us display items index_lower thru index_higher of this array
Context not available.
} }
s.PutChar(']'); s.PutChar(']');
return success; return success;
}
} }
static bool DumpRegister(Stream &s, StackFrame *frame, const char *reg_name, static bool DumpRegister(Stream &s, StackFrame *frame, const char *reg_name,
Context not available.
token_format = entry.printf_format.c_str(); token_format = entry.printf_format.c_str();
s.Printf(token_format, value->GetAsInteger()->GetValue()); s.Printf(token_format, value->GetAsInteger()->GetValue());
return true; return true;
} else if (value->GetType() == eStructuredDataTypeFloat) { }
if (value->GetType() == eStructuredDataTypeFloat) {
s.Printf("%f", value->GetAsFloat()->GetValue()); s.Printf("%f", value->GetAsFloat()->GetValue());
return true; return true;
} else if (value->GetType() == eStructuredDataTypeString) { } else if (value->GetType() == eStructuredDataTypeString) {
Context not available.
if (sc->function) { if (sc->function) {
s.Printf("function{0x%8.8" PRIx64 "}", sc->function->GetID()); s.Printf("function{0x%8.8" PRIx64 "}", sc->function->GetID());
return true; return true;
} else if (sc->symbol) { }
if (sc->symbol) {
s.Printf("symbol[%u]", sc->symbol->GetID()); s.Printf("symbol[%u]", sc->symbol->GetID());
return true; return true;
} }
Context not available.
if (language_plugin_handled) { if (language_plugin_handled) {
s << ss.GetString(); s << ss.GetString();
return true; return true;
} else { }
const char *name = nullptr; const char *name = nullptr;
if (sc->function) if (sc->function)
name = sc->function->GetName().AsCString(nullptr); name = sc->function->GetName().AsCString(nullptr);
else if (sc->symbol) else if (sc->symbol)
name = sc->symbol->GetName().AsCString(nullptr); name = sc->symbol->GetName().AsCString(nullptr);
if (name) { if (name) {
s.PutCString(name); s.PutCString(name);
if (sc->block) { if (sc->block) {
Block *inline_block = sc->block->GetContainingInlinedBlock(); Block *inline_block = sc->block->GetContainingInlinedBlock();
if (inline_block) { if (inline_block) {
const InlineFunctionInfo *inline_info = const InlineFunctionInfo *inline_info =
sc->block->GetInlinedFunctionInfo(); sc->block->GetInlinedFunctionInfo();
if (inline_info) { if (inline_info) {
s.PutCString(" [inlined] "); s.PutCString(" [inlined] ");
inline_info->GetName(sc->function->GetLanguage()).Dump(&s); inline_info->GetName(sc->function->GetLanguage()).Dump(&s);
}
} }
} }
return true;
} }
} return true;
}
} }
return false; return false;
Context not available.
if (language_plugin_handled) { if (language_plugin_handled) {
s << ss.GetString(); s << ss.GetString();
return true; return true;
} else {
ConstString name;
if (sc->function)
name = sc->function->GetNameNoArguments();
else if (sc->symbol)
name = sc->symbol->GetNameNoArguments();
if (name) {
s.PutCString(name.GetCString());
return true;
}
} }
ConstString name;
if (sc->function)
name = sc->function->GetNameNoArguments();
else if (sc->symbol)
name = sc->symbol->GetNameNoArguments();
if (name) {
s.PutCString(name.GetCString());
return true;
}
} }
return false; return false;
Context not available.
if (language_plugin_handled) { if (language_plugin_handled) {
s << ss.GetString(); s << ss.GetString();
return true; return true;
} else { }
// Print the function name with arguments in it // Print the function name with arguments in it
if (sc->function) { if (sc->function) {
ExecutionContextScope *exe_scope = ExecutionContextScope *exe_scope =
exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr; exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
const char *cstr = sc->function->GetName().AsCString(nullptr); const char *cstr = sc->function->GetName().AsCString(nullptr);
if (cstr) { if (cstr) {
const InlineFunctionInfo *inline_info = nullptr; const InlineFunctionInfo *inline_info = nullptr;
VariableListSP variable_list_sp; VariableListSP variable_list_sp;
bool get_function_vars = true; bool get_function_vars = true;
if (sc->block) { if (sc->block) {
Block *inline_block = sc->block->GetContainingInlinedBlock(); Block *inline_block = sc->block->GetContainingInlinedBlock();
if (inline_block) {
get_function_vars = false;
inline_info = sc->block->GetInlinedFunctionInfo();
if (inline_info)
variable_list_sp = inline_block->GetBlockVariableList(true);
}
}
if (get_function_vars) { if (inline_block) {
variable_list_sp = get_function_vars = false;
sc->function->GetBlock(true).GetBlockVariableList(true); inline_info = sc->block->GetInlinedFunctionInfo();
if (inline_info)
variable_list_sp = inline_block->GetBlockVariableList(true);
} }
}
if (inline_info) { if (get_function_vars) {
s.PutCString(cstr); variable_list_sp =
s.PutCString(" [inlined] "); sc->function->GetBlock(true).GetBlockVariableList(true);
cstr = }
inline_info->GetName(sc->function->GetLanguage()).GetCString();
}
VariableList args; if (inline_info) {
if (variable_list_sp) s.PutCString(cstr);
variable_list_sp->AppendVariablesWithScope( s.PutCString(" [inlined] ");
eValueTypeVariableArgument, args); cstr = inline_info->GetName(sc->function->GetLanguage()).GetCString();
if (args.GetSize() > 0) { }
const char *open_paren = strchr(cstr, '(');
const char *close_paren = nullptr;
const char *generic = strchr(cstr, '<');
// if before the arguments list begins there is a template sign
// then scan to the end of the generic args before you try to find
// the arguments list
if (generic && open_paren && generic < open_paren) {
int generic_depth = 1;
++generic;
for (; *generic && generic_depth > 0; generic++) {
if (*generic == '<')
generic_depth++;
if (*generic == '>')
generic_depth--;
}
if (*generic)
open_paren = strchr(generic, '(');
else
open_paren = nullptr;
}
if (open_paren) {
if (IsToken(open_paren, "(anonymous namespace)")) {
open_paren =
strchr(open_paren + strlen("(anonymous namespace)"), '(');
if (open_paren)
close_paren = strchr(open_paren, ')');
} else
close_paren = strchr(open_paren, ')');
}
if (open_paren) VariableList args;
s.Write(cstr, open_paren - cstr + 1); if (variable_list_sp)
else { variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument,
s.PutCString(cstr); args);
s.PutChar('('); if (args.GetSize() > 0) {
const char *open_paren = strchr(cstr, '(');
const char *close_paren = nullptr;
const char *generic = strchr(cstr, '<');
// if before the arguments list begins there is a template sign
// then scan to the end of the generic args before you try to find
// the arguments list
if (generic && open_paren && generic < open_paren) {
int generic_depth = 1;
++generic;
for (; *generic && generic_depth > 0; generic++) {
if (*generic == '<')
generic_depth++;
if (*generic == '>')
generic_depth--;
} }
const size_t num_args = args.GetSize(); if (*generic)
for (size_t arg_idx = 0; arg_idx < num_args; ++arg_idx) { open_paren = strchr(generic, '(');
std::string buffer; else
open_paren = nullptr;
VariableSP var_sp(args.GetVariableAtIndex(arg_idx)); }
ValueObjectSP var_value_sp( if (open_paren) {
ValueObjectVariable::Create(exe_scope, var_sp)); if (IsToken(open_paren, "(anonymous namespace)")) {
StreamString ss; open_paren =
llvm::StringRef var_representation; strchr(open_paren + strlen("(anonymous namespace)"), '(');
const char *var_name = var_value_sp->GetName().GetCString(); if (open_paren)
if (var_value_sp->GetCompilerType().IsValid()) { close_paren = strchr(open_paren, ')');
if (var_value_sp && exe_scope->CalculateTarget()) } else
var_value_sp = close_paren = strchr(open_paren, ')');
var_value_sp->GetQualifiedRepresentationIfAvailable( }
exe_scope->CalculateTarget()
->TargetProperties::GetPreferDynamicValue(),
exe_scope->CalculateTarget()
->TargetProperties::GetEnableSyntheticValue());
if (var_value_sp->GetCompilerType().IsAggregateType() &&
DataVisualization::ShouldPrintAsOneLiner(*var_value_sp)) {
static StringSummaryFormat format(
TypeSummaryImpl::Flags()
.SetHideItemNames(false)
.SetShowMembersOneLiner(true),
"");
format.FormatObject(var_value_sp.get(), buffer,
TypeSummaryOptions());
var_representation = buffer;
} else
var_value_sp->DumpPrintableRepresentation(
ss, ValueObject::ValueObjectRepresentationStyle::
eValueObjectRepresentationStyleSummary,
eFormatDefault,
ValueObject::PrintableRepresentationSpecialCases::eAllow,
false);
}
if (!ss.GetString().empty()) if (open_paren)
var_representation = ss.GetString(); s.Write(cstr, open_paren - cstr + 1);
if (arg_idx > 0) else {
s.PutCString(", "); s.PutCString(cstr);
if (var_value_sp->GetError().Success()) { s.PutChar('(');
if (!var_representation.empty()) }
s.Printf("%s=%s", var_name, var_representation.str().c_str()); const size_t num_args = args.GetSize();
else for (size_t arg_idx = 0; arg_idx < num_args; ++arg_idx) {
s.Printf("%s=%s at %s", var_name, std::string buffer;
var_value_sp->GetTypeName().GetCString(),
var_value_sp->GetLocationAsCString()); VariableSP var_sp(args.GetVariableAtIndex(arg_idx));
ValueObjectSP var_value_sp(
ValueObjectVariable::Create(exe_scope, var_sp));
StreamString ss;
llvm::StringRef var_representation;
const char *var_name = var_value_sp->GetName().GetCString();
if (var_value_sp->GetCompilerType().IsValid()) {
if (var_value_sp && exe_scope->CalculateTarget())
var_value_sp =
var_value_sp->GetQualifiedRepresentationIfAvailable(
exe_scope->CalculateTarget()
->TargetProperties::GetPreferDynamicValue(),
exe_scope->CalculateTarget()
->TargetProperties::GetEnableSyntheticValue());
if (var_value_sp->GetCompilerType().IsAggregateType() &&
DataVisualization::ShouldPrintAsOneLiner(*var_value_sp)) {
static StringSummaryFormat format(
TypeSummaryImpl::Flags()
.SetHideItemNames(false)
.SetShowMembersOneLiner(true),
"");
format.FormatObject(var_value_sp.get(), buffer,
TypeSummaryOptions());
var_representation = buffer;
} else } else
s.Printf("%s=<unavailable>", var_name); var_value_sp->DumpPrintableRepresentation(
ss,
ValueObject::ValueObjectRepresentationStyle::
eValueObjectRepresentationStyleSummary,
eFormatDefault,
ValueObject::PrintableRepresentationSpecialCases::eAllow,
false);
} }
if (close_paren) if (!ss.GetString().empty())
s.PutCString(close_paren); var_representation = ss.GetString();
else if (arg_idx > 0)
s.PutChar(')'); s.PutCString(", ");
if (var_value_sp->GetError().Success()) {
} else { if (!var_representation.empty())
s.PutCString(cstr); s.Printf("%s=%s", var_name, var_representation.str().c_str());
else
s.Printf("%s=%s at %s", var_name,
var_value_sp->GetTypeName().GetCString(),
var_value_sp->GetLocationAsCString());
} else
s.Printf("%s=<unavailable>", var_name);
} }
return true;
if (close_paren)
s.PutCString(close_paren);
else
s.PutChar(')');
} else {
s.PutCString(cstr);
} }
return true;
}
} else if (sc->symbol) { } else if (sc->symbol) {
const char *cstr = sc->symbol->GetName().AsCString(nullptr); const char *cstr = sc->symbol->GetName().AsCString(nullptr);
if (cstr) { if (cstr) {
Context not available.
return true; return true;
} }
} }
}
} }
return false; return false;
Context not available.
else else
remainder = llvm::StringRef(); // Exact match remainder = llvm::StringRef(); // Exact match
return entry_def; return entry_def;
} else {
if (entry_def->children) {
return FindEntry(p.second, entry_def, remainder);
} else {
remainder = p.second;
return entry_def;
}
} }
if (entry_def->children) {
return FindEntry(p.second, entry_def, remainder);
}
remainder = p.second;
return entry_def;
} }
} }
remainder = format_str; remainder = format_str;
Context not available.
if (variable_name.empty() || variable_name.equals(".fullpath")) { if (variable_name.empty() || variable_name.equals(".fullpath")) {
file_spec.Dump(&s); file_spec.Dump(&s);
return true; return true;
} else if (variable_name.equals(".basename")) { }
if (variable_name.equals(".basename")) {
s.PutCString(file_spec.GetFilename().AsCString("")); s.PutCString(file_spec.GetFilename().AsCString(""));
return true; return true;
} else if (variable_name.equals(".dirname")) { } else if (variable_name.equals(".dirname")) {
Context not available.

source/Core/IOHandler.cpp

Context not available.
#ifndef LLDB_DISABLE_LIBEDIT #ifndef LLDB_DISABLE_LIBEDIT
if (m_editline_ap) { if (m_editline_ap) {
return m_editline_ap->GetLine(line, interrupted); return m_editline_ap->GetLine(line, interrupted);
} else { }
#endif #endif
line.clear(); line.clear();
FILE *in = GetInputFILE(); FILE *in = GetInputFILE();
if (in) { if (in) {
if (GetIsInteractive()) { if (GetIsInteractive()) {
const char *prompt = nullptr; const char *prompt = nullptr;
if (m_multi_line && m_curr_line_idx > 0) if (m_multi_line && m_curr_line_idx > 0)
prompt = GetContinuationPrompt(); prompt = GetContinuationPrompt();
if (prompt == nullptr) if (prompt == nullptr)
prompt = GetPrompt(); prompt = GetPrompt();
if (prompt && prompt[0]) { if (prompt && prompt[0]) {
FILE *out = GetOutputFILE(); FILE *out = GetOutputFILE();
if (out) { if (out) {
::fprintf(out, "%s", prompt); ::fprintf(out, "%s", prompt);
::fflush(out); ::fflush(out);
}
} }
} }
char buffer[256]; }
bool done = false; char buffer[256];
bool got_line = false; bool done = false;
m_editing = true; bool got_line = false;
while (!done) { m_editing = true;
if (fgets(buffer, sizeof(buffer), in) == nullptr) { while (!done) {
const int saved_errno = errno; if (fgets(buffer, sizeof(buffer), in) == nullptr) {
if (feof(in)) const int saved_errno = errno;
done = true; if (feof(in))
else if (ferror(in)) { done = true;
if (saved_errno != EINTR) else if (ferror(in)) {
done = true; if (saved_errno != EINTR)
}
} else {
got_line = true;
size_t buffer_len = strlen(buffer);
assert(buffer[buffer_len] == '\0');
char last_char = buffer[buffer_len - 1];
if (last_char == '\r' || last_char == '\n') {
done = true; done = true;
// Strip trailing newlines }
while (last_char == '\r' || last_char == '\n') { } else {
--buffer_len; got_line = true;
if (buffer_len == 0) size_t buffer_len = strlen(buffer);
break; assert(buffer[buffer_len] == '\0');
last_char = buffer[buffer_len - 1]; char last_char = buffer[buffer_len - 1];
} if (last_char == '\r' || last_char == '\n') {
done = true;
// Strip trailing newlines
while (last_char == '\r' || last_char == '\n') {
--buffer_len;
if (buffer_len == 0)
break;
last_char = buffer[buffer_len - 1];
} }
line.append(buffer, buffer_len);
} }
line.append(buffer, buffer_len);
} }
m_editing = false;
// We might have gotten a newline on a line by itself make sure to return
// true in this case.
return got_line;
} else {
// No more input file, we are done...
SetIsDone(true);
} }
return false; m_editing = false;
#ifndef LLDB_DISABLE_LIBEDIT // We might have gotten a newline on a line by itself make sure to return
// true in this case.
return got_line;
} }
// No more input file, we are done...
SetIsDone(true);
return false;
#ifndef LLDB_DISABLE_LIBEDIT
#endif #endif
} }
Context not available.
#ifndef LLDB_DISABLE_LIBEDIT #ifndef LLDB_DISABLE_LIBEDIT
if (m_editline_ap) { if (m_editline_ap) {
return m_editline_ap->GetPrompt(); return m_editline_ap->GetPrompt();
} else { }
#endif #endif
if (m_prompt.empty()) if (m_prompt.empty())
return nullptr; return nullptr;
#ifndef LLDB_DISABLE_LIBEDIT #ifndef LLDB_DISABLE_LIBEDIT
}
#endif #endif
return m_prompt.c_str(); return m_prompt.c_str();
} }
Context not available.
#ifndef LLDB_DISABLE_LIBEDIT #ifndef LLDB_DISABLE_LIBEDIT
if (m_editline_ap) { if (m_editline_ap) {
return m_editline_ap->GetLines(m_base_line_number, lines, interrupted); return m_editline_ap->GetLines(m_base_line_number, lines, interrupted);
} else { }
#endif #endif
bool done = false; bool done = false;
Status error; Status error;
while (!done) { while (!done) {
// Show line numbers if we are asked to // Show line numbers if we are asked to
std::string line; std::string line;
if (m_base_line_number > 0 && GetIsInteractive()) { if (m_base_line_number > 0 && GetIsInteractive()) {
FILE *out = GetOutputFILE(); FILE *out = GetOutputFILE();
if (out) if (out)
::fprintf(out, "%u%s", m_base_line_number + (uint32_t)lines.GetSize(), ::fprintf(out, "%u%s", m_base_line_number + (uint32_t)lines.GetSize(),
GetPrompt() == nullptr ? " " : ""); GetPrompt() == nullptr ? " " : "");
} }
m_curr_line_idx = lines.GetSize(); m_curr_line_idx = lines.GetSize();
bool interrupted = false; bool interrupted = false;
if (GetLine(line, interrupted) && !interrupted) { if (GetLine(line, interrupted) && !interrupted) {
lines.AppendString(line); lines.AppendString(line);
done = m_delegate.IOHandlerIsInputComplete(*this, lines); done = m_delegate.IOHandlerIsInputComplete(*this, lines);
} else { } else {
done = true; done = true;
}
} }
success = lines.GetSize() > 0;
#ifndef LLDB_DISABLE_LIBEDIT
} }
success = lines.GetSize() > 0;
#ifndef LLDB_DISABLE_LIBEDIT
#endif #endif
return success; return success;
} }
Context not available.
bool IsActive() const { bool IsActive() const {
if (m_parent) if (m_parent)
return m_parent->GetActiveWindow().get() == this; return m_parent->GetActiveWindow().get() == this;
else
return true; // Top level window is always active return true; // Top level window is always active
} }
void SelectNextWindowAsActive() { void SelectNextWindowAsActive() {
Context not available.
m_selected = 0; m_selected = 0;
if (m_submenus[m_selected]->GetType() == Type::Separator) if (m_submenus[m_selected]->GetType() == Type::Separator)
continue; continue;
else
break; break;
} }
return eKeyHandled; return eKeyHandled;
} }
Context not available.
m_selected = num_submenus - 1; m_selected = num_submenus - 1;
if (m_submenus[m_selected]->GetType() == Type::Separator) if (m_submenus[m_selected]->GetType() == Type::Separator)
continue; continue;
else
break; break;
} }
return eKeyHandled; return eKeyHandled;
} }
Context not available.
for (auto &row : rows) { for (auto &row : rows) {
if (row_index == 0) if (row_index == 0)
return &row; return &row;
else {
--row_index; --row_index;
auto &children = row.GetChildren(); auto &children = row.GetChildren();
if (row.expanded && !children.empty()) { if (row.expanded && !children.empty()) {
Row *result = GetRowForRowIndexImpl(children, row_index); Row *result = GetRowForRowIndexImpl(children, row_index);
if (result) if (result)
return result; return result;
} }
}
} }
return nullptr; return nullptr;
} }
Context not available.
Process *process = exe_ctx.GetProcessPtr(); Process *process = exe_ctx.GetProcessPtr();
if (process && process->IsAlive()) if (process && process->IsAlive())
return true; // Don't do any updating if we are running return true; // Don't do any updating if we are running
else {
// Update the values with an empty list if there is no process or the // Update the values with an empty list if there is no process or the
// process isn't alive anymore // process isn't alive anymore
SetValues(value_list); SetValues(value_list);
}
} }
return ValueObjectListDelegate::WindowDelegateDraw(window, force); return ValueObjectListDelegate::WindowDelegateDraw(window, force);
} }
Context not available.

source/Core/Listener.cpp

Context not available.
num_broadcaster_names, event_type_mask, event_sp, num_broadcaster_names, event_type_mask, event_sp,
true)) { true)) {
return true; return true;
} else { }
std::cv_status result = std::cv_status::no_timeout; std::cv_status result = std::cv_status::no_timeout;
if (!timeout) if (!timeout)
m_events_condition.wait(lock); m_events_condition.wait(lock);
else else
result = m_events_condition.wait_for(lock, *timeout); result = m_events_condition.wait_for(lock, *timeout);
if (result == std::cv_status::timeout) { if (result == std::cv_status::timeout) {
log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS); log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
if (log) if (log)
log->Printf("%p Listener::GetEventInternal() timed out for %s", log->Printf("%p Listener::GetEventInternal() timed out for %s",
static_cast<void *>(this), m_name.c_str()); static_cast<void *>(this), m_name.c_str());
return false; return false;
} else if (result != std::cv_status::no_timeout) { }
log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS); if (result != std::cv_status::no_timeout) {
if (log) log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
log->Printf("%p Listener::GetEventInternal() unknown error for %s", if (log)
static_cast<void *>(this), m_name.c_str()); log->Printf("%p Listener::GetEventInternal() unknown error for %s",
return false; static_cast<void *>(this), m_name.c_str());
} return false;
} }
} }
Context not available.

source/Core/Mangled.cpp

Context not available.
if (m_demangled.IsEmpty()) { if (m_demangled.IsEmpty()) {
// Cannot demangle it, so don't try parsing. // Cannot demangle it, so don't try parsing.
return false; return false;
} else {
// Demangled successfully, we can try and parse it with
// CPlusPlusLanguage::MethodName.
return context.FromCxxMethodName(m_demangled);
} }
// Demangled successfully, we can try and parse it with
// CPlusPlusLanguage::MethodName.
return context.FromCxxMethodName(m_demangled);
} }
} }
llvm_unreachable("Fully covered switch above!"); llvm_unreachable("Fully covered switch above!");
Context not available.
const char *mangled_name = mangled.GetCString(); const char *mangled_name = mangled.GetCString();
if (CPlusPlusLanguage::IsCPPMangledName(mangled_name)) if (CPlusPlusLanguage::IsCPPMangledName(mangled_name))
return lldb::eLanguageTypeC_plus_plus; return lldb::eLanguageTypeC_plus_plus;
else if (ObjCLanguage::IsPossibleObjCMethodName(mangled_name)) if (ObjCLanguage::IsPossibleObjCMethodName(mangled_name))
return lldb::eLanguageTypeObjC; return lldb::eLanguageTypeObjC;
} }
} else { } else {
Context not available.

source/Core/Module.cpp

Context not available.
bool Module::IsExecutable() { bool Module::IsExecutable() {
if (GetObjectFile() == nullptr) if (GetObjectFile() == nullptr)
return false; return false;
else
return GetObjectFile()->IsExecutable(); return GetObjectFile()->IsExecutable();
} }
bool Module::IsLoadedInTarget(Target *target) { bool Module::IsLoadedInTarget(Target *target) {
Context not available.
if (object_file != nullptr) { if (object_file != nullptr) {
changed = object_file->SetLoadAddress(target, value, value_is_offset); changed = object_file->SetLoadAddress(target, value, value_is_offset);
return true; return true;
} else {
changed = false;
} }
changed = false;
return false; return false;
} }
Context not available.

source/Core/ModuleList.cpp

Context not available.
if (pos->unique()) { if (pos->unique()) {
pos = RemoveImpl(pos); pos = RemoveImpl(pos);
return true; return true;
} else }
return false; return false;
} }
} }
} }
Context not available.

source/Core/PluginManager.cpp

Context not available.
if (PluginIsLoaded(plugin_file_spec)) if (PluginIsLoaded(plugin_file_spec))
return FileSystem::eEnumerateDirectoryResultNext; return FileSystem::eEnumerateDirectoryResultNext;
else {
PluginInfo plugin_info; PluginInfo plugin_info;
std::string pluginLoadError; std::string pluginLoadError;
plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary( plugin_info.library = llvm::sys::DynamicLibrary::getPermanentLibrary(
plugin_file_spec.GetPath().c_str(), &pluginLoadError); plugin_file_spec.GetPath().c_str(), &pluginLoadError);
if (plugin_info.library.isValid()) { if (plugin_info.library.isValid()) {
bool success = false; bool success = false;
plugin_info.plugin_init_callback = CastToFPtr<PluginInitCallback>( plugin_info.plugin_init_callback = CastToFPtr<PluginInitCallback>(
plugin_info.library.getAddressOfSymbol("LLDBPluginInitialize")); plugin_info.library.getAddressOfSymbol("LLDBPluginInitialize"));
if (plugin_info.plugin_init_callback) { if (plugin_info.plugin_init_callback) {
// Call the plug-in "bool LLDBPluginInitialize(void)" function // Call the plug-in "bool LLDBPluginInitialize(void)" function
success = plugin_info.plugin_init_callback(); success = plugin_info.plugin_init_callback();
} }
if (success) { if (success) {
// It is ok for the "LLDBPluginTerminate" symbol to be nullptr // It is ok for the "LLDBPluginTerminate" symbol to be nullptr
plugin_info.plugin_term_callback = CastToFPtr<PluginTermCallback>( plugin_info.plugin_term_callback = CastToFPtr<PluginTermCallback>(
plugin_info.library.getAddressOfSymbol("LLDBPluginTerminate")); plugin_info.library.getAddressOfSymbol("LLDBPluginTerminate"));
} else { } else {
// The initialize function returned FALSE which means the plug-in // The initialize function returned FALSE which means the plug-in
// might not be compatible, or might be too new or too old, or might // might not be compatible, or might be too new or too old, or might
// not want to run on this machine. Set it to a default-constructed // not want to run on this machine. Set it to a default-constructed
// instance to invalidate it. // instance to invalidate it.
plugin_info = PluginInfo(); plugin_info = PluginInfo();
} }
// Regardless of success or failure, cache the plug-in load in our // Regardless of success or failure, cache the plug-in load in our
// plug-in info so we don't try to load it again and again. // plug-in info so we don't try to load it again and again.
SetPluginInfo(plugin_file_spec, plugin_info); SetPluginInfo(plugin_file_spec, plugin_info);
return FileSystem::eEnumerateDirectoryResultNext; return FileSystem::eEnumerateDirectoryResultNext;
} }
}
} }
if (ft == fs::file_type::directory_file || if (ft == fs::file_type::directory_file ||
Context not available.
if (idx < instances.size()) { if (idx < instances.size()) {
iteration_complete = false; iteration_complete = false;
return instances[idx].filter_callback; return instances[idx].filter_callback;
} else {
iteration_complete = true;
} }
iteration_complete = true;
return nullptr; return nullptr;
} }
Context not available.

source/Core/SearchFilter.cpp

Context not available.
DoCUIteration(module_sp, context, searcher); DoCUIteration(module_sp, context, searcher);
if (shouldContinue == Searcher::eCallbackReturnStop) if (shouldContinue == Searcher::eCallbackReturnStop)
return shouldContinue; return shouldContinue;
else if (shouldContinue == Searcher::eCallbackReturnPop) if (shouldContinue == Searcher::eCallbackReturnPop)
continue; continue;
} }
} }
Context not available.
if (shouldContinue == Searcher::eCallbackReturnPop) if (shouldContinue == Searcher::eCallbackReturnPop)
return Searcher::eCallbackReturnContinue; return Searcher::eCallbackReturnContinue;
else if (shouldContinue == Searcher::eCallbackReturnStop) if (shouldContinue == Searcher::eCallbackReturnStop)
return shouldContinue; return shouldContinue;
} else { } else {
// First make sure this compile unit's functions are parsed // First make sure this compile unit's functions are parsed
Context not available.
const FileSpec &module_spec) { const FileSpec &module_spec) {
if (m_target_sp->ModuleIsExcludedForUnconstrainedSearches(module_spec)) if (m_target_sp->ModuleIsExcludedForUnconstrainedSearches(module_spec))
return false; return false;
else
return true; return true;
} }
bool SearchFilterForUnconstrainedSearches::ModulePasses( bool SearchFilterForUnconstrainedSearches::ModulePasses(
const lldb::ModuleSP &module_sp) { const lldb::ModuleSP &module_sp) {
if (!module_sp) if (!module_sp)
return true; return true;
else if (m_target_sp->ModuleIsExcludedForUnconstrainedSearches(module_sp)) if (m_target_sp->ModuleIsExcludedForUnconstrainedSearches(module_sp))
return false; return false;
else else
return true; return true;
Context not available.
m_module_spec_list.FindFileIndex(0, module_sp->GetFileSpec(), false) != m_module_spec_list.FindFileIndex(0, module_sp->GetFileSpec(), false) !=
UINT32_MAX) UINT32_MAX)
return true; return true;
else
return false; return false;
} }
bool SearchFilterByModuleList::ModulePasses(const FileSpec &spec) { bool SearchFilterByModuleList::ModulePasses(const FileSpec &spec) {
Context not available.
if (m_module_spec_list.FindFileIndex(0, spec, true) != UINT32_MAX) if (m_module_spec_list.FindFileIndex(0, spec, true) != UINT32_MAX)
return true; return true;
else
return false; return false;
} }
bool SearchFilterByModuleList::AddressPasses(Address &address) { bool SearchFilterByModuleList::AddressPasses(Address &address) {
Context not available.
if (module_sp) { if (module_sp) {
bool module_passes = SearchFilterByModuleList::ModulePasses(module_sp); bool module_passes = SearchFilterByModuleList::ModulePasses(module_sp);
return module_passes; return module_passes;
} else }
return true; return true;
} else } else
return false; return false;
} }
Context not available.

source/Core/Section.cpp

Context not available.
if (m_file_addr >= file_addr) if (m_file_addr >= file_addr)
return parent_sp->SetFileAddress(m_file_addr - file_addr); return parent_sp->SetFileAddress(m_file_addr - file_addr);
return false; return false;
} else {
// This section has no parent, so m_file_addr is the file base address
m_file_addr = file_addr;
return true;
} }
// This section has no parent, so m_file_addr is the file base address
m_file_addr = file_addr;
return true;
} }
lldb::addr_t Section::GetOffset() const { lldb::addr_t Section::GetOffset() const {
Context not available.
if (a_sect_uid > b_sect_uid) if (a_sect_uid > b_sect_uid)
return 1; return 1;
return 0; return 0;
} else {
// The modules are different, just compare the module pointers
if (a_module_sp.get() < b_module_sp.get())
return -1;
else
return 1; // We already know the modules aren't equal
} }
// The modules are different, just compare the module pointers
if (a_module_sp.get() < b_module_sp.get())
return -1;
return 1; // We already know the modules aren't equal
} }
void Section::Dump(Stream *s, Target *target, uint32_t depth) const { void Section::Dump(Stream *s, Target *target, uint32_t depth) const {
Context not available.
if ((*sect_iter)->GetID() == sect_id) { if ((*sect_iter)->GetID() == sect_id) {
*sect_iter = sect_sp; *sect_iter = sect_sp;
return true; return true;
} else if (depth > 0) { }
if (depth > 0) {
if ((*sect_iter) if ((*sect_iter)
->GetChildren() ->GetChildren()
.ReplaceSection(sect_id, sect_sp, depth - 1)) .ReplaceSection(sect_id, sect_sp, depth - 1))
Context not available.
if ((*sect_iter)->GetID() == sect_id) { if ((*sect_iter)->GetID() == sect_id) {
sect_sp = *sect_iter; sect_sp = *sect_iter;
break; break;
} else {
sect_sp = (*sect_iter)->GetChildren().FindSectionByID(sect_id);
} }
sect_sp = (*sect_iter)->GetChildren().FindSectionByID(sect_id);
} }
} }
return sect_sp; return sect_sp;
Context not available.
if (m_sections[idx]->GetType() == sect_type) { if (m_sections[idx]->GetType() == sect_type) {
sect_sp = m_sections[idx]; sect_sp = m_sections[idx];
break; break;
} else if (check_children) { }
if (check_children) {
sect_sp = m_sections[idx]->GetChildren().FindSectionByType( sect_sp = m_sections[idx]->GetChildren().FindSectionByType(
sect_type, check_children, 0); sect_type, check_children, 0);
if (sect_sp) if (sect_sp)
Context not available.

source/Core/SourceManager.cpp

Context not available.
if (m_last_file_sp) { if (m_last_file_sp) {
m_last_line = line; m_last_line = line;
return true; return true;
} else {
m_last_file_sp = old_file_sp;
return false;
} }
m_last_file_sp = old_file_sp;
return false;
} }
bool SourceManager::GetDefaultFileAndLine(FileSpec &file_spec, uint32_t &line) { bool SourceManager::GetDefaultFileAndLine(FileSpec &file_spec, uint32_t &line) {
Context not available.
file_spec = m_last_file_sp->GetFileSpec(); file_spec = m_last_file_sp->GetFileSpec();
line = m_last_line; line = m_last_line;
return true; return true;
} else if (!m_default_set) { }
if (!m_default_set) {
TargetSP target_sp(m_target_wp.lock()); TargetSP target_sp(m_target_wp.lock());
if (target_sp) { if (target_sp) {
Context not available.
if (test_cu_spec != static_cast<FileSpec *>(sc.comp_unit)) if (test_cu_spec != static_cast<FileSpec *>(sc.comp_unit))
got_multiple = true; got_multiple = true;
break; break;
} else }
test_cu_spec = sc.comp_unit; test_cu_spec = sc.comp_unit;
} }
} }
} }
Context not available.

source/Core/Value.cpp

Context not available.
Value *ValueList::GetValueAtIndex(size_t idx) { Value *ValueList::GetValueAtIndex(size_t idx) {
if (idx < GetSize()) { if (idx < GetSize()) {
return &(m_values[idx]); return &(m_values[idx]);
} else }
return NULL; return NULL;
} }
void ValueList::Clear() { m_values.clear(); } void ValueList::Clear() { m_values.clear(); }
Context not available.

source/Core/ValueObject.cpp

Context not available.
if (m_did_calculate_complete_objc_class_type) { if (m_did_calculate_complete_objc_class_type) {
if (m_override_type.IsValid()) if (m_override_type.IsValid())
return m_override_type; return m_override_type;
else
return compiler_type; return compiler_type;
} }
CompilerType class_type; CompilerType class_type;
Context not available.
if (m_children_count_valid) { if (m_children_count_valid) {
size_t children_count = m_children.GetChildrenCount(); size_t children_count = m_children.GetChildrenCount();
return children_count <= max ? children_count : max; return children_count <= max ? children_count : max;
} else }
return CalculateNumChildren(max); return CalculateNumChildren(max);
} }
if (!m_children_count_valid) { if (!m_children_count_valid) {
Context not available.
if (error.Fail() || pointee_sp.get() == NULL) if (error.Fail() || pointee_sp.get() == NULL)
return 0; return 0;
return pointee_sp->GetData(data, error); return pointee_sp->GetData(data, error);
} else {
ValueObjectSP child_sp = GetChildAtIndex(0, true);
if (child_sp.get() == NULL)
return 0;
Status error;
return child_sp->GetData(data, error);
} }
return true; ValueObjectSP child_sp = GetChildAtIndex(0, true);
} else /* (items > 1) */ if (child_sp.get() == NULL)
{ return 0;
Status error; Status error;
lldb_private::DataBufferHeap *heap_buf_ptr = NULL; return child_sp->GetData(data, error);
lldb::DataBufferSP data_sp(heap_buf_ptr =
new lldb_private::DataBufferHeap()); return true;
} /* (items > 1) */
AddressType addr_type;
lldb::addr_t addr = is_pointer_type ? GetPointerValue(&addr_type) Status error;
: GetAddressOf(true, &addr_type); lldb_private::DataBufferHeap *heap_buf_ptr = NULL;
lldb::DataBufferSP data_sp(heap_buf_ptr = new lldb_private::DataBufferHeap());
switch (addr_type) {
case eAddressTypeFile: { AddressType addr_type;
ModuleSP module_sp(GetModule()); lldb::addr_t addr = is_pointer_type ? GetPointerValue(&addr_type)
if (module_sp) { : GetAddressOf(true, &addr_type);
addr = addr + offset;
Address so_addr; switch (addr_type) {
module_sp->ResolveFileAddress(addr, so_addr); case eAddressTypeFile: {
ExecutionContext exe_ctx(GetExecutionContextRef()); ModuleSP module_sp(GetModule());
Target *target = exe_ctx.GetTargetPtr(); if (module_sp) {
if (target) { addr = addr + offset;
heap_buf_ptr->SetByteSize(bytes); Address so_addr;
size_t bytes_read = target->ReadMemory( module_sp->ResolveFileAddress(addr, so_addr);
so_addr, false, heap_buf_ptr->GetBytes(), bytes, error); ExecutionContext exe_ctx(GetExecutionContextRef());
if (error.Success()) { Target *target = exe_ctx.GetTargetPtr();
data.SetData(data_sp); if (target) {
return bytes_read; heap_buf_ptr->SetByteSize(bytes);
} size_t bytes_read = target->ReadMemory(
so_addr, false, heap_buf_ptr->GetBytes(), bytes, error);
if (error.Success()) {
data.SetData(data_sp);
return bytes_read;
} }
} }
}
} break; } break;
case eAddressTypeLoad: { case eAddressTypeLoad: {
ExecutionContext exe_ctx(GetExecutionContextRef()); ExecutionContext exe_ctx(GetExecutionContextRef());
Context not available.
case eAddressTypeInvalid: case eAddressTypeInvalid:
break; break;
} }
}
return 0; return 0;
} }
uint64_t ValueObject::GetData(DataExtractor &data, Status &error) { uint64_t ValueObject::GetData(DataExtractor &data, Status &error) {
Context not available.
data = m_data; data = m_data;
error.Clear(); error.Clear();
return data.GetByteSize(); return data.GetByteSize();
} else {
return 0;
} }
return 0;
} }
data.SetAddressByteSize(m_data.GetAddressByteSize()); data.SetAddressByteSize(m_data.GetAddressByteSize());
data.SetByteOrder(m_data.GetByteOrder()); data.SetByteOrder(m_data.GetByteOrder());
Context not available.
buffer_sp.reset(new DataBufferHeap(cstr_len, 0)); buffer_sp.reset(new DataBufferHeap(cstr_len, 0));
memcpy(buffer_sp->GetBytes(), cstr, cstr_len); memcpy(buffer_sp->GetBytes(), cstr, cstr_len);
return {cstr_len, was_capped}; return {cstr_len, was_capped};
} else {
s << "<invalid address>";
error.SetErrorString("invalid address");
CopyStringDataToBufferSP(s, buffer_sp);
return {0, was_capped};
} }
s << "<invalid address>";
error.SetErrorString("invalid address");
CopyStringDataToBufferSP(s, buffer_sp);
return {0, was_capped};
} }
Address cstr_so_addr(cstr_address); Address cstr_so_addr(cstr_address);
Context not available.
if (m_object_desc_str.empty()) if (m_object_desc_str.empty())
return NULL; return NULL;
else
return m_object_desc_str.c_str(); return m_object_desc_str.c_str();
} }
bool ValueObject::GetValueAsCString(const lldb_private::TypeFormatImpl &format, bool ValueObject::GetValueAsCString(const lldb_private::TypeFormatImpl &format,
std::string &destination) { std::string &destination) {
if (UpdateValueIfNeeded(false)) if (UpdateValueIfNeeded(false))
return format.FormatObject(this, destination); return format.FormatObject(this, destination);
else
return false; return false;
} }
bool ValueObject::GetValueAsCString(lldb::Format format, bool ValueObject::GetValueAsCString(lldb::Format format,
Context not available.
Process *process = exe_ctx.GetProcessPtr(); Process *process = exe_ctx.GetProcessPtr();
if (process) if (process)
return process->IsPossibleDynamicValue(*this); return process->IsPossibleDynamicValue(*this);
else
return GetCompilerType().IsPossibleDynamicType(NULL, true, true); return GetCompilerType().IsPossibleDynamicType(NULL, true, true);
} }
bool ValueObject::IsRuntimeSupportValue() { bool ValueObject::IsRuntimeSupportValue() {
Context not available.
} }
if (m_dynamic_value) if (m_dynamic_value)
return m_dynamic_value->GetSP(); return m_dynamic_value->GetSP();
else
return ValueObjectSP(); return ValueObjectSP();
} }
ValueObjectSP ValueObject::GetStaticValue() { return GetSP(); } ValueObjectSP ValueObject::GetStaticValue() { return GetSP(); }
Context not available.
if (m_synthetic_value) if (m_synthetic_value)
return m_synthetic_value->GetSP(); return m_synthetic_value->GetSP();
else
return ValueObjectSP(); return ValueObjectSP();
} }
bool ValueObject::HasSyntheticValue() { bool ValueObject::HasSyntheticValue() {
Context not available.
if (m_synthetic_value) if (m_synthetic_value)
return true; return true;
else
return false; return false;
} }
bool ValueObject::GetBaseClassPath(Stream &s) { bool ValueObject::GetBaseClassPath(Stream &s) {
Context not available.
if (GetParent()) { if (GetParent()) {
if (GetParent()->IsBaseClass()) if (GetParent()->IsBaseClass())
return GetParent()->GetNonBaseClassParent(); return GetParent()->GetNonBaseClassParent();
else
return GetParent(); return GetParent();
} }
return NULL; return NULL;
} }
Context not available.
s.Printf("((%s)0x%" PRIx64 ")", GetTypeName().AsCString("void"), s.Printf("((%s)0x%" PRIx64 ")", GetTypeName().AsCString("void"),
GetValueAsUnsigned(0)); GetValueAsUnsigned(0));
return; return;
} else {
uint64_t load_addr =
m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
if (load_addr != LLDB_INVALID_ADDRESS) {
s.Printf("(*( (%s *)0x%" PRIx64 "))", GetTypeName().AsCString("void"),
load_addr);
return;
}
} }
uint64_t load_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
if (load_addr != LLDB_INVALID_ADDRESS) {
s.Printf("(*( (%s *)0x%" PRIx64 "))", GetTypeName().AsCString("void"),
load_addr);
return;
}
} }
if (CanProvideValue()) { if (CanProvideValue()) {
Context not available.
if (final_value_type) if (final_value_type)
*final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid; *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} else {
if (final_task_on_target)
*final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
return final_value;
} }
if (final_task_on_target)
*final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
return final_value;
} }
if (*final_task_on_target == if (*final_task_on_target ==
ValueObject::eExpressionPathAftermathTakeAddress) { ValueObject::eExpressionPathAftermathTakeAddress) {
Context not available.
if (final_value_type) if (final_value_type)
*final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid; *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} else {
if (final_task_on_target)
*final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
return final_value;
} }
if (final_task_on_target)
*final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
return final_value;
} }
} }
return ret_val; // final_task_on_target will still have its original value, so return ret_val; // final_task_on_target will still have its original value, so
Context not available.
ValueObject::eExpressionPathScanEndReasonEndOfString; ValueObject::eExpressionPathScanEndReasonEndOfString;
*final_result = ValueObject::eExpressionPathEndResultTypePlain; *final_result = ValueObject::eExpressionPathEndResultTypePlain;
return child_valobj_sp; return child_valobj_sp;
} else { }
switch (options.m_synthetic_children_traversal) { switch (options.m_synthetic_children_traversal) {
case GetValueForExpressionPathOptions::SyntheticChildrenTraversal:: case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None:
None: break;
break; case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
case GetValueForExpressionPathOptions::SyntheticChildrenTraversal:: FromSynthetic:
FromSynthetic: if (root->IsSynthetic()) {
if (root->IsSynthetic()) { child_valobj_sp = root->GetNonSyntheticValue();
child_valobj_sp = root->GetNonSyntheticValue(); if (child_valobj_sp.get())
if (child_valobj_sp.get()) child_valobj_sp =
child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
child_valobj_sp->GetChildMemberWithName(child_name, true); }
} break;
break; case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
case GetValueForExpressionPathOptions::SyntheticChildrenTraversal:: ToSynthetic:
ToSynthetic: if (!root->IsSynthetic()) {
if (!root->IsSynthetic()) { child_valobj_sp = root->GetSyntheticValue();
child_valobj_sp = root->GetSyntheticValue(); if (child_valobj_sp.get())
if (child_valobj_sp.get()) child_valobj_sp =
child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
child_valobj_sp->GetChildMemberWithName(child_name, true); }
} break;
break; case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::Both:
case GetValueForExpressionPathOptions::SyntheticChildrenTraversal:: if (root->IsSynthetic()) {
Both: child_valobj_sp = root->GetNonSyntheticValue();
if (root->IsSynthetic()) { if (child_valobj_sp.get())
child_valobj_sp = root->GetNonSyntheticValue(); child_valobj_sp =
if (child_valobj_sp.get()) child_valobj_sp->GetChildMemberWithName(child_name, true);
child_valobj_sp = } else {
child_valobj_sp->GetChildMemberWithName(child_name, true); child_valobj_sp = root->GetSyntheticValue();
} else { if (child_valobj_sp.get())
child_valobj_sp = root->GetSyntheticValue(); child_valobj_sp =
if (child_valobj_sp.get()) child_valobj_sp->GetChildMemberWithName(child_name, true);
child_valobj_sp =
child_valobj_sp->GetChildMemberWithName(child_name, true);
}
break;
} }
break;
} }
// if we are here and options.m_no_synthetic_children is true, // if we are here and options.m_no_synthetic_children is true,
Context not available.
ValueObject::eExpressionPathScanEndReasonEndOfString; ValueObject::eExpressionPathScanEndReasonEndOfString;
*final_result = ValueObject::eExpressionPathEndResultTypePlain; *final_result = ValueObject::eExpressionPathEndResultTypePlain;
return child_valobj_sp; return child_valobj_sp;
} else {
*reason_to_stop =
ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr;
} }
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr;
} else // other layers do expand } else // other layers do expand
{ {
llvm::StringRef next_separator = temp_expression.substr(next_sep_pos); llvm::StringRef next_separator = temp_expression.substr(next_sep_pos);
Context not available.
remainder = next_separator; remainder = next_separator;
*final_result = ValueObject::eExpressionPathEndResultTypePlain; *final_result = ValueObject::eExpressionPathEndResultTypePlain;
continue; continue;
} else { }
switch (options.m_synthetic_children_traversal) { switch (options.m_synthetic_children_traversal) {
case GetValueForExpressionPathOptions::SyntheticChildrenTraversal:: case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None:
None: break;
break; case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
case GetValueForExpressionPathOptions::SyntheticChildrenTraversal:: FromSynthetic:
FromSynthetic: if (root->IsSynthetic()) {
if (root->IsSynthetic()) { child_valobj_sp = root->GetNonSyntheticValue();
child_valobj_sp = root->GetNonSyntheticValue(); if (child_valobj_sp.get())
if (child_valobj_sp.get()) child_valobj_sp =
child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
child_valobj_sp->GetChildMemberWithName(child_name, true); }
} break;
break; case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
case GetValueForExpressionPathOptions::SyntheticChildrenTraversal:: ToSynthetic:
ToSynthetic: if (!root->IsSynthetic()) {
if (!root->IsSynthetic()) { child_valobj_sp = root->GetSyntheticValue();
child_valobj_sp = root->GetSyntheticValue(); if (child_valobj_sp.get())
if (child_valobj_sp.get()) child_valobj_sp =
child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
child_valobj_sp->GetChildMemberWithName(child_name, true); }
} break;
break; case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::Both:
case GetValueForExpressionPathOptions::SyntheticChildrenTraversal:: if (root->IsSynthetic()) {
Both: child_valobj_sp = root->GetNonSyntheticValue();
if (root->IsSynthetic()) { if (child_valobj_sp.get())
child_valobj_sp = root->GetNonSyntheticValue(); child_valobj_sp =
if (child_valobj_sp.get()) child_valobj_sp->GetChildMemberWithName(child_name, true);
child_valobj_sp = } else {
child_valobj_sp->GetChildMemberWithName(child_name, true); child_valobj_sp = root->GetSyntheticValue();
} else { if (child_valobj_sp.get())
child_valobj_sp = root->GetSyntheticValue(); child_valobj_sp =
if (child_valobj_sp.get()) child_valobj_sp->GetChildMemberWithName(child_name, true);
child_valobj_sp =
child_valobj_sp->GetChildMemberWithName(child_name, true);
}
break;
} }
break;
} }
// if we are here and options.m_no_synthetic_children is true, // if we are here and options.m_no_synthetic_children is true,
Context not available.
remainder = next_separator; remainder = next_separator;
*final_result = ValueObject::eExpressionPathEndResultTypePlain; *final_result = ValueObject::eExpressionPathEndResultTypePlain;
continue; continue;
} else {
*reason_to_stop =
ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr;
} }
*reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr;
} }
break; break;
} }
Context not available.
ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed; ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr; return nullptr;
} else // even if something follows, we cannot expand unbounded ranges, } // even if something follows, we cannot expand unbounded ranges,
// just let the caller do it // just let the caller do it
{
*reason_to_stop = *reason_to_stop =
ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet; ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
*final_result = *final_result = ValueObject::eExpressionPathEndResultTypeUnboundedRange;
ValueObject::eExpressionPathEndResultTypeUnboundedRange; return root;
return root;
}
} }
size_t close_bracket_position = temp_expression.find(']', 1); size_t close_bracket_position = temp_expression.find(']', 1);
Context not available.
temp_expression.substr(close_bracket_position + 1); // skip ] temp_expression.substr(close_bracket_position + 1); // skip ]
*final_result = ValueObject::eExpressionPathEndResultTypePlain; *final_result = ValueObject::eExpressionPathEndResultTypePlain;
continue; continue;
} else {
*reason_to_stop =
ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr;
} }
*reason_to_stop =
ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr;
} else if (root_compiler_type_info.Test(eTypeIsPointer)) { } else if (root_compiler_type_info.Test(eTypeIsPointer)) {
if (*what_next == if (*what_next ==
ValueObject:: ValueObject::
Context not available.
ValueObject::eExpressionPathScanEndReasonDereferencingFailed; ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr; return nullptr;
} else {
*what_next = eExpressionPathAftermathNothing;
continue;
} }
*what_next = eExpressionPathAftermathNothing;
continue;
} else { } else {
if (root->GetCompilerType().GetMinimumLanguage() == if (root->GetCompilerType().GetMinimumLanguage() ==
eLanguageTypeObjC && eLanguageTypeObjC &&
Context not available.
ValueObject::eExpressionPathScanEndReasonNoSuchChild; ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr; return nullptr;
} else {
remainder =
temp_expression.substr(close_bracket_position + 1); // skip ]
*final_result = ValueObject::eExpressionPathEndResultTypePlain;
continue;
} }
remainder =
temp_expression.substr(close_bracket_position + 1); // skip ]
*final_result = ValueObject::eExpressionPathEndResultTypePlain;
continue;
} }
} else if (root_compiler_type_info.Test(eTypeIsScalar)) { } else if (root_compiler_type_info.Test(eTypeIsScalar)) {
root = root->GetSyntheticBitFieldChild(index, index, true); root = root->GetSyntheticBitFieldChild(index, index, true);
Context not available.
ValueObject::eExpressionPathScanEndReasonNoSuchChild; ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr; return nullptr;
} else // we do not know how to expand members of bitfields, so we } // we do not know how to expand members of bitfields, so we
// just return and let the caller do any further processing // just return and let the caller do any further processing
{
*reason_to_stop = ValueObject:: *reason_to_stop =
eExpressionPathScanEndReasonBitfieldRangeOperatorMet; ValueObject::eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
*final_result = ValueObject::eExpressionPathEndResultTypeBitfield; *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
return root; return root;
}
} else if (root_compiler_type_info.Test(eTypeIsVector)) { } else if (root_compiler_type_info.Test(eTypeIsVector)) {
root = root->GetChildAtIndex(index, true); root = root->GetChildAtIndex(index, true);
if (!root) { if (!root) {
Context not available.
ValueObject::eExpressionPathScanEndReasonNoSuchChild; ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return ValueObjectSP(); return ValueObjectSP();
} else {
remainder =
temp_expression.substr(close_bracket_position + 1); // skip ]
*final_result = ValueObject::eExpressionPathEndResultTypePlain;
continue;
} }
remainder =
temp_expression.substr(close_bracket_position + 1); // skip ]
*final_result = ValueObject::eExpressionPathEndResultTypePlain;
continue;
} else if (options.m_synthetic_children_traversal == } else if (options.m_synthetic_children_traversal ==
GetValueForExpressionPathOptions:: GetValueForExpressionPathOptions::
SyntheticChildrenTraversal::ToSynthetic || SyntheticChildrenTraversal::ToSynthetic ||
Context not available.
ValueObject::eExpressionPathScanEndReasonNoSuchChild; ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr; return nullptr;
} else {
remainder =
temp_expression.substr(close_bracket_position + 1); // skip ]
*final_result = ValueObject::eExpressionPathEndResultTypePlain;
continue;
} }
remainder =
temp_expression.substr(close_bracket_position + 1); // skip ]
*final_result = ValueObject::eExpressionPathEndResultTypePlain;
continue;
} else { } else {
*reason_to_stop = *reason_to_stop =
ValueObject::eExpressionPathScanEndReasonNoSuchChild; ValueObject::eExpressionPathScanEndReasonNoSuchChild;
Context not available.
ValueObject::eExpressionPathScanEndReasonNoSuchChild; ValueObject::eExpressionPathScanEndReasonNoSuchChild;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr; return nullptr;
} else {
*reason_to_stop = ValueObject::
eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
*final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
return root;
} }
*reason_to_stop =
ValueObject::eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
*final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
return root;
} else if (root_compiler_type_info.Test( } else if (root_compiler_type_info.Test(
eTypeIsPointer) && // if this is a ptr-to-scalar, I am eTypeIsPointer) && // if this is a ptr-to-scalar, I am
// accessing it by index and I would // accessing it by index and I would
Context not available.
ValueObject::eExpressionPathScanEndReasonDereferencingFailed; ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
*final_result = ValueObject::eExpressionPathEndResultTypeInvalid; *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
return nullptr; return nullptr;
} else {
*what_next = ValueObject::eExpressionPathAftermathNothing;
continue;
} }
*what_next = ValueObject::eExpressionPathAftermathNothing;
continue;
} else { } else {
*reason_to_stop = *reason_to_stop =
ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet; ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
Context not available.
if (m_deref_valobj) { if (m_deref_valobj) {
error.Clear(); error.Clear();
return m_deref_valobj->GetSP(); return m_deref_valobj->GetSP();
} else {
StreamString strm;
GetExpressionPath(strm, true);
if (is_pointer_or_reference_type)
error.SetErrorStringWithFormat("dereference failed: (%s) %s",
GetTypeName().AsCString("<invalid type>"),
strm.GetData());
else
error.SetErrorStringWithFormat("not a pointer or reference type: (%s) %s",
GetTypeName().AsCString("<invalid type>"),
strm.GetData());
return ValueObjectSP();
} }
StreamString strm;
GetExpressionPath(strm, true);
if (is_pointer_or_reference_type)
error.SetErrorStringWithFormat("dereference failed: (%s) %s",
GetTypeName().AsCString("<invalid type>"),
strm.GetData());
else
error.SetErrorStringWithFormat("not a pointer or reference type: (%s) %s",
GetTypeName().AsCString("<invalid type>"),
strm.GetData());
return ValueObjectSP();
} }
ValueObjectSP ValueObject::AddressOf(Status &error) { ValueObjectSP ValueObject::AddressOf(Status &error) {
Context not available.

source/Core/ValueObjectConstResultImpl.cpp

Context not available.
m_address_of_backend->GetValue().GetScalar() = m_live_address; m_address_of_backend->GetValue().GetScalar() = m_live_address;
return m_address_of_backend; return m_address_of_backend;
} else }
return m_impl_backend->ValueObject::AddressOf(error); return m_impl_backend->ValueObject::AddressOf(error);
} }
lldb::ValueObjectSP lldb::ValueObjectSP
Context not available.

source/Core/ValueObjectDynamicValue.cpp

Context not available.
if (success) { if (success) {
if (m_dynamic_type_info.HasType()) if (m_dynamic_type_info.HasType())
return m_value.GetCompilerType(); return m_value.GetCompilerType();
else
return m_parent->GetCompilerType(); return m_parent->GetCompilerType();
} }
return m_parent->GetCompilerType(); return m_parent->GetCompilerType();
} }
Context not available.
ExecutionContext exe_ctx(GetExecutionContextRef()); ExecutionContext exe_ctx(GetExecutionContextRef());
auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx); auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
return children_count <= max ? children_count : max; return children_count <= max ? children_count : max;
} else }
return m_parent->GetNumChildren(max); return m_parent->GetNumChildren(max);
} }
uint64_t ValueObjectDynamicValue::GetByteSize() { uint64_t ValueObjectDynamicValue::GetByteSize() {
Context not available.
if (success && m_dynamic_type_info.HasType()) { if (success && m_dynamic_type_info.HasType()) {
ExecutionContext exe_ctx(GetExecutionContextRef()); ExecutionContext exe_ctx(GetExecutionContextRef());
return m_value.GetValueByteSize(nullptr, &exe_ctx); return m_value.GetValueByteSize(nullptr, &exe_ctx);
} else }
return m_parent->GetByteSize(); return m_parent->GetByteSize();
} }
lldb::ValueType ValueObjectDynamicValue::GetValueType() const { lldb::ValueType ValueObjectDynamicValue::GetValueType() const {
Context not available.
if (m_parent) if (m_parent)
return m_parent->GetPreferredDisplayLanguage(); return m_parent->GetPreferredDisplayLanguage();
return lldb::eLanguageTypeUnknown; return lldb::eLanguageTypeUnknown;
} else }
return m_preferred_display_language; return m_preferred_display_language;
} }
bool ValueObjectDynamicValue::IsSyntheticChildrenGenerated() { bool ValueObjectDynamicValue::IsSyntheticChildrenGenerated() {
Context not available.

source/Core/ValueObjectRegister.cpp

Context not available.
} }
if (valobj) if (valobj)
return valobj->GetSP(); return valobj->GetSP();
else
return ValueObjectSP(); return ValueObjectSP();
} }
size_t size_t
Context not available.
if (m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) { if (m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) {
SetNeedsUpdate(); SetNeedsUpdate();
return true; return true;
} else }
return false; return false;
} else } else
return false; return false;
} }
Context not available.
if (m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) { if (m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) {
SetNeedsUpdate(); SetNeedsUpdate();
return true; return true;
} else }
return false; return false;
} else } else
return false; return false;
} }
Context not available.

source/Core/ValueObjectSyntheticFilter.cpp

Context not available.
GetName().AsCString(), GetTypeName().AsCString(), GetName().AsCString(), GetTypeName().AsCString(),
num_children); num_children);
return num_children; return num_children;
} else {
size_t num_children = (m_synthetic_children_count =
m_synth_filter_ap->CalculateNumChildren(max));
if (log)
log->Printf("[ValueObjectSynthetic::CalculateNumChildren] for VO of name "
"%s and type %s, the filter returned %zu child values",
GetName().AsCString(), GetTypeName().AsCString(),
num_children);
return num_children;
} }
size_t num_children = (m_synthetic_children_count =
m_synth_filter_ap->CalculateNumChildren(max));
if (log)
log->Printf("[ValueObjectSynthetic::CalculateNumChildren] for VO of name "
"%s and type %s, the filter returned %zu child values",
GetName().AsCString(), GetTypeName().AsCString(), num_children);
return num_children;
} }
lldb::ValueObjectSP lldb::ValueObjectSP
Context not available.
synth_guy->SetPreferredDisplayLanguageIfNeeded( synth_guy->SetPreferredDisplayLanguageIfNeeded(
GetPreferredDisplayLanguage()); GetPreferredDisplayLanguage());
return synth_guy; return synth_guy;
} else {
if (log)
log->Printf("[ValueObjectSynthetic::GetChildAtIndex] name=%s, child at "
"index %zu not cached and cannot "
"be created (can_create = %s, synth_filter = %p)",
GetName().AsCString(), idx, can_create ? "yes" : "no",
static_cast<void *>(m_synth_filter_ap.get()));
return lldb::ValueObjectSP();
} }
if (log)
log->Printf("[ValueObjectSynthetic::GetChildAtIndex] name=%s, child at "
"index %zu not cached and cannot "
"be created (can_create = %s, synth_filter = %p)",
GetName().AsCString(), idx, can_create ? "yes" : "no",
static_cast<void *>(m_synth_filter_ap.get()));
return lldb::ValueObjectSP();
} else { } else {
if (log) if (log)
log->Printf("[ValueObjectSynthetic::GetChildAtIndex] name=%s, child at " log->Printf("[ValueObjectSynthetic::GetChildAtIndex] name=%s, child at "
Context not available.
return index; return index;
m_name_toindex.SetValueForKey(name.GetCString(), index); m_name_toindex.SetValueForKey(name.GetCString(), index);
return index; return index;
} else if (!did_find && m_synth_filter_ap.get() == nullptr) }
if (!did_find && m_synth_filter_ap.get() == nullptr)
return UINT32_MAX; return UINT32_MAX;
else /*if (iter != m_name_toindex.end())*/ else /*if (iter != m_name_toindex.end())*/
return found_index; return found_index;
Context not available.
if (m_parent) if (m_parent)
return m_parent->GetPreferredDisplayLanguage(); return m_parent->GetPreferredDisplayLanguage();
return lldb::eLanguageTypeUnknown; return lldb::eLanguageTypeUnknown;
} else }
return m_preferred_display_language; return m_preferred_display_language;
} }
bool ValueObjectSynthetic::IsSyntheticChildrenGenerated() { bool ValueObjectSynthetic::IsSyntheticChildrenGenerated() {
Context not available.

source/Core/ValueObjectVariable.cpp

Context not available.
StackFrame *frame = exe_ctx.GetFramePtr(); StackFrame *frame = exe_ctx.GetFramePtr();
if (frame) { if (frame) {
return m_variable_sp->IsInScope(frame); return m_variable_sp->IsInScope(frame);
} else {
// This ValueObject had a frame at one time, but now we can't locate it,
// so return false since we probably aren't in scope.
return false;
} }
// This ValueObject had a frame at one time, but now we can't locate it,
// so return false since we probably aren't in scope.
return false;
} }
// We have a variable that wasn't tied to a frame, which means it is a global // We have a variable that wasn't tied to a frame, which means it is a global
// and is always in scope. // and is always in scope.
Context not available.
const char *ValueObjectVariable::GetLocationAsCString() { const char *ValueObjectVariable::GetLocationAsCString() {
if (m_resolved_value.GetContextType() == Value::eContextTypeRegisterInfo) if (m_resolved_value.GetContextType() == Value::eContextTypeRegisterInfo)
return GetLocationAsCStringImpl(m_resolved_value, m_data); return GetLocationAsCStringImpl(m_resolved_value, m_data);
else
return ValueObject::GetLocationAsCString(); return ValueObject::GetLocationAsCString();
} }
bool ValueObjectVariable::SetValueFromCString(const char *value_str, bool ValueObjectVariable::SetValueFromCString(const char *value_str,
Context not available.
if (reg_ctx->WriteRegister(reg_info, reg_value)) { if (reg_ctx->WriteRegister(reg_info, reg_value)) {
SetNeedsUpdate(); SetNeedsUpdate();
return true; return true;
} else {
error.SetErrorString("unable to write back to register");
return false;
} }
error.SetErrorString("unable to write back to register");
return false;
} else } else
return ValueObject::SetValueFromCString(value_str, error); return ValueObject::SetValueFromCString(value_str, error);
} }
Context not available.
if (reg_ctx->WriteRegister(reg_info, reg_value)) { if (reg_ctx->WriteRegister(reg_info, reg_value)) {
SetNeedsUpdate(); SetNeedsUpdate();
return true; return true;
} else {
error.SetErrorString("unable to write back to register");
return false;
} }
error.SetErrorString("unable to write back to register");
return false;
} else } else
return ValueObject::SetData(data, error); return ValueObject::SetData(data, error);
} }
Context not available.

source/DataFormatters/CXXFunctionPointer.cpp

Context not available.
if (sstr.GetSize() > 0) { if (sstr.GetSize() > 0) {
stream.Printf("(%s)", sstr.GetData()); stream.Printf("(%s)", sstr.GetData());
return true; return true;
} else }
return false; return false;
} }
Context not available.

source/DataFormatters/FormatManager.cpp

Context not available.
lldb::ScriptedSyntheticChildrenSP synth_sp = GetSyntheticForType(type_sp); lldb::ScriptedSyntheticChildrenSP synth_sp = GetSyntheticForType(type_sp);
if (filter_sp->GetRevision() > synth_sp->GetRevision()) if (filter_sp->GetRevision() > synth_sp->GetRevision())
return lldb::SyntheticChildrenSP(filter_sp.get()); return lldb::SyntheticChildrenSP(filter_sp.get());
else
return lldb::SyntheticChildrenSP(synth_sp.get()); return lldb::SyntheticChildrenSP(synth_sp.get());
} }
#endif #endif
Context not available.

source/DataFormatters/TypeCategory.cpp

Context not available.
&reason_synth); &reason_synth);
if (!filter_sp.get() && !synth.get()) if (!filter_sp.get() && !synth.get())
return false; return false;
else if (!filter_sp.get() && synth.get()) if (!filter_sp.get() && synth.get())
pick_synth = true; pick_synth = true;
else if (filter_sp.get() && !synth.get()) else if (filter_sp.get() && !synth.get())
Context not available.
*reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter; *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
entry = synth; entry = synth;
return true; return true;
} else {
if (regex_filter && reason)
*reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
entry = filter_sp;
return true;
} }
if (regex_filter && reason)
*reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
entry = filter_sp;
return true;
#else #else
if (filter_sp) { if (filter_sp) {
Context not available.
TypeCategoryImpl::GetTypeNameSpecifierForSummaryAtIndex(size_t index) { TypeCategoryImpl::GetTypeNameSpecifierForSummaryAtIndex(size_t index) {
if (index < GetTypeSummariesContainer()->GetCount()) if (index < GetTypeSummariesContainer()->GetCount())
return GetTypeSummariesContainer()->GetTypeNameSpecifierAtIndex(index); return GetTypeSummariesContainer()->GetTypeNameSpecifierAtIndex(index);
else
return GetRegexTypeSummariesContainer()->GetTypeNameSpecifierAtIndex( return GetRegexTypeSummariesContainer()->GetTypeNameSpecifierAtIndex(
index - GetTypeSummariesContainer()->GetCount()); index - GetTypeSummariesContainer()->GetCount());
} }
TypeCategoryImpl::FormatContainer::MapValueType TypeCategoryImpl::FormatContainer::MapValueType
TypeCategoryImpl::GetFormatAtIndex(size_t index) { TypeCategoryImpl::GetFormatAtIndex(size_t index) {
if (index < GetTypeFormatsContainer()->GetCount()) if (index < GetTypeFormatsContainer()->GetCount())
return GetTypeFormatsContainer()->GetAtIndex(index); return GetTypeFormatsContainer()->GetAtIndex(index);
else
return GetRegexTypeFormatsContainer()->GetAtIndex( return GetRegexTypeFormatsContainer()->GetAtIndex(
index - GetTypeFormatsContainer()->GetCount()); index - GetTypeFormatsContainer()->GetCount());
} }
TypeCategoryImpl::SummaryContainer::MapValueType TypeCategoryImpl::SummaryContainer::MapValueType
TypeCategoryImpl::GetSummaryAtIndex(size_t index) { TypeCategoryImpl::GetSummaryAtIndex(size_t index) {
if (index < GetTypeSummariesContainer()->GetCount()) if (index < GetTypeSummariesContainer()->GetCount())
return GetTypeSummariesContainer()->GetAtIndex(index); return GetTypeSummariesContainer()->GetAtIndex(index);
else
return GetRegexTypeSummariesContainer()->GetAtIndex( return GetRegexTypeSummariesContainer()->GetAtIndex(
index - GetTypeSummariesContainer()->GetCount()); index - GetTypeSummariesContainer()->GetCount());
} }
TypeCategoryImpl::FilterContainer::MapValueType TypeCategoryImpl::FilterContainer::MapValueType
TypeCategoryImpl::GetFilterAtIndex(size_t index) { TypeCategoryImpl::GetFilterAtIndex(size_t index) {
if (index < GetTypeFiltersContainer()->GetCount()) if (index < GetTypeFiltersContainer()->GetCount())
return GetTypeFiltersContainer()->GetAtIndex(index); return GetTypeFiltersContainer()->GetAtIndex(index);
else
return GetRegexTypeFiltersContainer()->GetAtIndex( return GetRegexTypeFiltersContainer()->GetAtIndex(
index - GetTypeFiltersContainer()->GetCount()); index - GetTypeFiltersContainer()->GetCount());
} }
lldb::TypeNameSpecifierImplSP lldb::TypeNameSpecifierImplSP
TypeCategoryImpl::GetTypeNameSpecifierForFormatAtIndex(size_t index) { TypeCategoryImpl::GetTypeNameSpecifierForFormatAtIndex(size_t index) {
if (index < GetTypeFormatsContainer()->GetCount()) if (index < GetTypeFormatsContainer()->GetCount())
return GetTypeFormatsContainer()->GetTypeNameSpecifierAtIndex(index); return GetTypeFormatsContainer()->GetTypeNameSpecifierAtIndex(index);
else
return GetRegexTypeFormatsContainer()->GetTypeNameSpecifierAtIndex( return GetRegexTypeFormatsContainer()->GetTypeNameSpecifierAtIndex(
index - GetTypeFormatsContainer()->GetCount()); index - GetTypeFormatsContainer()->GetCount());
} }
lldb::TypeNameSpecifierImplSP lldb::TypeNameSpecifierImplSP
TypeCategoryImpl::GetTypeNameSpecifierForFilterAtIndex(size_t index) { TypeCategoryImpl::GetTypeNameSpecifierForFilterAtIndex(size_t index) {
if (index < GetTypeFiltersContainer()->GetCount()) if (index < GetTypeFiltersContainer()->GetCount())
return GetTypeFiltersContainer()->GetTypeNameSpecifierAtIndex(index); return GetTypeFiltersContainer()->GetTypeNameSpecifierAtIndex(index);
else
return GetRegexTypeFiltersContainer()->GetTypeNameSpecifierAtIndex( return GetRegexTypeFiltersContainer()->GetTypeNameSpecifierAtIndex(
index - GetTypeFiltersContainer()->GetCount()); index - GetTypeFiltersContainer()->GetCount());
} }
#ifndef LLDB_DISABLE_PYTHON #ifndef LLDB_DISABLE_PYTHON
Context not available.
TypeCategoryImpl::GetSyntheticAtIndex(size_t index) { TypeCategoryImpl::GetSyntheticAtIndex(size_t index) {
if (index < GetTypeSyntheticsContainer()->GetCount()) if (index < GetTypeSyntheticsContainer()->GetCount())
return GetTypeSyntheticsContainer()->GetAtIndex(index); return GetTypeSyntheticsContainer()->GetAtIndex(index);
else
return GetRegexTypeSyntheticsContainer()->GetAtIndex( return GetRegexTypeSyntheticsContainer()->GetAtIndex(
index - GetTypeSyntheticsContainer()->GetCount()); index - GetTypeSyntheticsContainer()->GetCount());
} }
lldb::TypeNameSpecifierImplSP lldb::TypeNameSpecifierImplSP
TypeCategoryImpl::GetTypeNameSpecifierForSyntheticAtIndex(size_t index) { TypeCategoryImpl::GetTypeNameSpecifierForSyntheticAtIndex(size_t index) {
if (index < GetTypeSyntheticsContainer()->GetCount()) if (index < GetTypeSyntheticsContainer()->GetCount())
return GetTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex(index); return GetTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex(index);
else
return GetRegexTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex( return GetRegexTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex(
index - GetTypeSyntheticsContainer()->GetCount()); index - GetTypeSyntheticsContainer()->GetCount());
} }
#endif #endif
Context not available.
TypeCategoryImpl::GetValidatorAtIndex(size_t index) { TypeCategoryImpl::GetValidatorAtIndex(size_t index) {
if (index < GetTypeValidatorsContainer()->GetCount()) if (index < GetTypeValidatorsContainer()->GetCount())
return GetTypeValidatorsContainer()->GetAtIndex(index); return GetTypeValidatorsContainer()->GetAtIndex(index);
else
return GetRegexTypeValidatorsContainer()->GetAtIndex( return GetRegexTypeValidatorsContainer()->GetAtIndex(
index - GetTypeValidatorsContainer()->GetCount()); index - GetTypeValidatorsContainer()->GetCount());
} }
lldb::TypeNameSpecifierImplSP lldb::TypeNameSpecifierImplSP
TypeCategoryImpl::GetTypeNameSpecifierForValidatorAtIndex(size_t index) { TypeCategoryImpl::GetTypeNameSpecifierForValidatorAtIndex(size_t index) {
if (index < GetTypeValidatorsContainer()->GetCount()) if (index < GetTypeValidatorsContainer()->GetCount())
return GetTypeValidatorsContainer()->GetTypeNameSpecifierAtIndex(index); return GetTypeValidatorsContainer()->GetTypeNameSpecifierAtIndex(index);
else
return GetRegexTypeValidatorsContainer()->GetTypeNameSpecifierAtIndex( return GetRegexTypeValidatorsContainer()->GetTypeNameSpecifierAtIndex(
index - GetTypeValidatorsContainer()->GetCount()); index - GetTypeValidatorsContainer()->GetCount());
} }
void TypeCategoryImpl::Enable(bool value, uint32_t position) { void TypeCategoryImpl::Enable(bool value, uint32_t position) {
Context not available.

source/DataFormatters/TypeFormat.cpp

Context not available.
} }
} }
return !dest.empty(); return !dest.empty();
} else }
return false; return false;
} }
std::string TypeFormatImpl_Format::GetDescription() { std::string TypeFormatImpl_Format::GetDescription() {
Context not available.

source/DataFormatters/TypeSummary.cpp

Context not available.
printer.PrintChildrenOneLiner(HideNames(valobj)); printer.PrintChildrenOneLiner(HideNames(valobj));
retval = s.GetString(); retval = s.GetString();
return true; return true;
} else {
if (FormatEntity::Format(m_format, s, &sc, &exe_ctx,
&sc.line_entry.range.GetBaseAddress(), valobj,
false, false)) {
retval.assign(s.GetString());
return true;
} else {
retval.assign("error: summary string parsing error");
return false;
}
} }
if (FormatEntity::Format(m_format, s, &sc, &exe_ctx,
&sc.line_entry.range.GetBaseAddress(), valobj, false,
false)) {
retval.assign(s.GetString());
return true;
}
retval.assign("error: summary string parsing error");
return false;
} }
std::string StringSummaryFormat::GetDescription() { std::string StringSummaryFormat::GetDescription() {
Context not available.

source/DataFormatters/ValueObjectPrinter.cpp

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) }
if (value_printed == false && summary_printed == false)
return true; return true;
else else
return false; return false;
Context not available.
m_options.m_pointer_as_array.m_base_element, m_options.m_pointer_as_array.m_base_element,
m_options.m_pointer_as_array.m_stride, idx), m_options.m_pointer_as_array.m_stride, idx),
true); true);
} else {
// otherwise, do the usual thing
return synth_valobj->GetChildAtIndex(idx, true);
} }
// otherwise, do the usual thing
return synth_valobj->GetChildAtIndex(idx, true);
} }
void ValueObjectPrinter::PrintChildren( void ValueObjectPrinter::PrintChildren(
Context not available.
// we're done here - get out fast // we're done here - get out fast
return; return;
} else }
m_printed_instance_pointers->emplace( m_printed_instance_pointers->emplace(
instance_ptr_value); // remember this guy for future reference instance_ptr_value); // remember this guy for future reference
} }
if (print_children) { if (print_children) {
Context not available.

source/Expression/DWARFExpression.cpp

Context not available.
if (reg_info.name) { if (reg_info.name) {
s->PutCString(reg_info.name); s->PutCString(reg_info.name);
break; break;
} else if (reg_info.alt_name) { }
if (reg_info.alt_name) {
s->PutCString(reg_info.alt_name); s->PutCString(reg_info.alt_name);
break; break;
} }
Context not available.
if (reg_info.name) { if (reg_info.name) {
s->Printf("[%s%+" PRIi64 "]", reg_info.name, reg_offset); s->Printf("[%s%+" PRIi64 "]", reg_info.name, reg_offset);
break; break;
} else if (reg_info.alt_name) { }
if (reg_info.alt_name) {
s->Printf("[%s%+" PRIi64 "]", reg_info.alt_name, reg_offset); s->Printf("[%s%+" PRIi64 "]", reg_info.alt_name, reg_offset);
break; break;
} }
Context not available.
if (reg_info.name) { if (reg_info.name) {
s->PutCString(reg_info.name); s->PutCString(reg_info.name);
break; break;
} else if (reg_info.alt_name) { }
if (reg_info.alt_name) {
s->PutCString(reg_info.alt_name); s->PutCString(reg_info.alt_name);
break; break;
} }
Context not available.
if (reg_info.name) { if (reg_info.name) {
s->Printf("[%s%+" PRIi64 "]", reg_info.name, reg_offset); s->Printf("[%s%+" PRIi64 "]", reg_info.name, reg_offset);
break; break;
} else if (reg_info.alt_name) { }
if (reg_info.alt_name) {
s->Printf("[%s%+" PRIi64 "]", reg_info.alt_name, reg_offset); s->Printf("[%s%+" PRIi64 "]", reg_info.alt_name, reg_offset);
break; break;
} }
Context not available.
if (error_ptr) if (error_ptr)
error_ptr->Clear(); error_ptr->Clear();
return true; return true;
} else {
// If we get this error, then we need to implement a value buffer in
// the dwarf expression evaluation function...
if (error_ptr)
error_ptr->SetErrorStringWithFormat(
"register %s can't be converted to a scalar value",
reg_info->name);
} }
// If we get this error, then we need to implement a value buffer in
// the dwarf expression evaluation function...
if (error_ptr)
error_ptr->SetErrorStringWithFormat(
"register %s can't be converted to a scalar value",
reg_info->name);
} else { } else {
if (error_ptr) if (error_ptr)
error_ptr->SetErrorStringWithFormat("register %s is not available", error_ptr->SetErrorStringWithFormat("register %s is not available",
Context not available.
const lldb::addr_t op_file_addr = m_data.GetAddress(&offset); const lldb::addr_t op_file_addr = m_data.GetAddress(&offset);
if (curr_op_addr_idx == op_addr_idx) if (curr_op_addr_idx == op_addr_idx)
return op_file_addr; return op_file_addr;
else
++curr_op_addr_idx; ++curr_op_addr_idx;
} else if (op == DW_OP_GNU_addr_index) { } else if (op == DW_OP_GNU_addr_index) {
uint64_t index = m_data.GetULEB128(&offset); uint64_t index = m_data.GetULEB128(&offset);
if (curr_op_addr_idx == op_addr_idx) { if (curr_op_addr_idx == op_addr_idx) {
Context not available.
} }
return ReadAddressFromDebugAddrSection(m_dwarf_cu, index); return ReadAddressFromDebugAddrSection(m_dwarf_cu, index);
} else }
++curr_op_addr_idx; ++curr_op_addr_idx;
} else { } else {
const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op); const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
if (op_arg_size == LLDB_INVALID_OFFSET) { if (op_arg_size == LLDB_INVALID_OFFSET) {
Context not available.
// the heap data so "m_data" will now correctly manage the heap data. // the heap data so "m_data" will now correctly manage the heap data.
m_data.SetData(DataBufferSP(head_data_ap.release())); m_data.SetData(DataBufferSP(head_data_ap.release()));
return true; return true;
} else {
const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
if (op_arg_size == LLDB_INVALID_OFFSET)
break;
offset += op_arg_size;
} }
const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
if (op_arg_size == LLDB_INVALID_OFFSET)
break;
offset += op_arg_size;
} }
return false; return false;
} }
Context not available.
const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op); const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
if (op_arg_size == LLDB_INVALID_OFFSET) if (op_arg_size == LLDB_INVALID_OFFSET)
return false; return false;
else
offset += op_arg_size; offset += op_arg_size;
} }
return false; return false;
} }
Context not available.
const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op); const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
if (op_arg_size == LLDB_INVALID_OFFSET) if (op_arg_size == LLDB_INVALID_OFFSET)
return false; return false;
else
offset += op_arg_size; offset += op_arg_size;
} }
} }
Context not available.
if (error_ptr) if (error_ptr)
error_ptr->SetErrorString("Divide by zero."); error_ptr->SetErrorString("Divide by zero.");
return false; return false;
} else {
stack.pop_back();
stack.back() =
stack.back().ResolveValue(exe_ctx) / tmp.ResolveValue(exe_ctx);
if (!stack.back().ResolveValue(exe_ctx).IsValid()) {
if (error_ptr)
error_ptr->SetErrorString("Divide failed.");
return false;
}
} }
stack.pop_back();
stack.back() =
stack.back().ResolveValue(exe_ctx) / tmp.ResolveValue(exe_ctx);
if (!stack.back().ResolveValue(exe_ctx).IsValid()) {
if (error_ptr)
error_ptr->SetErrorString("Divide failed.");
return false;
}
} }
break; break;
Context not available.
MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum), MatchBinaryOp(MatchOpType(Instruction::Operand::Type::Sum),
MatchRegOp(*reg), MatchRegOp(*reg),
MatchImmOp(offset)))(operand); MatchImmOp(offset)))(operand);
} else {
return MatchRegOp(*reg)(operand);
} }
return MatchRegOp(*reg)(operand);
} }
Context not available.

source/Expression/ExpressionSourceCode.cpp

Context not available.
if (line >= m_current_file_line) if (line >= m_current_file_line)
return false; return false;
else
return true; return true;
default: default:
return false; return false;
} }
Context not available.

source/Expression/ExpressionVariable.cpp

Context not available.
if (si != m_symbol_map.end()) if (si != m_symbol_map.end())
return si->second; return si->second;
else
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
} }
void PersistentExpressionState::RegisterExecutionUnit( void PersistentExpressionState::RegisterExecutionUnit(
Context not available.

source/Expression/IRDynamicChecks.cpp

Context not available.
if (m_valid_pointer_check && m_valid_pointer_check->ContainsAddress(addr)) { if (m_valid_pointer_check && m_valid_pointer_check->ContainsAddress(addr)) {
message.Printf("Attempted to dereference an invalid pointer."); message.Printf("Attempted to dereference an invalid pointer.");
return true; return true;
} else if (m_objc_object_check && }
m_objc_object_check->ContainsAddress(addr)) { if (m_objc_object_check && m_objc_object_check->ContainsAddress(addr)) {
message.Printf("Attempted to dereference an invalid ObjC Object or send it " message.Printf("Attempted to dereference an invalid ObjC Object or send it "
"an unrecognized selector"); "an unrecognized selector");
return true; return true;
Context not available.

source/Expression/IRExecutionUnit.cpp

Context not available.
if (param_and_qual_matches.size()) if (param_and_qual_matches.size())
return param_and_qual_matches[0]; // It is assumed that there will be only return param_and_qual_matches[0]; // It is assumed that there will be only
// one! // one!
else if (param_matches.size()) if (param_matches.size())
return param_matches[0]; // Return one of them as a best match return param_matches[0]; // Return one of them as a best match
else else
return ConstString(); return ConstString();
Context not available.
if (load_address != LLDB_INVALID_ADDRESS) { if (load_address != LLDB_INVALID_ADDRESS) {
if (is_external) { if (is_external) {
return true; return true;
} else if (best_internal_load_address == LLDB_INVALID_ADDRESS) { }
if (best_internal_load_address == LLDB_INVALID_ADDRESS) {
best_internal_load_address = load_address; best_internal_load_address = load_address;
load_address = LLDB_INVALID_ADDRESS; load_address = LLDB_INVALID_ADDRESS;
} }
Context not available.
if (get_external_load_address(load_address, sc_list, sc)) { if (get_external_load_address(load_address, sc_list, sc)) {
return load_address; return load_address;
} else {
sc_list.Clear();
} }
sc_list.Clear();
if (sc_list.GetSize() == 0 && sc.target_sp) { if (sc_list.GetSize() == 0 && sc.target_sp) {
sc.target_sp->GetImages().FindFunctions(spec.name, spec.mask, sc.target_sp->GetImages().FindFunctions(spec.name, spec.mask,
Context not available.
if (get_external_load_address(load_address, sc_list, sc)) { if (get_external_load_address(load_address, sc_list, sc)) {
return load_address; return load_address;
} else {
sc_list.Clear();
} }
sc_list.Clear();
if (sc_list.GetSize() == 0 && sc.target_sp) { if (sc_list.GetSize() == 0 && sc.target_sp) {
sc.target_sp->GetImages().FindSymbolsWithNameAndType( sc.target_sp->GetImages().FindSymbolsWithNameAndType(
Context not available.
m_parent.ReportSymbolLookupError(name_cs); m_parent.ReportSymbolLookupError(name_cs);
return 0; return 0;
} else {
if (log)
log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = %" PRIx64,
Name.c_str(), ret);
return ret;
} }
if (log)
log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = %" PRIx64,
Name.c_str(), ret);
return ret;
} }
void *IRExecutionUnit::MemoryManager::getPointerToNamedFunction( void *IRExecutionUnit::MemoryManager::getPointerToNamedFunction(
Context not available.

source/Expression/IRInterpreter.cpp

Context not available.
return AssignToMatchType(scalar, value_apint.getLimitedValue(), return AssignToMatchType(scalar, value_apint.getLimitedValue(),
value->getType()); value->getType());
} else { }
lldb::addr_t process_address = ResolveValue(value, module); lldb::addr_t process_address = ResolveValue(value, module);
size_t value_size = m_target_data.getTypeStoreSize(value->getType()); size_t value_size = m_target_data.getTypeStoreSize(value->getType());
lldb_private::DataExtractor value_extractor; lldb_private::DataExtractor value_extractor;
lldb_private::Status extract_error; lldb_private::Status extract_error;
m_execution_unit.GetMemoryData(value_extractor, process_address, m_execution_unit.GetMemoryData(value_extractor, process_address, value_size,
value_size, extract_error); extract_error);
if (!extract_error.Success()) if (!extract_error.Success())
return false; return false;
lldb::offset_t offset = 0; lldb::offset_t offset = 0;
if (value_size <= 8) { if (value_size <= 8) {
uint64_t u64value = value_extractor.GetMaxU64(&offset, value_size); uint64_t u64value = value_extractor.GetMaxU64(&offset, value_size);
return AssignToMatchType(scalar, u64value, value->getType()); return AssignToMatchType(scalar, u64value, value->getType());
} }
}
return false; return false;
} }
Context not available.

source/Expression/IRMemoryMap.cpp

Context not available.
if (!alloc_error.Success()) if (!alloc_error.Success())
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
else
return ret; return ret;
} }
// At this point we know that we need to hunt. // At this point we know that we need to hunt.
Context not available.
if (region_info.GetRange().GetRangeEnd() - 1 >= end_of_memory) { if (region_info.GetRange().GetRangeEnd() - 1 >= end_of_memory) {
ret = LLDB_INVALID_ADDRESS; ret = LLDB_INVALID_ADDRESS;
break; break;
} else {
ret = region_info.GetRange().GetRangeEnd();
} }
ret = region_info.GetRange().GetRangeEnd();
} else if (ret + size < region_info.GetRange().GetRangeEnd()) { } else if (ret + size < region_info.GetRange().GetRangeEnd()) {
return ret; return ret;
} else { } else {
Context not available.
scalar.GetAsMemoryData(buf, size, GetByteOrder(), error); scalar.GetAsMemoryData(buf, size, GetByteOrder(), error);
if (mem_size > 0) { if (mem_size > 0) {
return WriteMemory(process_address, buf, mem_size, error); return WriteMemory(process_address, buf, mem_size, error);
} else {
error.SetErrorToGenericError();
error.SetErrorString(
"Couldn't write scalar: failed to get scalar as memory data");
} }
error.SetErrorToGenericError();
error.SetErrorString(
"Couldn't write scalar: failed to get scalar as memory data");
} else { } else {
error.SetErrorToGenericError(); error.SetErrorToGenericError();
error.SetErrorString("Couldn't write scalar: its size was zero"); error.SetErrorString("Couldn't write scalar: its size was zero");
Context not available.

source/Expression/LLVMUserExpression.cpp

Context not available.
} }
return execution_result; return execution_result;
} else if (execution_result == lldb::eExpressionStoppedForDebug) { }
if (execution_result == lldb::eExpressionStoppedForDebug) {
diagnostic_manager.PutString( diagnostic_manager.PutString(
eDiagnosticSeverityRemark, eDiagnosticSeverityRemark,
"Execution was halted at the first instruction of the expression " "Execution was halted at the first instruction of the expression "
Context not available.
if (FinalizeJITExecution(diagnostic_manager, exe_ctx, result, if (FinalizeJITExecution(diagnostic_manager, exe_ctx, result,
function_stack_bottom, function_stack_top)) { function_stack_bottom, function_stack_top)) {
return lldb::eExpressionCompleted; return lldb::eExpressionCompleted;
} else {
return lldb::eExpressionResultUnavailable;
} }
return lldb::eExpressionResultUnavailable;
} else { } else {
diagnostic_manager.PutString( diagnostic_manager.PutString(
eDiagnosticSeverityError, eDiagnosticSeverityError,
Context not available.

source/Expression/UserExpression.cpp

Context not available.
if (m_address.IsValid()) { if (m_address.IsValid()) {
if (!frame_sp) if (!frame_sp)
return false; return false;
else
return (0 == Address::CompareLoadAddress(m_address, return (0 == Address::CompareLoadAddress(m_address,
frame_sp->GetFrameCodeAddress(), frame_sp->GetFrameCodeAddress(),
target_sp.get())); target_sp.get()));
} }
return true; return true;
Context not available.

source/Host/common/File.cpp

Context not available.
if (options & File::eOpenOptionRead) { if (options & File::eOpenOptionRead) {
if (options & File::eOpenOptionCanCreateNewOnly) if (options & File::eOpenOptionCanCreateNewOnly)
return "a+x"; return "a+x";
else
return "a+"; return "a+";
} else if (options & File::eOpenOptionWrite) { } else if (options & File::eOpenOptionWrite) {
if (options & File::eOpenOptionCanCreateNewOnly) if (options & File::eOpenOptionCanCreateNewOnly)
return "ax"; return "ax";
else
return "a"; return "a";
} }
} else if (options & File::eOpenOptionRead && } else if (options & File::eOpenOptionRead &&
options & File::eOpenOptionWrite) { options & File::eOpenOptionWrite) {
if (options & File::eOpenOptionCanCreate) { if (options & File::eOpenOptionCanCreate) {
if (options & File::eOpenOptionCanCreateNewOnly) if (options & File::eOpenOptionCanCreateNewOnly)
return "w+x"; return "w+x";
else
return "w+"; return "w+";
} else } else
return "r+"; return "r+";
} else if (options & File::eOpenOptionRead) { } else if (options & File::eOpenOptionRead) {
Context not available.

source/Host/common/Host.cpp

Context not available.
WaitStatus WaitStatus::Decode(int wstatus) { WaitStatus WaitStatus::Decode(int wstatus) {
if (WIFEXITED(wstatus)) if (WIFEXITED(wstatus))
return {Exit, uint8_t(WEXITSTATUS(wstatus))}; return {Exit, uint8_t(WEXITSTATUS(wstatus))};
else if (WIFSIGNALED(wstatus)) if (WIFSIGNALED(wstatus))
return {Signal, uint8_t(WTERMSIG(wstatus))}; return {Signal, uint8_t(WTERMSIG(wstatus))};
else if (WIFSTOPPED(wstatus)) else if (WIFSTOPPED(wstatus))
return {Stop, uint8_t(WSTOPSIG(wstatus))}; return {Stop, uint8_t(WSTOPSIG(wstatus))};
Context not available.

source/Host/common/NativeProcessProtocol.cpp

Context not available.
bool hardware) { bool hardware) {
if (hardware) if (hardware)
return RemoveHardwareBreakpoint(addr); return RemoveHardwareBreakpoint(addr);
else
return RemoveSoftwareBreakpoint(addr); return RemoveSoftwareBreakpoint(addr);
} }
Status NativeProcessProtocol::ReadMemoryWithoutTrap(lldb::addr_t addr, Status NativeProcessProtocol::ReadMemoryWithoutTrap(lldb::addr_t addr,
Context not available.

source/Host/common/NativeRegisterContext.cpp

Context not available.
"%" PRIu64, "%" PRIu64,
__FUNCTION__, value.GetAsUInt64()); __FUNCTION__, value.GetAsUInt64());
return value.GetAsUInt64(); return value.GetAsUInt64();
} else {
if (log)
log->Printf("NativeRegisterContext::%s ReadRegister() failed, error %s",
__FUNCTION__, error.AsCString());
} }
if (log)
log->Printf("NativeRegisterContext::%s ReadRegister() failed, error %s",
__FUNCTION__, error.AsCString());
} else { } else {
if (log) if (log)
log->Printf("NativeRegisterContext::%s ReadRegister() null reg_info", log->Printf("NativeRegisterContext::%s ReadRegister() null reg_info",
Context not available.

source/Host/common/Symbols.cpp

Context not available.
log->Printf("dSYM with matching UUID & arch found at %s", dsym_fspec.GetPath().c_str()); log->Printf("dSYM with matching UUID & arch found at %s", dsym_fspec.GetPath().c_str());
} }
return true; return true;
} else { }
FileSpec parent_dirs = exec_fspec; FileSpec parent_dirs = exec_fspec;
// Remove the binary name from the FileSpec // Remove the binary name from the FileSpec
parent_dirs.RemoveLastPathComponent(); parent_dirs.RemoveLastPathComponent();
// Add a ".dSYM" name to each directory component of the path, // Add a ".dSYM" name to each directory component of the path,
// stripping off components. e.g. we may have a binary like // stripping off components. e.g. we may have a binary like
// /S/L/F/Foundation.framework/Versions/A/Foundation and // /S/L/F/Foundation.framework/Versions/A/Foundation and
// /S/L/F/Foundation.framework.dSYM // /S/L/F/Foundation.framework.dSYM
// //
// so we'll need to start with // so we'll need to start with
// /S/L/F/Foundation.framework/Versions/A, add the .dSYM part to the // /S/L/F/Foundation.framework/Versions/A, add the .dSYM part to the
// "A", and if that doesn't exist, strip off the "A" and try it again // "A", and if that doesn't exist, strip off the "A" and try it again
// with "Versions", etc., until we find a dSYM bundle or we've // with "Versions", etc., until we find a dSYM bundle or we've
// stripped off enough path components that there's no need to // stripped off enough path components that there's no need to
// continue. // continue.
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
// Does this part of the path have a "." character - could it be a // Does this part of the path have a "." character - could it be a
// bundle's top level directory? // bundle's top level directory?
const char *fn = parent_dirs.GetFilename().AsCString(); const char *fn = parent_dirs.GetFilename().AsCString();
if (fn == nullptr) if (fn == nullptr)
break; break;
if (::strchr(fn, '.') != nullptr) { if (::strchr(fn, '.') != nullptr) {
if (::LookForDsymNextToExecutablePath (module_spec, parent_dirs, dsym_fspec)) { if (::LookForDsymNextToExecutablePath(module_spec, parent_dirs,
if (log) { dsym_fspec)) {
log->Printf("dSYM with matching UUID & arch found at %s", if (log) {
dsym_fspec.GetPath().c_str()); log->Printf("dSYM with matching UUID & arch found at %s",
} dsym_fspec.GetPath().c_str());
return true;
} }
return true;
} }
parent_dirs.RemoveLastPathComponent();
} }
} parent_dirs.RemoveLastPathComponent();
}
} }
dsym_fspec.Clear(); dsym_fspec.Clear();
return false; return false;
Context not available.

source/Host/common/UDPSocket.cpp

Context not available.
final_socket.reset(new UDPSocket(send_fd)); final_socket.reset(new UDPSocket(send_fd));
final_socket->m_sockaddr = service_info_ptr; final_socket->m_sockaddr = service_info_ptr;
break; break;
} else }
continue; continue;
} }
::freeaddrinfo(service_info_list); ::freeaddrinfo(service_info_list);
Context not available.

source/Host/common/XML.cpp

Context not available.
#if defined(LIBXML2_DEFINED) #if defined(LIBXML2_DEFINED)
if (IsValid()) if (IsValid())
return XMLNode(m_node->parent); return XMLNode(m_node->parent);
else
return XMLNode(); return XMLNode();
#else #else
return XMLNode(); return XMLNode();
#endif #endif
Context not available.
#if defined(LIBXML2_DEFINED) #if defined(LIBXML2_DEFINED)
if (IsValid()) if (IsValid())
return XMLNode(m_node->next); return XMLNode(m_node->next);
else
return XMLNode(); return XMLNode();
#else #else
return XMLNode(); return XMLNode();
#endif #endif
Context not available.
if (IsValid()) if (IsValid())
return XMLNode(m_node->children); return XMLNode(m_node->children);
else
return XMLNode(); return XMLNode();
#else #else
return XMLNode(); return XMLNode();
#endif #endif
Context not available.
#endif #endif
if (attr_value) if (attr_value)
return llvm::StringRef(attr_value); return llvm::StringRef(attr_value);
else
return llvm::StringRef(); return llvm::StringRef();
} }
bool XMLNode::GetAttributeValueAsUnsigned(const char *name, uint64_t &value, bool XMLNode::GetAttributeValueAsUnsigned(const char *name, uint64_t &value,
Context not available.
if (IsValid()) { if (IsValid()) {
if (path.empty()) if (path.empty())
return *this; return *this;
else {
XMLNode node = FindFirstChildElementWithName(path[0].c_str()); XMLNode node = FindFirstChildElementWithName(path[0].c_str());
const size_t n = path.size(); const size_t n = path.size();
for (size_t i = 1; node && i < n; ++i) for (size_t i = 1; node && i < n; ++i)
node = node.FindFirstChildElementWithName(path[i].c_str()); node = node.FindFirstChildElementWithName(path[i].c_str());
return node; return node;
}
} }
#endif #endif
Context not available.
// The text value _is_ the element name itself... // The text value _is_ the element name itself...
value = element_name.str(); value = element_name.str();
return true; return true;
} else if (element_name == "dict" || element_name == "array") }
if (element_name == "dict" || element_name == "array")
return false; // dictionaries and arrays have no text value, so we fail return false; // dictionaries and arrays have no text value, so we fail
else else
return node.GetElementText(value); return node.GetElementText(value);
Context not available.
return true; // Keep iterating through all child elements of the array return true; // Keep iterating through all child elements of the array
}); });
return array_sp; return array_sp;
} else if (element_name == "dict") { }
if (element_name == "dict") {
XMLNode key_node; XMLNode key_node;
std::shared_ptr<StructuredData::Dictionary> dict_sp( std::shared_ptr<StructuredData::Dictionary> dict_sp(
new StructuredData::Dictionary()); new StructuredData::Dictionary());
Context not available.

source/Host/macosx/Symbols.cpp

Context not available.
if (num_values == 1) { if (num_values == 1) {
return GetModuleSpecInfoFromUUIDDictionary(values[0], return GetModuleSpecInfoFromUUIDDictionary(values[0],
module_spec); module_spec);
} else { }
for (CFIndex i = 0; i < num_values; ++i) { for (CFIndex i = 0; i < num_values; ++i) {
ModuleSpec curr_module_spec; ModuleSpec curr_module_spec;
if (GetModuleSpecInfoFromUUIDDictionary(values[i], if (GetModuleSpecInfoFromUUIDDictionary(values[i],
curr_module_spec)) { curr_module_spec)) {
if (module_spec.GetArchitecture().IsCompatibleMatch( if (module_spec.GetArchitecture().IsCompatibleMatch(
curr_module_spec.GetArchitecture())) { curr_module_spec.GetArchitecture())) {
module_spec = curr_module_spec; module_spec = curr_module_spec;
return true; return true;
}
} }
} }
} }
Context not available.

source/Host/macosx/objcxx/Host.mm

Context not available.
// If the service is state-full, this is the time to initialize the new // If the service is state-full, this is the time to initialize the new
// service. // service.
return; return;
} else if (event == XPC_ERROR_CONNECTION_INVALID) { }
if (event == XPC_ERROR_CONNECTION_INVALID) {
// The service is invalid. Either the service name supplied to // The service is invalid. Either the service name supplied to
// xpc_connection_create() is incorrect // xpc_connection_create() is incorrect
// or we (this process) have canceled the service; we can do any cleanup // or we (this process) have canceled the service; we can do any cleanup
Context not available.
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
"cwd does not exist; cannot launch with shell argument expansion"); "cwd does not exist; cannot launch with shell argument expansion");
return error; return error;
} else {
FileSpec working_dir(wd);
free(wd);
launch_info.SetWorkingDirectory(working_dir);
} }
FileSpec working_dir(wd);
free(wd);
launch_info.SetWorkingDirectory(working_dir);
} }
RunShellCommand(expand_command, cwd, &status, nullptr, &output, RunShellCommand(expand_command, cwd, &status, nullptr, &output,
std::chrono::seconds(10)); std::chrono::seconds(10));
Context not available.

source/Host/posix/ConnectionFileDescriptorPosix.cpp

Context not available.
if ((addr = GetURLAddress(path, LISTEN_SCHEME))) { if ((addr = GetURLAddress(path, LISTEN_SCHEME))) {
// listen://HOST:PORT // listen://HOST:PORT
return SocketListenAndAccept(*addr, error_ptr); return SocketListenAndAccept(*addr, error_ptr);
} else if ((addr = GetURLAddress(path, ACCEPT_SCHEME))) { }
if ((addr = GetURLAddress(path, ACCEPT_SCHEME))) {
// unix://SOCKNAME // unix://SOCKNAME
return NamedSocketAccept(*addr, error_ptr); return NamedSocketAccept(*addr, error_ptr);
} else if ((addr = GetURLAddress(path, UNIX_ACCEPT_SCHEME))) { } else if ((addr = GetURLAddress(path, UNIX_ACCEPT_SCHEME))) {
Context not available.
m_read_sp.reset(); m_read_sp.reset();
m_write_sp.reset(); m_write_sp.reset();
return eConnectionStatusError; return eConnectionStatusError;
} else { }
// Don't take ownership of a file descriptor that gets passed to us // Don't take ownership of a file descriptor that gets passed to us
// since someone else opened the file descriptor and handed it to us. // since someone else opened the file descriptor and handed it to us.
// TODO: Since are using a URL to open connection we should // TODO: Since are using a URL to open connection we should
// eventually parse options using the web standard where we have // eventually parse options using the web standard where we have
// "fd://123?opt1=value;opt2=value" and we can have an option be // "fd://123?opt1=value;opt2=value" and we can have an option be
// "owns=1" or "owns=0" or something like this to allow us to specify // "owns=1" or "owns=0" or something like this to allow us to specify
// this. For now, we assume we must assume we don't own it. // this. For now, we assume we must assume we don't own it.
std::unique_ptr<TCPSocket> tcp_socket; std::unique_ptr<TCPSocket> tcp_socket;
tcp_socket.reset(new TCPSocket(fd, false, false)); tcp_socket.reset(new TCPSocket(fd, false, false));
// Try and get a socket option from this file descriptor to see if // Try and get a socket option from this file descriptor to see if
// this is a socket and set m_is_socket accordingly. // this is a socket and set m_is_socket accordingly.
int resuse; int resuse;
bool is_socket = bool is_socket =
!!tcp_socket->GetOption(SOL_SOCKET, SO_REUSEADDR, resuse); !!tcp_socket->GetOption(SOL_SOCKET, SO_REUSEADDR, resuse);
if (is_socket) { if (is_socket) {
m_read_sp = std::move(tcp_socket); m_read_sp = std::move(tcp_socket);
m_write_sp = m_read_sp; m_write_sp = m_read_sp;
} else { } else {
m_read_sp.reset(new File(fd, false)); m_read_sp.reset(new File(fd, false));
m_write_sp.reset(new File(fd, false)); m_write_sp.reset(new File(fd, false));
} }
m_uri = *addr; m_uri = *addr;
return eConnectionStatusSuccess; return eConnectionStatusSuccess;
}
} }
if (error_ptr) if (error_ptr)
Context not available.

source/Interpreter/CommandInterpreter.cpp

Context not available.
if (num_user_matches + num_cmd_matches + num_alias_matches == 1) { if (num_user_matches + num_cmd_matches + num_alias_matches == 1) {
if (num_cmd_matches) if (num_cmd_matches)
return real_match_sp; return real_match_sp;
else if (num_alias_matches) if (num_alias_matches)
return alias_match_sp; return alias_match_sp;
else else
return user_match_sp; return user_match_sp;
Context not available.
if (cmd_words.GetArgumentCount() == 1) if (cmd_words.GetArgumentCount() == 1)
return GetCommandSP(cmd_str, include_aliases, true, nullptr); return GetCommandSP(cmd_str, include_aliases, true, nullptr);
else {
// We have a multi-word command (seemingly), so we need to do more work. // We have a multi-word command (seemingly), so we need to do more work.
// First, get the cmd_obj_sp for the first word in the command. // First, get the cmd_obj_sp for the first word in the command.
CommandObjectSP cmd_obj_sp = GetCommandSP(llvm::StringRef(cmd_words.GetArgumentAtIndex(0)), CommandObjectSP cmd_obj_sp =
include_aliases, true, nullptr); GetCommandSP(llvm::StringRef(cmd_words.GetArgumentAtIndex(0)),
if (cmd_obj_sp.get() != nullptr) { include_aliases, true, nullptr);
// Loop through the rest of the words in the command (everything passed if (cmd_obj_sp.get() != nullptr) {
// in was supposed to be part of a command name), and find the // Loop through the rest of the words in the command (everything passed
// appropriate sub-command SP for each command word.... // in was supposed to be part of a command name), and find the
size_t end = cmd_words.GetArgumentCount(); // appropriate sub-command SP for each command word....
for (size_t j = 1; j < end; ++j) { size_t end = cmd_words.GetArgumentCount();
if (cmd_obj_sp->IsMultiwordObject()) { for (size_t j = 1; j < end; ++j) {
cmd_obj_sp = if (cmd_obj_sp->IsMultiwordObject()) {
cmd_obj_sp->GetSubcommandSP(cmd_words.GetArgumentAtIndex(j)); cmd_obj_sp =
if (cmd_obj_sp.get() == nullptr) cmd_obj_sp->GetSubcommandSP(cmd_words.GetArgumentAtIndex(j));
// The sub-command name was invalid. Fail and return the empty if (cmd_obj_sp.get() == nullptr)
// 'ret_val'. // The sub-command name was invalid. Fail and return the empty
return ret_val; // 'ret_val'.
} else
// We have more words in the command name, but we don't have a
// multiword object. Fail and return empty 'ret_val'.
return ret_val; return ret_val;
} } else
// We successfully looped through all the command words and got valid // We have more words in the command name, but we don't have a
// command objects for them. Assign the last object retrieved to // multiword object. Fail and return empty 'ret_val'.
// 'ret_val'. return ret_val;
ret_val = cmd_obj_sp;
} }
} // We successfully looped through all the command words and got valid
return ret_val; // command objects for them. Assign the last object retrieved to
// 'ret_val'.
ret_val = cmd_obj_sp;
}
return ret_val;
} }
CommandObject * CommandObject *
Context not available.
if (exact_match) { if (exact_match) {
full_name.assign(cmd); full_name.assign(cmd);
return exact_match; return exact_match;
} else {
StringList matches;
size_t num_alias_matches;
num_alias_matches =
AddNamesMatchingPartialString(m_alias_dict, cmd, matches);
if (num_alias_matches == 1) {
// Make sure this isn't shadowing a command in the regular command space:
StringList regular_matches;
const bool include_aliases = false;
const bool exact = false;
CommandObjectSP cmd_obj_sp(
GetCommandSP(cmd, include_aliases, exact, &regular_matches));
if (cmd_obj_sp || regular_matches.GetSize() > 0)
return false;
else {
full_name.assign(matches.GetStringAtIndex(0));
return true;
}
} else
return false;
} }
StringList matches;
size_t num_alias_matches;
num_alias_matches = AddNamesMatchingPartialString(m_alias_dict, cmd, matches);
if (num_alias_matches == 1) {
// Make sure this isn't shadowing a command in the regular command space:
StringList regular_matches;
const bool include_aliases = false;
const bool exact = false;
CommandObjectSP cmd_obj_sp(
GetCommandSP(cmd, include_aliases, exact, &regular_matches));
if (cmd_obj_sp || regular_matches.GetSize() > 0)
return false;
full_name.assign(matches.GetStringAtIndex(0));
return true;
} else
return false;
} }
bool CommandInterpreter::AliasExists(llvm::StringRef cmd) const { bool CommandInterpreter::AliasExists(llvm::StringRef cmd) const {
Context not available.
const size_t end_backtick = command.find('`', expr_content_start); const size_t end_backtick = command.find('`', expr_content_start);
if (end_backtick == std::string::npos) if (end_backtick == std::string::npos)
return error; return error;
else if (end_backtick == expr_content_start) { if (end_backtick == expr_content_start) {
// Empty expression (two backticks in a row) // Empty expression (two backticks in a row)
command.erase(start_backtick, 2); command.erase(start_backtick, 2);
} else { } else {
Context not available.
command.insert(start_backtick, value_strm.GetString()); command.insert(start_backtick, value_strm.GetString());
pos = start_backtick + value_string_size; pos = start_backtick + value_string_size;
continue; continue;
} else {
error.SetErrorStringWithFormat("expression value didn't result "
"in a scalar value for the "
"expression '%s'",
expr_str.c_str());
} }
error.SetErrorStringWithFormat("expression value didn't result "
"in a scalar value for the "
"expression '%s'",
expr_str.c_str());
} else { } else {
error.SetErrorStringWithFormat("expression value didn't result " error.SetErrorStringWithFormat("expression value didn't result "
"in a scalar value for the " "in a scalar value for the "
Context not available.
result.AppendError("empty command"); result.AppendError("empty command");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
} else {
command_line = m_repeat_command.c_str();
command_string = command_line;
original_command_string = command_line;
if (m_repeat_command.empty()) {
result.AppendErrorWithFormat("No auto repeat.\n");
result.SetStatus(eReturnStatusFailed);
return false;
}
} }
add_to_history = false; command_line = m_repeat_command.c_str();
command_string = command_line;
original_command_string = command_line;
if (m_repeat_command.empty()) {
result.AppendErrorWithFormat("No auto repeat.\n");
result.SetStatus(eReturnStatusFailed);
return false;
}
add_to_history = false;
} else { } else {
result.SetStatus(eReturnStatusSuccessFinishNoResult); result.SetStatus(eReturnStatusSuccessFinishNoResult);
return true; return true;
Context not available.
GetCommandObject(request.GetParsedLine().GetArgumentAtIndex(0)); GetCommandObject(request.GetParsedLine().GetArgumentAtIndex(0));
if (command_object == nullptr) { if (command_object == nullptr) {
return 0; return 0;
} else {
request.GetParsedLine().Shift();
request.SetCursorIndex(request.GetCursorIndex() - 1);
num_command_matches = command_object->HandleCompletion(request);
} }
request.GetParsedLine().Shift();
request.SetCursorIndex(request.GetCursorIndex() - 1);
num_command_matches = command_object->HandleCompletion(request);
} }
return num_command_matches; return num_command_matches;
Context not available.
if (first_arg) { if (first_arg) {
if (first_arg[0] == m_comment_char) if (first_arg[0] == m_comment_char)
return 0; return 0;
else if (first_arg[0] == CommandHistory::g_repeat_char) { if (first_arg[0] == CommandHistory::g_repeat_char) {
if (auto hist_str = m_command_history.FindString(first_arg)) { if (auto hist_str = m_command_history.FindString(first_arg)) {
matches.InsertStringAtIndex(0, *hist_str); matches.InsertStringAtIndex(0, *hist_str);
descriptions.InsertStringAtIndex(0, "Previous command history event"); descriptions.InsertStringAtIndex(0, "Previous command history event");
return -2; return -2;
} else }
return 0; return 0;
} }
} }
Context not available.
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
m_debugger.SetAsyncExecution(old_async_execution); m_debugger.SetAsyncExecution(old_async_execution);
return; return;
} else if (options.GetPrintResults()) { }
if (options.GetPrintResults()) {
result.AppendMessageWithFormat( result.AppendMessageWithFormat(
"Command #%" PRIu64 " '%s' failed with %s", (uint64_t)idx + 1, cmd, "Command #%" PRIu64 " '%s' failed with %s", (uint64_t)idx + 1, cmd,
error_msg.str().c_str()); error_msg.str().c_str());
Context not available.

source/Interpreter/CommandObject.cpp

Context not available.
// FIXME: Abstract telling the completion to insert the completion // FIXME: Abstract telling the completion to insert the completion
// character. // character.
return -1; return -1;
} else { }
// Can we do anything generic with the options? // Can we do anything generic with the options?
Options *cur_options = GetOptions(); Options *cur_options = GetOptions();
CommandReturnObject result; CommandReturnObject result;
OptionElementVector opt_element_vector; OptionElementVector opt_element_vector;
if (cur_options != nullptr) { if (cur_options != nullptr) {
opt_element_vector = cur_options->ParseForCompletion( opt_element_vector = cur_options->ParseForCompletion(
request.GetParsedLine(), request.GetCursorIndex()); request.GetParsedLine(), request.GetCursorIndex());
bool handled_by_options = cur_options->HandleOptionCompletion( bool handled_by_options = cur_options->HandleOptionCompletion(
request, opt_element_vector, GetCommandInterpreter()); request, opt_element_vector, GetCommandInterpreter());
if (handled_by_options) if (handled_by_options)
return request.GetNumberOfMatches(); return request.GetNumberOfMatches();
} }
// If we got here, the last word is not an option or an option argument. // If we got here, the last word is not an option or an option argument.
return HandleArgumentCompletion(request, opt_element_vector); return HandleArgumentCompletion(request, opt_element_vector);
}
} }
bool CommandObject::HelpTextContainsWord(llvm::StringRef search_word, bool CommandObject::HelpTextContainsWord(llvm::StringRef search_word,
Context not available.
if (process) if (process)
return process->GetThreadList().GetSelectedThread().get(); return process->GetThreadList().GetSelectedThread().get();
else
return nullptr; return nullptr;
} }
bool CommandObjectParsed::Execute(const char *args_string, bool CommandObjectParsed::Execute(const char *args_string,
Context not available.

source/Interpreter/CommandObjectRegexCommand.cpp

Context not available.
CommandCompletions::InvokeCommonCompletionCallbacks( CommandCompletions::InvokeCommonCompletionCallbacks(
GetCommandInterpreter(), m_completion_type_mask, request, nullptr); GetCommandInterpreter(), m_completion_type_mask, request, nullptr);
return request.GetNumberOfMatches(); return request.GetNumberOfMatches();
} else {
request.SetWordComplete(false);
} }
request.SetWordComplete(false);
return 0; return 0;
} }
Context not available.

source/Interpreter/OptionArgParser.cpp

Context not available.
if (ref.equals_lower("false") || ref.equals_lower("off") || if (ref.equals_lower("false") || ref.equals_lower("off") ||
ref.equals_lower("no") || ref.equals_lower("0")) { ref.equals_lower("no") || ref.equals_lower("0")) {
return false; return false;
} else if (ref.equals_lower("true") || ref.equals_lower("on") || }
ref.equals_lower("yes") || ref.equals_lower("1")) { if (ref.equals_lower("true") || ref.equals_lower("on") ||
ref.equals_lower("yes") || ref.equals_lower("1")) {
return true; return true;
} }
if (success_ptr) if (success_ptr)
Context not available.
if (error_ptr) if (error_ptr)
error_ptr->Clear(); error_ptr->Clear();
return addr; return addr;
} else { }
if (error_ptr) { if (error_ptr) {
error_set = true; error_set = true;
error_ptr->SetErrorStringWithFormat( error_ptr->SetErrorStringWithFormat(
"address expression \"%s\" resulted in a value whose type " "address expression \"%s\" resulted in a value whose type "
"can't be converted to an address: %s", "can't be converted to an address: %s",
s.str().c_str(), valobj_sp->GetTypeName().GetCString()); s.str().c_str(), valobj_sp->GetTypeName().GetCString());
}
} }
} else { } else {
Context not available.
if (addr != LLDB_INVALID_ADDRESS) { if (addr != LLDB_INVALID_ADDRESS) {
if (add) if (add)
return addr + offset; return addr + offset;
else
return addr - offset; return addr - offset;
} }
} }
} }
Context not available.

source/Interpreter/OptionGroupFormat.cpp

Context not available.
if (m_byte_size.GetDefaultValue() < UINT64_MAX) { if (m_byte_size.GetDefaultValue() < UINT64_MAX) {
if (m_count.GetDefaultValue() < UINT64_MAX) if (m_count.GetDefaultValue() < UINT64_MAX)
return result; return result;
else
return result.take_front(3); return result.take_front(3);
} }
return result.take_front(2); return result.take_front(2);
} }
Context not available.

source/Interpreter/OptionValueArray.cpp

Context not available.
if (!sub_value.empty()) if (!sub_value.empty())
return m_values[new_idx]->GetSubValue(exe_ctx, sub_value, return m_values[new_idx]->GetSubValue(exe_ctx, sub_value,
will_modify, error); will_modify, error);
else
return m_values[new_idx]; return m_values[new_idx];
} }
} else { } else {
if (array_count == 0) if (array_count == 0)
Context not available.
if (idx >= size) { if (idx >= size) {
all_indexes_valid = false; all_indexes_valid = false;
break; break;
} else }
remove_indexes.push_back(idx); remove_indexes.push_back(idx);
} }
if (all_indexes_valid) { if (all_indexes_valid) {
Context not available.

source/Interpreter/OptionValuePathMappings.cpp

Context not available.
static bool VerifyPathExists(const char *path) { static bool VerifyPathExists(const char *path) {
if (path && path[0]) if (path && path[0])
return FileSystem::Instance().Exists(path); return FileSystem::Instance().Exists(path);
else
return false; return false;
} }
} }
Context not available.

source/Interpreter/OptionValueProperties.cpp

Context not available.
// Still more subvalue string to evaluate // Still more subvalue string to evaluate
return value_sp->GetSubValue(exe_ctx, rest, return value_sp->GetSubValue(exe_ctx, rest,
will_modify, error); will_modify, error);
} else {
// We have a match!
break;
} }
// We have a match!
break;
} }
} }
} }
Context not available.
const OptionValueArray *array = value->GetAsArray(); const OptionValueArray *array = value->GetAsArray();
if (array) if (array)
return array->GetArgs(args); return array->GetArgs(args);
else {
const OptionValueDictionary *dict = value->GetAsDictionary(); const OptionValueDictionary *dict = value->GetAsDictionary();
if (dict) if (dict)
return dict->GetArgs(args); return dict->GetArgs(args);
}
} }
} }
return false; return false;
Context not available.
OptionValueArray *array = value->GetAsArray(); OptionValueArray *array = value->GetAsArray();
if (array) if (array)
return array->SetArgs(args, eVarSetOperationAssign).Success(); return array->SetArgs(args, eVarSetOperationAssign).Success();
else {
OptionValueDictionary *dict = value->GetAsDictionary(); OptionValueDictionary *dict = value->GetAsDictionary();
if (dict) if (dict)
return dict->SetArgs(args, eVarSetOperationAssign).Success(); return dict->SetArgs(args, eVarSetOperationAssign).Success();
}
} }
} }
return false; return false;
Context not available.

source/Interpreter/Options.cpp

Context not available.
} }
return true; return true;
} else if (opt_defs_index == OptionArgElement::eBareDoubleDash) { }
if (opt_defs_index == OptionArgElement::eBareDoubleDash) {
std::string full_name("--"); std::string full_name("--");
for (auto &def : opt_defs) { for (auto &def : opt_defs) {
if (!def.short_option) if (!def.short_option)
Context not available.
full_name.append(opt_defs[opt_defs_index].long_option); full_name.append(opt_defs[opt_defs_index].long_option);
request.AddCompletion(full_name.c_str()); request.AddCompletion(full_name.c_str());
return true; return true;
} else {
request.AddCompletion(request.GetCursorArgument());
return true;
} }
request.AddCompletion(request.GetCursorArgument());
return true;
} else { } else {
// FIXME - not handling wrong options yet: // FIXME - not handling wrong options yet:
// Check to see if they are writing a long option & complete it. // Check to see if they are writing a long option & complete it.
Context not available.
interpreter); interpreter);
request.SetWordComplete(subrequest.GetWordComplete()); request.SetWordComplete(subrequest.GetWordComplete());
return true; return true;
} else {
// No completion callback means no completions...
return true;
} }
// No completion callback means no completions...
return true;
} else { } else {
// Not the last element, keep going. // Not the last element, keep going.
Context not available.
OptionArgElement(OptionArgElement::eBareDoubleDash, dash_dash_pos, OptionArgElement(OptionArgElement::eBareDoubleDash, dash_dash_pos,
OptionArgElement::eBareDoubleDash)); OptionArgElement::eBareDoubleDash));
continue; continue;
} else }
break; break;
} else } else
break; break;
} else if (val == '?') { } else if (val == '?') {
Context not available.

source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp

Context not available.
} }
} }
return false; return false;
} else { }
if (sp == 0) { if (sp == 0) {
// Read the stack pointer if it already hasn't been read // Read the stack pointer if it already hasn't been read
sp = reg_ctx->GetSP(0); sp = reg_ctx->GetSP(0);
if (sp == 0) if (sp == 0)
return false; return false;
} }
// Arguments 5 on up are on the stack // Arguments 5 on up are on the stack
const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8; const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
Context not available.
return false; return false;
sp += arg_byte_size; sp += arg_byte_size;
}
} }
} }
} }
Context not available.

source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

Context not available.
} }
} }
return false; return false;
} else { }
if (sp == 0) { if (sp == 0) {
// Read the stack pointer if we already haven't read it // Read the stack pointer if we already haven't read it
sp = reg_ctx->GetSP(0); sp = reg_ctx->GetSP(0);
if (sp == 0) if (sp == 0)
return false; return false;
} }
// Arguments 5 on up are on the stack // Arguments 5 on up are on the stack
const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8; const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
Context not available.
sp += 1; sp += 1;
sp <<= 3; sp <<= 3;
} }
}
} }
} }
} }
Context not available.

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

Context not available.
} }
} }
return false; return false;
} else { }
if (sp == 0) { if (sp == 0) {
// Read the stack pointer if it already hasn't been read // Read the stack pointer if it already hasn't been read
sp = reg_ctx->GetSP(0); sp = reg_ctx->GetSP(0);
if (sp == 0) if (sp == 0)
return false; return false;
} }
// Arguments 5 on up are on the stack // Arguments 5 on up are on the stack
const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8; const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
Context not available.
return false; return false;
sp += arg_byte_size; sp += arg_byte_size;
}
} }
} }
} }
Context not available.
if (index != 0 && if (index != 0 &&
vfp_byte_size != base_type.GetByteSize(nullptr)) vfp_byte_size != base_type.GetByteSize(nullptr))
break; break;
else
vfp_byte_size = base_type.GetByteSize(nullptr); vfp_byte_size = base_type.GetByteSize(nullptr);
} else } else
break; break;
} else } else
Context not available.
return ValueObjectConstResult::Create(&thread, compiler_type, return ValueObjectConstResult::Create(&thread, compiler_type,
ConstString(""), data); ConstString(""), data);
} else { // Some error occurred while getting values from registers } // Some error occurred while getting values from registers
return return_valobj_sp; return return_valobj_sp;
}
} }
// If we get here, we have a valid Value, so make our ValueObject out of it: // If we get here, we have a valid Value, so make our ValueObject out of it:
Context not available.

source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

Context not available.
} }
} }
return false; return false;
} else { }
// TODO: Verify for stack layout for SysV // TODO: Verify for stack layout for SysV
if (sp == 0) { if (sp == 0) {
// Read the stack pointer if we already haven't read it // Read the stack pointer if we already haven't read it
sp = reg_ctx->GetSP(0); sp = reg_ctx->GetSP(0);
if (sp == 0) if (sp == 0)
return false; return false;
} }
// Arguments 5 on up are on the stack // Arguments 5 on up are on the stack
Context not available.
sp += 1; sp += 1;
sp <<= 3; sp <<= 3;
} }
}
} }
} }
} }
Context not available.

source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp

Context not available.
if (field_bit_width == 128) { if (field_bit_width == 128) {
is_memory = true; is_memory = true;
break; break;
} else if (field_bit_width == 64) { }
if (field_bit_width == 64) {
copy_from_offset = 0; copy_from_offset = 0;
fp_bytes += field_byte_width; fp_bytes += field_byte_width;
} else if (field_bit_width == 32) { } else if (field_bit_width == 32) {
Context not available.

source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

Context not available.
if (GetByteOrder() == lldb::eByteOrderLittle) { if (GetByteOrder() == lldb::eByteOrderLittle) {
count = llvm::array_lengthof(g_register_infos_ppc64le); count = llvm::array_lengthof(g_register_infos_ppc64le);
return g_register_infos_ppc64le; return g_register_infos_ppc64le;
} else {
count = llvm::array_lengthof(g_register_infos_ppc64);
return g_register_infos_ppc64;
} }
count = llvm::array_lengthof(g_register_infos_ppc64);
return g_register_infos_ppc64;
} }
size_t ABISysV_ppc64::GetRedZoneSize() const { return 224; } size_t ABISysV_ppc64::GetRedZoneSize() const { return 224; }
Context not available.
std::string GetName() const { std::string GetName() const {
if (m_type == GPR) if (m_type == GPR)
return ("r" + llvm::Twine(m_index + 3)).str(); return ("r" + llvm::Twine(m_index + 3)).str();
else
return ("f" + llvm::Twine(m_index + 1)).str(); return ("f" + llvm::Twine(m_index + 1)).str();
} }
// get raw register data // get raw register data
Context not available.
if (type_flags & eTypeIsComplex) { if (type_flags & eTypeIsComplex) {
LLDB_LOG(m_log, LOG_PREFIX "Complex numbers are not supported yet"); LLDB_LOG(m_log, LOG_PREFIX "Complex numbers are not supported yet");
return ValueObjectSP(); return ValueObjectSP();
} else {
value_sp = GetFloatValue(m_type, 0);
} }
value_sp = GetFloatValue(m_type, 0);
} }
} else if (type_flags & eTypeIsPointer) { } else if (type_flags & eTypeIsPointer) {
value_sp = GetPointerValue(0); value_sp = GetPointerValue(0);
Context not available.

source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

Context not available.
if (field_bit_width == 128) { if (field_bit_width == 128) {
is_memory = true; is_memory = true;
break; break;
} else if (field_bit_width == 64) { }
if (field_bit_width == 64) {
// These have to be in a single xmm register. // These have to be in a single xmm register.
if (fp_bytes == 0) if (fp_bytes == 0)
copy_from_extractor = &xmm0_data; copy_from_extractor = &xmm0_data;
Context not available.

source/Plugins/Architecture/Mips/ArchitectureMips.cpp

Context not available.
inst_to_choose = 1; inst_to_choose = 1;
break; break;
} }
else if (insn_size == 4) { if (insn_size == 4) {
// This instruction claims its a valid 4-byte instruction. But it // This instruction claims its a valid 4-byte instruction. But it
// could be a part of it's upper 4-byte instruction. Lets try // could be a part of it's upper 4-byte instruction. Lets try
// scanning upper 2 bytes to verify this. // scanning upper 2 bytes to verify this.
Context not available.

source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp

Context not available.
} }
m_mnemonics = mnemonic_strm.GetString(); m_mnemonics = mnemonic_strm.GetString();
return; return;
} else { }
if (m_does_branch == eLazyBoolCalculate) { if (m_does_branch == eLazyBoolCalculate) {
const bool can_branch = mc_disasm_ptr->CanBranch(inst); const bool can_branch = mc_disasm_ptr->CanBranch(inst);
if (can_branch) if (can_branch)
m_does_branch = eLazyBoolYes; m_does_branch = eLazyBoolYes;
else else
m_does_branch = eLazyBoolNo; m_does_branch = eLazyBoolNo;
}
} }
static RegularExpression s_regex( static RegularExpression s_regex(
Context not available.
if (*osi >= '0' && *osi <= '9') { if (*osi >= '0' && *osi <= '9') {
if (str.empty()) { if (str.empty()) {
return std::make_pair(Operand(), osi); return std::make_pair(Operand(), osi);
} else {
str.push_back(*osi);
} }
str.push_back(*osi);
} else if (*osi >= 'a' && *osi <= 'z') { } else if (*osi >= 'a' && *osi <= 'z') {
str.push_back(*osi); str.push_back(*osi);
} else { } else {
Context not available.
deref.m_type = Operand::Type::Dereference; deref.m_type = Operand::Type::Dereference;
deref.m_children.push_back(offset); deref.m_children.push_back(offset);
return std::make_pair(deref, osi); return std::make_pair(deref, osi);
} else {
Operand deref;
deref.m_type = Operand::Type::Dereference;
deref.m_children.push_back(index);
return std::make_pair(deref, osi);
} }
Operand deref;
deref.m_type = Operand::Type::Dereference;
deref.m_children.push_back(index);
return std::make_pair(deref, osi);
} }
// -0x10(%rbp) // -0x10(%rbp)
Context not available.
deref.m_type = Operand::Type::Dereference; deref.m_type = Operand::Type::Dereference;
deref.m_children.push_back(offset); deref.m_children.push_back(offset);
return std::make_pair(deref, osi); return std::make_pair(deref, osi);
} else {
Operand deref;
deref.m_type = Operand::Type::Dereference;
deref.m_children.push_back(base_and_iterator.first);
return std::make_pair(deref, osi);
} }
Operand deref;
deref.m_type = Operand::Type::Dereference;
deref.m_children.push_back(base_and_iterator.first);
return std::make_pair(deref, osi);
} }
// [sp, #8]! // [sp, #8]!
Context not available.
llvm::nulls(), llvm::nulls()); llvm::nulls(), llvm::nulls());
if (status == llvm::MCDisassembler::Success) if (status == llvm::MCDisassembler::Success)
return new_inst_size; return new_inst_size;
else
return 0; return 0;
} }
void DisassemblerLLVMC::MCDisasmInstance::PrintMCInst( void DisassemblerLLVMC::MCDisasmInstance::PrintMCInst(
Context not available.
triple.getArch() == llvm::Triple::x86_64) { triple.getArch() == llvm::Triple::x86_64) {
if (strcmp(flavor, "intel") == 0 || strcmp(flavor, "att") == 0) if (strcmp(flavor, "intel") == 0 || strcmp(flavor, "att") == 0)
return true; return true;
else
return false; return false;
} else } else
return false; return false;
} }
Context not available.

source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

Context not available.
// check we have successfully set bp // check we have successfully set bp
return (dyld_break != nullptr); return (dyld_break != nullptr);
} else }
// rendezvous already set // rendezvous already set
return true; return true;
} }
// We have just hit our breakpoint at <_rtld_debug_state> // We have just hit our breakpoint at <_rtld_debug_state>
Context not available.
addr, sizeof(uint32_t), 0, error); addr, sizeof(uint32_t), 0, error);
if (error.Fail()) if (error.Fail())
return -1; return -1;
else
return value; return value;
} }
lldb::addr_t lldb::addr_t
Context not available.
if (tls_block == LLDB_INVALID_ADDRESS) if (tls_block == LLDB_INVALID_ADDRESS)
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
else
return tls_block + tls_file_addr; return tls_block + tls_file_addr;
} }
Context not available.

source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.cpp

Context not available.
// accordingly. // accordingly.
if (m_previous.state == eAdd) if (m_previous.state == eAdd)
return UpdateSOEntriesForAddition(); return UpdateSOEntriesForAddition();
else if (m_previous.state == eDelete) if (m_previous.state == eDelete)
return UpdateSOEntriesForDeletion(); return UpdateSOEntriesForDeletion();
return false; return false;
Context not available.
return std::string(); return std::string();
if (c == 0) if (c == 0)
break; break;
else {
str.push_back(c); str.push_back(c);
addr++; addr++;
}
} }
return str; return str;
Context not available.

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

Context not available.
if (header.cputype) { if (header.cputype) {
if (header.cputype & llvm::MachO::CPU_ARCH_ABI64) if (header.cputype & llvm::MachO::CPU_ARCH_ABI64)
return 8; return 8;
else
return 4; return 4;
} }
return 0; return 0;
} }
Context not available.

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

Context not available.
} }
} }
return true; return true;
} else {
return false;
} }
return false;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Context not available.
// and then we'll // and then we'll
// figure it out when we hit the added breakpoint. // figure it out when we hit the added breakpoint.
return false; return false;
} else { }
if (!AddModulesUsingImageInfosAddress( if (!AddModulesUsingImageInfosAddress(
m_dyld_all_image_infos.dylib_info_addr, m_dyld_all_image_infos.dylib_info_addr,
m_dyld_all_image_infos.dylib_info_count)) { m_dyld_all_image_infos.dylib_info_count)) {
DEBUG_PRINTF("%s", "unable to read all data for all_dylib_infos."); DEBUG_PRINTF("%s", "unable to read all data for all_dylib_infos.");
m_dyld_image_infos.clear(); m_dyld_image_infos.clear();
}
} }
// Now we have one more bit of business. If there is a library left in the // Now we have one more bit of business. If there is a library left in the
Context not available.
} }
return true; return true;
} else }
return false; return false;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Context not available.

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

Context not available.
DataBufferSP AuxVector::GetAuxvData() { DataBufferSP AuxVector::GetAuxvData() {
if (m_process) if (m_process)
return m_process->GetAuxvData(); return m_process->GetAuxvData();
else
return DataBufferSP(); return DataBufferSP();
} }
void AuxVector::ParseAuxv(DataExtractor &data) { void AuxVector::ParseAuxv(DataExtractor &data) {
Context not available.

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

Context not available.
// accordingly. // accordingly.
if (m_previous.state == eAdd) if (m_previous.state == eAdd)
return fromRemote ? AddSOEntriesFromRemote(module_list) : AddSOEntries(); return fromRemote ? AddSOEntriesFromRemote(module_list) : AddSOEntries();
else if (m_previous.state == eDelete) if (m_previous.state == eDelete)
return fromRemote ? RemoveSOEntriesFromRemote(module_list) return fromRemote ? RemoveSOEntriesFromRemote(module_list)
: RemoveSOEntries(); : RemoveSOEntries();
Context not available.

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

Context not available.
if (tls_block == LLDB_INVALID_ADDRESS) if (tls_block == LLDB_INVALID_ADDRESS)
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
else
return tls_block + tls_file_addr; return tls_block + tls_file_addr;
} }
void DynamicLoaderPOSIXDYLD::ResolveExecutableModule( void DynamicLoaderPOSIXDYLD::ResolveExecutableModule(
Context not available.

source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

Context not available.
return GetMergerUnchecked().FindExternalLexicalDecls(decl_context, return GetMergerUnchecked().FindExternalLexicalDecls(decl_context,
predicate, predicate,
decls); decls);
} else if (!m_ast_importer_sp) }
if (!m_ast_importer_sp)
return; return;
ClangASTMetrics::RegisterLexicalQuery(); ClangASTMetrics::RegisterLexicalQuery();
Context not available.
clang::ASTContext &from_context = src_decl->getASTContext(); clang::ASTContext &from_context = src_decl->getASTContext();
if (m_ast_importer_sp) { if (m_ast_importer_sp) {
return m_ast_importer_sp->CopyDecl(m_ast_context, &from_context, src_decl); return m_ast_importer_sp->CopyDecl(m_ast_context, &from_context, src_decl);
} else if (m_merger_up) { }
if (m_merger_up) {
if (!m_merger_up->HasImporterForOrigin(from_context)) { if (!m_merger_up->HasImporterForOrigin(from_context)) {
lldbassert(0 && "Couldn't find the importer for a source context!"); lldbassert(0 && "Couldn't find the importer for a source context!");
return nullptr; return nullptr;
Context not available.
if (m_ast_importer_sp) { if (m_ast_importer_sp) {
return m_ast_importer_sp->ResolveDeclOrigin(decl, original_decl, return m_ast_importer_sp->ResolveDeclOrigin(decl, original_decl,
original_ctx); original_ctx);
} else if (m_merger_up) { }
if (m_merger_up) {
return false; // Implement this correctly in ExternalASTMerger return false; // Implement this correctly in ExternalASTMerger
} else { } else {
// this can happen early enough that no ExternalASTSource is installed. // this can happen early enough that no ExternalASTSource is installed.
Context not available.
m_decls.push_back(typedef_name_decl); m_decls.push_back(typedef_name_decl);
return (NamedDecl *)typedef_name_decl; return (NamedDecl *)typedef_name_decl;
} else if (const TagType *tag_type = qual_type->getAs<TagType>()) { }
if (const TagType *tag_type = qual_type->getAs<TagType>()) {
TagDecl *tag_decl = tag_type->getDecl(); TagDecl *tag_decl = tag_type->getDecl();
m_decls.push_back(tag_decl); m_decls.push_back(tag_decl);
Context not available.

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h

Context not available.
Target *GetTarget() { Target *GetTarget() {
if (m_exe_ctx.GetTargetPtr()) if (m_exe_ctx.GetTargetPtr())
return m_exe_ctx.GetTargetPtr(); return m_exe_ctx.GetTargetPtr();
else if (m_sym_ctx.target_sp) if (m_sym_ctx.target_sp)
m_sym_ctx.target_sp.get(); m_sym_ctx.target_sp.get();
return NULL; return NULL;
} }
Context not available.

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

Context not available.
target.getASTContext(), source.getASTContext(), target.getASTContext(), source.getASTContext(),
parser_type.GetOpaqueQualType()), parser_type.GetOpaqueQualType()),
&target); &target);
} else if (m_merger_up) { }
if (m_merger_up) {
clang::FileID source_file = clang::FileID source_file =
source.getASTContext()->getSourceManager().getFileID( source.getASTContext()->getSourceManager().getFileID(
source.getASTContext()->getTranslationUnitDecl()->getLocation()); source.getASTContext()->getTranslationUnitDecl()->getLocation());
Context not available.
} }
return; return;
} else { }
// This branch will get hit if we are executing code in the context of // This branch will get hit if we are executing code in the context of
// a function that claims to have an object pointer (through // a function that claims to have an object pointer (through
// DW_AT_object_pointer?) but is not formally a method of the class. // DW_AT_object_pointer?) but is not formally a method of the class.
// In that case, just look up the "self" variable in the current scope // In that case, just look up the "self" variable in the current scope
// and use its type. // and use its type.
VariableList *vars = frame->GetVariableList(false); VariableList *vars = frame->GetVariableList(false);
lldb::VariableSP self_var = vars->FindVariable(ConstString("self")); lldb::VariableSP self_var = vars->FindVariable(ConstString("self"));
if (self_var && self_var->IsInScope(frame) && if (self_var && self_var->IsInScope(frame) &&
self_var->LocationIsValidForFrame(frame)) { self_var->LocationIsValidForFrame(frame)) {
Type *self_type = self_var->GetType(); Type *self_type = self_var->GetType();
if (!self_type) if (!self_type)
return; return;
CompilerType self_clang_type = self_type->GetFullCompilerType(); CompilerType self_clang_type = self_type->GetFullCompilerType();
if (ClangASTContext::IsObjCClassType(self_clang_type)) { if (ClangASTContext::IsObjCClassType(self_clang_type)) {
return; return;
} else if (ClangASTContext::IsObjCObjectPointerType( }
self_clang_type)) { if (ClangASTContext::IsObjCObjectPointerType(self_clang_type)) {
self_clang_type = self_clang_type.GetPointeeType(); self_clang_type = self_clang_type.GetPointeeType();
if (!self_clang_type) if (!self_clang_type)
return; return;
if (log) { if (log) {
ASTDumper ast_dumper(self_type->GetFullCompilerType()); ASTDumper ast_dumper(self_type->GetFullCompilerType());
log->Printf(" FEVD[%u] Adding type for $__lldb_objc_class: %s", log->Printf(" FEVD[%u] Adding type for $__lldb_objc_class: %s",
current_id, ast_dumper.GetCString()); current_id, ast_dumper.GetCString());
} }
TypeFromUser class_user_type(self_clang_type); TypeFromUser class_user_type(self_clang_type);
AddOneType(context, class_user_type, current_id); AddOneType(context, class_user_type, current_id);
TypeFromUser self_user_type(self_type->GetFullCompilerType()); TypeFromUser self_user_type(self_type->GetFullCompilerType());
m_struct_vars->m_object_pointer_type = self_user_type; m_struct_vars->m_object_pointer_type = self_user_type;
return; return;
} }
} }
}
return; return;
} }
Context not available.
context.AddNamedDecl(copied_function_decl); context.AddNamedDecl(copied_function_decl);
return; return;
} else { }
if (log) { if (log) {
log->Printf(" Failed to import the function decl for '%s'", log->Printf(" Failed to import the function decl for '%s'",
src_function_decl->getName().str().c_str()); src_function_decl->getName().str().c_str());
}
} }
} }
} }
Context not available.

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

Context not available.
// FIXME - do we want to try to propagate specific errors here? // FIXME - do we want to try to propagate specific errors here?
if (!commit.isCommitable()) if (!commit.isCommitable())
return false; return false;
else if (!editor.commit(commit)) if (!editor.commit(commit))
return false; return false;
// Now play all the edits, and stash the result in the diagnostic manager. // Now play all the edits, and stash the result in the diagnostic manager.
Context not available.
err.SetErrorStringWithFormat("Couldn't find %s() in the module", err.SetErrorStringWithFormat("Couldn't find %s() in the module",
m_expr.FunctionName()); m_expr.FunctionName());
return err; return err;
} else {
if (log)
log->Printf("Found function %s for %s", function_name.AsCString(),
m_expr.FunctionName());
} }
if (log)
log->Printf("Found function %s for %s", function_name.AsCString(),
m_expr.FunctionName());
} }
SymbolContext sc; SymbolContext sc;
Context not available.

source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h

Context not available.
if (i == m_parser_vars.end()) if (i == m_parser_vars.end())
return NULL; return NULL;
else
return &i->second; return &i->second;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Context not available.
if (i == m_jit_vars.end()) if (i == m_jit_vars.end())
return NULL; return NULL;
else
return &i->second; return &i->second;
} }
TypeFromUser GetTypeFromUser(); TypeFromUser GetTypeFromUser();
Context not available.

source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp

Context not available.
if (i == m_persistent_decls.end()) if (i == m_persistent_decls.end())
return NULL; return NULL;
else
return i->second; return i->second;
} }
Context not available.

source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

Context not available.
if (ClangASTContext::IsObjCClassType(self_clang_type)) { if (ClangASTContext::IsObjCClassType(self_clang_type)) {
return; return;
} else if (ClangASTContext::IsObjCObjectPointerType( }
self_clang_type)) { if (ClangASTContext::IsObjCObjectPointerType(self_clang_type)) {
m_in_objectivec_method = true; m_in_objectivec_method = true;
m_needs_object_ptr = true; m_needs_object_ptr = true;
} else { } else {
Context not available.

source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp

Context not available.
if (jit_error.Success()) { if (jit_error.Success()) {
return true; return true;
} else { }
const char *error_cstr = jit_error.AsCString(); const char *error_cstr = jit_error.AsCString();
if (error_cstr && error_cstr[0]) { if (error_cstr && error_cstr[0]) {
diagnostic_manager.Printf(eDiagnosticSeverityError, "%s", error_cstr); diagnostic_manager.Printf(eDiagnosticSeverityError, "%s", error_cstr);
} else { } else {
diagnostic_manager.PutString(eDiagnosticSeverityError, diagnostic_manager.PutString(eDiagnosticSeverityError,
"expression can't be interpreted or run"); "expression can't be interpreted or run");
} }
return false; return false;
}
} }
void ClangUtilityFunction::ClangUtilityFunctionHelper::ResetDeclMap( void ClangUtilityFunction::ClangUtilityFunctionHelper::ResetDeclMap(
Context not available.

source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

Context not available.
return false; return false;
return true; return true;
} else if (ConstantDataArray *array_initializer = }
dyn_cast<ConstantDataArray>(initializer)) { if (ConstantDataArray *array_initializer =
dyn_cast<ConstantDataArray>(initializer)) {
if (array_initializer->isString()) { if (array_initializer->isString()) {
std::string array_initializer_string = array_initializer->getAsString(); std::string array_initializer_string = array_initializer->getAsString();
memcpy(data, array_initializer_string.c_str(), memcpy(data, array_initializer_string.c_str(),
Context not available.
value_size, value_alignment)) { value_size, value_alignment)) {
if (!global_variable->hasExternalLinkage()) if (!global_variable->hasExternalLinkage())
return true; return true;
else
return true; return true;
} }
} else if (dyn_cast<llvm::Function>(llvm_value_ptr)) { } else if (dyn_cast<llvm::Function>(llvm_value_ptr)) {
if (log) if (log)
Context not available.
LoadInst *load = new LoadInst(bit_cast, "", entry_instruction); LoadInst *load = new LoadInst(bit_cast, "", entry_instruction);
return load; return load;
} else {
BitCastInst *bit_cast = new BitCastInst(
get_element_ptr, value->getType(), "", entry_instruction);
return bit_cast;
} }
BitCastInst *bit_cast = new BitCastInst(
get_element_ptr, value->getType(), "", entry_instruction);
return bit_cast;
}); });
if (Constant *constant = dyn_cast<Constant>(value)) { if (Constant *constant = dyn_cast<Constant>(value)) {
Context not available.

source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp

Context not available.
uint32_t ITSession::GetCond() { uint32_t ITSession::GetCond() {
if (InITBlock()) if (InITBlock())
return Bits32(ITState, 7, 4); return Bits32(ITState, 7, 4);
else
return COND_AL; return COND_AL;
} }
// ARM constants used during decoding // ARM constants used during decoding
Context not available.
bool EmulateInstructionARM::SetTargetTriple(const ArchSpec &arch) { bool EmulateInstructionARM::SetTargetTriple(const ArchSpec &arch) {
if (arch.GetTriple().getArch() == llvm::Triple::arm) if (arch.GetTriple().getArch() == llvm::Triple::arm)
return true; return true;
else if (arch.GetTriple().getArch() == llvm::Triple::thumb) if (arch.GetTriple().getArch() == llvm::Triple::thumb)
return true; return true;
return false; return false;
Context not available.
if (!CurrentModeIsPrivileged()) if (!CurrentModeIsPrivileged())
// UNPREDICTABLE; // UNPREDICTABLE;
return false; return false;
else {
uint64_t Rn =
ReadRegisterUnsigned(eRegisterKindDWARF, dwarf_r0 + n, 0, &success);
if (!success)
return false;
addr_t address; uint64_t Rn =
// address = if increment then R[n] else R[n]-8; ReadRegisterUnsigned(eRegisterKindDWARF, dwarf_r0 + n, 0, &success);
if (increment) if (!success)
address = Rn; return false;
else
address = Rn - 8;
// if wordhigher then address = address+4; addr_t address;
if (wordhigher) // address = if increment then R[n] else R[n]-8;
address = address + 4; if (increment)
address = Rn;
else
address = Rn - 8;
// CPSRWriteByInstr(MemA[address+4,4], '1111', TRUE); // if wordhigher then address = address+4;
RegisterInfo base_reg; if (wordhigher)
GetRegisterInfo(eRegisterKindDWARF, dwarf_r0 + n, base_reg); address = address + 4;
EmulateInstruction::Context context; // CPSRWriteByInstr(MemA[address+4,4], '1111', TRUE);
context.type = eContextReturnFromException; RegisterInfo base_reg;
context.SetRegisterPlusOffset(base_reg, address - Rn); GetRegisterInfo(eRegisterKindDWARF, dwarf_r0 + n, base_reg);
uint64_t data = MemARead(context, address + 4, 4, 0, &success); EmulateInstruction::Context context;
if (!success) context.type = eContextReturnFromException;
return false; context.SetRegisterPlusOffset(base_reg, address - Rn);
CPSRWriteByInstr(data, 15, true); uint64_t data = MemARead(context, address + 4, 4, 0, &success);
if (!success)
return false;
// BranchWritePC(MemA[address,4]); CPSRWriteByInstr(data, 15, true);
uint64_t data2 = MemARead(context, address, 4, 0, &success);
if (!success) // BranchWritePC(MemA[address,4]);
return false; uint64_t data2 = MemARead(context, address, 4, 0, &success);
if (!success)
return false;
BranchWritePC(context, data2); BranchWritePC(context, data2);
// if wback then R[n] = if increment then R[n]+8 else R[n]-8; // if wback then R[n] = if increment then R[n]+8 else R[n]-8;
if (wback) { if (wback) {
context.type = eContextAdjustBaseRegister; context.type = eContextAdjustBaseRegister;
if (increment) { if (increment) {
context.SetOffset(8); context.SetOffset(8);
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_r0 + n, if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_r0 + n,
Rn + 8)) Rn + 8))
return false; return false;
} else { } else {
context.SetOffset(-8); context.SetOffset(-8);
if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_r0 + n, if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_r0 + n,
Rn - 8)) Rn - 8))
return false; return false;
} }
} // if wback } // if wback
}
} // if ConditionPassed() } // if ConditionPassed()
return true; return true;
} }
Context not available.
bool EmulateInstructionARM::LoadWritePC(Context &context, uint32_t addr) { bool EmulateInstructionARM::LoadWritePC(Context &context, uint32_t addr) {
if (ArchVersion() >= ARMv5T) if (ArchVersion() >= ARMv5T)
return BXWritePC(context, addr); return BXWritePC(context, addr);
else
return BranchWritePC((const Context)context, addr); return BranchWritePC((const Context)context, addr);
} }
// Dispatches to either BXWritePC or BranchWritePC based on architecture // Dispatches to either BXWritePC or BranchWritePC based on architecture
Context not available.
bool EmulateInstructionARM::ALUWritePC(Context &context, uint32_t addr) { bool EmulateInstructionARM::ALUWritePC(Context &context, uint32_t addr) {
if (ArchVersion() >= ARMv7 && CurrentInstrSet() == eModeARM) if (ArchVersion() >= ARMv7 && CurrentInstrSet() == eModeARM)
return BXWritePC(context, addr); return BXWritePC(context, addr);
else
return BranchWritePC((const Context)context, addr); return BranchWritePC((const Context)context, addr);
} }
EmulateInstructionARM::Mode EmulateInstructionARM::CurrentInstrSet() { EmulateInstructionARM::Mode EmulateInstructionARM::CurrentInstrSet() {
Context not available.

source/Plugins/Instruction/ARM/EmulationStateARM.cpp

Context not available.
pseudo_state->StoreToPseudoAddress(addr, value); pseudo_state->StoreToPseudoAddress(addr, value);
return length; return length;
} else if (length == 8) { }
if (length == 8) {
uint32_t value1; uint32_t value1;
uint32_t value2; uint32_t value2;
memcpy (&value1, dst, sizeof (uint32_t)); memcpy (&value1, dst, sizeof (uint32_t));
Context not available.
value_sp = mem_dict->GetValueForKey(address_key); value_sp = mem_dict->GetValueForKey(address_key);
if (value_sp.get() == NULL) if (value_sp.get() == NULL)
return false; return false;
else
start_address = value_sp->GetUInt64Value(); start_address = value_sp->GetUInt64Value();
value_sp = mem_dict->GetValueForKey(data_key); value_sp = mem_dict->GetValueForKey(data_key);
OptionValueArray *mem_array = value_sp->GetAsArray(); OptionValueArray *mem_array = value_sp->GetAsArray();
Context not available.

source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

Context not available.
bool EmulateInstructionARM64::SetTargetTriple(const ArchSpec &arch) { bool EmulateInstructionARM64::SetTargetTriple(const ArchSpec &arch) {
if (arch.GetTriple().getArch() == llvm::Triple::arm) if (arch.GetTriple().getArch() == llvm::Triple::arm)
return true; return true;
else if (arch.GetTriple().getArch() == llvm::Triple::thumb) if (arch.GetTriple().getArch() == llvm::Triple::thumb)
return true; return true;
return false; return false;
Context not available.

source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp

Context not available.
GetAddressByteSize()); GetAddressByteSize());
m_next_inst_size = GetSizeOfInstruction(data, next_inst_addr); m_next_inst_size = GetSizeOfInstruction(data, next_inst_addr);
return true; return true;
} else {
/*
* If the address class is not AddressClass::eCodeAlternateISA then
* the function is not microMIPS. In this case instruction size is
* always 4 bytes.
*/
m_next_inst_size = 4;
return true;
} }
/*
* If the address class is not AddressClass::eCodeAlternateISA then
* the function is not microMIPS. In this case instruction size is
* always 4 bytes.
*/
m_next_inst_size = 4;
return true;
} }
return false; return false;
} }
Context not available.
WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_sp_mips, result); WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_sp_mips, result);
return true; return true;
} else if (src == dwarf_sp_mips) { }
if (src == dwarf_sp_mips) {
rt = m_reg_info->getEncodingValue(insn.getOperand(2).getReg()); rt = m_reg_info->getEncodingValue(insn.getOperand(2).getReg());
/* read <src> register */ /* read <src> register */
Context not available.

source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp

Context not available.
WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_sp_mips64, result); WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_sp_mips64, result);
return true; return true;
} else if (src == dwarf_sp_mips64) { }
if (src == dwarf_sp_mips64) {
rt = m_reg_info->getEncodingValue(insn.getOperand(2).getReg()); rt = m_reg_info->getEncodingValue(insn.getOperand(2).getReg());
/* read <src> register */ /* read <src> register */
Context not available.

source/Plugins/Instruction/PPC64/EmulateInstructionPPC64.cpp

Context not available.
bool EmulateInstructionPPC64::SetTargetTriple(const ArchSpec &arch) { bool EmulateInstructionPPC64::SetTargetTriple(const ArchSpec &arch) {
if (arch.GetTriple().getArch() == llvm::Triple::ppc64) if (arch.GetTriple().getArch() == llvm::Triple::ppc64)
return true; return true;
else if (arch.GetTriple().getArch() == llvm::Triple::ppc64le) if (arch.GetTriple().getArch() == llvm::Triple::ppc64le)
return true; return true;
return false; return false;
Context not available.

source/Plugins/InstrumentationRuntime/ASan/ASanRuntime.cpp

Context not available.
"report.\n"); "report.\n");
} }
return true; // Return true to stop the target return true; // Return true to stop the target
} else }
return false; // Let target run return false; // Let target run
} }
void AddressSanitizerRuntime::Activate() { void AddressSanitizerRuntime::Activate() {
Context not available.

source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp

Context not available.
if (description == "data-race") { if (description == "data-race") {
return "Data race"; return "Data race";
} else if (description == "data-race-vptr") { }
if (description == "data-race-vptr") {
return "Data race on C++ virtual pointer"; return "Data race on C++ virtual pointer";
} else if (description == "heap-use-after-free") { } else if (description == "heap-use-after-free") {
return "Use of deallocated memory"; return "Use of deallocated memory";
Context not available.
"report.\n"); "report.\n");
} }
return true; // Return true to stop the target return true; // Return true to stop the target
} else }
return false; // Let target run return false; // Let target run
} }
const RegularExpression &ThreadSanitizerRuntime::GetPatternForRuntimeLibrary() { const RegularExpression &ThreadSanitizerRuntime::GetPatternForRuntimeLibrary() {
Context not available.

source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

Context not available.
bool JITLoaderGDB::ReadJITDescriptor(bool all_entries) { bool JITLoaderGDB::ReadJITDescriptor(bool all_entries) {
if (m_process->GetTarget().GetArchitecture().GetAddressByteSize() == 8) if (m_process->GetTarget().GetArchitecture().GetAddressByteSize() == 8)
return ReadJITDescriptorImpl<uint64_t>(all_entries); return ReadJITDescriptorImpl<uint64_t>(all_entries);
else
return ReadJITDescriptorImpl<uint32_t>(all_entries); return ReadJITDescriptorImpl<uint32_t>(all_entries);
} }
template <typename ptr_t> template <typename ptr_t>
Context not available.

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

Context not available.
if (IsTrivialBasename(m_basename)) { if (IsTrivialBasename(m_basename)) {
return true; return true;
} else {
// The C++ basename doesn't match our regular expressions so this can't
// be a valid C++ method, clear everything out and indicate an error
m_context = llvm::StringRef();
m_basename = llvm::StringRef();
m_arguments = llvm::StringRef();
m_qualifiers = llvm::StringRef();
return false;
} }
// The C++ basename doesn't match our regular expressions so this can't
// be a valid C++ method, clear everything out and indicate an error
m_context = llvm::StringRef();
m_basename = llvm::StringRef();
m_arguments = llvm::StringRef();
m_qualifiers = llvm::StringRef();
return false;
} }
return false; return false;
} }
Context not available.

source/Plugins/Language/CPlusPlus/CPlusPlusNameParser.cpp

Context not available.
} }
start_position.Remove(); start_position.Remove();
return result; return result;
} else {
return None;
} }
return None;
} }
llvm::StringRef CPlusPlusNameParser::GetTextForRange(const Range &range) { llvm::StringRef CPlusPlusNameParser::GetTextForRange(const Range &range) {
Context not available.

source/Plugins/Language/CPlusPlus/LibCxx.cpp

Context not available.
if (ptr_sp->GetValueAsUnsigned(0) == 0) { if (ptr_sp->GetValueAsUnsigned(0) == 0) {
stream.Printf("nullptr"); stream.Printf("nullptr");
return true; return true;
} else { }
bool print_pointee = false; bool print_pointee = false;
Status error; Status error;
ValueObjectSP pointee_sp = ptr_sp->Dereference(error); ValueObjectSP pointee_sp = ptr_sp->Dereference(error);
if (pointee_sp && error.Success()) { if (pointee_sp && error.Success()) {
if (pointee_sp->DumpPrintableRepresentation( if (pointee_sp->DumpPrintableRepresentation(
stream, ValueObject::eValueObjectRepresentationStyleSummary, stream, ValueObject::eValueObjectRepresentationStyleSummary,
lldb::eFormatInvalid, lldb::eFormatInvalid,
ValueObject::PrintableRepresentationSpecialCases::eDisable, ValueObject::PrintableRepresentationSpecialCases::eDisable, false))
false)) print_pointee = true;
print_pointee = true;
} }
if (!print_pointee) if (!print_pointee)
stream.Printf("ptr = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0)); stream.Printf("ptr = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0));
}
if (count_sp) if (count_sp)
stream.Printf(" strong=%" PRIu64, 1 + count_sp->GetValueAsUnsigned(0)); stream.Printf(" strong=%" PRIu64, 1 + count_sp->GetValueAsUnsigned(0));
Context not available.
shared_owners_sp->GetCompilerType()); shared_owners_sp->GetCompilerType());
} }
return m_count_sp; return m_count_sp;
} else /* if (idx == 2) */ } /* if (idx == 2) */
{
if (!m_weak_count_sp) { if (!m_weak_count_sp) {
ValueObjectSP shared_weak_owners_sp(m_cntrl->GetChildMemberWithName( ValueObjectSP shared_weak_owners_sp(m_cntrl->GetChildMemberWithName(
ConstString("__shared_weak_owners_"), true)); ConstString("__shared_weak_owners_"), true));
if (!shared_weak_owners_sp) if (!shared_weak_owners_sp)
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
uint64_t count = 1 + shared_weak_owners_sp->GetValueAsUnsigned(0); uint64_t count = 1 + shared_weak_owners_sp->GetValueAsUnsigned(0);
DataExtractor data(&count, 8, m_byte_order, m_ptr_size); DataExtractor data(&count, 8, m_byte_order, m_ptr_size);
m_weak_count_sp = CreateValueObjectFromData( m_weak_count_sp = CreateValueObjectFromData(
"count", data, valobj_sp->GetExecutionContextRef(), "count", data, valobj_sp->GetExecutionContextRef(),
shared_weak_owners_sp->GetCompilerType()); shared_weak_owners_sp->GetCompilerType());
}
return m_weak_count_sp;
} }
return m_weak_count_sp;
} }
bool lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::Update() { bool lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::Update() {
Context not available.
? size_mode_value ? size_mode_value
: ((size_mode_value >> 1) % 256); : ((size_mode_value >> 1) % 256);
return (location_sp.get() != nullptr); return (location_sp.get() != nullptr);
} else {
ValueObjectSP l(D->GetChildAtIndex(0, true));
if (!l)
return false;
// we can use the layout_decider object as the data pointer
location_sp = (layout == eLibcxxStringLayoutModeDSC)
? layout_decider
: l->GetChildAtIndex(2, true);
ValueObjectSP size_vo(l->GetChildAtIndex(1, true));
if (!size_vo || !location_sp)
return false;
size = size_vo->GetValueAsUnsigned(0);
return true;
} }
ValueObjectSP l(D->GetChildAtIndex(0, true));
if (!l)
return false;
// we can use the layout_decider object as the data pointer
location_sp = (layout == eLibcxxStringLayoutModeDSC)
? layout_decider
: l->GetChildAtIndex(2, true);
ValueObjectSP size_vo(l->GetChildAtIndex(1, true));
if (!size_vo || !location_sp)
return false;
size = size_vo->GetValueAsUnsigned(0);
return true;
} }
bool lldb_private::formatters::LibcxxWStringSummaryProvider( bool lldb_private::formatters::LibcxxWStringSummaryProvider(
Context not available.

source/Plugins/Language/CPlusPlus/LibCxxList.cpp

Context not available.
} }
if (m_count != UINT32_MAX) { if (m_count != UINT32_MAX) {
return m_count; return m_count;
} else { }
uint64_t next_val = m_head->GetValueAsUnsigned(0); uint64_t next_val = m_head->GetValueAsUnsigned(0);
uint64_t prev_val = m_tail->GetValueAsUnsigned(0); uint64_t prev_val = m_tail->GetValueAsUnsigned(0);
if (next_val == 0 || prev_val == 0) if (next_val == 0 || prev_val == 0)
return 0; return 0;
if (next_val == m_node_address) if (next_val == m_node_address)
return 0; return 0;
if (next_val == prev_val) if (next_val == prev_val)
return 1; return 1;
uint64_t size = 2; uint64_t size = 2;
ListEntry current(m_head); ListEntry current(m_head);
while (current.next() && current.next().value() != m_node_address) { while (current.next() && current.next().value() != m_node_address) {
size++; size++;
current = current.next(); current = current.next();
if (size > m_list_capping_size) if (size > m_list_capping_size)
break; break;
} }
return m_count = (size - 1); return m_count = (size - 1);
}
} }
lldb::ValueObjectSP ListFrontEnd::GetChildAtIndex(size_t idx) { lldb::ValueObjectSP ListFrontEnd::GetChildAtIndex(size_t idx) {
Context not available.

source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

Context not available.
0, name, &bit_offset_ptr, &bitfield_bit_size_ptr, &is_bitfield_ptr); 0, name, &bit_offset_ptr, &bitfield_bit_size_ptr, &is_bitfield_ptr);
m_element_type = m_element_type.GetTypedefedType(); m_element_type = m_element_type.GetTypedefedType();
return m_element_type.IsValid(); return m_element_type.IsValid();
} else {
m_element_type = m_backend.GetCompilerType().GetTypeTemplateArgument(0);
return m_element_type.IsValid();
} }
m_element_type = m_backend.GetCompilerType().GetTypeTemplateArgument(0);
return m_element_type.IsValid();
} }
void lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset( void lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset(
Context not available.

source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

Context not available.
StringPrinter::StringElementType::UTF8>(options)) { StringPrinter::StringElementType::UTF8>(options)) {
stream.Printf("Summary Unavailable"); stream.Printf("Summary Unavailable");
return true; return true;
} else }
return true; return true;
} break; } break;
case eAddressTypeHost: case eAddressTypeHost:
break; break;
Context not available.
if (idx == 0) if (idx == 0)
return valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true); return valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true);
else
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
} }
bool LibStdcppSharedPtrSyntheticFrontEnd::Update() { return false; } bool LibStdcppSharedPtrSyntheticFrontEnd::Update() { return false; }
Context not available.

source/Plugins/Language/ClangCommon/ClangHighlighter.cpp

Context not available.
// If we were in a preprocessor directive before, we now left it. // If we were in a preprocessor directive before, we now left it.
in_pp_directive = false; in_pp_directive = false;
return options.comment; return options.comment;
} else if (in_pp_directive || token.getKind() == tok::hash) { }
if (in_pp_directive || token.getKind() == tok::hash) {
// Let's assume that the rest of the line is a PP directive. // Let's assume that the rest of the line is a PP directive.
in_pp_directive = true; in_pp_directive = true;
// Preprocessor directives are hard to match, so we have to hack this in. // Preprocessor directives are hard to match, so we have to hack this in.
Context not available.

source/Plugins/Language/ObjC/NSArray.cpp

Context not available.
if (process.GetAddressByteSize() == 4) { if (process.GetAddressByteSize() == 4) {
return __NSArrayMSize_Impl<DataDescriptor<uint32_t>>(process, valobj_addr, return __NSArrayMSize_Impl<DataDescriptor<uint32_t>>(process, valobj_addr,
error); error);
} else {
return __NSArrayMSize_Impl<DataDescriptor<uint64_t>>(process, valobj_addr,
error);
} }
return __NSArrayMSize_Impl<DataDescriptor<uint64_t>>(process, valobj_addr,
error);
} }
} }
Context not available.
auto iter = map.find(class_name), end = map.end(); auto iter = map.find(class_name), end = map.end();
if (iter != end) if (iter != end)
return iter->second(valobj, stream, options); return iter->second(valobj, stream, options);
else
return false; return false;
} }
std::string prefix, suffix; std::string prefix, suffix;
Context not available.
return (new Foundation1436::NSArrayISyntheticFrontEnd(valobj_sp)); return (new Foundation1436::NSArrayISyntheticFrontEnd(valobj_sp));
if (runtime->GetFoundationVersion() >= 1430) if (runtime->GetFoundationVersion() >= 1430)
return (new Foundation1430::NSArrayISyntheticFrontEnd(valobj_sp)); return (new Foundation1430::NSArrayISyntheticFrontEnd(valobj_sp));
else
return (new Foundation1300::NSArrayISyntheticFrontEnd(valobj_sp)); return (new Foundation1300::NSArrayISyntheticFrontEnd(valobj_sp));
} else if (class_name == g_NSArrayI_Transfer) { } else if (class_name == g_NSArrayI_Transfer) {
return (new Foundation1436::NSArrayI_TransferSyntheticFrontEnd(valobj_sp)); return (new Foundation1436::NSArrayI_TransferSyntheticFrontEnd(valobj_sp));
} else if (class_name == g_NSArray0) { } else if (class_name == g_NSArray0) {
Context not available.
return (new Foundation1428::NSArrayMSyntheticFrontEnd(valobj_sp)); return (new Foundation1428::NSArrayMSyntheticFrontEnd(valobj_sp));
if (runtime->GetFoundationVersion() >= 1100) if (runtime->GetFoundationVersion() >= 1100)
return (new Foundation1010::NSArrayMSyntheticFrontEnd(valobj_sp)); return (new Foundation1010::NSArrayMSyntheticFrontEnd(valobj_sp));
else
return (new Foundation109::NSArrayMSyntheticFrontEnd(valobj_sp)); return (new Foundation109::NSArrayMSyntheticFrontEnd(valobj_sp));
} else if (class_name == g_NSCallStackArray) { } else if (class_name == g_NSCallStackArray) {
return (new CallStackArray::NSCallStackArraySyntheticFrontEnd(valobj_sp)); return (new CallStackArray::NSCallStackArraySyntheticFrontEnd(valobj_sp));
} else { } else {
Context not available.

source/Plugins/Language/ObjC/NSDictionary.cpp

Context not available.
if (process.GetAddressByteSize() == 4) { if (process.GetAddressByteSize() == 4) {
return __NSDictionaryMSize_Impl<DataDescriptor_32>(process, valobj_addr, return __NSDictionaryMSize_Impl<DataDescriptor_32>(process, valobj_addr,
error); error);
} else {
return __NSDictionaryMSize_Impl<DataDescriptor_64>(process, valobj_addr,
error);
} }
return __NSDictionaryMSize_Impl<DataDescriptor_64>(process, valobj_addr,
error);
} }
} }
Context not available.
if (class_name == g_DictionaryI) { if (class_name == g_DictionaryI) {
return (new NSDictionaryISyntheticFrontEnd(valobj_sp)); return (new NSDictionaryISyntheticFrontEnd(valobj_sp));
} else if (class_name == g_DictionaryM) { }
if (class_name == g_DictionaryM) {
if (runtime->GetFoundationVersion() >= 1437) { if (runtime->GetFoundationVersion() >= 1437) {
return (new Foundation1437::NSDictionaryMSyntheticFrontEnd(valobj_sp)); return (new Foundation1437::NSDictionaryMSyntheticFrontEnd(valobj_sp));
} else if (runtime->GetFoundationVersion() >= 1428) { }
if (runtime->GetFoundationVersion() >= 1428) {
return (new Foundation1428::NSDictionaryMSyntheticFrontEnd(valobj_sp)); return (new Foundation1428::NSDictionaryMSyntheticFrontEnd(valobj_sp));
} else { } else {
return (new Foundation1100::NSDictionaryMSyntheticFrontEnd(valobj_sp)); return (new Foundation1100::NSDictionaryMSyntheticFrontEnd(valobj_sp));
} }
} else if (class_name == g_DictionaryMLegacy) { } else if (class_name == g_DictionaryMLegacy) {
return (new Foundation1100::NSDictionaryMSyntheticFrontEnd(valobj_sp)); return (new Foundation1100::NSDictionaryMSyntheticFrontEnd(valobj_sp));
} else if (class_name == g_Dictionary1) { } else if (class_name == g_Dictionary1) {
return (new NSDictionary1SyntheticFrontEnd(valobj_sp)); return (new NSDictionary1SyntheticFrontEnd(valobj_sp));
} else { } else {
Context not available.

source/Plugins/Language/ObjC/NSError.cpp

Context not available.
stream.Printf("domain: %s - code: %" PRIu64, domain_str_summary.GetData(), stream.Printf("domain: %s - code: %" PRIu64, domain_str_summary.GetData(),
code); code);
return true; return true;
} else {
stream.Printf("domain: nil - code: %" PRIu64, code);
return true;
} }
stream.Printf("domain: nil - code: %" PRIu64, code);
return true;
} }
class NSErrorSyntheticFrontEnd : public SyntheticChildrenFrontEnd { class NSErrorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
Context not available.
if (!strcmp(class_name, "NSError")) if (!strcmp(class_name, "NSError"))
return (new NSErrorSyntheticFrontEnd(valobj_sp)); return (new NSErrorSyntheticFrontEnd(valobj_sp));
else if (!strcmp(class_name, "__NSCFError")) if (!strcmp(class_name, "__NSCFError"))
return (new NSErrorSyntheticFrontEnd(valobj_sp)); return (new NSErrorSyntheticFrontEnd(valobj_sp));
return nullptr; return nullptr;
Context not available.

source/Plugins/Language/ObjC/NSException.cpp

Context not available.
stream.Printf("name: %s - reason: %s", name_str_summary.GetData(), stream.Printf("name: %s - reason: %s", name_str_summary.GetData(),
reason_str_summary.GetData()); reason_str_summary.GetData());
return true; return true;
} else }
return false; return false;
} }
class NSExceptionSyntheticFrontEnd : public SyntheticChildrenFrontEnd { class NSExceptionSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
Context not available.
if (!strcmp(class_name, "NSException")) if (!strcmp(class_name, "NSException"))
return (new NSExceptionSyntheticFrontEnd(valobj_sp)); return (new NSExceptionSyntheticFrontEnd(valobj_sp));
else if (!strcmp(class_name, "NSCFException")) if (!strcmp(class_name, "NSCFException"))
return (new NSExceptionSyntheticFrontEnd(valobj_sp)); return (new NSExceptionSyntheticFrontEnd(valobj_sp));
else if (!strcmp(class_name, "__NSCFException")) else if (!strcmp(class_name, "__NSCFException"))
return (new NSExceptionSyntheticFrontEnd(valobj_sp)); return (new NSExceptionSyntheticFrontEnd(valobj_sp));
Context not available.

source/Plugins/Language/ObjC/NSSet.cpp

Context not available.
Status &error) { Status &error) {
if (process.GetAddressByteSize() == 4) { if (process.GetAddressByteSize() == 4) {
return __NSSetMSize_Impl<DataDescriptor_32>(process, valobj_addr, error); return __NSSetMSize_Impl<DataDescriptor_32>(process, valobj_addr, error);
} else {
return __NSSetMSize_Impl<DataDescriptor_64>(process, valobj_addr, error);
} }
return __NSSetMSize_Impl<DataDescriptor_64>(process, valobj_addr, error);
} }
} }
Context not available.
auto iter = map.find(class_name_cs), end = map.end(); auto iter = map.find(class_name_cs), end = map.end();
if (iter != end) if (iter != end)
return iter->second(valobj, stream, options); return iter->second(valobj, stream, options);
else
return false; return false;
} }
std::string prefix, suffix; std::string prefix, suffix;
Context not available.
if (!strcmp(class_name, "__NSSetI") || if (!strcmp(class_name, "__NSSetI") ||
!strcmp(class_name, "__NSOrderedSetI")) { !strcmp(class_name, "__NSOrderedSetI")) {
return (new NSSetISyntheticFrontEnd(valobj_sp)); return (new NSSetISyntheticFrontEnd(valobj_sp));
} else if (!strcmp(class_name, "__NSSetM")) { }
if (!strcmp(class_name, "__NSSetM")) {
AppleObjCRuntime *apple_runtime = AppleObjCRuntime *apple_runtime =
llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime); llvm::dyn_cast_or_null<AppleObjCRuntime>(runtime);
if (apple_runtime) { if (apple_runtime) {
if (apple_runtime->GetFoundationVersion() >= 1437) if (apple_runtime->GetFoundationVersion() >= 1437)
return (new Foundation1437::NSSetMSyntheticFrontEnd(valobj_sp)); return (new Foundation1437::NSSetMSyntheticFrontEnd(valobj_sp));
else if (apple_runtime->GetFoundationVersion() >= 1428) if (apple_runtime->GetFoundationVersion() >= 1428)
return (new Foundation1428::NSSetMSyntheticFrontEnd(valobj_sp)); return (new Foundation1428::NSSetMSyntheticFrontEnd(valobj_sp));
else else
return (new Foundation1300::NSSetMSyntheticFrontEnd(valobj_sp)); return (new Foundation1300::NSSetMSyntheticFrontEnd(valobj_sp));
Context not available.

source/Plugins/Language/ObjC/NSString.cpp

Context not available.
options.SetLanguage(summary_options.GetLanguage()); options.SetLanguage(summary_options.GetLanguage());
return StringPrinter::ReadStringAndDumpToStream< return StringPrinter::ReadStringAndDumpToStream<
StringPrinter::StringElementType::UTF16>(options); StringPrinter::StringElementType::UTF16>(options);
} else {
options.SetLocation(location + 1);
options.SetProcessSP(process_sp);
options.SetStream(&stream);
options.SetSourceSize(explicit_length);
options.SetNeedsZeroTermination(false);
options.SetIgnoreMaxLength(summary_options.GetCapping() ==
TypeSummaryCapping::eTypeSummaryUncapped);
options.SetBinaryZeroIsTerminator(false);
options.SetLanguage(summary_options.GetLanguage());
return StringPrinter::ReadStringAndDumpToStream<
StringPrinter::StringElementType::ASCII>(options);
} }
options.SetLocation(location + 1);
options.SetProcessSP(process_sp);
options.SetStream(&stream);
options.SetSourceSize(explicit_length);
options.SetNeedsZeroTermination(false);
options.SetIgnoreMaxLength(summary_options.GetCapping() ==
TypeSummaryCapping::eTypeSummaryUncapped);
options.SetBinaryZeroIsTerminator(false);
options.SetLanguage(summary_options.GetLanguage());
return StringPrinter::ReadStringAndDumpToStream<
StringPrinter::StringElementType::ASCII>(options);
} else if (is_inline && has_explicit_length && !is_unicode && } else if (is_inline && has_explicit_length && !is_unicode &&
!is_path_store && !is_mutable) { !is_path_store && !is_mutable) {
uint64_t location = 3 * ptr_size + valobj_addr; uint64_t location = 3 * ptr_size + valobj_addr;
Context not available.
if (is_inline) { if (is_inline) {
if (!has_explicit_length) { if (!has_explicit_length) {
return false; return false;
} else }
location += ptr_size; location += ptr_size;
} else { } else {
location = process_sp->ReadPointerFromMemory(location, error); location = process_sp->ReadPointerFromMemory(location, error);
if (error.Fail()) if (error.Fail())
Context not available.
if (has_explicit_length) if (has_explicit_length)
return StringPrinter::ReadStringAndDumpToStream< return StringPrinter::ReadStringAndDumpToStream<
StringPrinter::StringElementType::UTF8>(options); StringPrinter::StringElementType::UTF8>(options);
else
return StringPrinter::ReadStringAndDumpToStream< return StringPrinter::ReadStringAndDumpToStream<
StringPrinter::StringElementType::ASCII>(options); StringPrinter::StringElementType::ASCII>(options);
} else { } else {
uint64_t location = valobj_addr + 2 * ptr_size; uint64_t location = valobj_addr + 2 * ptr_size;
location = process_sp->ReadPointerFromMemory(location, error); location = process_sp->ReadPointerFromMemory(location, error);
Context not available.

source/Plugins/Language/ObjC/ObjCLanguage.h

Context not available.
if (strchr(name, ':') == nullptr) if (strchr(name, ':') == nullptr)
return true; return true;
else if (name[strlen(name) - 1] == ':') if (name[strlen(name) - 1] == ':')
return true; return true;
else else
return false; return false;
Context not available.

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

Context not available.
// Can we maybe ask Clang about this? // Can we maybe ask Clang about this?
if (strstr(name, "_vptr$") == name) if (strstr(name, "_vptr$") == name)
return true; return true;
else
return false; return false;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
Context not available.
language == eLanguageTypeC_plus_plus_11 || language == eLanguageTypeC_plus_plus_11 ||
language == eLanguageTypeC_plus_plus_14) language == eLanguageTypeC_plus_plus_14)
return new ItaniumABILanguageRuntime(process); return new ItaniumABILanguageRuntime(process);
else
return NULL; return NULL;
} }
class CommandObjectMultiwordItaniumABI_Demangle : public CommandObjectParsed { class CommandObjectMultiwordItaniumABI_Demangle : public CommandObjectParsed {
Context not available.
filter_modules.Append(FileSpec("libc++abi.dylib")); filter_modules.Append(FileSpec("libc++abi.dylib"));
filter_modules.Append(FileSpec("libSystem.B.dylib")); filter_modules.Append(FileSpec("libSystem.B.dylib"));
return target.GetSearchFilterForModuleList(&filter_modules); return target.GetSearchFilterForModuleList(&filter_modules);
} else {
return LanguageRuntime::CreateExceptionSearchFilter();
} }
return LanguageRuntime::CreateExceptionSearchFilter();
} }
lldb::BreakpointSP ItaniumABILanguageRuntime::CreateExceptionBreakpoint( lldb::BreakpointSP ItaniumABILanguageRuntime::CreateExceptionBreakpoint(
Context not available.
DynamicTypeCache::const_iterator pos = m_dynamic_type_map.find(vtable_addr); DynamicTypeCache::const_iterator pos = m_dynamic_type_map.find(vtable_addr);
if (pos == m_dynamic_type_map.end()) if (pos == m_dynamic_type_map.end())
return TypeAndOrName(); return TypeAndOrName();
else
return pos->second; return pos->second;
} }
void ItaniumABILanguageRuntime::SetDynamicTypeInfo( void ItaniumABILanguageRuntime::SetDynamicTypeInfo(
Context not available.

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

Context not available.
selector_components.push_back( selector_components.push_back(
&ast_ctx.Idents.get(llvm::StringRef(name_cursor))); &ast_ctx.Idents.get(llvm::StringRef(name_cursor)));
break; break;
} else {
is_zero_argument = false;
selector_components.push_back(&ast_ctx.Idents.get(
llvm::StringRef(name_cursor, colon_loc - name_cursor)));
name_cursor = colon_loc + 1;
} }
is_zero_argument = false;
selector_components.push_back(&ast_ctx.Idents.get(
llvm::StringRef(name_cursor, colon_loc - name_cursor)));
name_cursor = colon_loc + 1;
} }
clang::IdentifierInfo **identifier_infos = selector_components.data(); clang::IdentifierInfo **identifier_infos = selector_components.data();
Context not available.
decls.push_back(result_iface_decl); decls.push_back(result_iface_decl);
ret++; ret++;
break; break;
} else {
if (log)
log->Printf("AOCTV::FT [%u] There's something in the ASTContext, but "
"it's not something we know about",
current_id);
break;
} }
if (log)
log->Printf("AOCTV::FT [%u] There's something in the ASTContext, but "
"it's not something we know about",
current_id);
break;
} else if (log) { } else if (log) {
log->Printf("AOCTV::FT [%u] Couldn't find %s in the ASTContext", log->Printf("AOCTV::FT [%u] Couldn't find %s in the ASTContext",
current_id, name.AsCString()); current_id, name.AsCString());
Context not available.

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

Context not available.
} }
} }
return LLDB_INVALID_MODULE_VERSION; return LLDB_INVALID_MODULE_VERSION;
} else }
return m_Foundation_major.getValue(); return m_Foundation_major.getValue();
} }
void AppleObjCRuntime::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true, void AppleObjCRuntime::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
Context not available.
if (m_objc_trampoline_handler_ap.get() != NULL) { if (m_objc_trampoline_handler_ap.get() != NULL) {
m_read_objc_library = true; m_read_objc_library = true;
return true; return true;
} else }
return false; return false;
} }
ThreadPlanSP AppleObjCRuntime::GetStepThroughTrampolinePlan(Thread &thread, ThreadPlanSP AppleObjCRuntime::GetStepThroughTrampolinePlan(Thread &thread,
Context not available.
target.GetImages().FindSymbolsWithNameAndType(s_arclite_method_signature, target.GetImages().FindSymbolsWithNameAndType(s_arclite_method_signature,
eSymbolTypeCode, sc_list)) eSymbolTypeCode, sc_list))
return true; return true;
else
return false; return false;
} }
lldb::SearchFilterSP AppleObjCRuntime::CreateExceptionSearchFilter() { lldb::SearchFilterSP AppleObjCRuntime::CreateExceptionSearchFilter() {
Context not available.
FileSpecList filter_modules; FileSpecList filter_modules;
filter_modules.Append(std::get<0>(GetExceptionThrowLocation())); filter_modules.Append(std::get<0>(GetExceptionThrowLocation()));
return target.GetSearchFilterForModuleList(&filter_modules); return target.GetSearchFilterForModuleList(&filter_modules);
} else {
return LanguageRuntime::CreateExceptionSearchFilter();
} }
return LanguageRuntime::CreateExceptionSearchFilter();
} }
std::tuple<FileSpec, ConstString> std::tuple<FileSpec, ConstString>
Context not available.

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

Context not available.
if (AppleObjCRuntime::GetObjCVersion(process, objc_module_sp) == if (AppleObjCRuntime::GetObjCVersion(process, objc_module_sp) ==
ObjCRuntimeVersions::eAppleObjC_V1) ObjCRuntimeVersions::eAppleObjC_V1)
return new AppleObjCRuntimeV1(process); return new AppleObjCRuntimeV1(process);
else
return NULL; return NULL;
} else } else
return NULL; return NULL;
} }
Context not available.

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

Context not available.
if (read_value) if (read_value)
return process->ReadUnsignedIntegerFromMemory( return process->ReadUnsignedIntegerFromMemory(
symbol_load_addr, byte_size, default_value, error); symbol_load_addr, byte_size, default_value, error);
else
return symbol_load_addr; return symbol_load_addr;
} else { } else {
error.SetErrorString("symbol address invalid"); error.SetErrorString("symbol address invalid");
return default_value; return default_value;
Context not available.
if (AppleObjCRuntime::GetObjCVersion(process, objc_module_sp) == if (AppleObjCRuntime::GetObjCVersion(process, objc_module_sp) ==
ObjCRuntimeVersions::eAppleObjC_V2) ObjCRuntimeVersions::eAppleObjC_V2)
return new AppleObjCRuntimeV2(process, objc_module_sp); return new AppleObjCRuntimeV2(process, objc_module_sp);
else
return NULL; return NULL;
} else } else
return NULL; return NULL;
} }
Context not available.
} }
result.SetStatus(lldb::eReturnStatusSuccessFinishResult); result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
return true; return true;
} else {
result.AppendError("current process has no Objective-C runtime loaded");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
} }
result.AppendError("current process has no Objective-C runtime loaded");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
} }
CommandOptions m_options; CommandOptions m_options;
Context not available.
} }
result.SetStatus(lldb::eReturnStatusSuccessFinishResult); result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
return true; return true;
} else {
result.AppendError("current process has no Objective-C runtime loaded");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
} }
result.AppendError("current process has no Objective-C runtime loaded");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
} }
}; };
Context not available.
// tagged pointer // tagged pointer
if (IsTaggedPointer(isa_pointer)) { if (IsTaggedPointer(isa_pointer)) {
return m_tagged_pointer_vendor_ap->GetClassDescriptor(isa_pointer); return m_tagged_pointer_vendor_ap->GetClassDescriptor(isa_pointer);
} else { }
ExecutionContext exe_ctx(valobj.GetExecutionContextRef()); ExecutionContext exe_ctx(valobj.GetExecutionContextRef());
Process *process = exe_ctx.GetProcessPtr(); Process *process = exe_ctx.GetProcessPtr();
if (process) { if (process) {
Status error; Status error;
ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error); ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error);
if (isa != LLDB_INVALID_ADDRESS) { if (isa != LLDB_INVALID_ADDRESS) {
objc_class_sp = GetClassDescriptorFromISA(isa); objc_class_sp = GetClassDescriptorFromISA(isa);
if (isa && !objc_class_sp) { if (isa && !objc_class_sp) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
if (log) if (log)
log->Printf("0x%" PRIx64 log->Printf("0x%" PRIx64
": AppleObjCRuntimeV2::GetClassDescriptor() ISA was " ": AppleObjCRuntimeV2::GetClassDescriptor() ISA was "
"not in class descriptor cache 0x%" PRIx64, "not in class descriptor cache 0x%" PRIx64,
isa_pointer, isa); isa_pointer, isa);
}
} }
} }
} }
} }
return objc_class_sp; return objc_class_sp;
} }
Context not available.

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

Context not available.
get_impl_name.AsCString()); get_impl_name.AsCString());
} }
return; return;
} else if (m_impl_stret_fn_addr == LLDB_INVALID_ADDRESS) { }
if (m_impl_stret_fn_addr == LLDB_INVALID_ADDRESS) {
// It there is no stret return lookup function, assume that it is the same // It there is no stret return lookup function, assume that it is the same
// as the straight lookup: // as the straight lookup:
m_impl_stret_fn_addr = m_impl_fn_addr; m_impl_stret_fn_addr = m_impl_fn_addr;
Context not available.

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

Context not available.
if (type.NextIf(closer)) { if (type.NextIf(closer)) {
in_union = false; in_union = false;
break; break;
} else {
auto element = ReadStructElement(ast_ctx, type, for_expression);
if (element.type.isNull())
break;
else
elements.push_back(element);
} }
auto element = ReadStructElement(ast_ctx, type, for_expression);
if (element.type.isNull())
break;
elements.push_back(element);
} }
if (in_union) if (in_union)
return clang::QualType(); return clang::QualType();
Context not available.
if (less_than_pos != std::string::npos) { if (less_than_pos != std::string::npos) {
if (less_than_pos == 0) if (less_than_pos == 0)
return ast_ctx.getObjCIdType(); return ast_ctx.getObjCIdType();
else
name.erase(less_than_pos); name.erase(less_than_pos);
} }
DeclVendor *decl_vendor = m_runtime.GetDeclVendor(); DeclVendor *decl_vendor = m_runtime.GetDeclVendor();
Context not available.
return ClangUtil::GetQualType( return ClangUtil::GetQualType(
ClangASTContext::GetTypeForDecl(decls[0]).GetPointerType()); ClangASTContext::GetTypeForDecl(decls[0]).GetPointerType());
} else {
// We're going to resolve this dynamically anyway, so just smile and wave.
return ast_ctx.getObjCIdType();
} }
// We're going to resolve this dynamically anyway, so just smile and wave.
return ast_ctx.getObjCIdType();
} }
clang::QualType clang::QualType
Context not available.
if (bitfield_bit_size) { if (bitfield_bit_size) {
*bitfield_bit_size = size; *bitfield_bit_size = size;
return ast_ctx.UnsignedIntTy; // FIXME: the spec is fairly vague here. return ast_ctx.UnsignedIntTy; // FIXME: the spec is fairly vague here.
} else }
return clang::QualType(); return clang::QualType();
} }
case 'r': { case 'r': {
clang::QualType target_type = BuildType(ast_ctx, type, for_expression); clang::QualType target_type = BuildType(ast_ctx, type, for_expression);
if (target_type.isNull()) if (target_type.isNull())
return clang::QualType(); return clang::QualType();
else if (target_type == ast_ctx.UnknownAnyTy) if (target_type == ast_ctx.UnknownAnyTy)
return ast_ctx.UnknownAnyTy; return ast_ctx.UnknownAnyTy;
else else
return ast_ctx.getConstType(target_type); return ast_ctx.getConstType(target_type);
Context not available.
// nothing exists') but is way better than outright failure in many // nothing exists') but is way better than outright failure in many
// practical cases // practical cases
return ast_ctx.VoidPtrTy; return ast_ctx.VoidPtrTy;
} else {
clang::QualType target_type = BuildType(ast_ctx, type, for_expression);
if (target_type.isNull())
return clang::QualType();
else if (target_type == ast_ctx.UnknownAnyTy)
return ast_ctx.UnknownAnyTy;
else
return ast_ctx.getPointerType(target_type);
} }
clang::QualType target_type = BuildType(ast_ctx, type, for_expression);
if (target_type.isNull())
return clang::QualType();
if (target_type == ast_ctx.UnknownAnyTy)
return ast_ctx.UnknownAnyTy;
else
return ast_ctx.getPointerType(target_type);
} }
case '?': case '?':
return for_expression ? ast_ctx.UnknownAnyTy : clang::QualType(); return for_expression ? ast_ctx.UnknownAnyTy : clang::QualType();
Context not available.

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

Context not available.
if (m_func_sp) { if (m_func_sp) {
if (!m_func_sp->IsPlanComplete()) { if (!m_func_sp->IsPlanComplete()) {
return false; return false;
} else {
if (!m_func_sp->PlanSucceeded()) {
SetPlanComplete(false);
return true;
}
m_func_sp.reset();
} }
if (!m_func_sp->PlanSucceeded()) {
SetPlanComplete(false);
return true;
}
m_func_sp.reset();
} }
// Second stage, if all went well with the function calling, then fetch the // Second stage, if all went well with the function calling, then fetch the
Context not available.
m_thread.QueueThreadPlan(m_run_to_sp, false); m_thread.QueueThreadPlan(m_run_to_sp, false);
m_run_to_sp->SetPrivate(true); m_run_to_sp->SetPrivate(true);
return false; return false;
} else if (m_thread.IsThreadPlanDone(m_run_to_sp.get())) { }
if (m_thread.IsThreadPlanDone(m_run_to_sp.get())) {
// Third stage, work the run to target plan. // Third stage, work the run to target plan.
SetPlanComplete(); SetPlanComplete();
return true; return true;
Context not available.
bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() { bool AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged() {
if (IsPlanComplete()) if (IsPlanComplete())
return true; return true;
else
return false; 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.
name.AsCString(), offset); name.AsCString(), offset);
} }
return true; return true;
} else }
return false; return false;
} }
} // anonymous namespace } // anonymous namespace
Context not available.
if (language == eLanguageTypeExtRenderScript) if (language == eLanguageTypeExtRenderScript)
return new RenderScriptRuntime(process); return new RenderScriptRuntime(process);
else
return nullptr; return nullptr;
} }
// Callback with a module to search for matching symbols. We first check that // Callback with a module to search for matching symbols. We first check that
Context not available.
log->Printf("%s - Error while reading the function parameters", log->Printf("%s - Error while reading the function parameters",
__FUNCTION__); __FUNCTION__);
return; return;
} else if (log) { }
if (log) {
log->Printf("%s - groupName : 0x%" PRIx64, __FUNCTION__, log->Printf("%s - groupName : 0x%" PRIx64, __FUNCTION__,
addr_t(args[eGroupName])); addr_t(args[eGroupName]));
log->Printf("%s - groupNameSize: %" PRIu64, __FUNCTION__, log->Printf("%s - groupNameSize: %" PRIu64, __FUNCTION__,
Context not available.
if (log) if (log)
log->Printf("Error reading scriptgroup name from target"); log->Printf("Error reading scriptgroup name from target");
return; return;
} else {
if (log)
log->Printf("Extracted scriptgroup name %s", buffer.get());
} }
if (log)
log->Printf("Extracted scriptgroup name %s", buffer.get());
// write back the script group name // write back the script group name
group_name.SetCString(buffer.get()); group_name.SetCString(buffer.get());
} }
Context not available.
"with symbol '%s'.", "with symbol '%s'.",
__FUNCTION__, hook_defn->name, symbol_name); __FUNCTION__, hook_defn->name, symbol_name);
continue; continue;
} else {
if (log)
log->Printf("%s - function %s, address resolved at 0x%" PRIx64,
__FUNCTION__, hook_defn->name, addr);
} }
if (log)
log->Printf("%s - function %s, address resolved at 0x%" PRIx64,
__FUNCTION__, hook_defn->name, addr);
RuntimeHookSP hook(new RuntimeHook()); RuntimeHookSP hook(new RuntimeHook());
hook->address = addr; hook->address = addr;
Context not available.
if (log) if (log)
log->Printf("%s - encoding error in snprintf().", __FUNCTION__); log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
return false; return false;
} else if (written >= jit_max_expr_size) { }
if (written >= jit_max_expr_size) {
if (log) if (log)
log->Printf("%s - expression too long.", __FUNCTION__); log->Printf("%s - expression too long.", __FUNCTION__);
return false; return false;
Context not available.
if (log) if (log)
log->Printf("%s - encoding error in snprintf().", __FUNCTION__); log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
return false; return false;
} else if (written >= jit_max_expr_size) { }
if (written >= jit_max_expr_size) {
if (log) if (log)
log->Printf("%s - expression too long.", __FUNCTION__); log->Printf("%s - expression too long.", __FUNCTION__);
return false; return false;
Context not available.
if (log) if (log)
log->Printf("%s - encoding error in snprintf().", __FUNCTION__); log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
return false; return false;
} else if (written >= jit_max_expr_size) { }
if (written >= jit_max_expr_size) {
if (log) if (log)
log->Printf("%s - expression too long.", __FUNCTION__); log->Printf("%s - expression too long.", __FUNCTION__);
return false; return false;
Context not available.
if (log) if (log)
log->Printf("%s - encoding error in snprintf().", __FUNCTION__); log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
return false; return false;
} else if (written >= jit_max_expr_size) { }
if (written >= jit_max_expr_size) {
if (log) if (log)
log->Printf("%s - expression too long.", __FUNCTION__); log->Printf("%s - expression too long.", __FUNCTION__);
return false; return false;
Context not available.
if (log) if (log)
log->Printf("%s - encoding error in snprintf().", __FUNCTION__); log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
return false; return false;
} else if (written >= jit_max_expr_size) { }
if (written >= jit_max_expr_size) {
if (log) if (log)
log->Printf("%s - expression too long.", __FUNCTION__); log->Printf("%s - expression too long.", __FUNCTION__);
return false; return false;
Context not available.
if (log) if (log)
log->Printf("%s - encoding error in snprintf().", __FUNCTION__); log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
return false; return false;
} else if (written >= jit_max_expr_size) { }
if (written >= jit_max_expr_size) {
if (log) if (log)
log->Printf("%s - expression too long.", __FUNCTION__); log->Printf("%s - expression too long.", __FUNCTION__);
return false; return false;
Context not available.
if (log) if (log)
log->Printf("%s - encoding error in snprintf().", __FUNCTION__); log->Printf("%s - encoding error in snprintf().", __FUNCTION__);
return false; return false;
} else if (written >= jit_max_expr_size) { }
if (written >= jit_max_expr_size) {
if (log) if (log)
log->Printf("%s - expression too long.", __FUNCTION__); log->Printf("%s - expression too long.", __FUNCTION__);
return false; return false;
Context not available.
if (!elem.type_name.IsEmpty()) // Name already set if (!elem.type_name.IsEmpty()) // Name already set
return; return;
else
elem.type_name = Element::GetFallbackStructName(); // Default type name if elem.type_name = Element::GetFallbackStructName(); // Default type name if
// we don't succeed // we don't succeed
// Find all the global variables from the script rs modules // Find all the global variables from the script rs modules
VariableList var_list; VariableList var_list;
Context not available.
log->Error("Error parsing RenderScript reduction spec. wrong number " log->Error("Error parsing RenderScript reduction spec. wrong number "
"of fields"); "of fields");
return false; return false;
} else if (log) }
if (log)
log->Warning("Extraneous members in reduction spec: '%s'", log->Warning("Extraneous members in reduction spec: '%s'",
lines->str().c_str()); lines->str().c_str());
} }
Context not available.
if (success) { if (success) {
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
return true; return true;
} else {
result.SetStatus(eReturnStatusFailed);
return false;
} }
result.SetStatus(eReturnStatusFailed);
return false;
} }
}; };
Context not available.

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

Context not available.
if (match) { if (match) {
if (pos->second->GetModificationTime() == time) { if (pos->second->GetModificationTime() == time) {
return pos->second; return pos->second;
} else {
// We have a file at the same path with the same architecture whose
// modification time doesn't match. It doesn't make sense for us to
// continue to use this BSD archive since we cache only the object info
// which consists of file time info and also the file offset and file
// size of any contained objects. Since this information is now out of
// date, we won't get the correct information if we go and extract the
// file data, so we should remove the old and outdated entry.
archive_map.erase(pos);
pos = archive_map.find(file);
continue; // Continue to next iteration so we don't increment pos
// below...
} }
// We have a file at the same path with the same architecture whose
// modification time doesn't match. It doesn't make sense for us to
// continue to use this BSD archive since we cache only the object info
// which consists of file time info and also the file offset and file
// size of any contained objects. Since this information is now out of
// date, we won't get the correct information if we go and extract the
// file data, so we should remove the old and outdated entry.
archive_map.erase(pos);
pos = archive_map.find(file);
continue; // Continue to next iteration so we don't increment pos
// below...
} }
++pos; ++pos;
} }
Context not available.
// We already have this archive in our cache, use it // We already have this archive in our cache, use it
container_ap->SetArchive(archive_sp); container_ap->SetArchive(archive_sp);
return container_ap.release(); return container_ap.release();
} else if (container_ap->ParseHeader()) }
if (container_ap->ParseHeader())
return container_ap.release(); return container_ap.release();
} }
} }
Context not available.

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

Context not available.
lldb::offset_t *offset) { lldb::offset_t *offset) {
if (reloc.is<ELFRel *>()) if (reloc.is<ELFRel *>())
return reloc.get<ELFRel *>()->Parse(data, offset); return reloc.get<ELFRel *>()->Parse(data, offset);
else
return reloc.get<ELFRela *>()->Parse(data, offset); return reloc.get<ELFRela *>()->Parse(data, offset);
} }
unsigned ELFRelocation::RelocType32(const ELFRelocation &rel) { unsigned ELFRelocation::RelocType32(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>()) if (rel.reloc.is<ELFRel *>())
return ELFRel::RelocType32(*rel.reloc.get<ELFRel *>()); return ELFRel::RelocType32(*rel.reloc.get<ELFRel *>());
else
return ELFRela::RelocType32(*rel.reloc.get<ELFRela *>()); return ELFRela::RelocType32(*rel.reloc.get<ELFRela *>());
} }
unsigned ELFRelocation::RelocType64(const ELFRelocation &rel) { unsigned ELFRelocation::RelocType64(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>()) if (rel.reloc.is<ELFRel *>())
return ELFRel::RelocType64(*rel.reloc.get<ELFRel *>()); return ELFRel::RelocType64(*rel.reloc.get<ELFRel *>());
else
return ELFRela::RelocType64(*rel.reloc.get<ELFRela *>()); return ELFRela::RelocType64(*rel.reloc.get<ELFRela *>());
} }
unsigned ELFRelocation::RelocSymbol32(const ELFRelocation &rel) { unsigned ELFRelocation::RelocSymbol32(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>()) if (rel.reloc.is<ELFRel *>())
return ELFRel::RelocSymbol32(*rel.reloc.get<ELFRel *>()); return ELFRel::RelocSymbol32(*rel.reloc.get<ELFRel *>());
else
return ELFRela::RelocSymbol32(*rel.reloc.get<ELFRela *>()); return ELFRela::RelocSymbol32(*rel.reloc.get<ELFRela *>());
} }
unsigned ELFRelocation::RelocSymbol64(const ELFRelocation &rel) { unsigned ELFRelocation::RelocSymbol64(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>()) if (rel.reloc.is<ELFRel *>())
return ELFRel::RelocSymbol64(*rel.reloc.get<ELFRel *>()); return ELFRel::RelocSymbol64(*rel.reloc.get<ELFRel *>());
else
return ELFRela::RelocSymbol64(*rel.reloc.get<ELFRela *>()); return ELFRela::RelocSymbol64(*rel.reloc.get<ELFRela *>());
} }
unsigned ELFRelocation::RelocOffset32(const ELFRelocation &rel) { unsigned ELFRelocation::RelocOffset32(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>()) if (rel.reloc.is<ELFRel *>())
return rel.reloc.get<ELFRel *>()->r_offset; return rel.reloc.get<ELFRel *>()->r_offset;
else
return rel.reloc.get<ELFRela *>()->r_offset; return rel.reloc.get<ELFRela *>()->r_offset;
} }
unsigned ELFRelocation::RelocOffset64(const ELFRelocation &rel) { unsigned ELFRelocation::RelocOffset64(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>()) if (rel.reloc.is<ELFRel *>())
return rel.reloc.get<ELFRel *>()->r_offset; return rel.reloc.get<ELFRel *>()->r_offset;
else
return rel.reloc.get<ELFRela *>()->r_offset; return rel.reloc.get<ELFRela *>()->r_offset;
} }
unsigned ELFRelocation::RelocAddend32(const ELFRelocation &rel) { unsigned ELFRelocation::RelocAddend32(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>()) if (rel.reloc.is<ELFRel *>())
return 0; return 0;
else
return rel.reloc.get<ELFRela *>()->r_addend; return rel.reloc.get<ELFRela *>()->r_addend;
} }
unsigned ELFRelocation::RelocAddend64(const ELFRelocation &rel) { unsigned ELFRelocation::RelocAddend64(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>()) if (rel.reloc.is<ELFRel *>())
return 0; return 0;
else
return rel.reloc.get<ELFRela *>()->r_addend; return rel.reloc.get<ELFRela *>()->r_addend;
} }
} // end anonymous namespace } // end anonymous namespace
Context not available.
// We have the full build id uuid. // We have the full build id uuid.
*uuid = m_uuid; *uuid = m_uuid;
return true; return true;
} else if (GetType() == ObjectFile::eTypeCoreFile) { }
if (GetType() == ObjectFile::eTypeCoreFile) {
uint32_t core_notes_crc = 0; uint32_t core_notes_crc = 0;
if (!ParseProgramHeaders()) if (!ParseProgramHeaders())
Context not available.
} }
// MIPS executables uses DT_MIPS_RLD_MAP_REL to support PIE. DT_MIPS_RLD_MAP // MIPS executables uses DT_MIPS_RLD_MAP_REL to support PIE. DT_MIPS_RLD_MAP
// exists in non-PIE. // exists in non-PIE.
else if ((symbol.d_tag == DT_MIPS_RLD_MAP || if ((symbol.d_tag == DT_MIPS_RLD_MAP ||
symbol.d_tag == DT_MIPS_RLD_MAP_REL) && symbol.d_tag == DT_MIPS_RLD_MAP_REL) &&
target) { target) {
addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize(); addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target); addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target);
if (dyn_base == LLDB_INVALID_ADDRESS) if (dyn_base == LLDB_INVALID_ADDRESS)
Context not available.

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

Context not available.
if (is_64_bit) if (is_64_bit)
*data_offset_ptr += 4; *data_offset_ptr += 4;
return true; return true;
} else {
memset(&header, 0, sizeof(header));
} }
memset(&header, 0, sizeof(header));
return false; return false;
} }
Context not available.
if (m_section_infos[n_sect].vm_range.Contains(file_addr)) { if (m_section_infos[n_sect].vm_range.Contains(file_addr)) {
// Symbol is in section. // Symbol is in section.
return m_section_infos[n_sect].section_sp; return m_section_infos[n_sect].section_sp;
} else if (m_section_infos[n_sect].vm_range.GetByteSize() == 0 && }
m_section_infos[n_sect].vm_range.GetBaseAddress() == if (m_section_infos[n_sect].vm_range.GetByteSize() == 0 &&
file_addr) { m_section_infos[n_sect].vm_range.GetBaseAddress() == file_addr) {
// Symbol is in section with zero size, but has the same start address // Symbol is in section with zero size, but has the same start address
// as the section. This can happen with linker symbols (symbols that // as the section. This can happen with linker symbols (symbols that
// start with the letter 'l' or 'L'. // start with the letter 'l' or 'L'.
Context not available.
triple.setVendorName(llvm::StringRef()); triple.setVendorName(llvm::StringRef());
} }
return true; return true;
} else { }
struct load_command load_cmd; struct load_command load_cmd;
llvm::SmallString<16> os_name; llvm::SmallString<16> os_name;
llvm::raw_svector_ostream os(os_name); llvm::raw_svector_ostream os(os_name);
// See if there is an LC_VERSION_MIN_* load command that can give // See if there is an LC_VERSION_MIN_* load command that can give
// us the OS type. // us the OS type.
lldb::offset_t offset = lc_offset; lldb::offset_t offset = lc_offset;
for (uint32_t i = 0; i < header.ncmds; ++i) { for (uint32_t i = 0; i < header.ncmds; ++i) {
const lldb::offset_t cmd_offset = offset; const lldb::offset_t cmd_offset = offset;
if (data.GetU32(&offset, &load_cmd, 2) == NULL) if (data.GetU32(&offset, &load_cmd, 2) == NULL)
break; break;
struct version_min_command version_min; struct version_min_command version_min;
switch (load_cmd.cmd) { switch (load_cmd.cmd) {
case llvm::MachO::LC_VERSION_MIN_IPHONEOS: case llvm::MachO::LC_VERSION_MIN_IPHONEOS:
case llvm::MachO::LC_VERSION_MIN_MACOSX: case llvm::MachO::LC_VERSION_MIN_MACOSX:
case llvm::MachO::LC_VERSION_MIN_TVOS: case llvm::MachO::LC_VERSION_MIN_TVOS:
case llvm::MachO::LC_VERSION_MIN_WATCHOS: { case llvm::MachO::LC_VERSION_MIN_WATCHOS: {
if (load_cmd.cmdsize != sizeof(version_min)) if (load_cmd.cmdsize != sizeof(version_min))
break;
if (data.ExtractBytes(cmd_offset, sizeof(version_min),
data.GetByteOrder(), &version_min) == 0)
break;
MinOS min_os(version_min.version);
os << GetOSName(load_cmd.cmd) << min_os.major_version << '.'
<< min_os.minor_version << '.' << min_os.patch_version;
triple.setOSName(os.str());
return true;
}
default:
break; break;
} if (data.ExtractBytes(cmd_offset, sizeof(version_min),
data.GetByteOrder(), &version_min) == 0)
break;
MinOS min_os(version_min.version);
os << GetOSName(load_cmd.cmd) << min_os.major_version << '.'
<< min_os.minor_version << '.' << min_os.patch_version;
triple.setOSName(os.str());
return true;
}
default:
break;
}
offset = cmd_offset + load_cmd.cmdsize; offset = cmd_offset + load_cmd.cmdsize;
} }
// See if there is an LC_BUILD_VERSION load command that can give // See if there is an LC_BUILD_VERSION load command that can give
Context not available.
triple.setVendor(llvm::Triple::UnknownVendor); triple.setVendor(llvm::Triple::UnknownVendor);
triple.setVendorName(llvm::StringRef()); triple.setVendorName(llvm::StringRef());
} }
}
} }
return arch.IsValid(); return arch.IsValid();
} }
Context not available.

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

Context not available.
uint32_t ObjectFilePECOFF::GetAddressByteSize() const { uint32_t ObjectFilePECOFF::GetAddressByteSize() const {
if (m_coff_header_opt.magic == OPT_HEADER_MAGIC_PE32_PLUS) if (m_coff_header_opt.magic == OPT_HEADER_MAGIC_PE32_PLUS)
return 8; return 8;
else if (m_coff_header_opt.magic == OPT_HEADER_MAGIC_PE32) if (m_coff_header_opt.magic == OPT_HEADER_MAGIC_PE32)
return 4; return 4;
return 4; return 4;
} }
Context not available.
if (m_coff_header.machine != 0) { if (m_coff_header.machine != 0) {
if ((m_coff_header.flags & llvm::COFF::IMAGE_FILE_DLL) == 0) if ((m_coff_header.flags & llvm::COFF::IMAGE_FILE_DLL) == 0)
return eTypeExecutable; return eTypeExecutable;
else
return eTypeSharedLibrary; return eTypeSharedLibrary;
} }
return eTypeExecutable; return eTypeExecutable;
} }
Context not available.

source/Plugins/Platform/Android/AdbClient.cpp

Context not available.
if (error.Fail()) if (error.Fail())
return Status("Failed to read DONE error message: %s", error.AsCString()); return Status("Failed to read DONE error message: %s", error.AsCString());
return Status("Failed to push file: %s", error_message.c_str()); return Status("Failed to push file: %s", error_message.c_str());
} else if (response_id != kOKAY) }
if (response_id != kOKAY)
return Status("Got unexpected DONE response: %s", response_id.c_str()); return Status("Got unexpected DONE response: %s", response_id.c_str());
// If there was an error reading the source file, finish the adb file // If there was an error reading the source file, finish the adb file
Context not available.

source/Plugins/Platform/Android/PlatformAndroid.cpp

Context not available.
if (is_host) { if (is_host) {
static ConstString g_host_name(Platform::GetHostPlatformName()); static ConstString g_host_name(Platform::GetHostPlatformName());
return g_host_name; return g_host_name;
} else {
static ConstString g_remote_name("remote-android");
return g_remote_name;
} }
static ConstString g_remote_name("remote-android");
return g_remote_name;
} }
const char *PlatformAndroid::GetPluginDescriptionStatic(bool is_host) { const char *PlatformAndroid::GetPluginDescriptionStatic(bool is_host) {
if (is_host) if (is_host)
return "Local Android user platform plug-in."; return "Local Android user platform plug-in.";
else
return "Remote Android user platform plug-in."; return "Remote Android user platform plug-in.";
} }
ConstString PlatformAndroid::GetPluginName() { ConstString PlatformAndroid::GetPluginName() {
Context not available.

source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

Context not available.
if (is_host) { if (is_host) {
static ConstString g_host_name(Platform::GetHostPlatformName()); static ConstString g_host_name(Platform::GetHostPlatformName());
return g_host_name; return g_host_name;
} else {
static ConstString g_remote_name("remote-freebsd");
return g_remote_name;
} }
static ConstString g_remote_name("remote-freebsd");
return g_remote_name;
} }
const char *PlatformFreeBSD::GetPluginDescriptionStatic(bool is_host) { const char *PlatformFreeBSD::GetPluginDescriptionStatic(bool is_host) {
if (is_host) if (is_host)
return "Local FreeBSD user platform plug-in."; return "Local FreeBSD user platform plug-in.";
else
return "Remote FreeBSD user platform plug-in."; return "Remote FreeBSD user platform plug-in.";
} }
ConstString PlatformFreeBSD::GetPluginName() { ConstString PlatformFreeBSD::GetPluginName() {
Context not available.
if (idx == 0) { if (idx == 0) {
arch = hostArch; arch = hostArch;
return arch.IsValid(); return arch.IsValid();
} else if (idx == 1) { }
if (idx == 1) {
// If the default host architecture is 64-bit, look for a 32-bit // If the default host architecture is 64-bit, look for a 32-bit
// variant // variant
if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit()) { if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit()) {
Context not available.

source/Plugins/Platform/Linux/PlatformLinux.cpp

Context not available.
if (is_host) { if (is_host) {
static ConstString g_host_name(Platform::GetHostPlatformName()); static ConstString g_host_name(Platform::GetHostPlatformName());
return g_host_name; return g_host_name;
} else {
static ConstString g_remote_name("remote-linux");
return g_remote_name;
} }
static ConstString g_remote_name("remote-linux");
return g_remote_name;
} }
const char *PlatformLinux::GetPluginDescriptionStatic(bool is_host) { const char *PlatformLinux::GetPluginDescriptionStatic(bool is_host) {
if (is_host) if (is_host)
return "Local Linux user platform plug-in."; return "Local Linux user platform plug-in.";
else
return "Remote Linux user platform plug-in."; return "Remote Linux user platform plug-in.";
} }
ConstString PlatformLinux::GetPluginName() { ConstString PlatformLinux::GetPluginName() {
Context not available.
if (idx == 0) { if (idx == 0) {
arch = hostArch; arch = hostArch;
return arch.IsValid(); return arch.IsValid();
} else if (idx == 1) { }
if (idx == 1) {
// If the default host architecture is 64-bit, look for a 32-bit // If the default host architecture is 64-bit, look for a 32-bit
// variant // variant
if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit()) { if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit()) {
Context not available.
bool PlatformLinux::CanDebugProcess() { bool PlatformLinux::CanDebugProcess() {
if (IsHost()) { if (IsHost()) {
return true; return true;
} else {
// If we're connected, we can debug.
return IsConnected();
} }
// If we're connected, we can debug.
return IsConnected();
} }
// For local debugging, Linux will override the debug logic to use llgs-launch // For local debugging, Linux will override the debug logic to use llgs-launch
Context not available.

source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp

Context not available.
if (spawned) { if (spawned) {
launch_info.SetProcessID(spawned.GetPID()); launch_info.SetProcessID(spawned.GetPID());
return Status(); return Status();
} else }
return spawned.GetError(); return spawned.GetError();
#else #else
Status err; Status err;
err.SetErrorString(UNSUPPORTED_ERROR); err.SetErrorString(UNSUPPORTED_ERROR);
Context not available.
if (arg_str == device.GetUDID() || arg_str == device.GetName()) { if (arg_str == device.GetUDID() || arg_str == device.GetName()) {
m_device = device; m_device = device;
return false; // Stop iterating return false; // Stop iterating
} else {
return true; // Keep iterating
} }
return true; // Keep iterating
}); });
if (!m_device) if (!m_device)
error.SetErrorStringWithFormat( error.SetErrorStringWithFormat(
Context not available.
if (m_device.hasValue()) if (m_device.hasValue())
return m_device.getValue(); return m_device.getValue();
else
return CoreSimulatorSupport::Device(); return CoreSimulatorSupport::Device();
} }
#endif #endif
Context not available.

source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp

Context not available.
if (error.Success()) { if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile()) if (exe_module_sp && exe_module_sp->GetObjectFile())
break; break;
else
error.SetErrorToGenericError(); error.SetErrorToGenericError();
} }
if (idx > 0) if (idx > 0)
Context not available.

source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp

Context not available.
if (error.Success()) { if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile()) if (exe_module_sp && exe_module_sp->GetObjectFile())
break; break;
else
error.SetErrorToGenericError(); error.SetErrorToGenericError();
} }
if (idx > 0) if (idx > 0)
Context not available.

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

Context not available.
module_sp.reset(new Module(local_spec)); module_sp.reset(new Module(local_spec));
module_sp->SetPlatformFileSpec(module_spec.GetFileSpec()); module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
return Status(); return Status();
} else }
return Status("unable to obtain valid module file"); return Status("unable to obtain valid module file");
} else } else
return Status("no cache path"); return Status("no cache path");
} else } else
Context not available.
ObjectFile::Type obj_type = obj_file->GetType(); ObjectFile::Type obj_type = obj_file->GetType();
if (obj_type == ObjectFile::eTypeDynamicLinker) if (obj_type == ObjectFile::eTypeDynamicLinker)
return true; return true;
else
return false; return false;
} }
bool PlatformDarwin::x86GetSupportedArchitectureAtIndex(uint32_t idx, bool PlatformDarwin::x86GetSupportedArchitectureAtIndex(uint32_t idx,
Context not available.
if (idx == 0) { if (idx == 0) {
arch = HostInfo::GetArchitecture(HostInfo::eArchKindDefault); arch = HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
return arch.IsValid(); return arch.IsValid();
} else if (idx == 1) { }
if (idx == 1) {
ArchSpec platform_arch( ArchSpec platform_arch(
HostInfo::GetArchitecture(HostInfo::eArchKindDefault)); HostInfo::GetArchitecture(HostInfo::eArchKindDefault));
ArchSpec platform_arch64( ArchSpec platform_arch64(
Context not available.
if (launch_info.GetEnvironment().lookup("COMMAND_MODE") == "legacy") if (launch_info.GetEnvironment().lookup("COMMAND_MODE") == "legacy")
return 2; return 2;
return 1; return 1;
} else if (strcmp(shell_name, "csh") == 0 || }
strcmp(shell_name, "tcsh") == 0 || if (strcmp(shell_name, "csh") == 0 || strcmp(shell_name, "tcsh") == 0 ||
strcmp(shell_name, "zsh") == 0) { strcmp(shell_name, "zsh") == 0) {
// csh and tcsh always seem to re-exec themselves. // csh and tcsh always seem to re-exec themselves.
return 2; return 2;
} else } else
Context not available.
if (FileSystem::Instance().IsDirectory(enumerator_info.found_path)) if (FileSystem::Instance().IsDirectory(enumerator_info.found_path))
return enumerator_info.found_path; return enumerator_info.found_path;
else
return FileSpec(); return FileSpec();
} }
FileSpec PlatformDarwin::GetSDKDirectoryForModules(SDKType sdk_type) { FileSpec PlatformDarwin::GetSDKDirectoryForModules(SDKType sdk_type) {
Context not available.

source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

Context not available.
if (log_verbose) if (log_verbose)
log_verbose->Printf ("PlatformDarwinKernel descending into directory '%s'", file_spec.GetPath().c_str()); log_verbose->Printf ("PlatformDarwinKernel descending into directory '%s'", file_spec.GetPath().c_str());
return FileSystem::eEnumerateDirectoryResultEnter; return FileSystem::eEnumerateDirectoryResultEnter;
} else {
return FileSystem::eEnumerateDirectoryResultNext;
} }
return FileSystem::eEnumerateDirectoryResultNext;
} }
void PlatformDarwinKernel::AddKextToMap(PlatformDarwinKernel *thisp, void PlatformDarwinKernel::AddKextToMap(PlatformDarwinKernel *thisp,
Context not available.
process->GetTarget().GetImages().AppendIfNeeded(module_sp); process->GetTarget().GetImages().AppendIfNeeded(module_sp);
error.Clear(); error.Clear();
return error; return error;
} else { }
error = ModuleList::GetSharedModule(kern_spec, module_sp, NULL, error = ModuleList::GetSharedModule(kern_spec, module_sp, NULL, NULL,
NULL, NULL); NULL);
if (module_sp && module_sp->GetObjectFile() && if (module_sp && module_sp->GetObjectFile() &&
module_sp->GetObjectFile()->GetType() != module_sp->GetObjectFile()->GetType() !=
ObjectFile::Type::eTypeCoreFile) { ObjectFile::Type::eTypeCoreFile) {
return error; return error;
} }
module_sp.reset(); module_sp.reset();
}
} }
} }
} }
Context not available.
process->GetTarget().GetImages().AppendIfNeeded(module_sp); process->GetTarget().GetImages().AppendIfNeeded(module_sp);
error.Clear(); error.Clear();
return error; return error;
} else { }
error = ModuleList::GetSharedModule(kern_spec, module_sp, NULL, error = ModuleList::GetSharedModule(kern_spec, module_sp, NULL, NULL,
NULL, NULL); NULL);
if (module_sp && module_sp->GetObjectFile() && if (module_sp && module_sp->GetObjectFile() &&
module_sp->GetObjectFile()->GetType() != module_sp->GetObjectFile()->GetType() !=
ObjectFile::Type::eTypeCoreFile) { ObjectFile::Type::eTypeCoreFile) {
return error; return error;
} }
module_sp.reset(); module_sp.reset();
}
} }
} }
} }
Context not available.

source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

Context not available.
if (is_host) { if (is_host) {
static ConstString g_host_name(Platform::GetHostPlatformName()); static ConstString g_host_name(Platform::GetHostPlatformName());
return g_host_name; return g_host_name;
} else {
static ConstString g_remote_name("remote-macosx");
return g_remote_name;
} }
static ConstString g_remote_name("remote-macosx");
return g_remote_name;
} }
const char *PlatformMacOSX::GetDescriptionStatic(bool is_host) { const char *PlatformMacOSX::GetDescriptionStatic(bool is_host) {
if (is_host) if (is_host)
return "Local Mac OS X user platform plug-in."; return "Local Mac OS X user platform plug-in.";
else
return "Remote Mac OS X user platform plug-in."; return "Remote Mac OS X user platform plug-in.";
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
Context not available.
// same OS version: the local file is good enough // same OS version: the local file is good enough
local_file = platform_file; local_file = platform_file;
return Status(); return Status();
} else { }
// try to find the file in the cache // try to find the file in the cache
std::string cache_path(GetLocalCacheDirectory()); std::string cache_path(GetLocalCacheDirectory());
std::string module_path(platform_file.GetPath()); std::string module_path(platform_file.GetPath());
cache_path.append(module_path); cache_path.append(module_path);
FileSpec module_cache_spec(cache_path); FileSpec module_cache_spec(cache_path);
if (FileSystem::Instance().Exists(module_cache_spec)) { if (FileSystem::Instance().Exists(module_cache_spec)) {
local_file = module_cache_spec; local_file = module_cache_spec;
return Status(); return Status();
} }
// bring in the remote module file // bring in the remote module file
FileSpec module_cache_folder = FileSpec module_cache_folder =
Context not available.
if (FileSystem::Instance().Exists(module_cache_spec)) { if (FileSystem::Instance().Exists(module_cache_spec)) {
local_file = module_cache_spec; local_file = module_cache_spec;
return Status(); return Status();
} else }
return Status("unable to obtain valid module file"); return Status("unable to obtain valid module file");
}
} }
local_file = platform_file; local_file = platform_file;
return Status(); return Status();
Context not available.

source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp

Context not available.
if (error.Success()) { if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile()) if (exe_module_sp && exe_module_sp->GetObjectFile())
break; break;
else
error.SetErrorToGenericError(); error.SetErrorToGenericError();
} }
if (idx > 0) if (idx > 0)
Context not available.

source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

Context not available.
if (error.Success()) { if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile()) if (exe_module_sp && exe_module_sp->GetObjectFile())
break; break;
else
error.SetErrorToGenericError(); error.SetErrorToGenericError();
} }
if (idx > 0) if (idx > 0)
Context not available.
// 32/64: return "x86_64-apple-macosx" for architecture 1 // 32/64: return "x86_64-apple-macosx" for architecture 1
arch = platform_arch64; arch = platform_arch64;
return true; return true;
} else if (idx == 2 || idx == 3) { }
if (idx == 2 || idx == 3) {
arch = HostInfo::GetArchitecture(HostInfo::eArchKind32); arch = HostInfo::GetArchitecture(HostInfo::eArchKind32);
if (arch.IsValid()) { if (arch.IsValid()) {
if (idx == 2) if (idx == 2)
Context not available.

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

Context not available.
m_family.clear(); m_family.clear();
m_versions.clear(); m_versions.clear();
return; return;
} else {
m_family.push_back(c);
} }
m_family.push_back(c);
} }
} }
Context not available.
if (m_model_identifier.hasValue()) if (m_model_identifier.hasValue())
return m_model_identifier.getValue(); return m_model_identifier.getValue();
else
return ModelIdentifier(); return ModelIdentifier();
} }
CoreSimulatorSupport::OSVersion CoreSimulatorSupport::OSVersion
Context not available.
auto utf8_udid = [[[m_dev UDID] UUIDString] UTF8String]; auto utf8_udid = [[[m_dev UDID] UUIDString] UTF8String];
if (utf8_udid) if (utf8_udid)
return std::string(utf8_udid); return std::string(utf8_udid);
else
return std::string(); return std::string();
} }
CoreSimulatorSupport::DeviceType CoreSimulatorSupport::Device::GetDeviceType() { CoreSimulatorSupport::DeviceType CoreSimulatorSupport::Device::GetDeviceType() {
Context not available.
if ([m_dev bootWithOptions:options error:&nserror]) { if ([m_dev bootWithOptions:options error:&nserror]) {
err.Clear(); err.Clear();
return true; return true;
} else {
err.SetErrorString([[nserror description] UTF8String]);
return false;
} }
err.SetErrorString([[nserror description] UTF8String]);
return false;
} }
bool CoreSimulatorSupport::Device::Shutdown(Status &err) { bool CoreSimulatorSupport::Device::Shutdown(Status &err) {
Context not available.
if ([m_dev shutdownWithError:&nserror]) { if ([m_dev shutdownWithError:&nserror]) {
err.Clear(); err.Clear();
return true; return true;
} else {
err.SetErrorString([[nserror description] UTF8String]);
return false;
} }
err.SetErrorString([[nserror description] UTF8String]);
return false;
} }
static Status HandleFileAction(ProcessLaunchInfo &launch_info, static Status HandleFileAction(ProcessLaunchInfo &launch_info,
Context not available.
file.SetDescriptor(created_fd, true); file.SetDescriptor(created_fd, true);
[options setValue:[NSNumber numberWithInteger:created_fd] forKey:key]; [options setValue:[NSNumber numberWithInteger:created_fd] forKey:key];
return error; // Success return error; // Success
} else {
posix_error.SetErrorToErrno();
error.SetErrorStringWithFormat("unable to open file '%s': %s",
file_spec.GetPath().c_str(),
posix_error.AsCString());
} }
posix_error.SetErrorToErrno();
error.SetErrorStringWithFormat("unable to open file '%s': %s",
file_spec.GetPath().c_str(),
posix_error.AsCString());
} }
} break; } break;
} }
Context not available.

source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

Context not available.
if (is_host) { if (is_host) {
static ConstString g_host_name(Platform::GetHostPlatformName()); static ConstString g_host_name(Platform::GetHostPlatformName());
return g_host_name; return g_host_name;
} else {
static ConstString g_remote_name("remote-netbsd");
return g_remote_name;
} }
static ConstString g_remote_name("remote-netbsd");
return g_remote_name;
} }
const char *PlatformNetBSD::GetPluginDescriptionStatic(bool is_host) { const char *PlatformNetBSD::GetPluginDescriptionStatic(bool is_host) {
if (is_host) if (is_host)
return "Local NetBSD user platform plug-in."; return "Local NetBSD user platform plug-in.";
else
return "Remote NetBSD user platform plug-in."; return "Remote NetBSD user platform plug-in.";
} }
ConstString PlatformNetBSD::GetPluginName() { ConstString PlatformNetBSD::GetPluginName() {
Context not available.
if (idx == 0) { if (idx == 0) {
arch = hostArch; arch = hostArch;
return arch.IsValid(); return arch.IsValid();
} else if (idx == 1) { }
if (idx == 1) {
// If the default host architecture is 64-bit, look for a 32-bit // If the default host architecture is 64-bit, look for a 32-bit
// variant // variant
if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit()) { if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit()) {
Context not available.
bool PlatformNetBSD::CanDebugProcess() { bool PlatformNetBSD::CanDebugProcess() {
if (IsHost()) { if (IsHost()) {
return true; return true;
} else {
// If we're connected, we can debug.
return IsConnected();
} }
// If we're connected, we can debug.
return IsConnected();
} }
// For local debugging, NetBSD will override the debug logic to use llgs-launch // For local debugging, NetBSD will override the debug logic to use llgs-launch
Context not available.

source/Plugins/Platform/OpenBSD/PlatformOpenBSD.cpp

Context not available.
if (is_host) { if (is_host) {
static ConstString g_host_name(Platform::GetHostPlatformName()); static ConstString g_host_name(Platform::GetHostPlatformName());
return g_host_name; return g_host_name;
} else {
static ConstString g_remote_name("remote-openbsd");
return g_remote_name;
} }
static ConstString g_remote_name("remote-openbsd");
return g_remote_name;
} }
const char *PlatformOpenBSD::GetPluginDescriptionStatic(bool is_host) { const char *PlatformOpenBSD::GetPluginDescriptionStatic(bool is_host) {
if (is_host) if (is_host)
return "Local OpenBSD user platform plug-in."; return "Local OpenBSD user platform plug-in.";
else
return "Remote OpenBSD user platform plug-in."; return "Remote OpenBSD user platform plug-in.";
} }
ConstString PlatformOpenBSD::GetPluginName() { ConstString PlatformOpenBSD::GetPluginName() {
Context not available.

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

Context not available.
bool PlatformPOSIX::IsConnected() const { bool PlatformPOSIX::IsConnected() const {
if (IsHost()) if (IsHost())
return true; return true;
else if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->IsConnected(); return m_remote_platform_sp->IsConnected();
return false; return false;
} }
Context not available.
if (IsHost()) if (IsHost())
return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr, return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr,
command_output, timeout); command_output, timeout);
else {
if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->RunShellCommand( return m_remote_platform_sp->RunShellCommand(
command, working_dir, status_ptr, signo_ptr, command_output, timeout); command, working_dir, status_ptr, signo_ptr, command_output, timeout);
else
return Status("unable to run a remote command without a platform"); return Status("unable to run a remote command without a platform");
}
} }
Status Status
Context not available.
if (error.Success()) { if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile()) if (exe_module_sp && exe_module_sp->GetObjectFile())
break; break;
else
error.SetErrorToGenericError(); error.SetErrorToGenericError();
} }
if (idx > 0) if (idx > 0)
Context not available.
uint32_t file_permissions) { uint32_t file_permissions) {
if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->MakeDirectory(file_spec, file_permissions); return m_remote_platform_sp->MakeDirectory(file_spec, file_permissions);
else
return Platform::MakeDirectory(file_spec, file_permissions); return Platform::MakeDirectory(file_spec, file_permissions);
} }
Status PlatformPOSIX::GetFilePermissions(const FileSpec &file_spec, Status PlatformPOSIX::GetFilePermissions(const FileSpec &file_spec,
Context not available.
if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->GetFilePermissions(file_spec, return m_remote_platform_sp->GetFilePermissions(file_spec,
file_permissions); file_permissions);
else
return Platform::GetFilePermissions(file_spec, file_permissions); return Platform::GetFilePermissions(file_spec, file_permissions);
} }
Status PlatformPOSIX::SetFilePermissions(const FileSpec &file_spec, Status PlatformPOSIX::SetFilePermissions(const FileSpec &file_spec,
Context not available.
if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->SetFilePermissions(file_spec, return m_remote_platform_sp->SetFilePermissions(file_spec,
file_permissions); file_permissions);
else
return Platform::SetFilePermissions(file_spec, file_permissions); return Platform::SetFilePermissions(file_spec, file_permissions);
} }
lldb::user_id_t PlatformPOSIX::OpenFile(const FileSpec &file_spec, lldb::user_id_t PlatformPOSIX::OpenFile(const FileSpec &file_spec,
Context not available.
Status &error) { Status &error) {
if (IsHost()) if (IsHost())
return FileCache::GetInstance().OpenFile(file_spec, flags, mode, error); return FileCache::GetInstance().OpenFile(file_spec, flags, mode, error);
else if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->OpenFile(file_spec, flags, mode, error); return m_remote_platform_sp->OpenFile(file_spec, flags, mode, error);
else else
return Platform::OpenFile(file_spec, flags, mode, error); return Platform::OpenFile(file_spec, flags, mode, error);
Context not available.
bool PlatformPOSIX::CloseFile(lldb::user_id_t fd, Status &error) { bool PlatformPOSIX::CloseFile(lldb::user_id_t fd, Status &error) {
if (IsHost()) if (IsHost())
return FileCache::GetInstance().CloseFile(fd, error); return FileCache::GetInstance().CloseFile(fd, error);
else if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->CloseFile(fd, error); return m_remote_platform_sp->CloseFile(fd, error);
else else
return Platform::CloseFile(fd, error); return Platform::CloseFile(fd, error);
Context not available.
uint64_t dst_len, Status &error) { uint64_t dst_len, Status &error) {
if (IsHost()) if (IsHost())
return FileCache::GetInstance().ReadFile(fd, offset, dst, dst_len, error); return FileCache::GetInstance().ReadFile(fd, offset, dst, dst_len, error);
else if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->ReadFile(fd, offset, dst, dst_len, error); return m_remote_platform_sp->ReadFile(fd, offset, dst, dst_len, error);
else else
return Platform::ReadFile(fd, offset, dst, dst_len, error); return Platform::ReadFile(fd, offset, dst, dst_len, error);
Context not available.
Status &error) { Status &error) {
if (IsHost()) if (IsHost())
return FileCache::GetInstance().WriteFile(fd, offset, src, src_len, error); return FileCache::GetInstance().WriteFile(fd, offset, src, src_len, error);
else if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->WriteFile(fd, offset, src, src_len, error); return m_remote_platform_sp->WriteFile(fd, offset, src, src_len, error);
else else
return Platform::WriteFile(fd, offset, src, src_len, error); return Platform::WriteFile(fd, offset, src, src_len, error);
Context not available.
if (chown_file(this, dst_path.c_str(), uid, gid) != 0) if (chown_file(this, dst_path.c_str(), uid, gid) != 0)
return Status("unable to perform chown"); return Status("unable to perform chown");
return Status(); return Status();
} else if (m_remote_platform_sp) { }
if (m_remote_platform_sp) {
if (GetSupportsRSync()) { if (GetSupportsRSync()) {
std::string src_path(source.GetPath()); std::string src_path(source.GetPath());
if (src_path.empty()) if (src_path.empty())
Context not available.
if (llvm::sys::fs::file_size(file_spec.GetPath(), Size)) if (llvm::sys::fs::file_size(file_spec.GetPath(), Size))
return 0; return 0;
return Size; return Size;
} else if (m_remote_platform_sp) }
if (m_remote_platform_sp)
return m_remote_platform_sp->GetFileSize(file_spec); return m_remote_platform_sp->GetFileSize(file_spec);
else else
return Platform::GetFileSize(file_spec); return Platform::GetFileSize(file_spec);
Context not available.
Status PlatformPOSIX::CreateSymlink(const FileSpec &src, const FileSpec &dst) { Status PlatformPOSIX::CreateSymlink(const FileSpec &src, const FileSpec &dst) {
if (IsHost()) if (IsHost())
return FileSystem::Instance().Symlink(src, dst); return FileSystem::Instance().Symlink(src, dst);
else if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->CreateSymlink(src, dst); return m_remote_platform_sp->CreateSymlink(src, dst);
else else
return Platform::CreateSymlink(src, dst); return Platform::CreateSymlink(src, dst);
Context not available.
bool PlatformPOSIX::GetFileExists(const FileSpec &file_spec) { bool PlatformPOSIX::GetFileExists(const FileSpec &file_spec) {
if (IsHost()) if (IsHost())
return FileSystem::Instance().Exists(file_spec); return FileSystem::Instance().Exists(file_spec);
else if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->GetFileExists(file_spec); return m_remote_platform_sp->GetFileExists(file_spec);
else else
return Platform::GetFileExists(file_spec); return Platform::GetFileExists(file_spec);
Context not available.
Status PlatformPOSIX::Unlink(const FileSpec &file_spec) { Status PlatformPOSIX::Unlink(const FileSpec &file_spec) {
if (IsHost()) if (IsHost())
return llvm::sys::fs::remove(file_spec.GetPath()); return llvm::sys::fs::remove(file_spec.GetPath());
else if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->Unlink(file_spec); return m_remote_platform_sp->Unlink(file_spec);
else else
return Platform::Unlink(file_spec); return Platform::Unlink(file_spec);
Context not available.
if (status != 0) if (status != 0)
return Status("unable to perform copy"); return Status("unable to perform copy");
return Status(); return Status();
} else if (m_remote_platform_sp) { }
if (m_remote_platform_sp) {
if (GetSupportsRSync()) { if (GetSupportsRSync()) {
StreamString command; StreamString command;
if (GetIgnoresRemoteHostname()) { if (GetIgnoresRemoteHostname()) {
Context not available.
stream.Printf("cache dir: %s", GetLocalCacheDirectory()); stream.Printf("cache dir: %s", GetLocalCacheDirectory());
if (stream.GetSize()) if (stream.GetSize())
return stream.GetString(); return stream.GetString();
else
return ""; return "";
} }
bool PlatformPOSIX::CalculateMD5(const FileSpec &file_spec, uint64_t &low, bool PlatformPOSIX::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
Context not available.
FileSpec PlatformPOSIX::GetRemoteWorkingDirectory() { FileSpec PlatformPOSIX::GetRemoteWorkingDirectory() {
if (IsRemote() && m_remote_platform_sp) if (IsRemote() && m_remote_platform_sp)
return m_remote_platform_sp->GetRemoteWorkingDirectory(); return m_remote_platform_sp->GetRemoteWorkingDirectory();
else
return Platform::GetRemoteWorkingDirectory(); return Platform::GetRemoteWorkingDirectory();
} }
bool PlatformPOSIX::SetRemoteWorkingDirectory(const FileSpec &working_dir) { bool PlatformPOSIX::SetRemoteWorkingDirectory(const FileSpec &working_dir) {
if (IsRemote() && m_remote_platform_sp) if (IsRemote() && m_remote_platform_sp)
return m_remote_platform_sp->SetRemoteWorkingDirectory(working_dir); return m_remote_platform_sp->SetRemoteWorkingDirectory(working_dir);
else
return Platform::SetRemoteWorkingDirectory(working_dir); return Platform::SetRemoteWorkingDirectory(working_dir);
} }
bool PlatformPOSIX::GetRemoteOSVersion() { bool PlatformPOSIX::GetRemoteOSVersion() {
Context not available.

source/Plugins/Platform/Windows/PlatformWindows.cpp

Context not available.
if (is_host) { if (is_host) {
static ConstString g_host_name(Platform::GetHostPlatformName()); static ConstString g_host_name(Platform::GetHostPlatformName());
return g_host_name; return g_host_name;
} else {
static ConstString g_remote_name("remote-windows");
return g_remote_name;
} }
static ConstString g_remote_name("remote-windows");
return g_remote_name;
} }
const char *PlatformWindows::GetPluginDescriptionStatic(bool is_host) { const char *PlatformWindows::GetPluginDescriptionStatic(bool is_host) {
Context not available.
if (error.Success()) { if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile()) if (exe_module_sp && exe_module_sp->GetObjectFile())
break; break;
else
error.SetErrorToGenericError(); error.SetErrorToGenericError();
} }
if (idx > 0) if (idx > 0)
Context not available.
bool PlatformWindows::IsConnected() const { bool PlatformWindows::IsConnected() const {
if (IsHost()) if (IsHost())
return true; return true;
else if (m_remote_platform_sp) if (m_remote_platform_sp)
return m_remote_platform_sp->IsConnected(); return m_remote_platform_sp->IsConnected();
return false; return false;
} }
Context not available.
// This is a process attach. Don't need to launch anything. // This is a process attach. Don't need to launch anything.
ProcessAttachInfo attach_info(launch_info); ProcessAttachInfo attach_info(launch_info);
return Attach(attach_info, debugger, target, error); return Attach(attach_info, debugger, target, error);
} else { }
ProcessSP process_sp = ProcessSP process_sp =
target->CreateProcess(launch_info.GetListenerForProcess(debugger), target->CreateProcess(launch_info.GetListenerForProcess(debugger),
launch_info.GetProcessPluginName(), nullptr); launch_info.GetProcessPluginName(), nullptr);
// We need to launch and attach to the process. // We need to launch and attach to the process.
launch_info.GetFlags().Set(eLaunchFlagDebug); launch_info.GetFlags().Set(eLaunchFlagDebug);
if (process_sp) if (process_sp)
error = process_sp->Launch(launch_info); error = process_sp->Launch(launch_info);
return process_sp; return process_sp;
}
} }
lldb::ProcessSP PlatformWindows::Attach(ProcessAttachInfo &attach_info, lldb::ProcessSP PlatformWindows::Attach(ProcessAttachInfo &attach_info,
Context not available.

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

Context not available.
if (error.Success()) { if (error.Success()) {
if (exe_module_sp && exe_module_sp->GetObjectFile()) if (exe_module_sp && exe_module_sp->GetObjectFile())
break; break;
else
error.SetErrorToGenericError(); error.SetErrorToGenericError();
} }
if (idx > 0) if (idx > 0)
Context not available.
if (idx == 0) { if (idx == 0) {
arch = remote_arch; arch = remote_arch;
return arch.IsValid(); return arch.IsValid();
} else if (idx == 1 && remote_arch.IsValid() && }
remote_arch.GetTriple().isArch64Bit()) { if (idx == 1 && remote_arch.IsValid() &&
remote_arch.GetTriple().isArch64Bit()) {
arch.SetTriple(remote_arch.GetTriple().get32BitArchVariant()); arch.SetTriple(remote_arch.GetTriple().get32BitArchVariant());
return arch.IsValid(); return arch.IsValid();
} }
Context not available.
"PlatformRemoteGDBServer::GetRemoteWorkingDirectory() -> '%s'", "PlatformRemoteGDBServer::GetRemoteWorkingDirectory() -> '%s'",
working_dir.GetCString()); working_dir.GetCString());
return working_dir; return working_dir;
} else {
return Platform::GetRemoteWorkingDirectory();
} }
return Platform::GetRemoteWorkingDirectory();
} }
bool PlatformRemoteGDBServer::SetRemoteWorkingDirectory( bool PlatformRemoteGDBServer::SetRemoteWorkingDirectory(
Context not available.
log->Printf("PlatformRemoteGDBServer::SetRemoteWorkingDirectory('%s')", log->Printf("PlatformRemoteGDBServer::SetRemoteWorkingDirectory('%s')",
working_dir.GetCString()); working_dir.GetCString());
return m_gdb_client.SetWorkingDir(working_dir) == 0; return m_gdb_client.SetWorkingDir(working_dir) == 0;
} else }
return Platform::SetRemoteWorkingDirectory(working_dir); return Platform::SetRemoteWorkingDirectory(working_dir);
} }
bool PlatformRemoteGDBServer::IsConnected() const { bool PlatformRemoteGDBServer::IsConnected() const {
Context not available.

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

Context not available.
if (command == KDP_RESUMECPUS) if (command == KDP_RESUMECPUS)
m_is_running.SetValue(true, eBroadcastAlways); m_is_running.SetValue(true, eBroadcastAlways);
return true; return true;
} else {
// Failed to get the correct response, bail
reply_packet.Clear();
return false;
} }
// Failed to get the correct response, bail
reply_packet.Clear();
return false;
} else if (reply_sequence_id > request_sequence_id) { } else if (reply_sequence_id > request_sequence_id) {
// Sequence ID was greater than the sequence ID of the packet we // Sequence ID was greater than the sequence ID of the packet we
// sent, something is really wrong... // sent, something is really wrong...
Context not available.
return false; return false;
if (strncmp(m_kernel_version.c_str(), "EFI", 3) == 0) if (strncmp(m_kernel_version.c_str(), "EFI", 3) == 0)
return true; return true;
else
return false; return false;
} }
bool CommunicationKDP::RemoteIsDarwinKernel() { bool CommunicationKDP::RemoteIsDarwinKernel() {
Context not available.
return false; return false;
if (m_kernel_version.find("Darwin Kernel") != std::string::npos) if (m_kernel_version.find("Darwin Kernel") != std::string::npos)
return true; return true;
else
return false; return false;
} }
lldb::addr_t CommunicationKDP::GetLoadAddress() { lldb::addr_t CommunicationKDP::GetLoadAddress() {
Context not available.

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

Context not available.
result.AppendMessage(packet.GetString()); result.AppendMessage(packet.GetString());
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
return true; return true;
} else {
const char *error_cstr = error.AsCString();
if (error_cstr && error_cstr[0])
result.AppendError(error_cstr);
else
result.AppendErrorWithFormat("unknown error 0x%8.8x",
error.GetError());
result.SetStatus(eReturnStatusFailed);
return false;
} }
const char *error_cstr = error.AsCString();
if (error_cstr && error_cstr[0])
result.AppendError(error_cstr);
else
result.AppendErrorWithFormat("unknown error 0x%8.8x",
error.GetError());
result.SetStatus(eReturnStatusFailed);
return false;
} else { } else {
result.AppendErrorWithFormat("process must be stopped in order " result.AppendErrorWithFormat("process must be stopped in order "
"to send KDP packets, state is %s", "to send KDP packets, state is %s",
Context not available.

source/Plugins/Process/Utility/ARMUtils.h

Context not available.
uint32_t result = LSL_C(value, amount, dont_care, success); uint32_t result = LSL_C(value, amount, dont_care, success);
if (*success) if (*success)
return result; return result;
else
return 0; return 0;
} }
static inline uint32_t LSR_C(const uint32_t value, const uint32_t amount, static inline uint32_t LSR_C(const uint32_t value, const uint32_t amount,
Context not available.
uint32_t result = LSR_C(value, amount, dont_care, success); uint32_t result = LSR_C(value, amount, dont_care, success);
if (*success) if (*success)
return result; return result;
else
return 0; return 0;
} }
static inline uint32_t ASR_C(const uint32_t value, const uint32_t amount, static inline uint32_t ASR_C(const uint32_t value, const uint32_t amount,
Context not available.
carry_out = Bit32(value, amount - 1); carry_out = Bit32(value, amount - 1);
int64_t extended = llvm::SignExtend64<32>(value); int64_t extended = llvm::SignExtend64<32>(value);
return UnsignedBits(extended, amount + 31, amount); return UnsignedBits(extended, amount + 31, amount);
} else {
carry_out = (negative ? 1 : 0);
return (negative ? 0xffffffff : 0);
} }
carry_out = (negative ? 1 : 0);
return (negative ? 0xffffffff : 0);
} }
static inline uint32_t ASR(const uint32_t value, const uint32_t amount, static inline uint32_t ASR(const uint32_t value, const uint32_t amount,
Context not available.
uint32_t result = ASR_C(value, amount, dont_care, success); uint32_t result = ASR_C(value, amount, dont_care, success);
if (*success) if (*success)
return result; return result;
else
return 0; return 0;
} }
static inline uint32_t ROR_C(const uint32_t value, const uint32_t amount, static inline uint32_t ROR_C(const uint32_t value, const uint32_t amount,
Context not available.
uint32_t result = ROR_C(value, amount, dont_care, success); uint32_t result = ROR_C(value, amount, dont_care, success);
if (*success) if (*success)
return result; return result;
else
return 0; return 0;
} }
static inline uint32_t RRX_C(const uint32_t value, const uint32_t carry_in, static inline uint32_t RRX_C(const uint32_t value, const uint32_t carry_in,
Context not available.
uint32_t result = RRX_C(value, carry_in, dont_care, success); uint32_t result = RRX_C(value, carry_in, dont_care, success);
if (*success) if (*success)
return result; return result;
else
return 0; return 0;
} }
static inline uint32_t Shift_C(const uint32_t value, ARM_ShifterType type, static inline uint32_t Shift_C(const uint32_t value, ARM_ShifterType type,
Context not available.
} }
if (*success) if (*success)
return result; return result;
else
return 0; return 0;
} }
static inline uint32_t Shift(const uint32_t value, ARM_ShifterType type, static inline uint32_t Shift(const uint32_t value, ARM_ShifterType type,
Context not available.
uint32_t result = Shift_C(value, type, amount, carry_in, dont_care, success); uint32_t result = Shift_C(value, type, amount, carry_in, dont_care, success);
if (*success) if (*success)
return result; return result;
else
return 0; return 0;
} }
static inline uint32_t bits(const uint32_t val, const uint32_t msbit, static inline uint32_t bits(const uint32_t val, const uint32_t msbit,
Context not available.

source/Plugins/Process/Utility/NativeRegisterContextRegisterInfo.cpp

Context not available.
uint32_t reg_index) const { uint32_t reg_index) const {
if (reg_index <= GetRegisterCount()) if (reg_index <= GetRegisterCount())
return m_register_info_interface_up->GetRegisterInfo() + reg_index; return m_register_info_interface_up->GetRegisterInfo() + reg_index;
else
return nullptr; return nullptr;
} }
const RegisterInfoInterface & const RegisterInfoInterface &
Context not available.

source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp

Context not available.
int RegisterContextDarwin_arm::GetSetForNativeRegNum(int reg) { int RegisterContextDarwin_arm::GetSetForNativeRegNum(int reg) {
if (reg < fpu_s0) if (reg < fpu_s0)
return GPRRegSet; return GPRRegSet;
else if (reg < exc_exception) if (reg < exc_exception)
return FPURegSet; return FPURegSet;
else if (reg < k_num_registers) else if (reg < k_num_registers)
aprantlUnsubmitted
Not Done
ReplyInline Actions

This is inconsistent (do you need to re-run it until it reaches a fixpoint?

aprantl: This is inconsistent (do you need to re-run it until it reaches a fixpoint?
return EXCRegSet; return EXCRegSet;
Context not available.

source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp

Context not available.
int RegisterContextDarwin_arm64::GetSetForNativeRegNum(int reg) { int RegisterContextDarwin_arm64::GetSetForNativeRegNum(int reg) {
if (reg < fpu_v0) if (reg < fpu_v0)
return GPRRegSet; return GPRRegSet;
else if (reg < exc_far) if (reg < exc_far)
return FPURegSet; return FPURegSet;
else if (reg < k_num_registers) else if (reg < k_num_registers)
return EXCRegSet; return EXCRegSet;
Context not available.

source/Plugins/Process/Utility/RegisterContextDarwin_i386.cpp

Context not available.
int RegisterContextDarwin_i386::GetSetForNativeRegNum(int reg_num) { int RegisterContextDarwin_i386::GetSetForNativeRegNum(int reg_num) {
if (reg_num < fpu_fcw) if (reg_num < fpu_fcw)
return GPRRegSet; return GPRRegSet;
else if (reg_num < exc_trapno) if (reg_num < exc_trapno)
return FPURegSet; return FPURegSet;
else if (reg_num < k_num_registers) else if (reg_num < k_num_registers)
return EXCRegSet; return EXCRegSet;
Context not available.
// If the trace bit is already set, there is nothing to do // If the trace bit is already set, there is nothing to do
if (gpr.eflags & trace_bit) if (gpr.eflags & trace_bit)
return true; return true;
else
gpr.eflags |= trace_bit; gpr.eflags |= trace_bit;
} else { } else {
// If the trace bit is already cleared, there is nothing to do // If the trace bit is already cleared, there is nothing to do
if (gpr.eflags & trace_bit) if (gpr.eflags & trace_bit)
Context not available.

source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp

Context not available.
int RegisterContextDarwin_x86_64::GetSetForNativeRegNum(int reg_num) { int RegisterContextDarwin_x86_64::GetSetForNativeRegNum(int reg_num) {
if (reg_num < fpu_fcw) if (reg_num < fpu_fcw)
return GPRRegSet; return GPRRegSet;
else if (reg_num < exc_trapno) if (reg_num < exc_trapno)
return FPURegSet; return FPURegSet;
else if (reg_num < k_num_registers) else if (reg_num < k_num_registers)
return EXCRegSet; return EXCRegSet;
Context not available.
if (gpr.rflags & trace_bit) if (gpr.rflags & trace_bit)
return true; // trace bit is already set, there is nothing to do return true; // trace bit is already set, there is nothing to do
else
gpr.rflags |= trace_bit; gpr.rflags |= trace_bit;
} else { } else {
if (gpr.rflags & trace_bit) if (gpr.rflags & trace_bit)
gpr.rflags &= ~trace_bit; gpr.rflags &= ~trace_bit;
Context not available.

source/Plugins/Process/Utility/RegisterContextLLDB.cpp

Context not available.
static ConstString GetSymbolOrFunctionName(const SymbolContext &sym_ctx) { static ConstString GetSymbolOrFunctionName(const SymbolContext &sym_ctx) {
if (sym_ctx.symbol) if (sym_ctx.symbol)
return sym_ctx.symbol->GetName(); return sym_ctx.symbol->GetName();
else if (sym_ctx.function) if (sym_ctx.function)
return sym_ctx.function->GetName(); return sym_ctx.function->GetName();
return ConstString(); return ConstString();
} }
Context not available.
} }
m_frame_type = eNormalFrame; m_frame_type = eNormalFrame;
return unwind_plan_sp; return unwind_plan_sp;
} else {
unwind_plan_sp.reset();
} }
unwind_plan_sp.reset();
} }
return unwind_plan_sp; return unwind_plan_sp;
} }
Context not available.
unwind_plan_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric)); unwind_plan_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric));
if (eh_frame->GetUnwindPlan(m_current_pc, *unwind_plan_sp)) if (eh_frame->GetUnwindPlan(m_current_pc, *unwind_plan_sp))
return unwind_plan_sp; return unwind_plan_sp;
else
unwind_plan_sp.reset(); unwind_plan_sp.reset();
} }
ArmUnwindInfo *arm_exidx = ArmUnwindInfo *arm_exidx =
Context not available.
if (arm_exidx->GetUnwindPlan(exe_ctx.GetTargetRef(), m_current_pc, if (arm_exidx->GetUnwindPlan(exe_ctx.GetTargetRef(), m_current_pc,
*unwind_plan_sp)) *unwind_plan_sp))
return unwind_plan_sp; return unwind_plan_sp;
else
unwind_plan_sp.reset(); unwind_plan_sp.reset();
} }
return arch_default_unwind_plan_sp; return arch_default_unwind_plan_sp;
Context not available.
"RegisterContext at frame 0", "RegisterContext at frame 0",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound; return UnwindLLDB::RegisterSearchResult::eRegisterFound;
} else { }
std::string unwindplan_name(""); std::string unwindplan_name("");
if (m_full_unwind_plan_sp) { if (m_full_unwind_plan_sp) {
unwindplan_name += "via '"; unwindplan_name += "via '";
unwindplan_name += m_full_unwind_plan_sp->GetSourceName().AsCString(); unwindplan_name += m_full_unwind_plan_sp->GetSourceName().AsCString();
unwindplan_name += "'"; unwindplan_name += "'";
} }
UnwindLogMsg("no save location for %s (%d) %s", regnum.GetName(), UnwindLogMsg("no save location for %s (%d) %s", regnum.GetName(),
regnum.GetAsKind(eRegisterKindLLDB), regnum.GetAsKind(eRegisterKindLLDB),
unwindplan_name.c_str()); unwindplan_name.c_str());
}
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
} }
// unwindplan_regloc has valid contents about where to retrieve the register // unwindplan_regloc has valid contents about where to retrieve the register
Context not available.
"have no information", "have no information",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterNotFound; return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
} else {
regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
regloc.location.register_number = regnum.GetAsKind(eRegisterKindLLDB);
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg(
"supplying caller's register %s (%d), saved in register %s (%d)",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB),
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
} }
regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
regloc.location.register_number = regnum.GetAsKind(eRegisterKindLLDB);
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg(
"supplying caller's register %s (%d), saved in register %s (%d)",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB), regnum.GetName(),
regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
} }
if (unwindplan_regloc.IsCFAPlusOffset()) { if (unwindplan_regloc.IsCFAPlusOffset()) {
Context not available.
"(IsDWARFExpression)", "(IsDWARFExpression)",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB)); regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound; return UnwindLLDB::RegisterSearchResult::eRegisterFound;
} else {
regloc.type =
UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
regloc.location.target_memory_location = val;
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
"(IsAtDWARFExpression)",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
} }
regloc.type =
UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
regloc.location.target_memory_location = val;
m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
"(IsAtDWARFExpression)",
regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
return UnwindLLDB::RegisterSearchResult::eRegisterFound;
} }
UnwindLogMsg("tried to use IsDWARFExpression or IsAtDWARFExpression for %s " UnwindLogMsg("tried to use IsDWARFExpression or IsAtDWARFExpression for %s "
"(%d) but failed", "(%d) but failed",
Context not available.
cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB), cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
cfa_reg_contents, address); cfa_reg_contents, address);
return true; return true;
} else {
UnwindLogMsg("Tried to deref reg %s (%d) [0x%" PRIx64
"] but memory read failed.",
cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
cfa_reg_contents);
} }
UnwindLogMsg("Tried to deref reg %s (%d) [0x%" PRIx64
"] but memory read failed.",
cfa_reg.GetName(), cfa_reg.GetAsKind(eRegisterKindLLDB),
cfa_reg_contents);
} }
} }
break; break;
Context not available.
} }
return true; return true;
} else {
return false;
} }
return false;
} }
void RegisterContextLLDB::UnwindLogMsg(const char *fmt, ...) { void RegisterContextLLDB::UnwindLogMsg(const char *fmt, ...) {
Context not available.

source/Plugins/Process/Utility/RegisterContextPOSIX_arm.cpp

Context not available.
RegisterContextPOSIX_arm::GetRegisterInfoAtIndex(size_t reg) { RegisterContextPOSIX_arm::GetRegisterInfoAtIndex(size_t reg) {
if (reg < m_reg_info.num_registers) if (reg < m_reg_info.num_registers)
return &GetRegisterInfo()[reg]; return &GetRegisterInfo()[reg];
else
return NULL; return NULL;
} }
size_t RegisterContextPOSIX_arm::GetRegisterSetCount() { size_t RegisterContextPOSIX_arm::GetRegisterSetCount() {
Context not available.

source/Plugins/Process/Utility/RegisterContextPOSIX_arm64.cpp

Context not available.
RegisterContextPOSIX_arm64::GetRegisterInfoAtIndex(size_t reg) { RegisterContextPOSIX_arm64::GetRegisterInfoAtIndex(size_t reg) {
if (reg < m_reg_info.num_registers) if (reg < m_reg_info.num_registers)
return &GetRegisterInfo()[reg]; return &GetRegisterInfo()[reg];
else
return NULL; return NULL;
} }
size_t RegisterContextPOSIX_arm64::GetRegisterSetCount() { size_t RegisterContextPOSIX_arm64::GetRegisterSetCount() {
Context not available.

source/Plugins/Process/Utility/RegisterContextPOSIX_mips64.cpp

Context not available.
RegisterContextPOSIX_mips64::GetRegisterInfoAtIndex(size_t reg) { RegisterContextPOSIX_mips64::GetRegisterInfoAtIndex(size_t reg) {
if (reg < m_num_registers) if (reg < m_num_registers)
return &GetRegisterInfo()[reg]; return &GetRegisterInfo()[reg];
else
return NULL; return NULL;
} }
size_t RegisterContextPOSIX_mips64::GetRegisterSetCount() { size_t RegisterContextPOSIX_mips64::GetRegisterSetCount() {
Context not available.

source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp

Context not available.
RegisterContextPOSIX_powerpc::GetRegisterInfoAtIndex(size_t reg) { RegisterContextPOSIX_powerpc::GetRegisterInfoAtIndex(size_t reg) {
if (reg < k_num_registers_powerpc) if (reg < k_num_registers_powerpc)
return &GetRegisterInfo()[reg]; return &GetRegisterInfo()[reg];
else
return NULL; return NULL;
} }
size_t RegisterContextPOSIX_powerpc::GetRegisterSetCount() { size_t RegisterContextPOSIX_powerpc::GetRegisterSetCount() {
Context not available.
const RegisterSet *RegisterContextPOSIX_powerpc::GetRegisterSet(size_t set) { const RegisterSet *RegisterContextPOSIX_powerpc::GetRegisterSet(size_t set) {
if (IsRegisterSetAvailable(set)) if (IsRegisterSetAvailable(set))
return &g_reg_sets_powerpc[set]; return &g_reg_sets_powerpc[set];
else
return NULL; return NULL;
} }
const char *RegisterContextPOSIX_powerpc::GetRegisterName(unsigned reg) { const char *RegisterContextPOSIX_powerpc::GetRegisterName(unsigned reg) {
Context not available.

source/Plugins/Process/Utility/RegisterContextPOSIX_ppc64le.cpp

Context not available.
RegisterContextPOSIX_ppc64le::GetRegisterInfoAtIndex(size_t reg) { RegisterContextPOSIX_ppc64le::GetRegisterInfoAtIndex(size_t reg) {
if (reg < k_num_registers_ppc64le) if (reg < k_num_registers_ppc64le)
return &GetRegisterInfo()[reg]; return &GetRegisterInfo()[reg];
else
return NULL; return NULL;
} }
size_t RegisterContextPOSIX_ppc64le::GetRegisterSetCount() { size_t RegisterContextPOSIX_ppc64le::GetRegisterSetCount() {
Context not available.
const RegisterSet *RegisterContextPOSIX_ppc64le::GetRegisterSet(size_t set) { const RegisterSet *RegisterContextPOSIX_ppc64le::GetRegisterSet(size_t set) {
if (IsRegisterSetAvailable(set)) if (IsRegisterSetAvailable(set))
return &g_reg_sets_ppc64le[set]; return &g_reg_sets_ppc64le[set];
else
return NULL; return NULL;
} }
const char *RegisterContextPOSIX_ppc64le::GetRegisterName(unsigned reg) { const char *RegisterContextPOSIX_ppc64le::GetRegisterName(unsigned reg) {
Context not available.

source/Plugins/Process/Utility/RegisterContextPOSIX_s390x.cpp

Context not available.
RegisterContextPOSIX_s390x::GetRegisterInfoAtIndex(size_t reg) { RegisterContextPOSIX_s390x::GetRegisterInfoAtIndex(size_t reg) {
if (reg < m_reg_info.num_registers) if (reg < m_reg_info.num_registers)
return &GetRegisterInfo()[reg]; return &GetRegisterInfo()[reg];
else
return NULL; return NULL;
} }
size_t RegisterContextPOSIX_s390x::GetRegisterCount() { size_t RegisterContextPOSIX_s390x::GetRegisterCount() {
Context not available.

source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp

Context not available.
RegisterContextPOSIX_x86::GetRegisterInfoAtIndex(size_t reg) { RegisterContextPOSIX_x86::GetRegisterInfoAtIndex(size_t reg) {
if (reg < m_reg_info.num_registers) if (reg < m_reg_info.num_registers)
return &GetRegisterInfo()[reg]; return &GetRegisterInfo()[reg];
else
return NULL; return NULL;
} }
size_t RegisterContextPOSIX_x86::GetRegisterSetCount() { size_t RegisterContextPOSIX_x86::GetRegisterSetCount() {
Context not available.

source/Plugins/Process/Utility/StopInfoMachException.cpp

Context not available.
wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code); wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
return StopInfo::CreateStopReasonWithWatchpointID(thread, return StopInfo::CreateStopReasonWithWatchpointID(thread,
wp_sp->GetID()); wp_sp->GetID());
} else {
is_actual_breakpoint = true;
is_trace_if_actual_breakpoint_missing = true;
} }
is_actual_breakpoint = true;
is_trace_if_actual_breakpoint_missing = true;
} else if (exc_code == 1) // EXC_ARM_BREAKPOINT } else if (exc_code == 1) // EXC_ARM_BREAKPOINT
{ {
is_actual_breakpoint = true; is_actual_breakpoint = true;
Context not available.
thread.GetProcess()->GetOperatingSystem() != NULL) thread.GetProcess()->GetOperatingSystem() != NULL)
return StopInfo::CreateStopReasonWithBreakpointSiteID( return StopInfo::CreateStopReasonWithBreakpointSiteID(
thread, bp_site_sp->GetID()); thread, bp_site_sp->GetID());
else if (is_trace_if_actual_breakpoint_missing) if (is_trace_if_actual_breakpoint_missing)
return StopInfo::CreateStopReasonToTrace(thread); return StopInfo::CreateStopReasonToTrace(thread);
else else
return StopInfoSP(); return StopInfoSP();
Context not available.

source/Plugins/Process/Utility/UnwindLLDB.cpp

Context not available.
"stopping stack walk", "stopping stack walk",
cur_idx < 100 ? cur_idx : 100, "", cur_idx); cur_idx < 100 ? cur_idx : 100, "", cur_idx);
return nullptr; return nullptr;
} else {
if (log)
log->Printf("%*sFrame %d had a bad CFA value but we switched the "
"UnwindPlan being used and got one that looks more "
"realistic.",
cur_idx < 100 ? cur_idx : 100, "", cur_idx);
} }
if (log)
log->Printf("%*sFrame %d had a bad CFA value but we switched the "
"UnwindPlan being used and got one that looks more "
"realistic.",
cur_idx < 100 ? cur_idx : 100, "", cur_idx);
} }
} }
if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) { if (!reg_ctx_sp->ReadPC(cursor_sp->start_pc)) {
Context not available.
lldb_regnum, regloc); lldb_regnum, regloc);
if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound) if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound)
return true; return true;
else
return false; return false;
} }
while (frame_num >= 0) { while (frame_num >= 0) {
UnwindLLDB::RegisterSearchResult result; UnwindLLDB::RegisterSearchResult result;
Context not available.

source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp

Context not available.
v = m_gpr.GetMaxU64(&offset, reg_info->byte_size); v = m_gpr.GetMaxU64(&offset, reg_info->byte_size);
value = v; value = v;
return true; return true;
} else if (IsFPR(reg_info->kinds[lldb::eRegisterKindLLDB])) { }
if (IsFPR(reg_info->kinds[lldb::eRegisterKindLLDB])) {
offset = offset - sizeof(GPR_linux_mips); offset = offset - sizeof(GPR_linux_mips);
v =m_fpr.GetMaxU64(&offset, reg_info->byte_size); v =m_fpr.GetMaxU64(&offset, reg_info->byte_size);
value = v; value = v;
return true; return true;
} }
return false; return false;
} }
Context not available.

source/Plugins/Process/elf-core/RegisterContextPOSIXCore_ppc64le.cpp

Context not available.
value.SetBytes(&v, reg_info->byte_size, m_vsx.GetByteOrder()); value.SetBytes(&v, reg_info->byte_size, m_vsx.GetByteOrder());
return true; return true;
} else {
offset =
m_vmx.CopyData(offset - GetVSXSize() / 2, reg_info->byte_size, &v);
if (offset == reg_info->byte_size) {
value.SetBytes(v, reg_info->byte_size, m_vmx.GetByteOrder());
return true;
}
} }
offset = m_vmx.CopyData(offset - GetVSXSize() / 2, reg_info->byte_size, &v);
if (offset == reg_info->byte_size) {
value.SetBytes(v, reg_info->byte_size, m_vmx.GetByteOrder());
return true;
}
} else { } else {
uint64_t v = m_gpr.GetMaxU64(&offset, reg_info->byte_size); uint64_t v = m_gpr.GetMaxU64(&offset, reg_info->byte_size);
Context not available.

source/Plugins/Process/elf-core/ThreadElfCore.cpp

Context not available.
assert(!abi.empty() && "ABI is not set"); assert(!abi.empty() && "ABI is not set");
if (!abi.compare("n64")) if (!abi.compare("n64"))
return sizeof(ELFLinuxPrStatus); return sizeof(ELFLinuxPrStatus);
else if (!abi.compare("o32")) if (!abi.compare("o32"))
return mips_linux_pr_status_size_o32; return mips_linux_pr_status_size_o32;
// N32 ABI // N32 ABI
return mips_linux_pr_status_size_n32; return mips_linux_pr_status_size_n32;
Context not available.

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

Context not available.
if (bytes_written == packet_length) { if (bytes_written == packet_length) {
if (!skip_ack && GetSendAcks()) if (!skip_ack && GetSendAcks())
return GetAck(); return GetAck();
else
return PacketResult::Success; return PacketResult::Success;
} else { } else {
if (log) if (log)
log->Printf("error: failed to send packet: %.*s", (int)packet_length, log->Printf("error: failed to send packet: %.*s", (int)packet_length,
Context not available.
if (packet.GetResponseType() == if (packet.GetResponseType() ==
StringExtractorGDBRemote::ResponseType::eAck) StringExtractorGDBRemote::ResponseType::eAck)
return PacketResult::Success; return PacketResult::Success;
else
return PacketResult::ErrorSendAck; return PacketResult::ErrorSendAck;
} }
return result; return result;
} }
Context not available.
bool sync_on_timeout) { bool sync_on_timeout) {
if (m_read_thread_enabled) if (m_read_thread_enabled)
return PopPacketFromQueue(response, timeout); return PopPacketFromQueue(response, timeout);
else
return WaitForPacketNoLock(response, timeout, sync_on_timeout); return WaitForPacketNoLock(response, timeout, sync_on_timeout);
} }
// This function is called when a packet is requested. // This function is called when a packet is requested.
Context not available.
if (response_regex.Execute(echo_response.GetStringRef())) { if (response_regex.Execute(echo_response.GetStringRef())) {
sync_success = true; sync_success = true;
break; break;
} else if (successful_responses == 1) { }
if (successful_responses == 1) {
// We got something else back as the first successful // We got something else back as the first successful
// response, it probably is the response to the packet we // response, it probably is the response to the packet we
// actually wanted, so copy it over if this is the first // actually wanted, so copy it over if this is the first
Context not available.
return PacketResult::ErrorDisconnected; return PacketResult::ErrorDisconnected;
if (timed_out) if (timed_out)
return PacketResult::ErrorReplyTimeout; return PacketResult::ErrorReplyTimeout;
else
return PacketResult::ErrorReplyFailed; return PacketResult::ErrorReplyFailed;
} }
bool GDBRemoteCommunication::DecompressPacket() { bool GDBRemoteCommunication::DecompressPacket() {
Context not available.
SendNack(); SendNack();
m_bytes.erase(0, size_of_first_packet); m_bytes.erase(0, size_of_first_packet);
return false; return false;
} else {
SendAck();
} }
SendAck();
} }
if (m_bytes[1] == 'N') { if (m_bytes[1] == 'N') {
Context not available.
if (content_length == std::string::npos) { if (content_length == std::string::npos) {
packet.Clear(); packet.Clear();
return GDBRemoteCommunication::PacketType::Invalid; return GDBRemoteCommunication::PacketType::Invalid;
} else if (total_length > 0) { }
if (total_length > 0) {
// We have a valid packet... // We have a valid packet...
assert(content_length <= m_bytes.size()); assert(content_length <= m_bytes.size());
Context not available.
if (isNotifyPacket) if (isNotifyPacket)
return GDBRemoteCommunication::PacketType::Notify; return GDBRemoteCommunication::PacketType::Notify;
else
return GDBRemoteCommunication::PacketType::Standard; return GDBRemoteCommunication::PacketType::Standard;
} }
} }
packet.Clear(); packet.Clear();
Context not available.

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

Context not available.
// live connection to a remote GDB server... // live connection to a remote GDB server...
if (QueryNoAckModeSupported()) { if (QueryNoAckModeSupported()) {
return true; return true;
} else {
if (error_ptr)
error_ptr->SetErrorString("failed to get reply to handshake packet");
} }
if (error_ptr)
error_ptr->SetErrorString("failed to get reply to handshake packet");
} else { } else {
if (error_ptr) if (error_ptr)
error_ptr->SetErrorString("failed to send the handshake ack"); error_ptr->SetErrorString("failed to send the handshake ack");
Context not available.
} }
if (m_attach_or_wait_reply == eLazyBoolYes) if (m_attach_or_wait_reply == eLazyBoolYes)
return true; return true;
else
return false; return false;
} }
bool GDBRemoteCommunicationClient::GetSyncThreadStateSupported() { bool GDBRemoteCommunicationClient::GetSyncThreadStateSupported() {
Context not available.
} }
if (m_prepare_for_reg_writing_reply == eLazyBoolYes) if (m_prepare_for_reg_writing_reply == eLazyBoolYes)
return true; return true;
else
return false; return false;
} }
void GDBRemoteCommunicationClient::ResetDiscoverableSettings(bool did_exec) { void GDBRemoteCommunicationClient::ResetDiscoverableSettings(bool did_exec) {
Context not available.
if (m_curr_pid_is_valid == eLazyBoolYes) { if (m_curr_pid_is_valid == eLazyBoolYes) {
// We really got it. // We really got it.
return m_curr_pid; return m_curr_pid;
} else { }
// If we don't get a response for qProcessInfo, check if $qC gives us a // If we don't get a response for qProcessInfo, check if $qC gives us a
// result. $qC only returns a real process id on older debugserver and // result. $qC only returns a real process id on older debugserver and
// lldb-platform stubs. The gdb remote protocol documents $qC as returning // lldb-platform stubs. The gdb remote protocol documents $qC as returning
// the thread id, which newer debugserver and lldb-gdbserver stubs return // the thread id, which newer debugserver and lldb-gdbserver stubs return
// correctly. // correctly.
StringExtractorGDBRemote response; StringExtractorGDBRemote response;
if (SendPacketAndWaitForResponse("qC", response, false) == if (SendPacketAndWaitForResponse("qC", response, false) ==
PacketResult::Success) { PacketResult::Success) {
if (response.GetChar() == 'Q') { if (response.GetChar() == 'Q') {
if (response.GetChar() == 'C') { if (response.GetChar() == 'C') {
m_curr_pid = response.GetHexMaxU32(false, LLDB_INVALID_PROCESS_ID); m_curr_pid = response.GetHexMaxU32(false, LLDB_INVALID_PROCESS_ID);
if (m_curr_pid != LLDB_INVALID_PROCESS_ID) { if (m_curr_pid != LLDB_INVALID_PROCESS_ID) {
m_curr_pid_is_valid = eLazyBoolYes; m_curr_pid_is_valid = eLazyBoolYes;
return m_curr_pid; return m_curr_pid;
}
} }
} }
} }
}
// If we don't get a response for $qC, check if $qfThreadID gives us a // If we don't get a response for $qC, check if $qfThreadID gives us a
// result. // result.
Context not available.
return m_curr_pid; return m_curr_pid;
} }
} }
}
return LLDB_INVALID_PROCESS_ID; return LLDB_INVALID_PROCESS_ID;
} }
Context not available.
if (was_supported) if (was_supported)
*was_supported = true; *was_supported = true;
return 0; return 0;
} else if (response.IsUnsupportedResponse()) { }
if (response.IsUnsupportedResponse()) {
if (was_supported) if (was_supported)
*was_supported = false; *was_supported = false;
return -1; return -1;
Context not available.
if (m_supports_detach_stay_stopped == eLazyBoolNo) { if (m_supports_detach_stay_stopped == eLazyBoolNo) {
error.SetErrorString("Stays stopped not supported by this target."); error.SetErrorString("Stays stopped not supported by this target.");
return error; return error;
} else {
StringExtractorGDBRemote response;
PacketResult packet_result =
SendPacketAndWaitForResponse("D1", response, false);
if (packet_result != PacketResult::Success)
error.SetErrorString("Sending extended disconnect packet failed.");
} }
StringExtractorGDBRemote response;
PacketResult packet_result =
SendPacketAndWaitForResponse("D1", response, false);
if (packet_result != PacketResult::Success)
error.SetErrorString("Sending extended disconnect packet failed.");
} else { } else {
StringExtractorGDBRemote response; StringExtractorGDBRemote response;
PacketResult packet_result = PacketResult packet_result =
Context not available.
if (SendPacketAndWaitForResponse(packet, response, false) == if (SendPacketAndWaitForResponse(packet, response, false) ==
PacketResult::Success) { PacketResult::Success) {
return DecodeProcessInfoResponse(response, process_info); return DecodeProcessInfoResponse(response, process_info);
} else {
m_supports_qProcessInfoPID = false;
return false;
} }
m_supports_qProcessInfoPID = false;
return false;
} }
return false; return false;
} }
Context not available.
uint32_t exitcode = response.GetHexMaxU32(false, UINT32_MAX); uint32_t exitcode = response.GetHexMaxU32(false, UINT32_MAX);
if (exitcode == UINT32_MAX) if (exitcode == UINT32_MAX)
return Status("unable to run remote process"); return Status("unable to run remote process");
else if (status_ptr) if (status_ptr)
*status_ptr = exitcode; *status_ptr = exitcode;
if (response.GetChar() != ',') if (response.GetChar() != ',')
return Status("malformed reply"); return Status("malformed reply");
Context not available.
return 0; return 0;
} }
return bytes_written; return bytes_written;
} else {
error.SetErrorString("failed to send vFile:pwrite packet");
} }
error.SetErrorString("failed to send vFile:pwrite packet");
return 0; return 0;
} }
Context not available.
lldb::eStructuredDataTypeDictionary) { lldb::eStructuredDataTypeDictionary) {
error.SetErrorString("Invalid Configuration obtained"); error.SetErrorString("Invalid Configuration obtained");
return error; return error;
} else }
options.setTraceParams( options.setTraceParams(
static_pointer_cast<StructuredData::Dictionary>( static_pointer_cast<StructuredData::Dictionary>(custom_params_sp));
custom_params_sp));
} }
} else { } else {
error = response.GetStatus(); error = response.GetStatus();
Context not available.
// connected to // connected to
m_supports_qSymbol = false; m_supports_qSymbol = false;
return; return;
} else { }
llvm::StringRef response_str(response.GetStringRef()); llvm::StringRef response_str(response.GetStringRef());
if (response_str.startswith("qSymbol:")) { if (response_str.startswith("qSymbol:")) {
response.SetFilePos(strlen("qSymbol:")); response.SetFilePos(strlen("qSymbol:"));
std::string symbol_name; std::string symbol_name;
if (response.GetHexByteString(symbol_name)) { if (response.GetHexByteString(symbol_name)) {
if (symbol_name.empty()) if (symbol_name.empty())
return; return;
addr_t symbol_load_addr = LLDB_INVALID_ADDRESS; addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
lldb_private::SymbolContextList sc_list; lldb_private::SymbolContextList sc_list;
if (process->GetTarget().GetImages().FindSymbolsWithNameAndType( if (process->GetTarget().GetImages().FindSymbolsWithNameAndType(
ConstString(symbol_name), eSymbolTypeAny, sc_list)) { ConstString(symbol_name), eSymbolTypeAny, sc_list)) {
const size_t num_scs = sc_list.GetSize(); const size_t num_scs = sc_list.GetSize();
for (size_t sc_idx = 0; for (size_t sc_idx = 0;
sc_idx < num_scs && sc_idx < num_scs && symbol_load_addr == LLDB_INVALID_ADDRESS;
symbol_load_addr == LLDB_INVALID_ADDRESS; ++sc_idx) {
++sc_idx) { SymbolContext sc;
SymbolContext sc; if (sc_list.GetContextAtIndex(sc_idx, sc)) {
if (sc_list.GetContextAtIndex(sc_idx, sc)) { if (sc.symbol) {
if (sc.symbol) { switch (sc.symbol->GetType()) {
switch (sc.symbol->GetType()) { case eSymbolTypeInvalid:
case eSymbolTypeInvalid: case eSymbolTypeAbsolute:
case eSymbolTypeAbsolute: case eSymbolTypeUndefined:
case eSymbolTypeUndefined: case eSymbolTypeSourceFile:
case eSymbolTypeSourceFile: case eSymbolTypeHeaderFile:
case eSymbolTypeHeaderFile: case eSymbolTypeObjectFile:
case eSymbolTypeObjectFile: case eSymbolTypeCommonBlock:
case eSymbolTypeCommonBlock: case eSymbolTypeBlock:
case eSymbolTypeBlock: case eSymbolTypeLocal:
case eSymbolTypeLocal: case eSymbolTypeParam:
case eSymbolTypeParam: case eSymbolTypeVariable:
case eSymbolTypeVariable: case eSymbolTypeVariableType:
case eSymbolTypeVariableType: case eSymbolTypeLineEntry:
case eSymbolTypeLineEntry: case eSymbolTypeLineHeader:
case eSymbolTypeLineHeader: case eSymbolTypeScopeBegin:
case eSymbolTypeScopeBegin: case eSymbolTypeScopeEnd:
case eSymbolTypeScopeEnd: case eSymbolTypeAdditional:
case eSymbolTypeAdditional: case eSymbolTypeCompiler:
case eSymbolTypeCompiler: case eSymbolTypeInstrumentation:
case eSymbolTypeInstrumentation: case eSymbolTypeTrampoline:
case eSymbolTypeTrampoline: break;
break;
case eSymbolTypeCode:
case eSymbolTypeCode: case eSymbolTypeResolver:
case eSymbolTypeResolver: case eSymbolTypeData:
case eSymbolTypeData: case eSymbolTypeRuntime:
case eSymbolTypeRuntime: case eSymbolTypeException:
case eSymbolTypeException: case eSymbolTypeObjCClass:
case eSymbolTypeObjCClass: case eSymbolTypeObjCMetaClass:
case eSymbolTypeObjCMetaClass: case eSymbolTypeObjCIVar:
case eSymbolTypeObjCIVar: case eSymbolTypeReExported:
case eSymbolTypeReExported: symbol_load_addr =
symbol_load_addr = sc.symbol->GetLoadAddress(&process->GetTarget());
sc.symbol->GetLoadAddress(&process->GetTarget()); break;
break;
}
} }
} }
} }
} }
// This is the normal path where our symbol lookup was successful
// and we want to send a packet with the new symbol value and see
// if another lookup needs to be done.
// Change "packet" to contain the requested symbol value and name
packet.Clear();
packet.PutCString("qSymbol:");
if (symbol_load_addr != LLDB_INVALID_ADDRESS) {
packet.Printf("%" PRIx64, symbol_load_addr);
symbol_response_provided = true;
} else {
symbol_response_provided = false;
}
packet.PutCString(":");
packet.PutBytesAsRawHex8(symbol_name.data(), symbol_name.size());
continue; // go back to the while loop and send "packet" and wait
// for another response
} }
// This is the normal path where our symbol lookup was successful
// and we want to send a packet with the new symbol value and see
// if another lookup needs to be done.
// Change "packet" to contain the requested symbol value and name
packet.Clear();
packet.PutCString("qSymbol:");
if (symbol_load_addr != LLDB_INVALID_ADDRESS) {
packet.Printf("%" PRIx64, symbol_load_addr);
symbol_response_provided = true;
} else {
symbol_response_provided = false;
}
packet.PutCString(":");
packet.PutBytesAsRawHex8(symbol_name.data(), symbol_name.size());
continue; // go back to the while loop and send "packet" and wait
// for another response
}
} }
}
} }
// If we make it here, the symbol request packet response wasn't valid or // If we make it here, the symbol request packet response wasn't valid or
// our symbol lookup failed so we must abort // our symbol lookup failed so we must abort
return; return;
}
} else if (Log *log = ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet( if (Log *log = ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(
GDBR_LOG_PROCESS | GDBR_LOG_PACKETS)) { GDBR_LOG_PROCESS | GDBR_LOG_PACKETS)) {
log->Printf( log->Printf(
"GDBRemoteCommunicationClient::%s: Didn't get sequence mutex.", "GDBRemoteCommunicationClient::%s: Didn't get sequence mutex.",
__FUNCTION__); __FUNCTION__);
Context not available.
if (response.IsOKResponse()) { if (response.IsOKResponse()) {
return Status(); return Status();
} else {
return Status("Unknown error happened during sending QPassSignals packet.");
} }
return Status("Unknown error happened during sending QPassSignals packet.");
} }
Status GDBRemoteCommunicationClient::ConfigureRemoteStructuredData( Status GDBRemoteCommunicationClient::ConfigureRemoteStructuredData(
Context not available.

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationHistory.h

Context not available.
uint32_t GetFirstSavedPacketIndex() const { uint32_t GetFirstSavedPacketIndex() const {
if (m_total_packet_count < m_packets.size()) if (m_total_packet_count < m_packets.size())
return 0; return 0;
else
return m_curr_idx + 1; return m_curr_idx + 1;
} }
uint32_t GetNumPacketsInHistory() const { uint32_t GetNumPacketsInHistory() const {
if (m_total_packet_count < m_packets.size()) if (m_total_packet_count < m_packets.size())
return m_total_packet_count; return m_total_packet_count;
else
return (uint32_t)m_packets.size(); return (uint32_t)m_packets.size();
} }
uint32_t GetNextIndex() { uint32_t GetNextIndex() {
Context not available.

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

Context not available.
packet.Printf("E%2.2x;", static_cast<uint8_t>(error.GetError())); packet.Printf("E%2.2x;", static_cast<uint8_t>(error.GetError()));
packet.PutCStringAsRawHex8(error.AsCString()); packet.PutCStringAsRawHex8(error.AsCString());
return SendPacketNoLock(packet.GetString()); return SendPacketNoLock(packet.GetString());
} else }
return SendErrorResponse(error.GetError()); return SendErrorResponse(error.GetError());
} }
GDBRemoteCommunication::PacketResult GDBRemoteCommunication::PacketResult
Context not available.

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

Context not available.
// FIXME add continue at address support for $C{signo}[;{continue-address}]. // FIXME add continue at address support for $C{signo}[;{continue-address}].
if (*packet.Peek() == ';') if (*packet.Peek() == ';')
return SendUnimplementedResponse(packet.GetStringRef().c_str()); return SendUnimplementedResponse(packet.GetStringRef().c_str());
else
return SendIllFormedResponse( return SendIllFormedResponse(packet,
packet, "unexpected content after $C{signal-number}"); "unexpected content after $C{signal-number}");
} }
ResumeActionList resume_actions(StateType::eStateRunning, 0); ResumeActionList resume_actions(StateType::eStateRunning, 0);
Context not available.
// Move past the ';', then do a simple 'c'. // Move past the ';', then do a simple 'c'.
packet.SetFilePos(packet.GetFilePos() + 1); packet.SetFilePos(packet.GetFilePos() + 1);
return Handle_c(packet); return Handle_c(packet);
} else if (::strcmp(packet.Peek(), ";s") == 0) { }
if (::strcmp(packet.Peek(), ";s") == 0) {
// Move past the ';', then do a simple 's'. // Move past the ';', then do a simple 's'.
packet.SetFilePos(packet.GetFilePos() + 1); packet.SetFilePos(packet.GetFilePos() + 1);
return Handle_s(packet); return Handle_s(packet);
Context not available.
LLDB_LOG(log, "pid {0} failed to set breakpoint: {1}", LLDB_LOG(log, "pid {0} failed to set breakpoint: {1}",
m_debugged_process_up->GetID(), error); m_debugged_process_up->GetID(), error);
return SendErrorResponse(0x09); return SendErrorResponse(0x09);
} else {
// Try to set the watchpoint.
const Status error = m_debugged_process_up->SetWatchpoint(
addr, size, watch_flags, want_hardware);
if (error.Success())
return SendOKResponse();
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
LLDB_LOG(log, "pid {0} failed to set watchpoint: {1}",
m_debugged_process_up->GetID(), error);
return SendErrorResponse(0x09);
} }
// Try to set the watchpoint.
const Status error = m_debugged_process_up->SetWatchpoint(
addr, size, watch_flags, want_hardware);
if (error.Success())
return SendOKResponse();
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
LLDB_LOG(log, "pid {0} failed to set watchpoint: {1}",
m_debugged_process_up->GetID(), error);
return SendErrorResponse(0x09);
} }
GDBRemoteCommunication::PacketResult GDBRemoteCommunication::PacketResult
Context not available.
LLDB_LOG(log, "pid {0} failed to remove breakpoint: {1}", LLDB_LOG(log, "pid {0} failed to remove breakpoint: {1}",
m_debugged_process_up->GetID(), error); m_debugged_process_up->GetID(), error);
return SendErrorResponse(0x09); return SendErrorResponse(0x09);
} else {
// Try to clear the watchpoint.
const Status error = m_debugged_process_up->RemoveWatchpoint(addr);
if (error.Success())
return SendOKResponse();
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
LLDB_LOG(log, "pid {0} failed to remove watchpoint: {1}",
m_debugged_process_up->GetID(), error);
return SendErrorResponse(0x09);
} }
// Try to clear the watchpoint.
const Status error = m_debugged_process_up->RemoveWatchpoint(addr);
if (error.Success())
return SendOKResponse();
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
LLDB_LOG(log, "pid {0} failed to remove watchpoint: {1}",
m_debugged_process_up->GetID(), error);
return SendErrorResponse(0x09);
} }
GDBRemoteCommunication::PacketResult GDBRemoteCommunication::PacketResult
Context not available.
if (m_thread_suffix_supported) if (m_thread_suffix_supported)
return SendIllFormedResponse( return SendIllFormedResponse(
packet, "No thread specified in QSaveRegisterState packet"); packet, "No thread specified in QSaveRegisterState packet");
else
return SendIllFormedResponse(packet, return SendIllFormedResponse(packet,
"No thread was is set with the Hg packet"); "No thread was is set with the Hg packet");
} }
// Grab the register context for the thread. // Grab the register context for the thread.
Context not available.
if (m_thread_suffix_supported) if (m_thread_suffix_supported)
return SendIllFormedResponse( return SendIllFormedResponse(
packet, "No thread specified in QRestoreRegisterState packet"); packet, "No thread specified in QRestoreRegisterState packet");
else
return SendIllFormedResponse(packet, return SendIllFormedResponse(packet,
"No thread was is set with the Hg packet"); "No thread was is set with the Hg packet");
} }
// Grab the register context for the thread. // Grab the register context for the thread.
Context not available.
const lldb::tid_t current_tid = GetCurrentThreadID(); const lldb::tid_t current_tid = GetCurrentThreadID();
if (current_tid == LLDB_INVALID_THREAD_ID) if (current_tid == LLDB_INVALID_THREAD_ID)
return nullptr; return nullptr;
else if (current_tid == 0) { if (current_tid == 0) {
// Pick a thread. // Pick a thread.
return m_debugged_process_up->GetThreadAtIndex(0); return m_debugged_process_up->GetThreadAtIndex(0);
} else } else
Context not available.

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

Context not available.
// go ahead and attempt to kill the spawned process // go ahead and attempt to kill the spawned process
if (KillSpawnedProcess(pid)) if (KillSpawnedProcess(pid))
return SendOKResponse(); return SendOKResponse();
else
return SendErrorResponse(11); return SendErrorResponse(11);
} }
bool GDBRemoteCommunicationServerPlatform::KillSpawnedProcess(lldb::pid_t pid) { bool GDBRemoteCommunicationServerPlatform::KillSpawnedProcess(lldb::pid_t pid) {
Context not available.

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

Context not available.
reg_checkpoint.SetID(save_id); reg_checkpoint.SetID(save_id);
reg_checkpoint.GetData().reset(); reg_checkpoint.GetData().reset();
return true; return true;
} else {
reg_checkpoint.SetID(0); // Invalid save ID is zero
return ReadAllRegisterValues(reg_checkpoint.GetData());
} }
reg_checkpoint.SetID(0); // Invalid save ID is zero
return ReadAllRegisterValues(reg_checkpoint.GetData());
} }
bool GDBRemoteRegisterContext::WriteAllRegisterValues( bool GDBRemoteRegisterContext::WriteAllRegisterValues(
Context not available.
((ProcessGDBRemote *)process)->GetGDBRemote()); ((ProcessGDBRemote *)process)->GetGDBRemote());
return gdb_comm.RestoreRegisterState(m_thread.GetProtocolID(), save_id); return gdb_comm.RestoreRegisterState(m_thread.GetProtocolID(), save_id);
} else {
return WriteAllRegisterValues(reg_checkpoint.GetData());
} }
return WriteAllRegisterValues(reg_checkpoint.GetData());
} }
bool GDBRemoteRegisterContext::ReadAllRegisterValues( bool GDBRemoteRegisterContext::ReadAllRegisterValues(
Context not available.
data_sp.reset(new DataBufferHeap(m_reg_data.GetDataStart(), data_sp.reset(new DataBufferHeap(m_reg_data.GetDataStart(),
m_reg_info.GetRegisterDataByteSize())); m_reg_info.GetRegisterDataByteSize()));
return true; return true;
} else { }
Log *log(ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(GDBR_LOG_THREAD | Log *log(ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(GDBR_LOG_THREAD |
GDBR_LOG_PACKETS)); GDBR_LOG_PACKETS));
Context not available.
log->Printf("error: failed to get packet sequence mutex, not sending " log->Printf("error: failed to get packet sequence mutex, not sending "
"read all registers"); "read all registers");
} }
}
data_sp.reset(); data_sp.reset();
return false; return false;
Context not available.
} }
} }
return num_restored > 0; return num_restored > 0;
} else { }
// For the use_g_packet == false case, we're going to write each register // For the use_g_packet == false case, we're going to write each register
// individually. The data buffer is binary data in this case, instead of // individually. The data buffer is binary data in this case, instead of
// ascii characters. // ascii characters.
bool arm64_debugserver = false; bool arm64_debugserver = false;
if (m_thread.GetProcess().get()) { if (m_thread.GetProcess().get()) {
const ArchSpec &arch = const ArchSpec &arch =
m_thread.GetProcess()->GetTarget().GetArchitecture(); m_thread.GetProcess()->GetTarget().GetArchitecture();
if (arch.IsValid() && arch.GetMachine() == llvm::Triple::aarch64 && if (arch.IsValid() && arch.GetMachine() == llvm::Triple::aarch64 &&
arch.GetTriple().getVendor() == llvm::Triple::Apple && arch.GetTriple().getVendor() == llvm::Triple::Apple &&
arch.GetTriple().getOS() == llvm::Triple::IOS) { arch.GetTriple().getOS() == llvm::Triple::IOS) {
arm64_debugserver = true; arm64_debugserver = true;
} }
} }
uint32_t num_restored = 0; uint32_t num_restored = 0;
const RegisterInfo *reg_info; const RegisterInfo *reg_info;
Context not available.
++num_restored; ++num_restored;
} }
return num_restored > 0; return num_restored > 0;
}
} else { } else {
Log *log(ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(GDBR_LOG_THREAD | Log *log(ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(GDBR_LOG_THREAD |
GDBR_LOG_PACKETS)); GDBR_LOG_PACKETS));
Context not available.

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

Context not available.
// See if we can get register definitions from a python file // See if we can get register definitions from a python file
if (ParsePythonTargetDefinition(target_definition_fspec)) { if (ParsePythonTargetDefinition(target_definition_fspec)) {
return; return;
} else {
StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream();
stream_sp->Printf("ERROR: target description file %s failed to parse.\n",
target_definition_fspec.GetPath().c_str());
} }
StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream();
stream_sp->Printf("ERROR: target description file %s failed to parse.\n",
target_definition_fspec.GetPath().c_str());
} }
const ArchSpec &target_arch = GetTarget().GetArchitecture(); const ArchSpec &target_arch = GetTarget().GetArchitecture();
Context not available.
if (conn_ap->Connect(connect_url, &error) == eConnectionStatusSuccess) { if (conn_ap->Connect(connect_url, &error) == eConnectionStatusSuccess) {
m_gdb_comm.SetConnection(conn_ap.release()); m_gdb_comm.SetConnection(conn_ap.release());
break; break;
} else if (error.WasInterrupted()) { }
if (error.WasInterrupted()) {
// If we were interrupted, don't keep retrying. // If we were interrupted, don't keep retrying.
break; break;
} }
Context not available.
} }
memcpy(buf, response.GetStringRef().data(), data_received_size); memcpy(buf, response.GetStringRef().data(), data_received_size);
return data_received_size; return data_received_size;
} else {
return response.GetHexBytes(
llvm::MutableArrayRef<uint8_t>((uint8_t *)buf, size), '\xdd');
} }
return response.GetHexBytes(
llvm::MutableArrayRef<uint8_t>((uint8_t *)buf, size), '\xdd');
} else if (response.IsErrorResponse()) } else if (response.IsErrorResponse())
error.SetErrorStringWithFormat("memory read failed for 0x%" PRIx64, addr); error.SetErrorStringWithFormat("memory read failed for 0x%" PRIx64, addr);
else if (response.IsUnsupportedResponse()) else if (response.IsUnsupportedResponse())
Context not available.
if (response.IsOKResponse()) { if (response.IsOKResponse()) {
error.Clear(); error.Clear();
return size; return size;
} else if (response.IsErrorResponse()) }
if (response.IsErrorResponse())
error.SetErrorStringWithFormat("memory write failed for 0x%" PRIx64, error.SetErrorStringWithFormat("memory write failed for 0x%" PRIx64,
addr); addr);
else if (response.IsUnsupportedResponse()) else if (response.IsUnsupportedResponse())
Context not available.
assert(watch_read || watch_write); assert(watch_read || watch_write);
if (watch_read && watch_write) if (watch_read && watch_write)
return eWatchpointReadWrite; return eWatchpointReadWrite;
else if (watch_read) if (watch_read)
return eWatchpointRead; return eWatchpointRead;
else // Must be watch_write, then. else // Must be watch_write, then.
return eWatchpointWrite; return eWatchpointWrite;
Context not available.
wp->GetByteSize()) == 0) { wp->GetByteSize()) == 0) {
wp->SetEnabled(true, notify); wp->SetEnabled(true, notify);
return error; return error;
} else }
error.SetErrorString("sending gdb watchpoint packet failed"); error.SetErrorString("sending gdb watchpoint packet failed");
} else } else
error.SetErrorString("watchpoints not supported"); error.SetErrorString("watchpoints not supported");
} else { } else {
Context not available.
wp->GetByteSize()) == 0) { wp->GetByteSize()) == 0) {
wp->SetEnabled(false, notify); wp->SetEnabled(false, notify);
return error; return error;
} else }
error.SetErrorString("sending gdb watchpoint packet failed"); error.SetErrorString("sending gdb watchpoint packet failed");
} }
// TODO: clear software watchpoints if we implement them // TODO: clear software watchpoints if we implement them
} else { } else {
Context not available.

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

Context not available.
if (CachedQueueInfoIsValid()) { if (CachedQueueInfoIsValid()) {
if (m_dispatch_queue_name.empty()) if (m_dispatch_queue_name.empty())
return nullptr; return nullptr;
else
return m_dispatch_queue_name.c_str(); return m_dispatch_queue_name.c_str();
} }
// Always re-fetch the dispatch queue name since it can change // Always re-fetch the dispatch queue name since it can change
Context not available.

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

Context not available.
return m_mach_kernel_addr; return m_mach_kernel_addr;
} }
return m_dyld_addr; return m_dyld_addr;
} else {
if (m_dyld_addr != LLDB_INVALID_ADDRESS) {
return m_dyld_addr;
}
return m_mach_kernel_addr;
} }
if (m_dyld_addr != LLDB_INVALID_ADDRESS) {
return m_dyld_addr;
}
return m_mach_kernel_addr;
} }
lldb_private::ObjectFile *ProcessMachCore::GetCoreObjectFile() { lldb_private::ObjectFile *ProcessMachCore::GetCoreObjectFile() {
Context not available.

source/Plugins/Process/minidump/MinidumpParser.cpp

Context not available.
// to match. // to match.
if (arch.GetTriple().getVendor() == llvm::Triple::Apple) if (arch.GetTriple().getVendor() == llvm::Triple::Apple)
return UUID::fromData(pdb70_uuid->Uuid, sizeof(pdb70_uuid->Uuid)); return UUID::fromData(pdb70_uuid->Uuid, sizeof(pdb70_uuid->Uuid));
else
return UUID::fromData(pdb70_uuid, sizeof(*pdb70_uuid)); return UUID::fromData(pdb70_uuid, sizeof(*pdb70_uuid));
} }
} else if (cv_signature == CvSignature::ElfBuildId) } else if (cv_signature == CvSignature::ElfBuildId)
return UUID::fromData(cv_record); return UUID::fromData(cv_record);
Context not available.
info.SetMapped((entry->state != MemFree) ? yes : no); info.SetMapped((entry->state != MemFree) ? yes : no);
return info; return info;
} else if (head > load_addr && }
(next_entry == nullptr || head < next_entry->base_address)) { if (head > load_addr &&
(next_entry == nullptr || head < next_entry->base_address)) {
// In case there is no region containing load_addr keep track of the // In case there is no region containing load_addr keep track of the
// nearest region after load_addr so we can return the distance to it. // nearest region after load_addr so we can return the distance to it.
next_entry = entry; next_entry = entry;
Context not available.

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

Context not available.
PythonFile new_file(file, mode); PythonFile new_file(file, mode);
sys_module_dict.SetItemForKey(PythonString(py_name), new_file); sys_module_dict.SetItemForKey(PythonString(py_name), new_file);
return true; return true;
} else }
save_file.Reset(); save_file.Reset();
return false; return false;
} }
Context not available.
bp_options->SetCallback(ScriptInterpreterPython::BreakpointCallbackFunction, bp_options->SetCallback(ScriptInterpreterPython::BreakpointCallbackFunction,
baton_sp); baton_sp);
return error; return error;
} else }
return error; return error;
} }
// Set a Python one-liner as the callback for the watchpoint. // Set a Python one-liner as the callback for the watchpoint.
Context not available.
} }
if (should_step) if (should_step)
return lldb::eStateStepping; return lldb::eStateStepping;
else
return lldb::eStateRunning; return lldb::eStateRunning;
} }
StructuredData::GenericSP StructuredData::GenericSP
Context not available.
if (depth_as_int <= lldb::kLastSearchDepthKind) if (depth_as_int <= lldb::kLastSearchDepthKind)
return (lldb::SearchDepth) depth_as_int; return (lldb::SearchDepth) depth_as_int;
else
return lldb::eSearchDepthModule; return lldb::eSearchDepthModule;
} }
StructuredData::ObjectSP StructuredData::ObjectSP
Context not available.
if (result_ptr) if (result_ptr)
dest.assign(result_ptr); dest.assign(result_ptr);
return true; return true;
} else {
StreamString str_stream;
str_stream.Printf(
"Function %s was not found. Containing module might be missing.", item);
dest = str_stream.GetString();
return false;
} }
StreamString str_stream;
str_stream.Printf(
"Function %s was not found. Containing module might be missing.", item);
dest = str_stream.GetString();
return false;
} }
bool ScriptInterpreterPython::GetShortHelpForCommandObject( bool ScriptInterpreterPython::GetShortHelpForCommandObject(
Context not available.

source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

Context not available.
auto find_it = options_map.find(debugger_wp); auto find_it = options_map.find(debugger_wp);
if (find_it != options_map.end()) if (find_it != options_map.end())
return find_it->second; return find_it->second;
else
return EnableOptionsSP(); return EnableOptionsSP();
} }
void SetGlobalEnableOptions(const DebuggerSP &debugger_sp, void SetGlobalEnableOptions(const DebuggerSP &debugger_sp,
Context not available.
bool StructuredDataDarwinLog::GetEnabled(const ConstString &type_name) const { bool StructuredDataDarwinLog::GetEnabled(const ConstString &type_name) const {
if (type_name == GetStaticPluginName()) if (type_name == GetStaticPluginName())
return m_is_enabled; return m_is_enabled;
else
return false; return false;
} }
void StructuredDataDarwinLog::SetEnabled(bool enabled) { void StructuredDataDarwinLog::SetEnabled(bool enabled) {
Context not available.
llvm::Triple::VendorType::Apple) { llvm::Triple::VendorType::Apple) {
auto process_wp = ProcessWP(process.shared_from_this()); auto process_wp = ProcessWP(process.shared_from_this());
return StructuredDataPluginSP(new StructuredDataDarwinLog(process_wp)); return StructuredDataPluginSP(new StructuredDataDarwinLog(process_wp));
} else {
return StructuredDataPluginSP();
} }
return StructuredDataPluginSP();
} }
void StructuredDataDarwinLog::DebuggerInitialize(Debugger &debugger) { void StructuredDataDarwinLog::DebuggerInitialize(Debugger &debugger) {
Context not available.

source/Plugins/SymbolFile/DWARF/DIERef.cpp

Context not available.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
if (dwarf && die_offset != DW_INVALID_OFFSET) if (dwarf && die_offset != DW_INVALID_OFFSET)
return dwarf->GetID() | die_offset; return dwarf->GetID() | die_offset;
else
return LLDB_INVALID_UID; return LLDB_INVALID_UID;
} }
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

Context not available.
// overlap and must be at a higher bit offset than any previous bitfield // overlap and must be at a higher bit offset than any previous bitfield
// + size. // + size.
return (bit_size + bit_offset) <= next_bit_offset; return (bit_size + bit_offset) <= next_bit_offset;
} else {
// If the this BitfieldInfo is not valid, then any offset isOK
return true;
} }
// If the this BitfieldInfo is not valid, then any offset isOK
return true;
} }
}; };
Context not available.
if (IsSubroutine(candidate)) { if (IsSubroutine(candidate)) {
if (candidate.GetReferencedDIE(DW_AT_abstract_origin)) { if (candidate.GetReferencedDIE(DW_AT_abstract_origin)) {
return candidate; return candidate;
} else {
return DWARFDIE();
} }
return DWARFDIE();
} }
} }
assert(0 && "Shouldn't call GetContainingFunctionWithAbstractOrigin on " assert(0 && "Shouldn't call GetContainingFunctionWithAbstractOrigin on "
Context not available.
static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]); static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]);
if (namespace_decl) if (namespace_decl)
return namespace_decl; return namespace_decl;
else {
const char *namespace_name = die.GetName(); const char *namespace_name = die.GetName();
clang::DeclContext *containing_decl_ctx = clang::DeclContext *containing_decl_ctx =
GetClangDeclContextContainingDIE(die, nullptr); GetClangDeclContextContainingDIE(die, nullptr);
namespace_decl = m_ast.GetUniqueNamespaceDeclaration(namespace_name, namespace_decl = m_ast.GetUniqueNamespaceDeclaration(namespace_name,
containing_decl_ctx); containing_decl_ctx);
Log *log = Log *log = nullptr; // (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
nullptr; // (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO)); if (log) {
if (log) { SymbolFileDWARF *dwarf = die.GetDWARF();
SymbolFileDWARF *dwarf = die.GetDWARF(); if (namespace_name) {
if (namespace_name) { dwarf->GetObjectFile()->GetModule()->LogMessage(
dwarf->GetObjectFile()->GetModule()->LogMessage( log,
log, "ASTContext => %p: 0x%8.8" PRIx64 "ASTContext => %p: 0x%8.8" PRIx64
": DW_TAG_namespace with DW_AT_name(\"%s\") => " ": DW_TAG_namespace with DW_AT_name(\"%s\") => "
"clang::NamespaceDecl *%p (original = %p)", "clang::NamespaceDecl *%p (original = %p)",
static_cast<void *>(m_ast.getASTContext()), die.GetID(), static_cast<void *>(m_ast.getASTContext()), die.GetID(),
namespace_name, static_cast<void *>(namespace_decl), namespace_name, static_cast<void *>(namespace_decl),
static_cast<void *>(namespace_decl->getOriginalNamespace())); static_cast<void *>(namespace_decl->getOriginalNamespace()));
} else { } else {
dwarf->GetObjectFile()->GetModule()->LogMessage( dwarf->GetObjectFile()->GetModule()->LogMessage(
log, "ASTContext => %p: 0x%8.8" PRIx64 log,
": DW_TAG_namespace (anonymous) => clang::NamespaceDecl *%p " "ASTContext => %p: 0x%8.8" PRIx64
"(original = %p)", ": DW_TAG_namespace (anonymous) => clang::NamespaceDecl *%p "
static_cast<void *>(m_ast.getASTContext()), die.GetID(), "(original = %p)",
static_cast<void *>(namespace_decl), static_cast<void *>(m_ast.getASTContext()), die.GetID(),
static_cast<void *>(namespace_decl->getOriginalNamespace())); static_cast<void *>(namespace_decl),
} static_cast<void *>(namespace_decl->getOriginalNamespace()));
}
aprantlUnsubmitted
Not Done
ReplyInline Actions

what's going on here with the indentation?

aprantl: what's going on here with the indentation?
} }
if (namespace_decl) if (namespace_decl)
LinkDeclContextToDIE((clang::DeclContext *)namespace_decl, die); LinkDeclContextToDIE((clang::DeclContext *)namespace_decl, die);
return namespace_decl; return namespace_decl;
}
} }
return nullptr; return nullptr;
} }
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.cpp

Context not available.
} }
return m_tag != 0; return m_tag != 0;
} else {
m_tag = 0;
m_has_children = 0;
} }
m_tag = 0;
m_has_children = 0;
return false; return false;
} }
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp

Context not available.
dw_tag_t DWARFBaseDIE::Tag() const { dw_tag_t DWARFBaseDIE::Tag() const {
if (m_die) if (m_die)
return m_die->Tag(); return m_die->Tag();
else
return 0; return 0;
} }
const char *DWARFBaseDIE::GetTagAsCString() const { const char *DWARFBaseDIE::GetTagAsCString() const {
Context not available.
if (IsValid()) if (IsValid())
return m_die->GetAttributeValueAsString(GetDWARF(), GetCU(), attr, return m_die->GetAttributeValueAsString(GetDWARF(), GetCU(), attr,
fail_value); fail_value);
else
return fail_value; return fail_value;
} }
uint64_t DWARFBaseDIE::GetAttributeValueAsUnsigned(const dw_attr_t attr, uint64_t DWARFBaseDIE::GetAttributeValueAsUnsigned(const dw_attr_t attr,
Context not available.
if (IsValid()) if (IsValid())
return m_die->GetAttributeValueAsUnsigned(GetDWARF(), GetCU(), attr, return m_die->GetAttributeValueAsUnsigned(GetDWARF(), GetCU(), attr,
fail_value); fail_value);
else
return fail_value; return fail_value;
} }
int64_t DWARFBaseDIE::GetAttributeValueAsSigned(const dw_attr_t attr, int64_t DWARFBaseDIE::GetAttributeValueAsSigned(const dw_attr_t attr,
Context not available.
if (IsValid()) if (IsValid())
return m_die->GetAttributeValueAsSigned(GetDWARF(), GetCU(), attr, return m_die->GetAttributeValueAsSigned(GetDWARF(), GetCU(), attr,
fail_value); fail_value);
else
return fail_value; return fail_value;
} }
uint64_t DWARFBaseDIE::GetAttributeValueAsReference(const dw_attr_t attr, uint64_t DWARFBaseDIE::GetAttributeValueAsReference(const dw_attr_t attr,
Context not available.
if (IsValid()) if (IsValid())
return m_die->GetAttributeValueAsReference(GetDWARF(), GetCU(), attr, return m_die->GetAttributeValueAsReference(GetDWARF(), GetCU(), attr,
fail_value); fail_value);
else
return fail_value; return fail_value;
} }
uint64_t DWARFBaseDIE::GetAttributeValueAsAddress(const dw_attr_t attr, uint64_t DWARFBaseDIE::GetAttributeValueAsAddress(const dw_attr_t attr,
Context not available.
if (IsValid()) if (IsValid())
return m_die->GetAttributeValueAsAddress(GetDWARF(), GetCU(), attr, return m_die->GetAttributeValueAsAddress(GetDWARF(), GetCU(), attr,
fail_value); fail_value);
else
return fail_value; return fail_value;
} }
lldb::user_id_t DWARFBaseDIE::GetID() const { lldb::user_id_t DWARFBaseDIE::GetID() const {
Context not available.
const char *DWARFBaseDIE::GetName() const { const char *DWARFBaseDIE::GetName() const {
if (IsValid()) if (IsValid())
return m_die->GetName(GetDWARF(), m_cu); return m_die->GetName(GetDWARF(), m_cu);
else
return nullptr; return nullptr;
} }
lldb::LanguageType DWARFBaseDIE::GetLanguage() const { lldb::LanguageType DWARFBaseDIE::GetLanguage() const {
if (IsValid()) if (IsValid())
return m_cu->GetLanguageType(); return m_cu->GetLanguageType();
else
return lldb::eLanguageTypeUnknown; return lldb::eLanguageTypeUnknown;
} }
lldb::ModuleSP DWARFBaseDIE::GetModule() const { lldb::ModuleSP DWARFBaseDIE::GetModule() const {
SymbolFileDWARF *dwarf = GetDWARF(); SymbolFileDWARF *dwarf = GetDWARF();
if (dwarf) if (dwarf)
return dwarf->GetObjectFile()->GetModule(); return dwarf->GetObjectFile()->GetModule();
else
return lldb::ModuleSP(); return lldb::ModuleSP();
} }
lldb_private::CompileUnit *DWARFBaseDIE::GetLLDBCompileUnit() const { lldb_private::CompileUnit *DWARFBaseDIE::GetLLDBCompileUnit() const {
if (IsValid()) if (IsValid())
return GetDWARF()->GetCompUnitForDWARFCompUnit(GetCU()); return GetDWARF()->GetCompUnitForDWARFCompUnit(GetCU());
else
return nullptr; return nullptr;
} }
dw_offset_t DWARFBaseDIE::GetOffset() const { dw_offset_t DWARFBaseDIE::GetOffset() const {
if (IsValid()) if (IsValid())
return m_die->GetOffset(); return m_die->GetOffset();
else
return DW_INVALID_OFFSET; return DW_INVALID_OFFSET;
} }
dw_offset_t DWARFBaseDIE::GetCompileUnitRelativeOffset() const { dw_offset_t DWARFBaseDIE::GetCompileUnitRelativeOffset() const {
if (IsValid()) if (IsValid())
return m_die->GetOffset() - m_cu->GetOffset(); return m_die->GetOffset() - m_cu->GetOffset();
else
return DW_INVALID_OFFSET; return DW_INVALID_OFFSET;
} }
SymbolFileDWARF *DWARFBaseDIE::GetDWARF() const { SymbolFileDWARF *DWARFBaseDIE::GetDWARF() const {
if (m_cu) if (m_cu)
return m_cu->GetSymbolFileDWARF(); return m_cu->GetSymbolFileDWARF();
else
return nullptr; return nullptr;
} }
lldb_private::TypeSystem *DWARFBaseDIE::GetTypeSystem() const { lldb_private::TypeSystem *DWARFBaseDIE::GetTypeSystem() const {
if (m_cu) if (m_cu)
return m_cu->GetTypeSystem(); return m_cu->GetTypeSystem();
else
return nullptr; return nullptr;
} }
DWARFASTParser *DWARFBaseDIE::GetDWARFParser() const { DWARFASTParser *DWARFBaseDIE::GetDWARFParser() const {
lldb_private::TypeSystem *type_system = GetTypeSystem(); lldb_private::TypeSystem *type_system = GetTypeSystem();
if (type_system) if (type_system)
return type_system->GetDWARFParser(); return type_system->GetDWARFParser();
else
return nullptr; return nullptr;
} }
bool DWARFBaseDIE::HasChildren() const { bool DWARFBaseDIE::HasChildren() const {
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

Context not available.
DWARFDIE::GetParent() const { DWARFDIE::GetParent() const {
if (IsValid()) if (IsValid())
return DWARFDIE(m_cu, m_die->GetParent()); return DWARFDIE(m_cu, m_die->GetParent());
else
return DWARFDIE(); return DWARFDIE();
} }
DWARFDIE DWARFDIE
DWARFDIE::GetFirstChild() const { DWARFDIE::GetFirstChild() const {
if (IsValid()) if (IsValid())
return DWARFDIE(m_cu, m_die->GetFirstChild()); return DWARFDIE(m_cu, m_die->GetFirstChild());
else
return DWARFDIE(); return DWARFDIE();
} }
DWARFDIE DWARFDIE
DWARFDIE::GetSibling() const { DWARFDIE::GetSibling() const {
if (IsValid()) if (IsValid())
return DWARFDIE(m_cu, m_die->GetSibling()); return DWARFDIE(m_cu, m_die->GetSibling());
else
return DWARFDIE(); return DWARFDIE();
} }
DWARFDIE DWARFDIE
Context not available.
GetAttributeValueAsReference(attr, DW_INVALID_OFFSET); GetAttributeValueAsReference(attr, DW_INVALID_OFFSET);
if (die_offset != DW_INVALID_OFFSET) if (die_offset != DW_INVALID_OFFSET)
return GetDIE(die_offset); return GetDIE(die_offset);
else
return DWARFDIE(); return DWARFDIE();
} }
DWARFDIE DWARFDIE
DWARFDIE::GetDIE(dw_offset_t die_offset) const { DWARFDIE::GetDIE(dw_offset_t die_offset) const {
if (IsValid()) if (IsValid())
return m_cu->GetDIE(die_offset); return m_cu->GetDIE(die_offset);
else
return DWARFDIE(); return DWARFDIE();
} }
DWARFDIE DWARFDIE
Context not available.
if (block_die && block_die != function_die) { if (block_die && block_die != function_die) {
if (cu->ContainsDIEOffset(block_die->GetOffset())) if (cu->ContainsDIEOffset(block_die->GetOffset()))
return DWARFDIE(cu, block_die); return DWARFDIE(cu, block_die);
else
return DWARFDIE(dwarf->DebugInfo()->GetCompileUnit( return DWARFDIE(dwarf->DebugInfo()->GetCompileUnit(
DIERef(cu->GetOffset(), block_die->GetOffset())), DIERef(cu->GetOffset(), block_die->GetOffset())),
block_die); block_die);
} }
} }
} }
Context not available.
const char *DWARFDIE::GetMangledName() const { const char *DWARFDIE::GetMangledName() const {
if (IsValid()) if (IsValid())
return m_die->GetMangledName(GetDWARF(), m_cu); return m_die->GetMangledName(GetDWARF(), m_cu);
else
return nullptr; return nullptr;
} }
const char *DWARFDIE::GetPubname() const { const char *DWARFDIE::GetPubname() const {
if (IsValid()) if (IsValid())
return m_die->GetPubname(GetDWARF(), m_cu); return m_die->GetPubname(GetDWARF(), m_cu);
else
return nullptr; return nullptr;
} }
const char *DWARFDIE::GetQualifiedName(std::string &storage) const { const char *DWARFDIE::GetQualifiedName(std::string &storage) const {
if (IsValid()) if (IsValid())
return m_die->GetQualifiedName(GetDWARF(), m_cu, storage); return m_die->GetQualifiedName(GetDWARF(), m_cu, storage);
else
return nullptr; return nullptr;
} }
lldb_private::Type *DWARFDIE::ResolveType() const { lldb_private::Type *DWARFDIE::ResolveType() const {
if (IsValid()) if (IsValid())
return GetDWARF()->ResolveType(*this, true); return GetDWARF()->ResolveType(*this, true);
else
return nullptr; return nullptr;
} }
lldb_private::Type *DWARFDIE::ResolveTypeUID(const DIERef &die_ref) const { lldb_private::Type *DWARFDIE::ResolveTypeUID(const DIERef &die_ref) const {
SymbolFileDWARF *dwarf = GetDWARF(); SymbolFileDWARF *dwarf = GetDWARF();
if (dwarf) if (dwarf)
return dwarf->ResolveTypeUID(dwarf->GetDIE(die_ref), true); return dwarf->ResolveTypeUID(dwarf->GetDIE(die_ref), true);
else
return nullptr; return nullptr;
} }
void DWARFDIE::GetDeclContextDIEs(DWARFDIECollection &decl_context_dies) const { void DWARFDIE::GetDeclContextDIEs(DWARFDIECollection &decl_context_dies) const {
Context not available.
DWARFDIE::GetParentDeclContextDIE() const { DWARFDIE::GetParentDeclContextDIE() const {
if (IsValid()) if (IsValid())
return m_die->GetParentDeclContextDIE(GetDWARF(), m_cu); return m_die->GetParentDeclContextDIE(GetDWARF(), m_cu);
else
return DWARFDIE(); return DWARFDIE();
} }
bool DWARFDIE::IsStructUnionOrClass() const { bool DWARFDIE::IsStructUnionOrClass() const {
Context not available.
return m_die->GetDIENamesAndRanges( return m_die->GetDIENamesAndRanges(
GetDWARF(), GetCU(), name, mangled, ranges, decl_file, decl_line, GetDWARF(), GetCU(), name, mangled, ranges, decl_file, decl_line,
decl_column, call_file, call_line, call_column, frame_base); decl_column, call_file, call_line, call_column, frame_base);
} else }
return false; return false;
} }
CompilerDecl DWARFDIE::GetDecl() const { CompilerDecl DWARFDIE::GetDecl() const {
DWARFASTParser *dwarf_ast = GetDWARFParser(); DWARFASTParser *dwarf_ast = GetDWARFParser();
if (dwarf_ast) if (dwarf_ast)
return dwarf_ast->GetDeclForUIDFromDWARF(*this); return dwarf_ast->GetDeclForUIDFromDWARF(*this);
else
return CompilerDecl(); return CompilerDecl();
} }
CompilerDeclContext DWARFDIE::GetDeclContext() const { CompilerDeclContext DWARFDIE::GetDeclContext() const {
DWARFASTParser *dwarf_ast = GetDWARFParser(); DWARFASTParser *dwarf_ast = GetDWARFParser();
if (dwarf_ast) if (dwarf_ast)
return dwarf_ast->GetDeclContextForUIDFromDWARF(*this); return dwarf_ast->GetDeclContextForUIDFromDWARF(*this);
else
return CompilerDeclContext(); return CompilerDeclContext();
} }
CompilerDeclContext DWARFDIE::GetContainingDeclContext() const { CompilerDeclContext DWARFDIE::GetContainingDeclContext() const {
DWARFASTParser *dwarf_ast = GetDWARFParser(); DWARFASTParser *dwarf_ast = GetDWARFParser();
if (dwarf_ast) if (dwarf_ast)
return dwarf_ast->GetDeclContextContainingUIDFromDWARF(*this); return dwarf_ast->GetDeclContextContainingUIDFromDWARF(*this);
else
return CompilerDeclContext(); return CompilerDeclContext();
} }
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFDebugAbbrev.cpp

Context not available.
if (m_prev_abbr_offset_pos != end && if (m_prev_abbr_offset_pos != end &&
m_prev_abbr_offset_pos->first == cu_abbr_offset) m_prev_abbr_offset_pos->first == cu_abbr_offset)
return &(m_prev_abbr_offset_pos->second); return &(m_prev_abbr_offset_pos->second);
else {
pos = m_abbrevCollMap.find(cu_abbr_offset); pos = m_abbrevCollMap.find(cu_abbr_offset);
m_prev_abbr_offset_pos = pos; m_prev_abbr_offset_pos = pos;
}
if (pos != m_abbrevCollMap.end()) if (pos != m_abbrevCollMap.end())
return &(pos->second); return &(pos->second);
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

Context not available.
DWARFUnit *DWARFDebugInfo::GetCompileUnit(const DIERef &die_ref) { DWARFUnit *DWARFDebugInfo::GetCompileUnit(const DIERef &die_ref) {
if (die_ref.cu_offset == DW_INVALID_OFFSET) if (die_ref.cu_offset == DW_INVALID_OFFSET)
return GetCompileUnitContainingDIEOffset(die_ref.die_offset); return GetCompileUnitContainingDIEOffset(die_ref.die_offset);
else
return GetCompileUnit(die_ref.cu_offset); return GetCompileUnit(die_ref.cu_offset);
} }
DWARFUnit * DWARFUnit *
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

Context not available.
} }
*offset_ptr = offset; *offset_ptr = offset;
return true; return true;
} else {
m_tag = 0;
m_has_children = false;
return true; // NULL debug tag entry
} }
m_tag = 0;
m_has_children = false;
return true; // NULL debug tag entry
return false; return false;
} }
Context not available.
if (die.IsNULL()) { if (die.IsNULL()) {
s.PutCString("NULL"); s.PutCString("NULL");
return true; return true;
} else {
const char *name = die.GetAttributeValueAsString(
dwarf2Data, cu, DW_AT_name, nullptr, true);
if (name) {
s.PutCString(name);
return true;
}
} }
const char *name = die.GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name,
nullptr, true);
if (name) {
s.PutCString(name);
return true;
}
} }
return false; return false;
} }
Context not available.
if (die.IsNULL()) { if (die.IsNULL()) {
s.PutCString("NULL"); s.PutCString("NULL");
return true; return true;
} else { }
const char *name = die.GetPubname(dwarf2Data, cu); const char *name = die.GetPubname(dwarf2Data, cu);
if (name) if (name)
s.PutCString(name); s.PutCString(name);
else { else {
bool result = true; bool result = true;
const DWARFAbbreviationDeclaration *abbrevDecl = const DWARFAbbreviationDeclaration *abbrevDecl =
die.GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset); die.GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
if (abbrevDecl == NULL)
return false;
switch (abbrevDecl->Tag()) {
case DW_TAG_array_type:
break; // print out a "[]" after printing the full type of the element
// below
case DW_TAG_base_type:
s.PutCString("base ");
break;
case DW_TAG_class_type:
s.PutCString("class ");
break;
case DW_TAG_const_type:
s.PutCString("const ");
break;
case DW_TAG_enumeration_type:
s.PutCString("enum ");
break;
case DW_TAG_file_type:
s.PutCString("file ");
break;
case DW_TAG_interface_type:
s.PutCString("interface ");
break;
case DW_TAG_packed_type:
s.PutCString("packed ");
break;
case DW_TAG_pointer_type:
break; // print out a '*' after printing the full type below
case DW_TAG_ptr_to_member_type:
break; // print out a '*' after printing the full type below
case DW_TAG_reference_type:
break; // print out a '&' after printing the full type below
case DW_TAG_restrict_type:
s.PutCString("restrict ");
break;
case DW_TAG_set_type:
s.PutCString("set ");
break;
case DW_TAG_shared_type:
s.PutCString("shared ");
break;
case DW_TAG_string_type:
s.PutCString("string ");
break;
case DW_TAG_structure_type:
s.PutCString("struct ");
break;
case DW_TAG_subrange_type:
s.PutCString("subrange ");
break;
case DW_TAG_subroutine_type:
s.PutCString("function ");
break;
case DW_TAG_thrown_type:
s.PutCString("thrown ");
break;
case DW_TAG_union_type:
s.PutCString("union ");
break;
case DW_TAG_unspecified_type:
s.PutCString("unspecified ");
break;
case DW_TAG_volatile_type:
s.PutCString("volatile ");
break;
default:
return false;
}
// Follow the DW_AT_type if possible if (abbrevDecl == NULL)
DWARFFormValue form_value; return false;
if (die.GetAttributeValue(dwarf2Data, cu, DW_AT_type, form_value)) {
uint64_t next_die_offset = form_value.Reference();
result = AppendTypeName(dwarf2Data, cu, next_die_offset, s);
}
switch (abbrevDecl->Tag()) { switch (abbrevDecl->Tag()) {
case DW_TAG_array_type: case DW_TAG_array_type:
s.PutCString("[]"); break; // print out a "[]" after printing the full type of the element
break; // below
case DW_TAG_pointer_type: case DW_TAG_base_type:
s.PutChar('*'); s.PutCString("base ");
break; break;
case DW_TAG_ptr_to_member_type: case DW_TAG_class_type:
s.PutChar('*'); s.PutCString("class ");
break; break;
case DW_TAG_reference_type: case DW_TAG_const_type:
s.PutChar('&'); s.PutCString("const ");
break; break;
default: case DW_TAG_enumeration_type:
break; s.PutCString("enum ");
} break;
return result; case DW_TAG_file_type:
s.PutCString("file ");
break;
case DW_TAG_interface_type:
s.PutCString("interface ");
break;
case DW_TAG_packed_type:
s.PutCString("packed ");
break;
case DW_TAG_pointer_type:
break; // print out a '*' after printing the full type below
case DW_TAG_ptr_to_member_type:
break; // print out a '*' after printing the full type below
case DW_TAG_reference_type:
break; // print out a '&' after printing the full type below
case DW_TAG_restrict_type:
s.PutCString("restrict ");
break;
case DW_TAG_set_type:
s.PutCString("set ");
break;
case DW_TAG_shared_type:
s.PutCString("shared ");
break;
case DW_TAG_string_type:
s.PutCString("string ");
break;
case DW_TAG_structure_type:
s.PutCString("struct ");
break;
case DW_TAG_subrange_type:
s.PutCString("subrange ");
break;
case DW_TAG_subroutine_type:
s.PutCString("function ");
break;
case DW_TAG_thrown_type:
s.PutCString("thrown ");
break;
case DW_TAG_union_type:
s.PutCString("union ");
break;
case DW_TAG_unspecified_type:
s.PutCString("unspecified ");
break;
case DW_TAG_volatile_type:
s.PutCString("volatile ");
break;
default:
return false;
}
// Follow the DW_AT_type if possible
DWARFFormValue form_value;
if (die.GetAttributeValue(dwarf2Data, cu, DW_AT_type, form_value)) {
uint64_t next_die_offset = form_value.Reference();
result = AppendTypeName(dwarf2Data, cu, next_die_offset, s);
}
switch (abbrevDecl->Tag()) {
case DW_TAG_array_type:
s.PutCString("[]");
break;
case DW_TAG_pointer_type:
s.PutChar('*');
break;
case DW_TAG_ptr_to_member_type:
s.PutChar('*');
break;
case DW_TAG_reference_type:
s.PutChar('&');
break;
default:
break;
}
return result;
} }
}
} }
return false; return false;
} }
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

Context not available.
if (ParseStatementTable(debug_line_data, &offset, DumpStateToFile, log, nullptr)) if (ParseStatementTable(debug_line_data, &offset, DumpStateToFile, log, nullptr))
return offset; return offset;
else
return debug_line_offset + 1; // Skip to next byte in .debug_line section return debug_line_offset + 1; // Skip to next byte in .debug_line section
} }
return DW_INVALID_OFFSET; return DW_INVALID_OFFSET;
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFDebugMacinfoEntry.cpp

Context not available.
break; break;
} }
return true; return true;
} else }
m_type_code = 0; m_type_code = 0;
return false; return false;
} }
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp

Context not available.
if (begin == 0 && end == 0) { if (begin == 0 && end == 0) {
s.PutCString(" End"); s.PutCString(" End");
break; break;
} else if (begin == LLDB_INVALID_ADDRESS) { }
if (begin == LLDB_INVALID_ADDRESS) {
// A base address selection entry // A base address selection entry
base_addr = end; base_addr = end;
s.Address(base_addr, sizeof(dw_addr_t), " Base address = "); s.Address(base_addr, sizeof(dw_addr_t), " Base address = ");
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFDeclContext.h

Context not available.
bool NameMatches(const Entry &rhs) const { bool NameMatches(const Entry &rhs) const {
if (name == rhs.name) if (name == rhs.name)
return true; return true;
else if (name && rhs.name) if (name && rhs.name)
return strcmp(name, rhs.name) == 0; return strcmp(name, rhs.name) == 0;
return false; return false;
} }
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

Context not available.
if (m_form == DW_FORM_string) { if (m_form == DW_FORM_string) {
return m_value.value.cstr; return m_value.value.cstr;
} else if (m_form == DW_FORM_strp) { }
if (m_form == DW_FORM_strp) {
if (!symbol_file) if (!symbol_file)
return nullptr; return nullptr;
Context not available.
const char *b_string = b_value.AsCString(); const char *b_string = b_value.AsCString();
if (a_string == b_string) if (a_string == b_string)
return 0; return 0;
else if (a_string && b_string) if (a_string && b_string)
return strcmp(a_string, b_string); return strcmp(a_string, b_string);
else if (a_string == NULL) else if (a_string == NULL)
return -1; // A string is NULL, and B is valid return -1; // A string is NULL, and B is valid
Context not available.

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

Context not available.
m_base_obj_offset != DW_INVALID_OFFSET ? m_base_obj_offset : m_offset; m_base_obj_offset != DW_INVALID_OFFSET ? m_base_obj_offset : m_offset;
if (m_dwarf) if (m_dwarf)
return DIERef(local_id, local_id).GetUID(m_dwarf); return DIERef(local_id, local_id).GetUID(m_dwarf);
else
return local_id; return local_id;
} }
dw_offset_t DWARFUnit::GetNextCompileUnitOffset() const { dw_offset_t DWARFUnit::GetNextCompileUnitOffset() const {
Context not available.
TypeSystem *DWARFUnit::GetTypeSystem() { TypeSystem *DWARFUnit::GetTypeSystem() {
if (m_dwarf) if (m_dwarf)
return m_dwarf->GetTypeSystemForLanguage(GetLanguageType()); return m_dwarf->GetTypeSystemForLanguage(GetLanguageType());
else
return nullptr; return nullptr;
} }
DWARFFormValue::FixedFormSizes DWARFUnit::GetFixedFormSizes() { DWARFFormValue::FixedFormSizes DWARFUnit::GetFixedFormSizes() {
Context not available.
if (major_version > 425 || if (major_version > 425 ||
(major_version == 425 && GetProducerVersionUpdate() >= 13)) (major_version == 425 && GetProducerVersionUpdate() >= 13))
return true; return true;
else
return false; 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/DebugNamesDWARFIndex.cpp

Context not available.
// If we find the complete version we're done. // If we find the complete version we're done.
offsets.push_back(ref); offsets.push_back(ref);
return; return;
} else {
incomplete_types.push_back(ref);
} }
incomplete_types.push_back(ref);
} }
offsets.insert(offsets.end(), incomplete_types.begin(), offsets.insert(offsets.end(), incomplete_types.begin(),
Context not available.

source/Plugins/SymbolFile/DWARF/HashedNameToDIE.cpp

Context not available.
die_offsets.emplace_back(die_info_array[i].cu_offset, die_offsets.emplace_back(die_info_array[i].cu_offset,
die_info_array[i].offset); die_info_array[i].offset);
return; return;
} else {
// Put the one true definition as the first entry so it matches first
die_offsets.emplace(die_offsets.begin(), die_info_array[i].cu_offset,
die_info_array[i].offset);
} }
// Put the one true definition as the first entry so it matches first
die_offsets.emplace(die_offsets.begin(), die_info_array[i].cu_offset,
die_info_array[i].offset);
} else { } else {
die_offsets.emplace_back(die_info_array[i].cu_offset, die_offsets.emplace_back(die_info_array[i].cu_offset,
die_info_array[i].offset); die_info_array[i].offset);
Context not available.
if (match) if (match)
return eResultKeyMatch; // The key (cstring) matches and we have lookup return eResultKeyMatch; // The key (cstring) matches and we have lookup
// results! // results!
else
return eResultKeyMismatch; // The key doesn't match, this function will return eResultKeyMismatch; // The key doesn't match, this function will
// get called // get called
// again for the next key/value or the key terminator which in our case is // again for the next key/value or the key terminator which in our case is
// a zero .debug_str offset. // a zero .debug_str offset.
} else { } else {
Context not available.
if (match) if (match)
return eResultKeyMatch; // The key (cstring) matches and we have lookup return eResultKeyMatch; // The key (cstring) matches and we have lookup
// results! // results!
else
return eResultKeyMismatch; // The key doesn't match, this function will return eResultKeyMismatch; // The key doesn't match, this function will
// get called // get called
// again for the next key/value or the key terminator which in our case is // again for the next key/value or the key terminator which in our case is
// a zero .debug_str offset. // a zero .debug_str offset.
} else { } else {
Context not available.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Context not available.
SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
if (debug_map_symfile) if (debug_map_symfile)
return debug_map_symfile->GetTypeList(); return debug_map_symfile->GetTypeList();
else
return m_obj_file->GetModule()->GetTypeList(); return m_obj_file->GetModule()->GetTypeList();
} }
void SymbolFileDWARF::GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset, void SymbolFileDWARF::GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
dw_offset_t max_die_offset, uint32_t type_mask, dw_offset_t max_die_offset, uint32_t type_mask,
Context not available.
SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
if (debug_map_symfile) if (debug_map_symfile)
return debug_map_symfile->GetUniqueDWARFASTTypeMap(); return debug_map_symfile->GetUniqueDWARFASTTypeMap();
else
return m_unique_ast_type_map; return m_unique_ast_type_map;
} }
TypeSystem *SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) { TypeSystem *SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
Context not available.
if (dwarf_cu->GetSymbolFileDWARF() != this) { if (dwarf_cu->GetSymbolFileDWARF() != this) {
return dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(dwarf_cu, return dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(dwarf_cu,
cu_idx); cu_idx);
} else if (dwarf_cu->GetOffset() == 0 && GetDebugMapSymfile()) { }
if (dwarf_cu->GetOffset() == 0 && GetDebugMapSymfile()) {
// Let the debug map create the compile unit // Let the debug map create the compile unit
cu_sp = m_debug_map_symfile->GetCompileUnit(this); cu_sp = m_debug_map_symfile->GetCompileUnit(this);
dwarf_cu->SetUserData(cu_sp.get()); dwarf_cu->SetUserData(cu_sp.get());
Context not available.
DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit); DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu) if (dwarf_cu)
return dwarf_cu->GetLanguageType(); return dwarf_cu->GetLanguageType();
else
return eLanguageTypeUnknown; return eLanguageTypeUnknown;
} }
size_t SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc) { size_t SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc) {
Context not available.
DWARFDIE type_die = GetDIEFromUID(type_uid); DWARFDIE type_die = GetDIEFromUID(type_uid);
if (type_die) if (type_die)
return type_die.ResolveType(); return type_die.ResolveType();
else
return nullptr; return nullptr;
} }
llvm::Optional<SymbolFile::ArrayInfo> llvm::Optional<SymbolFile::ArrayInfo>
Context not available.
DWARFDIE type_die = GetDIEFromUID(type_uid); DWARFDIE type_die = GetDIEFromUID(type_uid);
if (type_die) if (type_die)
return DWARFASTParser::ParseChildArrayInfo(type_die, exe_ctx); return DWARFASTParser::ParseChildArrayInfo(type_die, exe_ctx);
else
return llvm::None; return llvm::None;
} }
Type *SymbolFileDWARF::ResolveTypeUID(const DIERef &die_ref) { Type *SymbolFileDWARF::ResolveTypeUID(const DIERef &die_ref) {
Context not available.
const auto &pos = m_external_type_modules.find(name); const auto &pos = m_external_type_modules.find(name);
if (pos != m_external_type_modules.end()) if (pos != m_external_type_modules.end())
return pos->second; return pos->second;
else
return lldb::ModuleSP(); return lldb::ModuleSP();
} }
DWARFDIE DWARFDIE
Context not available.
DWARFDebugInfo *debug_info = DebugInfo(); DWARFDebugInfo *debug_info = DebugInfo();
if (debug_info) if (debug_info)
return debug_info->GetDIE(die_ref); return debug_info->GetDIE(die_ref);
else
return DWARFDIE(); return DWARFDIE();
} }
std::unique_ptr<SymbolFileDWARFDwo> std::unique_ptr<SymbolFileDWARFDwo>
Context not available.
// Make sure we haven't already searched this SymbolFile before... // Make sure we haven't already searched this SymbolFile before...
if (searched_symbol_files.count(this)) if (searched_symbol_files.count(this))
return 0; return 0;
else
searched_symbol_files.insert(this); searched_symbol_files.insert(this);
DWARFDebugInfo *info = DebugInfo(); DWARFDebugInfo *info = DebugInfo();
if (info == NULL) if (info == NULL)
Context not available.
} }
} }
return num_matches; return num_matches;
} else { }
UpdateExternalModuleListIfNeeded(); UpdateExternalModuleListIfNeeded();
for (const auto &pair : m_external_type_modules) { for (const auto &pair : m_external_type_modules) {
ModuleSP external_module_sp = pair.second; ModuleSP external_module_sp = pair.second;
if (external_module_sp) { if (external_module_sp) {
SymbolVendor *sym_vendor = external_module_sp->GetSymbolVendor(); SymbolVendor *sym_vendor = external_module_sp->GetSymbolVendor();
if (sym_vendor) { if (sym_vendor) {
const uint32_t num_external_matches = const uint32_t num_external_matches =
sym_vendor->FindTypes(sc, name, parent_decl_ctx, append, sym_vendor->FindTypes(sc, name, parent_decl_ctx, append,
max_matches, searched_symbol_files, types); max_matches, searched_symbol_files, types);
if (num_external_matches) if (num_external_matches)
return num_external_matches; return num_external_matches;
}
} }
} }
} }
return 0; return 0;
} }
Context not available.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

Context not available.
searched_symbol_files, types); searched_symbol_files, types);
if (types.GetSize() >= max_matches) if (types.GetSize() >= max_matches)
return true; return true;
else
return false; return false;
}); });
} }
Context not available.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

Context not available.
// Only dwo files with 1 compile unit is supported // Only dwo files with 1 compile unit is supported
if (GetNumCompileUnits() == 1) if (GetNumCompileUnits() == 1)
return DebugInfo()->GetCompileUnitAtIndex(0); return DebugInfo()->GetCompileUnitAtIndex(0);
else
return nullptr; return nullptr;
} }
DWARFUnit * DWARFUnit *
Context not available.

source/Symbol/ArmUnwindInfo.cpp

Context not available.
// 10000000 00000000 // 10000000 00000000
// Refuse to unwind (for example, out of a cleanup) (see remark a) // Refuse to unwind (for example, out of a cleanup) (see remark a)
return false; return false;
} else {
// 1000iiii iiiiiiii (i not all 0)
// Pop up to 12 integer registers under masks {r15-r12}, {r11-r4} (see
// remark b)
uint16_t regs = ((byte1 & 0x0f) << 8) | byte2;
for (uint8_t i = 0; i < 12; ++i) {
if (regs & (1 << i)) {
register_offsets.emplace_back(dwarf_r4 + i, vsp);
vsp += 4;
}
}
} }
// 1000iiii iiiiiiii (i not all 0)
// Pop up to 12 integer registers under masks {r15-r12}, {r11-r4} (see
// remark b)
uint16_t regs = ((byte1 & 0x0f) << 8) | byte2;
for (uint8_t i = 0; i < 12; ++i) {
if (regs & (1 << i)) {
register_offsets.emplace_back(dwarf_r4 + i, vsp);
vsp += 4;
}
}
} else if ((byte1 & 0xff) == 0x9d) { } else if ((byte1 & 0xff) == 0x9d) {
// 10011101 // 10011101
// Reserved as prefix for ARM register to register moves // Reserved as prefix for ARM register to register moves
Context not available.
// 10110001 00000000 // 10110001 00000000
// Spare (see remark f) // Spare (see remark f)
return false; return false;
} else if ((byte2 & 0xf0) == 0x00) { }
if ((byte2 & 0xf0) == 0x00) {
// 10110001 0000iiii (i not all 0) // 10110001 0000iiii (i not all 0)
// Pop integer registers under mask {r3, r2, r1, r0} // Pop integer registers under mask {r3, r2, r1, r0}
for (uint8_t i = 0; i < 4; ++i) { for (uint8_t i = 0; i < 4; ++i) {
Context not available.

source/Symbol/Block.cpp

Context not available.
if (parent_block) { if (parent_block) {
if (parent_block->GetInlinedFunctionInfo()) if (parent_block->GetInlinedFunctionInfo())
return parent_block; return parent_block;
else
return parent_block->GetInlinedParent(); return parent_block->GetInlinedParent();
} }
return nullptr; return nullptr;
} }
Context not available.

source/Symbol/ClangASTContext.cpp

Context not available.
if (baseDtorDecl->isVirtual()) { if (baseDtorDecl->isVirtual()) {
path.Decls = baseDtorDecl; path.Decls = baseDtorDecl;
return true; return true;
} else }
return false; return false;
} }
// Otherwise, search for name in the base class. // Otherwise, search for name in the base class.
Context not available.
ast_sp->SetArchitecture(fixed_arch); ast_sp->SetArchitecture(fixed_arch);
} }
return ast_sp; return ast_sp;
} else if (target && target->IsValid()) { }
if (target && target->IsValid()) {
std::shared_ptr<ClangASTContextForExpressions> ast_sp( std::shared_ptr<ClangASTContextForExpressions> ast_sp(
new ClangASTContextForExpressions(*target)); new ClangASTContextForExpressions(*target));
if (ast_sp) { if (ast_sp) {
Context not available.
if (type_name) { if (type_name) {
if (streq(type_name, "char16_t")) { if (streq(type_name, "char16_t")) {
return CompilerType(ast, ast->Char16Ty); return CompilerType(ast, ast->Char16Ty);
} else if (streq(type_name, "char32_t")) { }
if (streq(type_name, "char32_t")) {
return CompilerType(ast, ast->Char32Ty); return CompilerType(ast, ast->Char32Ty);
} }
} }
Context not available.
return unary; return unary;
if (num_params == 2) if (num_params == 2)
return binary; return binary;
else
return false; return false;
} }
bool ClangASTContext::CheckOverloadedOperatorKindParameterCount( bool ClangASTContext::CheckOverloadedOperatorKindParameterCount(
Context not available.
return CompilerType( return CompilerType(
ast, ast->getExtVectorType(ClangUtil::GetQualType(element_type), ast, ast->getExtVectorType(ClangUtil::GetQualType(element_type),
element_count)); element_count));
} else { }
llvm::APInt ap_element_count(64, element_count); llvm::APInt ap_element_count(64, element_count);
if (element_count == 0) { if (element_count == 0) {
return CompilerType(ast, ast->getIncompleteArrayType( return CompilerType(ast, ast->getIncompleteArrayType(
ClangUtil::GetQualType(element_type), ClangUtil::GetQualType(element_type),
clang::ArrayType::Normal, 0)); clang::ArrayType::Normal, 0));
} else {
return CompilerType(
ast, ast->getConstantArrayType(ClangUtil::GetQualType(element_type),
ap_element_count,
clang::ArrayType::Normal, 0));
} }
} return CompilerType(
ast, ast->getConstantArrayType(ClangUtil::GetQualType(element_type),
ap_element_count,
clang::ArrayType::Normal, 0));
} }
return CompilerType(); return CompilerType();
} }
Context not available.
ast_source->CompleteType(tag_decl); ast_source->CompleteType(tag_decl);
return !tag_decl->getTypeForDecl()->isIncompleteType(); return !tag_decl->getTypeForDecl()->isIncompleteType();
} else if (clang::ObjCInterfaceDecl *objc_interface_decl = }
llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) { if (clang::ObjCInterfaceDecl *objc_interface_decl =
llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) {
if (objc_interface_decl->getDefinition()) if (objc_interface_decl->getDefinition())
return true; return true;
Context not available.
if (external_source && external_source->HasMetadata(object)) if (external_source && external_source->HasMetadata(object))
return external_source->GetMetadata(object); return external_source->GetMetadata(object);
else
return nullptr; return nullptr;
} }
clang::DeclContext * clang::DeclContext *
Context not available.
if (field_qual_type->isFloatingType()) { if (field_qual_type->isFloatingType()) {
if (field_qual_type->isComplexType()) if (field_qual_type->isComplexType())
return 0; return 0;
if (num_fields == 0)
base_qual_type = field_qual_type;
else { else {
if (num_fields == 0) if (is_hva)
base_qual_type = field_qual_type; return 0;
else { is_hfa = true;
if (is_hva) if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
return 0; return 0;
is_hfa = true;
if (field_qual_type.getTypePtr() !=
base_qual_type.getTypePtr())
return 0;
} }
}
} else if (field_qual_type->isVectorType() || } else if (field_qual_type->isVectorType() ||
field_qual_type->isExtVectorType()) { field_qual_type->isExtVectorType()) {
if (num_fields == 0) { if (num_fields == 0) {
Context not available.
if (tag_decl) if (tag_decl)
return tag_decl->isCompleteDefinition(); return tag_decl->isCompleteDefinition();
return false; return false;
} else {
const clang::ObjCObjectType *objc_class_type =
llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
if (objc_class_type) {
clang::ObjCInterfaceDecl *class_interface_decl =
objc_class_type->getInterface();
if (class_interface_decl)
return class_interface_decl->getDefinition() != nullptr;
return false;
}
} }
return true; const clang::ObjCObjectType *objc_class_type =
llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
if (objc_class_type) {
clang::ObjCInterfaceDecl *class_interface_decl =
objc_class_type->getInterface();
if (class_interface_decl)
return class_interface_decl->getDefinition() != nullptr;
return false;
}
return true;
} }
bool ClangASTContext::IsObjCClassType(const CompilerType &type) { bool ClangASTContext::IsObjCClassType(const CompilerType &type) {
Context not available.
const clang::RecordDecl *record_decl = record_type->getDecl(); const clang::RecordDecl *record_decl = record_type->getDecl();
if (record_decl->isUnion()) if (record_decl->isUnion())
return lldb::eTypeClassUnion; return lldb::eTypeClassUnion;
else if (record_decl->isStruct()) if (record_decl->isStruct())
return lldb::eTypeClassStruct; return lldb::eTypeClassStruct;
else else
return lldb::eTypeClassClass; return lldb::eTypeClassClass;
Context not available.
ast_ctx, ast_ctx->getConstantArrayType( ast_ctx, ast_ctx->getConstantArrayType(
qual_type, llvm::APInt(64, size), qual_type, llvm::APInt(64, size),
clang::ArrayType::ArraySizeModifier::Normal, 0)); clang::ArrayType::ArraySizeModifier::Normal, 0));
else
return CompilerType( return CompilerType(
ast_ctx, ast_ctx,
ast_ctx->getIncompleteArrayType( ast_ctx->getIncompleteArrayType(
qual_type, clang::ArrayType::ArraySizeModifier::Normal, 0)); qual_type, clang::ArrayType::ArraySizeModifier::Normal, 0));
} }
} }
Context not available.
if (kind == eMemberFunctionKindUnknown) if (kind == eMemberFunctionKindUnknown)
return TypeMemberFunctionImpl(); return TypeMemberFunctionImpl();
else
return TypeMemberFunctionImpl(clang_type, clang_decl, name, kind); return TypeMemberFunctionImpl(clang_type, clang_decl, name, kind);
} }
CompilerType CompilerType
Context not available.
return CompilerType(this, getASTContext() return CompilerType(this, getASTContext()
->getLValueReferenceType(GetQualType(type)) ->getLValueReferenceType(GetQualType(type))
.getAsOpaquePtr()); .getAsOpaquePtr());
else
return CompilerType(); return CompilerType();
} }
CompilerType CompilerType
Context not available.
return CompilerType(this, getASTContext() return CompilerType(this, getASTContext()
->getRValueReferenceType(GetQualType(type)) ->getRValueReferenceType(GetQualType(type))
.getAsOpaquePtr()); .getAsOpaquePtr());
else
return CompilerType(); return CompilerType();
} }
CompilerType CompilerType
Context not available.
case clang::Type::Complex: { case clang::Type::Complex: {
if (qual_type->isComplexType()) if (qual_type->isComplexType())
return lldb::eFormatComplex; return lldb::eFormatComplex;
else
return lldb::eFormatComplexInteger; return lldb::eFormatComplexInteger;
} }
case clang::Type::ObjCInterface: case clang::Type::ObjCInterface:
break; break;
Context not available.
child_bitfield_bit_size, child_bitfield_bit_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
child_is_base_class, tmp_child_is_deref_of_parent, valobj, child_is_base_class, tmp_child_is_deref_of_parent, valobj,
language_flags); language_flags);
} else { }
child_is_deref_of_parent = true; child_is_deref_of_parent = true;
const char *parent_name = const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
valobj ? valobj->GetName().GetCString() : NULL; if (parent_name) {
if (parent_name) { child_name.assign(1, '*');
child_name.assign(1, '*'); child_name += parent_name;
child_name += parent_name;
} }
// We have a pointer to an simple type // We have a pointer to an simple type
Context not available.
child_byte_offset = 0; child_byte_offset = 0;
return pointee_clang_type; return pointee_clang_type;
} }
}
} }
break; break;
Context not available.
child_bitfield_bit_size, child_bitfield_bit_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
child_is_base_class, tmp_child_is_deref_of_parent, valobj, child_is_base_class, tmp_child_is_deref_of_parent, valobj,
language_flags); language_flags);
} else { }
child_is_deref_of_parent = true; child_is_deref_of_parent = true;
const char *parent_name = const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
valobj ? valobj->GetName().GetCString() : NULL; if (parent_name) {
if (parent_name) { child_name.assign(1, '*');
child_name.assign(1, '*'); child_name += parent_name;
child_name += parent_name;
} }
// We have a pointer to an simple type // We have a pointer to an simple type
Context not available.
child_byte_offset = 0; child_byte_offset = 0;
return pointee_clang_type; return pointee_clang_type;
} }
}
break; break;
} }
case clang::Type::LValueReference: case clang::Type::LValueReference:
Context not available.
child_bitfield_bit_size, child_bitfield_bit_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
child_is_base_class, tmp_child_is_deref_of_parent, valobj, child_is_base_class, tmp_child_is_deref_of_parent, valobj,
language_flags); language_flags);
} else { }
const char *parent_name = const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
valobj ? valobj->GetName().GetCString() : NULL; if (parent_name) {
if (parent_name) { child_name.assign(1, '&');
child_name.assign(1, '&'); child_name += parent_name;
child_name += parent_name;
} }
// We have a pointer to an simple type // We have a pointer to an simple type
Context not available.
child_byte_offset = 0; child_byte_offset = 0;
return pointee_clang_type; return pointee_clang_type;
} }
}
} }
break; break;
Context not available.
if (child_idx == UINT32_MAX) { if (child_idx == UINT32_MAX) {
child_indexes.clear(); child_indexes.clear();
return 0; return 0;
} else {
child_indexes.push_back(child_idx);
parent_record_decl = llvm::cast<clang::RecordDecl>(
elem.Base->getType()
->getAs<clang::RecordType>()
->getDecl());
} }
child_indexes.push_back(child_idx);
parent_record_decl = llvm::cast<clang::RecordDecl>(
elem.Base->getType()
->getAs<clang::RecordType>()
->getDecl());
} }
for (clang::NamedDecl *path_decl : path->Decls) { for (clang::NamedDecl *path_decl : path->Decls) {
child_idx = GetIndexForRecordChild( child_idx = GetIndexForRecordChild(
Context not available.
if (child_idx == UINT32_MAX) { if (child_idx == UINT32_MAX) {
child_indexes.clear(); child_indexes.clear();
return 0; return 0;
} else {
child_indexes.push_back(child_idx);
} }
child_indexes.push_back(child_idx);
} }
} }
return child_indexes.size(); return child_indexes.size();
Context not available.
if (pointee_type.IsAggregateType()) { if (pointee_type.IsAggregateType()) {
return pointee_type.GetIndexOfChildWithName(name, return pointee_type.GetIndexOfChildWithName(name,
omit_empty_base_classes); omit_empty_base_classes);
} else {
// if (parent_name)
// {
// child_name.assign(1, '*');
// child_name += parent_name;
// }
//
// // We have a pointer to an simple type
// if (idx == 0)
// {
// std::pair<uint64_t, unsigned> clang_type_info
// = ast->getTypeInfo(pointee_type);
// assert(clang_type_info.first % 8 == 0);
// child_byte_size = clang_type_info.first / 8;
// child_byte_offset = 0;
// return pointee_type.getAsOpaquePtr();
// }
} }
// if (parent_name)
// {
// child_name.assign(1, '*');
// child_name += parent_name;
// }
//
// // We have a pointer to an simple type
// if (idx == 0)
// {
// std::pair<uint64_t, unsigned> clang_type_info
// = ast->getTypeInfo(pointee_type);
// assert(clang_type_info.first % 8 == 0);
// child_byte_size = clang_type_info.first / 8;
// child_byte_offset = 0;
// return pointee_type.getAsOpaquePtr();
// }
} break; } break;
case clang::Type::Auto: case clang::Type::Auto:
Context not available.
clang::QualType qual_type = ClangUtil::GetCanonicalQualType(type); clang::QualType qual_type = ClangUtil::GetCanonicalQualType(type);
if (qual_type.isNull()) if (qual_type.isNull())
return nullptr; return nullptr;
else
return qual_type->getAsTagDecl(); return qual_type->getAsTagDecl();
} }
clang::TypedefNameDecl * clang::TypedefNameDecl *
Context not available.
LLDB_INVALID_ADDRESS, 0, 0); LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('"'); s->PutChar('"');
return; return;
} else { }
CompilerType element_clang_type(getASTContext(), element_qual_type); CompilerType element_clang_type(getASTContext(), element_qual_type);
lldb::Format element_format = element_clang_type.GetFormat(); lldb::Format element_format = element_clang_type.GetFormat();
for (element_idx = 0; element_idx < element_count; ++element_idx) {
// Print the starting squiggly bracket (if this is the first member) or
// comman (for member 2 and beyong) for the struct/union/class member.
if (element_idx == 0)
s->PutChar('{');
else
s->PutChar(',');
// Indent and print the index
s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx);
// Figure out the field offset within the current struct/union/class
// type
element_offset = element_idx * element_stride;
// Dump the value of the member for (element_idx = 0; element_idx < element_count; ++element_idx) {
element_clang_type.DumpValue( // Print the starting squiggly bracket (if this is the first member) or
exe_ctx, // comman (for member 2 and beyong) for the struct/union/class member.
s, // Stream to dump to if (element_idx == 0)
element_format, // The format with which to display the element s->PutChar('{');
data, // Data buffer containing all bytes for this type else
data_byte_offset + s->PutChar(',');
element_offset, // Offset into "data" where to grab value from
element_byte_size, // Size of this type in bytes // Indent and print the index
0, // Bitfield bit size s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx);
0, // Bitfield bit offset
show_types, // Boolean indicating if we should show the variable // Figure out the field offset within the current struct/union/class
// types // type
show_summary, // Boolean indicating if we should show a summary for element_offset = element_idx * element_stride;
// the current type
verbose, // Verbose output? // Dump the value of the member
depth + DEPTH_INCREMENT); // Scope depth for any types that have element_clang_type.DumpValue(
// children exe_ctx,
s, // Stream to dump to
element_format, // The format with which to display the element
data, // Data buffer containing all bytes for this type
data_byte_offset +
element_offset, // Offset into "data" where to grab value from
element_byte_size, // Size of this type in bytes
0, // Bitfield bit size
0, // Bitfield bit offset
show_types, // Boolean indicating if we should show the variable
// types
show_summary, // Boolean indicating if we should show a summary for
// the current type
verbose, // Verbose output?
depth + DEPTH_INCREMENT); // Scope depth for any types that have
// children
} }
// Indent the trailing squiggly bracket // Indent the trailing squiggly bracket
if (element_idx > 0) if (element_idx > 0)
s->Printf("\n%*s}", depth, ""); s->Printf("\n%*s}", depth, "");
}
} }
return; return;
Context not available.
return false; return false;
if (IsAggregateType(type)) { if (IsAggregateType(type)) {
return false; return false;
} else { }
clang::QualType qual_type(GetQualType(type)); clang::QualType qual_type(GetQualType(type));
const clang::Type::TypeClass type_class = qual_type->getTypeClass(); const clang::Type::TypeClass type_class = qual_type->getTypeClass();
switch (type_class) { switch (type_class) {
case clang::Type::Typedef: { case clang::Type::Typedef: {
clang::QualType typedef_qual_type = clang::QualType typedef_qual_type =
llvm::cast<clang::TypedefType>(qual_type) llvm::cast<clang::TypedefType>(qual_type)
->getDecl() ->getDecl()
->getUnderlyingType(); ->getUnderlyingType();
CompilerType typedef_clang_type(getASTContext(), typedef_qual_type); CompilerType typedef_clang_type(getASTContext(), typedef_qual_type);
if (format == eFormatDefault) if (format == eFormatDefault)
format = typedef_clang_type.GetFormat(); format = typedef_clang_type.GetFormat();
clang::TypeInfo typedef_type_info = clang::TypeInfo typedef_type_info =
getASTContext()->getTypeInfo(typedef_qual_type); getASTContext()->getTypeInfo(typedef_qual_type);
uint64_t typedef_byte_size = typedef_type_info.Width / 8; uint64_t typedef_byte_size = typedef_type_info.Width / 8;
return typedef_clang_type.DumpTypeValue( return typedef_clang_type.DumpTypeValue(
s, s,
format, // The format with which to display the element format, // The format with which to display the element
data, // Data buffer containing all bytes for this type data, // Data buffer containing all bytes for this type
byte_offset, // Offset into "data" where to grab value from byte_offset, // Offset into "data" where to grab value from
typedef_byte_size, // Size of this type in bytes typedef_byte_size, // Size of this type in bytes
bitfield_bit_size, // Size in bits of a bitfield value, if zero don't bitfield_bit_size, // Size in bits of a bitfield value, if zero don't
// treat as a bitfield // treat as a bitfield
bitfield_bit_offset, // Offset in bits of a bitfield value if bitfield_bit_offset, // Offset in bits of a bitfield value if
// bitfield_bit_size != 0 // bitfield_bit_size != 0
exe_scope); exe_scope);
} break; } break;
case clang::Type::Enum: case clang::Type::Enum:
Context not available.
} }
break; break;
} }
}
return 0; return 0;
} }
void ClangASTContext::DumpSummary(lldb::opaque_compiler_type_t type, void ClangASTContext::DumpSummary(lldb::opaque_compiler_type_t type,
Context not available.
if (opaque_decl) if (opaque_decl)
return CompilerDeclContext(this, return CompilerDeclContext(this,
((clang::Decl *)opaque_decl)->getDeclContext()); ((clang::Decl *)opaque_decl)->getDeclContext());
else
return CompilerDeclContext(); return CompilerDeclContext();
} }
CompilerType ClangASTContext::DeclGetFunctionReturnType(void *opaque_decl) { CompilerType ClangASTContext::DeclGetFunctionReturnType(void *opaque_decl) {
Context not available.
if (clang::ObjCMethodDecl *objc_method = if (clang::ObjCMethodDecl *objc_method =
llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl *)opaque_decl)) llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl *)opaque_decl))
return CompilerType(this, objc_method->getReturnType().getAsOpaquePtr()); return CompilerType(this, objc_method->getReturnType().getAsOpaquePtr());
else
return CompilerType(); return CompilerType();
} }
size_t ClangASTContext::DeclGetFunctionNumArguments(void *opaque_decl) { size_t ClangASTContext::DeclGetFunctionNumArguments(void *opaque_decl) {
Context not available.
if (clang::ObjCMethodDecl *objc_method = if (clang::ObjCMethodDecl *objc_method =
llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl *)opaque_decl)) llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl *)opaque_decl))
return objc_method->param_size(); return objc_method->param_size();
else
return 0; return 0;
} }
CompilerType ClangASTContext::DeclGetFunctionArgumentType(void *opaque_decl, CompilerType ClangASTContext::DeclGetFunctionArgumentType(void *opaque_decl,
Context not available.
bool ClangASTContext::DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) { bool ClangASTContext::DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) {
if (opaque_decl_ctx) if (opaque_decl_ctx)
return ((clang::DeclContext *)opaque_decl_ctx)->isRecord(); return ((clang::DeclContext *)opaque_decl_ctx)->isRecord();
else
return false; return false;
} }
ConstString ClangASTContext::DeclContextGetName(void *opaque_decl_ctx) { ConstString ClangASTContext::DeclContextGetName(void *opaque_decl_ctx) {
Context not available.
if (language_object_name_ptr) if (language_object_name_ptr)
language_object_name_ptr->SetCString("self"); language_object_name_ptr->SetCString("self");
return true; return true;
} else if (CXXMethodDecl *cxx_method = }
llvm::dyn_cast<clang::CXXMethodDecl>(decl_ctx)) { if (CXXMethodDecl *cxx_method =
llvm::dyn_cast<clang::CXXMethodDecl>(decl_ctx)) {
if (is_instance_method_ptr) if (is_instance_method_ptr)
*is_instance_method_ptr = cxx_method->isInstance(); *is_instance_method_ptr = cxx_method->isInstance();
if (language_ptr) if (language_ptr)
Context not available.

source/Symbol/ClangASTImporter.cpp

Context not available.
} }
return true; return true;
} else {
return false;
} }
return false;
} }
return true; return true;
Context not available.
if (ObjCInterfaceDecl *objc_interface_decl = if (ObjCInterfaceDecl *objc_interface_decl =
objc_object_type->getInterface()) objc_object_type->getInterface())
return CompleteObjCInterfaceDecl(objc_interface_decl); return CompleteObjCInterfaceDecl(objc_interface_decl);
else
return false; return false;
} }
if (const ArrayType *array_type = type->getAsArrayTypeUnsafe()) { if (const ArrayType *array_type = type->getAsArrayTypeUnsafe()) {
return RequireCompleteType(array_type->getElementType()); return RequireCompleteType(array_type->getElementType());
Context not available.
if (decl_origin.Valid()) if (decl_origin.Valid())
return ClangASTContext::GetMetadata(decl_origin.ctx, decl_origin.decl); return ClangASTContext::GetMetadata(decl_origin.ctx, decl_origin.decl);
else
return ClangASTContext::GetMetadata(&decl->getASTContext(), decl); return ClangASTContext::GetMetadata(&decl->getASTContext(), decl);
} }
ClangASTImporter::DeclOrigin ClangASTImporter::DeclOrigin
Context not available.
if (iter != origins.end()) if (iter != origins.end())
return iter->second; return iter->second;
else
return DeclOrigin(); return DeclOrigin();
} }
void ClangASTImporter::SetDeclOrigin(const clang::Decl *decl, void ClangASTImporter::SetDeclOrigin(const clang::Decl *decl,
Context not available.
if (iter != namespace_maps.end()) if (iter != namespace_maps.end())
return iter->second; return iter->second;
else
return NamespaceMapSP(); return NamespaceMapSP();
} }
void ClangASTImporter::BuildNamespaceMap(const clang::NamespaceDecl *decl) { void ClangASTImporter::BuildNamespaceMap(const clang::NamespaceDecl *decl) {
Context not available.

source/Symbol/ClangExternalASTSourceCommon.cpp

Context not available.
if (iter != source_map.end()) { if (iter != source_map.end()) {
return iter->second; return iter->second;
} else {
return nullptr;
} }
return nullptr;
} }
ClangExternalASTSourceCommon::ClangExternalASTSourceCommon() ClangExternalASTSourceCommon::ClangExternalASTSourceCommon()
Context not available.
ClangExternalASTSourceCommon::GetMetadata(const void *object) { ClangExternalASTSourceCommon::GetMetadata(const void *object) {
if (HasMetadata(object)) if (HasMetadata(object))
return &m_metadata[object]; return &m_metadata[object];
else
return nullptr; return nullptr;
} }
void ClangExternalASTSourceCommon::SetMetadata(const void *object, void ClangExternalASTSourceCommon::SetMetadata(const void *object,
Context not available.

source/Symbol/CompactUnwindInfo.cpp

Context not available.
if (mid != last && entry_func_end_offset) if (mid != last && entry_func_end_offset)
*entry_func_end_offset = next_func_offset; *entry_func_end_offset = next_func_offset;
return first_entry + (mid * 8); return first_entry + (mid * 8);
} else {
low = mid + 1;
} }
low = mid + 1;
} else { } else {
high = mid; high = mid;
} }
Context not available.
if (mid != last && entry_func_end_offset) if (mid != last && entry_func_end_offset)
*entry_func_end_offset = next_func_offset; *entry_func_end_offset = next_func_offset;
return UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX(entry); return UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX(entry);
} else {
low = mid + 1;
} }
low = mid + 1;
} else { } else {
high = mid; high = mid;
} }
Context not available.
} }
} }
return true; return true;
} else if (kind == UNWIND_SECOND_LEVEL_COMPRESSED) { }
if (kind == UNWIND_SECOND_LEVEL_COMPRESSED) {
// struct unwind_info_compressed_second_level_page_header { // struct unwind_info_compressed_second_level_page_header {
// uint32_t kind; // UNWIND_SECOND_LEVEL_COMPRESSED // uint32_t kind; // UNWIND_SECOND_LEVEL_COMPRESSED
// uint16_t entryPageOffset; // offset from this 2nd lvl page // uint16_t entryPageOffset; // offset from this 2nd lvl page
Context not available.

source/Symbol/CompilerDeclContext.cpp

Context not available.
if (IsValid()) if (IsValid())
return m_type_system->DeclContextFindDeclByName(m_opaque_decl_ctx, name, return m_type_system->DeclContextFindDeclByName(m_opaque_decl_ctx, name,
ignore_using_decls); ignore_using_decls);
else
return std::vector<CompilerDecl>(); return std::vector<CompilerDecl>();
} }
bool CompilerDeclContext::IsClang() const { bool CompilerDeclContext::IsClang() const {
Context not available.
ConstString CompilerDeclContext::GetName() const { ConstString CompilerDeclContext::GetName() const {
if (IsValid()) if (IsValid())
return m_type_system->DeclContextGetName(m_opaque_decl_ctx); return m_type_system->DeclContextGetName(m_opaque_decl_ctx);
else
return ConstString(); return ConstString();
} }
ConstString CompilerDeclContext::GetScopeQualifiedName() const { ConstString CompilerDeclContext::GetScopeQualifiedName() const {
if (IsValid()) if (IsValid())
return m_type_system->DeclContextGetScopeQualifiedName(m_opaque_decl_ctx); return m_type_system->DeclContextGetScopeQualifiedName(m_opaque_decl_ctx);
else
return ConstString(); return ConstString();
} }
bool CompilerDeclContext::IsStructUnionOrClass() const { bool CompilerDeclContext::IsStructUnionOrClass() const {
if (IsValid()) if (IsValid())
return m_type_system->DeclContextIsStructUnionOrClass(m_opaque_decl_ctx); return m_type_system->DeclContextIsStructUnionOrClass(m_opaque_decl_ctx);
else
return false; return false;
} }
bool CompilerDeclContext::IsClassMethod(lldb::LanguageType *language_ptr, bool CompilerDeclContext::IsClassMethod(lldb::LanguageType *language_ptr,
Context not available.
return m_type_system->DeclContextIsClassMethod( return m_type_system->DeclContextIsClassMethod(
m_opaque_decl_ctx, language_ptr, is_instance_method_ptr, m_opaque_decl_ctx, language_ptr, is_instance_method_ptr,
language_object_name_ptr); language_object_name_ptr);
else
return false; return false;
} }
bool lldb_private::operator==(const lldb_private::CompilerDeclContext &lhs, bool lldb_private::operator==(const lldb_private::CompilerDeclContext &lhs,
Context not available.

source/Symbol/CompilerType.cpp

Context not available.
CompilerType CompilerType::GetLValueReferenceType() const { CompilerType CompilerType::GetLValueReferenceType() const {
if (IsValid()) if (IsValid())
return m_type_system->GetLValueReferenceType(m_type); return m_type_system->GetLValueReferenceType(m_type);
else
return CompilerType(); return CompilerType();
} }
CompilerType CompilerType::GetRValueReferenceType() const { CompilerType CompilerType::GetRValueReferenceType() const {
if (IsValid()) if (IsValid())
return m_type_system->GetRValueReferenceType(m_type); return m_type_system->GetRValueReferenceType(m_type);
else
return CompilerType(); return CompilerType();
} }
CompilerType CompilerType::AddConstModifier() const { CompilerType CompilerType::AddConstModifier() const {
if (IsValid()) if (IsValid())
return m_type_system->AddConstModifier(m_type); return m_type_system->AddConstModifier(m_type);
else
return CompilerType(); return CompilerType();
} }
CompilerType CompilerType::AddVolatileModifier() const { CompilerType CompilerType::AddVolatileModifier() const {
if (IsValid()) if (IsValid())
return m_type_system->AddVolatileModifier(m_type); return m_type_system->AddVolatileModifier(m_type);
else
return CompilerType(); return CompilerType();
} }
CompilerType CompilerType::AddRestrictModifier() const { CompilerType CompilerType::AddRestrictModifier() const {
if (IsValid()) if (IsValid())
return m_type_system->AddRestrictModifier(m_type); return m_type_system->AddRestrictModifier(m_type);
else
return CompilerType(); return CompilerType();
} }
CompilerType CompilerType
Context not available.
const CompilerDeclContext &decl_ctx) const { const CompilerDeclContext &decl_ctx) const {
if (IsValid()) if (IsValid())
return m_type_system->CreateTypedef(m_type, name, decl_ctx); return m_type_system->CreateTypedef(m_type, name, decl_ctx);
else
return CompilerType(); return CompilerType();
} }
CompilerType CompilerType::GetTypedefedType() const { CompilerType CompilerType::GetTypedefedType() const {
if (IsValid()) if (IsValid())
return m_type_system->GetTypedefedType(m_type); return m_type_system->GetTypedefedType(m_type);
else
return CompilerType(); return CompilerType();
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Context not available.
if (IsAggregateType()) { if (IsAggregateType()) {
return false; // Aggregate types don't have scalar values return false; // Aggregate types don't have scalar values
} else { }
uint64_t count = 0; uint64_t count = 0;
lldb::Encoding encoding = GetEncoding(count); lldb::Encoding encoding = GetEncoding(count);
if (encoding == lldb::eEncodingInvalid || count != 1) if (encoding == lldb::eEncodingInvalid || count != 1)
return false; return false;
const uint64_t byte_size = GetByteSize(nullptr); const uint64_t byte_size = GetByteSize(nullptr);
lldb::offset_t offset = data_byte_offset; lldb::offset_t offset = data_byte_offset;
switch (encoding) { switch (encoding) {
case lldb::eEncodingInvalid: case lldb::eEncodingInvalid:
break; break;
case lldb::eEncodingVector: case lldb::eEncodingVector:
break; break;
case lldb::eEncodingUint: case lldb::eEncodingUint:
if (byte_size <= sizeof(unsigned long long)) { if (byte_size <= sizeof(unsigned long long)) {
uint64_t uval64 = data.GetMaxU64(&offset, byte_size); uint64_t uval64 = data.GetMaxU64(&offset, byte_size);
if (byte_size <= sizeof(unsigned int)) { if (byte_size <= sizeof(unsigned int)) {
value = (unsigned int)uval64; value = (unsigned int)uval64;
return true;
}
if (byte_size <= sizeof(unsigned long)) {
value = (unsigned long)uval64;
return true;
} else if (byte_size <= sizeof(unsigned long long)) {
value = (unsigned long long)uval64;
return true;
} else
value.Clear();
}
break;
case lldb::eEncodingSint:
if (byte_size <= sizeof(long long)) {
int64_t sval64 = data.GetMaxS64(&offset, byte_size);
if (byte_size <= sizeof(int)) {
value = (int)sval64;
return true;
}
if (byte_size <= sizeof(long)) {
value = (long)sval64;
return true;
} else if (byte_size <= sizeof(long long)) {
value = (long long)sval64;
return true;
} else
value.Clear();
}
break;
case lldb::eEncodingIEEE754:
if (byte_size <= sizeof(long double)) {
uint32_t u32;
uint64_t u64;
if (byte_size == sizeof(float)) {
if (sizeof(float) == sizeof(uint32_t)) {
u32 = data.GetU32(&offset);
value = *((float *)&u32);
return true; return true;
} else if (byte_size <= sizeof(unsigned long)) { }
value = (unsigned long)uval64; if (sizeof(float) == sizeof(uint64_t)) {
u64 = data.GetU64(&offset);
value = *((float *)&u64);
return true; return true;
} else if (byte_size <= sizeof(unsigned long long)) { }
value = (unsigned long long)uval64; } else if (byte_size == sizeof(double)) {
if (sizeof(double) == sizeof(uint32_t)) {
u32 = data.GetU32(&offset);
value = *((double *)&u32);
return true; return true;
} else }
value.Clear(); if (sizeof(double) == sizeof(uint64_t)) {
} u64 = data.GetU64(&offset);
break; value = *((double *)&u64);
case lldb::eEncodingSint:
if (byte_size <= sizeof(long long)) {
int64_t sval64 = data.GetMaxS64(&offset, byte_size);
if (byte_size <= sizeof(int)) {
value = (int)sval64;
return true; return true;
} else if (byte_size <= sizeof(long)) { }
value = (long)sval64; } else if (byte_size == sizeof(long double)) {
if (sizeof(long double) == sizeof(uint32_t)) {
u32 = data.GetU32(&offset);
value = *((long double *)&u32);
return true; return true;
} else if (byte_size <= sizeof(long long)) { }
value = (long long)sval64; if (sizeof(long double) == sizeof(uint64_t)) {
u64 = data.GetU64(&offset);
value = *((long double *)&u64);
return true; return true;
} else
value.Clear();
}
break;
case lldb::eEncodingIEEE754:
if (byte_size <= sizeof(long double)) {
uint32_t u32;
uint64_t u64;
if (byte_size == sizeof(float)) {
if (sizeof(float) == sizeof(uint32_t)) {
u32 = data.GetU32(&offset);
value = *((float *)&u32);
return true;
} else if (sizeof(float) == sizeof(uint64_t)) {
u64 = data.GetU64(&offset);
value = *((float *)&u64);
return true;
}
} else if (byte_size == sizeof(double)) {
if (sizeof(double) == sizeof(uint32_t)) {
u32 = data.GetU32(&offset);
value = *((double *)&u32);
return true;
} else if (sizeof(double) == sizeof(uint64_t)) {
u64 = data.GetU64(&offset);
value = *((double *)&u64);
return true;
}
} else if (byte_size == sizeof(long double)) {
if (sizeof(long double) == sizeof(uint32_t)) {
u32 = data.GetU32(&offset);
value = *((long double *)&u32);
return true;
} else if (sizeof(long double) == sizeof(uint64_t)) {
u64 = data.GetU64(&offset);
value = *((long double *)&u64);
return true;
}
} }
} }
break;
} }
} break;
return false; }
return false;
} }
bool CompilerType::SetValueFromScalar(const Scalar &value, Stream &strm) { bool CompilerType::SetValueFromScalar(const Scalar &value, Stream &strm) {
Context not available.
if (byte_size == sizeof(float)) { if (byte_size == sizeof(float)) {
strm.PutFloat(value.Float()); strm.PutFloat(value.Float());
return true; return true;
} else if (byte_size == sizeof(double)) { }
if (byte_size == sizeof(double)) {
strm.PutDouble(value.Double()); strm.PutDouble(value.Double());
return true; return true;
} else if (byte_size == sizeof(long double)) { } else if (byte_size == sizeof(long double)) {
Context not available.
// The address is an address in this process, so just copy it // The address is an address in this process, so just copy it
memcpy(dst, reinterpret_cast<uint8_t *>(addr), byte_size); memcpy(dst, reinterpret_cast<uint8_t *>(addr), byte_size);
return true; return true;
} else {
Process *process = nullptr;
if (exe_ctx)
process = exe_ctx->GetProcessPtr();
if (process) {
Status error;
return process->ReadMemory(addr, dst, byte_size, error) == byte_size;
}
} }
Process *process = nullptr;
if (exe_ctx)
process = exe_ctx->GetProcessPtr();
if (process) {
Status error;
return process->ReadMemory(addr, dst, byte_size, error) == byte_size;
}
} }
return false; return false;
} }
Context not available.
// The address is an address in this process, so just copy it // The address is an address in this process, so just copy it
memcpy((void *)addr, new_value.GetData(), byte_size); memcpy((void *)addr, new_value.GetData(), byte_size);
return true; return true;
} else {
Process *process = nullptr;
if (exe_ctx)
process = exe_ctx->GetProcessPtr();
if (process) {
Status error;
return process->WriteMemory(addr, new_value.GetData(), byte_size,
error) == byte_size;
}
} }
Process *process = nullptr;
if (exe_ctx)
process = exe_ctx->GetProcessPtr();
if (process) {
Status error;
return process->WriteMemory(addr, new_value.GetData(), byte_size,
error) == byte_size;
}
} }
return false; return false;
} }
Context not available.

source/Symbol/Declaration.cpp

Context not available.
s->Printf(":%u", m_column); s->Printf(":%u", m_column);
#endif #endif
return true; return true;
} else if (m_line > 0) { }
if (m_line > 0) {
s->Printf(" line %u", m_line); s->Printf(" line %u", m_line);
#ifdef LLDB_ENABLE_DECLARATION_COLUMNS #ifdef LLDB_ENABLE_DECLARATION_COLUMNS
if (m_column > 0) if (m_column > 0)
Context not available.
return result; return result;
if (a.m_line < b.m_line) if (a.m_line < b.m_line)
return -1; return -1;
else if (a.m_line > b.m_line) if (a.m_line > b.m_line)
return 1; return 1;
#ifdef LLDB_ENABLE_DECLARATION_COLUMNS #ifdef LLDB_ENABLE_DECLARATION_COLUMNS
if (a.m_column < b.m_column) if (a.m_column < b.m_column)
Context not available.

source/Symbol/Function.cpp

Context not available.
lldb::LanguageType Function::GetLanguage() const { lldb::LanguageType Function::GetLanguage() const {
if (m_comp_unit) if (m_comp_unit)
return m_comp_unit->GetLanguage(); return m_comp_unit->GetLanguage();
else
return lldb::eLanguageTypeUnknown; return lldb::eLanguageTypeUnknown;
} }
ConstString Function::GetName() const { ConstString Function::GetName() const {
Context not available.

source/Symbol/LineTable.cpp

Context not available.
if (m_entries[idx].line < line) { if (m_entries[idx].line < line) {
continue; continue;
} else if (m_entries[idx].line == line) { }
if (m_entries[idx].line == line) {
if (line_entry_ptr) if (line_entry_ptr)
ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr); ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr);
return idx; return idx;
Context not available.
if (m_entries[idx].line < line) { if (m_entries[idx].line < line) {
continue; continue;
} else if (m_entries[idx].line == line) { }
if (m_entries[idx].line == line) {
if (line_entry_ptr) if (line_entry_ptr)
ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr); ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr);
return idx; return idx;
Context not available.

source/Symbol/ObjectFile.cpp

Context not available.
section_dst_len = section_bytes_left; section_dst_len = section_bytes_left;
return CopyData(section->GetFileOffset() + section_offset, return CopyData(section->GetFileOffset() + section_offset,
section_dst_len, dst); section_dst_len, dst);
} else { }
if (section->GetType() == eSectionTypeZeroFill) { if (section->GetType() == eSectionTypeZeroFill) {
const uint64_t section_size = section->GetByteSize(); const uint64_t section_size = section->GetByteSize();
const uint64_t section_bytes_left = section_size - section_offset; const uint64_t section_bytes_left = section_size - section_offset;
uint64_t section_dst_len = dst_len; uint64_t section_dst_len = dst_len;
if (section_dst_len > section_bytes_left) if (section_dst_len > section_bytes_left)
section_dst_len = section_bytes_left; section_dst_len = section_bytes_left;
memset(dst, 0, section_dst_len); memset(dst, 0, section_dst_len);
return section_dst_len; return section_dst_len;
}
} }
} }
return 0; return 0;
Context not available.
} }
return GetData(section->GetFileOffset(), section->GetFileSize(), return GetData(section->GetFileOffset(), section->GetFileSize(),
section_data); section_data);
} else {
// The object file now contains a full mmap'ed copy of the object file
// data, so just use this
if (!section->IsRelocated())
RelocateSection(section);
return GetData(section->GetFileOffset(), section->GetFileSize(),
section_data);
} }
// The object file now contains a full mmap'ed copy of the object file
// data, so just use this
if (!section->IsRelocated())
RelocateSection(section);
return GetData(section->GetFileOffset(), section->GetFileSize(),
section_data);
} }
bool ObjectFile::SplitArchivePathWithObject(const char *path_with_object, bool ObjectFile::SplitArchivePathWithObject(const char *path_with_object,
Context not available.

source/Symbol/Symbol.cpp

Context not available.
intptr_t str_ptr = m_addr_range.GetBaseAddress().GetOffset(); intptr_t str_ptr = m_addr_range.GetBaseAddress().GetOffset();
if (str_ptr != 0) if (str_ptr != 0)
return ConstString((const char *)str_ptr); return ConstString((const char *)str_ptr);
else
return GetName(); return GetName();
} }
return ConstString(); return ConstString();
} }
Context not available.
lldb::addr_t Symbol::GetFileAddress() const { lldb::addr_t Symbol::GetFileAddress() const {
if (ValueIsAddress()) if (ValueIsAddress())
return GetAddressRef().GetFileAddress(); return GetAddressRef().GetFileAddress();
else
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
} }
lldb::addr_t Symbol::GetLoadAddress(Target *target) const { lldb::addr_t Symbol::GetLoadAddress(Target *target) const {
if (ValueIsAddress()) if (ValueIsAddress())
return GetAddressRef().GetLoadAddress(target); return GetAddressRef().GetLoadAddress(target);
else
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
} }
ConstString Symbol::GetName() const { return m_mangled.GetName(GetLanguage()); } ConstString Symbol::GetName() const { return m_mangled.GetName(GetLanguage()); }
Context not available.

source/Symbol/SymbolContext.cpp

Context not available.
LanguageType lang; LanguageType lang;
if (function && (lang = function->GetLanguage()) != eLanguageTypeUnknown) { if (function && (lang = function->GetLanguage()) != eLanguageTypeUnknown) {
return lang; return lang;
} else if (variable && }
(lang = variable->GetLanguage()) != eLanguageTypeUnknown) { if (variable && (lang = variable->GetLanguage()) != eLanguageTypeUnknown) {
return lang; return lang;
} else if (symbol && (lang = symbol->GetLanguage()) != eLanguageTypeUnknown) { } else if (symbol && (lang = symbol->GetLanguage()) != eLanguageTypeUnknown) {
return lang; return lang;
Context not available.
next_frame_sc.line_entry.column = next_frame_sc.line_entry.column =
curr_inlined_block_inlined_info->GetCallSite().GetColumn(); curr_inlined_block_inlined_info->GetCallSite().GetColumn();
return true; return true;
} else { }
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS));
if (log) { if (log) {
log->Printf( log->Printf(
"warning: inlined block 0x%8.8" PRIx64 "warning: inlined block 0x%8.8" PRIx64
" doesn't have a range that contains file address 0x%" PRIx64, " doesn't have a range that contains file address 0x%" PRIx64,
curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress()); curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress());
} }
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
else { else {
Context not available.
} }
} }
#endif #endif
}
} }
} }
Context not available.
} }
} }
return function->GetMangled().GetName(function->GetLanguage(), preference); return function->GetMangled().GetName(function->GetLanguage(), preference);
} else if (symbol && symbol->ValueIsAddress()) { }
if (symbol && symbol->ValueIsAddress()) {
return symbol->GetMangled().GetName(symbol->GetLanguage(), preference); return symbol->GetMangled().GetName(symbol->GetLanguage(), preference);
} else { } else {
// No function, return an empty string. // No function, return an empty string.
Context not available.
ss.PutChar('\n'); ss.PutChar('\n');
error.SetErrorString(ss.GetData()); error.SetErrorString(ss.GetData());
return nullptr; return nullptr;
} else if (external_symbols.size()) { }
if (external_symbols.size()) {
return external_symbols[0]; return external_symbols[0];
} else if (internal_symbols.size() > 1) { } else if (internal_symbols.size() > 1) {
StreamString ss; StreamString ss;
Context not available.
if (!error.Success()) { if (!error.Success()) {
return nullptr; return nullptr;
} else if (module_symbol) { }
if (module_symbol) {
return module_symbol; return module_symbol;
} }
} }
Context not available.
if (!error.Success()) { if (!error.Success()) {
return nullptr; return nullptr;
} else if (target_symbol) { }
if (target_symbol) {
return target_symbol; return target_symbol;
} }
} }
Context not available.

source/Symbol/SymbolVendor.cpp

Context not available.
assert(m_compile_units[idx].get() == nullptr); assert(m_compile_units[idx].get() == nullptr);
m_compile_units[idx] = cu_sp; m_compile_units[idx] = cu_sp;
return true; return true;
} else {
// This should NOT happen, and if it does, we want to crash and know
// about it
assert(idx < num_compile_units);
} }
// This should NOT happen, and if it does, we want to crash and know
// about it
assert(idx < num_compile_units);
} }
return false; return false;
} }
Context not available.

source/Symbol/Symtab.cpp

Context not available.
if (uid_a > uid_b) if (uid_a > uid_b)
return false; return false;
return false; return false;
} else if (value_a < value_b) }
if (value_a < value_b)
return true; return true;
return false; return false;
Context not available.

source/Symbol/Type.cpp

Context not available.
return false; return false;
memcpy(dst, reinterpret_cast<uint8_t *>(addr), byte_size); memcpy(dst, reinterpret_cast<uint8_t *>(addr), byte_size);
return true; return true;
} else { }
if (exe_ctx) { if (exe_ctx) {
Process *process = exe_ctx->GetProcessPtr(); Process *process = exe_ctx->GetProcessPtr();
if (process) { if (process) {
Status error; Status error;
return exe_ctx->GetProcessPtr()->ReadMemory(addr, dst, byte_size, return exe_ctx->GetProcessPtr()->ReadMemory(addr, dst, byte_size,
error) == byte_size; error) == byte_size;
}
} }
} }
} }
Context not available.
bool TypeAndOrName::IsEmpty() const { bool TypeAndOrName::IsEmpty() const {
if ((bool)m_type_name || (bool)m_type_pair) if ((bool)m_type_name || (bool)m_type_pair)
return false; return false;
else
return true; return true;
} }
void TypeAndOrName::Clear() { void TypeAndOrName::Clear() {
Context not available.
size_t TypeMemberFunctionImpl::GetNumArguments() const { size_t TypeMemberFunctionImpl::GetNumArguments() const {
if (m_type) if (m_type)
return m_type.GetNumberOfFunctionArguments(); return m_type.GetNumberOfFunctionArguments();
else
return m_decl.GetNumFunctionArguments(); return m_decl.GetNumFunctionArguments();
} }
CompilerType TypeMemberFunctionImpl::GetArgumentAtIndex(size_t idx) const { CompilerType TypeMemberFunctionImpl::GetArgumentAtIndex(size_t idx) const {
if (m_type) if (m_type)
return m_type.GetFunctionArgumentAtIndex(idx); return m_type.GetFunctionArgumentAtIndex(idx);
else
return m_decl.GetFunctionArgumentType(idx); return m_decl.GetFunctionArgumentType(idx);
} }
TypeEnumMemberImpl::TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp, TypeEnumMemberImpl::TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp,
Context not available.

source/Symbol/UnwindPlan.cpp

Context not available.
const UnwindPlan::RowSP UnwindPlan::GetRowAtIndex(uint32_t idx) const { const UnwindPlan::RowSP UnwindPlan::GetRowAtIndex(uint32_t idx) const {
if (idx < m_row_list.size()) if (idx < m_row_list.size())
return m_row_list[idx]; return m_row_list[idx];
else {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND)); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
if (log) if (log)
log->Printf("error: UnwindPlan::GetRowAtIndex(idx = %u) invalid index " log->Printf("error: UnwindPlan::GetRowAtIndex(idx = %u) invalid index "
"(number rows is %u)", "(number rows is %u)",
idx, (uint32_t)m_row_list.size()); idx, (uint32_t)m_row_list.size());
return UnwindPlan::RowSP(); return UnwindPlan::RowSP();
}
} }
const UnwindPlan::RowSP UnwindPlan::GetLastRow() const { const UnwindPlan::RowSP UnwindPlan::GetLastRow() const {
Context not available.

source/Target/CPPLanguageRuntime.cpp

Context not available.
ret_plan_sp.reset(new ThreadPlanRunToAddress( ret_plan_sp.reset(new ThreadPlanRunToAddress(
thread, callable_info.callable_address, stop_others)); thread, callable_info.callable_address, stop_others));
return ret_plan_sp; return ret_plan_sp;
} else {
// We are in std::function but we could not obtain the callable.
// We create a ThreadPlan to keep stepping through using the address range
// of the current function.
ret_plan_sp.reset(new ThreadPlanStepInRange(thread, range_of_curr_func,
sc, eOnlyThisThread,
eLazyBoolYes, eLazyBoolYes));
return ret_plan_sp;
} }
// We are in std::function but we could not obtain the callable.
// We create a ThreadPlan to keep stepping through using the address range
// of the current function.
ret_plan_sp.reset(new ThreadPlanStepInRange(thread, range_of_curr_func, sc,
eOnlyThisThread, eLazyBoolYes,
eLazyBoolYes));
return ret_plan_sp;
} }
return ret_plan_sp; return ret_plan_sp;
Context not available.

source/Target/ExecutionContext.cpp

Context not available.
RegisterContext *ExecutionContext::GetRegisterContext() const { RegisterContext *ExecutionContext::GetRegisterContext() const {
if (m_frame_sp) if (m_frame_sp)
return m_frame_sp->GetRegisterContext().get(); return m_frame_sp->GetRegisterContext().get();
else if (m_thread_sp) if (m_thread_sp)
return m_thread_sp->GetRegisterContext().get(); return m_thread_sp->GetRegisterContext().get();
return nullptr; return nullptr;
} }
Context not available.

source/Target/FileAction.cpp

Context not available.
m_arg = O_NOCTTY | O_CREAT | O_WRONLY; m_arg = O_NOCTTY | O_CREAT | O_WRONLY;
m_file_spec = file_spec; m_file_spec = file_spec;
return true; return true;
} else {
Clear();
} }
Clear();
return false; return false;
} }
Context not available.

source/Target/Language.cpp

Context not available.
const char *Language::GetNameForLanguageType(LanguageType language) { const char *Language::GetNameForLanguageType(LanguageType language) {
if (language < num_languages) if (language < num_languages)
return language_names[language].name; return language_names[language].name;
else
return language_names[eLanguageTypeUnknown].name; return language_names[eLanguageTypeUnknown].name;
} }
void Language::PrintAllLanguages(Stream &s, const char *prefix, void Language::PrintAllLanguages(Stream &s, const char *prefix,
Context not available.

source/Target/LanguageRuntime.cpp

Context not available.
if (SetActualResolver()) if (SetActualResolver())
return m_actual_resolver_sp->SearchCallback(filter, context, addr, return m_actual_resolver_sp->SearchCallback(filter, context, addr,
containing); containing);
else
return eCallbackReturnStop; return eCallbackReturnStop;
} }
lldb::SearchDepth GetDepth() override { lldb::SearchDepth GetDepth() override {
if (SetActualResolver()) if (SetActualResolver())
return m_actual_resolver_sp->GetDepth(); return m_actual_resolver_sp->GetDepth();
else
return lldb::eSearchDepthTarget; return lldb::eSearchDepthTarget;
} }
void GetDescription(Stream *s) override { void GetDescription(Stream *s) override {
Context not available.

source/Target/ObjCLanguageRuntime.cpp

Context not available.
if (complete_type_sp) if (complete_type_sp)
return complete_type_sp; return complete_type_sp;
else
m_complete_class_cache.erase(name); m_complete_class_cache.erase(name);
} }
if (m_negative_complete_class_cache.count(name) > 0) if (m_negative_complete_class_cache.count(name) > 0)
Context not available.
return true; return true;
if ((value % ptr_size) == 0) if ((value % ptr_size) == 0)
return (check_version_specific ? CheckPointer(value, ptr_size) : true); return (check_version_specific ? CheckPointer(value, ptr_size) : true);
else
return false; return false;
} }
ObjCLanguageRuntime::ObjCISA ObjCLanguageRuntime::ObjCISA
Context not available.

source/Target/Platform.cpp

Context not available.
#else #else
return false; return false;
#endif #endif
else
return GetRemoteOSBuildString(s); return GetRemoteOSBuildString(s);
} }
bool Platform::GetOSKernelDescription(std::string &s) { bool Platform::GetOSKernelDescription(std::string &s) {
Context not available.
#else #else
return false; return false;
#endif #endif
else
return GetRemoteOSKernelDescription(s); return GetRemoteOSKernelDescription(s);
} }
void Platform::AddClangModuleCompilationOptions( void Platform::AddClangModuleCompilationOptions(
Context not available.
llvm::SmallString<64> cwd; llvm::SmallString<64> cwd;
if (llvm::sys::fs::current_path(cwd)) if (llvm::sys::fs::current_path(cwd))
return {}; return {};
else {
FileSpec file_spec(cwd); FileSpec file_spec(cwd);
FileSystem::Instance().Resolve(file_spec); FileSystem::Instance().Resolve(file_spec);
return file_spec; return file_spec;
}
} else { } else {
if (!m_working_dir) if (!m_working_dir)
m_working_dir = GetRemoteWorkingDirectory(); m_working_dir = GetRemoteWorkingDirectory();
Context not available.
return false; return false;
} }
return true; return true;
} else {
m_working_dir.Clear();
return SetRemoteWorkingDirectory(file_spec);
} }
m_working_dir.Clear();
return SetRemoteWorkingDirectory(file_spec);
} }
Status Platform::MakeDirectory(const FileSpec &file_spec, Status Platform::MakeDirectory(const FileSpec &file_spec,
uint32_t permissions) { uint32_t permissions) {
if (IsHost()) if (IsHost())
return llvm::sys::fs::create_directory(file_spec.GetPath(), permissions); return llvm::sys::fs::create_directory(file_spec.GetPath(), permissions);
else {
Status error; Status error;
error.SetErrorStringWithFormat("remote platform %s doesn't support %s", error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
GetPluginName().GetCString(), GetPluginName().GetCString(),
LLVM_PRETTY_FUNCTION); LLVM_PRETTY_FUNCTION);
return error; return error;
}
} }
Status Platform::GetFilePermissions(const FileSpec &file_spec, Status Platform::GetFilePermissions(const FileSpec &file_spec,
Context not available.
if (Value) if (Value)
file_permissions = Value.get(); file_permissions = Value.get();
return Status(Value.getError()); return Status(Value.getError());
} else {
Status error;
error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
GetPluginName().GetCString(),
LLVM_PRETTY_FUNCTION);
return error;
} }
Status error;
error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
GetPluginName().GetCString(),
LLVM_PRETTY_FUNCTION);
return error;
} }
Status Platform::SetFilePermissions(const FileSpec &file_spec, Status Platform::SetFilePermissions(const FileSpec &file_spec,
Context not available.
if (IsHost()) { if (IsHost()) {
auto Perms = static_cast<llvm::sys::fs::perms>(file_permissions); auto Perms = static_cast<llvm::sys::fs::perms>(file_permissions);
return llvm::sys::fs::setPermissions(file_spec.GetPath(), Perms); return llvm::sys::fs::setPermissions(file_spec.GetPath(), Perms);
} else {
Status error;
error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
GetPluginName().GetCString(),
LLVM_PRETTY_FUNCTION);
return error;
} }
Status error;
error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
GetPluginName().GetCString(),
LLVM_PRETTY_FUNCTION);
return error;
} }
ConstString Platform::GetName() { return GetPluginName(); } ConstString Platform::GetName() { return GetPluginName(); }
Context not available.
// We don't need anyone setting the OS version for the host platform, we // We don't need anyone setting the OS version for the host platform, we
// should be able to figure it out by calling HostInfo::GetOSVersion(...). // should be able to figure it out by calling HostInfo::GetOSVersion(...).
return false; return false;
} else {
// We have a remote platform, allow setting the target OS version if we
// aren't connected, since if we are connected, we should be able to
// request the remote OS version from the connected platform.
if (IsConnected())
return false;
else {
// We aren't connected and we might want to set the OS version ahead of
// time before we connect so we can peruse files and use a local SDK or
// PDK cache of support files to disassemble or do other things.
m_os_version = version;
return true;
}
} }
// We have a remote platform, allow setting the target OS version if we
// aren't connected, since if we are connected, we should be able to
// request the remote OS version from the connected platform.
if (IsConnected())
return false;
// We aren't connected and we might want to set the OS version ahead of
// time before we connect so we can peruse files and use a local SDK or
// PDK cache of support files to disassemble or do other things.
m_os_version = version;
return true;
return false; return false;
} }
Context not available.
if (IsHost()) if (IsHost())
return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr, return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr,
command_output, timeout); command_output, timeout);
else
return Status("unimplemented"); return Status("unimplemented");
} }
bool Platform::CalculateMD5(const FileSpec &file_spec, uint64_t &low, bool Platform::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
Context not available.

source/Target/Process.cpp

Context not available.
if (process_sp->CanDebug(target_sp, false)) { if (process_sp->CanDebug(target_sp, false)) {
process_sp->m_process_unique_id = ++g_process_unique_id; process_sp->m_process_unique_id = ++g_process_unique_id;
break; break;
} else }
process_sp.reset(); process_sp.reset();
} }
} }
} }
Context not available.
if (listener_sp) { if (listener_sp) {
return HijackBroadcaster(listener_sp, eBroadcastBitStateChanged | return HijackBroadcaster(listener_sp, eBroadcastBitStateChanged |
eBroadcastBitInterrupt); eBroadcastBitInterrupt);
} else }
return false; return false;
} }
void Process::RestoreProcessEvents() { RestoreBroadcaster(); } void Process::RestoreProcessEvents() { RestoreBroadcaster(); }
Context not available.
if (control_only) if (control_only)
return m_private_state_listener_sp->GetEventForBroadcaster( return m_private_state_listener_sp->GetEventForBroadcaster(
&m_private_state_control_broadcaster, event_sp, timeout); &m_private_state_control_broadcaster, event_sp, timeout);
else
return m_private_state_listener_sp->GetEvent(event_sp, timeout); return m_private_state_listener_sp->GetEvent(event_sp, timeout);
} }
bool Process::IsRunning() const { bool Process::IsRunning() const {
Context not available.
m_language_runtimes[language] = runtime_sp; m_language_runtimes[language] = runtime_sp;
return runtime_sp.get(); return runtime_sp.get();
} else }
return (*pos).second.get(); return (*pos).second.get();
} }
CPPLanguageRuntime *Process::GetCPPLanguageRuntime(bool retry_if_null) { CPPLanguageRuntime *Process::GetCPPLanguageRuntime(bool retry_if_null) {
Context not available.
bp_site_sp->AddOwner(owner); bp_site_sp->AddOwner(owner);
owner->SetBreakpointSite(bp_site_sp); owner->SetBreakpointSite(bp_site_sp);
return bp_site_sp->GetID(); return bp_site_sp->GetID();
} else {
bp_site_sp.reset(new BreakpointSite(&m_breakpoint_site_list, owner,
load_addr, use_hardware));
if (bp_site_sp) {
Status error = EnableBreakpointSite(bp_site_sp.get());
if (error.Success()) {
owner->SetBreakpointSite(bp_site_sp);
return m_breakpoint_site_list.Add(bp_site_sp);
} else {
if (show_error || use_hardware) {
// Report error for setting breakpoint...
GetTarget().GetDebugger().GetErrorFile()->Printf(
"warning: failed to set breakpoint site at 0x%" PRIx64
" for breakpoint %i.%i: %s\n",
load_addr, owner->GetBreakpoint().GetID(), owner->GetID(),
error.AsCString() ? error.AsCString() : "unknown error");
}
}
}
} }
bp_site_sp.reset(new BreakpointSite(&m_breakpoint_site_list, owner,
load_addr, use_hardware));
if (bp_site_sp) {
Status error = EnableBreakpointSite(bp_site_sp.get());
if (error.Success()) {
owner->SetBreakpointSite(bp_site_sp);
return m_breakpoint_site_list.Add(bp_site_sp);
}
if (show_error || use_hardware) {
// Report error for setting breakpoint...
GetTarget().GetDebugger().GetErrorFile()->Printf(
"warning: failed to set breakpoint site at 0x%" PRIx64
" for breakpoint %i.%i: %s\n",
load_addr, owner->GetBreakpoint().GetID(), owner->GetID(),
error.AsCString() ? error.AsCString() : "unknown error");
}
aprantlUnsubmitted
Not Done
ReplyInline Actions

this also looks suspicious

aprantl: this also looks suspicious
}
} }
// We failed to enable the breakpoint // We failed to enable the breakpoint
return LLDB_INVALID_BREAK_ID; return LLDB_INVALID_BREAK_ID;
Context not available.
"addr = 0x%" PRIx64 " -- SUCCESS", "addr = 0x%" PRIx64 " -- SUCCESS",
bp_site->GetID(), (uint64_t)bp_addr); bp_site->GetID(), (uint64_t)bp_addr);
return error; return error;
} else {
if (break_op_found)
error.SetErrorString("Failed to restore original opcode.");
} }
if (break_op_found)
error.SetErrorString("Failed to restore original opcode.");
} else } else
error.SetErrorString("Failed to read memory to verify that " error.SetErrorString("Failed to read memory to verify that "
"breakpoint trap was restored."); "breakpoint trap was restored.");
Context not available.
return m_memory_cache.Read(addr, buf, size, error); return m_memory_cache.Read(addr, buf, size, error);
#endif // defined (VERIFY_MEMORY_READS) #endif // defined (VERIFY_MEMORY_READS)
} else {
// Memory caching is disabled
return ReadMemoryFromInferior(addr, buf, size, error);
} }
// Memory caching is disabled
return ReadMemoryFromInferior(addr, buf, size, error);
} }
size_t Process::ReadCStringFromMemory(addr_t addr, std::string &out_str, size_t Process::ReadCStringFromMemory(addr_t addr, std::string &out_str,
Context not available.
// No breakpoint sites overlap // No breakpoint sites overlap
if (bp_sites_in_range.IsEmpty()) if (bp_sites_in_range.IsEmpty())
return WriteMemoryPrivate(addr, buf, size, error); return WriteMemoryPrivate(addr, buf, size, error);
else {
const uint8_t *ubuf = (const uint8_t *)buf;
uint64_t bytes_written = 0;
bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf, const uint8_t *ubuf = (const uint8_t *)buf;
&error](BreakpointSite *bp) -> void { uint64_t bytes_written = 0;
if (error.Success()) { bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf,
addr_t intersect_addr; &error](BreakpointSite *bp) -> void {
size_t intersect_size; if (error.Success()) {
size_t opcode_offset; addr_t intersect_addr;
const bool intersects = bp->IntersectsRange( size_t intersect_size;
addr, size, &intersect_addr, &intersect_size, &opcode_offset); size_t opcode_offset;
UNUSED_IF_ASSERT_DISABLED(intersects); const bool intersects = bp->IntersectsRange(
assert(intersects); addr, size, &intersect_addr, &intersect_size, &opcode_offset);
assert(addr <= intersect_addr && intersect_addr < addr + size); UNUSED_IF_ASSERT_DISABLED(intersects);
assert(addr < intersect_addr + intersect_size && assert(intersects);
intersect_addr + intersect_size <= addr + size); assert(addr <= intersect_addr && intersect_addr < addr + size);
assert(opcode_offset + intersect_size <= bp->GetByteSize()); assert(addr < intersect_addr + intersect_size &&
intersect_addr + intersect_size <= addr + size);
// Check for bytes before this breakpoint assert(opcode_offset + intersect_size <= bp->GetByteSize());
const addr_t curr_addr = addr + bytes_written;
if (intersect_addr > curr_addr) { // Check for bytes before this breakpoint
// There are some bytes before this breakpoint that we need to just const addr_t curr_addr = addr + bytes_written;
// write to memory if (intersect_addr > curr_addr) {
size_t curr_size = intersect_addr - curr_addr; // There are some bytes before this breakpoint that we need to just
size_t curr_bytes_written = WriteMemoryPrivate( // write to memory
curr_addr, ubuf + bytes_written, curr_size, error); size_t curr_size = intersect_addr - curr_addr;
bytes_written += curr_bytes_written; size_t curr_bytes_written = WriteMemoryPrivate(
if (curr_bytes_written != curr_size) { curr_addr, ubuf + bytes_written, curr_size, error);
// We weren't able to write all of the requested bytes, we are bytes_written += curr_bytes_written;
// done looping and will return the number of bytes that we have if (curr_bytes_written != curr_size) {
// written so far. // We weren't able to write all of the requested bytes, we are
if (error.Success()) // done looping and will return the number of bytes that we have
error.SetErrorToGenericError(); // written so far.
} if (error.Success())
error.SetErrorToGenericError();
} }
// Now write any bytes that would cover up any software breakpoints
// directly into the breakpoint opcode buffer
::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset,
ubuf + bytes_written, intersect_size);
bytes_written += intersect_size;
} }
}); // Now write any bytes that would cover up any software breakpoints
// directly into the breakpoint opcode buffer
::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset,
ubuf + bytes_written, intersect_size);
bytes_written += intersect_size;
}
});
if (bytes_written < size)
WriteMemoryPrivate(addr + bytes_written, ubuf + bytes_written,
size - bytes_written, error);
if (bytes_written < size)
WriteMemoryPrivate(addr + bytes_written, ubuf + bytes_written,
size - bytes_written, error);
}
} else { } else {
return WriteMemoryPrivate(addr, buf, size, error); return WriteMemoryPrivate(addr, buf, size, error);
} }
Context not available.
scalar.GetAsMemoryData(buf, byte_size, GetByteOrder(), error); scalar.GetAsMemoryData(buf, byte_size, GetByteOrder(), error);
if (mem_size > 0) if (mem_size > 0)
return WriteMemory(addr, buf, mem_size, error); return WriteMemory(addr, buf, mem_size, error);
else
error.SetErrorString("failed to get scalar as memory data"); error.SetErrorString("failed to get scalar as memory data");
} else { } else {
error.SetErrorString("invalid scalar value"); error.SetErrorString("invalid scalar value");
} }
Context not available.
RequestResume(); RequestResume();
return eEventActionRetry; return eEventActionRetry;
} else {
if (log)
log->Printf("Process::AttachCompletionHandler::%s state %s: no more "
"execs expected to start, continuing with attach",
__FUNCTION__, StateAsCString(state));
m_process->CompleteAttach();
return eEventActionSuccess;
} }
if (log)
log->Printf("Process::AttachCompletionHandler::%s state %s: no more "
"execs expected to start, continuing with attach",
__FUNCTION__, StateAsCString(state));
m_process->CompleteAttach();
return eEventActionSuccess;
break; break;
default: default:
Context not available.
ListenerSP ProcessAttachInfo::GetListenerForProcess(Debugger &debugger) { ListenerSP ProcessAttachInfo::GetListenerForProcess(Debugger &debugger) {
if (m_listener_sp) if (m_listener_sp)
return m_listener_sp; return m_listener_sp;
else
return debugger.GetListener(); return debugger.GetListener();
} }
Status Process::Attach(ProcessAttachInfo &attach_info) { Status Process::Attach(ProcessAttachInfo &attach_info) {
Context not available.
log->Printf("Process::%s() Process exited while waiting to stop.", log->Printf("Process::%s() Process exited while waiting to stop.",
__FUNCTION__); __FUNCTION__);
return error; return error;
} else }
exit_event_sp.reset(); // It is ok to consume any non-exit stop events exit_event_sp.reset(); // It is ok to consume any non-exit stop events
if (state != eStateStopped) { if (state != eStateStopped) {
if (log) if (log)
Context not available.
if (!error.Success()) { if (!error.Success()) {
m_destroy_in_process = false; m_destroy_in_process = false;
return error; return error;
} else if (exit_event_sp) { }
if (exit_event_sp) {
// We shouldn't need to do anything else here. There's no process left // We shouldn't need to do anything else here. There's no process left
// to detach from... // to detach from...
StopPrivateStateThread(); StopPrivateStateThread();
Context not available.
if (m_private_state_thread.IsJoinable()) { if (m_private_state_thread.IsJoinable()) {
ResumePrivateStateThread(); ResumePrivateStateThread();
return true; return true;
} else }
return false; return false;
} }
void Process::PausePrivateStateThread() { void Process::PausePrivateStateThread() {
Context not available.
} }
continue; continue;
} else if (event_sp->GetType() == eBroadcastBitInterrupt) { }
if (event_sp->GetType() == eBroadcastBitInterrupt) {
if (m_public_state.GetValue() == eStateAttaching) { if (m_public_state.GetValue() == eStateAttaching) {
if (log) if (log)
log->Printf("Process::%s (arg = %p, pid = %" PRIu64 log->Printf("Process::%s (arg = %p, pid = %" PRIu64
Context not available.
const ProcessEventData *data = GetEventDataFromEvent(event_ptr); const ProcessEventData *data = GetEventDataFromEvent(event_ptr);
if (data == nullptr) if (data == nullptr)
return eStateInvalid; return eStateInvalid;
else
return data->GetState(); return data->GetState();
} }
bool Process::ProcessEventData::GetRestartedFromEvent(const Event *event_ptr) { bool Process::ProcessEventData::GetRestartedFromEvent(const Event *event_ptr) {
const ProcessEventData *data = GetEventDataFromEvent(event_ptr); const ProcessEventData *data = GetEventDataFromEvent(event_ptr);
if (data == nullptr) if (data == nullptr)
return false; return false;
else
return data->GetRestarted(); return data->GetRestarted();
} }
void Process::ProcessEventData::SetRestartedInEvent(Event *event_ptr, void Process::ProcessEventData::SetRestartedInEvent(Event *event_ptr,
Context not available.
const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr)); const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
if (data != nullptr) if (data != nullptr)
return data->GetNumRestartedReasons(); return data->GetNumRestartedReasons();
else
return 0; return 0;
} }
const char * const char *
Context not available.
const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr)); const_cast<ProcessEventData *>(GetEventDataFromEvent(event_ptr));
if (data != nullptr) if (data != nullptr)
return data->GetRestartedReasonAtIndex(idx); return data->GetRestartedReasonAtIndex(idx);
else
return nullptr; return nullptr;
} }
void Process::ProcessEventData::AddRestartedReason(Event *event_ptr, void Process::ProcessEventData::AddRestartedReason(Event *event_ptr,
Context not available.
const ProcessEventData *data = GetEventDataFromEvent(event_ptr); const ProcessEventData *data = GetEventDataFromEvent(event_ptr);
if (data == nullptr) if (data == nullptr)
return false; return false;
else
return data->GetInterrupted(); return data->GetInterrupted();
} }
void Process::ProcessEventData::SetInterruptedInEvent(Event *event_ptr, void Process::ProcessEventData::SetInterruptedInEvent(Event *event_ptr,
Context not available.
auto find_it = m_structured_data_plugin_map.find(type_name); auto find_it = m_structured_data_plugin_map.find(type_name);
if (find_it != m_structured_data_plugin_map.end()) if (find_it != m_structured_data_plugin_map.end())
return find_it->second; return find_it->second;
else
return StructuredDataPluginSP(); return StructuredDataPluginSP();
} }
size_t Process::GetAsyncProfileData(char *buf, size_t buf_size, Status &error) { size_t Process::GetAsyncProfileData(char *buf, size_t buf_size, Status &error) {
Context not available.
size_t bytes_written = 0; size_t bytes_written = 0;
Status result = m_pipe.Write(&ch, 1, bytes_written); Status result = m_pipe.Write(&ch, 1, bytes_written);
return result.Success(); return result.Success();
} else {
// This IOHandler might be pushed on the stack, but not being run
// currently so do the right thing if we aren't actively watching for
// STDIN by sending the interrupt to the process. Otherwise the write to
// the pipe above would do nothing. This can happen when the command
// interpreter is running and gets a "expression ...". It will be on the
// IOHandler thread and sending the input is complete to the delegate
// which will cause the expression to run, which will push the process IO
// handler, but not run it.
if (StateIsRunningState(m_process->GetState())) {
m_process->SendAsyncInterrupt();
return true;
}
} }
return false; // This IOHandler might be pushed on the stack, but not being run
// currently so do the right thing if we aren't actively watching for
// STDIN by sending the interrupt to the process. Otherwise the write to
// the pipe above would do nothing. This can happen when the command
// interpreter is running and gets a "expression ...". It will be on the
// IOHandler thread and sending the input is complete to the delegate
// which will cause the expression to run, which will push the process IO
// handler, but not run it.
if (StateIsRunningState(m_process->GetState())) {
m_process->SendAsyncInterrupt();
return true;
}
return false;
} }
void GotEOF() override {} void GotEOF() override {}
Context not available.
if (!options.GetTimeout()) if (!options.GetTimeout())
return llvm::None; return llvm::None;
else
return *options.GetTimeout() - GetOneThreadExpressionTimeout(options); return *options.GetTimeout() - GetOneThreadExpressionTimeout(options);
} }
static llvm::Optional<ExpressionResults> static llvm::Optional<ExpressionResults>
Context not available.
log->Printf("Process::RunThreadPlan(): Got interrupted by " log->Printf("Process::RunThreadPlan(): Got interrupted by "
"eBroadcastBitInterrupted, exiting."); "eBroadcastBitInterrupted, exiting.");
break; break;
} else { }
stop_state = stop_state =
Process::ProcessEventData::GetStateFromEvent(event_sp.get()); Process::ProcessEventData::GetStateFromEvent(event_sp.get());
if (log) if (log)
log->Printf( log->Printf(
"Process::RunThreadPlan(): in while loop, got event: %s.", "Process::RunThreadPlan(): in while loop, got event: %s.",
StateAsCString(stop_state)); StateAsCString(stop_state));
switch (stop_state) { switch (stop_state) {
case lldb::eStateStopped: { case lldb::eStateStopped: {
// We stopped, figure out what we are going to do now. // We stopped, figure out what we are going to do now.
ThreadSP thread_sp = ThreadSP thread_sp =
GetThreadList().FindThreadByIndexID(thread_idx_id); GetThreadList().FindThreadByIndexID(thread_idx_id);
if (!thread_sp) { if (!thread_sp) {
// Ooh, our thread has vanished. Unlikely that this was // Ooh, our thread has vanished. Unlikely that this was
// successful execution... // successful execution...
if (log) if (log)
log->Printf("Process::RunThreadPlan(): execution completed " log->Printf("Process::RunThreadPlan(): execution completed "
"but our thread (index-id=%u) has vanished.", "but our thread (index-id=%u) has vanished.",
thread_idx_id); thread_idx_id);
return_value = eExpressionInterrupted; return_value = eExpressionInterrupted;
} else if (Process::ProcessEventData::GetRestartedFromEvent( } else if (Process::ProcessEventData::GetRestartedFromEvent(
event_sp.get())) { event_sp.get())) {
// If we were restarted, we just need to go back up to fetch // If we were restarted, we just need to go back up to fetch
// another event. // another event.
if (log) { if (log) {
log->Printf("Process::RunThreadPlan(): Got a stop and " log->Printf("Process::RunThreadPlan(): Got a stop and "
"restart, so we'll continue waiting."); "restart, so we'll continue waiting.");
}
keep_going = true;
do_resume = false;
handle_running_event = true;
} else {
const bool handle_interrupts = true;
return_value = *HandleStoppedEvent(
*thread, thread_plan_sp, thread_plan_restorer, event_sp,
event_to_broadcast_sp, options, handle_interrupts);
} }
keep_going = true;
do_resume = false;
handle_running_event = true;
} else {
const bool handle_interrupts = true;
return_value = *HandleStoppedEvent(
*thread, thread_plan_sp, thread_plan_restorer, event_sp,
event_to_broadcast_sp, options, handle_interrupts);
}
aprantlUnsubmitted
Not Done
ReplyInline Actions

wouldn't hurt to manually check this one, too

aprantl: wouldn't hurt to manually check this one, too
} break; } break;
case lldb::eStateRunning: case lldb::eStateRunning:
Context not available.
return_value = eExpressionInterrupted; return_value = eExpressionInterrupted;
break; break;
} }
}
if (keep_going) if (keep_going)
continue; continue;
else
break; break;
} else { } else {
if (log) if (log)
log->PutCString("Process::RunThreadPlan(): got_event was true, but " log->PutCString("Process::RunThreadPlan(): got_event was true, but "
Context not available.
back_to_top = true; back_to_top = true;
break; break;
} else {
// Running all threads failed, so return Interrupted.
if (log)
log->PutCString("Process::RunThreadPlan(): running all "
"threads timed out.");
return_value = eExpressionInterrupted;
back_to_top = false;
break;
} }
// Running all threads failed, so return Interrupted.
if (log)
log->PutCString("Process::RunThreadPlan(): running all "
"threads timed out.");
return_value = eExpressionInterrupted;
back_to_top = false;
break;
} }
} else { } else {
if (log) if (log)
Context not available.
if (!back_to_top || try_halt_again > num_retries) if (!back_to_top || try_halt_again > num_retries)
break; break;
else
continue; continue;
} }
} // END WAIT LOOP } // END WAIT LOOP
Context not available.
if (!event_sp) { if (!event_sp) {
event_explanation = "<no event>"; event_explanation = "<no event>";
break; break;
} else if (event_sp->GetType() == eBroadcastBitInterrupt) { }
if (event_sp->GetType() == eBroadcastBitInterrupt) {
event_explanation = "<user interrupt>"; event_explanation = "<user interrupt>";
break; break;
} else { } else {
Context not available.
ProcessRunLock &Process::GetRunLock() { ProcessRunLock &Process::GetRunLock() {
if (m_private_state_thread.EqualsThread(Host::GetCurrentThread())) if (m_private_state_thread.EqualsThread(Host::GetCurrentThread()))
return m_private_run_lock; return m_private_run_lock;
else
return m_public_run_lock; return m_public_run_lock;
} }
void Process::Flush() { void Process::Flush() {
Context not available.
pos = m_instrumentation_runtimes.find(type); pos = m_instrumentation_runtimes.find(type);
if (pos == m_instrumentation_runtimes.end()) { if (pos == m_instrumentation_runtimes.end()) {
return InstrumentationRuntimeSP(); return InstrumentationRuntimeSP();
} else }
return (*pos).second; return (*pos).second;
} }
bool Process::GetModuleSpec(const FileSpec &module_file_spec, bool Process::GetModuleSpec(const FileSpec &module_file_spec,
Context not available.

source/Target/ProcessLaunchInfo.cpp

Context not available.
m_executable = m_shell; m_executable = m_shell;
m_arguments = shell_arguments; m_arguments = shell_arguments;
return true; return true;
} else {
error.SetErrorString("invalid shell path");
} }
error.SetErrorString("invalid shell path");
} else { } else {
error.SetErrorString("not launching in shell"); error.SetErrorString("not launching in shell");
} }
Context not available.
ListenerSP ProcessLaunchInfo::GetListenerForProcess(Debugger &debugger) { ListenerSP ProcessLaunchInfo::GetListenerForProcess(Debugger &debugger) {
if (m_listener_sp) if (m_listener_sp)
return m_listener_sp; return m_listener_sp;
else
return debugger.GetListener(); return debugger.GetListener();
} }
Context not available.

source/Target/QueueList.cpp

Context not available.
std::lock_guard<std::mutex> guard(m_mutex); std::lock_guard<std::mutex> guard(m_mutex);
if (idx < m_queues.size()) { if (idx < m_queues.size()) {
return m_queues[idx]; return m_queues[idx];
} else {
return QueueSP();
} }
return QueueSP();
} }
void QueueList::Clear() { void QueueList::Clear() {
Context not available.

source/Target/RegisterNumber.cpp

Context not available.
if (m_kind == rhs.m_kind) { if (m_kind == rhs.m_kind) {
if (m_regnum == rhs.m_regnum) if (m_regnum == rhs.m_regnum)
return true; return true;
else
return false; 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) if (m_regnum == rhs_regnum)
return true; return true;
else
return false; return false;
} }
uint32_t lhs_regnum = GetAsKind(rhs.m_kind); uint32_t lhs_regnum = GetAsKind(rhs.m_kind);
{ {
if (lhs_regnum == rhs.m_regnum) if (lhs_regnum == rhs.m_regnum)
return true; return true;
else
return false; return false;
} }
return false; return false;
} }
Context not available.

source/Target/SectionLoadHistory.cpp

Context not available.
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (m_stop_id_to_section_load_list.empty()) if (m_stop_id_to_section_load_list.empty())
return 0; return 0;
else
return m_stop_id_to_section_load_list.rbegin()->first; return m_stop_id_to_section_load_list.rbegin()->first;
} }
SectionLoadList * SectionLoadList *
Context not available.
StopIDToSectionLoadList::reverse_iterator rpos = StopIDToSectionLoadList::reverse_iterator rpos =
m_stop_id_to_section_load_list.rbegin(); m_stop_id_to_section_load_list.rbegin();
return rpos->second.get(); return rpos->second.get();
} else {
StopIDToSectionLoadList::iterator pos =
m_stop_id_to_section_load_list.lower_bound(stop_id);
if (pos != m_stop_id_to_section_load_list.end() &&
pos->first == stop_id)
return pos->second.get();
else if (pos != m_stop_id_to_section_load_list.begin()) {
--pos;
return pos->second.get();
}
} }
StopIDToSectionLoadList::iterator pos =
m_stop_id_to_section_load_list.lower_bound(stop_id);
if (pos != m_stop_id_to_section_load_list.end() && pos->first == stop_id)
return pos->second.get();
if (pos != m_stop_id_to_section_load_list.begin()) {
--pos;
return pos->second.get();
}
} else { } else {
// You can only use "eStopIDNow" when reading from the section load // You can only use "eStopIDNow" when reading from the section load
// history // history
Context not available.

source/Target/SectionLoadList.cpp

Context not available.
if (sta_pos != m_sect_to_addr.end()) { if (sta_pos != m_sect_to_addr.end()) {
if (load_addr == sta_pos->second) if (load_addr == sta_pos->second)
return false; // No change... return false; // No change...
else
sta_pos->second = load_addr; sta_pos->second = load_addr;
} else } else
m_sect_to_addr[section.get()] = load_addr; m_sect_to_addr[section.get()] = load_addr;
Context not available.
} else } else
m_addr_to_sect[load_addr] = section; m_addr_to_sect[load_addr] = section;
return true; // Changed return true; // Changed
} else {
if (log) {
log->Printf(
"SectionLoadList::%s (section = %p (%s), load_addr = 0x%16.16" PRIx64
") error: module has been deleted",
__FUNCTION__, static_cast<void *>(section.get()),
section->GetName().AsCString(), load_addr);
}
} }
if (log) {
log->Printf(
"SectionLoadList::%s (section = %p (%s), load_addr = 0x%16.16" PRIx64
") error: module has been deleted",
__FUNCTION__, static_cast<void *>(section.get()),
section->GetName().AsCString(), load_addr);
}
return false; return false;
} }
Context not available.

source/Target/StackFrame.cpp

Context not available.
if (thread_sp) if (thread_sp)
return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex( return thread_sp->GetStackFrameList()->GetVisibleStackFrameIndex(
m_frame_index); m_frame_index);
else
return m_frame_index; return m_frame_index;
} }
void StackFrame::SetSymbolContextScope(SymbolContextScope *symbol_scope) { void StackFrame::SetSymbolContextScope(SymbolContextScope *symbol_scope) {
Context not available.
// want this frame to have only the variables for the inlined function // want this frame to have only the variables for the inlined function
// and its non-inlined block child blocks. // and its non-inlined block child blocks.
return inline_block; return inline_block;
} else {
// This block is not contained within any inlined function blocks with so
// we want to use the top most function block.
return &m_sc.function->GetBlock(false);
} }
// This block is not contained within any inlined function blocks with so
// we want to use the top most function block.
return &m_sc.function->GetBlock(false);
} }
return nullptr; return nullptr;
} }
Context not available.
var_expr_path_strm.GetData()); var_expr_path_strm.GetData());
return ValueObjectSP(); return ValueObjectSP();
} else if (is_objc_pointer) { }
if (is_objc_pointer) {
// dereferencing ObjC variables is not valid.. so let's try and // dereferencing ObjC variables is not valid.. so let's try and
// recur to synthetic children // recur to synthetic children
ValueObjectSP synthetic = valobj_sp->GetSyntheticValue(); ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
Context not available.
} }
if (reg_value.GetAsUInt64() == value) { if (reg_value.GetAsUInt64() == value) {
return std::make_pair(&operand, 0); return std::make_pair(&operand, 0);
} else {
return std::make_pair(nullptr, 0);
} }
return std::make_pair(nullptr, 0);
} }
} }
return std::make_pair(nullptr, 0); return std::make_pair(nullptr, 0);
Context not available.
target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC); target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
if (!c_type_system) { if (!c_type_system) {
return ValueObjectSP(); return ValueObjectSP();
} else {
CompilerType void_ptr_type =
c_type_system
->GetBasicTypeFromAST(lldb::BasicType::eBasicTypeChar)
.GetPointerType();
return ValueObjectMemory::Create(this, "", addr, void_ptr_type);
} }
CompilerType void_ptr_type =
c_type_system->GetBasicTypeFromAST(lldb::BasicType::eBasicTypeChar)
.GetPointerType();
return ValueObjectMemory::Create(this, "", addr, void_ptr_type);
} else { } else {
return ValueObjectSP(); return ValueObjectSP();
} }
Context not available.
if (offset == 0) { if (offset == 0) {
return parent; return parent;
} else {
return ValueObjectSP();
} }
return ValueObjectSP();
} }
ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame, ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame,
Context not available.

source/Target/StackFrameList.cpp

Context not available.
"GetCurrentInlinedDepth: invalidating current inlined depth.\n"); "GetCurrentInlinedDepth: invalidating current inlined depth.\n");
} }
return m_current_inlined_depth; return m_current_inlined_depth;
} else {
return UINT32_MAX;
} }
return UINT32_MAX;
} }
void StackFrameList::ResetCurrentInlinedDepth() { void StackFrameList::ResetCurrentInlinedDepth() {
Context not available.
if (frame_sp) { if (frame_sp) {
SetSelectedFrame(frame_sp.get()); SetSelectedFrame(frame_sp.get());
return true; return true;
} else }
return false; return false;
} }
void StackFrameList::SetDefaultFileAndLineToSelectedFrame() { void StackFrameList::SetDefaultFileAndLineToSelectedFrame() {
Context not available.

source/Target/StopInfo.cpp

Context not available.
lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState(); lldb::StateType ret_type = thread_sp->GetProcess()->GetPrivateState();
if (ret_type == eStateRunning) { if (ret_type == eStateRunning) {
return true; return true;
} else if (ret_type == eStateStopped) { }
if (ret_type == eStateStopped) {
// This is a little tricky. We want to count "run and stopped again // This is a little tricky. We want to count "run and stopped again
// before you could ask this question as a "TRUE" answer to // before you could ask this question as a "TRUE" answer to
// HasTargetRunSinceMe. But we don't want to include any running of the // HasTargetRunSinceMe. But we don't want to include any running of the
Context not available.
thread_sp->GetProcess()->GetLastUserExpressionResumeID(); thread_sp->GetProcess()->GetLastUserExpressionResumeID();
if (curr_resume_id == m_resume_id) { if (curr_resume_id == m_resume_id) {
return false; return false;
} else if (curr_resume_id > last_user_expression_id) { }
if (curr_resume_id > last_user_expression_id) {
return true; return true;
} }
} }
Context not available.
const char *GetDescription() override { const char *GetDescription() override {
if (m_description.empty()) if (m_description.empty())
return "trace"; return "trace";
else
return m_description.c_str(); return m_description.c_str();
} }
}; };
Context not available.
const char *GetDescription() override { const char *GetDescription() override {
if (m_description.empty()) if (m_description.empty())
return "exception"; return "exception";
else
return m_description.c_str(); return m_description.c_str();
} }
}; };
Context not available.
bool ShouldStop(Event *event_ptr) override { bool ShouldStop(Event *event_ptr) override {
if (m_plan_sp) if (m_plan_sp)
return m_plan_sp->ShouldStop(event_ptr); return m_plan_sp->ShouldStop(event_ptr);
else
return StopInfo::ShouldStop(event_ptr); return StopInfo::ShouldStop(event_ptr);
} }
private: private:
Context not available.
StopInfoThreadPlan *plan_stop_info = StopInfoThreadPlan *plan_stop_info =
static_cast<StopInfoThreadPlan *>(stop_info_sp.get()); static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
return plan_stop_info->GetReturnValueObject(); return plan_stop_info->GetReturnValueObject();
} else }
return ValueObjectSP(); return ValueObjectSP();
} }
ExpressionVariableSP StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp) { ExpressionVariableSP StopInfo::GetExpressionVariable(StopInfoSP &stop_info_sp) {
Context not available.
StopInfoThreadPlan *plan_stop_info = StopInfoThreadPlan *plan_stop_info =
static_cast<StopInfoThreadPlan *>(stop_info_sp.get()); static_cast<StopInfoThreadPlan *>(stop_info_sp.get());
return plan_stop_info->GetExpressionVariable(); return plan_stop_info->GetExpressionVariable();
} else }
return ExpressionVariableSP(); return ExpressionVariableSP();
} }
lldb::ValueObjectSP lldb::ValueObjectSP
Context not available.

source/Target/Target.cpp

Context not available.
BreakpointList &Target::GetBreakpointList(bool internal) { BreakpointList &Target::GetBreakpointList(bool internal) {
if (internal) if (internal)
return m_internal_breakpoint_list; return m_internal_breakpoint_list;
else
return m_breakpoint_list; return m_breakpoint_list;
} }
const BreakpointList &Target::GetBreakpointList(bool internal) const { const BreakpointList &Target::GetBreakpointList(bool internal) const {
if (internal) if (internal)
return m_internal_breakpoint_list; return m_internal_breakpoint_list;
else
return m_breakpoint_list; return m_breakpoint_list;
} }
BreakpointSP Target::GetBreakpointByID(break_id_t break_id) { BreakpointSP Target::GetBreakpointByID(break_id_t break_id) {
Context not available.
StructuredData::ParseJSONFromFile(file, error); StructuredData::ParseJSONFromFile(file, error);
if (!error.Success()) { if (!error.Success()) {
return error; return error;
} else if (!input_data_sp || !input_data_sp->IsValid()) { }
if (!input_data_sp || !input_data_sp->IsValid()) {
error.SetErrorStringWithFormat("Invalid JSON from input file: %s.", error.SetErrorStringWithFormat("Invalid JSON from input file: %s.",
file.GetPath().c_str()); file.GetPath().c_str());
return error; return error;
Context not available.
ArchSpec merged_arch(m_arch.GetSpec()); ArchSpec merged_arch(m_arch.GetSpec());
merged_arch.MergeFrom(arch_spec); merged_arch.MergeFrom(arch_spec);
return SetArchitecture(merged_arch); return SetArchitecture(merged_arch);
} else {
// The new architecture is different, we just need to replace it
return SetArchitecture(arch_spec);
} }
// The new architecture is different, we just need to replace it
return SetArchitecture(arch_spec);
} }
return false; return false;
} }
Context not available.
section_sp.get(), addr.GetOffset(), dst, dst_len); section_sp.get(), addr.GetOffset(), dst, dst_len);
if (bytes_read > 0) if (bytes_read > 0)
return bytes_read; return bytes_read;
else
error.SetErrorStringWithFormat("error reading data from section %s", error.SetErrorStringWithFormat("error reading data from section %s",
section_sp->GetName().GetCString()); section_sp->GetName().GetCString());
} else } else
error.SetErrorString("address isn't from a object file"); error.SetErrorString("address isn't from a object file");
} else } else
Context not available.
} else { } else {
if (languages_for_expressions.empty()) { if (languages_for_expressions.empty()) {
return nullptr; return nullptr;
} else {
language = *languages_for_expressions.begin();
} }
language = *languages_for_expressions.begin();
} }
} }
Context not available.
if (type_system) { if (type_system) {
return type_system->GetPersistentExpressionState(); return type_system->GetPersistentExpressionState();
} else {
return nullptr;
} }
return nullptr;
} }
UserExpression *Target::GetUserExpressionForLanguage( UserExpression *Target::GetUserExpressionForLanguage(
Context not available.
if (exp_values) if (exp_values)
return exp_values->GetPropertyAtIndexAsBoolean( return exp_values->GetPropertyAtIndexAsBoolean(
exe_ctx, ePropertyInjectLocalVars, true); exe_ctx, ePropertyInjectLocalVars, true);
else
return true; return true;
} }
void TargetProperties::SetInjectLocalVariables(ExecutionContext *exe_ctx, void TargetProperties::SetInjectLocalVariables(ExecutionContext *exe_ctx,
Context not available.
if (exp_values) if (exp_values)
return exp_values->GetPropertyAtIndexAsBoolean( return exp_values->GetPropertyAtIndexAsBoolean(
nullptr, ePropertyUseModernTypeLookup, true); nullptr, ePropertyUseModernTypeLookup, true);
else
return true; return true;
} }
ArchSpec TargetProperties::GetDefaultArchitecture() const { ArchSpec TargetProperties::GetDefaultArchitecture() const {
Context not available.

source/Target/Thread.cpp

Context not available.
BroadcastSelectedFrameChange(frame_sp->GetStackID()); BroadcastSelectedFrameChange(frame_sp->GetStackID());
FunctionOptimizationWarning(frame_sp.get()); FunctionOptimizationWarning(frame_sp.get());
return true; return true;
} else }
return false; return false;
} }
bool Thread::SetSelectedFrameByIndexNoisily(uint32_t frame_idx, bool Thread::SetSelectedFrameByIndexNoisily(uint32_t frame_idx,
Context not available.
return frame_sp->GetStatus(output_stream, show_frame_info, show_source); return frame_sp->GetStatus(output_stream, show_frame_info, show_source);
} }
return false; return false;
} else }
return false; return false;
} }
void Thread::FunctionOptimizationWarning(StackFrame *frame) { void Thread::FunctionOptimizationWarning(StackFrame *frame) {
Context not available.
if (have_valid_stop_info && !plan_overrides_trace && !plan_failed) { if (have_valid_stop_info && !plan_overrides_trace && !plan_failed) {
return m_stop_info_sp; return m_stop_info_sp;
} else if (completed_plan_sp) { }
if (completed_plan_sp) {
return StopInfo::CreateStopReasonWithPlan( return StopInfo::CreateStopReasonWithPlan(
completed_plan_sp, GetReturnValueObject(), GetExpressionVariable()); completed_plan_sp, GetReturnValueObject(), GetExpressionVariable());
} else { } else {
Context not available.
ProcessSP process_sp(GetProcess()); ProcessSP process_sp(GetProcess());
if (process_sp) if (process_sp)
return m_stop_info_stop_id == process_sp->GetStopID(); return m_stop_info_stop_id == process_sp->GetStopID();
else
return true; // Process is no longer around so stop info is always up to return true; // Process is no longer around so stop info is always up to
// date... // date...
} }
void Thread::ResetStopInfo() { void Thread::ResetStopInfo() {
Context not available.
void Thread::SetShouldReportStop(Vote vote) { void Thread::SetShouldReportStop(Vote vote) {
if (vote == eVoteNoOpinion) if (vote == eVoteNoOpinion)
return; return;
else {
m_override_should_notify = (vote == eVoteYes ? eLazyBoolYes : eLazyBoolNo); m_override_should_notify = (vote == eVoteYes ? eLazyBoolYes : eLazyBoolNo);
if (m_stop_info_sp) if (m_stop_info_sp)
m_stop_info_sp->OverrideShouldNotify(m_override_should_notify == m_stop_info_sp->OverrideShouldNotify(m_override_should_notify ==
eLazyBoolYes); eLazyBoolYes);
}
} }
void Thread::SetStopInfoToNothing() { void Thread::SetStopInfoToNothing() {
Context not available.
!current_plan->OkayToDiscard()) { !current_plan->OkayToDiscard()) {
PopPlan(); PopPlan();
break; break;
} else { }
PopPlan(); PopPlan();
current_plan = GetCurrentPlan(); current_plan = GetCurrentPlan();
if (current_plan == nullptr) { if (current_plan == nullptr) {
break; break;
} }
}
} else { } else {
break; break;
} }
Context not available.
": returning vote for complete stack's back plan", ": returning vote for complete stack's back plan",
GetID()); GetID());
return m_completed_plan_stack.back()->ShouldReportStop(event_ptr); return m_completed_plan_stack.back()->ShouldReportStop(event_ptr);
} else { }
Vote thread_vote = eVoteNoOpinion; Vote thread_vote = eVoteNoOpinion;
ThreadPlan *plan_ptr = GetCurrentPlan(); ThreadPlan *plan_ptr = GetCurrentPlan();
while (1) { while (1) {
if (plan_ptr->PlanExplainsStop(event_ptr)) { if (plan_ptr->PlanExplainsStop(event_ptr)) {
thread_vote = plan_ptr->ShouldReportStop(event_ptr); thread_vote = plan_ptr->ShouldReportStop(event_ptr);
break; break;
} }
if (PlanIsBasePlan(plan_ptr)) if (PlanIsBasePlan(plan_ptr))
break; break;
else
plan_ptr = GetPreviousPlan(plan_ptr); plan_ptr = GetPreviousPlan(plan_ptr);
} }
if (log) if (log)
log->Printf("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64 log->Printf("Thread::ShouldReportStop() tid = 0x%4.4" PRIx64
Context not available.
GetID(), thread_vote); GetID(), thread_vote);
return thread_vote; return thread_vote;
}
} }
Vote Thread::ShouldReportRun(Event *event_ptr) { Vote Thread::ShouldReportRun(Event *event_ptr) {
Context not available.
m_completed_plan_stack.back()->GetName()); m_completed_plan_stack.back()->GetName());
return m_completed_plan_stack.back()->ShouldReportRun(event_ptr); return m_completed_plan_stack.back()->ShouldReportRun(event_ptr);
} else {
if (log)
log->Printf("Current Plan for thread %d(%p) (0x%4.4" PRIx64
", %s): %s being asked whether we should report run.",
GetIndexID(), static_cast<void *>(this), GetID(),
StateAsCString(GetTemporaryResumeState()),
GetCurrentPlan()->GetName());
return GetCurrentPlan()->ShouldReportRun(event_ptr);
} }
if (log)
log->Printf("Current Plan for thread %d(%p) (0x%4.4" PRIx64
", %s): %s being asked whether we should report run.",
GetIndexID(), static_cast<void *>(this), GetID(),
StateAsCString(GetTemporaryResumeState()),
GetCurrentPlan()->GetName());
return GetCurrentPlan()->ShouldReportRun(event_ptr);
} }
bool Thread::MatchesSpec(const ThreadSpec *spec) { bool Thread::MatchesSpec(const ThreadSpec *spec) {
Context not available.
if (m_plan_stack.size() <= 1) if (m_plan_stack.size() <= 1)
return; return;
else {
ThreadPlanSP &plan = m_plan_stack.back(); ThreadPlanSP &plan = m_plan_stack.back();
if (log) { if (log) {
log->Printf("Popping plan: \"%s\", tid = 0x%4.4" PRIx64 ".", log->Printf("Popping plan: \"%s\", tid = 0x%4.4" PRIx64 ".",
plan->GetName(), plan->GetThread().GetID()); plan->GetName(), plan->GetThread().GetID());
} }
m_completed_plan_stack.push_back(plan); m_completed_plan_stack.push_back(plan);
plan->WillPop(); plan->WillPop();
m_plan_stack.pop_back(); m_plan_stack.pop_back();
}
} }
void Thread::DiscardPlan() { void Thread::DiscardPlan() {
Context not available.
if (idx == thread_index) { if (idx == thread_index) {
up_to_plan_ptr = plan_sp.get(); up_to_plan_ptr = plan_sp.get();
break; break;
} else }
idx++; idx++;
} }
if (up_to_plan_ptr == nullptr) if (up_to_plan_ptr == nullptr)
Context not available.
bool Thread::PlanIsBasePlan(ThreadPlan *plan_ptr) { bool Thread::PlanIsBasePlan(ThreadPlan *plan_ptr) {
if (plan_ptr->IsBasePlan()) if (plan_ptr->IsBasePlan())
return true; return true;
else if (m_plan_stack.size() == 0) if (m_plan_stack.size() == 0)
return false; return false;
else else
return m_plan_stack[0].get() == plan_ptr; return m_plan_stack[0].get() == plan_ptr;
Context not available.
if (outside_function.empty()) { if (outside_function.empty()) {
return Status("Cannot locate an address for %s:%i.", return Status("Cannot locate an address for %s:%i.",
file.GetFilename().AsCString(), line); file.GetFilename().AsCString(), line);
} else if (outside_function.size() == 1) { }
if (outside_function.size() == 1) {
return Status("%s:%i is outside the current function.", return Status("%s:%i is outside the current function.",
file.GetFilename().AsCString(), line); file.GetFilename().AsCString(), line);
} else { } else {
Context not available.
if (loader) if (loader)
return loader->GetThreadLocalData(module, shared_from_this(), return loader->GetThreadLocalData(module, shared_from_this(),
tls_file_addr); tls_file_addr);
else
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
} }
bool Thread::SafeToCallFunctions() { bool Thread::SafeToCallFunctions() {
Context not available.

source/Target/ThreadList.cpp

Context not available.
ThreadSP expr_thread_sp = FindThreadByID(m_expression_tid_stack.back()); ThreadSP expr_thread_sp = FindThreadByID(m_expression_tid_stack.back());
if (expr_thread_sp) if (expr_thread_sp)
return expr_thread_sp; return expr_thread_sp;
else
return GetSelectedThread(); return GetSelectedThread();
} }
void ThreadList::PushExpressionExecutionThread(lldb::tid_t tid) { void ThreadList::PushExpressionExecutionThread(lldb::tid_t tid) {
Context not available.

source/Target/ThreadPlan.cpp

Context not available.
bool actual_value = DoPlanExplainsStop(event_ptr); bool actual_value = DoPlanExplainsStop(event_ptr);
m_cached_plan_explains_stop = actual_value ? eLazyBoolYes : eLazyBoolNo; m_cached_plan_explains_stop = actual_value ? eLazyBoolYes : eLazyBoolNo;
return actual_value; return actual_value;
} else {
return m_cached_plan_explains_stop == eLazyBoolYes;
} }
return m_cached_plan_explains_stop == eLazyBoolYes;
} }
bool ThreadPlan::IsPlanComplete() { bool ThreadPlan::IsPlanComplete() {
Context not available.
if (m_tracer_sp && m_tracer_sp->TracingEnabled() && if (m_tracer_sp && m_tracer_sp->TracingEnabled() &&
m_tracer_sp->SingleStepEnabled()) m_tracer_sp->SingleStepEnabled())
return eStateStepping; return eStateStepping;
else
return GetPlanRunState(); return GetPlanRunState();
} }
bool ThreadPlan::IsUsuallyUnexplainedStopReason(lldb::StopReason reason) { bool ThreadPlan::IsUsuallyUnexplainedStopReason(lldb::StopReason reason) {
Context not available.

source/Target/ThreadPlanBase.cpp

Context not available.
// handles the stop. // handles the stop.
if (TracerExplainsStop()) if (TracerExplainsStop())
return false; return false;
else
return true; return true;
} }
Vote ThreadPlanBase::ShouldReportStop(Event *event_ptr) { Vote ThreadPlanBase::ShouldReportStop(Event *event_ptr) {
Context not available.
bool should_notify = stop_info_sp->ShouldNotify(event_ptr); bool should_notify = stop_info_sp->ShouldNotify(event_ptr);
if (should_notify) if (should_notify)
return eVoteYes; return eVoteYes;
else
return eVoteNoOpinion; return eVoteNoOpinion;
} else } else
return eVoteNoOpinion; return eVoteNoOpinion;
} }
Context not available.

source/Target/ThreadPlanCallFunction.cpp

Context not available.
log->Printf("ThreadPlanCallFunction(%p): %s.", static_cast<void *>(this), log->Printf("ThreadPlanCallFunction(%p): %s.", static_cast<void *>(this),
m_constructor_errors.GetData()); m_constructor_errors.GetData());
return false; return false;
} else { }
ObjectFile *objectFile = exe_module->GetObjectFile(); ObjectFile *objectFile = exe_module->GetObjectFile();
if (!objectFile) { if (!objectFile) {
m_constructor_errors.Printf( m_constructor_errors.Printf(
"Could not find object file for module \"%s\".", "Could not find object file for module \"%s\".",
exe_module->GetFileSpec().GetFilename().AsCString()); exe_module->GetFileSpec().GetFilename().AsCString());
if (log) if (log)
log->Printf("ThreadPlanCallFunction(%p): %s.", log->Printf("ThreadPlanCallFunction(%p): %s.", static_cast<void *>(this),
static_cast<void *>(this), m_constructor_errors.GetData()); m_constructor_errors.GetData());
return false; return false;
} }
m_start_addr = objectFile->GetEntryPointAddress(); m_start_addr = objectFile->GetEntryPointAddress();
Context not available.
static_cast<void *>(this), m_constructor_errors.GetData()); static_cast<void *>(this), m_constructor_errors.GetData());
return false; return false;
} }
}
start_load_addr = m_start_addr.GetLoadAddress(&GetTarget()); start_load_addr = m_start_addr.GetLoadAddress(&GetTarget());
Context not available.
Vote ThreadPlanCallFunction::ShouldReportStop(Event *event_ptr) { Vote ThreadPlanCallFunction::ShouldReportStop(Event *event_ptr) {
if (m_takedown_done || IsPlanComplete()) if (m_takedown_done || IsPlanComplete())
return eVoteYes; return eVoteYes;
else
return ThreadPlan::ShouldReportStop(event_ptr); return ThreadPlan::ShouldReportStop(event_ptr);
} }
bool ThreadPlanCallFunction::DoPlanExplainsStop(Event *event_ptr) { bool ThreadPlanCallFunction::DoPlanExplainsStop(Event *event_ptr) {
Context not available.
"returning true"); "returning true");
m_real_stop_info_sp->OverrideShouldStop(false); m_real_stop_info_sp->OverrideShouldStop(false);
return true; return true;
} else {
if (log)
log->Printf("ThreadPlanCallFunction::PlanExplainsStop: we are not "
"ignoring breakpoints, overriding breakpoint stop info "
"ShouldStop, returning true");
m_real_stop_info_sp->OverrideShouldStop(true);
return false;
} }
if (log)
log->Printf("ThreadPlanCallFunction::PlanExplainsStop: we are not "
"ignoring breakpoints, overriding breakpoint stop info "
"ShouldStop, returning true");
m_real_stop_info_sp->OverrideShouldStop(true);
return false;
} else if (!m_unwind_on_error) { } else if (!m_unwind_on_error) {
// If we don't want to discard this plan, than any stop we don't understand // If we don't want to discard this plan, than any stop we don't understand
// should be propagated up the stack. // should be propagated up the stack.
Context not available.
m_real_stop_info_sp->ShouldStopSynchronous(event_ptr)) { m_real_stop_info_sp->ShouldStopSynchronous(event_ptr)) {
SetPlanComplete(false); SetPlanComplete(false);
return m_subplan_sp ? m_unwind_on_error : false; return m_subplan_sp ? m_unwind_on_error : false;
} else }
return true; return true;
} }
} }
Context not available.
if (IsPlanComplete()) { if (IsPlanComplete()) {
ReportRegisterState("Function completed. Register state was:"); ReportRegisterState("Function completed. Register state was:");
return true; return true;
} else {
return false;
} }
return false;
} }
bool ThreadPlanCallFunction::StopOthers() { return m_stop_other_threads; } bool ThreadPlanCallFunction::StopOthers() { return m_stop_other_threads; }
Context not available.
ThreadPlan::MischiefManaged(); ThreadPlan::MischiefManaged();
return true; return true;
} else {
return false;
} }
return false;
} }
void ThreadPlanCallFunction::SetBreakpoints() { void ThreadPlanCallFunction::SetBreakpoints() {
Context not available.

source/Target/ThreadPlanCallUserExpression.cpp

Context not available.
ThreadPlan::MischiefManaged(); ThreadPlan::MischiefManaged();
return true; return true;
} else {
return false;
} }
return false;
} }
StopInfoSP ThreadPlanCallUserExpression::GetRealStopInfo() { StopInfoSP ThreadPlanCallUserExpression::GetRealStopInfo() {
Context not available.

source/Target/ThreadPlanRunToAddress.cpp

Context not available.
if (num_addresses == 0) { if (num_addresses == 0) {
s->Printf("run to address with no addresses given."); s->Printf("run to address with no addresses given.");
return; return;
} else if (num_addresses == 1) }
if (num_addresses == 1)
s->Printf("run to address: "); s->Printf("run to address: ");
else else
s->Printf("run to addresses: "); s->Printf("run to addresses: ");
Context not available.
if (num_addresses == 0) { if (num_addresses == 0) {
s->Printf("run to address with no addresses given."); s->Printf("run to address with no addresses given.");
return; return;
} else if (num_addresses == 1) }
if (num_addresses == 1)
s->Printf("Run to address: "); s->Printf("Run to address: ");
else { else {
s->Printf("Run to addresses: "); s->Printf("Run to addresses: ");
Context not available.
log->Printf("Completed run to address plan."); log->Printf("Completed run to address plan.");
ThreadPlan::MischiefManaged(); ThreadPlan::MischiefManaged();
return true; return true;
} else }
return false; return false;
} }
bool ThreadPlanRunToAddress::AtOurAddress() { bool ThreadPlanRunToAddress::AtOurAddress() {
Context not available.

source/Target/ThreadPlanShouldStopHere.cpp

Context not available.
lldb::FrameComparison operation, Status &status) { lldb::FrameComparison operation, Status &status) {
if (!InvokeShouldStopHereCallback(operation, status)) if (!InvokeShouldStopHereCallback(operation, status))
return QueueStepOutFromHerePlan(m_flags, operation, status); return QueueStepOutFromHerePlan(m_flags, operation, status);
else
return ThreadPlanSP(); return ThreadPlanSP();
} }
Context not available.

source/Target/ThreadPlanStepInRange.cpp

Context not available.
SetPlanComplete(); SetPlanComplete();
m_no_more_plans = true; m_no_more_plans = true;
return true; return true;
} else }
m_sub_plan_sp.reset(); m_sub_plan_sp.reset();
} }
if (m_virtual_step) { if (m_virtual_step) {
Context not available.
m_no_more_plans = true; m_no_more_plans = true;
SetPlanComplete(); SetPlanComplete();
return true; return true;
} else {
m_no_more_plans = false;
m_sub_plan_sp->SetPrivate(true);
return false;
} }
m_no_more_plans = false;
m_sub_plan_sp->SetPrivate(true);
return false;
} }
void ThreadPlanStepInRange::SetAvoidRegexp(const char *name) { void ThreadPlanStepInRange::SetAvoidRegexp(const char *name) {
Context not available.

source/Target/ThreadPlanStepInstruction.cpp

Context not available.
SetPlanComplete(); SetPlanComplete();
} }
return (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr); return (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr);
} else if (cur_frame_id < m_stack_id) { }
if (cur_frame_id < m_stack_id) {
// If the current frame is younger than the start frame and we are stepping // If the current frame is younger than the start frame and we are stepping
// over, then we need to continue, but if we are doing just one step, we're // over, then we need to continue, but if we are doing just one step, we're
// done. // done.
Context not available.
if (--m_iteration_count <= 0) { if (--m_iteration_count <= 0) {
SetPlanComplete(); SetPlanComplete();
return true; return true;
} else {
// We are still stepping, reset the start pc, and in case we've
// stepped out, reset the current stack id.
SetUpState();
return false;
} }
// We are still stepping, reset the start pc, and in case we've
// stepped out, reset the current stack id.
SetUpState();
return false;
} else } else
return false; return false;
} else { } else {
Context not available.
false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0, false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0,
m_status); m_status);
return false; return false;
} else { }
if (log) { if (log) {
log->PutCString( log->PutCString(
"The stack id we are stepping in changed, but our parent frame " "The stack id we are stepping in changed, but our parent frame "
"did not when stepping from code with no symbols. " "did not when stepping from code with no symbols. "
"We are probably just confused about where we are, stopping."); "We are probably just confused about where we are, stopping.");
} }
SetPlanComplete(); SetPlanComplete();
return true; return true;
}
} else { } else {
if (log) if (log)
log->Printf("Could not find previous frame, stopping."); log->Printf("Could not find previous frame, stopping.");
Context not available.
if (--m_iteration_count <= 0) { if (--m_iteration_count <= 0) {
SetPlanComplete(); SetPlanComplete();
return true; return true;
} else {
// We are still stepping, reset the start pc, and in case we've stepped
// in or out, reset the current stack id.
SetUpState();
return false;
} }
// We are still stepping, reset the start pc, and in case we've stepped
// in or out, reset the current stack id.
SetUpState();
return false;
} else } else
return false; return false;
} }
Context not available.
log->Printf("Completed single instruction step plan."); log->Printf("Completed single instruction step plan.");
ThreadPlan::MischiefManaged(); ThreadPlan::MischiefManaged();
return true; return true;
} else {
return false;
} }
return false;
} }
Context not available.

source/Target/ThreadPlanStepOut.cpp

Context not available.
// inlined frame. // inlined frame.
if (m_step_out_to_inline_plan_sp) { if (m_step_out_to_inline_plan_sp) {
return m_step_out_to_inline_plan_sp->MischiefManaged(); return m_step_out_to_inline_plan_sp->MischiefManaged();
} else if (m_step_through_inline_plan_sp) { }
if (m_step_through_inline_plan_sp) {
if (m_step_through_inline_plan_sp->MischiefManaged()) { if (m_step_through_inline_plan_sp->MischiefManaged()) {
CalculateReturnValue(); CalculateReturnValue();
SetPlanComplete(); SetPlanComplete();
return true; return true;
} else }
return false; return false;
} else if (m_step_out_further_plan_sp) { } else if (m_step_out_further_plan_sp) {
return m_step_out_further_plan_sp->MischiefManaged(); return m_step_out_further_plan_sp->MischiefManaged();
} }
Context not available.
return true; return true;
} }
return false; return false;
} else if (IsUsuallyUnexplainedStopReason(reason)) }
if (IsUsuallyUnexplainedStopReason(reason))
return false; return false;
else else
return true; return true;
Context not available.
m_step_out_to_inline_plan_sp.reset(); m_step_out_to_inline_plan_sp.reset();
SetPlanComplete(false); SetPlanComplete(false);
return true; return true;
} else }
done = true; done = true;
} else } else
return m_step_out_to_inline_plan_sp->ShouldStop(event_ptr); return m_step_out_to_inline_plan_sp->ShouldStop(event_ptr);
} else if (m_step_through_inline_plan_sp) { } else if (m_step_through_inline_plan_sp) {
Context not available.
ThreadPlan::MischiefManaged(); ThreadPlan::MischiefManaged();
return true; return true;
} else {
return false;
} }
return false;
} }
bool ThreadPlanStepOut::QueueInlinedStepPlan(bool queue_now) { bool ThreadPlanStepOut::QueueInlinedStepPlan(bool queue_now) {
Context not available.

source/Target/ThreadPlanStepOverBreakpoint.cpp

Context not available.
// If we are still at the PC of our breakpoint, then for some reason we // If we are still at the PC of our breakpoint, then for some reason we
// didn't get a chance to run. // didn't get a chance to run.
return false; return false;
} else {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
if (log)
log->Printf("Completed step over breakpoint plan.");
// Otherwise, re-enable the breakpoint we were stepping over, and we're
// done.
ReenableBreakpointSite();
ThreadPlan::MischiefManaged();
return true;
} }
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
if (log)
log->Printf("Completed step over breakpoint plan.");
// Otherwise, re-enable the breakpoint we were stepping over, and we're
// done.
ReenableBreakpointSite();
ThreadPlan::MischiefManaged();
return true;
} }
void ThreadPlanStepOverBreakpoint::ReenableBreakpointSite() { void ThreadPlanStepOverBreakpoint::ReenableBreakpointSite() {
Context not available.

source/Target/ThreadPlanStepOverRange.cpp

Context not available.
false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0, false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0,
m_status, true); m_status, true);
break; break;
} else {
new_plan_sp = m_thread.QueueThreadPlanForStepThrough(
m_stack_id, false, stop_others, m_status);
// If we found a way through, then we should stop recursing.
if (new_plan_sp)
break;
} }
new_plan_sp = m_thread.QueueThreadPlanForStepThrough(
m_stack_id, false, stop_others, m_status);
// If we found a way through, then we should stop recursing.
if (new_plan_sp)
break;
} }
} else { } else {
// If we're still in the range, keep going. // If we're still in the range, keep going.
Context not available.
// this calculation again in MischiefManaged. // this calculation again in MischiefManaged.
SetPlanComplete(m_status.Success()); SetPlanComplete(m_status.Success());
return true; return true;
} else }
return false; return false;
} }
bool ThreadPlanStepOverRange::DoPlanExplainsStop(Event *event_ptr) { bool ThreadPlanStepOverRange::DoPlanExplainsStop(Event *event_ptr) {
Context not available.

source/Target/ThreadPlanStepRange.cpp

Context not available.
if (m_addr_context.function != nullptr) { if (m_addr_context.function != nullptr) {
return m_addr_context.function->GetAddressRange().ContainsLoadAddress( return m_addr_context.function->GetAddressRange().ContainsLoadAddress(
cur_pc, m_thread.CalculateTarget().get()); cur_pc, m_thread.CalculateTarget().get());
} else if (m_addr_context.symbol && m_addr_context.symbol->ValueIsAddress()) { }
if (m_addr_context.symbol && m_addr_context.symbol->ValueIsAddress()) {
AddressRange range(m_addr_context.symbol->GetAddressRef(), AddressRange range(m_addr_context.symbol->GetAddressRef(),
m_addr_context.symbol->GetByteSize()); m_addr_context.symbol->GetByteSize());
return range.ContainsLoadAddress(cur_pc, m_thread.CalculateTarget().get()); return range.ContainsLoadAddress(cur_pc, m_thread.CalculateTarget().get());
Context not available.
} }
if (!m_instruction_ranges[i]) if (!m_instruction_ranges[i])
return nullptr; return nullptr;
else {
// Find where we are in the instruction list as well. If we aren't at // Find where we are in the instruction list as well. If we aren't at
// an instruction, return nullptr. In this case, we're probably lost, // an instruction, return nullptr. In this case, we're probably lost,
// and shouldn't try to do anything fancy. // and shouldn't try to do anything fancy.
insn_offset = insn_offset = m_instruction_ranges[i]
m_instruction_ranges[i] ->GetInstructionList()
->GetInstructionList() .GetIndexOfInstructionAtLoadAddress(addr, GetTarget());
.GetIndexOfInstructionAtLoadAddress(addr, GetTarget()); if (insn_offset == UINT32_MAX)
if (insn_offset == UINT32_MAX) return nullptr;
return nullptr;
else { range_index = i;
range_index = i; return &m_instruction_ranges[i]->GetInstructionList();
return &m_instruction_ranges[i]->GetInstructionList();
}
}
} }
} }
return nullptr; return nullptr;
Context not available.
GetInstructionsForAddress(cur_addr, range_index, pc_index); GetInstructionsForAddress(cur_addr, range_index, pc_index);
if (instructions == nullptr) if (instructions == nullptr)
return false; return false;
else {
Target &target = GetThread().GetProcess()->GetTarget(); Target &target = GetThread().GetProcess()->GetTarget();
uint32_t branch_index; uint32_t branch_index;
branch_index = branch_index =
instructions->GetIndexOfNextBranchInstruction(pc_index, target); instructions->GetIndexOfNextBranchInstruction(pc_index, target);
Address run_to_address; Address run_to_address;
// If we didn't find a branch, run to the end of the range. // If we didn't find a branch, run to the end of the range.
if (branch_index == UINT32_MAX) { if (branch_index == UINT32_MAX) {
uint32_t last_index = instructions->GetSize() - 1; uint32_t last_index = instructions->GetSize() - 1;
if (last_index - pc_index > 1) { if (last_index - pc_index > 1) {
InstructionSP last_inst = InstructionSP last_inst = instructions->GetInstructionAtIndex(last_index);
instructions->GetInstructionAtIndex(last_index); size_t last_inst_size = last_inst->GetOpcode().GetByteSize();
size_t last_inst_size = last_inst->GetOpcode().GetByteSize(); run_to_address = last_inst->GetAddress();
run_to_address = last_inst->GetAddress(); run_to_address.Slide(last_inst_size);
run_to_address.Slide(last_inst_size); }
aprantlUnsubmitted
Not Done
ReplyInline Actions

weird indentation again

aprantl: weird indentation again
}
} else if (branch_index - pc_index > 1) { } else if (branch_index - pc_index > 1) {
run_to_address = run_to_address =
instructions->GetInstructionAtIndex(branch_index)->GetAddress(); instructions->GetInstructionAtIndex(branch_index)->GetAddress();
Context not available.
m_next_branch_bp_sp->SetBreakpointKind("next-branch-location"); m_next_branch_bp_sp->SetBreakpointKind("next-branch-location");
return true; return true;
} else }
return false; return false;
} }
}
return false; return false;
} }
bool ThreadPlanStepRange::NextRangeBreakpointExplainsStop( bool ThreadPlanStepRange::NextRangeBreakpointExplainsStop(
Context not available.
m_thread.GetProcess()->GetBreakpointSiteList().FindByID(bp_site_id); m_thread.GetProcess()->GetBreakpointSiteList().FindByID(bp_site_id);
if (!bp_site_sp) if (!bp_site_sp)
return false; return false;
else if (!bp_site_sp->IsBreakpointAtThisSite(m_next_branch_bp_sp->GetID())) if (!bp_site_sp->IsBreakpointAtThisSite(m_next_branch_bp_sp->GetID()))
return false; return false;
else { else {
// If we've hit the next branch breakpoint, then clear it. // If we've hit the next branch breakpoint, then clear it.
Context not available.
StateType ThreadPlanStepRange::GetPlanRunState() { StateType ThreadPlanStepRange::GetPlanRunState() {
if (m_next_branch_bp_sp) if (m_next_branch_bp_sp)
return eStateRunning; return eStateRunning;
else
return eStateStepping; return eStateStepping;
} }
bool ThreadPlanStepRange::MischiefManaged() { bool ThreadPlanStepRange::MischiefManaged() {
Context not available.
ClearNextBranchBreakpoint(); ClearNextBranchBreakpoint();
ThreadPlan::MischiefManaged(); ThreadPlan::MischiefManaged();
return true; return true;
} else {
return false;
} }
return false;
} }
bool ThreadPlanStepRange::IsPlanStale() { bool ThreadPlanStepRange::IsPlanStale() {
Context not available.
"stepped out."); "stepped out.");
} }
return true; return true;
} else if (frame_order == eFrameCompareEqual && InSymbol()) { }
if (frame_order == eFrameCompareEqual && InSymbol()) {
// If we are not in a place we should step through, we've gotten stale. One // If we are not in a place we should step through, we've gotten stale. One
// tricky bit here is that some stubs don't push a frame, so we should. // tricky bit here is that some stubs don't push a frame, so we should.
// check that we are in the same symbol. // check that we are in the same symbol.
Context not available.

source/Target/ThreadPlanStepThrough.cpp

Context not available.
if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID) { if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID) {
m_sub_plan_sp.reset(); m_sub_plan_sp.reset();
return false; return false;
} else {
SetPlanComplete(false);
return true;
} }
SetPlanComplete(false);
return true;
} }
// Next see if there is a specific step through plan at our current pc (these // Next see if there is a specific step through plan at our current pc (these
Context not available.
if (m_sub_plan_sp) { if (m_sub_plan_sp) {
PushPlan(m_sub_plan_sp); PushPlan(m_sub_plan_sp);
return false; return false;
} else {
SetPlanComplete();
return true;
} }
SetPlanComplete();
return true;
} }
bool ThreadPlanStepThrough::StopOthers() { return m_stop_others; } bool ThreadPlanStepThrough::StopOthers() { return m_stop_others; }
Context not available.
if (!IsPlanComplete()) { if (!IsPlanComplete()) {
return false; return false;
} else {
if (log)
log->Printf("Completed step through step plan.");
ClearBackstopBreakpoint();
ThreadPlan::MischiefManaged();
return true;
} }
if (log)
log->Printf("Completed step through step plan.");
ClearBackstopBreakpoint();
ThreadPlan::MischiefManaged();
return true;
} }
bool ThreadPlanStepThrough::HitOurBackstopBreakpoint() { bool ThreadPlanStepThrough::HitOurBackstopBreakpoint() {
Context not available.

source/Target/ThreadPlanStepUntil.cpp

Context not available.
error->PutCString( error->PutCString(
"Could not create hardware breakpoint for thread plan."); "Could not create hardware breakpoint for thread plan.");
return false; return false;
} else if (m_return_bp_id == LLDB_INVALID_BREAK_ID) { }
if (m_return_bp_id == LLDB_INVALID_BREAK_ID) {
if (error) if (error)
error->PutCString("Could not create return breakpoint."); error->PutCString("Could not create return breakpoint.");
return false; return false;
Context not available.
else else
m_explains_stop = false; m_explains_stop = false;
return; return;
} else { }
// Check if we've hit one of our "until" breakpoints. // Check if we've hit one of our "until" breakpoints.
until_collection::iterator pos, end = m_until_points.end(); until_collection::iterator pos, end = m_until_points.end();
for (pos = m_until_points.begin(); pos != end; pos++) { for (pos = m_until_points.begin(); pos != end; pos++) {
if (this_site->IsBreakpointAtThisSite((*pos).second)) { if (this_site->IsBreakpointAtThisSite((*pos).second)) {
// If we're at the right stack depth, then we're done. // If we're at the right stack depth, then we're done.
bool done; bool done;
StackID frame_zero_id = StackID frame_zero_id =
m_thread.GetStackFrameAtIndex(0)->GetStackID(); m_thread.GetStackFrameAtIndex(0)->GetStackID();
if (frame_zero_id == m_stack_id) if (frame_zero_id == m_stack_id)
done = true; done = true;
else if (frame_zero_id < m_stack_id) else if (frame_zero_id < m_stack_id)
done = false;
else {
StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(1);
// But if we can't even unwind one frame we should just get out
// of here & stop...
if (older_frame_sp) {
const SymbolContext &older_context =
older_frame_sp->GetSymbolContext(eSymbolContextEverything);
SymbolContext stack_context;
m_stack_id.GetSymbolContextScope()->CalculateSymbolContext(
&stack_context);
done = (older_context == stack_context);
} else
done = false; done = false;
else {
StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(1);
// But if we can't even unwind one frame we should just get out
// of here & stop...
if (older_frame_sp) {
const SymbolContext &older_context =
older_frame_sp->GetSymbolContext(eSymbolContextEverything);
SymbolContext stack_context;
m_stack_id.GetSymbolContextScope()->CalculateSymbolContext(
&stack_context);
done = (older_context == stack_context);
} else
done = false;
}
if (done)
SetPlanComplete();
else
m_should_stop = false;
// Otherwise we've hit this breakpoint recursively. If we're the
// only breakpoint here, then we do explain the stop, and we'll
// continue. If not then we should let higher plans handle this
// stop.
if (this_site->GetNumberOfOwners() == 1)
m_explains_stop = true;
else {
m_should_stop = true;
m_explains_stop = false;
}
return;
} }
if (done)
SetPlanComplete();
else
m_should_stop = false;
// Otherwise we've hit this breakpoint recursively. If we're the
// only breakpoint here, then we do explain the stop, and we'll
// continue. If not then we should let higher plans handle this
// stop.
if (this_site->GetNumberOfOwners() == 1)
m_explains_stop = true;
else {
m_should_stop = true;
m_explains_stop = false;
}
return;
} }
} }
aprantlUnsubmitted
Not Done
ReplyInline Actions

again

aprantl: again
// If we get here we haven't hit any of our breakpoints, so let the
// higher plans take care of the stop. // If we get here we haven't hit any of our breakpoints, so let the
m_explains_stop = false; // higher plans take care of the stop.
return; m_explains_stop = false;
} else if (IsUsuallyUnexplainedStopReason(reason)) { return;
}
if (IsUsuallyUnexplainedStopReason(reason)) {
m_explains_stop = false; m_explains_stop = false;
} else { } else {
m_explains_stop = true; m_explains_stop = true;
Context not available.

source/Target/ThreadPlanTracer.cpp

Context not available.
Stream *ThreadPlanTracer::GetLogStream() { Stream *ThreadPlanTracer::GetLogStream() {
if (m_stream_sp) if (m_stream_sp)
return m_stream_sp.get(); return m_stream_sp.get();
else {
TargetSP target_sp(m_thread.CalculateTarget()); TargetSP target_sp(m_thread.CalculateTarget());
if (target_sp) if (target_sp)
return target_sp->GetDebugger().GetOutputFile().get(); return target_sp->GetDebugger().GetOutputFile().get();
}
return nullptr; return nullptr;
} }
Context not available.
if (m_enabled && m_single_step) { if (m_enabled && m_single_step) {
lldb::StopInfoSP stop_info = m_thread.GetStopInfo(); lldb::StopInfoSP stop_info = m_thread.GetStopInfo();
return (stop_info->GetStopReason() == eStopReasonTrace); return (stop_info->GetStopReason() == eStopReasonTrace);
} else }
return false; return false;
} }
#pragma mark ThreadPlanAssemblyTracer #pragma mark ThreadPlanAssemblyTracer
Context not available.

source/Target/UnixSignals.cpp

Context not available.
collection::const_iterator pos = m_signals.find(signo); collection::const_iterator pos = m_signals.find(signo);
if (pos == m_signals.end()) if (pos == m_signals.end())
return nullptr; return nullptr;
else
return pos->second.m_name.GetCString(); return pos->second.m_name.GetCString();
} }
bool UnixSignals::SignalIsValid(int32_t signo) const { bool UnixSignals::SignalIsValid(int32_t signo) const {
Context not available.
collection::const_iterator end = m_signals.end(); collection::const_iterator end = m_signals.end();
if (pos == end) if (pos == end)
return LLDB_INVALID_SIGNAL_NUMBER; return LLDB_INVALID_SIGNAL_NUMBER;
else {
pos++; pos++;
if (pos == end) if (pos == end)
return LLDB_INVALID_SIGNAL_NUMBER; return LLDB_INVALID_SIGNAL_NUMBER;
else
return pos->first; return pos->first;
}
} }
const char *UnixSignals::GetSignalInfo(int32_t signo, bool &should_suppress, const char *UnixSignals::GetSignalInfo(int32_t signo, bool &should_suppress,
Context not available.
collection::const_iterator pos = m_signals.find(signo); collection::const_iterator pos = m_signals.find(signo);
if (pos == m_signals.end()) if (pos == m_signals.end())
return nullptr; return nullptr;
else {
const Signal &signal = pos->second; const Signal &signal = pos->second;
should_suppress = signal.m_suppress; should_suppress = signal.m_suppress;
should_stop = signal.m_stop; should_stop = signal.m_stop;
should_notify = signal.m_notify; should_notify = signal.m_notify;
return signal.m_name.AsCString(""); return signal.m_name.AsCString("");
}
} }
bool UnixSignals::GetShouldSuppress(int signo) const { bool UnixSignals::GetShouldSuppress(int signo) const {
Context not available.

source/Utility/ConstString.cpp

Context not available.
if (case_sensitive) { if (case_sensitive) {
return lhs_string_ref.compare(rhs_string_ref); return lhs_string_ref.compare(rhs_string_ref);
} else {
return lhs_string_ref.compare_lower(rhs_string_ref);
} }
return lhs_string_ref.compare_lower(rhs_string_ref);
} }
if (lhs_cstr) if (lhs_cstr)
return +1; // LHS isn't nullptr but RHS is return +1; // LHS isn't nullptr but RHS is
else
return -1; // LHS is nullptr but RHS isn't return -1; // LHS is nullptr but RHS isn't
} }
void ConstString::Dump(Stream *s, const char *fail_value) const { void ConstString::Dump(Stream *s, const char *fail_value) const {
Context not available.

source/Utility/DataExtractor.cpp

Context not available.
::memset(dst + src_len, 0, num_zeroes); ::memset(dst + src_len, 0, num_zeroes);
} }
return src_len; return src_len;
} else { }
// We are only copying some of the value from src into dst.. // We are only copying some of the value from src into dst..
if (dst_byte_order == eByteOrderBig) { if (dst_byte_order == eByteOrderBig) {
// Big endian dst // Big endian dst
if (m_byte_order == eByteOrderBig) { if (m_byte_order == eByteOrderBig) {
// Big endian dst, with big endian src // Big endian dst, with big endian src
::memcpy(dst, src + (src_len - dst_len), dst_len); ::memcpy(dst, src + (src_len - dst_len), dst_len);
} else { } else {
// Big endian dst, with little endian src // Big endian dst, with little endian src
for (uint32_t i = 0; i < dst_len; ++i) for (uint32_t i = 0; i < dst_len; ++i)
dst[i] = src[dst_len - 1 - i]; dst[i] = src[dst_len - 1 - i];
} }
} else { } else {
// Little endian dst // Little endian dst
if (m_byte_order == eByteOrderBig) { if (m_byte_order == eByteOrderBig) {
Context not available.
} }
} }
return dst_len; return dst_len;
}
} }
return 0; return 0;
} }
Context not available.

source/Utility/JSON.cpp

Context not available.
start_index); start_index);
value = std::move(error.GetString()); value = std::move(error.GetString());
return Token::Status; return Token::Status;
}
} else { const bool is_end_quote = escaped_ch == '"';
const bool is_end_quote = escaped_ch == '"'; const bool is_null = escaped_ch == 0;
const bool is_null = escaped_ch == 0; if (was_escaped || (!is_end_quote && !is_null)) {
if (was_escaped || (!is_end_quote && !is_null)) { if (CHAR_MIN <= escaped_ch && escaped_ch <= CHAR_MAX) {
if (CHAR_MIN <= escaped_ch && escaped_ch <= CHAR_MAX) { value.append(1, (char)escaped_ch);
value.append(1, (char)escaped_ch); } else {
} else { error.Printf("error: wide character support is needed for unicode "
error.Printf("error: wide character support is needed for unicode " "character 0x%4.4x at offset %" PRIu64,
"character 0x%4.4x at offset %" PRIu64, escaped_ch, start_index);
escaped_ch, start_index); value = std::move(error.GetString());
value = std::move(error.GetString()); return Token::Status;
return Token::Status; }
}
} else if (is_end_quote) { } else if (is_end_quote) {
return Token::String; return Token::String;
} else if (is_null) { } else if (is_null) {
value = "error: missing end quote for string"; value = "error: missing end quote for string";
return Token::Status; return Token::Status;
} }
}
} }
} break; } break;
Context not available.
// We have an exponent, make sure we got exponent digits // We have an exponent, make sure we got exponent digits
if (got_exp_digits) { if (got_exp_digits) {
return Token::Float; return Token::Float;
} else {
error.Printf("error: got exponent character but no exponent digits "
"at offset in float value \"%s\"",
value.c_str());
value = std::move(error.GetString());
return Token::Status;
} }
error.Printf("error: got exponent character but no exponent digits "
"at offset in float value \"%s\"",
value.c_str());
value = std::move(error.GetString());
return Token::Status;
} else { } else {
// No exponent, but we need at least one decimal after the decimal // No exponent, but we need at least one decimal after the decimal
// point // point
if (got_frac_digits) { if (got_frac_digits) {
return Token::Float; return Token::Float;
} else {
error.Printf("error: no digits after decimal point \"%s\"",
value.c_str());
value = std::move(error.GetString());
return Token::Status;
} }
error.Printf("error: no digits after decimal point \"%s\"",
value.c_str());
value = std::move(error.GetString());
return Token::Status;
} }
} else { } else {
// No decimal point // No decimal point
if (got_int_digits) { if (got_int_digits) {
// We need at least some integer digits to make an integer // We need at least some integer digits to make an integer
return Token::Integer; return Token::Integer;
} else {
error.Printf("error: no digits negate sign \"%s\"", value.c_str());
value = std::move(error.GetString());
return Token::Status;
} }
error.Printf("error: no digits negate sign \"%s\"", value.c_str());
value = std::move(error.GetString());
return Token::Status;
} }
} else { } else {
error.Printf("error: invalid number found at offset %" PRIu64, error.Printf("error: invalid number found at offset %" PRIu64,
Context not available.
JSONParser::Token token = GetToken(value); JSONParser::Token token = GetToken(value);
if (token == JSONParser::Token::Comma) { if (token == JSONParser::Token::Comma) {
continue; continue;
} else if (token == JSONParser::Token::ArrayEnd) { }
if (token == JSONParser::Token::ArrayEnd) {
return JSONValue::SP(array_up.release()); return JSONValue::SP(array_up.release());
} else { } else {
break; break;
Context not available.

source/Utility/RegularExpression.cpp

Context not available.
// Matched the empty string... // Matched the empty string...
match_str = llvm::StringRef(); match_str = llvm::StringRef();
return true; return true;
} else if (m_matches[idx].rm_eo > m_matches[idx].rm_so) { }
if (m_matches[idx].rm_eo > m_matches[idx].rm_so) {
match_str = s.substr(m_matches[idx].rm_so, match_str = s.substr(m_matches[idx].rm_so,
m_matches[idx].rm_eo - m_matches[idx].rm_so); m_matches[idx].rm_eo - m_matches[idx].rm_so);
return true; return true;
Context not available.
// Matched the empty string... // Matched the empty string...
match_str = llvm::StringRef(); match_str = llvm::StringRef();
return true; return true;
} else if (m_matches[idx1].rm_so < m_matches[idx2].rm_eo) { }
if (m_matches[idx1].rm_so < m_matches[idx2].rm_eo) {
match_str = s.substr(m_matches[idx1].rm_so, match_str = s.substr(m_matches[idx1].rm_so,
m_matches[idx2].rm_eo - m_matches[idx1].rm_so); m_matches[idx2].rm_eo - m_matches[idx1].rm_so);
return true; return true;
Context not available.

source/Utility/SelectHelper.cpp

Context not available.
auto pos = m_fd_map.find(fd); auto pos = m_fd_map.find(fd);
if (pos != m_fd_map.end()) if (pos != m_fd_map.end())
return pos->second.read_is_set; return pos->second.read_is_set;
else
return false; return false;
} }
bool SelectHelper::FDIsSetWrite(lldb::socket_t fd) const { bool SelectHelper::FDIsSetWrite(lldb::socket_t fd) const {
auto pos = m_fd_map.find(fd); auto pos = m_fd_map.find(fd);
if (pos != m_fd_map.end()) if (pos != m_fd_map.end())
return pos->second.write_is_set; return pos->second.write_is_set;
else
return false; return false;
} }
bool SelectHelper::FDIsSetError(lldb::socket_t fd) const { bool SelectHelper::FDIsSetError(lldb::socket_t fd) const {
auto pos = m_fd_map.find(fd); auto pos = m_fd_map.find(fd);
if (pos != m_fd_map.end()) if (pos != m_fd_map.end())
return pos->second.error_is_set; return pos->second.error_is_set;
else
return false; return false;
} }
static void updateMaxFd(llvm::Optional<lldb::socket_t> &vold, static void updateMaxFd(llvm::Optional<lldb::socket_t> &vold,
Context not available.
if (error.GetError() == EINTR) { if (error.GetError() == EINTR) {
error.Clear(); error.Clear();
continue; // Keep calling select if we get EINTR continue; // Keep calling select if we get EINTR
} else }
return error; return error;
} else if (num_set_fds == 0) { } else if (num_set_fds == 0) {
// Timeout // Timeout
error.SetError(ETIMEDOUT, lldb::eErrorTypePOSIX); error.SetError(ETIMEDOUT, lldb::eErrorTypePOSIX);
Context not available.

source/Utility/Status.cpp

Context not available.
int length = SetErrorStringWithVarArg(format, args); int length = SetErrorStringWithVarArg(format, args);
va_end(args); va_end(args);
return length; return length;
} else {
m_string.clear();
} }
m_string.clear();
return 0; return 0;
} }
Context not available.
VASprintf(buf, format, args); VASprintf(buf, format, args);
m_string = buf.str(); m_string = buf.str();
return buf.size(); return buf.size();
} else {
m_string.clear();
} }
m_string.clear();
return 0; return 0;
} }
Context not available.

source/Utility/Stream.cpp

Context not available.
size_t Stream::PutSLEB128(int64_t sval) { size_t Stream::PutSLEB128(int64_t sval) {
if (m_flags.Test(eBinary)) if (m_flags.Test(eBinary))
return llvm::encodeSLEB128(sval, m_forwarder); return llvm::encodeSLEB128(sval, m_forwarder);
else
return Printf("0x%" PRIi64, sval); return Printf("0x%" PRIi64, sval);
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
Context not available.
size_t Stream::PutULEB128(uint64_t uval) { size_t Stream::PutULEB128(uint64_t uval) {
if (m_flags.Test(eBinary)) if (m_flags.Test(eBinary))
return llvm::encodeULEB128(uval, m_forwarder); return llvm::encodeULEB128(uval, m_forwarder);
else
return Printf("0x%" PRIx64, uval); return Printf("0x%" PRIx64, uval);
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
Context not available.

source/Utility/StreamString.cpp

Context not available.
size_t last_line_begin_pos = m_packet.find_last_of("\r\n"); size_t last_line_begin_pos = m_packet.find_last_of("\r\n");
if (last_line_begin_pos == std::string::npos) { if (last_line_begin_pos == std::string::npos) {
return length; return length;
} else {
++last_line_begin_pos;
return length - last_line_begin_pos;
} }
++last_line_begin_pos;
return length - last_line_begin_pos;
} }
llvm::StringRef StreamString::GetString() const { return m_packet; } llvm::StringRef StreamString::GetString() const { return m_packet; }
Context not available.

source/Utility/StringExtractor.cpp

Context not available.
llvm::StringRef S = GetStringRef(); llvm::StringRef S = GetStringRef();
if (!S.startswith(str)) if (!S.startswith(str))
return false; return false;
else
m_index += str.size(); m_index += str.size();
return true; return true;
} }
Context not available.

source/Utility/StringExtractorGDBRemote.cpp

Context not available.
if (PACKET_STARTS_WITH("vFile:")) { if (PACKET_STARTS_WITH("vFile:")) {
if (PACKET_STARTS_WITH("vFile:open:")) if (PACKET_STARTS_WITH("vFile:open:"))
return eServerPacketType_vFile_open; return eServerPacketType_vFile_open;
else if (PACKET_STARTS_WITH("vFile:close:")) if (PACKET_STARTS_WITH("vFile:close:"))
return eServerPacketType_vFile_close; return eServerPacketType_vFile_close;
else if (PACKET_STARTS_WITH("vFile:pread")) else if (PACKET_STARTS_WITH("vFile:pread"))
return eServerPacketType_vFile_pread; return eServerPacketType_vFile_pread;
Context not available.
// If we have a validator callback, try to validate the callback // If we have a validator callback, try to validate the callback
if (m_validator) if (m_validator)
return m_validator(m_validator_baton, *this); return m_validator(m_validator_baton, *this);
else
return true; // No validator, so response is valid return true; // No validator, so response is valid
} }
Context not available.

source/Utility/StructuredData.cpp

Context not available.
JSONParser::Token token = json_parser.GetToken(value); JSONParser::Token token = json_parser.GetToken(value);
if (token == JSONParser::Token::Comma) { if (token == JSONParser::Token::Comma) {
continue; continue;
} else if (token == JSONParser::Token::ArrayEnd) { }
if (token == JSONParser::Token::ArrayEnd) {
return StructuredData::ObjectSP(array_up.release()); return StructuredData::ObjectSP(array_up.release());
} else { } else {
break; break;
Context not available.
// we're at right now. // we're at right now.
if (match.second.empty()) { if (match.second.empty()) {
return value; return value;
} else {
return value->GetObjectForDotSeparatedPath(match.second);
} }
return value->GetObjectForDotSeparatedPath(match.second);
} }
return ObjectSP(); return ObjectSP();
} }
Context not available.

source/Utility/VMRange.cpp

Context not available.
bool lldb_private::operator<(const VMRange &lhs, const VMRange &rhs) { bool lldb_private::operator<(const VMRange &lhs, const VMRange &rhs) {
if (lhs.GetBaseAddress() < rhs.GetBaseAddress()) if (lhs.GetBaseAddress() < rhs.GetBaseAddress())
return true; return true;
else if (lhs.GetBaseAddress() > rhs.GetBaseAddress()) if (lhs.GetBaseAddress() > rhs.GetBaseAddress())
return false; return false;
return lhs.GetEndAddress() < rhs.GetEndAddress(); return lhs.GetEndAddress() < rhs.GetEndAddress();
} }
Context not available.

tools/debugserver/source/DNB.cpp

Context not available.
if (n_events == -1) { if (n_events == -1) {
if (errno == EINTR) if (errno == EINTR)
continue; continue;
else {
DNBLogError("kqueue failed with error: (%d): %s", errno, DNBLogError("kqueue failed with error: (%d): %s", errno, strerror(errno));
strerror(errno)); return NULL;
return NULL;
}
} else if (death_event.flags & EV_ERROR) { } else if (death_event.flags & EV_ERROR) {
int error_no = static_cast<int>(death_event.data); int error_no = static_cast<int>(death_event.data);
const char *error_str = strerror(error_no); const char *error_str = strerror(error_no);
Context not available.
if (errno == EINTR) if (errno == EINTR)
continue; continue;
break; break;
} else {
if (WIFSTOPPED(status)) {
continue;
} else // if (WIFEXITED(status) || WIFSIGNALED(status))
{
DNBLogThreadedIf(
LOG_PROCESS,
"waitpid_thread (): setting exit status for pid = %i to %i",
child_pid, status);
DNBProcessSetExitStatus(child_pid, status);
return NULL;
}
} }
if (WIFSTOPPED(status)) {
continue;
} // if (WIFEXITED(status) || WIFSIGNALED(status))
DNBLogThreadedIf(
LOG_PROCESS,
"waitpid_thread (): setting exit status for pid = %i to %i", child_pid,
status);
DNBProcessSetExitStatus(child_pid, status);
return NULL;
} }
// We should never exit as long as our child process is alive, so if we // We should never exit as long as our child process is alive, so if we
Context not available.
if (num_matching_proc_infos == 0) { if (num_matching_proc_infos == 0) {
DNBLogError("error: no processes match '%s'\n", name); DNBLogError("error: no processes match '%s'\n", name);
return INVALID_NUB_PROCESS; return INVALID_NUB_PROCESS;
} else if (num_matching_proc_infos > 1) { }
if (num_matching_proc_infos > 1) {
DNBLogError("error: %llu processes match '%s':\n", DNBLogError("error: %llu processes match '%s':\n",
(uint64_t)num_matching_proc_infos, name); (uint64_t)num_matching_proc_infos, name);
size_t i; size_t i;
Context not available.
// Found the path relatively... // Found the path relatively...
::strlcpy(resolved_path, max_path, resolved_path_size); ::strlcpy(resolved_path, max_path, resolved_path_size);
return strlen(resolved_path) + 1 < resolved_path_size; return strlen(resolved_path) + 1 < resolved_path_size;
} else { }
// Not a relative path, check the PATH environment variable if the // Not a relative path, check the PATH environment variable if the
const char *PATH = getenv("PATH"); const char *PATH = getenv("PATH");
if (PATH) { if (PATH) {
const char *curr_path_start = PATH; const char *curr_path_start = PATH;
const char *curr_path_end; const char *curr_path_end;
while (curr_path_start && *curr_path_start) { while (curr_path_start && *curr_path_start) {
curr_path_end = strchr(curr_path_start, ':'); curr_path_end = strchr(curr_path_start, ':');
if (curr_path_end == NULL) { if (curr_path_end == NULL) {
result.assign(curr_path_start); result.assign(curr_path_start);
curr_path_start = NULL; curr_path_start = NULL;
} else if (curr_path_end > curr_path_start) { } else if (curr_path_end > curr_path_start) {
size_t len = curr_path_end - curr_path_start; size_t len = curr_path_end - curr_path_start;
result.assign(curr_path_start, len); result.assign(curr_path_start, len);
curr_path_start += len + 1; curr_path_start += len + 1;
} else } else
break; break;
result += '/'; result += '/';
result += path; result += path;
struct stat s; struct stat s;
if (stat(result.c_str(), &s) == 0) { if (stat(result.c_str(), &s) == 0) {
::strlcpy(resolved_path, result.c_str(), resolved_path_size); ::strlcpy(resolved_path, result.c_str(), resolved_path_size);
return result.size() + 1 < resolved_path_size; return result.size() + 1 < resolved_path_size;
}
} }
} }
} }
return false;
return false;
} }
bool DNBGetOSVersionNumbers(uint64_t *major, uint64_t *minor, uint64_t *patch) { bool DNBGetOSVersionNumbers(uint64_t *major, uint64_t *minor, uint64_t *patch) {
Context not available.
if (arch && arch[0]) { if (arch && arch[0]) {
if (strcasecmp(arch, "i386") == 0) if (strcasecmp(arch, "i386") == 0)
return DNBArchProtocol::SetArchitecture(CPU_TYPE_I386); return DNBArchProtocol::SetArchitecture(CPU_TYPE_I386);
else if ((strcasecmp(arch, "x86_64") == 0) || if ((strcasecmp(arch, "x86_64") == 0) || (strcasecmp(arch, "x86_64h") == 0))
(strcasecmp(arch, "x86_64h") == 0))
return DNBArchProtocol::SetArchitecture(CPU_TYPE_X86_64); return DNBArchProtocol::SetArchitecture(CPU_TYPE_X86_64);
else if (strstr(arch, "arm64") == arch || strstr(arch, "armv8") == arch || else if (strstr(arch, "arm64") == arch || strstr(arch, "armv8") == arch ||
strstr(arch, "aarch64") == arch) strstr(arch, "aarch64") == arch)
Context not available.

tools/debugserver/source/DNBTimer.h

Context not available.
OffsetTimeOfDay(&now); OffsetTimeOfDay(&now);
if (now.tv_sec > ts.tv_sec) if (now.tv_sec > ts.tv_sec)
return true; return true;
else if (now.tv_sec < ts.tv_sec) if (now.tv_sec < ts.tv_sec)
return false; return false;
else { else {
if (now.tv_nsec > ts.tv_nsec) if (now.tv_nsec > ts.tv_nsec)
return true; return true;
else
return false; return false;
} }
} }
Context not available.

tools/debugserver/source/JSON.cpp

Context not available.
// We have the value, and it is true. // We have the value, and it is true.
value = true; value = true;
return true; return true;
} else if (JSONFalse::classof(value_sp.get())) { }
if (JSONFalse::classof(value_sp.get())) {
// We have the value, and it is false. // We have the value, and it is false.
value = false; value = false;
return true; return true;
Context not available.
<< start_index; << start_index;
value = error.str(); value = error.str();
return Token::Status; return Token::Status;
}
} else { const bool is_end_quote = escaped_ch == '"';
const bool is_end_quote = escaped_ch == '"'; const bool is_null = escaped_ch == 0;
const bool is_null = escaped_ch == 0; if (was_escaped || (!is_end_quote && !is_null)) {
if (was_escaped || (!is_end_quote && !is_null)) { if (CHAR_MIN <= escaped_ch && escaped_ch <= CHAR_MAX) {
if (CHAR_MIN <= escaped_ch && escaped_ch <= CHAR_MAX) { value.append(1, (char)escaped_ch);
value.append(1, (char)escaped_ch); } else {
} else { error << "error: wide character support is needed for unicode "
error << "error: wide character support is needed for unicode " "character 0x"
"character 0x" << std::setprecision(4) << std::hex << escaped_ch;
<< std::setprecision(4) << std::hex << escaped_ch; error << " at offset " << start_index;
error << " at offset " << start_index; value = error.str();
value = error.str(); return Token::Status;
return Token::Status; }
}
} else if (is_end_quote) { } else if (is_end_quote) {
return Token::String; return Token::String;
} else if (is_null) { } else if (is_null) {
value = "error: missing end quote for string"; value = "error: missing end quote for string";
return Token::Status; return Token::Status;
} }
}
} }
} break; } break;
Context not available.
// We have an exponent, make sure we got exponent digits // We have an exponent, make sure we got exponent digits
if (got_exp_digits) { if (got_exp_digits) {
return Token::Float; return Token::Float;
} else {
error << "error: got exponent character but no exponent digits at "
"offset in float value \""
<< value.c_str() << "\"";
value = error.str();
return Token::Status;
} }
error << "error: got exponent character but no exponent digits at "
"offset in float value \""
<< value.c_str() << "\"";
value = error.str();
return Token::Status;
} else { } else {
// No exponent, but we need at least one decimal after the decimal // No exponent, but we need at least one decimal after the decimal
// point // point
if (got_frac_digits) { if (got_frac_digits) {
return Token::Float; return Token::Float;
} else {
error << "error: no digits after decimal point \"" << value.c_str()
<< "\"";
value = error.str();
return Token::Status;
} }
error << "error: no digits after decimal point \"" << value.c_str()
<< "\"";
value = error.str();
return Token::Status;
} }
} else { } else {
// No decimal point // No decimal point
if (got_int_digits) { if (got_int_digits) {
// We need at least some integer digits to make an integer // We need at least some integer digits to make an integer
return Token::Integer; return Token::Integer;
} else {
error << "error: no digits negate sign \"" << value.c_str() << "\"";
value = error.str();
return Token::Status;
} }
error << "error: no digits negate sign \"" << value.c_str() << "\"";
value = error.str();
return Token::Status;
} }
} else { } else {
error << "error: invalid number found at offset " << start_index; error << "error: invalid number found at offset " << start_index;
Context not available.
JSONParser::Token token = GetToken(value); JSONParser::Token token = GetToken(value);
if (token == JSONParser::Token::Comma) { if (token == JSONParser::Token::Comma) {
continue; continue;
} else if (token == JSONParser::Token::ArrayEnd) { }
if (token == JSONParser::Token::ArrayEnd) {
return JSONValue::SP(array_up.release()); return JSONValue::SP(array_up.release());
} else { } else {
break; break;
Context not available.

tools/debugserver/source/MacOSX/DarwinLog/DarwinLogCollector.cpp

Context not available.
static FilterTarget TargetStringToEnum(const std::string &filter_target_name) { static FilterTarget TargetStringToEnum(const std::string &filter_target_name) {
if (filter_target_name == "activity") if (filter_target_name == "activity")
return eFilterTargetActivity; return eFilterTargetActivity;
else if (filter_target_name == "activity-chain") if (filter_target_name == "activity-chain")
return eFilterTargetActivityChain; return eFilterTargetActivityChain;
else if (filter_target_name == "category") else if (filter_target_name == "category")
return eFilterTargetCategory; return eFilterTargetCategory;
Context not available.
if (depth > MAX_ACTIVITY_CHAIN_DEPTH) { if (depth > MAX_ACTIVITY_CHAIN_DEPTH) {
// Terminating condition - too deeply nested. // Terminating condition - too deeply nested.
return; return;
} else if (activity_id == 0) { }
if (activity_id == 0) {
// Terminating condition - no activity. // Terminating condition - no activity.
return; return;
} }
Context not available.

tools/debugserver/source/MacOSX/MachException.cpp

Context not available.
g_message->exc_type = exc_type; g_message->exc_type = exc_type;
g_message->AppendExceptionData(exc_data, exc_data_count); g_message->AppendExceptionData(exc_data, exc_data_count);
return KERN_SUCCESS; return KERN_SUCCESS;
} else if (!MachTask::IsValid(g_message->task_port)) { }
if (!MachTask::IsValid(g_message->task_port)) {
// Our original exception port isn't valid anymore check for a SIGTRAP // Our original exception port isn't valid anymore check for a SIGTRAP
if (exc_type == EXC_SOFTWARE && exc_data_count == 2 && if (exc_type == EXC_SOFTWARE && exc_data_count == 2 &&
exc_data[0] == EXC_SOFT_SIGNAL && exc_data[1] == SIGTRAP) { exc_data[0] == EXC_SOFT_SIGNAL && exc_data[1] == SIGTRAP) {
Context not available.

tools/debugserver/source/MacOSX/MachProcess.mm

Context not available.
if (kret == KERN_SUCCESS) if (kret == KERN_SUCCESS)
return true; return true;
else
return false; return false;
} }
ThreadInfo::QoS MachProcess::GetRequestedQoS(nub_thread_t tid, nub_addr_t tsd, ThreadInfo::QoS MachProcess::GetRequestedQoS(nub_thread_t tid, nub_addr_t tsd,
Context not available.
m_thread_actions = thread_actions; m_thread_actions = thread_actions;
PrivateResume(); PrivateResume();
return true; return true;
} else if (state == eStateRunning) { }
if (state == eStateRunning) {
DNBLog("Resume() - task 0x%x is already running, ignoring...", DNBLog("Resume() - task 0x%x is already running, ignoring...",
m_task.TaskPort()); m_task.TaskPort());
return true; return true;
Context not available.
"MachProcess::Interrupt() - sent %i signal to interrupt process", "MachProcess::Interrupt() - sent %i signal to interrupt process",
m_sent_interrupt_signo); m_sent_interrupt_signo);
return true; return true;
} else {
m_sent_interrupt_signo = 0;
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - failed to "
"send %i signal to interrupt process",
m_sent_interrupt_signo);
} }
m_sent_interrupt_signo = 0;
DNBLogThreadedIf(LOG_PROCESS,
"MachProcess::Interrupt() - failed to "
"send %i signal to interrupt process",
m_sent_interrupt_signo);
} else { } else {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - previously " DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - previously "
"sent an interrupt signal %i that hasn't " "sent an interrupt signal %i that hasn't "
Context not available.
(uint64_t)addr, (uint64_t)length, (uint64_t)addr, (uint64_t)length,
reinterpret_cast<void *>(bp)); reinterpret_cast<void *>(bp));
return bp; return bp;
} else if (bp->Release() == 0) { }
if (bp->Release() == 0) {
m_breakpoints.Remove(addr); m_breakpoints.Remove(addr);
} }
// We failed to enable the breakpoint // We failed to enable the breakpoint
Context not available.
(uint64_t)addr, (uint64_t)length, (uint64_t)addr, (uint64_t)length,
reinterpret_cast<void *>(wp)); reinterpret_cast<void *>(wp));
return wp; return wp;
} else {
DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = "
"0x%8.8llx, length = %llu) => FAILED",
(uint64_t)addr, (uint64_t)length);
m_watchpoints.Remove(addr);
} }
DNBLogThreadedIf(LOG_WATCHPOINTS,
"MachProcess::CreateWatchpoint ( addr = "
"0x%8.8llx, length = %llu) => FAILED",
(uint64_t)addr, (uint64_t)length);
m_watchpoints.Remove(addr);
// We failed to enable the watchpoint // We failed to enable the watchpoint
return NULL; return NULL;
} }
Context not available.
"0x%8.8llx, remove = %d ) => success", "0x%8.8llx, remove = %d ) => success",
(uint64_t)addr, remove); (uint64_t)addr, remove);
return true; return true;
} else {
if (break_op_found)
DNBLogError("MachProcess::DisableBreakpoint ( addr = "
"0x%8.8llx, remove = %d ) : failed to restore "
"original opcode",
(uint64_t)addr, remove);
else
DNBLogError("MachProcess::DisableBreakpoint ( addr = "
"0x%8.8llx, remove = %d ) : opcode changed",
(uint64_t)addr, remove);
} }
if (break_op_found)
DNBLogError("MachProcess::DisableBreakpoint ( addr = "
"0x%8.8llx, remove = %d ) : failed to restore "
"original opcode",
(uint64_t)addr, remove);
else
DNBLogError("MachProcess::DisableBreakpoint ( addr = "
"0x%8.8llx, remove = %d ) : opcode changed",
(uint64_t)addr, remove);
} else { } else {
DNBLogWarning("MachProcess::DisableBreakpoint: unable to disable " DNBLogWarning("MachProcess::DisableBreakpoint: unable to disable "
"breakpoint 0x%8.8llx", "breakpoint 0x%8.8llx",
Context not available.
"breakpoint already enabled.", "breakpoint already enabled.",
(uint64_t)addr); (uint64_t)addr);
return true; return true;
} else { }
if (bp->HardwarePreferred()) { if (bp->HardwarePreferred()) {
bp->SetHardwareIndex(m_thread_list.EnableHardwareBreakpoint(bp)); bp->SetHardwareIndex(m_thread_list.EnableHardwareBreakpoint(bp));
if (bp->IsHardware()) { if (bp->IsHardware()) {
bp->SetEnabled(true); bp->SetEnabled(true);
return true; return true;
}
} }
}
const nub_size_t break_op_size = bp->ByteSize(); const nub_size_t break_op_size = bp->ByteSize();
assert(break_op_size != 0); assert(break_op_size != 0);
Context not available.
"0x%8.8llx ) : SUCCESS.", "0x%8.8llx ) : SUCCESS.",
(uint64_t)addr); (uint64_t)addr);
return true; return true;
} else {
DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx "
"): breakpoint opcode verification failed.",
(uint64_t)addr);
} }
DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx "
"): breakpoint opcode verification failed.",
(uint64_t)addr);
} else { } else {
DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): " DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
"unable to read memory to verify breakpoint opcode.", "unable to read memory to verify breakpoint opcode.",
Context not available.
"software breakpoint opcode for current architecture.", "software breakpoint opcode for current architecture.",
(uint64_t)addr); (uint64_t)addr);
} }
}
} }
return false; return false;
} }
Context not available.
"watchpoint already enabled.", "watchpoint already enabled.",
(uint64_t)addr); (uint64_t)addr);
return true; return true;
} else { }
// Currently only try and set hardware watchpoints. // Currently only try and set hardware watchpoints.
wp->SetHardwareIndex(m_thread_list.EnableHardwareWatchpoint(wp)); wp->SetHardwareIndex(m_thread_list.EnableHardwareWatchpoint(wp));
if (wp->IsHardware()) { if (wp->IsHardware()) {
wp->SetEnabled(true); wp->SetEnabled(true);
return true; return true;
} }
// TODO: Add software watchpoints by doing page protection tricks. // TODO: Add software watchpoints by doing page protection tricks.
}
} }
return false; return false;
} }
Context not available.
} }
} }
break; break;
} else if (m_sent_interrupt_signo != 0 && }
signo == m_sent_interrupt_signo) { if (m_sent_interrupt_signo != 0 && signo == m_sent_interrupt_signo) {
received_interrupt = true; received_interrupt = true;
} }
} }
Context not available.
::usleep(250000); ::usleep(250000);
DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", pid); DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", pid);
return m_pid; return m_pid;
} else {
::snprintf(err_str, err_len, "%s", err.AsString());
DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", pid);
} }
::snprintf(err_str, err_len, "%s", err.AsString());
DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", pid);
} }
return INVALID_NUB_PROCESS; return INVALID_NUB_PROCESS;
} }
Context not available.
// Status during fork. // Status during fork.
//-------------------------------------------------------------- //--------------------------------------------------------------
return pid; return pid;
} else if (pid == 0) { }
if (pid == 0) {
//-------------------------------------------------------------- //--------------------------------------------------------------
// Child process // Child process
//-------------------------------------------------------------- //--------------------------------------------------------------
Context not available.

tools/debugserver/source/MacOSX/MachTask.mm

Context not available.
err = ::pthread_create(&m_exception_thread, NULL, MachTask::ExceptionThread, err = ::pthread_create(&m_exception_thread, NULL, MachTask::ExceptionThread,
this); this);
return err.Success(); return err.Success();
} else {
DNBLogError("MachTask::%s (): task invalid, exception thread start failed.",
__FUNCTION__);
} }
DNBLogError("MachTask::%s (): task invalid, exception thread start failed.",
__FUNCTION__);
return false; return false;
} }
Context not available.
DNBLogThreadedIf(LOG_EXCEPTIONS, DNBLogThreadedIf(LOG_EXCEPTIONS,
"interrupted, but task still valid, continuing..."); "interrupted, but task still valid, continuing...");
continue; continue;
} else {
DNBLogThreadedIf(LOG_EXCEPTIONS, "task has exited...");
mach_proc->SetState(eStateExited);
// Our task has died, exit the thread.
break;
} }
DNBLogThreadedIf(LOG_EXCEPTIONS, "task has exited...");
mach_proc->SetState(eStateExited);
// Our task has died, exit the thread.
break;
} else if (err.Status() == MACH_RCV_TIMED_OUT) { } else if (err.Status() == MACH_RCV_TIMED_OUT) {
if (num_exceptions_received > 0) { if (num_exceptions_received > 0) {
// We were receiving all current exceptions with a timeout of zero // We were receiving all current exceptions with a timeout of zero
Context not available.
// Task is still ok // Task is still ok
DNBLogThreadedIf(LOG_EXCEPTIONS, "got a timeout, continuing..."); DNBLogThreadedIf(LOG_EXCEPTIONS, "got a timeout, continuing...");
continue; continue;
} else {
DNBLogThreadedIf(LOG_EXCEPTIONS, "task has exited...");
mach_proc->SetState(eStateExited);
// Our task has died, exit the thread.
break;
} }
DNBLogThreadedIf(LOG_EXCEPTIONS, "task has exited...");
mach_proc->SetState(eStateExited);
// Our task has died, exit the thread.
break;
} }
#if defined(WITH_SPRINGBOARD) && !defined(WITH_BKS) #if defined(WITH_SPRINGBOARD) && !defined(WITH_BKS)
Context not available.
getenv("DEBUGSERVER_ZOMBIE_ALLOCATIONS")) { getenv("DEBUGSERVER_ZOMBIE_ALLOCATIONS")) {
::mach_vm_protect(task, (*pos).first, (*pos).second, 0, VM_PROT_NONE); ::mach_vm_protect(task, (*pos).first, (*pos).second, 0, VM_PROT_NONE);
return true; return true;
} else }
return ::mach_vm_deallocate(task, (*pos).first, (*pos).second) == return ::mach_vm_deallocate(task, (*pos).first, (*pos).second) ==
KERN_SUCCESS; KERN_SUCCESS;
} }
} }
return false; return false;
Context not available.

tools/debugserver/source/MacOSX/MachThread.cpp

Context not available.
// This thread is sitting at a breakpoint, ask the breakpoint // This thread is sitting at a breakpoint, ask the breakpoint
// if we should be stopping here. // if we should be stopping here.
return true; return true;
} else { }
if (m_arch_ap->StepNotComplete()) { if (m_arch_ap->StepNotComplete()) {
step_more = true; step_more = true;
return false; return false;
} }
// The thread state is used to let us know what the thread was // The thread state is used to let us know what the thread was
// trying to do. MachThread::ThreadWillResume() will set the // trying to do. MachThread::ThreadWillResume() will set the
// thread state to various values depending if the thread was // thread state to various values depending if the thread was
Context not available.
// If our state is running, then we should continue as we are in // If our state is running, then we should continue as we are in
// the process of stepping over a breakpoint. // the process of stepping over a breakpoint.
return false; return false;
} else {
// Stop if we have any kind of valid exception for this
// thread.
if (GetStopException().IsValid())
return true;
} }
} // Stop if we have any kind of valid exception for this
return false; // thread.
if (GetStopException().IsValid())
return true;
return false;
} }
bool MachThread::IsStepping() { return GetState() == eStateStepping; } bool MachThread::IsStepping() { return GetState() == eStateStepping; }
Context not available.

tools/debugserver/source/MacOSX/MachVMMemory.cpp

Context not available.
(int)vm_info.page_size); (int)vm_info.page_size);
m_page_size = vm_info.page_size; m_page_size = vm_info.page_size;
return m_page_size; return m_page_size;
} else {
DNBLogThreadedIf(LOG_TASK, "MachVMMemory::PageSize task_info call "
"failed to get page size, TASK_VM_INFO %d, "
"TASK_VM_INFO_COUNT %d, kern return %d",
TASK_VM_INFO, TASK_VM_INFO_COUNT, kr);
} }
DNBLogThreadedIf(LOG_TASK,
"MachVMMemory::PageSize task_info call "
"failed to get page size, TASK_VM_INFO %d, "
"TASK_VM_INFO_COUNT %d, kern return %d",
TASK_VM_INFO, TASK_VM_INFO_COUNT, kr);
} }
#endif #endif
m_err = ::host_page_size(::mach_host_self(), &m_page_size); m_err = ::host_page_size(::mach_host_self(), &m_page_size);
Context not available.
if (bytes_written <= 0) { if (bytes_written <= 0) {
// Status should have already be posted by WriteRegion... // Status should have already be posted by WriteRegion...
break; break;
} else {
total_bytes_written += bytes_written;
curr_addr += bytes_written;
curr_data += bytes_written;
} }
total_bytes_written += bytes_written;
curr_addr += bytes_written;
curr_data += bytes_written;
} else { } else {
DNBLogThreadedIf( DNBLogThreadedIf(
LOG_MEMORY_PROTECTIONS, "Failed to set read/write protections on " LOG_MEMORY_PROTECTIONS, "Failed to set read/write protections on "
Context not available.

tools/debugserver/source/MacOSX/MachVMRegion.h

Context not available.
mach_vm_address_t BytesRemaining(mach_vm_address_t addr) const { mach_vm_address_t BytesRemaining(mach_vm_address_t addr) const {
if (ContainsAddress(addr)) if (ContainsAddress(addr))
return m_size - (addr - m_start); return m_size - (addr - m_start);
else
return 0; return 0;
} }
bool ContainsAddress(mach_vm_address_t addr) const { bool ContainsAddress(mach_vm_address_t addr) const {
return addr >= StartAddress() && addr < EndAddress(); return addr >= StartAddress() && addr < EndAddress();
Context not available.

tools/debugserver/source/MacOSX/MachVMRegion.cpp

Context not available.
__FUNCTION__, prot, m_task, (uint64_t)addr); __FUNCTION__, prot, m_task, (uint64_t)addr);
// Protections are already set as requested... // Protections are already set as requested...
return true; return true;
} else { }
m_err = ::mach_vm_protect(m_task, addr, prot_size, 0, prot); m_err = ::mach_vm_protect(m_task, addr, prot_size, 0, prot);
if (DNBLogCheckLogBit(LOG_MEMORY_PROTECTIONS)) if (DNBLogCheckLogBit(LOG_MEMORY_PROTECTIONS))
m_err.LogThreaded("::mach_vm_protect ( task = 0x%4.4x, addr = "
"0x%8.8llx, size = %llu, set_max = %i, prot = %u )",
m_task, (uint64_t)addr, (uint64_t)prot_size, 0, prot);
if (m_err.Fail()) {
// Try again with the ability to create a copy on write region
m_err =
::mach_vm_protect(m_task, addr, prot_size, 0, prot | VM_PROT_COPY);
if (DNBLogCheckLogBit(LOG_MEMORY_PROTECTIONS) || m_err.Fail())
m_err.LogThreaded("::mach_vm_protect ( task = 0x%4.4x, addr = " m_err.LogThreaded("::mach_vm_protect ( task = 0x%4.4x, addr = "
"0x%8.8llx, size = %llu, set_max = %i, prot = %u )", "0x%8.8llx, size = %llu, set_max = %i, prot = %u "
")",
m_task, (uint64_t)addr, (uint64_t)prot_size, 0, m_task, (uint64_t)addr, (uint64_t)prot_size, 0,
prot); prot | VM_PROT_COPY);
if (m_err.Fail()) {
// Try again with the ability to create a copy on write region
m_err = ::mach_vm_protect(m_task, addr, prot_size, 0,
prot | VM_PROT_COPY);
if (DNBLogCheckLogBit(LOG_MEMORY_PROTECTIONS) || m_err.Fail())
m_err.LogThreaded("::mach_vm_protect ( task = 0x%4.4x, addr = "
"0x%8.8llx, size = %llu, set_max = %i, prot = %u "
")",
m_task, (uint64_t)addr, (uint64_t)prot_size, 0,
prot | VM_PROT_COPY);
} }
if (m_err.Success()) { if (m_err.Success()) {
m_curr_protection = prot; m_curr_protection = prot;
Context not available.
m_protection_size = prot_size; m_protection_size = prot_size;
return true; return true;
} }
}
} else { } else {
DNBLogThreadedIf(LOG_MEMORY_PROTECTIONS | LOG_VERBOSE, DNBLogThreadedIf(LOG_MEMORY_PROTECTIONS | LOG_VERBOSE,
"%s: Zero size for task 0x%4.4x at address 0x%8.8llx) ", "%s: Zero size for task 0x%4.4x at address 0x%8.8llx) ",
Context not available.

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

Context not available.
if (DEBUG_FPU_REGS) { if (DEBUG_FPU_REGS) {
m_state.SetError(e_regSetFPU, Write, 0); m_state.SetError(e_regSetFPU, Write, 0);
return m_state.GetError(e_regSetFPU, Write); return m_state.GetError(e_regSetFPU, Write);
} else { }
int flavor = __i386_FLOAT_STATE; int flavor = __i386_FLOAT_STATE;
mach_msg_type_number_t count = e_regSetWordSizeFPU; mach_msg_type_number_t count = e_regSetWordSizeFPU;
if (CPUHasAVX512f() || FORCE_AVX_REGS) { if (CPUHasAVX512f() || FORCE_AVX_REGS) {
flavor = __i386_AVX512F_STATE; flavor = __i386_AVX512F_STATE;
count = e_regSetWordSizeAVX512f; count = e_regSetWordSizeAVX512f;
} else } else
if (CPUHasAVX()) { if (CPUHasAVX()) {
flavor = __i386_AVX_STATE; flavor = __i386_AVX_STATE;
Context not available.
(thread_state_t)&m_state.context.fpu, (thread_state_t)&m_state.context.fpu,
count)); count));
return m_state.GetError(e_regSetFPU, Write); return m_state.GetError(e_regSetFPU, Write);
}
} }
kern_return_t DNBArchImplI386::SetEXCState() { kern_return_t DNBArchImplI386::SetEXCState() {
Context not available.
if (kret == KERN_SUCCESS) if (kret == KERN_SUCCESS)
return true; return true;
else
return false; return false;
} }
bool DNBArchImplI386::FinishTransForHWP() { bool DNBArchImplI386::FinishTransForHWP() {
m_2pc_trans_state = Trans_Done; m_2pc_trans_state = Trans_Done;
Context not available.
if (kret == KERN_SUCCESS) if (kret == KERN_SUCCESS)
return i; return i;
else // Revert to the previous debug state voluntarily. The transaction // Revert to the previous debug state voluntarily. The transaction
// coordinator knows that we have failed. // coordinator knows that we have failed.
m_state.context.dbg = GetDBGCheckpoint(); m_state.context.dbg = GetDBGCheckpoint();
} else { } else {
DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchImplI386::" DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchImplI386::"
"EnableHardwareWatchpoint(): All " "EnableHardwareWatchpoint(): All "
Context not available.
if (kret == KERN_SUCCESS) if (kret == KERN_SUCCESS)
return true; return true;
else // Revert to the previous debug state voluntarily. The transaction // Revert to the previous debug state voluntarily. The transaction
// coordinator knows that we have failed. // coordinator knows that we have failed.
m_state.context.dbg = GetDBGCheckpoint(); m_state.context.dbg = GetDBGCheckpoint();
} }
} }
return false; return false;
Context not available.
return g_reg_sets_avx512f; return g_reg_sets_avx512f;
if (CPUHasAVX()) if (CPUHasAVX())
return g_reg_sets_avx; return g_reg_sets_avx;
else
return g_reg_sets_no_avx; return g_reg_sets_no_avx;
} }
void DNBArchImplI386::Initialize() { void DNBArchImplI386::Initialize() {
Context not available.

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

Context not available.
if (m_state.GetError(e_regSetFPU, Read) == KERN_SUCCESS) if (m_state.GetError(e_regSetFPU, Read) == KERN_SUCCESS)
return m_state.GetError(e_regSetFPU, Read); return m_state.GetError(e_regSetFPU, Read);
else
DNBLogThreadedIf(LOG_THREAD, DNBLogThreadedIf(LOG_THREAD,
"::thread_get_state attempted fetch of avx512 fpu regctx failed, will try fetching avx"); "::thread_get_state attempted fetch of avx512 fpu "
"regctx failed, will try fetching avx");
} }
if (CPUHasAVX() || FORCE_AVX_REGS) { if (CPUHasAVX() || FORCE_AVX_REGS) {
count = e_regSetWordSizeAVX; count = e_regSetWordSizeAVX;
Context not available.
if (DEBUG_FPU_REGS) { if (DEBUG_FPU_REGS) {
m_state.SetError(e_regSetFPU, Write, 0); m_state.SetError(e_regSetFPU, Write, 0);
return m_state.GetError(e_regSetFPU, Write); return m_state.GetError(e_regSetFPU, Write);
} else { }
int flavor = __x86_64_FLOAT_STATE; int flavor = __x86_64_FLOAT_STATE;
mach_msg_type_number_t count = e_regSetWordSizeFPU; mach_msg_type_number_t count = e_regSetWordSizeFPU;
if (CPUHasAVX512f() || FORCE_AVX_REGS) { if (CPUHasAVX512f() || FORCE_AVX_REGS) {
count = e_regSetWordSizeAVX512f; count = e_regSetWordSizeAVX512f;
flavor = __x86_64_AVX512F_STATE; flavor = __x86_64_AVX512F_STATE;
m_state.SetError( m_state.SetError(e_regSetFPU, Write,
e_regSetFPU, Write, ::thread_set_state(m_thread->MachPortNumber(), flavor,
::thread_set_state(m_thread->MachPortNumber(), flavor, (thread_state_t)&m_state.context.fpu,
(thread_state_t)&m_state.context.fpu, count)); count));
if (m_state.GetError(e_regSetFPU, Write) == KERN_SUCCESS) if (m_state.GetError(e_regSetFPU, Write) == KERN_SUCCESS)
return m_state.GetError(e_regSetFPU, Write); return m_state.GetError(e_regSetFPU, Write);
else
DNBLogThreadedIf(LOG_THREAD, DNBLogThreadedIf(LOG_THREAD,
"::thread_get_state attempted save of avx512 fpu regctx failed, will try saving avx regctx"); "::thread_get_state attempted save of avx512 fpu regctx "
"failed, will try saving avx regctx");
} }
if (CPUHasAVX() || FORCE_AVX_REGS) { if (CPUHasAVX() || FORCE_AVX_REGS) {
Context not available.
::thread_set_state(m_thread->MachPortNumber(), flavor, ::thread_set_state(m_thread->MachPortNumber(), flavor,
(thread_state_t)&m_state.context.fpu, count)); (thread_state_t)&m_state.context.fpu, count));
return m_state.GetError(e_regSetFPU, Write); return m_state.GetError(e_regSetFPU, Write);
}
} }
kern_return_t DNBArchImplX86_64::SetEXCState() { kern_return_t DNBArchImplX86_64::SetEXCState() {
Context not available.
if (kret == KERN_SUCCESS) if (kret == KERN_SUCCESS)
return true; return true;
else
return false; 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.
if (kret == KERN_SUCCESS) if (kret == KERN_SUCCESS)
return i; return i;
else // Revert to the previous debug state voluntarily. The transaction // Revert to the previous debug state voluntarily. The transaction
// coordinator knows that we have failed. // coordinator knows that we have failed.
m_state.context.dbg = GetDBGCheckpoint(); m_state.context.dbg = GetDBGCheckpoint();
} else { } else {
DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchImplX86_64::" DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchImplX86_64::"
"EnableHardwareWatchpoint(): All " "EnableHardwareWatchpoint(): All "
Context not available.
if (kret == KERN_SUCCESS) if (kret == KERN_SUCCESS)
return true; return true;
else // Revert to the previous debug state voluntarily. The transaction // Revert to the previous debug state voluntarily. The transaction
// coordinator knows that we have failed. // coordinator knows that we have failed.
m_state.context.dbg = GetDBGCheckpoint(); m_state.context.dbg = GetDBGCheckpoint();
} }
} }
return false; return false;
Context not available.
return g_reg_sets_avx512f; return g_reg_sets_avx512f;
if (CPUHasAVX() || FORCE_AVX_REGS) if (CPUHasAVX() || FORCE_AVX_REGS)
return g_reg_sets_avx; return g_reg_sets_avx;
else
return g_reg_sets_no_avx; return g_reg_sets_no_avx;
} }
void DNBArchImplX86_64::Initialize() { void DNBArchImplX86_64::Initialize() {
Context not available.

tools/debugserver/source/RNBContext.cpp

Context not available.
const char *RNBContext::EnvironmentAtIndex(size_t index) { const char *RNBContext::EnvironmentAtIndex(size_t index) {
if (index < m_env_vec.size()) if (index < m_env_vec.size())
return m_env_vec[index].c_str(); return m_env_vec[index].c_str();
else
return NULL; return NULL;
} }
static std::string GetEnvironmentKey(const std::string &env) { static std::string GetEnvironmentKey(const std::string &env) {
Context not available.
const char *RNBContext::ArgumentAtIndex(size_t index) { const char *RNBContext::ArgumentAtIndex(size_t index) {
if (index < m_arg_vec.size()) if (index < m_arg_vec.size())
return m_arg_vec[index].c_str(); return m_arg_vec[index].c_str();
else
return NULL; return NULL;
} }
bool RNBContext::SetWorkingDirectory(const char *path) { bool RNBContext::SetWorkingDirectory(const char *path) {
Context not available.

tools/debugserver/source/RNBRemote.cpp

Context not available.
int ch = decoded_hex_ascii_char(c); int ch = decoded_hex_ascii_char(c);
if (ch == -1) if (ch == -1)
break; break;
else
arg.push_back(ch); arg.push_back(ch);
} }
} }
return arg; return arg;
Context not available.
payload.c_str()); payload.c_str());
HandlePacket_UNIMPLEMENTED(payload.c_str()); HandlePacket_UNIMPLEMENTED(payload.c_str());
return rnb_err; return rnb_err;
} else {
packet_info = *it;
packet_payload = payload;
} }
packet_info = *it;
packet_payload = payload;
} }
return err; return err;
} }
Context not available.
if (type != NULL) if (type != NULL)
*type = packet_info.type; *type = packet_info.type;
return (this->*packet_callback)(packet_data.c_str()); return (this->*packet_callback)(packet_data.c_str());
} else {
// Do not fall through to end of this function, if we have valid
// packet_info and it has a NULL callback, then we need to respect
// that it may not want any response or anything to be done.
return err;
} }
// Do not fall through to end of this function, if we have valid
// packet_info and it has a NULL callback, then we need to respect
// that it may not want any response or anything to be done.
return err;
} }
return rnb_err; return rnb_err;
} }
Context not available.
#elif defined(__i386__) || defined(__x86_64__) #elif defined(__i386__) || defined(__x86_64__)
if (sizeof(char *) == 8) { if (sizeof(char *) == 8) {
return CPU_TYPE_X86_64; return CPU_TYPE_X86_64;
} else {
return CPU_TYPE_I386;
} }
return CPU_TYPE_I386;
#endif #endif
return 0; return 0;
} }
Context not available.
ostrm << std::hex << th; ostrm << std::hex << th;
} }
return SendPacket(ostrm.str()); return SendPacket(ostrm.str());
} else {
return SendPacket("l");
} }
return SendPacket("l");
} }
rnb_err_t RNBRemote::HandlePacket_qThreadExtraInfo(const char *p) { rnb_err_t RNBRemote::HandlePacket_qThreadExtraInfo(const char *p) {
Context not available.
const char *threadInfo = DNBThreadGetInfo(pid, tid); const char *threadInfo = DNBThreadGetInfo(pid, tid);
if (threadInfo != NULL && threadInfo[0]) { if (threadInfo != NULL && threadInfo[0]) {
return SendHexEncodedBytePacket(NULL, threadInfo, strlen(threadInfo), NULL); return SendHexEncodedBytePacket(NULL, threadInfo, strlen(threadInfo), NULL);
} else {
// "OK" == 4f6b
// Return "OK" as a ASCII hex byte stream if things go wrong
return SendPacket("4f6b");
} }
// "OK" == 4f6b
// Return "OK" as a ASCII hex byte stream if things go wrong
return SendPacket("4f6b");
return SendPacket(""); return SendPacket("");
} }
Context not available.
return SendPacket("OK"); return SendPacket("OK");
} }
return SendPacket("E71"); return SendPacket("E71");
} else if (variable.compare("logmask") == 0) { }
if (variable.compare("logmask") == 0) {
char *end; char *end;
errno = 0; errno = 0;
uint32_t logmask = uint32_t logmask =
Context not available.
rnb_err_t result = set_logging(p); rnb_err_t result = set_logging(p);
if (result == rnb_success) if (result == rnb_success)
return SendPacket("OK"); return SendPacket("OK");
else
return SendPacket("E35"); return SendPacket("E35");
} }
rnb_err_t RNBRemote::HandlePacket_QSetDisableASLR(const char *p) { rnb_err_t RNBRemote::HandlePacket_QSetDisableASLR(const char *p) {
Context not available.
if (::stat(m_ctx.GetWorkingDirPath(), &working_dir_stat) == -1) { if (::stat(m_ctx.GetWorkingDirPath(), &working_dir_stat) == -1) {
m_ctx.GetWorkingDir().clear(); m_ctx.GetWorkingDir().clear();
return SendPacket("E61"); // Working directory doesn't exist... return SendPacket("E61"); // Working directory doesn't exist...
} else if ((working_dir_stat.st_mode & S_IFMT) == S_IFDIR) { }
if ((working_dir_stat.st_mode & S_IFMT) == S_IFDIR) {
return SendPacket("OK"); return SendPacket("OK");
} else { } else {
m_ctx.GetWorkingDir().clear(); m_ctx.GetWorkingDir().clear();
Context not available.
} }
if (DNBProcessSyncThreadState(m_ctx.ProcessID(), tid)) if (DNBProcessSyncThreadState(m_ctx.ProcessID(), tid))
return SendPacket("OK"); return SendPacket("OK");
else
return SendPacket("E61"); return SendPacket("E61");
} }
rnb_err_t RNBRemote::HandlePacket_QSetDetachOnError(const char *p) { rnb_err_t RNBRemote::HandlePacket_QSetDetachOnError(const char *p) {
Context not available.
if (Context().HasValidProcessID()) { if (Context().HasValidProcessID()) {
if (DNBProcessSendEvent(Context().ProcessID(), p)) if (DNBProcessSendEvent(Context().ProcessID(), p))
return SendPacket("OK"); return SendPacket("OK");
else
return SendPacket("E80"); return SendPacket("E80");
} else { } else {
Context().PushProcessEvent(p); Context().PushProcessEvent(p);
} }
Context not available.
exit_packet << RAWHEX8(exit_info[i]); exit_packet << RAWHEX8(exit_info[i]);
exit_packet << ';'; exit_packet << ';';
return SendPacket(exit_packet.str()); return SendPacket(exit_packet.str());
} else }
return SendPacket(pid_exited_packet); return SendPacket(pid_exited_packet);
} break; } break;
} }
return rnb_success; return rnb_success;
Context not available.
DNBProcessMemoryWrite(m_ctx.ProcessID(), addr, length, buf); DNBProcessMemoryWrite(m_ctx.ProcessID(), addr, length, buf);
if (wrote != length) if (wrote != length)
return SendPacket("E09"); return SendPacket("E09");
else
return SendPacket("OK"); return SendPacket("OK");
} }
rnb_err_t RNBRemote::HandlePacket_m(const char *p) { rnb_err_t RNBRemote::HandlePacket_m(const char *p) {
Context not available.
DNBThreadSetRegisterContext(pid, tid, reg_ctx.data(), reg_ctx.size()); DNBThreadSetRegisterContext(pid, tid, reg_ctx.data(), reg_ctx.size());
if (reg_ctx_size == reg_ctx.size()) if (reg_ctx_size == reg_ctx.size())
return SendPacket("OK"); return SendPacket("OK");
else
return SendPacket("E55"); return SendPacket("E55");
} else { } else {
DNBLogError("RNBRemote::HandlePacket_G(%s): extracted %llu of %llu " DNBLogError("RNBRemote::HandlePacket_G(%s): extracted %llu of %llu "
"bytes, size mismatch\n", "bytes, size mismatch\n",
Context not available.
RNBRemote *remote = remoteSP.get(); RNBRemote *remote = remoteSP.get();
if (remote->Comm().IsConnected()) if (remote->Comm().IsConnected())
return false; return false;
else
return true; return true;
} }
return true; return true;
} }
Context not available.
return HandlePacket_ILLFORMED( return HandlePacket_ILLFORMED(
__FILE__, __LINE__, p, __FILE__, __LINE__, p,
"No thread specified in QSaveRegisterState packet"); "No thread specified in QSaveRegisterState packet");
else
return HandlePacket_ILLFORMED(__FILE__, __LINE__, p, return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
"No thread was is set with the Hg packet"); "No thread was is set with the Hg packet");
} }
// Get the register context size first by calling with NULL buffer // Get the register context size first by calling with NULL buffer
Context not available.
char response[64]; char response[64];
snprintf(response, sizeof(response), "%u", save_id); snprintf(response, sizeof(response), "%u", save_id);
return SendPacket(response); return SendPacket(response);
} else {
return SendPacket("E75");
} }
return SendPacket("E75");
} }
// FORMAT: QRestoreRegisterState:SAVEID;thread:TTTT; (when thread suffix is // FORMAT: QRestoreRegisterState:SAVEID;thread:TTTT; (when thread suffix is
// supported) // supported)
Context not available.
return HandlePacket_ILLFORMED( return HandlePacket_ILLFORMED(
__FILE__, __LINE__, p, __FILE__, __LINE__, p,
"No thread specified in QSaveRegisterState packet"); "No thread specified in QSaveRegisterState packet");
else
return HandlePacket_ILLFORMED(__FILE__, __LINE__, p, return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
"No thread was is set with the Hg packet"); "No thread was is set with the Hg packet");
} }
StdStringExtractor packet(p); StdStringExtractor packet(p);
Context not available.
// Get the register context size first by calling with NULL buffer // Get the register context size first by calling with NULL buffer
if (DNBThreadRestoreRegisterState(pid, tid, save_id)) if (DNBThreadRestoreRegisterState(pid, tid, save_id))
return SendPacket("OK"); return SendPacket("OK");
else
return SendPacket("E77"); return SendPacket("E77");
} }
return SendPacket("E76"); return SendPacket("E76");
} }
Context not available.
if (strcmp(p, "vCont;c") == 0) { if (strcmp(p, "vCont;c") == 0) {
// Simple continue // Simple continue
return RNBRemote::HandlePacket_c("c"); return RNBRemote::HandlePacket_c("c");
} else if (strcmp(p, "vCont;s") == 0) { }
if (strcmp(p, "vCont;s") == 0) {
// Simple step // Simple step
return RNBRemote::HandlePacket_s("s"); return RNBRemote::HandlePacket_s("s");
} else if (strstr(p, "vCont") == p) { } else if (strstr(p, "vCont") == p) {
Context not available.
// Send a stop reply packet to indicate we successfully attached! // Send a stop reply packet to indicate we successfully attached!
NotifyThatProcessStopped(); NotifyThatProcessStopped();
return rnb_success; return rnb_success;
} else { }
m_ctx.LaunchStatus().SetError(-1, DNBError::Generic); m_ctx.LaunchStatus().SetError(-1, DNBError::Generic);
if (err_str[0]) if (err_str[0])
m_ctx.LaunchStatus().SetErrorString(err_str); m_ctx.LaunchStatus().SetErrorString(err_str);
else else
m_ctx.LaunchStatus().SetErrorString("attach failed"); m_ctx.LaunchStatus().SetErrorString("attach failed");
#if defined(__APPLE__) && \ #if defined(__APPLE__) && \
(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101000) (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101000)
Context not available.
SendPacket("E01"); // E01 is our magic error value for attach failed. SendPacket("E01"); // E01 is our magic error value for attach failed.
DNBLogError("Attach failed: \"%s\".", err_str); DNBLogError("Attach failed: \"%s\".", err_str);
return rnb_err; return rnb_err;
}
} }
// All other failures come through here // All other failures come through here
Context not available.
// a ref count structure with the breakID and add it to our // a ref count structure with the breakID and add it to our
// map. // map.
return SendPacket("OK"); return SendPacket("OK");
} else {
// We failed to set the software breakpoint
return SendPacket("E09");
} }
// We failed to set the software breakpoint
return SendPacket("E09");
} break; } break;
case '2': // set write watchpoint case '2': // set write watchpoint
Context not available.
if (DNBWatchpointSet(pid, addr, byte_size, watch_flags, hardware)) { if (DNBWatchpointSet(pid, addr, byte_size, watch_flags, hardware)) {
return SendPacket("OK"); return SendPacket("OK");
} else {
// We failed to set the watchpoint
return SendPacket("E09");
} }
// We failed to set the watchpoint
return SendPacket("E09");
} break; } break;
default: default:
Context not available.
std::string data = DNBProcessGetProfileData(pid, scan_type); std::string data = DNBProcessGetProfileData(pid, scan_type);
if (!data.empty()) { if (!data.empty()) {
return SendPacket(data.c_str()); return SendPacket(data.c_str());
} else {
return SendPacket("OK");
} }
return SendPacket("OK");
} }
// QSetEnableAsyncProfiling;enable:[0|1]:interval_usec:XXXXXX;scan_type:0xYYYYYYY // QSetEnableAsyncProfiling;enable:[0|1]:interval_usec:XXXXXX;scan_type:0xYYYYYYY
Context not available.
EnableCompressionNextSendPacket(compression_types::zlib_deflate); EnableCompressionNextSendPacket(compression_types::zlib_deflate);
m_compression_minsize = new_compression_minsize; m_compression_minsize = new_compression_minsize;
return SendPacket("OK"); return SendPacket("OK");
} else if (strstr(p, "type:lz4;") != nullptr) { }
if (strstr(p, "type:lz4;") != nullptr) {
EnableCompressionNextSendPacket(compression_types::lz4); EnableCompressionNextSendPacket(compression_types::lz4);
m_compression_minsize = new_compression_minsize; m_compression_minsize = new_compression_minsize;
return SendPacket("OK"); return SendPacket("OK");
Context not available.
return HandlePacket_ILLFORMED( return HandlePacket_ILLFORMED(
__FILE__, __LINE__, p, __FILE__, __LINE__, p,
"Didn't find response_size value at right offset"); "Didn't find response_size value at right offset");
else if (*end == ';') { if (*end == ';') {
static char g_data[4 * 1024 * 1024 + 16] = "data:"; static char g_data[4 * 1024 * 1024 + 16] = "data:";
memset(g_data + 5, 'a', response_size); memset(g_data + 5, 'a', response_size);
g_data[response_size + 5] = '\0'; g_data[response_size + 5] = '\0';
Context not available.
if (errno != 0) if (errno != 0)
return HandlePacket_ILLFORMED(__FILE__, __LINE__, p, return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
"Could not parse signal in C packet"); "Could not parse signal in C packet");
else if (*end == ';') { if (*end == ';') {
errno = 0; errno = 0;
action.addr = strtoull(end + 1, NULL, 16); action.addr = strtoull(end + 1, NULL, 16);
if (errno != 0 && action.addr == 0) if (errno != 0 && action.addr == 0)
Context not available.
if (errno != 0) if (errno != 0)
return HandlePacket_ILLFORMED(__FILE__, __LINE__, p, return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
"Could not parse signal in S packet"); "Could not parse signal in S packet");
else if (*end == ';') { if (*end == ';') {
errno = 0; errno = 0;
action.addr = strtoull(end + 1, NULL, 16); action.addr = strtoull(end + 1, NULL, 16);
if (errno != 0 && action.addr == 0) { if (errno != 0 && action.addr == 0) {
Context not available.
if (strncmp(c, "true", 4) == 0) { if (strncmp(c, "true", 4) == 0) {
value = true; value = true;
return true; return true;
} else if (strncmp(c, "false", 5) == 0) { }
if (strncmp(c, "false", 5) == 0) {
value = false; value = false;
return true; return true;
} }
Context not available.
if (json_str.str().size() > 0) { if (json_str.str().size() > 0) {
std::string json_str_quoted = binary_encode_string(json_str.str()); std::string json_str_quoted = binary_encode_string(json_str.str());
return SendPacket(json_str_quoted.c_str()); return SendPacket(json_str_quoted.c_str());
} else {
SendPacket("E84");
} }
SendPacket("E84");
} }
} }
return SendPacket("OK"); return SendPacket("OK");
Context not available.
if (json_str.str().size() > 0) { if (json_str.str().size() > 0) {
std::string json_str_quoted = binary_encode_string(json_str.str()); std::string json_str_quoted = binary_encode_string(json_str.str());
return SendPacket(json_str_quoted.c_str()); return SendPacket(json_str_quoted.c_str());
} else {
SendPacket("E86");
} }
SendPacket("E86");
} }
} }
return SendPacket("OK"); return SendPacket("OK");
Context not available.
if (symbol_name.empty()) { if (symbol_name.empty()) {
// Done with symbol lookups // Done with symbol lookups
return SendPacket("OK"); return SendPacket("OK");
} else {
std::ostringstream reply;
reply << "qSymbol:";
for (size_t i = 0; i < symbol_name.size(); ++i)
reply << RAWHEX8(symbol_name[i]);
return SendPacket(reply.str().c_str());
} }
std::ostringstream reply;
reply << "qSymbol:";
for (size_t i = 0; i < symbol_name.size(); ++i)
reply << RAWHEX8(symbol_name[i]);
return SendPacket(reply.str().c_str());
} }
// Note that all numeric values returned by qProcessInfo are hex encoded, // Note that all numeric values returned by qProcessInfo are hex encoded,
Context not available.
if (m_dispatch_queue_offsets.IsValid()) if (m_dispatch_queue_offsets.IsValid())
return &m_dispatch_queue_offsets; return &m_dispatch_queue_offsets;
else
return nullptr; return nullptr;
} }
void RNBRemote::EnableCompressionNextSendPacket(compression_types type) { void RNBRemote::EnableCompressionNextSendPacket(compression_types type) {
Context not available.

tools/debugserver/source/RNBServices.cpp

Context not available.
if (bytes != NULL && size > 0) { if (bytes != NULL && size > 0) {
plist.assign((const char *)bytes, size); plist.assign((const char *)bytes, size);
return 0; // Success return 0; // Success
} else {
DNBLogError("empty application property list.");
result = -2;
} }
DNBLogError("empty application property list.");
result = -2;
} else { } else {
DNBLogError("serializing task list."); DNBLogError("serializing task list.");
result = -3; result = -3;
Context not available.

tools/debugserver/source/RNBSocket.cpp

Context not available.
strcmp(hostname, "127.0.0.1") == 0) { strcmp(hostname, "127.0.0.1") == 0) {
addr = htonl(INADDR_LOOPBACK); addr = htonl(INADDR_LOOPBACK);
return true; return true;
} else if (strcmp(hostname, "*") == 0) { }
if (strcmp(hostname, "*") == 0) {
addr = htonl(INADDR_ANY); addr = htonl(INADDR_ANY);
return true; return true;
} else { } else {
Context not available.
err.SetError(errno, DNBError::POSIX); err.SetError(errno, DNBError::POSIX);
err.LogThreaded("can't open file '%s'", path); err.LogThreaded("can't open file '%s'", path);
return rnb_not_connected; return rnb_not_connected;
} else { }
struct termios stdin_termios; struct termios stdin_termios;
if (::tcgetattr(m_fd, &stdin_termios) == 0) { if (::tcgetattr(m_fd, &stdin_termios) == 0) {
stdin_termios.c_lflag &= ~ECHO; // Turn off echoing stdin_termios.c_lflag &= ~ECHO; // Turn off echoing
stdin_termios.c_lflag &= ~ICANON; // Get one char at a time stdin_termios.c_lflag &= ~ICANON; // Get one char at a time
::tcsetattr(m_fd, TCSANOW, &stdin_termios); ::tcsetattr(m_fd, TCSANOW, &stdin_termios);
} }
}
return rnb_success; return rnb_success;
} }
int RNBSocket::SetSocketOption(int fd, int level, int option_name, int RNBSocket::SetSocketOption(int fd, int level, int option_name,
Context not available.
if (bytesread == 0) { if (bytesread == 0) {
m_fd = -1; m_fd = -1;
return rnb_not_connected; return rnb_not_connected;
} else if (bytesread == -1) { }
if (bytesread == -1) {
m_fd = -1; m_fd = -1;
return rnb_err; return rnb_err;
} }
Context not available.

tools/debugserver/source/libdebugserver.cpp

Context not available.
if (type == RNBRemote::vattach || type == RNBRemote::vattachwait) { if (type == RNBRemote::vattach || type == RNBRemote::vattachwait) {
if (err == rnb_success) if (err == rnb_success)
return eRNBRunLoopModeInferiorExecuting; return eRNBRunLoopModeInferiorExecuting;
else {
RNBLogSTDERR("error: attach failed."); RNBLogSTDERR("error: attach failed.");
return eRNBRunLoopModeExit; return eRNBRunLoopModeExit;
}
} }
if (err == rnb_success) { if (err == rnb_success) {
DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s Got success...", __FUNCTION__); DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s Got success...", __FUNCTION__);
continue; continue;
} else if (err == rnb_not_connected) { }
if (err == rnb_not_connected) {
RNBLogSTDERR("error: connection lost."); RNBLogSTDERR("error: connection lost.");
return eRNBRunLoopModeExit; return eRNBRunLoopModeExit;
} else { } else {
Context not available.

tools/lldb-mi/MICmdArgValFile.cpp

Context not available.
m_argValue = rFile.Trim('"'); m_argValue = rFile.Trim('"');
vwArgContext.RemoveArg(rFile); vwArgContext.RemoveArg(rFile);
return MIstatus::success; return MIstatus::success;
} else }
return MIstatus::failure; return MIstatus::failure;
} }
// In reality there are more than one option, if so the file option // In reality there are more than one option, if so the file option
Context not available.
m_bValid = true; m_bValid = true;
m_argValue = rTxt.Trim('"'); m_argValue = rTxt.Trim('"');
return MIstatus::success; return MIstatus::success;
} else }
return MIstatus::success; return MIstatus::success;
} }
// Next // Next
Context not available.

tools/lldb-mi/MICmdArgValListOfN.cpp

Context not available.
m_bValid = true; m_bValid = true;
vwArgContext.RemoveArg(rArg); vwArgContext.RemoveArg(rArg);
return MIstatus::success; return MIstatus::success;
} else }
return MIstatus::failure; return MIstatus::failure;
} }
//++ //++
Context not available.

tools/lldb-mi/MICmdArgValNumber.cpp

Context not available.
m_argValue = GetNumber(); m_argValue = GetNumber();
vwArgContext.RemoveArg(rArg); vwArgContext.RemoveArg(rArg);
return MIstatus::success; return MIstatus::success;
} else }
return MIstatus::failure; return MIstatus::failure;
} }
// More than one option... // More than one option...
Context not available.
m_bValid = true; m_bValid = true;
m_argValue = GetNumber(); m_argValue = GetNumber();
return MIstatus::success; return MIstatus::success;
} else }
return MIstatus::failure; return MIstatus::failure;
} }
// Next // Next
Context not available.

tools/lldb-mi/MICmdArgValOptionLong.cpp

Context not available.
m_bIsMissingOptions = true; m_bIsMissingOptions = true;
return MIstatus::failure; return MIstatus::failure;
} else }
return MIstatus::failure; return MIstatus::failure;
} }
// More than one option... // More than one option...
Context not available.
m_bIsMissingOptions = true; m_bIsMissingOptions = true;
return MIstatus::failure; return MIstatus::failure;
} else {
m_bValid = true;
return MIstatus::success;
} }
m_bValid = true;
return MIstatus::success;
} }
// Next // Next
Context not available.

tools/lldb-mi/MICmdArgValString.cpp

Context not available.
m_bValid = true; m_bValid = true;
m_argValue = rArg.StripSlashes(); m_argValue = rArg.StripSlashes();
return MIstatus::success; return MIstatus::success;
} else }
return MIstatus::failure; return MIstatus::failure;
} }
// Next // Next
Context not available.

tools/lldb-mi/MICmdArgValThreadGrp.cpp

Context not available.
m_argValue = GetNumber(); m_argValue = GetNumber();
vwArgContext.RemoveArg(rArg); vwArgContext.RemoveArg(rArg);
return MIstatus::success; return MIstatus::success;
} else }
return MIstatus::failure; return MIstatus::failure;
} }
// More than one option... // More than one option...
Context not available.
m_bValid = true; m_bValid = true;
m_argValue = GetNumber(); m_argValue = GetNumber();
return MIstatus::success; return MIstatus::success;
} else }
return MIstatus::failure; return MIstatus::failure;
} }
// Next // Next
Context not available.

tools/lldb-mi/MICmdCmdData.cpp

Context not available.
if (error.Fail()) { if (error.Fail()) {
SetError(error.GetCString()); SetError(error.GetCString());
return MIstatus::failure; return MIstatus::failure;
} else if (!addrExprValue.IsValid()) { }
if (!addrExprValue.IsValid()) {
SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_EXPR_INVALID), SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_EXPR_INVALID),
rAddrExpr.c_str())); rAddrExpr.c_str()));
return MIstatus::failure; return MIstatus::failure;
Context not available.

tools/lldb-mi/MICmdCmdGdbShow.cpp

Context not available.
miValueResult); miValueResult);
m_miResultRecord = miRecordResult; m_miResultRecord = miRecordResult;
return MIstatus::success; return MIstatus::success;
} else if (m_bGdbOptionFnSuccessful) { }
if (m_bGdbOptionFnSuccessful) {
// Ignore empty value (for fallback) // Ignore empty value (for fallback)
const CMICmnMIResultRecord miRecordResult( const CMICmnMIResultRecord miRecordResult(
m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done); m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done);
Context not available.

tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

Context not available.
if (bYesAccessible) { if (bYesAccessible) {
vwrResolvedPath = strTestPath; vwrResolvedPath = strTestPath;
return MIstatus::success; return MIstatus::success;
} else }
nFoldersBack++; nFoldersBack++;
} }
// No files exist in the union of working directory and debuginfo path // No files exist in the union of working directory and debuginfo path
Context not available.

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

Context not available.
if (nChildren == 0) { if (nChildren == 0) {
vwrValue = GetValueSummary(!m_bHandleCharType && IsCharType(), kUnknownValue); vwrValue = GetValueSummary(!m_bHandleCharType && IsCharType(), kUnknownValue);
return MIstatus::success; return MIstatus::success;
} else if (IsPointerType()) { }
vwrValue = if (IsPointerType()) {
GetValueSummary(!m_bHandleCharType && IsPointeeCharType(), kUnknownValue); vwrValue = GetValueSummary(!m_bHandleCharType && IsPointeeCharType(),
kUnknownValue);
return MIstatus::success; return MIstatus::success;
} else if (IsArrayType()) { } else if (IsArrayType()) {
CMICmnLLDBDebugSessionInfo &rSessionInfo( CMICmnLLDBDebugSessionInfo &rSessionInfo(
Context not available.
IsFirstChildCharType()) { IsFirstChildCharType()) {
vwrValue = GetValueSummary(false); vwrValue = GetValueSummary(false);
return MIstatus::success; return MIstatus::success;
} else if (vbHandleArrayType) { }
if (vbHandleArrayType) {
vwrValue = CMIUtilString::Format("[%u]", nChildren); vwrValue = CMIUtilString::Format("[%u]", nChildren);
return MIstatus::success; return MIstatus::success;
} }
Context not available.
process.ReadMemory(addr, &ch, sizeof(ch), error); process.ReadMemory(addr, &ch, sizeof(ch), error);
if (error.Fail() || nReadBytes != sizeof(ch)) if (error.Fail() || nReadBytes != sizeof(ch))
return kUnknownValue; return kUnknownValue;
else if (ch == 0) if (ch == 0)
break; break;
result.append( result.append(
CMIUtilString::ConvertToPrintableASCII(ch, true /* bEscapeQuotes */)); CMIUtilString::ConvertToPrintableASCII(ch, true /* bEscapeQuotes */));
Context not available.

tools/lldb-mi/MIDriverMgr.cpp

Context not available.
CMIUtilString CMIDriverMgr::DriverGetError() const { CMIUtilString CMIDriverMgr::DriverGetError() const {
if (m_pDriverCurrent != nullptr) if (m_pDriverCurrent != nullptr)
return m_pDriverCurrent->GetError(); return m_pDriverCurrent->GetError();
else {
const CMIUtilString errMsg(MIRSRC(IDS_DRIVER_ERR_CURRENT_NOT_SET)); const CMIUtilString errMsg(MIRSRC(IDS_DRIVER_ERR_CURRENT_NOT_SET));
CMICmnStreamStdout::Instance().Write(errMsg, true); CMICmnStreamStdout::Instance().Write(errMsg, true);
}
return CMIUtilString(); return CMIUtilString();
} }
Context not available.
CMIUtilString CMIDriverMgr::DriverGetName() const { CMIUtilString CMIDriverMgr::DriverGetName() const {
if (m_pDriverCurrent != nullptr) if (m_pDriverCurrent != nullptr)
return m_pDriverCurrent->GetName(); return m_pDriverCurrent->GetName();
else {
const CMIUtilString errMsg(MIRSRC(IDS_DRIVER_ERR_CURRENT_NOT_SET)); const CMIUtilString errMsg(MIRSRC(IDS_DRIVER_ERR_CURRENT_NOT_SET));
CMICmnStreamStdout::Instance().Write(errMsg, true); CMICmnStreamStdout::Instance().Write(errMsg, true);
}
return CMIUtilString(); return CMIUtilString();
} }
Context not available.

tools/lldb-mi/MIUtilMapIdToVariant.h

Context not available.
vrwbFound = true; vrwbFound = true;
vrwData = *pDataObj; vrwData = *pDataObj;
return MIstatus::success; return MIstatus::success;
} else {
SetErrorDescription(MIRSRC(IDS_VARIANT_ERR_USED_BASECLASS));
return MIstatus::failure;
} }
SetErrorDescription(MIRSRC(IDS_VARIANT_ERR_USED_BASECLASS));
return MIstatus::failure;
} }
return MIstatus::success; return MIstatus::success;
Context not available.

tools/lldb-server/lldb-platform.cpp

Context not available.
// Parent will continue to listen for new connections. // Parent will continue to listen for new connections.
continue; continue;
} else {
// Child process will handle the connection and exit.
g_server = 0;
// Listening socket is owned by parent process.
acceptor_up.release();
} }
// Child process will handle the connection and exit.
g_server = 0;
// Listening socket is owned by parent process.
acceptor_up.release();
} else { } else {
// If not running as a server, this process will not accept // If not running as a server, this process will not accept
// connections while a connection is active. // connections while a connection is active.
Context not available.

unittests/Host/NativeProcessProtocolTest.cpp

Context not available.
bool Hardware) override { bool Hardware) override {
if (Hardware) if (Hardware)
return SetHardwareBreakpoint(Addr, Size); return SetHardwareBreakpoint(Addr, Size);
else
return SetSoftwareBreakpoint(Addr, Size); return SetSoftwareBreakpoint(Addr, Size);
} }
// Redirect base class Read/Write Memory methods to functions whose signatures // Redirect base class Read/Write Memory methods to functions whose signatures
Context not available.