1 //===-- LibStdcppUniquePointer.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 "LibStdcpp.h" 10 11 #include "lldb/Core/ValueObject.h" 12 #include "lldb/DataFormatters/FormattersHelpers.h" 13 #include "lldb/DataFormatters/TypeSynthetic.h" 14 #include "lldb/Utility/ConstString.h" 15 16 #include <memory> 17 #include <vector> 18 19 using namespace lldb; 20 using namespace lldb_private; 21 using namespace lldb_private::formatters; 22 23 namespace { 24 25 class LibStdcppUniquePtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd { 26 public: 27 explicit LibStdcppUniquePtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp); 28 29 size_t CalculateNumChildren() override; 30 31 lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; 32 33 bool Update() override; 34 35 bool MightHaveChildren() override; 36 37 size_t GetIndexOfChildWithName(ConstString name) override; 38 39 bool GetSummary(Stream &stream, const TypeSummaryOptions &options); 40 41 private: 42 // The lifetime of a ValueObject and all its derivative ValueObjects 43 // (children, clones, etc.) is managed by a ClusterManager. These 44 // objects are only destroyed when every shared pointer to any of them 45 // is destroyed, so we must not store a shared pointer to any ValueObject 46 // derived from our backend ValueObject (since we're in the same cluster). 47 ValueObject* m_ptr_obj = nullptr; 48 ValueObject* m_obj_obj = nullptr; 49 ValueObject* m_del_obj = nullptr; 50 51 ValueObjectSP GetTuple(); 52 }; 53 54 } // end of anonymous namespace 55 56 LibStdcppUniquePtrSyntheticFrontEnd::LibStdcppUniquePtrSyntheticFrontEnd( 57 lldb::ValueObjectSP valobj_sp) 58 : SyntheticChildrenFrontEnd(*valobj_sp) { 59 Update(); 60 } 61 62 ValueObjectSP LibStdcppUniquePtrSyntheticFrontEnd::GetTuple() { 63 ValueObjectSP valobj_backend_sp = m_backend.GetSP(); 64 65 if (!valobj_backend_sp) 66 return nullptr; 67 68 ValueObjectSP valobj_sp = valobj_backend_sp->GetNonSyntheticValue(); 69 if (!valobj_sp) 70 return nullptr; 71 72 ValueObjectSP obj_child_sp = valobj_sp->GetChildMemberWithName("_M_t"); 73 if (!obj_child_sp) 74 return nullptr; 75 76 ValueObjectSP obj_subchild_sp = obj_child_sp->GetChildMemberWithName("_M_t"); 77 78 // if there is a _M_t subchild, the tuple is found in the obj_subchild_sp 79 // (for libstdc++ 6.0.23). 80 if (obj_subchild_sp) { 81 return obj_subchild_sp; 82 } 83 84 return obj_child_sp; 85 } 86 87 bool LibStdcppUniquePtrSyntheticFrontEnd::Update() { 88 ValueObjectSP tuple_sp = GetTuple(); 89 90 if (!tuple_sp) 91 return false; 92 93 std::unique_ptr<SyntheticChildrenFrontEnd> tuple_frontend( 94 LibStdcppTupleSyntheticFrontEndCreator(nullptr, tuple_sp)); 95 96 ValueObjectSP ptr_obj = tuple_frontend->GetChildAtIndex(0); 97 if (ptr_obj) 98 m_ptr_obj = ptr_obj->Clone(ConstString("pointer")).get(); 99 100 // Add a 'deleter' child if there was a non-empty deleter type specified. 101 // 102 // The object might have size=1 in the TypeSystem but occupies no dedicated 103 // storage due to no_unique_address, so infer the actual size from the total 104 // size of the unique_ptr class. If sizeof(unique_ptr) == sizeof(void*) then 105 // the deleter is empty and should be hidden. 106 if (tuple_sp->GetByteSize() > ptr_obj->GetByteSize()) { 107 ValueObjectSP del_obj = tuple_frontend->GetChildAtIndex(1); 108 if (del_obj) 109 m_del_obj = del_obj->Clone(ConstString("deleter")).get(); 110 } 111 112 if (m_ptr_obj) { 113 Status error; 114 ValueObjectSP obj_obj = m_ptr_obj->Dereference(error); 115 if (error.Success()) { 116 m_obj_obj = obj_obj->Clone(ConstString("object")).get(); 117 } 118 } 119 120 return false; 121 } 122 123 bool LibStdcppUniquePtrSyntheticFrontEnd::MightHaveChildren() { return true; } 124 125 lldb::ValueObjectSP 126 LibStdcppUniquePtrSyntheticFrontEnd::GetChildAtIndex(size_t idx) { 127 if (idx == 0 && m_ptr_obj) 128 return m_ptr_obj->GetSP(); 129 if (idx == 1 && m_del_obj) 130 return m_del_obj->GetSP(); 131 if (idx == 2 && m_obj_obj) 132 return m_obj_obj->GetSP(); 133 return lldb::ValueObjectSP(); 134 } 135 136 size_t LibStdcppUniquePtrSyntheticFrontEnd::CalculateNumChildren() { 137 if (m_del_obj) 138 return 2; 139 return 1; 140 } 141 142 size_t LibStdcppUniquePtrSyntheticFrontEnd::GetIndexOfChildWithName( 143 ConstString name) { 144 if (name == "ptr" || name == "pointer") 145 return 0; 146 if (name == "del" || name == "deleter") 147 return 1; 148 if (name == "obj" || name == "object" || name == "$$dereference$$") 149 return 2; 150 return UINT32_MAX; 151 } 152 153 bool LibStdcppUniquePtrSyntheticFrontEnd::GetSummary( 154 Stream &stream, const TypeSummaryOptions &options) { 155 if (!m_ptr_obj) 156 return false; 157 158 bool success; 159 uint64_t ptr_value = m_ptr_obj->GetValueAsUnsigned(0, &success); 160 if (!success) 161 return false; 162 if (ptr_value == 0) 163 stream.Printf("nullptr"); 164 else 165 stream.Printf("0x%" PRIx64, ptr_value); 166 return true; 167 } 168 169 SyntheticChildrenFrontEnd * 170 lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator( 171 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { 172 return (valobj_sp ? new LibStdcppUniquePtrSyntheticFrontEnd(valobj_sp) 173 : nullptr); 174 } 175 176 bool lldb_private::formatters::LibStdcppUniquePointerSummaryProvider( 177 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 178 LibStdcppUniquePtrSyntheticFrontEnd formatter(valobj.GetSP()); 179 return formatter.GetSummary(stream, options); 180 } 181