1 //===-- NSError.cpp ---------------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "clang/AST/DeclCXX.h"
11
12 #include "Cocoa.h"
13
14 #include "lldb/Core/ValueObject.h"
15 #include "lldb/Core/ValueObjectConstResult.h"
16 #include "lldb/DataFormatters/FormattersHelpers.h"
17 #include "lldb/Symbol/ClangASTContext.h"
18 #include "lldb/Target/ObjCLanguageRuntime.h"
19 #include "lldb/Target/ProcessStructReader.h"
20 #include "lldb/Target/Target.h"
21 #include "lldb/Utility/DataBufferHeap.h"
22 #include "lldb/Utility/Endian.h"
23 #include "lldb/Utility/Status.h"
24 #include "lldb/Utility/Stream.h"
25
26 #include "Plugins/Language/ObjC/NSString.h"
27
28 using namespace lldb;
29 using namespace lldb_private;
30 using namespace lldb_private::formatters;
31
DerefToNSErrorPointer(ValueObject & valobj)32 static lldb::addr_t DerefToNSErrorPointer(ValueObject &valobj) {
33 CompilerType valobj_type(valobj.GetCompilerType());
34 Flags type_flags(valobj_type.GetTypeInfo());
35 if (type_flags.AllClear(eTypeHasValue)) {
36 if (valobj.IsBaseClass() && valobj.GetParent())
37 return valobj.GetParent()->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
38 } else {
39 lldb::addr_t ptr_value = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
40 if (type_flags.AllSet(eTypeIsPointer)) {
41 CompilerType pointee_type(valobj_type.GetPointeeType());
42 Flags pointee_flags(pointee_type.GetTypeInfo());
43 if (pointee_flags.AllSet(eTypeIsPointer)) {
44 if (ProcessSP process_sp = valobj.GetProcessSP()) {
45 Status error;
46 ptr_value = process_sp->ReadPointerFromMemory(ptr_value, error);
47 }
48 }
49 }
50 return ptr_value;
51 }
52
53 return LLDB_INVALID_ADDRESS;
54 }
55
NSError_SummaryProvider(ValueObject & valobj,Stream & stream,const TypeSummaryOptions & options)56 bool lldb_private::formatters::NSError_SummaryProvider(
57 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
58 ProcessSP process_sp(valobj.GetProcessSP());
59 if (!process_sp)
60 return false;
61
62 lldb::addr_t ptr_value = DerefToNSErrorPointer(valobj);
63 if (ptr_value == LLDB_INVALID_ADDRESS)
64 return false;
65
66 size_t ptr_size = process_sp->GetAddressByteSize();
67 lldb::addr_t code_location = ptr_value + 2 * ptr_size;
68 lldb::addr_t domain_location = ptr_value + 3 * ptr_size;
69
70 Status error;
71 uint64_t code = process_sp->ReadUnsignedIntegerFromMemory(code_location,
72 ptr_size, 0, error);
73 if (error.Fail())
74 return false;
75
76 lldb::addr_t domain_str_value =
77 process_sp->ReadPointerFromMemory(domain_location, error);
78 if (error.Fail() || domain_str_value == LLDB_INVALID_ADDRESS)
79 return false;
80
81 if (!domain_str_value) {
82 stream.Printf("domain: nil - code: %" PRIu64, code);
83 return true;
84 }
85
86 InferiorSizedWord isw(domain_str_value, *process_sp);
87
88 ValueObjectSP domain_str_sp = ValueObject::CreateValueObjectFromData(
89 "domain_str", isw.GetAsData(process_sp->GetByteOrder()),
90 valobj.GetExecutionContextRef(), process_sp->GetTarget()
91 .GetScratchClangASTContext()
92 ->GetBasicType(lldb::eBasicTypeVoid)
93 .GetPointerType());
94
95 if (!domain_str_sp)
96 return false;
97
98 StreamString domain_str_summary;
99 if (NSStringSummaryProvider(*domain_str_sp, domain_str_summary, options) &&
100 !domain_str_summary.Empty()) {
101 stream.Printf("domain: %s - code: %" PRIu64, domain_str_summary.GetData(),
102 code);
103 return true;
104 } else {
105 stream.Printf("domain: nil - code: %" PRIu64, code);
106 return true;
107 }
108 }
109
110 class NSErrorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
111 public:
NSErrorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)112 NSErrorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
113 : SyntheticChildrenFrontEnd(*valobj_sp) {}
114
115 ~NSErrorSyntheticFrontEnd() override = default;
116 // no need to delete m_child_ptr - it's kept alive by the cluster manager on
117 // our behalf
118
CalculateNumChildren()119 size_t CalculateNumChildren() override {
120 if (m_child_ptr)
121 return 1;
122 if (m_child_sp)
123 return 1;
124 return 0;
125 }
126
GetChildAtIndex(size_t idx)127 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
128 if (idx != 0)
129 return lldb::ValueObjectSP();
130
131 if (m_child_ptr)
132 return m_child_ptr->GetSP();
133 return m_child_sp;
134 }
135
Update()136 bool Update() override {
137 m_child_ptr = nullptr;
138 m_child_sp.reset();
139
140 ProcessSP process_sp(m_backend.GetProcessSP());
141 if (!process_sp)
142 return false;
143
144 lldb::addr_t userinfo_location = DerefToNSErrorPointer(m_backend);
145 if (userinfo_location == LLDB_INVALID_ADDRESS)
146 return false;
147
148 size_t ptr_size = process_sp->GetAddressByteSize();
149
150 userinfo_location += 4 * ptr_size;
151 Status error;
152 lldb::addr_t userinfo =
153 process_sp->ReadPointerFromMemory(userinfo_location, error);
154 if (userinfo == LLDB_INVALID_ADDRESS || error.Fail())
155 return false;
156 InferiorSizedWord isw(userinfo, *process_sp);
157 m_child_sp = CreateValueObjectFromData(
158 "_userInfo", isw.GetAsData(process_sp->GetByteOrder()),
159 m_backend.GetExecutionContextRef(),
160 process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(
161 lldb::eBasicTypeObjCID));
162 return false;
163 }
164
MightHaveChildren()165 bool MightHaveChildren() override { return true; }
166
GetIndexOfChildWithName(const ConstString & name)167 size_t GetIndexOfChildWithName(const ConstString &name) override {
168 static ConstString g___userInfo("_userInfo");
169 if (name == g___userInfo)
170 return 0;
171 return UINT32_MAX;
172 }
173
174 private:
175 // the child here can be "real" (i.e. an actual child of the root) or
176 // synthetized from raw memory if the former, I need to store a plain pointer
177 // to it - or else a loop of references will cause this entire hierarchy of
178 // values to leak if the latter, then I need to store a SharedPointer to it -
179 // so that it only goes away when everyone else in the cluster goes away oh
180 // joy!
181 ValueObject *m_child_ptr;
182 ValueObjectSP m_child_sp;
183 };
184
185 SyntheticChildrenFrontEnd *
NSErrorSyntheticFrontEndCreator(CXXSyntheticChildren *,lldb::ValueObjectSP valobj_sp)186 lldb_private::formatters::NSErrorSyntheticFrontEndCreator(
187 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
188 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
189 if (!process_sp)
190 return nullptr;
191 ObjCLanguageRuntime *runtime =
192 (ObjCLanguageRuntime *)process_sp->GetLanguageRuntime(
193 lldb::eLanguageTypeObjC);
194 if (!runtime)
195 return nullptr;
196
197 ObjCLanguageRuntime::ClassDescriptorSP descriptor(
198 runtime->GetClassDescriptor(*valobj_sp.get()));
199
200 if (!descriptor.get() || !descriptor->IsValid())
201 return nullptr;
202
203 const char *class_name = descriptor->GetClassName().GetCString();
204
205 if (!class_name || !*class_name)
206 return nullptr;
207
208 if (!strcmp(class_name, "NSError"))
209 return (new NSErrorSyntheticFrontEnd(valobj_sp));
210 else if (!strcmp(class_name, "__NSCFError"))
211 return (new NSErrorSyntheticFrontEnd(valobj_sp));
212
213 return nullptr;
214 }
215