contrib/llvm/tools/lldb/source/DataFormatters/LibCxxMap.cpp

   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 MapEntry
  29 {
  30 public:
  31     MapEntry () {}
  32     MapEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {}
  33     MapEntry (const MapEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {}
  34     MapEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {}
  35
  36     ValueObjectSP
  37     left ()
  38     {
  39         if (!m_entry_sp)
  40             return m_entry_sp;
  41         return m_entry_sp->GetChildMemberWithName(ConstString("__left_"), true);
  42     }
  43
  44     ValueObjectSP
  45     right ()
  46     {
  47         if (!m_entry_sp)
  48             return m_entry_sp;
  49         return m_entry_sp->GetChildMemberWithName(ConstString("__right_"), true);
  50     }
  51
  52     ValueObjectSP
  53     parent ()
  54     {
  55         if (!m_entry_sp)
  56             return m_entry_sp;
  57         return m_entry_sp->GetChildMemberWithName(ConstString("__parent_"), true);
  58     }
  59
  60     uint64_t
  61     value ()
  62     {
  63         if (!m_entry_sp)
  64             return 0;
  65         return m_entry_sp->GetValueAsUnsigned(0);
  66     }
  67
  68     bool
  69     error ()
  70     {
  71         if (!m_entry_sp)
  72             return true;
  73         return m_entry_sp->GetError().Fail();
  74     }
  75
  76     bool
  77     null()
  78     {
  79         return (value() == 0);
  80     }
  81
  82     ValueObjectSP
  83     GetEntry ()
  84     {
  85         return m_entry_sp;
  86     }
  87
  88     void
  89     SetEntry (ValueObjectSP entry)
  90     {
  91         m_entry_sp = entry;
  92     }
  93
  94     bool
  95     operator == (const MapEntry& rhs) const
  96     {
  97         return (rhs.m_entry_sp.get() == m_entry_sp.get());
  98     }
  99
 100 private:
 101     ValueObjectSP m_entry_sp;
 102 };
 103
 104 class MapIterator
 105 {
 106 public:
 107     MapIterator () {}
 108     MapIterator (MapEntry entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
 109     MapIterator (ValueObjectSP entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
 110     MapIterator (const MapIterator& rhs) : m_entry(rhs.m_entry),m_max_depth(rhs.m_max_depth), m_error(false) {}
 111     MapIterator (ValueObject* entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
 112
 113     ValueObjectSP
 114     value ()
 115     {
 116         return m_entry.GetEntry();
 117     }
 118
 119     ValueObjectSP
 120     advance (size_t count)
 121     {
 122         if (m_error)
 123             return lldb::ValueObjectSP();
 124         if (count == 0)
 125             return m_entry.GetEntry();
 126         if (count == 1)
 127         {
 128             next ();
 129             return m_entry.GetEntry();
 130         }
 131         size_t steps = 0;
 132         while (count > 0)
 133         {
 134             if (m_error)
 135                 return lldb::ValueObjectSP();
 136             next ();
 137             count--;
 138             if (m_entry.null())
 139                 return lldb::ValueObjectSP();
 140             steps++;
 141             if (steps > m_max_depth)
 142                 return lldb::ValueObjectSP();
 143         }
 144         return m_entry.GetEntry();
 145     }
 146 protected:
 147     void
 148     next ()
 149     {
 150         m_entry.SetEntry(increment(m_entry.GetEntry()));
 151     }
 152
 153 private:
 154     ValueObjectSP
 155     tree_min (ValueObjectSP x_sp)
 156     {
 157         MapEntry x(x_sp);
 158         if (x.null())
 159             return ValueObjectSP();
 160         MapEntry left(x.left());
 161         size_t steps = 0;
 162         while (left.null() == false)
 163         {
 164             if (left.error())
 165             {
 166                 m_error = true;
 167                 return lldb::ValueObjectSP();
 168             }
 169             x.SetEntry(left.GetEntry());
 170             left.SetEntry(x.left());
 171             steps++;
 172             if (steps > m_max_depth)
 173                 return lldb::ValueObjectSP();
 174         }
 175         return x.GetEntry();
 176     }
 177
 178     ValueObjectSP
 179     tree_max (ValueObjectSP x_sp)
 180     {
 181         MapEntry x(x_sp);
 182         if (x.null())
 183             return ValueObjectSP();
 184         MapEntry right(x.right());
 185         size_t steps = 0;
 186         while (right.null() == false)
 187         {
 188             if (right.error())
 189                 return lldb::ValueObjectSP();
 190             x.SetEntry(right.GetEntry());
 191             right.SetEntry(x.right());
 192             steps++;
 193             if (steps > m_max_depth)
 194                 return lldb::ValueObjectSP();
 195         }
 196         return x.GetEntry();
 197     }
 198
 199     bool
 200     is_left_child (ValueObjectSP x_sp)
 201     {
 202         MapEntry x(x_sp);
 203         if (x.null())
 204             return false;
 205         MapEntry rhs(x.parent());
 206         rhs.SetEntry(rhs.left());
 207         return x.value() == rhs.value();
 208     }
 209
 210     ValueObjectSP
 211     increment (ValueObjectSP x_sp)
 212     {
 213         MapEntry node(x_sp);
 214         if (node.null())
 215             return ValueObjectSP();
 216         MapEntry right(node.right());
 217         if (right.null() == false)
 218             return tree_min(right.GetEntry());
 219         size_t steps = 0;
 220         while (!is_left_child(node.GetEntry()))
 221         {
 222             if (node.error())
 223             {
 224                 m_error = true;
 225                 return lldb::ValueObjectSP();
 226             }
 227             node.SetEntry(node.parent());
 228             steps++;
 229             if (steps > m_max_depth)
 230                 return lldb::ValueObjectSP();
 231         }
 232         return node.parent();
 233     }
 234
 235     MapEntry m_entry;
 236     size_t m_max_depth;
 237     bool m_error;
 238 };
 239
 240 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::LibcxxStdMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
 241 SyntheticChildrenFrontEnd(*valobj_sp.get()),
 242 m_tree(NULL),
 243 m_root_node(NULL),
 244 m_element_type(),
 245 m_skip_size(UINT32_MAX),
 246 m_count(UINT32_MAX),
 247 m_children()
 248 {
 249     if (valobj_sp)
 250         Update();
 251 }
 252
 253 size_t
 254 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::CalculateNumChildren ()
 255 {
 256     if (m_count != UINT32_MAX)
 257         return m_count;
 258     if (m_tree == NULL)
 259         return 0;
 260     ValueObjectSP m_item(m_tree->GetChildMemberWithName(ConstString("__pair3_"), true));
 261     if (!m_item)
 262         return 0;
 263     m_item = m_item->GetChildMemberWithName(ConstString("__first_"), true);
 264     if (!m_item)
 265         return 0;
 266     m_count = m_item->GetValueAsUnsigned(0);
 267     return m_count;
 268 }
 269
 270 bool
 271 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType()
 272 {
 273     if (m_element_type.GetOpaqueQualType() && m_element_type.GetASTContext())
 274         return true;
 275     m_element_type.Clear();
 276     ValueObjectSP deref;
 277     Error error;
 278     deref = m_root_node->Dereference(error);
 279     if (!deref || error.Fail())
 280         return false;
 281     deref = deref->GetChildMemberWithName(ConstString("__value_"), true);
 282     if (!deref)
 283         return false;
 284     m_element_type = deref->GetClangType();
 285     return true;
 286 }
 287
 288 void
 289 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset (const lldb::ValueObjectSP& node)
 290 {
 291     if (m_skip_size != UINT32_MAX)
 292         return;
 293     if (!node)
 294         return;
 295     ClangASTType node_type(node->GetClangType());
 296     uint64_t bit_offset;
 297     if (node_type.GetIndexOfFieldWithName("__value_", NULL, &bit_offset) == UINT32_MAX)
 298         return;
 299     m_skip_size = bit_offset / 8u;
 300 }
 301
 302 lldb::ValueObjectSP
 303 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex (size_t idx)
 304 {
 305     if (idx >= CalculateNumChildren())
 306         return lldb::ValueObjectSP();
 307     if (m_tree == NULL || m_root_node == NULL)
 308         return lldb::ValueObjectSP();
 309
 310     auto cached = m_children.find(idx);
 311     if (cached != m_children.end())
 312         return cached->second;
 313
 314     bool need_to_skip = (idx > 0);
 315     MapIterator iterator(m_root_node, CalculateNumChildren());
 316     ValueObjectSP iterated_sp(iterator.advance(idx));
 317     if (iterated_sp.get() == NULL)
 318     {
 319         // this tree is garbage - stop
 320         m_tree = NULL; // this will stop all future searches until an Update() happens
 321         return iterated_sp;
 322     }
 323     if (GetDataType())
 324     {
 325         if (!need_to_skip)
 326         {
 327             Error error;
 328             iterated_sp = iterated_sp->Dereference(error);
 329             if (!iterated_sp || error.Fail())
 330             {
 331                 m_tree = NULL;
 332                 return lldb::ValueObjectSP();
 333             }
 334             GetValueOffset(iterated_sp);
 335             iterated_sp = iterated_sp->GetChildMemberWithName(ConstString("__value_"), true);
 336             if (!iterated_sp)
 337             {
 338                 m_tree = NULL;
 339                 return lldb::ValueObjectSP();
 340             }
 341         }
 342         else
 343         {
 344             // because of the way our debug info is made, we need to read item 0 first
 345             // so that we can cache information used to generate other elements
 346             if (m_skip_size == UINT32_MAX)
 347                 GetChildAtIndex(0);
 348             if (m_skip_size == UINT32_MAX)
 349             {
 350                 m_tree = NULL;
 351                 return lldb::ValueObjectSP();
 352             }
 353             iterated_sp = iterated_sp->GetSyntheticChildAtOffset(m_skip_size, m_element_type, true);
 354             if (!iterated_sp)
 355             {
 356                 m_tree = NULL;
 357                 return lldb::ValueObjectSP();
 358             }
 359         }
 360     }
 361     else
 362     {
 363         m_tree = NULL;
 364         return lldb::ValueObjectSP();
 365     }
 366     // at this point we have a valid
 367     // we need to copy current_sp into a new object otherwise we will end up with all items named __value_
 368     DataExtractor data;
 369     iterated_sp->GetData(data);
 370     StreamString name;
 371     name.Printf("[%zu]",idx);
 372     return (m_children[idx] = ValueObject::CreateValueObjectFromData(name.GetData(), data, m_backend.GetExecutionContextRef(), m_element_type));
 373 }
 374
 375 bool
 376 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::Update()
 377 {
 378     m_count = UINT32_MAX;
 379     m_tree = m_root_node = NULL;
 380     m_children.clear();
 381     m_tree = m_backend.GetChildMemberWithName(ConstString("__tree_"), true).get();
 382     if (!m_tree)
 383         return false;
 384     m_root_node = m_tree->GetChildMemberWithName(ConstString("__begin_node_"), true).get();
 385     return false;
 386 }
 387
 388 bool
 389 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::MightHaveChildren ()
 390 {
 391     return true;
 392 }
 393
 394 size_t
 395 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 396 {
 397     return ExtractIndexFromString(name.GetCString());
 398 }
 399
 400 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::~LibcxxStdMapSyntheticFrontEnd ()
 401 {}
 402
 403 SyntheticChildrenFrontEnd*
 404 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
 405 {
 406     if (!valobj_sp)
 407         return NULL;
 408     return (new LibcxxStdMapSyntheticFrontEnd(valobj_sp));
 409 }