LLDB mainline
NSException.cpp
Go to the documentation of this file.
1//===-- NSException.cpp ---------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "clang/AST/DeclCXX.h"
10
11#include "Cocoa.h"
12
16#include "lldb/Target/Target.h"
18#include "lldb/Utility/Endian.h"
19#include "lldb/Utility/Status.h"
20#include "lldb/Utility/Stream.h"
21
25
26using namespace lldb;
27using namespace lldb_private;
28using namespace lldb_private::formatters;
29
30static bool ExtractFields(ValueObject &valobj, ValueObjectSP *name_sp,
31 ValueObjectSP *reason_sp, ValueObjectSP *userinfo_sp,
32 ValueObjectSP *reserved_sp) {
33 ProcessSP process_sp(valobj.GetProcessSP());
34 if (!process_sp)
35 return false;
36
38
39 CompilerType valobj_type(valobj.GetCompilerType());
40 Flags type_flags(valobj_type.GetTypeInfo());
41 if (type_flags.AllClear(eTypeHasValue)) {
42 if (valobj.IsBaseClass() && valobj.GetParent())
44 } else {
46 }
47
48 if (ptr == LLDB_INVALID_ADDRESS)
49 return false;
50 size_t ptr_size = process_sp->GetAddressByteSize();
51
53 auto name = process_sp->ReadPointerFromMemory(ptr + 1 * ptr_size, error);
54 if (error.Fail() || name == LLDB_INVALID_ADDRESS)
55 return false;
56 auto reason = process_sp->ReadPointerFromMemory(ptr + 2 * ptr_size, error);
57 if (error.Fail() || reason == LLDB_INVALID_ADDRESS)
58 return false;
59 auto userinfo = process_sp->ReadPointerFromMemory(ptr + 3 * ptr_size, error);
60 if (error.Fail() || userinfo == LLDB_INVALID_ADDRESS)
61 return false;
62 auto reserved = process_sp->ReadPointerFromMemory(ptr + 4 * ptr_size, error);
63 if (error.Fail() || reserved == LLDB_INVALID_ADDRESS)
64 return false;
65
66 InferiorSizedWord name_isw(name, *process_sp);
67 InferiorSizedWord reason_isw(reason, *process_sp);
68 InferiorSizedWord userinfo_isw(userinfo, *process_sp);
69 InferiorSizedWord reserved_isw(reserved, *process_sp);
70
71 TypeSystemClangSP scratch_ts_sp =
72 ScratchTypeSystemClang::GetForTarget(process_sp->GetTarget());
73 if (!scratch_ts_sp)
74 return false;
75
76 CompilerType voidstar =
77 scratch_ts_sp->GetBasicType(lldb::eBasicTypeVoid).GetPointerType();
78
79 if (name_sp)
81 "name", name_isw.GetAsData(process_sp->GetByteOrder()),
82 valobj.GetExecutionContextRef(), voidstar);
83 if (reason_sp)
85 "reason", reason_isw.GetAsData(process_sp->GetByteOrder()),
86 valobj.GetExecutionContextRef(), voidstar);
87 if (userinfo_sp)
89 "userInfo", userinfo_isw.GetAsData(process_sp->GetByteOrder()),
90 valobj.GetExecutionContextRef(), voidstar);
91 if (reserved_sp)
93 "reserved", reserved_isw.GetAsData(process_sp->GetByteOrder()),
94 valobj.GetExecutionContextRef(), voidstar);
95
96 return true;
97}
98
100 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
101 lldb::ValueObjectSP reason_sp;
102 if (!ExtractFields(valobj, nullptr, &reason_sp, nullptr, nullptr))
103 return false;
104
105 if (!reason_sp) {
106 stream.Printf("No reason");
107 return false;
108 }
109
110 StreamString reason_str_summary;
111 if (NSStringSummaryProvider(*reason_sp, reason_str_summary, options) &&
112 !reason_str_summary.Empty()) {
113 stream.Printf("%s", reason_str_summary.GetData());
114 return true;
115 } else
116 return false;
117}
118
120public:
122 : SyntheticChildrenFrontEnd(*valobj_sp) {}
123
124 ~NSExceptionSyntheticFrontEnd() override = default;
125
126 llvm::Expected<uint32_t> CalculateNumChildren() override { return 4; }
127
128 lldb::ValueObjectSP GetChildAtIndex(uint32_t idx) override {
129 switch (idx) {
130 case 0: return m_name_sp;
131 case 1: return m_reason_sp;
132 case 2: return m_userinfo_sp;
133 case 3: return m_reserved_sp;
134 }
135 return lldb::ValueObjectSP();
136 }
137
139 m_name_sp.reset();
140 m_reason_sp.reset();
141 m_userinfo_sp.reset();
142 m_reserved_sp.reset();
143
144 const auto ret = ExtractFields(m_backend, &m_name_sp, &m_reason_sp,
146
149 }
150
151 bool MightHaveChildren() override { return true; }
152
153 size_t GetIndexOfChildWithName(ConstString name) override {
154 // NSException has 4 members:
155 // NSString *name;
156 // NSString *reason;
157 // NSDictionary *userInfo;
158 // id reserved;
159 static ConstString g_name("name");
160 static ConstString g_reason("reason");
161 static ConstString g_userInfo("userInfo");
162 static ConstString g_reserved("reserved");
163 if (name == g_name) return 0;
164 if (name == g_reason) return 1;
165 if (name == g_userInfo) return 2;
166 if (name == g_reserved) return 3;
167 return UINT32_MAX;
168 }
169
170private:
175};
176
180 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
181 if (!process_sp)
182 return nullptr;
183 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
184 if (!runtime)
185 return nullptr;
186
188 runtime->GetClassDescriptor(*valobj_sp.get()));
189
190 if (!descriptor.get() || !descriptor->IsValid())
191 return nullptr;
192
193 const char *class_name = descriptor->GetClassName().GetCString();
194
195 if (!class_name || !*class_name)
196 return nullptr;
197
198 if (!strcmp(class_name, "NSException"))
199 return (new NSExceptionSyntheticFrontEnd(valobj_sp));
200 else if (!strcmp(class_name, "NSCFException"))
201 return (new NSExceptionSyntheticFrontEnd(valobj_sp));
202 else if (!strcmp(class_name, "__NSCFException"))
203 return (new NSExceptionSyntheticFrontEnd(valobj_sp));
204
205 return nullptr;
206}
static llvm::raw_ostream & error(Stream &strm)
static bool ExtractFields(ValueObject &valobj, ValueObjectSP *name_sp, ValueObjectSP *reason_sp, ValueObjectSP *userinfo_sp, ValueObjectSP *reserved_sp)
Definition: NSException.cpp:30
lldb::ChildCacheState Update() override
This function is assumed to always succeed and if it fails, the front-end should know to deal with it...
llvm::Expected< uint32_t > CalculateNumChildren() override
size_t GetIndexOfChildWithName(ConstString name) override
~NSExceptionSyntheticFrontEnd() override=default
bool MightHaveChildren() override
NSExceptionSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
lldb::ValueObjectSP GetChildAtIndex(uint32_t idx) override
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
CompilerType GetPointerType() const
Return a new CompilerType that is a pointer to this type.
uint32_t GetTypeInfo(CompilerType *pointee_or_element_compiler_type=nullptr) const
A uniqued constant string class.
Definition: ConstString.h:40
A class to manage flags.
Definition: Flags.h:22
bool AllClear(ValueType mask) const
Test if all bits in mask are clear.
Definition: Flags.h:103
std::shared_ptr< ClassDescriptor > ClassDescriptorSP
static ObjCLanguageRuntime * Get(Process &process)
virtual ClassDescriptorSP GetClassDescriptor(ValueObject &in_value)
static lldb::TypeSystemClangSP GetForTarget(Target &target, std::optional< IsolatedASTKind > ast_kind=DefaultAST, bool create_on_demand=true)
Returns the scratch TypeSystemClang for the given target.
An error handling class.
Definition: Status.h:44
const char * GetData() const
Definition: StreamString.h:43
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
CompilerType GetCompilerType()
Definition: ValueObject.h:352
lldb::ProcessSP GetProcessSP() const
Definition: ValueObject.h:338
virtual uint64_t GetValueAsUnsigned(uint64_t fail_value, bool *success=nullptr)
static lldb::ValueObjectSP CreateValueObjectFromData(llvm::StringRef name, const DataExtractor &data, const ExecutionContext &exe_ctx, CompilerType type)
virtual bool IsBaseClass()
Definition: ValueObject.h:398
virtual ValueObject * GetParent()
Definition: ValueObject.h:748
const ExecutionContextRef & GetExecutionContextRef() const
Definition: ValueObject.h:330
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
#define UINT32_MAX
Definition: lldb-defines.h:19
bool NSException_SummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options)
Definition: NSException.cpp:99
SyntheticChildrenFrontEnd * NSExceptionSyntheticFrontEndCreator(CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp)
bool NSStringSummaryProvider(ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options)
Definition: NSString.cpp:33
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Definition: SBAddress.h:15
ChildCacheState
Specifies if children need to be re-computed after a call to SyntheticChildrenFrontEnd::Update.
@ eRefetch
Children need to be recomputed dynamically.
@ eReuse
Children did not change and don't need to be recomputed; re-use what we computed the last time we cal...
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:472
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:381
std::shared_ptr< lldb_private::TypeSystemClang > TypeSystemClangSP
Definition: lldb-forward.h:458
uint64_t addr_t
Definition: lldb-types.h:80
DataExtractor GetAsData(lldb::ByteOrder byte_order=lldb::eByteOrderInvalid) const