2/2: Fix `TestDataFormatterStdList` regression

[jankratochvil]

Summary

Since D66174 I see failures of TestDataFormatterStdList in about 50% of runs on Fedora 30 x86_64 libstdc++.
I have found out that LLDB internally expects these RegularExpressions to be matched in their alphabetical order:

^std::(__cxx11::)?list<.+>(( )?&)?$
^std::__[[:alnum:]]+::list<.+>(( )?&)?$

But since D66174 they are sometimes matched in reverse order. A simple ugly workaround is to just sort it for ite ration. The overlapping matches one can see by another debug patch on top of it.
In fact it was only some luck it worked before as there is internally std::map<lldb::RegularExpressionSP, FormatterImpl> (FormattersContainer).

[jankratochvil]

From IRC:
In fact the whole patch is a oneliner (+operator< for RegularExpression.h):

-  typedef FormattersContainer<lldb::RegularExpressionSP, FormatterImpl> RegexMatchContainer;
+  typedef FormattersContainer<RegularExpression, FormatterImpl> RegexMatchContainer;

The rest of the patch is just a mechanical update to make it compile again.

It was my mistake when trying to fix the TestDataFormatterStdList regression that it looked to me the new RegularExpression must be broken (its lifetime). In the end it was not broken. But along the way I have removed its IMO-excessive Compile() method as I am trying to push this API change as a cleanup in D66392. If there is disagreement I will rework this patch D66398 to use the former RegularExpression API using Compile(). If there is disagreement even with that I can drop it all and just make a new comparison function for lldb::RegularExpressionSP.

I find the change from std::shared_ptr to rvalues is a nice cleanup+optimization anyway. I do not like much std::shared_ptr myself as due to its lock instructions it kills performance of manycore machines.

[labath]

I very much support getting rid of shared pointers, and for this is I am inclined to accept this. However, I don't think it was ever really intended to use the sorting order of the regex text as a disambiguating criterion for data formatters, and I don't think we should make a feature of it now -- it's just too weird and I doubt anybody will expect that.

