Vendor import of lldb release_39 branch r276489:vendor/lldb/lldb-release_39-r276489

https://llvm.org/svn/llvm-project/lldb/branches/release_39@276489

1 files changed, 40 insertions, 141 deletions

diff --git a/source/Core/SearchFilter.cpp b/source/Core/SearchFilter.cpp
index f54bbe8d4adf..202a40ff414d 100644
--- a/source/Core/SearchFilter.cpp
+++ b/source/Core/SearchFilter.cpp
@@ -9,9 +9,9 @@
 
 // C Includes
 // C++ Includes
+
 // Other libraries and framework includes
 // Project includes
-
 #include "lldb/lldb-private.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/Module.h"
@@ -21,56 +21,26 @@
 using namespace lldb;
 using namespace lldb_private;
 
-//----------------------------------------------------------------------
-// SearchFilter constructor
-//----------------------------------------------------------------------
-Searcher::Searcher ()
-{
+Searcher::Searcher() = default;
 
-}
-
-Searcher::~Searcher ()
-{
-
-}
+Searcher::~Searcher() = default;
 
 void
 Searcher::GetDescription (Stream *s)
 {
 }
 
-//----------------------------------------------------------------------
-// SearchFilter constructor
-//----------------------------------------------------------------------
 SearchFilter::SearchFilter(const TargetSP &target_sp) :
     m_target_sp (target_sp)
 {
 }
 
-//----------------------------------------------------------------------
-// SearchFilter copy constructor
-//----------------------------------------------------------------------
-SearchFilter::SearchFilter(const SearchFilter& rhs) :
-    m_target_sp (rhs.m_target_sp)
-{
-}
+SearchFilter::SearchFilter(const SearchFilter& rhs) = default;
 
-//----------------------------------------------------------------------
-// SearchFilter assignment operator
-//----------------------------------------------------------------------
-const SearchFilter&
-SearchFilter::operator=(const SearchFilter& rhs)
-{
-    m_target_sp = rhs.m_target_sp;
-    return *this;
-}
+SearchFilter&
+SearchFilter::operator=(const SearchFilter& rhs) = default;
 
-//----------------------------------------------------------------------
-// Destructor
-//----------------------------------------------------------------------
-SearchFilter::~SearchFilter()
-{
-}
+SearchFilter::~SearchFilter() = default;
 
 bool
 SearchFilter::ModulePasses (const FileSpec &spec)
@@ -116,7 +86,6 @@ SearchFilter::GetDescription (Stream *s)
 void
 SearchFilter::Dump (Stream *s) const
 {
-
 }
 
 lldb::SearchFilterSP
@@ -143,7 +112,7 @@ SearchFilter::Search (Searcher &searcher)
     empty_sc.target_sp = m_target_sp;
 
     if (searcher.GetDepth() == Searcher::eDepthTarget)
-        searcher.SearchCallback (*this, empty_sc, NULL, false);
+        searcher.SearchCallback(*this, empty_sc, nullptr, false);
     else
         DoModuleIteration(empty_sc, searcher);
 }
@@ -158,10 +127,10 @@ SearchFilter::SearchInModuleList (Searcher &searcher, ModuleList &modules)
     empty_sc.target_sp = m_target_sp;
 
     if (searcher.GetDepth() == Searcher::eDepthTarget)
-        searcher.SearchCallback (*this, empty_sc, NULL, false);
+        searcher.SearchCallback(*this, empty_sc, nullptr, false);
     else
     {
-        Mutex::Locker modules_locker(modules.GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(modules.GetMutex());
         const size_t numModules = modules.GetSize();
 
         for (size_t i = 0; i < numModules; i++)
@@ -176,7 +145,6 @@ SearchFilter::SearchInModuleList (Searcher &searcher, ModuleList &modules)
     }
 }
 
