1 //===-- LibCxxList.cpp -------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/lldb-python.h" 11 12 #include "lldb/DataFormatters/CXXFormatterFunctions.h" 13 14 #include "lldb/Core/DataBufferHeap.h" 15 #include "lldb/Core/Error.h" 16 #include "lldb/Core/Stream.h" 17 #include "lldb/Core/ValueObject.h" 18 #include "lldb/Core/ValueObjectConstResult.h" 19 #include "lldb/Host/Endian.h" 20 #include "lldb/Symbol/ClangASTContext.h" 21 #include "lldb/Target/ObjCLanguageRuntime.h" 22 #include "lldb/Target/Target.h" 23 24 using namespace lldb; 25 using namespace lldb_private; 26 using namespace lldb_private::formatters; 27 28 class ListEntry 29 { 30 public: 31 ListEntry () {} 32 ListEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {} 33 ListEntry (const ListEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {} 34 ListEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {} 35 36 ValueObjectSP 37 next () 38 { 39 if (!m_entry_sp) 40 return m_entry_sp; 41 return m_entry_sp->GetChildMemberWithName(ConstString("__next_"), true); 42 } 43 44 ValueObjectSP 45 prev () 46 { 47 if (!m_entry_sp) 48 return m_entry_sp; 49 return m_entry_sp->GetChildMemberWithName(ConstString("__prev_"), true); 50 } 51 52 uint64_t 53 value () 54 { 55 if (!m_entry_sp) 56 return 0; 57 return m_entry_sp->GetValueAsUnsigned(0); 58 } 59 60 bool 61 null() 62 { 63 return (value() == 0); 64 } 65 66 ValueObjectSP 67 GetEntry () 68 { 69 return m_entry_sp; 70 } 71 72 void 73 SetEntry (ValueObjectSP entry) 74 { 75 m_entry_sp = entry; 76 } 77 78 bool 79 operator == (const ListEntry& rhs) const 80 { 81 return (rhs.m_entry_sp.get() == m_entry_sp.get()); 82 } 83 84 private: 85 ValueObjectSP m_entry_sp; 86 }; 87 88 class ListIterator 89 { 90 public: 91 ListIterator () {} 92 ListIterator (ListEntry entry) : m_entry(entry) {} 93 ListIterator (ValueObjectSP entry) : m_entry(entry) {} 94 ListIterator (const ListIterator& rhs) : m_entry(rhs.m_entry) {} 95 ListIterator (ValueObject* entry) : m_entry(entry) {} 96 97 ValueObjectSP 98 value () 99 { 100 return m_entry.GetEntry(); 101 } 102 103 ValueObjectSP 104 advance (size_t count) 105 { 106 if (count == 0) 107 return m_entry.GetEntry(); 108 if (count == 1) 109 { 110 next (); 111 return m_entry.GetEntry(); 112 } 113 while (count > 0) 114 { 115 next (); 116 count--; 117 if (m_entry.null()) 118 return lldb::ValueObjectSP(); 119 } 120 return m_entry.GetEntry(); 121 } 122 123 bool 124 operator == (const ListIterator& rhs) const 125 { 126 return (rhs.m_entry == m_entry); 127 } 128 129 protected: 130 void 131 next () 132 { 133 m_entry.SetEntry(m_entry.next()); 134 } 135 136 void 137 prev () 138 { 139 m_entry.SetEntry(m_entry.prev()); 140 } 141 private: 142 ListEntry m_entry; 143 }; 144 145 lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::LibcxxStdListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) : 146 SyntheticChildrenFrontEnd(*valobj_sp.get()), 147 m_list_capping_size(0), 148 m_node_address(), 149 m_head(NULL), 150 m_tail(NULL), 151 m_element_type(), 152 m_count(UINT32_MAX), 153 m_children() 154 { 155 if (valobj_sp) 156 Update(); 157 } 158 159 bool 160 lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::HasLoop() 161 { 162 if (g_use_loop_detect == false) 163 return false; 164 ListEntry slow(m_head); 165 ListEntry fast1(m_head); 166 ListEntry fast2(m_head); 167 while (slow.next() && slow.next()->GetValueAsUnsigned(0) != m_node_address) 168 { 169 auto slow_value = slow.value(); 170 fast1.SetEntry(fast2.next()); 171 fast2.SetEntry(fast1.next()); 172 if (fast1.value() == slow_value || fast2.value() == slow_value) 173 return true; 174 slow.SetEntry(slow.next()); 175 } 176 return false; 177 } 178 179 size_t 180 lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::CalculateNumChildren () 181 { 182 if (m_count != UINT32_MAX) 183 return m_count; 184 if (!m_head || !m_tail || m_node_address == 0) 185 return 0; 186 ValueObjectSP size_alloc(m_backend.GetChildMemberWithName(ConstString("__size_alloc_"), true)); 187 if (size_alloc) 188 { 189 ValueObjectSP first(size_alloc->GetChildMemberWithName(ConstString("__first_"), true)); 190 if (first) 191 { 192 m_count = first->GetValueAsUnsigned(UINT32_MAX); 193 } 194 } 195 if (m_count != UINT32_MAX) 196 { 197 if (!HasLoop()) 198 return m_count; 199 return m_count = 0; 200 } 201 else 202 { 203 uint64_t next_val = m_head->GetValueAsUnsigned(0); 204 uint64_t prev_val = m_tail->GetValueAsUnsigned(0); 205 if (next_val == 0 || prev_val == 0) 206 return 0; 207 if (next_val == m_node_address) 208 return 0; 209 if (next_val == prev_val) 210 return 1; 211 if (HasLoop()) 212 return 0; 213 uint64_t size = 2; 214 ListEntry current(m_head); 215 while (current.next() && current.next()->GetValueAsUnsigned(0) != m_node_address) 216 { 217 size++; 218 current.SetEntry(current.next()); 219 if (size > m_list_capping_size) 220 break; 221 } 222 return m_count = (size-1); 223 } 224 } 225 226 lldb::ValueObjectSP 227 lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetChildAtIndex (size_t idx) 228 { 229 if (idx >= CalculateNumChildren()) 230 return lldb::ValueObjectSP(); 231 232 if (!m_head || !m_tail || m_node_address == 0) 233 return lldb::ValueObjectSP(); 234 235 auto cached = m_children.find(idx); 236 if (cached != m_children.end()) 237 return cached->second; 238 239 ListIterator current(m_head); 240 ValueObjectSP current_sp(current.advance(idx)); 241 if (!current_sp) 242 return lldb::ValueObjectSP(); 243 current_sp = current_sp->GetChildMemberWithName(ConstString("__value_"), true); 244 if (!current_sp) 245 return lldb::ValueObjectSP(); 246 // we need to copy current_sp into a new object otherwise we will end up with all items named __value_ 247 DataExtractor data; 248 current_sp->GetData(data); 249 StreamString name; 250 name.Printf("[%zu]",idx); 251 return (m_children[idx] = ValueObject::CreateValueObjectFromData(name.GetData(), data, m_backend.GetExecutionContextRef(), m_element_type)); 252 } 253 254 bool 255 lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::Update() 256 { 257 m_head = m_tail = NULL; 258 m_node_address = 0; 259 m_count = UINT32_MAX; 260 Error err; 261 ValueObjectSP backend_addr(m_backend.AddressOf(err)); 262 m_list_capping_size = 0; 263 if (m_backend.GetTargetSP()) 264 m_list_capping_size = m_backend.GetTargetSP()->GetMaximumNumberOfChildrenToDisplay(); 265 if (m_list_capping_size == 0) 266 m_list_capping_size = 255; 267 if (err.Fail() || backend_addr.get() == NULL) 268 return false; 269 m_node_address = backend_addr->GetValueAsUnsigned(0); 270 if (!m_node_address || m_node_address == LLDB_INVALID_ADDRESS) 271 return false; 272 ValueObjectSP impl_sp(m_backend.GetChildMemberWithName(ConstString("__end_"),true)); 273 if (!impl_sp) 274 return false; 275 ClangASTType list_type = m_backend.GetClangType(); 276 if (list_type.IsReferenceType()) 277 list_type = list_type.GetNonReferenceType(); 278 279 if (list_type.GetNumTemplateArguments() == 0) 280 return false; 281 lldb::TemplateArgumentKind kind; 282 m_element_type = list_type.GetTemplateArgument(0, kind); 283 m_head = impl_sp->GetChildMemberWithName(ConstString("__next_"), true).get(); 284 m_tail = impl_sp->GetChildMemberWithName(ConstString("__prev_"), true).get(); 285 return false; 286 } 287 288 bool 289 lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::MightHaveChildren () 290 { 291 return true; 292 } 293 294 size_t 295 lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name) 296 { 297 return ExtractIndexFromString(name.GetCString()); 298 } 299 300 lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::~LibcxxStdListSyntheticFrontEnd () 301 {} 302 303 SyntheticChildrenFrontEnd* 304 lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp) 305 { 306 if (!valobj_sp) 307 return NULL; 308 return (new LibcxxStdListSyntheticFrontEnd(valobj_sp)); 309 } 310 311