Since it seems that there is a need for disambiguation (libc++ can be configured to have any name for the inline namespace, so there's no way to make its regex not match the libstdc++ one), I think we should just use the registration order to disambiguate. Then we just need to make sure the libstdc++ formatter is registered before the libc++ one, which should be both easy to achieve and understandable.

Since you've recently touched this code, how hard do you think it would be to exchange the std::map in FormattersContainer for a std::vector? Would you be willing to give that a try?

[JDevlieghere]

lldb/source/DataFormatters/FormatManager.cpp

950

I'd just remove this

[jankratochvil]

In D66398#1635344, @labath wrote:

Since it seems that there is a need for disambiguation (libc++ can be configured to have any name for the inline namespace, so there's no way to make its regex not match the libstdc++ one),

This is regression from D57466. If you configure libc++ to have the same name ("__cxx11") as libstdc++ then LLDB really cannot recognize it is libc++ behind.

I think we should just use the registration order to disambiguate. Then we just need to make sure the libstdc++ formatter is registered before the libc++ one, which should be both easy to achieve and understandable.

Since you've recently touched this code, how hard do you think it would be to exchange the std::map in FormattersContainer for a std::vector? Would you be willing to give that a try?

From IRC:
That std::vector there is not easy. First some methods were already using .find() on it so I had to change them to iterate through that vector.
Also some iterating in FormattersContainer (Delete_Impl, GetExact_Impl) were now iterating for comparison despite they could use .find() so by moving to std::vector we lose this improvement possibility.
labath: if replace that by a single entry then the nondeterminism goes away
labath: std::.*::list -> { if (inline_namespace == "__cxx11") return "libstdc++ formatter" else return "libc++ formatter" }

I have somehow find that dispatching implemented C++ not so simple, why not just to remove the ambiguity from the regexes?

[jankratochvil]

It just makes now the regexes unambiguous.

[labath]

In D66398#1640840, @jankratochvil wrote:

It just makes now the regexes unambiguous.

I think this is fine too, but I would also only consider it a stop-gap, because these kinds of regular are horrid.

What was the problem with the dispatching solution? If it is hard to programatically access the inline namespace name (though I expect you should at least be able to to something like type.GetName().startswith("std::__cxx11"), then we can dispatch based on some other property. The presence of some member variable for instance? This would technically be even more correct as it would also work in the case when someone sadistically configures libc++ to use the __cxx11 namespace. And since the formatters need have knowledge of the member variables then I think dispatching based on them is fair game too...

lldb/include/lldb/DataFormatters/FormattersContainer.h

298–315

Let's make a separate patch for this. I think it would be better to print this error through proper channels, but that might require some plumbing.

[jankratochvil]

In D66398#1640871, @labath wrote:

because these kinds of regular are horrid.

Yes, they are. So let's link with PCRE (BSD licensed).

What was the problem with the dispatching solution?

I do not find it so easy as libc++ formatter is using static function LibcxxStdListSyntheticFrontEndCreator while libstdc++ is using new object instance ScriptedSyntheticChildren. The dispatching should be in LibcxxStdListSyntheticFrontEndCreator so should it store new ScriptedSyntheticChildren as a static variable?

And then I do not like that solution anyway. Currently the dispatching is based on type name strings so why not to just do that? KISS

we can dispatch based on some other property. The presence of some member variable for instance?

So let's drop the type name completely and make the matching duck typed. Why to divert from how it is currently done?

Anyway sure feel free to rewrite it but the regression is fixed now.

[jankratochvil]

"jankratochvil added a reverting change" - that is not true, Differential got somehow confused by the commit text there talking about this patch.

[labath]

In D66398#1677414, @jankratochvil wrote:

"jankratochvil added a reverting change" - that is not true, Differential got somehow confused by the commit text there talking about this patch.

Good to know, but assuming that the above patch sticks, the plan *is* to revert this, right?

[jankratochvil]

In D66398#1679071, @labath wrote:

Good to know, but assuming that the above patch sticks, the plan *is* to revert this, right?

D66654 is already checked-in, I have considered it as done as is. If you want to revert this patch then:

• One needs to reverse the registration order as a simple revert fails for TestDataFormatterStdList.py
• One should put a big fat warning there.

Should I do that?

lldb/include/lldb/Breakpoint/BreakpointResolverName.h

public:
   // This one takes a C++ array of names.  It is always MatchType = Exact.
   BreakpointResolverName(Breakpoint *bkpt, std::vector<std::string> names,
                          lldb::FunctionNameType name_type_mask,
                          lldb::LanguageType language, lldb::addr_t offset,
                          bool skip_prologue);
 
   // 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);
 
   static BreakpointResolver *
   CreateFromStructuredData(Breakpoint *bkpt,
                            const StructuredData::Dictionary &data_dict,
                            Status &error);
 

lldb/include/lldb/DataFormatters/FormattersContainer.h

 
 template <typename KeyType, typename ValueType> class FormattersContainer;
 
 template <typename KeyType, typename ValueType> class FormatMap {
 public:
   typedef typename ValueType::SharedPointer ValueSP;
   typedef std::map<KeyType, ValueSP> MapType;
   typedef typename MapType::iterator MapIterator;
-  typedef std::function<bool(KeyType, const ValueSP &)> ForEachCallback;
+  typedef std::function<bool(const KeyType &, const ValueSP &)> 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<std::recursive_mutex> guard(m_map_mutex);
-    m_map[name] = entry;
+    m_map[std::move(name)] = entry;
     if (listener)
       listener->Changed();
   }
 
   bool Delete(KeyType name) {
     std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     MapIterator iter = m_map.find(name);
     if (iter == m_map.end())
bool Get(KeyType name, ValueSP &entry) {
     return true;
   }
 
   void ForEach(ForEachCallback callback) {
     if (callback) {
       std::lock_guard<std::recursive_mutex> 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;
       }
     }
   }
 
   uint32_t GetCount() { return m_map.size(); }
 
   ValueSP GetValueAtIndex(size_t index) {
     std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     MapIterator iter = m_map.begin();
     MapIterator end = m_map.end();
     while (index > 0) {
       iter++;
       index--;
       if (end == iter)
         return ValueSP();
     }
     return iter->second;
   }
 
-  KeyType GetKeyAtIndex(size_t index) {
+  const KeyType *GetKeyAtIndex(size_t index) {
     std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     MapIterator iter = m_map.begin();
     MapIterator end = m_map.end();
     while (index > 0) {
       iter++;
       index--;
       if (end == iter)
-        return KeyType();
+        return nullptr;
     }
-    return iter->first;
+    return &iter->first;
   }
 
 protected:
   MapType m_map;
   std::recursive_mutex m_map_mutex;
   IFormatChangeListener *listener;
 
   MapType &map() { return m_map; }
public:
   typedef typename std::shared_ptr<FormattersContainer<KeyType, ValueType>>
       SharedPointer;
 
   friend class TypeCategoryImpl;
 
   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<KeyType *>(nullptr));
+  void Add(MapKeyType &&type, const MapValueType &entry) {
+    Add_Impl(std::move(type), entry, static_cast<KeyType *>(nullptr));
   }
 
   bool Delete(ConstString type) {
     return Delete_Impl(type, static_cast<KeyType *>(nullptr));
   }
 
   bool Get(ValueObject &valobj, MapValueType &entry,
            lldb::DynamicValueType use_dynamic, uint32_t *why = nullptr) {
public:
   uint32_t GetCount() { return m_format_map.GetCount(); }
 
 protected:
   BackEndType m_format_map;
   std::string m_name;
 
   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,
                 ConstString *dummy) {
     m_format_map.Add(GetValidTypeName_Impl(type), entry);
   }
 
   bool Delete_Impl(ConstString type, ConstString *dummy) {
     return m_format_map.Delete(type);
   }
 
-  bool Delete_Impl(ConstString type, lldb::RegularExpressionSP *dummy) {
+  bool Delete_Impl(ConstString type, RegularExpression *dummy) {
     std::lock_guard<std::recursive_mutex> 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 &regex = pos->first;
+      if (type.GetStringRef() == regex.GetText()) {
         m_format_map.map().erase(pos);
         if (m_format_map.listener)
           m_format_map.listener->Changed();
         return true;
       }
     }
     return false;
   }
 
   bool Get_Impl(ConstString type, MapValueType &entry, ConstString *dummy) {
     return m_format_map.Get(type, entry);
   }
 
   bool GetExact_Impl(ConstString type, MapValueType &entry,
                      ConstString *dummy) {
     return Get_Impl(type, entry, static_cast<KeyType *>(nullptr));
   }
 
   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<std::recursive_mutex> 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 &regex = pos->first;
+      if (regex.Execute(key_str)) {
         value = pos->second;
         return true;
       }
     }
     return false;
   }
 
   bool GetExact_Impl(ConstString key, MapValueType &value,
-                     lldb::RegularExpressionSP *dummy) {
+                     RegularExpression *dummy) {
     std::lock_guard<std::recursive_mutex> 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 &regex = pos->first;
+      if (regex.GetText() == key.GetStringRef()) {
         value = pos->second;
         return true;
       }
     }
     return false;
   }
 
   bool Get(const FormattersMatchVector &candidates, MapValueType &entry,
            uint32_t *reason) {

lldb/include/lldb/DataFormatters/TypeCategory.h

 #include "lldb/DataFormatters/FormatClasses.h"
 #include "lldb/DataFormatters/FormattersContainer.h"
 
 namespace lldb_private {
 
 template <typename FormatterImpl> class FormatterContainerPair {
 public:
   typedef FormattersContainer<ConstString, FormatterImpl> ExactMatchContainer;
-  typedef FormattersContainer<lldb::RegularExpressionSP, FormatterImpl>
+  typedef FormattersContainer<RegularExpression, FormatterImpl>
       RegexMatchContainer;
 
   typedef typename ExactMatchContainer::MapType ExactMatchMap;
   typedef typename RegexMatchContainer::MapType RegexMatchMap;
 
   typedef typename ExactMatchContainer::MapValueType MapValueType;
 
   typedef typename ExactMatchContainer::SharedPointer ExactMatchContainerSP;

lldb/include/lldb/Target/Target.h

public:
 
   // Use this to create breakpoint that matches regex against the source lines
   // in files given in source_file_list: If function_names is non-empty, also
   // filter by function after the matches are made.
   lldb::BreakpointSP CreateSourceRegexBreakpoint(
       const FileSpecList *containingModules,
       const FileSpecList *source_file_list,
       const std::unordered_set<std::string> &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
   lldb::BreakpointSP CreateBreakpoint(lldb::addr_t load_addr, bool internal,
                                       bool request_hardware);
 
   // Use this to create a breakpoint from a load address and a module file spec
   lldb::BreakpointSP CreateAddressInModuleBreakpoint(lldb::addr_t file_addr,
                                                      bool internal,
                                                      const FileSpec *file_spec,
                                                      bool request_hardware);
 
   // Use this to create Address breakpoints:
   lldb::BreakpointSP CreateBreakpoint(const Address &addr, bool internal,
                                       bool request_hardware);
 
   // Use this to create a function breakpoint by regexp in
   // containingModule/containingSourceFiles, or all modules if it is nullptr
   // When "skip_prologue is set to eLazyBoolCalculate, we use the current
   // 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
   // eLazyBoolCalculate, we use the current target setting, else we use the
   // values passed in. func_name_type_mask is or'ed values from the
   // FunctionNameType enum.
   lldb::BreakpointSP CreateBreakpoint(
       const FileSpecList *containingModules,

lldb/include/lldb/Utility/RegularExpression.h

public:
   ///
   /// \return \b true if the regular expression compiled and is ready for
   ///     execution, \b false otherwise.
   bool IsValid() const;
 
   /// Return an error if the regular expression failed to compile.
   llvm::Error GetError() const;
 
+  bool operator<(const RegularExpression &rhs) const {
+    return GetText() < rhs.GetText();
+  }
+
 private:
   /// A copy of the original regular expression text.
   std::string m_regex_text;
   /// The compiled regular expression.
   mutable llvm::Regex m_regex;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_RegularExpression_h_

lldb/source/API/SBTarget.cpp

lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(
   if (target_sp && symbol_name_regex && symbol_name_regex[0]) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     RegularExpression regexp((llvm::StringRef(symbol_name_regex)));
     const bool internal = false;
     const bool hardware = false;
     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);
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress,
                      (lldb::addr_t), address);
if (target_sp && source_regex && source_regex[0]) {
     const LazyBool move_to_nearest_code = eLazyBoolCalculate;
     RegularExpression regexp((llvm::StringRef(source_regex)));
     std::unordered_set<std::string> func_names_set;
     for (size_t i = 0; i < func_names.GetSize(); i++) {
       func_names_set.insert(func_names.GetStringAtIndex(i));
     }
 
     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);
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateForException(lldb::LanguageType language,
                                        bool catch_bp, bool throw_bp) {

lldb/source/API/SBTypeCategory.cpp

bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
   if (!type_name.IsValid())
     return false;
 
   if (!format.IsValid())
     return false;
 
   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(
         ConstString(type_name.GetName()), format.GetSP());
 
   return true;
 }
 
for (uint32_t j = 0; j < num_debuggers; j++) {
           }
         }
       }
     }
   }
 
   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(
         ConstString(type_name.GetName()), summary.GetSP());
 
   return true;
 }
 
bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
   if (!type_name.IsValid())
     return false;
 
   if (!filter.IsValid())
     return false;
 
   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(
         ConstString(type_name.GetName()), filter.GetSP());
 
   return true;
 }
 
for (uint32_t j = 0; j < num_debuggers; j++) {
           }
         }
       }
     }
   }
 
   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(
         ConstString(type_name.GetName()), synth.GetSP());
 
   return true;
 }
 

lldb/source/Breakpoint/BreakpointResolverName.cpp

: BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
       m_match_type(Breakpoint::Exact), m_language(language),
       m_skip_prologue(skip_prologue) {
   for (const std::string &name : names) {
     AddNameLookup(ConstString(name.c_str(), name.size()), name_type_mask);
   }
 }
 
 BreakpointResolverName::BreakpointResolverName(Breakpoint *bkpt,
-                                               RegularExpression func_regex,
+                                               RegularExpression &&func_regex,
                                                lldb::LanguageType language,
                                                lldb::addr_t offset,
                                                bool skip_prologue)
     : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
       m_class_name(nullptr), m_regex(std::move(func_regex)),
       m_match_type(Breakpoint::Regexp), m_language(language),
       m_skip_prologue(skip_prologue) {}
 
if (!success) {
     error.SetErrorStringWithFormat("BRN::CFSD: Missing Skip prologue entry.");
     return nullptr;
   }
 
   llvm::StringRef regex_text;
   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(
         GetKey(OptionNames::SymbolNameArray), names_array);
     if (!success) {
       error.SetErrorStringWithFormat("BRN::CFSD: Missing symbol names entry.");
       return nullptr;
     }