-
 Searcher::CallbackReturn
 SearchFilter::DoModuleIteration (const lldb::ModuleSP& module_sp, Searcher &searcher)
 {
@@ -194,7 +162,7 @@ SearchFilter::DoModuleIteration (const SymbolContext &context, Searcher &searche
             if (searcher.GetDepth () == Searcher::eDepthModule)
             {
                 SymbolContext matchingContext(context.module_sp.get());
-                searcher.SearchCallback (*this, matchingContext, NULL, false);
+                searcher.SearchCallback(*this, matchingContext, nullptr, false);
             }
             else
             {
@@ -204,8 +172,8 @@ SearchFilter::DoModuleIteration (const SymbolContext &context, Searcher &searche
         else
         {
             const ModuleList &target_images = m_target_sp->GetImages();
-            Mutex::Locker modules_locker(target_images.GetMutex());
-            
+            std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
+
             size_t n_modules = target_images.GetSize();
             for (size_t i = 0; i < n_modules; i++)
             {
@@ -219,7 +187,7 @@ SearchFilter::DoModuleIteration (const SymbolContext &context, Searcher &searche
                 {
                     SymbolContext matchingContext(m_target_sp, module_sp);
 
-                    Searcher::CallbackReturn shouldContinue = searcher.SearchCallback (*this, matchingContext, NULL, false);
+                    Searcher::CallbackReturn shouldContinue = searcher.SearchCallback(*this, matchingContext, nullptr, false);
                     if (shouldContinue == Searcher::eCallbackReturnStop
                         || shouldContinue == Searcher::eCallbackReturnPop)
                         return shouldContinue;
@@ -242,7 +210,7 @@ Searcher::CallbackReturn
 SearchFilter::DoCUIteration (const ModuleSP &module_sp, const SymbolContext &context, Searcher &searcher)
 {
     Searcher::CallbackReturn shouldContinue;
-    if (context.comp_unit == NULL)
+    if (context.comp_unit == nullptr)
     {
         const size_t num_comp_units = module_sp->GetNumCompileUnits();
         for (size_t i = 0; i < num_comp_units; i++)
@@ -257,7 +225,7 @@ SearchFilter::DoCUIteration (const ModuleSP &module_sp, const SymbolContext &con
                 {
                     SymbolContext matchingContext(m_target_sp, module_sp, cu_sp.get());
 
-                    shouldContinue = searcher.SearchCallback (*this, matchingContext, NULL, false);
+                    shouldContinue = searcher.SearchCallback(*this, matchingContext, nullptr, false);
 
                     if (shouldContinue == Searcher::eCallbackReturnPop)
                         return Searcher::eCallbackReturnContinue;
@@ -276,7 +244,7 @@ SearchFilter::DoCUIteration (const ModuleSP &module_sp, const SymbolContext &con
         if (CompUnitPasses(*context.comp_unit))
         {
             SymbolContext matchingContext (m_target_sp, module_sp, context.comp_unit);
-            return searcher.SearchCallback (*this, matchingContext, NULL, false);
+            return searcher.SearchCallback(*this, matchingContext, nullptr, false);
         }
     }
     return Searcher::eCallbackReturnContinue;
@@ -326,30 +294,15 @@ SearchFilterForUnconstrainedSearches::DoCopyForBreakpoint (Breakpoint &breakpoin
 //  Selects a shared library matching a given file spec
 //----------------------------------------------------------------------
 
-//----------------------------------------------------------------------
-// SearchFilterByModule constructors
-//----------------------------------------------------------------------
-
 SearchFilterByModule::SearchFilterByModule (const lldb::TargetSP &target_sp, const FileSpec &module) :
     SearchFilter (target_sp),
     m_module_spec (module)
 {
 }
 
+SearchFilterByModule::SearchFilterByModule(const SearchFilterByModule& rhs) = default;
 
-//----------------------------------------------------------------------
-// SearchFilterByModule copy constructor
-//----------------------------------------------------------------------
-SearchFilterByModule::SearchFilterByModule(const SearchFilterByModule& rhs) :
-    SearchFilter (rhs),
-    m_module_spec (rhs.m_module_spec)
-{
-}
-
-//----------------------------------------------------------------------
-// SearchFilterByModule assignment operator
-//----------------------------------------------------------------------
-const SearchFilterByModule&
+SearchFilterByModule&
 SearchFilterByModule::operator=(const SearchFilterByModule& rhs)
 {
     m_target_sp = rhs.m_target_sp;
@@ -357,20 +310,12 @@ SearchFilterByModule::operator=(const SearchFilterByModule& rhs)
     return *this;
 }
 
-//----------------------------------------------------------------------
-// Destructor
-//----------------------------------------------------------------------
-SearchFilterByModule::~SearchFilterByModule()
-{
-}
+SearchFilterByModule::~SearchFilterByModule() = default;
 
 bool
 SearchFilterByModule::ModulePasses (const ModuleSP &module_sp)
 {
-    if (module_sp && FileSpec::Equal(module_sp->GetFileSpec(), m_module_spec, false))
-        return true;
-    else
-        return false;
+    return (module_sp && FileSpec::Equal(module_sp->GetFileSpec(), m_module_spec, false));
 }
 
 bool
@@ -388,7 +333,6 @@ SearchFilterByModule::AddressPasses (Address &address)
     return true;
 }
 
-
 bool
 SearchFilterByModule::CompUnitPasses (FileSpec &fileSpec)
 {
@@ -411,7 +355,7 @@ SearchFilterByModule::Search (Searcher &searcher)
     {
         SymbolContext empty_sc;
         empty_sc.target_sp = m_target_sp;
-        searcher.SearchCallback (*this, empty_sc, NULL, false);
+        searcher.SearchCallback(*this, empty_sc, nullptr, false);
     }
 
     // If the module file spec is a full path, then we can just find the one
@@ -419,8 +363,8 @@ SearchFilterByModule::Search (Searcher &searcher)
     // find the ones that match the file name.
 
     const ModuleList &target_modules = m_target_sp->GetImages();
-    Mutex::Locker modules_locker (target_modules.GetMutex());
-    
+    std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
+
     const size_t num_modules = target_modules.GetSize ();
     for (size_t i = 0; i < num_modules; i++)
     {
@@ -463,7 +407,6 @@ SearchFilterByModule::GetFilterRequiredItems()
 void
 SearchFilterByModule::Dump (Stream *s) const
 {
-
 }
 
 lldb::SearchFilterSP
@@ -478,10 +421,6 @@ SearchFilterByModule::DoCopyForBreakpoint (Breakpoint &breakpoint)
 //  Selects a shared library matching a given file spec
 //----------------------------------------------------------------------
 
-//----------------------------------------------------------------------
-// SearchFilterByModuleList constructors
-//----------------------------------------------------------------------
-
 SearchFilterByModuleList::SearchFilterByModuleList (const lldb::TargetSP &target_sp,
                                                     const FileSpecList &module_list) :
     SearchFilter (target_sp),
@@ -489,20 +428,9 @@ SearchFilterByModuleList::SearchFilterByModuleList (const lldb::TargetSP &target
 {
 }
 
+SearchFilterByModuleList::SearchFilterByModuleList(const SearchFilterByModuleList& rhs) = default;
 
-//----------------------------------------------------------------------
-// SearchFilterByModuleList copy constructor
-//----------------------------------------------------------------------
-SearchFilterByModuleList::SearchFilterByModuleList(const SearchFilterByModuleList& rhs) :
-    SearchFilter (rhs),
-    m_module_spec_list (rhs.m_module_spec_list)
-{
-}
-
-//----------------------------------------------------------------------
-// SearchFilterByModuleList assignment operator
-//----------------------------------------------------------------------
-const SearchFilterByModuleList&
+SearchFilterByModuleList&
 SearchFilterByModuleList::operator=(const SearchFilterByModuleList& rhs)
 {
     m_target_sp = rhs.m_target_sp;
@@ -510,12 +438,7 @@ SearchFilterByModuleList::operator=(const SearchFilterByModuleList& rhs)
     return *this;
 }
 
-//----------------------------------------------------------------------
-// Destructor
-//----------------------------------------------------------------------
-SearchFilterByModuleList::~SearchFilterByModuleList()
-{
-}
+SearchFilterByModuleList::~SearchFilterByModuleList() = default;
 
 bool
 SearchFilterByModuleList::ModulePasses (const ModuleSP &module_sp)
@@ -523,7 +446,8 @@ SearchFilterByModuleList::ModulePasses (const ModuleSP &module_sp)
     if (m_module_spec_list.GetSize() == 0)
         return true;
         
-    if (module_sp && m_module_spec_list.FindFileIndex(0, module_sp->GetFileSpec(), false) != UINT32_MAX)
+    if (module_sp &&
+        m_module_spec_list.FindFileIndex(0, module_sp->GetFileSpec(), false) != UINT32_MAX)
         return true;
     else
         return false;
@@ -548,7 +472,6 @@ SearchFilterByModuleList::AddressPasses (Address &address)
     return true;
 }
 
-
 bool
 SearchFilterByModuleList::CompUnitPasses (FileSpec &fileSpec)
 {
@@ -571,7 +494,7 @@ SearchFilterByModuleList::Search (Searcher &searcher)
     {
         SymbolContext empty_sc;
         empty_sc.target_sp = m_target_sp;
-        searcher.SearchCallback (*this, empty_sc, NULL, false);
+        searcher.SearchCallback(*this, empty_sc, nullptr, false);
     }
 
     // If the module file spec is a full path, then we can just find the one
@@ -579,8 +502,8 @@ SearchFilterByModuleList::Search (Searcher &searcher)
     // find the ones that match the file name.
 
     const ModuleList &target_modules = m_target_sp->GetImages();
-    Mutex::Locker modules_locker (target_modules.GetMutex());
-    
+    std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
+
     const size_t num_modules = target_modules.GetSize ();
     for (size_t i = 0; i < num_modules; i++)
     {
@@ -645,7 +568,6 @@ SearchFilterByModuleList::GetFilterRequiredItems()
 void
 SearchFilterByModuleList::Dump (Stream *s) const
 {
-
 }
 
 lldb::SearchFilterSP
@@ -655,16 +577,11 @@ SearchFilterByModuleList::DoCopyForBreakpoint (Breakpoint &breakpoint)
     return ret_sp;
 }
 
-
 //----------------------------------------------------------------------
 //  SearchFilterByModuleListAndCU:
 //  Selects a shared library matching a given file spec
 //----------------------------------------------------------------------
 
-//----------------------------------------------------------------------
-// SearchFilterByModuleListAndCU constructors
-//----------------------------------------------------------------------
-
 SearchFilterByModuleListAndCU::SearchFilterByModuleListAndCU (const lldb::TargetSP &target_sp, 
                                                               const FileSpecList &module_list,
                                                               const FileSpecList &cu_list) :
@@ -673,20 +590,9 @@ SearchFilterByModuleListAndCU::SearchFilterByModuleListAndCU (const lldb::Target
 {
 }
 
+SearchFilterByModuleListAndCU::SearchFilterByModuleListAndCU(const SearchFilterByModuleListAndCU& rhs) = default;
 
-//----------------------------------------------------------------------
-// SearchFilterByModuleListAndCU copy constructor
-//----------------------------------------------------------------------
-SearchFilterByModuleListAndCU::SearchFilterByModuleListAndCU(const SearchFilterByModuleListAndCU& rhs) :
-    SearchFilterByModuleList (rhs),
-    m_cu_spec_list (rhs.m_cu_spec_list)
-{
-}
-
-//----------------------------------------------------------------------
-// SearchFilterByModuleListAndCU assignment operator
-//----------------------------------------------------------------------
-const SearchFilterByModuleListAndCU&
+SearchFilterByModuleListAndCU&
 SearchFilterByModuleListAndCU::operator=(const SearchFilterByModuleListAndCU& rhs)
 {
     if (&rhs != this)
@@ -698,12 +604,7 @@ SearchFilterByModuleListAndCU::operator=(const SearchFilterByModuleListAndCU& rh
     return *this;
 }
 
-//----------------------------------------------------------------------
-// Destructor
-//----------------------------------------------------------------------
-SearchFilterByModuleListAndCU::~SearchFilterByModuleListAndCU()
-{
-}
+SearchFilterByModuleListAndCU::~SearchFilterByModuleListAndCU() = default;
 
 bool
 SearchFilterByModuleListAndCU::AddressPasses (Address &address)
@@ -711,7 +612,6 @@ SearchFilterByModuleListAndCU::AddressPasses (Address &address)
     return true;
 }
 
-
 bool
 SearchFilterByModuleListAndCU::CompUnitPasses (FileSpec &fileSpec)
 {
@@ -747,7 +647,7 @@ SearchFilterByModuleListAndCU::Search (Searcher &searcher)
     {
         SymbolContext empty_sc;
         empty_sc.target_sp = m_target_sp;
-        searcher.SearchCallback (*this, empty_sc, NULL, false);
+        searcher.SearchCallback(*this, empty_sc, nullptr, false);
     }
 
     // If the module file spec is a full path, then we can just find the one
@@ -756,14 +656,15 @@ SearchFilterByModuleListAndCU::Search (Searcher &searcher)
 
     ModuleList matching_modules;
     const ModuleList &target_images = m_target_sp->GetImages();
-    Mutex::Locker modules_locker(target_images.GetMutex());
-    
+    std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
+
     const size_t num_modules = target_images.GetSize ();
     bool no_modules_in_filter = m_module_spec_list.GetSize() == 0;
     for (size_t i = 0; i < num_modules; i++)
     {
         lldb::ModuleSP module_sp = target_images.GetModuleAtIndexUnlocked(i);
-        if (no_modules_in_filter || m_module_spec_list.FindFileIndex(0, module_sp->GetFileSpec(), false) != UINT32_MAX)
+        if (no_modules_in_filter ||
+            m_module_spec_list.FindFileIndex(0, module_sp->GetFileSpec(), false) != UINT32_MAX)
         {
             SymbolContext matchingContext(m_target_sp, module_sp);
             Searcher::CallbackReturn shouldContinue;
@@ -844,7 +745,6 @@ SearchFilterByModuleListAndCU::GetFilterRequiredItems()
 void
 SearchFilterByModuleListAndCU::Dump (Stream *s) const
 {
-
 }
 
 lldb::SearchFilterSP
@@ -853,4 +753,3 @@ SearchFilterByModuleListAndCU::DoCopyForBreakpoint (Breakpoint &breakpoint)
     SearchFilterSP ret_sp(new SearchFilterByModuleListAndCU(*this));
     return ret_sp;
 }
-