Index: lldb/include/lldb/Breakpoint/BreakpointResolverName.h =================================================================== --- lldb/include/lldb/Breakpoint/BreakpointResolverName.h +++ lldb/include/lldb/Breakpoint/BreakpointResolverName.h @@ -44,7 +44,7 @@ // Creates a function breakpoint by regular expression. Takes over control // of the lifespan of func_regex. - BreakpointResolverName(Breakpoint *bkpt, RegularExpression func_regex, + BreakpointResolverName(Breakpoint *bkpt, RegularExpression &&func_regex, lldb::LanguageType language, lldb::addr_t offset, bool skip_prologue); Index: lldb/include/lldb/DataFormatters/FormattersContainer.h =================================================================== --- lldb/include/lldb/DataFormatters/FormattersContainer.h +++ lldb/include/lldb/DataFormatters/FormattersContainer.h @@ -67,19 +67,19 @@ typedef typename ValueType::SharedPointer ValueSP; typedef std::map MapType; typedef typename MapType::iterator MapIterator; - typedef std::function ForEachCallback; + typedef std::function ForEachCallback; FormatMap(IFormatChangeListener *lst) : m_map(), m_map_mutex(), listener(lst) {} - void Add(KeyType name, const ValueSP &entry) { + void Add(KeyType &&name, const ValueSP &entry) { if (listener) entry->GetRevision() = listener->GetCurrentRevision(); else entry->GetRevision() = 0; std::lock_guard guard(m_map_mutex); - m_map[name] = entry; + m_map[std::move(name)] = entry; if (listener) listener->Changed(); } @@ -116,7 +116,7 @@ std::lock_guard guard(m_map_mutex); MapIterator pos, end = m_map.end(); for (pos = m_map.begin(); pos != end; pos++) { - KeyType type = pos->first; + const KeyType &type = pos->first; if (!callback(type, pos->second)) break; } @@ -138,7 +138,7 @@ return iter->second; } - KeyType GetKeyAtIndex(size_t index) { + const KeyType *GetKeyAtIndex(size_t index) { std::lock_guard guard(m_map_mutex); MapIterator iter = m_map.begin(); MapIterator end = m_map.end(); @@ -146,9 +146,9 @@ iter++; index--; if (end == iter) - return KeyType(); + return nullptr; } - return iter->first; + return &iter->first; } protected: @@ -182,8 +182,8 @@ FormattersContainer(std::string name, IFormatChangeListener *lst) : m_format_map(lst), m_name(name) {} - void Add(const MapKeyType &type, const MapValueType &entry) { - Add_Impl(type, entry, static_cast(nullptr)); + void Add(MapKeyType &&type, const MapValueType &entry) { + Add_Impl(std::move(type), entry, static_cast(nullptr)); } bool Delete(ConstString type) { @@ -233,9 +233,9 @@ DISALLOW_COPY_AND_ASSIGN(FormattersContainer); - void Add_Impl(const MapKeyType &type, const MapValueType &entry, - lldb::RegularExpressionSP *dummy) { - m_format_map.Add(type, entry); + void Add_Impl(MapKeyType &&type, const MapValueType &entry, + RegularExpression *dummy) { + m_format_map.Add(std::move(type), entry); } void Add_Impl(ConstString type, const MapValueType &entry, @@ -247,12 +247,12 @@ return m_format_map.Delete(type); } - bool Delete_Impl(ConstString type, lldb::RegularExpressionSP *dummy) { + bool Delete_Impl(ConstString type, RegularExpression *dummy) { std::lock_guard guard(m_format_map.mutex()); MapIterator pos, end = m_format_map.map().end(); for (pos = m_format_map.map().begin(); pos != end; pos++) { - lldb::RegularExpressionSP regex = pos->first; - if (type.GetStringRef() == regex->GetText()) { + const RegularExpression ®ex = pos->first; + if (type.GetStringRef() == regex.GetText()) { m_format_map.map().erase(pos); if (m_format_map.listener) m_format_map.listener->Changed(); @@ -273,32 +273,31 @@ lldb::TypeNameSpecifierImplSP GetTypeNameSpecifierAtIndex_Impl(size_t index, ConstString *dummy) { - ConstString key = m_format_map.GetKeyAtIndex(index); + const ConstString *key = m_format_map.GetKeyAtIndex(index); if (key) return lldb::TypeNameSpecifierImplSP( - new TypeNameSpecifierImpl(key.AsCString(), false)); + new TypeNameSpecifierImpl(key->AsCString(), false)); else return lldb::TypeNameSpecifierImplSP(); } lldb::TypeNameSpecifierImplSP - GetTypeNameSpecifierAtIndex_Impl(size_t index, - lldb::RegularExpressionSP *dummy) { - lldb::RegularExpressionSP regex = m_format_map.GetKeyAtIndex(index); - if (regex.get() == nullptr) + GetTypeNameSpecifierAtIndex_Impl(size_t index, RegularExpression *dummy) { + const RegularExpression *regex = m_format_map.GetKeyAtIndex(index); + if (!regex) return lldb::TypeNameSpecifierImplSP(); return lldb::TypeNameSpecifierImplSP( new TypeNameSpecifierImpl(regex->GetText().str().c_str(), true)); } bool Get_Impl(ConstString key, MapValueType &value, - lldb::RegularExpressionSP *dummy) { + RegularExpression *dummy) { llvm::StringRef key_str = key.GetStringRef(); std::lock_guard guard(m_format_map.mutex()); MapIterator pos, end = m_format_map.map().end(); for (pos = m_format_map.map().begin(); pos != end; pos++) { - lldb::RegularExpressionSP regex = pos->first; - if (regex->Execute(key_str)) { + const RegularExpression ®ex = pos->first; + if (regex.Execute(key_str)) { value = pos->second; return true; } @@ -307,12 +306,12 @@ } bool GetExact_Impl(ConstString key, MapValueType &value, - lldb::RegularExpressionSP *dummy) { + RegularExpression *dummy) { std::lock_guard guard(m_format_map.mutex()); MapIterator pos, end = m_format_map.map().end(); for (pos = m_format_map.map().begin(); pos != end; pos++) { - lldb::RegularExpressionSP regex = pos->first; - if (regex->GetText() == key.GetStringRef()) { + const RegularExpression ®ex = pos->first; + if (regex.GetText() == key.GetStringRef()) { value = pos->second; return true; } Index: lldb/include/lldb/DataFormatters/TypeCategory.h =================================================================== --- lldb/include/lldb/DataFormatters/TypeCategory.h +++ lldb/include/lldb/DataFormatters/TypeCategory.h @@ -26,7 +26,7 @@ template class FormatterContainerPair { public: typedef FormattersContainer ExactMatchContainer; - typedef FormattersContainer + typedef FormattersContainer RegexMatchContainer; typedef typename ExactMatchContainer::MapType ExactMatchMap; Index: lldb/include/lldb/Target/Target.h =================================================================== --- lldb/include/lldb/Target/Target.h +++ lldb/include/lldb/Target/Target.h @@ -598,7 +598,7 @@ const FileSpecList *containingModules, const FileSpecList *source_file_list, const std::unordered_set &function_names, - RegularExpression &source_regex, bool internal, bool request_hardware, + RegularExpression &&source_regex, bool internal, bool request_hardware, LazyBool move_to_nearest_code); // Use this to create a breakpoint from a load address @@ -621,9 +621,9 @@ // target setting, else we use the values passed in lldb::BreakpointSP CreateFuncRegexBreakpoint( const FileSpecList *containingModules, - const FileSpecList *containingSourceFiles, RegularExpression &func_regexp, - lldb::LanguageType requested_language, LazyBool skip_prologue, - bool internal, bool request_hardware); + const FileSpecList *containingSourceFiles, + RegularExpression &&func_regexp, lldb::LanguageType requested_language, + LazyBool skip_prologue, bool internal, bool request_hardware); // Use this to create a function breakpoint by name in containingModule, or // all modules if it is nullptr When "skip_prologue is set to Index: lldb/source/API/SBTarget.cpp =================================================================== --- lldb/source/API/SBTarget.cpp +++ lldb/source/API/SBTarget.cpp @@ -960,8 +960,8 @@ const LazyBool skip_prologue = eLazyBoolCalculate; sb_bp = target_sp->CreateFuncRegexBreakpoint( - module_list.get(), comp_unit_list.get(), regexp, symbol_language, - skip_prologue, internal, hardware); + module_list.get(), comp_unit_list.get(), std::move(regexp), + symbol_language, skip_prologue, internal, hardware); } return LLDB_RECORD_RESULT(sb_bp); @@ -1061,8 +1061,8 @@ } sb_bp = target_sp->CreateSourceRegexBreakpoint( - module_list.get(), source_file_list.get(), func_names_set, regexp, - false, hardware, move_to_nearest_code); + module_list.get(), source_file_list.get(), func_names_set, + std::move(regexp), false, hardware, move_to_nearest_code); } return LLDB_RECORD_RESULT(sb_bp); Index: lldb/source/API/SBTypeCategory.cpp =================================================================== --- lldb/source/API/SBTypeCategory.cpp +++ lldb/source/API/SBTypeCategory.cpp @@ -364,8 +364,8 @@ if (type_name.IsRegex()) m_opaque_sp->GetRegexTypeFormatsContainer()->Add( - lldb::RegularExpressionSP(new RegularExpression( - llvm::StringRef::withNullAsEmpty(type_name.GetName()))), + RegularExpression( + llvm::StringRef::withNullAsEmpty(type_name.GetName())), format.GetSP()); else m_opaque_sp->GetTypeFormatsContainer()->Add( @@ -443,8 +443,8 @@ if (type_name.IsRegex()) m_opaque_sp->GetRegexTypeSummariesContainer()->Add( - lldb::RegularExpressionSP(new RegularExpression( - llvm::StringRef::withNullAsEmpty(type_name.GetName()))), + RegularExpression( + llvm::StringRef::withNullAsEmpty(type_name.GetName())), summary.GetSP()); else m_opaque_sp->GetTypeSummariesContainer()->Add( @@ -488,8 +488,8 @@ if (type_name.IsRegex()) m_opaque_sp->GetRegexTypeFiltersContainer()->Add( - lldb::RegularExpressionSP(new RegularExpression( - llvm::StringRef::withNullAsEmpty(type_name.GetName()))), + RegularExpression( + llvm::StringRef::withNullAsEmpty(type_name.GetName())), filter.GetSP()); else m_opaque_sp->GetTypeFiltersContainer()->Add( @@ -567,8 +567,8 @@ if (type_name.IsRegex()) m_opaque_sp->GetRegexTypeSyntheticsContainer()->Add( - lldb::RegularExpressionSP(new RegularExpression( - llvm::StringRef::withNullAsEmpty(type_name.GetName()))), + RegularExpression( + llvm::StringRef::withNullAsEmpty(type_name.GetName())), synth.GetSP()); else m_opaque_sp->GetTypeSyntheticsContainer()->Add( Index: lldb/source/Breakpoint/BreakpointResolverName.cpp =================================================================== --- lldb/source/Breakpoint/BreakpointResolverName.cpp +++ lldb/source/Breakpoint/BreakpointResolverName.cpp @@ -71,7 +71,7 @@ } BreakpointResolverName::BreakpointResolverName(Breakpoint *bkpt, - RegularExpression func_regex, + RegularExpression &&func_regex, lldb::LanguageType language, lldb::addr_t offset, bool skip_prologue) @@ -126,9 +126,8 @@ success = options_dict.GetValueForKeyAsString( GetKey(OptionNames::RegexString), regex_text); if (success) { - RegularExpression regex(regex_text); - return new BreakpointResolverName(bkpt, regex, language, offset, - skip_prologue); + return new BreakpointResolverName(bkpt, RegularExpression(regex_text), + language, offset, skip_prologue); } else { StructuredData::Array *names_array; success = options_dict.GetValueForKeyAsArray( Index: lldb/source/Commands/CommandObjectBreakpoint.cpp =================================================================== --- lldb/source/Commands/CommandObjectBreakpoint.cpp +++ lldb/source/Commands/CommandObjectBreakpoint.cpp @@ -690,13 +690,10 @@ return false; } - bp_sp = target->CreateFuncRegexBreakpoint(&(m_options.m_modules), - &(m_options.m_filenames), - regexp, - m_options.m_language, - m_options.m_skip_prologue, - internal, - m_options.m_hardware); + bp_sp = target->CreateFuncRegexBreakpoint( + &(m_options.m_modules), &(m_options.m_filenames), std::move(regexp), + m_options.m_language, m_options.m_skip_prologue, internal, + m_options.m_hardware); } break; case eSetTypeSourceRegexp: // Breakpoint by regexp on source text. @@ -723,15 +720,10 @@ result.SetStatus(eReturnStatusFailed); return false; } - bp_sp = - target->CreateSourceRegexBreakpoint(&(m_options.m_modules), - &(m_options.m_filenames), - m_options - .m_source_regex_func_names, - regexp, - internal, - m_options.m_hardware, - m_options.m_move_to_nearest_code); + bp_sp = target->CreateSourceRegexBreakpoint( + &(m_options.m_modules), &(m_options.m_filenames), + m_options.m_source_regex_func_names, std::move(regexp), internal, + m_options.m_hardware, m_options.m_move_to_nearest_code); } break; case eSetTypeException: { Status precond_error; Index: lldb/source/Commands/CommandObjectType.cpp =================================================================== --- lldb/source/Commands/CommandObjectType.cpp +++ lldb/source/Commands/CommandObjectType.cpp @@ -692,17 +692,18 @@ ConstString typeCS(arg_entry.ref); if (m_command_options.m_regex) { - RegularExpressionSP typeRX(new RegularExpression(arg_entry.ref)); - if (!typeRX->IsValid()) { + RegularExpression typeRX(arg_entry.ref); + if (!typeRX.IsValid()) { result.AppendError( "regex format error (maybe this is not really a regex?)"); result.SetStatus(eReturnStatusFailed); return false; } category_sp->GetRegexTypeSummariesContainer()->Delete(typeCS); - category_sp->GetRegexTypeFormatsContainer()->Add(typeRX, entry); + category_sp->GetRegexTypeFormatsContainer()->Add(std::move(typeRX), + entry); } else - category_sp->GetTypeFormatsContainer()->Add(typeCS, entry); + category_sp->GetTypeFormatsContainer()->Add(std::move(typeCS), entry); } result.SetStatus(eReturnStatusSuccessFinishNoResult); @@ -1100,13 +1101,13 @@ foreach .SetWithRegex([&result, &formatter_regex, &any_printed]( - RegularExpressionSP regex_sp, + const RegularExpression ®ex, const FormatterSharedPointer &format_sp) -> bool { if (formatter_regex) { bool escape = true; - if (regex_sp->GetText() == formatter_regex->GetText()) { + if (regex.GetText() == formatter_regex->GetText()) { escape = false; - } else if (formatter_regex->Execute(regex_sp->GetText())) { + } else if (formatter_regex->Execute(regex.GetText())) { escape = false; } @@ -1116,7 +1117,7 @@ any_printed = true; result.GetOutputStream().Printf("%s: %s\n", - regex_sp->GetText().str().c_str(), + regex.GetText().str().c_str(), format_sp->GetDescription().c_str()); return true; }); @@ -1631,8 +1632,8 @@ } if (type == eRegexSummary) { - RegularExpressionSP typeRX(new RegularExpression(type_name.GetStringRef())); - if (!typeRX->IsValid()) { + RegularExpression typeRX(type_name.GetStringRef()); + if (!typeRX.IsValid()) { if (error) error->SetErrorString( "regex format error (maybe this is not really a regex?)"); @@ -1640,7 +1641,7 @@ } category->GetRegexTypeSummariesContainer()->Delete(type_name); - category->GetRegexTypeSummariesContainer()->Add(typeRX, entry); + category->GetRegexTypeSummariesContainer()->Add(std::move(typeRX), entry); return true; } else if (type == eNamedSummary) { @@ -1648,7 +1649,7 @@ DataVisualization::NamedSummaryFormats::Add(type_name, entry); return true; } else { - category->GetTypeSummariesContainer()->Add(type_name, entry); + category->GetTypeSummariesContainer()->Add(std::move(type_name), entry); return true; } } @@ -2371,8 +2372,8 @@ } if (type == eRegexSynth) { - RegularExpressionSP typeRX(new RegularExpression(type_name.GetStringRef())); - if (!typeRX->IsValid()) { + RegularExpression typeRX(type_name.GetStringRef()); + if (!typeRX.IsValid()) { if (error) error->SetErrorString( "regex format error (maybe this is not really a regex?)"); @@ -2380,11 +2381,11 @@ } category->GetRegexTypeSyntheticsContainer()->Delete(type_name); - category->GetRegexTypeSyntheticsContainer()->Add(typeRX, entry); + category->GetRegexTypeSyntheticsContainer()->Add(std::move(typeRX), entry); return true; } else { - category->GetTypeSyntheticsContainer()->Add(type_name, entry); + category->GetTypeSyntheticsContainer()->Add(std::move(type_name), entry); return true; } } @@ -2499,8 +2500,8 @@ } if (type == eRegexFilter) { - RegularExpressionSP typeRX(new RegularExpression(type_name.GetStringRef())); - if (!typeRX->IsValid()) { + RegularExpression typeRX(type_name.GetStringRef()); + if (!typeRX.IsValid()) { if (error) error->SetErrorString( "regex format error (maybe this is not really a regex?)"); @@ -2508,11 +2509,11 @@ } category->GetRegexTypeFiltersContainer()->Delete(type_name); - category->GetRegexTypeFiltersContainer()->Add(typeRX, entry); + category->GetRegexTypeFiltersContainer()->Add(std::move(typeRX), entry); return true; } else { - category->GetTypeFiltersContainer()->Add(type_name, entry); + category->GetTypeFiltersContainer()->Add(std::move(type_name), entry); return true; } } Index: lldb/source/DataFormatters/FormatManager.cpp =================================================================== --- lldb/source/DataFormatters/FormatManager.cpp +++ lldb/source/DataFormatters/FormatManager.cpp @@ -946,10 +946,10 @@ lldb::TypeSummaryImplSP string_array_format( new StringSummaryFormat(string_array_flags, "${var%s}")); - lldb::RegularExpressionSP any_size_char_arr( - new RegularExpression(llvm::StringRef("char \\[[0-9]+\\]"))); - lldb::RegularExpressionSP any_size_wchar_arr( - new RegularExpression(llvm::StringRef("wchar_t \\[[0-9]+\\]"))); + RegularExpression any_size_char_arr(llvm::StringRef("char \\[[0-9]+\\]")); +#if 0 // FIXME: unused: + RegularExpression any_size_wchar_arr(llvm::StringRef("wchar_t \\[[0-9]+\\]")); +#endif TypeCategoryImpl::SharedPointer sys_category_sp = GetCategory(m_system_category_name); @@ -958,8 +958,8 @@ string_format); sys_category_sp->GetTypeSummariesContainer()->Add( ConstString("unsigned char *"), string_format); - sys_category_sp->GetRegexTypeSummariesContainer()->Add(any_size_char_arr, - string_array_format); + sys_category_sp->GetRegexTypeSummariesContainer()->Add( + std::move(any_size_char_arr), string_array_format); lldb::TypeSummaryImplSP ostype_summary( new StringSummaryFormat(TypeSummaryImpl::Flags() Index: lldb/source/DataFormatters/FormattersHelpers.cpp =================================================================== --- lldb/source/DataFormatters/FormattersHelpers.cpp +++ lldb/source/DataFormatters/FormattersHelpers.cpp @@ -29,10 +29,10 @@ if (regex) category_sp->GetRegexTypeFormatsContainer()->Add( - RegularExpressionSP(new RegularExpression(type_name.GetStringRef())), - format_sp); + RegularExpression(type_name.GetStringRef()), format_sp); else - category_sp->GetTypeFormatsContainer()->Add(type_name, format_sp); + category_sp->GetTypeFormatsContainer()->Add(std::move(type_name), + format_sp); } void lldb_private::formatters::AddSummary( @@ -40,10 +40,10 @@ ConstString type_name, bool regex) { if (regex) category_sp->GetRegexTypeSummariesContainer()->Add( - RegularExpressionSP(new RegularExpression(type_name.GetStringRef())), - summary_sp); + RegularExpression(type_name.GetStringRef()), summary_sp); else - category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp); + category_sp->GetTypeSummariesContainer()->Add(std::move(type_name), + summary_sp); } void lldb_private::formatters::AddStringSummary( @@ -53,10 +53,10 @@ if (regex) category_sp->GetRegexTypeSummariesContainer()->Add( - RegularExpressionSP(new RegularExpression(type_name.GetStringRef())), - summary_sp); + RegularExpression(type_name.GetStringRef()), summary_sp); else - category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp); + category_sp->GetTypeSummariesContainer()->Add(std::move(type_name), + summary_sp); } void lldb_private::formatters::AddOneLineSummary( @@ -67,10 +67,10 @@ if (regex) category_sp->GetRegexTypeSummariesContainer()->Add( - RegularExpressionSP(new RegularExpression(type_name.GetStringRef())), - summary_sp); + RegularExpression(type_name.GetStringRef()), summary_sp); else - category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp); + category_sp->GetTypeSummariesContainer()->Add(std::move(type_name), + summary_sp); } void lldb_private::formatters::AddCXXSummary( @@ -81,10 +81,10 @@ new CXXFunctionSummaryFormat(flags, funct, description)); if (regex) category_sp->GetRegexTypeSummariesContainer()->Add( - RegularExpressionSP(new RegularExpression(type_name.GetStringRef())), - summary_sp); + RegularExpression(type_name.GetStringRef()), summary_sp); else - category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp); + category_sp->GetTypeSummariesContainer()->Add(std::move(type_name), + summary_sp); } void lldb_private::formatters::AddCXXSynthetic( @@ -96,10 +96,10 @@ new CXXSyntheticChildren(flags, description, generator)); if (regex) category_sp->GetRegexTypeSyntheticsContainer()->Add( - RegularExpressionSP(new RegularExpression(type_name.GetStringRef())), - synth_sp); + RegularExpression(type_name.GetStringRef()), synth_sp); else - category_sp->GetTypeSyntheticsContainer()->Add(type_name, synth_sp); + category_sp->GetTypeSyntheticsContainer()->Add(std::move(type_name), + synth_sp); } void lldb_private::formatters::AddFilter( @@ -111,10 +111,10 @@ filter_sp->AddExpressionPath(child); if (regex) category_sp->GetRegexTypeFiltersContainer()->Add( - RegularExpressionSP(new RegularExpression(type_name.GetStringRef())), - filter_sp); + RegularExpression(type_name.GetStringRef()), filter_sp); else - category_sp->GetTypeFiltersContainer()->Add(type_name, filter_sp); + category_sp->GetTypeFiltersContainer()->Add(std::move(type_name), + filter_sp); } size_t lldb_private::formatters::ExtractIndexFromString(const char *item_name) { Index: lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp =================================================================== --- lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp +++ lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp @@ -547,8 +547,8 @@ ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_synth_flags, true); cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( - RegularExpressionSP(new RegularExpression( - llvm::StringRef("^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$"))), + RegularExpression( + llvm::StringRef("^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$")), SyntheticChildrenSP(new ScriptedSyntheticChildren( stl_synth_flags, "lldb.formatters.cpp.libcxx.stddeque_SynthProvider"))); @@ -744,38 +744,32 @@ false); cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( - RegularExpressionSP( - new RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$"))), + RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$")), SyntheticChildrenSP(new ScriptedSyntheticChildren( stl_synth_flags, "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider"))); cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( - RegularExpressionSP( - new RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$"))), + RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$")), SyntheticChildrenSP(new ScriptedSyntheticChildren( stl_synth_flags, "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider"))); cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add( - RegularExpressionSP(new RegularExpression( - llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$"))), + RegularExpression(llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$")), SyntheticChildrenSP(new ScriptedSyntheticChildren( stl_synth_flags, "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider"))); stl_summary_flags.SetDontShowChildren(false); stl_summary_flags.SetSkipPointers(true); cpp_category_sp->GetRegexTypeSummariesContainer()->Add( - RegularExpressionSP( - new RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$"))), + RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$")), TypeSummaryImplSP( new StringSummaryFormat(stl_summary_flags, "size=${svar%#}"))); cpp_category_sp->GetRegexTypeSummariesContainer()->Add( - RegularExpressionSP( - new RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$"))), + RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$")), TypeSummaryImplSP( new StringSummaryFormat(stl_summary_flags, "size=${svar%#}"))); cpp_category_sp->GetRegexTypeSummariesContainer()->Add( - RegularExpressionSP(new RegularExpression( - llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$"))), + RegularExpression(llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$")), TypeSummaryImplSP( new StringSummaryFormat(stl_summary_flags, "size=${svar%#}"))); Index: lldb/source/Target/Target.cpp =================================================================== --- lldb/source/Target/Target.cpp +++ lldb/source/Target/Target.cpp @@ -307,14 +307,14 @@ const FileSpecList *containingModules, const FileSpecList *source_file_spec_list, const std::unordered_set &function_names, - RegularExpression &source_regex, bool internal, bool hardware, + RegularExpression &&source_regex, bool internal, bool hardware, LazyBool move_to_nearest_code) { SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList( containingModules, source_file_spec_list)); if (move_to_nearest_code == eLazyBoolCalculate) move_to_nearest_code = GetMoveToNearestCode() ? eLazyBoolYes : eLazyBoolNo; BreakpointResolverSP resolver_sp(new BreakpointResolverFileRegex( - nullptr, source_regex, function_names, + nullptr, std::move(source_regex), function_names, !static_cast(move_to_nearest_code))); return CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true); @@ -549,7 +549,7 @@ BreakpointSP Target::CreateFuncRegexBreakpoint( const FileSpecList *containingModules, - const FileSpecList *containingSourceFiles, RegularExpression &func_regex, + const FileSpecList *containingSourceFiles, RegularExpression &&func_regex, lldb::LanguageType requested_language, LazyBool skip_prologue, bool internal, bool hardware) { SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList( @@ -558,7 +558,7 @@ ? GetSkipPrologue() : static_cast(skip_prologue); BreakpointResolverSP resolver_sp(new BreakpointResolverName( - nullptr, func_regex, requested_language, 0, skip)); + nullptr, std::move(func_regex), requested_language, 0, skip)); return CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true); }