lldb/source/Commands/CommandObjectBreakpoint.cpp

case eSetTypeFunctionRegexp: // Breakpoint by regular expression function
         if (llvm::Error err = regexp.GetError()) {
           result.AppendErrorWithFormat(
               "Function name regular expression could not be compiled: \"%s\"",
               llvm::toString(std::move(err)).c_str());
           result.SetStatus(eReturnStatusFailed);
           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,
       }
       break;
     case eSetTypeSourceRegexp: // Breakpoint by regexp on source text.
     {
       const size_t num_files = m_options.m_filenames.GetSize();
 
       if (num_files == 0 && !m_options.m_all_files) {
         FileSpec file;
case eSetTypeSourceRegexp: // Breakpoint by regexp on source text.
       RegularExpression regexp(m_options.m_source_text_regexp);
       if (llvm::Error err = regexp.GetError()) {
         result.AppendErrorWithFormat(
             "Source text regular expression could not be compiled: \"%s\"",
             llvm::toString(std::move(err)).c_str());
         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;
       bp_sp = target->CreateExceptionBreakpoint(m_options.m_exception_language, 
                                                 m_options.m_catch_bp,
                                                 m_options.m_throw_bp, 
                                                 internal,
                                                 &m_options

lldb/source/Commands/CommandObjectType.cpp

for (auto &arg_entry : command.entries()) {
       if (arg_entry.ref.empty()) {
         result.AppendError("empty typenames not allowed");
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
 
       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);
     return result.Succeeded();
   }
 };
 
 #define LLDB_OPTIONS_type_formatter_delete
auto category_closure = [&result, &formatter_regex, &any_printed](
           any_printed = true;
           result.GetOutputStream().Printf("%s: %s\n", name.AsCString(),
                                           format_sp->GetDescription().c_str());
           return true;
         });
 
       foreach
         .SetWithRegex([&result, &formatter_regex, &any_printed](
-                          RegularExpressionSP regex_sp,
+                          const RegularExpression &regex,
                           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;
             }
 
             if (escape)
               return true;
           }
 
           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;
         });
 
       category->ForEach(foreach);
     };
 
     if (m_options.m_category_language.OptionWasSet()) {
DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()),
                                              category);
 
   if (type == eRegularSummary) {
     if (FixArrayTypeNameWithRegex(type_name))
       type = eRegexSummary;
   }
 
   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?)");
       return false;
     }
 
     category->GetRegexTypeSummariesContainer()->Delete(type_name);
