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

   1 //===-- CPlusPlusLanguage.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 "CPlusPlusLanguage.h"
  11
  12
  13 #include "llvm/ADT/StringRef.h"
  14
  15 #include "lldb/Core/ConstString.h"
  16 #include "lldb/Core/PluginManager.h"
  17 #include "lldb/Core/RegularExpression.h"
  18 #include "lldb/Core/UniqueCStringMap.h"
  19 #include "lldb/DataFormatters/CXXFunctionPointer.h"
  20 #include "lldb/DataFormatters/DataVisualization.h"
  21 #include "lldb/DataFormatters/FormattersHelpers.h"
  22 #include "lldb/DataFormatters/VectorType.h"
  23
  24 #include "CxxStringTypes.h"
  25 #include "LibCxx.h"
  26 #include "LibStdcpp.h"
  27
  28 #include <cstring>
  29 #include <cctype>
  30 #include <functional>
  31 #include <mutex>
  32
  33 using namespace lldb;
  34 using namespace lldb_private;
  35 using namespace lldb_private::formatters;
  36
  37 void
  38 CPlusPlusLanguage::Initialize()
  39 {
  40     PluginManager::RegisterPlugin (GetPluginNameStatic(),
  41                                    "C++ Language",
  42                                    CreateInstance);
  43 }
  44
  45 void
  46 CPlusPlusLanguage::Terminate()
  47 {
  48     PluginManager::UnregisterPlugin (CreateInstance);
  49 }
  50
  51 lldb_private::ConstString
  52 CPlusPlusLanguage::GetPluginNameStatic()
  53 {
  54     static ConstString g_name("cplusplus");
  55     return g_name;
  56 }
  57
  58
  59 //------------------------------------------------------------------
  60 // PluginInterface protocol
  61 //------------------------------------------------------------------
  62 lldb_private::ConstString
  63 CPlusPlusLanguage::GetPluginName()
  64 {
  65     return GetPluginNameStatic();
  66 }
  67
  68 uint32_t
  69 CPlusPlusLanguage::GetPluginVersion()
  70 {
  71     return 1;
  72 }
  73
  74 //------------------------------------------------------------------
  75 // Static Functions
  76 //------------------------------------------------------------------
  77 Language *
  78 CPlusPlusLanguage::CreateInstance (lldb::LanguageType language)
  79 {
  80     if (Language::LanguageIsCPlusPlus(language))
  81         return new CPlusPlusLanguage();
  82     return nullptr;
  83 }
  84
  85 void
  86 CPlusPlusLanguage::MethodName::Clear()
  87 {
  88     m_full.Clear();
  89     m_basename = llvm::StringRef();
  90     m_context = llvm::StringRef();
  91     m_arguments = llvm::StringRef();
  92     m_qualifiers = llvm::StringRef();
  93     m_type = eTypeInvalid;
  94     m_parsed = false;
  95     m_parse_error = false;
  96 }
  97
  98 bool
  99 ReverseFindMatchingChars (const llvm::StringRef &s,
 100                           const llvm::StringRef &left_right_chars,
 101                           size_t &left_pos,
 102                           size_t &right_pos,
 103                           size_t pos = llvm::StringRef::npos)
 104 {
 105     assert (left_right_chars.size() == 2);
 106     left_pos = llvm::StringRef::npos;
 107     const char left_char = left_right_chars[0];
 108     const char right_char = left_right_chars[1];
 109     pos = s.find_last_of(left_right_chars, pos);
 110     if (pos == llvm::StringRef::npos || s[pos] == left_char)
 111         return false;
 112     right_pos = pos;
 113     uint32_t depth = 1;
 114     while (pos > 0 && depth > 0)
 115     {
 116         pos = s.find_last_of(left_right_chars, pos);
 117         if (pos == llvm::StringRef::npos)
 118             return false;
 119         if (s[pos] == left_char)
 120         {
 121             if (--depth == 0)
 122             {
 123                 left_pos = pos;
 124                 return left_pos < right_pos;
 125             }
 126         }
 127         else if (s[pos] == right_char)
 128         {
 129             ++depth;
 130         }
 131     }
 132     return false;
 133 }
 134
 135 static bool
 136 IsValidBasename(const llvm::StringRef& basename)
 137 {
 138     // Check that the basename matches with the following regular expression or is an operator name:
 139     // "^~?([A-Za-z_][A-Za-z_0-9]*)(<.*>)?$"
 140     // We are using a hand written implementation because it is significantly more efficient then
 141     // using the general purpose regular expression library.
 142     size_t idx = 0;
 143     if (basename.size() > 0 && basename[0] == '~')
 144         idx = 1;
 145
 146     if (basename.size() <= idx)
 147         return false; // Empty string or "~"
 148
 149     if (!std::isalpha(basename[idx]) && basename[idx] != '_')
 150         return false; // First charater (after removing the possible '~'') isn't in [A-Za-z_]
 151
 152     // Read all characters matching [A-Za-z_0-9]
 153     ++idx;
 154     while (idx < basename.size())
 155     {
 156         if (!std::isalnum(basename[idx]) && basename[idx] != '_')
 157             break;
 158         ++idx;
 159     }
 160
 161     // We processed all characters. It is a vaild basename.
 162     if (idx == basename.size())
 163         return true;
 164
 165     // Check for basename with template arguments
 166     // TODO: Improve the quality of the validation with validating the template arguments
 167     if (basename[idx] == '<' && basename.back() == '>')
 168         return true;
 169
 170     // Check if the basename is a vaild C++ operator name
 171     if (!basename.startswith("operator"))
 172         return false;
 173
 174     static RegularExpression g_operator_regex("^(operator)( ?)([A-Za-z_][A-Za-z_0-9]*|\\(\\)|\\[\\]|[\\^<>=!\\/*+-]+)(<.*>)?(\\[\\])?$");
 175     std::string basename_str(basename.str());
 176     return g_operator_regex.Execute(basename_str.c_str(), nullptr);
 177 }
 178
 179 void
 180 CPlusPlusLanguage::MethodName::Parse()
 181 {
 182     if (!m_parsed && m_full)
 183     {
 184 //        ConstString mangled;
 185 //        m_full.GetMangledCounterpart(mangled);
 186 //        printf ("\n   parsing = '%s'\n", m_full.GetCString());
 187 //        if (mangled)
 188 //            printf ("   mangled = '%s'\n", mangled.GetCString());
 189         m_parse_error = false;
 190         m_parsed = true;
 191         llvm::StringRef full (m_full.GetCString());
 192
 193         size_t arg_start, arg_end;
 194         llvm::StringRef parens("()", 2);
 195         if (ReverseFindMatchingChars (full, parens, arg_start, arg_end))
 196         {
 197             m_arguments = full.substr(arg_start, arg_end - arg_start + 1);
 198             if (arg_end + 1 < full.size())
 199                 m_qualifiers = full.substr(arg_end + 1);
 200             if (arg_start > 0)
 201             {
 202                 size_t basename_end = arg_start;
 203                 size_t context_start = 0;
 204                 size_t context_end = llvm::StringRef::npos;
 205                 if (basename_end > 0 && full[basename_end-1] == '>')
 206                 {
 207                     // TODO: handle template junk...
 208                     // Templated function
 209                     size_t template_start, template_end;
 210                     llvm::StringRef lt_gt("<>", 2);
 211                     if (ReverseFindMatchingChars (full, lt_gt, template_start, template_end, basename_end))
 212                     {
 213                         // Check for templated functions that include return type like: 'void foo<Int>()'
 214                         context_start = full.rfind(' ', template_start);
 215                         if (context_start == llvm::StringRef::npos)
 216                             context_start = 0;
 217
 218                         context_end = full.rfind(':', template_start);
 219                         if (context_end == llvm::StringRef::npos || context_end < context_start)
 220                             context_end = context_start;
 221                     }
 222                     else
 223                     {
 224                         context_end = full.rfind(':', basename_end);
 225                     }
 226                 }
 227                 else if (context_end == llvm::StringRef::npos)
 228                 {
 229                     context_end = full.rfind(':', basename_end);
 230                 }
 231
 232                 if (context_end == llvm::StringRef::npos)
 233                     m_basename = full.substr(0, basename_end);
 234                 else
 235                 {
 236                     if (context_start < context_end)
 237                         m_context = full.substr(context_start, context_end - 1);
 238                     const size_t basename_begin = context_end + 1;
 239                     m_basename = full.substr(basename_begin, basename_end - basename_begin);
 240                 }
 241                 m_type = eTypeUnknownMethod;
 242             }
 243             else
 244             {
 245                 m_parse_error = true;
 246                 return;
 247             }
 248
 249             if (!IsValidBasename(m_basename))
 250             {
 251                 // The C++ basename doesn't match our regular expressions so this can't
 252                 // be a valid C++ method, clear everything out and indicate an error
 253                 m_context = llvm::StringRef();
 254                 m_basename = llvm::StringRef();
 255                 m_arguments = llvm::StringRef();
 256                 m_qualifiers = llvm::StringRef();
 257                 m_parse_error = true;
 258             }
 259         }
 260         else
 261         {
 262             m_parse_error = true;
 263         }
 264     }
 265 }
 266
 267 llvm::StringRef
 268 CPlusPlusLanguage::MethodName::GetBasename ()
 269 {
 270     if (!m_parsed)
 271         Parse();
 272     return m_basename;
 273 }
 274
 275 llvm::StringRef
 276 CPlusPlusLanguage::MethodName::GetContext ()
 277 {
 278     if (!m_parsed)
 279         Parse();
 280     return m_context;
 281 }
 282
 283 llvm::StringRef
 284 CPlusPlusLanguage::MethodName::GetArguments ()
 285 {
 286     if (!m_parsed)
 287         Parse();
 288     return m_arguments;
 289 }
 290
 291 llvm::StringRef
 292 CPlusPlusLanguage::MethodName::GetQualifiers ()
 293 {
 294     if (!m_parsed)
 295         Parse();
 296     return m_qualifiers;
 297 }
 298
 299 bool
 300 CPlusPlusLanguage::IsCPPMangledName (const char *name)
 301 {
 302     // FIXME, we should really run through all the known C++ Language plugins and ask each one if
 303     // this is a C++ mangled name, but we can put that off till there is actually more than one
 304     // we care about.
 305
 306     if (name && name[0] == '_' && name[1] == 'Z')
 307         return true;
 308     else
 309         return false;
 310 }
 311
 312 bool
 313 CPlusPlusLanguage::ExtractContextAndIdentifier (const char *name, llvm::StringRef &context, llvm::StringRef &identifier)
 314 {
 315     static RegularExpression g_basename_regex("^(([A-Za-z_][A-Za-z_0-9]*::)*)([A-Za-z_][A-Za-z_0-9]*)$");
 316     RegularExpression::Match match(4);
 317     if (g_basename_regex.Execute (name, &match))
 318     {
 319         match.GetMatchAtIndex(name, 1, context);
 320         match.GetMatchAtIndex(name, 3, identifier);
 321         return true;
 322     }
 323     return false;
 324 }
 325
 326 class CPPRuntimeEquivalents
 327 {
 328 public:
 329     CPPRuntimeEquivalents ()
 330     {
 331
 332         m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >").AsCString(), ConstString("basic_string<char>"));
 333
 334         // these two (with a prefixed std::) occur when c++stdlib string class occurs as a template argument in some STL container
 335         m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >").AsCString(), ConstString("std::basic_string<char>"));
 336
 337         m_impl.Sort();
 338     }
 339
 340     void
 341     Add (ConstString& type_name,
 342          ConstString& type_equivalent)
 343     {
 344         m_impl.Insert(type_name.AsCString(), type_equivalent);
 345     }
 346
 347     uint32_t
 348     FindExactMatches (ConstString& type_name,
 349                       std::vector<ConstString>& equivalents)
 350     {
 351
 352         uint32_t count = 0;
 353
 354         for (ImplData match = m_impl.FindFirstValueForName(type_name.AsCString());
 355              match != NULL;
 356              match = m_impl.FindNextValueForName(match))
 357         {
 358             equivalents.push_back(match->value);
 359             count++;
 360         }
 361
 362         return count;
 363     }
 364
 365     // partial matches can occur when a name with equivalents is a template argument.
 366     // e.g. we may have "class Foo" be a match for "struct Bar". if we have a typename
 367     // such as "class Templatized<class Foo, Anything>" we want this to be replaced with
 368     // "class Templatized<struct Bar, Anything>". Since partial matching is time consuming
 369     // once we get a partial match, we add it to the exact matches list for faster retrieval
 370     uint32_t
 371     FindPartialMatches (ConstString& type_name,
 372                         std::vector<ConstString>& equivalents)
 373     {
 374
 375         uint32_t count = 0;
 376
 377         const char* type_name_cstr = type_name.AsCString();
 378
 379         size_t items_count = m_impl.GetSize();
 380
 381         for (size_t item = 0; item < items_count; item++)
 382         {
 383             const char* key_cstr = m_impl.GetCStringAtIndex(item);
 384             if ( strstr(type_name_cstr,key_cstr) )
 385             {
 386                 count += AppendReplacements(type_name_cstr,
 387                                             key_cstr,
 388                                             equivalents);
 389             }
 390         }
 391
 392         return count;
 393
 394     }
 395
 396 private:
 397
 398     std::string& replace (std::string& target,
 399                           std::string& pattern,
 400                           std::string& with)
 401     {
 402         size_t pos;
 403         size_t pattern_len = pattern.size();
 404
 405         while ( (pos = target.find(pattern)) != std::string::npos )
 406             target.replace(pos, pattern_len, with);
 407
 408         return target;
 409     }
 410
 411     uint32_t
 412     AppendReplacements (const char* original,
 413                         const char *matching_key,
 414                         std::vector<ConstString>& equivalents)
 415     {
 416
 417         std::string matching_key_str(matching_key);
 418         ConstString original_const(original);
 419
 420         uint32_t count = 0;
 421
 422         for (ImplData match = m_impl.FindFirstValueForName(matching_key);
 423              match != NULL;
 424              match = m_impl.FindNextValueForName(match))
 425         {
 426             std::string target(original);
 427             std::string equiv_class(match->value.AsCString());
 428
 429             replace (target, matching_key_str, equiv_class);
 430
 431             ConstString target_const(target.c_str());
 432
 433 // you will most probably want to leave this off since it might make this map grow indefinitely
 434 #ifdef ENABLE_CPP_EQUIVALENTS_MAP_TO_GROW
 435             Add(original_const, target_const);
 436 #endif
 437             equivalents.push_back(target_const);
 438
 439             count++;
 440         }
 441
 442         return count;
 443     }
 444
 445     typedef UniqueCStringMap<ConstString> Impl;
 446     typedef const Impl::Entry* ImplData;
 447     Impl m_impl;
 448 };
 449
 450 static CPPRuntimeEquivalents&
 451 GetEquivalentsMap ()
 452 {
 453     static CPPRuntimeEquivalents g_equivalents_map;
 454     return g_equivalents_map;
 455 }
 456
 457
 458 uint32_t
 459 CPlusPlusLanguage::FindEquivalentNames(ConstString type_name, std::vector<ConstString>& equivalents)
 460 {
 461     uint32_t count = GetEquivalentsMap().FindExactMatches(type_name, equivalents);
 462
 463     bool might_have_partials=
 464         ( count == 0 )  // if we have a full name match just use it
 465         && (strchr(type_name.AsCString(), '<') != NULL  // we should only have partial matches when templates are involved, check that we have
 466             && strchr(type_name.AsCString(), '>') != NULL); // angle brackets in the type_name before trying to scan for partial matches
 467
 468     if ( might_have_partials )
 469         count = GetEquivalentsMap().FindPartialMatches(type_name, equivalents);
 470
 471     return count;
 472 }
 473
 474 static void
 475 LoadLibCxxFormatters (lldb::TypeCategoryImplSP cpp_category_sp)
 476 {
 477     if (!cpp_category_sp)
 478         return;
 479
 480     TypeSummaryImpl::Flags stl_summary_flags;
 481     stl_summary_flags.SetCascades(true)
 482     .SetSkipPointers(false)
 483     .SetSkipReferences(false)
 484     .SetDontShowChildren(true)
 485     .SetDontShowValue(true)
 486     .SetShowMembersOneLiner(false)
 487     .SetHideItemNames(false);
 488
 489 #ifndef LLDB_DISABLE_PYTHON
 490     lldb::TypeSummaryImplSP std_string_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxStringSummaryProvider, "std::string summary provider"));
 491     lldb::TypeSummaryImplSP std_wstring_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxWStringSummaryProvider, "std::wstring summary provider"));
 492
 493     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::string"),
 494                                                          std_string_summary_sp);
 495     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >"),
 496                                                          std_string_summary_sp);
 497
 498     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::wstring"),
 499                                                          std_wstring_summary_sp);
 500     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> >"),
 501                                                          std_wstring_summary_sp);
 502
 503     SyntheticChildren::Flags stl_synth_flags;
 504     stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false);
 505
 506     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator, "libc++ std::vector synthetic children", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_synth_flags, true);
 507     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator, "libc++ std::list synthetic children", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_synth_flags, true);
 508     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::map synthetic children", ConstString("^std::__1::map<.+> >(( )?&)?$"), stl_synth_flags, true);
 509     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_synth_flags);
 510     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_synth_flags);
 511     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::set synthetic children", ConstString("^std::__1::set<.+> >(( )?&)?$"), stl_synth_flags, true);
 512     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multiset synthetic children", ConstString("^std::__1::multiset<.+> >(( )?&)?$"), stl_synth_flags, true);
 513     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multimap synthetic children", ConstString("^std::__1::multimap<.+> >(( )?&)?$"), stl_synth_flags, true);
 514     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator, "libc++ std::unordered containers synthetic children", ConstString("^(std::__1::)unordered_(multi)?(map|set)<.+> >$"), stl_synth_flags, true);
 515     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator, "libc++ std::initializer_list synthetic children", ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags, true);
 516
 517     cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^(std::__1::)deque<.+>(( )?&)?$")),
 518                                                                SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
 519                                                                                                                  "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
 520
 521     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "shared_ptr synthetic children", ConstString("^(std::__1::)shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
 522     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "weak_ptr synthetic children", ConstString("^(std::__1::)weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
 523
 524     stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(false);
 525     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_synth_flags);
 526
 527     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector summary provider", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_summary_flags, true);
 528     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::list summary provider", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_summary_flags, true);
 529     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::map summary provider", ConstString("^std::__1::map<.+>(( )?&)?$"), stl_summary_flags, true);
 530     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::deque summary provider", ConstString("^std::__1::deque<.+>(( )?&)?$"), stl_summary_flags, true);
 531     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_summary_flags);
 532     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_summary_flags);
 533     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::set summary provider", ConstString("^std::__1::set<.+>(( )?&)?$"), stl_summary_flags, true);
 534     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multiset summary provider", ConstString("^std::__1::multiset<.+>(( )?&)?$"), stl_summary_flags, true);
 535     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multimap summary provider", ConstString("^std::__1::multimap<.+>(( )?&)?$"), stl_summary_flags, true);
 536     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::unordered containers summary provider", ConstString("^(std::__1::)unordered_(multi)?(map|set)<.+> >$"), stl_summary_flags, true);
 537
 538     stl_summary_flags.SetSkipPointers(true);
 539
 540     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxSmartPointerSummaryProvider, "libc++ std::shared_ptr summary provider", ConstString("^std::__1::shared_ptr<.+>(( )?&)?$"), stl_summary_flags, true);
 541     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxSmartPointerSummaryProvider, "libc++ std::weak_ptr summary provider", ConstString("^std::__1::weak_ptr<.+>(( )?&)?$"), stl_summary_flags, true);
 542
 543     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^std::__1::__wrap_iter<.+>$"), stl_synth_flags, true);
 544
 545     AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<bool, std::__1::allocator<bool> >"), stl_summary_flags);
 546     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::__1::__map_iterator<.+>$"), stl_synth_flags, true);
 547
 548     AddFilter(cpp_category_sp, {"__a_"}, "libc++ std::atomic filter", ConstString("^std::__1::atomic<.*>$"), stl_synth_flags, true);
 549 #endif
 550 }
 551
 552 static void
 553 LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp)
 554 {
 555     if (!cpp_category_sp)
 556         return;
 557
 558     TypeSummaryImpl::Flags stl_summary_flags;
 559     stl_summary_flags.SetCascades(true)
 560     .SetSkipPointers(false)
 561     .SetSkipReferences(false)
 562     .SetDontShowChildren(true)
 563     .SetDontShowValue(true)
 564     .SetShowMembersOneLiner(false)
 565     .SetHideItemNames(false);
 566
 567     lldb::TypeSummaryImplSP std_string_summary_sp(new StringSummaryFormat(stl_summary_flags,
 568                                                                           "${var._M_dataplus._M_p}"));
 569
 570     lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags,
 571                                                                                  LibStdcppStringSummaryProvider,
 572                                                                                  "libstdc++ c++11 std::string summary provider"));
 573     lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags,
 574                                                                                  LibStdcppWStringSummaryProvider,
 575                                                                                  "libstdc++ c++11 std::wstring summary provider"));
 576
 577     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"),
 578                                                       std_string_summary_sp);
 579     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char>"),
 580                                                       std_string_summary_sp);
 581     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char,std::char_traits<char>,std::allocator<char> >"),
 582                                                       std_string_summary_sp);
 583     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
 584                                                       std_string_summary_sp);
 585
 586     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::string"),
 587                                                       cxx11_string_summary_sp);
 588     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
 589                                                       cxx11_string_summary_sp);
 590
 591     // making sure we force-pick the summary for printing wstring (_M_p is a wchar_t*)
 592     lldb::TypeSummaryImplSP std_wstring_summary_sp(new StringSummaryFormat(stl_summary_flags,
 593                                                                            "${var._M_dataplus._M_p%S}"));
 594
 595     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"),
 596                                                       std_wstring_summary_sp);
 597     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t>"),
 598                                                       std_wstring_summary_sp);
 599     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >"),
 600                                                       std_wstring_summary_sp);
 601     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
 602                                                       std_wstring_summary_sp);
 603
 604     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::wstring"),
 605                                                       cxx11_wstring_summary_sp);
 606     cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
 607                                                       cxx11_wstring_summary_sp);
 608
 609 #ifndef LLDB_DISABLE_PYTHON
 610
 611     SyntheticChildren::Flags stl_synth_flags;
 612     stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false);
 613
 614     cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
 615                                                             SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
 616                                                                                                               "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
 617     cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
 618                                                             SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
 619                                                                                                               "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider")));
 620     cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$")),
 621                                                             SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
 622                                                                                                               "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
 623     stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(true);
 624     cpp_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
 625                                                            TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
 626                                                                                                      "size=${svar%#}")));
 627     cpp_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
 628                                                            TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
 629                                                                                                      "size=${svar%#}")));
 630     cpp_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$")),
 631                                                            TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
 632                                                                                                      "size=${svar%#}")));
 633
 634     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);
 635
 636     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true);
 637 #endif
 638 }
 639
 640 static void
 641 LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp)
 642 {
 643     if (!cpp_category_sp)
 644         return;
 645
 646     TypeSummaryImpl::Flags string_flags;
 647     string_flags.SetCascades(true)
 648     .SetSkipPointers(true)
 649     .SetSkipReferences(false)
 650     .SetDontShowChildren(true)
 651     .SetDontShowValue(false)
 652     .SetShowMembersOneLiner(false)
 653     .SetHideItemNames(false);
 654
 655     TypeSummaryImpl::Flags string_array_flags;
 656     string_array_flags.SetCascades(true)
 657     .SetSkipPointers(true)
 658     .SetSkipReferences(false)
 659     .SetDontShowChildren(true)
 660     .SetDontShowValue(true)
 661     .SetShowMembersOneLiner(false)
 662     .SetHideItemNames(false);
 663
 664 #ifndef LLDB_DISABLE_PYTHON
 665     // FIXME because of a bug in the FormattersContainer we need to add a summary for both X* and const X* (<rdar://problem/12717717>)
 666     AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "char16_t * summary provider", ConstString("char16_t *"), string_flags);
 667     AddCXXSummary(cpp_category_sp,
 668                   lldb_private::formatters::Char16StringSummaryProvider,
 669                   "char16_t [] summary provider",
 670                   ConstString("char16_t \\[[0-9]+\\]"),
 671                   string_array_flags,
 672                   true);
 673
 674     AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider, "char32_t * summary provider", ConstString("char32_t *"), string_flags);
 675     AddCXXSummary(cpp_category_sp,
 676                   lldb_private::formatters::Char32StringSummaryProvider,
 677                   "char32_t [] summary provider",
 678                   ConstString("char32_t \\[[0-9]+\\]"),
 679                   string_array_flags,
 680                   true);
 681
 682     AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t *"), string_flags);
 683     AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t \\[[0-9]+\\]"), string_array_flags, true);
 684
 685     AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "unichar * summary provider", ConstString("unichar *"), string_flags);
 686
 687     TypeSummaryImpl::Flags widechar_flags;
 688     widechar_flags.SetDontShowValue(true)
 689     .SetSkipPointers(true)
 690     .SetSkipReferences(false)
 691     .SetCascades(true)
 692     .SetDontShowChildren(true)
 693     .SetHideItemNames(true)
 694     .SetShowMembersOneLiner(false);
 695
 696     AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16SummaryProvider, "char16_t summary provider", ConstString("char16_t"), widechar_flags);
 697     AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char32SummaryProvider, "char32_t summary provider", ConstString("char32_t"), widechar_flags);
 698     AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider, "wchar_t summary provider", ConstString("wchar_t"), widechar_flags);
 699
 700     AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char16SummaryProvider, "unichar summary provider", ConstString("unichar"), widechar_flags);
 701 #endif
 702 }
 703
 704 lldb::TypeCategoryImplSP
 705 CPlusPlusLanguage::GetFormatters ()
 706 {
 707     static std::once_flag g_initialize;
 708     static TypeCategoryImplSP g_category;
 709
 710     std::call_once(g_initialize, [this] () -> void {
 711         DataVisualization::Categories::GetCategory(GetPluginName(), g_category);
 712         if (g_category)
 713         {
 714             LoadLibCxxFormatters(g_category);
 715             LoadLibStdcppFormatters(g_category);
 716             LoadSystemFormatters(g_category);
 717         }
 718     });
 719     return g_category;
 720 }
 721
 722 HardcodedFormatters::HardcodedSummaryFinder
 723 CPlusPlusLanguage::GetHardcodedSummaries ()
 724 {
 725     static std::once_flag g_initialize;
 726     static ConstString g_vectortypes("VectorTypes");
 727     static HardcodedFormatters::HardcodedSummaryFinder g_formatters;
 728
 729     std::call_once(g_initialize, [] () -> void {
 730         g_formatters.push_back(
 731                                         [](lldb_private::ValueObject& valobj,
 732                                            lldb::DynamicValueType,
 733                                            FormatManager&) -> TypeSummaryImpl::SharedPointer {
 734                                             static CXXFunctionSummaryFormat::SharedPointer formatter_sp(new CXXFunctionSummaryFormat(TypeSummaryImpl::Flags(), lldb_private::formatters::CXXFunctionPointerSummaryProvider, "Function pointer summary provider"));
 735                                             if (valobj.GetCompilerType().IsFunctionPointerType())
 736                                             {
 737                                                 return formatter_sp;
 738                                             }
 739                                             return nullptr;
 740                                         });
 741         g_formatters.push_back(
 742                                         [](lldb_private::ValueObject& valobj,
 743                                            lldb::DynamicValueType,
 744                                            FormatManager& fmt_mgr) -> TypeSummaryImpl::SharedPointer {
 745                                             static CXXFunctionSummaryFormat::SharedPointer formatter_sp(new CXXFunctionSummaryFormat(TypeSummaryImpl::Flags()
 746                                                                                                                                      .SetCascades(true)
 747                                                                                                                                      .SetDontShowChildren(true)
 748                                                                                                                                      .SetHideItemNames(true)
 749                                                                                                                                      .SetShowMembersOneLiner(true)
 750                                                                                                                                      .SetSkipPointers(true)
 751                                                                                                                                      .SetSkipReferences(false),
 752                                                                                                                                      lldb_private::formatters::VectorTypeSummaryProvider,
 753                                                                                                                                      "vector_type pointer summary provider"));
 754                                             if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr))
 755                                             {
 756                                                 if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
 757                                                     return formatter_sp;
 758                                             }
 759                                             return nullptr;
 760                                         });
 761     });
 762
 763     return g_formatters;
 764 }
 765
 766 HardcodedFormatters::HardcodedSyntheticFinder
 767 CPlusPlusLanguage::GetHardcodedSynthetics ()
 768 {
 769     static std::once_flag g_initialize;
 770     static ConstString g_vectortypes("VectorTypes");
 771     static HardcodedFormatters::HardcodedSyntheticFinder g_formatters;
 772
 773     std::call_once(g_initialize, [] () -> void {
 774         g_formatters.push_back(
 775                                          [](lldb_private::ValueObject& valobj,
 776                                             lldb::DynamicValueType,
 777                                             FormatManager& fmt_mgr) -> SyntheticChildren::SharedPointer {
 778                                              static CXXSyntheticChildren::SharedPointer formatter_sp(new CXXSyntheticChildren(SyntheticChildren::Flags().SetCascades(true).SetSkipPointers(true).SetSkipReferences(true).SetNonCacheable(true),
 779                                                                                                                               "vector_type synthetic children",
 780                                                                                                                               lldb_private::formatters::VectorTypeSyntheticFrontEndCreator));
 781                                              if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr))
 782                                              {
 783                                                  if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
 784                                                      return formatter_sp;
 785                                              }
 786                                              return nullptr;
 787                                          });
 788     });
 789
 790     return g_formatters;
 791 }
 792