1 //===-- LibCxxVector.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 "LibCxx.h" 10 11 #include "lldb/DataFormatters/FormattersHelpers.h" 12 #include "lldb/Utility/ConstString.h" 13 #include "lldb/ValueObject/ValueObject.h" 14 #include "lldb/lldb-enumerations.h" 15 #include "lldb/lldb-forward.h" 16 #include <optional> 17 18 using namespace lldb; 19 using namespace lldb_private; 20 using namespace lldb_private::formatters; 21 22 namespace lldb_private { 23 namespace formatters { 24 class LibcxxStdVectorSyntheticFrontEnd : public SyntheticChildrenFrontEnd { 25 public: 26 LibcxxStdVectorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp); 27 28 ~LibcxxStdVectorSyntheticFrontEnd() override; 29 30 llvm::Expected<uint32_t> CalculateNumChildren() override; 31 32 lldb::ValueObjectSP GetChildAtIndex(uint32_t idx) override; 33 34 lldb::ChildCacheState Update() override; 35 36 bool MightHaveChildren() override; 37 38 size_t GetIndexOfChildWithName(ConstString name) override; 39 40 private: 41 ValueObject *m_start = nullptr; 42 ValueObject *m_finish = nullptr; 43 CompilerType m_element_type; 44 uint32_t m_element_size = 0; 45 }; 46 47 class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd { 48 public: 49 LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp); 50 51 llvm::Expected<uint32_t> CalculateNumChildren() override; 52 53 lldb::ValueObjectSP GetChildAtIndex(uint32_t idx) override; 54 55 lldb::ChildCacheState Update() override; 56 57 bool MightHaveChildren() override { return true; } 58 59 size_t GetIndexOfChildWithName(ConstString name) override; 60 61 private: 62 CompilerType m_bool_type; 63 ExecutionContextRef m_exe_ctx_ref; 64 uint64_t m_count = 0; 65 lldb::addr_t m_base_data_address = 0; 66 std::map<size_t, lldb::ValueObjectSP> m_children; 67 }; 68 69 } // namespace formatters 70 } // namespace lldb_private 71 72 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd:: 73 LibcxxStdVectorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) 74 : SyntheticChildrenFrontEnd(*valobj_sp), m_element_type() { 75 if (valobj_sp) 76 Update(); 77 } 78 79 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd:: 80 ~LibcxxStdVectorSyntheticFrontEnd() { 81 // these need to stay around because they are child objects who will follow 82 // their parent's life cycle 83 // delete m_start; 84 // delete m_finish; 85 } 86 87 llvm::Expected<uint32_t> lldb_private::formatters:: 88 LibcxxStdVectorSyntheticFrontEnd::CalculateNumChildren() { 89 if (!m_start || !m_finish) 90 return 0; 91 uint64_t start_val = m_start->GetValueAsUnsigned(0); 92 uint64_t finish_val = m_finish->GetValueAsUnsigned(0); 93 94 if (start_val == 0 || finish_val == 0) 95 return 0; 96 97 if (start_val >= finish_val) 98 return 0; 99 100 size_t num_children = (finish_val - start_val); 101 if (num_children % m_element_size) 102 return 0; 103 return num_children / m_element_size; 104 } 105 106 lldb::ValueObjectSP 107 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetChildAtIndex( 108 uint32_t idx) { 109 if (!m_start || !m_finish) 110 return lldb::ValueObjectSP(); 111 112 uint64_t offset = idx * m_element_size; 113 offset = offset + m_start->GetValueAsUnsigned(0); 114 StreamString name; 115 name.Printf("[%" PRIu64 "]", (uint64_t)idx); 116 return CreateValueObjectFromAddress(name.GetString(), offset, 117 m_backend.GetExecutionContextRef(), 118 m_element_type); 119 } 120 121 static ValueObjectSP GetDataPointer(ValueObject &root) { 122 if (auto cap_sp = root.GetChildMemberWithName("__cap_")) 123 return cap_sp; 124 125 ValueObjectSP cap_sp = root.GetChildMemberWithName("__end_cap_"); 126 if (!cap_sp) 127 return nullptr; 128 129 if (!isOldCompressedPairLayout(*cap_sp)) 130 return nullptr; 131 132 return GetFirstValueOfLibCXXCompressedPair(*cap_sp); 133 } 134 135 lldb::ChildCacheState 136 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() { 137 m_start = m_finish = nullptr; 138 ValueObjectSP data_sp(GetDataPointer(m_backend)); 139 140 if (!data_sp) 141 return lldb::ChildCacheState::eRefetch; 142 143 m_element_type = data_sp->GetCompilerType().GetPointeeType(); 144 if (std::optional<uint64_t> size = m_element_type.GetByteSize(nullptr)) { 145 m_element_size = *size; 146 147 if (m_element_size > 0) { 148 // store raw pointers or end up with a circular dependency 149 m_start = m_backend.GetChildMemberWithName("__begin_").get(); 150 m_finish = m_backend.GetChildMemberWithName("__end_").get(); 151 } 152 } 153 return lldb::ChildCacheState::eRefetch; 154 } 155 156 bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd:: 157 MightHaveChildren() { 158 return true; 159 } 160 161 size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd:: 162 GetIndexOfChildWithName(ConstString name) { 163 if (!m_start || !m_finish) 164 return UINT32_MAX; 165 return ExtractIndexFromString(name.GetCString()); 166 } 167 168 lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd:: 169 LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) 170 : SyntheticChildrenFrontEnd(*valobj_sp), m_bool_type(), m_exe_ctx_ref(), 171 m_children() { 172 if (valobj_sp) { 173 Update(); 174 m_bool_type = 175 valobj_sp->GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeBool); 176 } 177 } 178 179 llvm::Expected<uint32_t> lldb_private::formatters:: 180 LibcxxVectorBoolSyntheticFrontEnd::CalculateNumChildren() { 181 return m_count; 182 } 183 184 lldb::ValueObjectSP 185 lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex( 186 uint32_t idx) { 187 auto iter = m_children.find(idx), end = m_children.end(); 188 if (iter != end) 189 return iter->second; 190 if (idx >= m_count) 191 return {}; 192 if (m_base_data_address == 0 || m_count == 0) 193 return {}; 194 if (!m_bool_type) 195 return {}; 196 size_t byte_idx = (idx >> 3); // divide by 8 to get byte index 197 size_t bit_index = (idx & 7); // efficient idx % 8 for bit index 198 lldb::addr_t byte_location = m_base_data_address + byte_idx; 199 ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP()); 200 if (!process_sp) 201 return {}; 202 uint8_t byte = 0; 203 uint8_t mask = 0; 204 Status err; 205 size_t bytes_read = process_sp->ReadMemory(byte_location, &byte, 1, err); 206 if (err.Fail() || bytes_read == 0) 207 return {}; 208 mask = 1 << bit_index; 209 bool bit_set = ((byte & mask) != 0); 210 std::optional<uint64_t> size = m_bool_type.GetByteSize(nullptr); 211 if (!size) 212 return {}; 213 WritableDataBufferSP buffer_sp(new DataBufferHeap(*size, 0)); 214 if (bit_set && buffer_sp && buffer_sp->GetBytes()) { 215 // regardless of endianness, anything non-zero is true 216 *(buffer_sp->GetBytes()) = 1; 217 } 218 StreamString name; 219 name.Printf("[%" PRIu64 "]", (uint64_t)idx); 220 ValueObjectSP retval_sp(CreateValueObjectFromData( 221 name.GetString(), 222 DataExtractor(buffer_sp, process_sp->GetByteOrder(), 223 process_sp->GetAddressByteSize()), 224 m_exe_ctx_ref, m_bool_type)); 225 if (retval_sp) 226 m_children[idx] = retval_sp; 227 return retval_sp; 228 } 229 230 lldb::ChildCacheState 231 lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::Update() { 232 m_children.clear(); 233 ValueObjectSP valobj_sp = m_backend.GetSP(); 234 if (!valobj_sp) 235 return lldb::ChildCacheState::eRefetch; 236 m_exe_ctx_ref = valobj_sp->GetExecutionContextRef(); 237 ValueObjectSP size_sp(valobj_sp->GetChildMemberWithName("__size_")); 238 if (!size_sp) 239 return lldb::ChildCacheState::eRefetch; 240 m_count = size_sp->GetValueAsUnsigned(0); 241 if (!m_count) 242 return lldb::ChildCacheState::eReuse; 243 ValueObjectSP begin_sp(valobj_sp->GetChildMemberWithName("__begin_")); 244 if (!begin_sp) { 245 m_count = 0; 246 return lldb::ChildCacheState::eRefetch; 247 } 248 m_base_data_address = begin_sp->GetValueAsUnsigned(0); 249 if (!m_base_data_address) { 250 m_count = 0; 251 return lldb::ChildCacheState::eRefetch; 252 } 253 return lldb::ChildCacheState::eRefetch; 254 } 255 256 size_t lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd:: 257 GetIndexOfChildWithName(ConstString name) { 258 if (!m_count || !m_base_data_address) 259 return UINT32_MAX; 260 const char *item_name = name.GetCString(); 261 uint32_t idx = ExtractIndexFromString(item_name); 262 if (idx < UINT32_MAX && idx >= CalculateNumChildrenIgnoringErrors()) 263 return UINT32_MAX; 264 return idx; 265 } 266 267 lldb_private::SyntheticChildrenFrontEnd * 268 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator( 269 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { 270 if (!valobj_sp) 271 return nullptr; 272 CompilerType type = valobj_sp->GetCompilerType(); 273 if (!type.IsValid() || type.GetNumTemplateArguments() == 0) 274 return nullptr; 275 CompilerType arg_type = type.GetTypeTemplateArgument(0); 276 if (arg_type.GetTypeName() == "bool") 277 return new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp); 278 return new LibcxxStdVectorSyntheticFrontEnd(valobj_sp); 279 } 280