-    category->GetRegexTypeSummariesContainer()->Add(typeRX, entry);
+    category->GetRegexTypeSummariesContainer()->Add(std::move(typeRX), entry);
 
     return true;
   } else if (type == eNamedSummary) {
     // system named summaries do not exist (yet?)
     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;
   }
 }
 
 // CommandObjectTypeSummaryDelete
 
 class CommandObjectTypeSummaryDelete : public CommandObjectTypeFormatterDelete {
 public:
if (category->AnyMatches(type_name, eFormatCategoryItemFilter |
     if (error)
       error->SetErrorStringWithFormat("cannot add synthetic for type %s when "
                                       "filter is defined in same category!",
                                       type_name.AsCString());
     return false;
   }
 
   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?)");
       return false;
     }
 
     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;
   }
 }
 
 #endif // LLDB_DISABLE_PYTHON
 #define LLDB_OPTIONS_type_filter_add
 #include "CommandOptions.inc"
 
if (category->AnyMatches(type_name, eFormatCategoryItemSynth |
         error->SetErrorStringWithFormat("cannot add filter for type %s when "
                                         "synthetic is defined in same "
                                         "category!",
                                         type_name.AsCString());
       return false;
     }
 
     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?)");
         return false;
       }
 
       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;
     }
   }
 
 public:
   CommandObjectTypeFilterAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "type filter add",
                             "Add a new filter for a type.", nullptr),

lldb/source/DataFormatters/FormatManager.cpp

