1//===-- NSError.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
13#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
14#include "lldb/DataFormatters/FormattersHelpers.h"
15#include "lldb/Target/Target.h"
16#include "lldb/Utility/DataBufferHeap.h"
17#include "lldb/Utility/Endian.h"
18#include "lldb/Utility/Status.h"
19#include "lldb/Utility/Stream.h"
20#include "lldb/ValueObject/ValueObject.h"
21#include "lldb/ValueObject/ValueObjectConstResult.h"
22
23#include "Plugins/Language/ObjC/NSString.h"
24#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
25
26using namespace lldb;
27using namespace lldb_private;
28using namespace lldb_private::formatters;
29
30static lldb::addr_t DerefToNSErrorPointer(ValueObject &valobj) {
31 CompilerType valobj_type(valobj.GetCompilerType());
32 Flags type_flags(valobj_type.GetTypeInfo());
33 if (type_flags.AllClear(mask: eTypeHasValue)) {
34 if (valobj.IsBaseClass() && valobj.GetParent())
35 return valobj.GetParent()->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
36 } else {
37 lldb::addr_t ptr_value = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
38 if (type_flags.AllSet(mask: eTypeIsPointer)) {
39 CompilerType pointee_type(valobj_type.GetPointeeType());
40 Flags pointee_flags(pointee_type.GetTypeInfo());
41 if (pointee_flags.AllSet(mask: eTypeIsPointer)) {
42 if (ProcessSP process_sp = valobj.GetProcessSP()) {
43 Status error;
44 ptr_value = process_sp->ReadPointerFromMemory(vm_addr: ptr_value, error);
45 }
46 }
47 }
48 return ptr_value;
49 }
50
51 return LLDB_INVALID_ADDRESS;
52}
53
54bool lldb_private::formatters::NSError_SummaryProvider(
55 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
56 ProcessSP process_sp(valobj.GetProcessSP());
57 if (!process_sp)
58 return false;
59
60 lldb::addr_t ptr_value = DerefToNSErrorPointer(valobj);
61 if (ptr_value == LLDB_INVALID_ADDRESS)
62 return false;
63
64 size_t ptr_size = process_sp->GetAddressByteSize();
65 lldb::addr_t code_location = ptr_value + 2 * ptr_size;
66 lldb::addr_t domain_location = ptr_value + 3 * ptr_size;
67
68 Status error;
69 int64_t code = process_sp->ReadSignedIntegerFromMemory(load_addr: code_location,
70 byte_size: ptr_size, fail_value: 0, error);
71 if (error.Fail())
72 return false;
73
74 lldb::addr_t domain_str_value =
75 process_sp->ReadPointerFromMemory(vm_addr: domain_location, error);
76 if (error.Fail() || domain_str_value == LLDB_INVALID_ADDRESS)
77 return false;
78
79 if (!domain_str_value) {
80 stream.Printf(format: "domain: nil - code: %" PRIi64, code);
81 return true;
82 }
83
84 InferiorSizedWord isw(domain_str_value, *process_sp);
85 TypeSystemClangSP scratch_ts_sp =
86 ScratchTypeSystemClang::GetForTarget(target&: process_sp->GetTarget());
87
88 if (!scratch_ts_sp)
89 return false;
90 ValueObjectSP domain_str_sp = ValueObject::CreateValueObjectFromData(
91 name: "domain_str", data: isw.GetAsData(byte_order: process_sp->GetByteOrder()),
92 exe_ctx: valobj.GetExecutionContextRef(),
93 type: scratch_ts_sp->GetBasicType(type: lldb::eBasicTypeVoid).GetPointerType());
94
95 if (!domain_str_sp)
96 return false;
97
98 StreamString domain_str_summary;
99 if (NSStringSummaryProvider(valobj&: *domain_str_sp, stream&: domain_str_summary, options) &&
100 !domain_str_summary.Empty()) {
101 stream.Printf(format: "domain: %s - code: %" PRIi64, domain_str_summary.GetData(),
102 code);
103 return true;
104 } else {
105 stream.Printf(format: "domain: nil - code: %" PRIi64, code);
106 return true;
107 }
108}
109
110class NSErrorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
111public:
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
119 llvm::Expected<uint32_t> CalculateNumChildren() override {
120 if (m_child_ptr)
121 return 1;
122 if (m_child_sp)
123 return 1;
124 return 0;
125 }
126
127 lldb::ValueObjectSP GetChildAtIndex(uint32_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
136 lldb::ChildCacheState 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 lldb::ChildCacheState::eRefetch;
143
144 lldb::addr_t userinfo_location = DerefToNSErrorPointer(valobj&: m_backend);
145 if (userinfo_location == LLDB_INVALID_ADDRESS)
146 return lldb::ChildCacheState::eRefetch;
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(vm_addr: userinfo_location, error);
154 if (userinfo == LLDB_INVALID_ADDRESS || error.Fail())
155 return lldb::ChildCacheState::eRefetch;
156 InferiorSizedWord isw(userinfo, *process_sp);
157 TypeSystemClangSP scratch_ts_sp =
158 ScratchTypeSystemClang::GetForTarget(target&: process_sp->GetTarget());
159 if (!scratch_ts_sp)
160 return lldb::ChildCacheState::eRefetch;
161 m_child_sp = CreateValueObjectFromData(
162 name: "_userInfo", data: isw.GetAsData(byte_order: process_sp->GetByteOrder()),
163 exe_ctx: m_backend.GetExecutionContextRef(),
164 type: scratch_ts_sp->GetBasicType(type: lldb::eBasicTypeObjCID));
165 return lldb::ChildCacheState::eRefetch;
166 }
167
168 llvm::Expected<size_t> GetIndexOfChildWithName(ConstString name) override {
169 static ConstString g_userInfo("_userInfo");
170 if (name == g_userInfo)
171 return 0;
172 return llvm::createStringError(Fmt: "Type has no child named '%s'",
173 Vals: name.AsCString());
174 }
175
176private:
177 // the child here can be "real" (i.e. an actual child of the root) or
178 // synthetized from raw memory if the former, I need to store a plain pointer
179 // to it - or else a loop of references will cause this entire hierarchy of
180 // values to leak if the latter, then I need to store a SharedPointer to it -
181 // so that it only goes away when everyone else in the cluster goes away oh
182 // joy!
183 ValueObject *m_child_ptr = nullptr;
184 ValueObjectSP m_child_sp;
185};
186
187SyntheticChildrenFrontEnd *
188lldb_private::formatters::NSErrorSyntheticFrontEndCreator(
189 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
190 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
191 if (!process_sp)
192 return nullptr;
193 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(process&: *process_sp);
194 if (!runtime)
195 return nullptr;
196
197 ObjCLanguageRuntime::ClassDescriptorSP descriptor(
198 runtime->GetClassDescriptor(in_value&: *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(s1: class_name, s2: "NSError"))
209 return (new NSErrorSyntheticFrontEnd(valobj_sp));
210 else if (!strcmp(s1: class_name, s2: "__NSCFError"))
211 return (new NSErrorSyntheticFrontEnd(valobj_sp));
212
213 return nullptr;
214}
215

source code of lldb/source/Plugins/Language/ObjC/NSError.cpp