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
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(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
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  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
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  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
177private:
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
188SyntheticChildrenFrontEnd *
189lldb_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