string_array_flags.SetCascades(true)
       .SetHideItemNames(false);
 
   lldb::TypeSummaryImplSP string_format(
       new StringSummaryFormat(string_flags, "${var%s}"));
 
   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);
 
   sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("char *"),
                                                     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()
                                   .SetCascades(false)
                                   .SetSkipPointers(true)
                                   .SetSkipReferences(true)
                                   .SetDontShowChildren(true)
                                   .SetDontShowValue(false)

lldb/source/DataFormatters/FormattersHelpers.cpp

 
 void lldb_private::formatters::AddFormat(
     TypeCategoryImpl::SharedPointer category_sp, lldb::Format format,
     ConstString type_name, TypeFormatImpl::Flags flags, bool regex) {
   lldb::TypeFormatImplSP format_sp(new TypeFormatImpl_Format(format, flags));
 
   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(
     TypeCategoryImpl::SharedPointer category_sp, TypeSummaryImplSP summary_sp,
     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(
     TypeCategoryImpl::SharedPointer category_sp, const char *string,
     ConstString type_name, TypeSummaryImpl::Flags flags, bool regex) {
   lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags, string));
 
   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(
     TypeCategoryImpl::SharedPointer category_sp, ConstString type_name,
     TypeSummaryImpl::Flags flags, bool regex) {
   flags.SetShowMembersOneLiner(true);
   lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags, ""));
 
   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(
     TypeCategoryImpl::SharedPointer category_sp,
     CXXFunctionSummaryFormat::Callback funct, const char *description,
     ConstString type_name, TypeSummaryImpl::Flags flags, bool regex) {
   lldb::TypeSummaryImplSP summary_sp(
       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(
     TypeCategoryImpl::SharedPointer category_sp,
     CXXSyntheticChildren::CreateFrontEndCallback generator,
     const char *description, ConstString type_name,
     ScriptedSyntheticChildren::Flags flags, bool regex) {
   lldb::SyntheticChildrenSP synth_sp(
       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(
     TypeCategoryImpl::SharedPointer category_sp,
     std::vector<std::string> children, const char *description,
     ConstString type_name, ScriptedSyntheticChildren::Flags flags, bool regex) {
   TypeFilterImplSP filter_sp(new TypeFilterImpl(flags));
   for (auto child : children)
     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) {
   if (!item_name || !*item_name)
     return UINT32_MAX;
   if (*item_name != '[')
     return UINT32_MAX;
   item_name++;

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

AddCXXSynthetic(cpp_category_sp, LibcxxVariantFrontEndCreator,
                   stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator,
       "libc++ std::atomic synthetic children",
       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")));
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
       "shared_ptr synthetic children",
cpp_category_sp->GetTypeSummariesContainer()->Add(
                   "std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
       cxx11_wstring_summary_sp);
 
   SyntheticChildren::Flags stl_synth_flags;
   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
       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%#}")));
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator,
       "std::vector iterator synthetic children",
       ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);

lldb/source/Target/Target.cpp

BreakpointSP Target::GetBreakpointByID(break_id_t break_id) {
 
   return bp_sp;
 }
 
 BreakpointSP Target::CreateSourceRegexBreakpoint(
     const FileSpecList *containingModules,
     const FileSpecList *source_file_spec_list,
     const std::unordered_set<std::string> &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<bool>(move_to_nearest_code)));
 
   return CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true);
 }
 
 BreakpointSP Target::CreateBreakpoint(const FileSpecList *containingModules,
                                       const FileSpec &file, uint32_t line_no,
                                       uint32_t column, lldb::addr_t offset,
if (containingModules == nullptr) {
     filter_sp = std::make_shared<SearchFilterByModuleListAndCU>(
         shared_from_this(), *containingModules, *containingSourceFiles);
   }
   return filter_sp;
 }
 
 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(
       containingModules, containingSourceFiles));
   bool skip = (skip_prologue == eLazyBoolCalculate)
                   ? GetSkipPrologue()
                   : static_cast<bool>(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);
 }
 
 lldb::BreakpointSP
 Target::CreateExceptionBreakpoint(enum lldb::LanguageType language,
                                   bool catch_bp, bool throw_bp, bool internal,
                                   Args *additional_args, Status *error) {