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/Core/ValueObject.h" 15 #include "lldb/Core/ValueObjectConstResult.h" 16 #include "lldb/DataFormatters/FormattersHelpers.h" 17 #include "lldb/Target/Target.h" 18 #include "lldb/Utility/DataBufferHeap.h" 19 #include "lldb/Utility/Endian.h" 20 #include "lldb/Utility/Status.h" 21 #include "lldb/Utility/Stream.h" 22 23 #include "Plugins/Language/ObjC/NSString.h" 24 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" 25 26 using namespace lldb; 27 using namespace lldb_private; 28 using namespace lldb_private::formatters; 29 30 static lldb::addr_t DerefToNSErrorPointer(ValueObject &valobj) { 31 CompilerType valobj_type(valobj.GetCompilerType()); 32 Flags type_flags(valobj_type.GetTypeInfo()); 33 if (type_flags.AllClear(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(eTypeIsPointer)) { 39 CompilerType pointee_type(valobj_type.GetPointeeType()); 40 Flags pointee_flags(pointee_type.GetTypeInfo()); 41 if (pointee_flags.AllSet(eTypeIsPointer)) { 42 if (ProcessSP process_sp = valobj.GetProcessSP()) { 43 Status error; 44 ptr_value = process_sp->ReadPointerFromMemory(ptr_value, error); 45 } 46 } 47 } 48 return ptr_value; 49 } 50 51 return LLDB_INVALID_ADDRESS; 52 } 53 54 bool 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 uint64_t code = process_sp->ReadUnsignedIntegerFromMemory(code_location, 70 ptr_size, 0, error); 71 if (error.Fail()) 72 return false; 73 74 lldb::addr_t domain_str_value = 75 process_sp->ReadPointerFromMemory(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("domain: nil - code: %" PRIu64, code); 81 return true; 82 } 83 84 InferiorSizedWord isw(domain_str_value, *process_sp); 85 TypeSystemClangSP scratch_ts_sp = 86 ScratchTypeSystemClang::GetForTarget(process_sp->GetTarget()); 87 88 if (!scratch_ts_sp) 89 return false; 90 ValueObjectSP domain_str_sp = ValueObject::CreateValueObjectFromData( 91 "domain_str", isw.GetAsData(process_sp->GetByteOrder()), 92 valobj.GetExecutionContextRef(), 93 scratch_ts_sp->GetBasicType(lldb::eBasicTypeVoid).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: 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 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 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 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 TypeSystemClangSP scratch_ts_sp = 158 ScratchTypeSystemClang::GetForTarget(process_sp->GetTarget()); 159 if (!scratch_ts_sp) 160 return false; 161 m_child_sp = CreateValueObjectFromData( 162 "_userInfo", isw.GetAsData(process_sp->GetByteOrder()), 163 m_backend.GetExecutionContextRef(), 164 scratch_ts_sp->GetBasicType(lldb::eBasicTypeObjCID)); 165 return false; 166 } 167 168 bool MightHaveChildren() override { return true; } 169 170 size_t GetIndexOfChildWithName(ConstString name) override { 171 static ConstString g_userInfo("_userInfo"); 172 if (name == g_userInfo) 173 return 0; 174 return UINT32_MAX; 175 } 176 177 private: 178 // the child here can be "real" (i.e. an actual child of the root) or 179 // synthetized from raw memory if the former, I need to store a plain pointer 180 // to it - or else a loop of references will cause this entire hierarchy of 181 // values to leak if the latter, then I need to store a SharedPointer to it - 182 // so that it only goes away when everyone else in the cluster goes away oh 183 // joy! 184 ValueObject *m_child_ptr = nullptr; 185 ValueObjectSP m_child_sp; 186 }; 187 188 SyntheticChildrenFrontEnd * 189 lldb_private::formatters::NSErrorSyntheticFrontEndCreator( 190 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { 191 lldb::ProcessSP process_sp(valobj_sp->GetProcessSP()); 192 if (!process_sp) 193 return nullptr; 194 ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp); 195 if (!runtime) 196 return nullptr; 197 198 ObjCLanguageRuntime::ClassDescriptorSP descriptor( 199 runtime->GetClassDescriptor(*valobj_sp.get())); 200 201 if (!descriptor.get() || !descriptor->IsValid()) 202 return nullptr; 203 204 const char *class_name = descriptor->GetClassName().GetCString(); 205 206 if (!class_name || !*class_name) 207 return nullptr; 208 209 if (!strcmp(class_name, "NSError")) 210 return (new NSErrorSyntheticFrontEnd(valobj_sp)); 211 else if (!strcmp(class_name, "__NSCFError")) 212 return (new NSErrorSyntheticFrontEnd(valobj_sp)); 213 214 return nullptr; 215 } 216