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

   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 }