contrib/llvm/tools/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

   1 //===-- LibStdcpp.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 "LibStdcpp.h"
  11
  12 #include "lldb/Core/ValueObject.h"
  13 #include "lldb/Core/ValueObjectConstResult.h"
  14 #include "lldb/DataFormatters/StringPrinter.h"
  15 #include "lldb/DataFormatters/VectorIterator.h"
  16 #include "lldb/Symbol/ClangASTContext.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 using namespace lldb;
  24 using namespace lldb_private;
  25 using namespace lldb_private::formatters;
  26
  27 namespace {
  28
  29 class LibstdcppMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
  30   /*
  31    (std::_Rb_tree_iterator<std::pair<const int, std::basic_string<char,
  32    std::char_traits<char>, std::allocator<char> > > >) ibeg = {
  33    (_Base_ptr) _M_node = 0x0000000100103910 {
  34    (std::_Rb_tree_color) _M_color = _S_black
  35    (std::_Rb_tree_node_base::_Base_ptr) _M_parent = 0x00000001001038c0
  36    (std::_Rb_tree_node_base::_Base_ptr) _M_left = 0x0000000000000000
  37    (std::_Rb_tree_node_base::_Base_ptr) _M_right = 0x0000000000000000
  38    }
  39    }
  40    */
  41
  42 public:
  43   explicit LibstdcppMapIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
  44
  45   size_t CalculateNumChildren() override;
  46
  47   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
  48
  49   bool Update() override;
  50
  51   bool MightHaveChildren() override;
  52
  53   size_t GetIndexOfChildWithName(const ConstString &name) override;
  54
  55 private:
  56   ExecutionContextRef m_exe_ctx_ref;
  57   lldb::addr_t m_pair_address;
  58   CompilerType m_pair_type;
  59   lldb::ValueObjectSP m_pair_sp;
  60 };
  61
  62 class LibStdcppSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
  63 public:
  64   explicit LibStdcppSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
  65
  66   size_t CalculateNumChildren() override;
  67
  68   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
  69
  70   bool Update() override;
  71
  72   bool MightHaveChildren() override;
  73
  74   size_t GetIndexOfChildWithName(const ConstString &name) override;
  75 };
  76
  77 } // end of anonymous namespace
  78
  79 LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd(
  80     lldb::ValueObjectSP valobj_sp)
  81     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_pair_address(0),
  82       m_pair_type(), m_pair_sp() {
  83   if (valobj_sp)
  84     Update();
  85 }
  86
  87 bool LibstdcppMapIteratorSyntheticFrontEnd::Update() {
  88   ValueObjectSP valobj_sp = m_backend.GetSP();
  89   if (!valobj_sp)
  90     return false;
  91
  92   TargetSP target_sp(valobj_sp->GetTargetSP());
  93
  94   if (!target_sp)
  95     return false;
  96
  97   bool is_64bit = (target_sp->GetArchitecture().GetAddressByteSize() == 8);
  98
  99   if (!valobj_sp)
 100     return false;
 101   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
 102
 103   ValueObjectSP _M_node_sp(
 104       valobj_sp->GetChildMemberWithName(ConstString("_M_node"), true));
 105   if (!_M_node_sp)
 106     return false;
 107
 108   m_pair_address = _M_node_sp->GetValueAsUnsigned(0);
 109   if (m_pair_address == 0)
 110     return false;
 111
 112   m_pair_address += (is_64bit ? 32 : 16);
 113
 114   CompilerType my_type(valobj_sp->GetCompilerType());
 115   if (my_type.GetNumTemplateArguments() >= 1) {
 116     CompilerType pair_type = my_type.GetTypeTemplateArgument(0);
 117     if (!pair_type)
 118       return false;
 119     m_pair_type = pair_type;
 120   } else
 121     return false;
 122
 123   return true;
 124 }
 125
 126 size_t LibstdcppMapIteratorSyntheticFrontEnd::CalculateNumChildren() {
 127   return 2;
 128 }
 129
 130 lldb::ValueObjectSP
 131 LibstdcppMapIteratorSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
 132   if (m_pair_address != 0 && m_pair_type) {
 133     if (!m_pair_sp)
 134       m_pair_sp = CreateValueObjectFromAddress("pair", m_pair_address,
 135                                                m_exe_ctx_ref, m_pair_type);
 136     if (m_pair_sp)
 137       return m_pair_sp->GetChildAtIndex(idx, true);
 138   }
 139   return lldb::ValueObjectSP();
 140 }
 141
 142 bool LibstdcppMapIteratorSyntheticFrontEnd::MightHaveChildren() { return true; }
 143
 144 size_t LibstdcppMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName(
 145     const ConstString &name) {
 146   if (name == ConstString("first"))
 147     return 0;
 148   if (name == ConstString("second"))
 149     return 1;
 150   return UINT32_MAX;
 151 }
 152
 153 SyntheticChildrenFrontEnd *
 154 lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator(
 155     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
 156   return (valobj_sp ? new LibstdcppMapIteratorSyntheticFrontEnd(valobj_sp)
 157                     : nullptr);
 158 }
 159
 160 /*
 161  (lldb) fr var ibeg --ptr-depth 1
 162  (__gnu_cxx::__normal_iterator<int *, std::vector<int, std::allocator<int> > >)
 163  ibeg = {
 164  _M_current = 0x00000001001037a0 {
 165  *_M_current = 1
 166  }
 167  }
 168  */
 169
 170 SyntheticChildrenFrontEnd *
 171 lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator(
 172     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
 173   static ConstString g_item_name;
 174   if (!g_item_name)
 175     g_item_name.SetCString("_M_current");
 176   return (valobj_sp
 177               ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name)
 178               : nullptr);
 179 }
 180
 181 lldb_private::formatters::VectorIteratorSyntheticFrontEnd::
 182     VectorIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp,
 183                                     ConstString item_name)
 184     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(),
 185       m_item_name(item_name), m_item_sp() {
 186   if (valobj_sp)
 187     Update();
 188 }
 189
 190 bool VectorIteratorSyntheticFrontEnd::Update() {
 191   m_item_sp.reset();
 192
 193   ValueObjectSP valobj_sp = m_backend.GetSP();
 194   if (!valobj_sp)
 195     return false;
 196
 197   if (!valobj_sp)
 198     return false;
 199
 200   ValueObjectSP item_ptr(valobj_sp->GetChildMemberWithName(m_item_name, true));
 201   if (!item_ptr)
 202     return false;
 203   if (item_ptr->GetValueAsUnsigned(0) == 0)
 204     return false;
 205   Status err;
 206   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
 207   m_item_sp = CreateValueObjectFromAddress(
 208       "item", item_ptr->GetValueAsUnsigned(0), m_exe_ctx_ref,
 209       item_ptr->GetCompilerType().GetPointeeType());
 210   if (err.Fail())
 211     m_item_sp.reset();
 212   return false;
 213 }
 214
 215 size_t VectorIteratorSyntheticFrontEnd::CalculateNumChildren() { return 1; }
 216
 217 lldb::ValueObjectSP
 218 VectorIteratorSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
 219   if (idx == 0)
 220     return m_item_sp;
 221   return lldb::ValueObjectSP();
 222 }
 223
 224 bool VectorIteratorSyntheticFrontEnd::MightHaveChildren() { return true; }
 225
 226 size_t VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName(
 227     const ConstString &name) {
 228   if (name == ConstString("item"))
 229     return 0;
 230   return UINT32_MAX;
 231 }
 232
 233 bool lldb_private::formatters::LibStdcppStringSummaryProvider(
 234     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
 235   const bool scalar_is_load_addr = true;
 236   AddressType addr_type;
 237   lldb::addr_t addr_of_string =
 238       valobj.GetAddressOf(scalar_is_load_addr, &addr_type);
 239   if (addr_of_string != LLDB_INVALID_ADDRESS) {
 240     switch (addr_type) {
 241     case eAddressTypeLoad: {
 242       ProcessSP process_sp(valobj.GetProcessSP());
 243       if (!process_sp)
 244         return false;
 245
 246       StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
 247       Status error;
 248       lldb::addr_t addr_of_data =
 249           process_sp->ReadPointerFromMemory(addr_of_string, error);
 250       if (error.Fail() || addr_of_data == 0 ||
 251           addr_of_data == LLDB_INVALID_ADDRESS)
 252         return false;
 253       options.SetLocation(addr_of_data);
 254       options.SetProcessSP(process_sp);
 255       options.SetStream(&stream);
 256       options.SetNeedsZeroTermination(false);
 257       options.SetBinaryZeroIsTerminator(true);
 258       lldb::addr_t size_of_data = process_sp->ReadPointerFromMemory(
 259           addr_of_string + process_sp->GetAddressByteSize(), error);
 260       if (error.Fail())
 261         return false;
 262       options.SetSourceSize(size_of_data);
 263
 264       if (!StringPrinter::ReadStringAndDumpToStream<
 265               StringPrinter::StringElementType::UTF8>(options)) {
 266         stream.Printf("Summary Unavailable");
 267         return true;
 268       } else
 269         return true;
 270     } break;
 271     case eAddressTypeHost:
 272       break;
 273     case eAddressTypeInvalid:
 274     case eAddressTypeFile:
 275       break;
 276     }
 277   }
 278   return false;
 279 }
 280
 281 bool lldb_private::formatters::LibStdcppWStringSummaryProvider(
 282     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
 283   const bool scalar_is_load_addr = true;
 284   AddressType addr_type;
 285   lldb::addr_t addr_of_string =
 286       valobj.GetAddressOf(scalar_is_load_addr, &addr_type);
 287   if (addr_of_string != LLDB_INVALID_ADDRESS) {
 288     switch (addr_type) {
 289     case eAddressTypeLoad: {
 290       ProcessSP process_sp(valobj.GetProcessSP());
 291       if (!process_sp)
 292         return false;
 293
 294       CompilerType wchar_compiler_type =
 295           valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeWChar);
 296
 297       if (!wchar_compiler_type)
 298         return false;
 299
 300       // Safe to pass nullptr for exe_scope here.
 301       llvm::Optional<uint64_t> size = wchar_compiler_type.GetBitSize(nullptr);
 302       if (!size)
 303         return false;
 304       const uint32_t wchar_size = *size;
 305
 306       StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
 307       Status error;
 308       lldb::addr_t addr_of_data =
 309           process_sp->ReadPointerFromMemory(addr_of_string, error);
 310       if (error.Fail() || addr_of_data == 0 ||
 311           addr_of_data == LLDB_INVALID_ADDRESS)
 312         return false;
 313       options.SetLocation(addr_of_data);
 314       options.SetProcessSP(process_sp);
 315       options.SetStream(&stream);
 316       options.SetNeedsZeroTermination(false);
 317       options.SetBinaryZeroIsTerminator(false);
 318       lldb::addr_t size_of_data = process_sp->ReadPointerFromMemory(
 319           addr_of_string + process_sp->GetAddressByteSize(), error);
 320       if (error.Fail())
 321         return false;
 322       options.SetSourceSize(size_of_data);
 323       options.SetPrefixToken("L");
 324
 325       switch (wchar_size) {
 326       case 8:
 327         return StringPrinter::ReadStringAndDumpToStream<
 328             StringPrinter::StringElementType::UTF8>(options);
 329       case 16:
 330         return StringPrinter::ReadStringAndDumpToStream<
 331             StringPrinter::StringElementType::UTF16>(options);
 332       case 32:
 333         return StringPrinter::ReadStringAndDumpToStream<
 334             StringPrinter::StringElementType::UTF32>(options);
 335       default:
 336         stream.Printf("size for wchar_t is not valid");
 337         return true;
 338       }
 339       return true;
 340     } break;
 341     case eAddressTypeHost:
 342       break;
 343     case eAddressTypeInvalid:
 344     case eAddressTypeFile:
 345       break;
 346     }
 347   }
 348   return false;
 349 }
 350
 351 LibStdcppSharedPtrSyntheticFrontEnd::LibStdcppSharedPtrSyntheticFrontEnd(
 352     lldb::ValueObjectSP valobj_sp)
 353     : SyntheticChildrenFrontEnd(*valobj_sp) {
 354   if (valobj_sp)
 355     Update();
 356 }
 357
 358 size_t LibStdcppSharedPtrSyntheticFrontEnd::CalculateNumChildren() { return 1; }
 359
 360 lldb::ValueObjectSP
 361 LibStdcppSharedPtrSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
 362   ValueObjectSP valobj_sp = m_backend.GetSP();
 363   if (!valobj_sp)
 364     return lldb::ValueObjectSP();
 365
 366   if (idx == 0)
 367     return valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true);
 368   else
 369     return lldb::ValueObjectSP();
 370 }
 371
 372 bool LibStdcppSharedPtrSyntheticFrontEnd::Update() { return false; }
 373
 374 bool LibStdcppSharedPtrSyntheticFrontEnd::MightHaveChildren() { return true; }
 375
 376 size_t LibStdcppSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName(
 377     const ConstString &name) {
 378   if (name == ConstString("_M_ptr"))
 379     return 0;
 380   return UINT32_MAX;
 381 }
 382
 383 SyntheticChildrenFrontEnd *
 384 lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator(
 385     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
 386   return (valobj_sp ? new LibStdcppSharedPtrSyntheticFrontEnd(valobj_sp)
 387                     : nullptr);
 388 }
 389
 390 bool lldb_private::formatters::LibStdcppSmartPointerSummaryProvider(
 391     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
 392   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
 393   if (!valobj_sp)
 394     return false;
 395
 396   ValueObjectSP ptr_sp(
 397       valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true));
 398   if (!ptr_sp)
 399     return false;
 400
 401   ValueObjectSP usecount_sp(valobj_sp->GetChildAtNamePath(
 402       {ConstString("_M_refcount"), ConstString("_M_pi"),
 403        ConstString("_M_use_count")}));
 404   if (!usecount_sp)
 405     return false;
 406
 407   if (ptr_sp->GetValueAsUnsigned(0) == 0 ||
 408       usecount_sp->GetValueAsUnsigned(0) == 0) {
 409     stream.Printf("nullptr");
 410     return true;
 411   }
 412
 413   Status error;
 414   ValueObjectSP pointee_sp = ptr_sp->Dereference(error);
 415   if (pointee_sp && error.Success()) {
 416     if (pointee_sp->DumpPrintableRepresentation(
 417             stream, ValueObject::eValueObjectRepresentationStyleSummary,
 418             lldb::eFormatInvalid,
 419             ValueObject::PrintableRepresentationSpecialCases::eDisable,
 420             false)) {
 421       return true;
 422     }
 423   }
 424
 425   stream.Printf("ptr = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0));
 426   return true;
 427 }