[Utility] Reimplement RegularExpression on top of llvm::Regex

[JDevlieghere]

Summary

Originally I wanted to remove the RegularExpression class in Utility and replace it with llvm::Regex. However, during that transition I noticed that there are different places where need the underlying regular expression string. So instead I propose to keep the RegularExpression class and make it a relatively thin wrapper around llvm::Regex.

[labath]

Overall, I am very supportive of this, though I have some comments inline. The interface seems ok, though maybe you could add a couple of quick unit tests to show how the class is meant to be used.

lldb/source/Commands/CommandObjectBreakpoint.cpp

685 ↗

(On Diff #215022)

I wouldn't use auto in cases like these because Optional<string> is definitely not among the things one would expect a function called GetError to return. Though maybe that means the function should really return an llvm::Error?

lldb/source/Host/common/Socket.cpp

287 ↗

(On Diff #215022)

Are there any cases where evaluation of the regex can succeed, but the result will not contain the expected number of matches? Should this be changed into an assert, or just dropped completely?

lldb/unittests/Utility/NameMatchesTest.cpp

52–53 ↗

(On Diff #215022)

This is interesting. So, llvm::regex considers an empty pattern to not match anything? That doesn't sound right. I've just tried grep, python and perl, and all of them seem perfectly happy to accept an empty string as a pattern which matches everything..

I'd say this is a bug in llvm::regex we should fix.

[xiaobai]

I like the idea of using something from llvm instead of rolling our own. The code changes look relatively simple and straightforward, so that's good.

lldb/source/Commands/CommandObjectBreakpoint.cpp

685 ↗

(On Diff #215022)

If Pavel hadn't pointed this out, I would have thought that error was an llvm::Error here and not a an Optional. I think something should change here.

[jingham]

I think we need to fix the behavior for "", other than that, this looks fine to me.

lldb/source/Host/common/Socket.cpp

287 ↗

(On Diff #215022)

Jonas introduced this pattern everywhere he calls Execute. It does seem a little odd, since there's no way any of the patterns that he checks matches for could match but not match the () part. It makes the reader wonder if they don't understand regular expressions after all...

lldb/source/Target/ThreadPlanStepInRange.cpp

367 ↗

(On Diff #215022)

You can move this into the "if (return_value" It doesn't get used outside the check, and this test mostly fails so it would be good not to do more work in that case.

lldb/unittests/Utility/NameMatchesTest.cpp

52–53 ↗

(On Diff #215022)

Yes, that does seem odd to me. I would expect:

(lldb) break set -r ""

to match everything, not nothing.

[JDevlieghere]

• Cleanup interface
• Return llvm::Error
• Remove size comparison
• Add empty regex workaround
• Add unit tests

[JDevlieghere]

lldb/unittests/Utility/NameMatchesTest.cpp

52–53 ↗

(On Diff #215022)

The POSIX standard says that an empty regex is not a thing, it is rejected by the grammar as defined in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html. The BSD implementation in LLVM agrees. Unfortunately GNU seems to disagree, which is probably why you expect the old behavior. If you look at the old code, the LLDB implementation worked around this.

I've put the old workaround back, but I don't think we should "fix" the llvm::Regex implementation. Personally I think we should follow the standard in LLDB as well. I tried a few things and I couldn't find a compelling scenario. For example, setting a breakpoint with an empty regex is already not supported.

[clayborg]

Looks fine to me. A few nits.

lldb/include/lldb/Utility/RegularExpression.h

98 ↗

(On Diff #215248)

Why does this need to be mutable?

lldb/source/Commands/CommandObjectFrame.cpp

1 ↗

(On Diff #215248)

revert

[JDevlieghere]

lldb/include/lldb/Utility/RegularExpression.h

98 ↗

(On Diff #215248)

llvm::Regex's match method is not const. We could unconst Execute but that would mean a bunch of churn in the API.

lldb/source/Commands/CommandObjectFrame.cpp

1 ↗

(On Diff #215248)

Oops

[JDevlieghere]

Undo typo in CommandObjectFrame.cpp

[labath]

I was unhappy with the () workaround, so I did some investigation. Now, I am even more unhappy, but at least better educated. :P

Basically, what I've learned is that according to POSIX https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html an empty string is not a valid regular expression. Most tools seem to ignore that, and treat it as if it matches everything (and I can't say I blame them). However, the BSD implementation (that the llvm stuff is based on) tried to do a strict implementation and it rejects that as an invalid expression.

Funnily enough, () is not valid according to POSIX either, but the BSD implementation accepts it. So does (linux) grep and python. However, perl rejects it (it still considers it a valid expression, but one that doesn't match anything).

a||b (a OR empty pattern OR b) is also not valid. grep, python and perl accept that, but the BSD regexes don't.

So, overall, it seems to me that there is a lot of confusion about what should empty (sub-)patterns do. I don't think special-casing "" in lldb_private::RegularExpression would help alleviate any of that confusion as we would be still left with all of the other inconsistencies. So, if we want to go through with this (and I still think we should), I guess we'll just have to bite the bullet and say that our expressions are now (more or less) POSIX conformant, and repeat that to anyone who comes complaining that lldb regexes behave differently than grep, python or older versions of lldb...

lldb/source/Commands/CommandObjectFrame.cpp

577–578 ↗

(On Diff #215287)

GetErrorStream().Format("error: {0}\n", llvm::fmt_consume(std::move(err))); would be slightly less verbose.

[JDevlieghere]

In D66174#1631055, @labath wrote:

I was unhappy with the () workaround, so I did some investigation. Now, I am even more unhappy, but at least better educated. :P

Basically, what I've learned is that according to POSIX https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html an empty string is not a valid regular expression. Most tools seem to ignore that, and treat it as if it matches everything (and I can't say I blame them). However, the BSD implementation (that the llvm stuff is based on) tried to do a strict implementation and it rejects that as an invalid expression.

Funnily enough, () is not valid according to POSIX either, but the BSD implementation accepts it. So does (linux) grep and python. However, perl rejects it (it still considers it a valid expression, but one that doesn't match anything).

a||b (a OR empty pattern OR b) is also not valid. grep, python and perl accept that, but the BSD regexes don't.

So, overall, it seems to me that there is a lot of confusion about what should empty (sub-)patterns do. I don't think special-casing "" in lldb_private::RegularExpression would help alleviate any of that confusion as we would be still left with all of the other inconsistencies. So, if we want to go through with this (and I still think we should), I guess we'll just have to bite the bullet and say that our expressions are now (more or less) POSIX conformant, and repeat that to anyone who comes complaining that lldb regexes behave differently than grep, python or older versions of lldb...

For the record, in case my earlier response gets lost in the inline comments, I strongly support this :-)

[JDevlieghere]

Make RegularExpression POSIX compliant.

[labath]

lgtm. Thanks for doing this.

[jingham]

Pavel said "we'll just have to bite the bullet and say that our expressions are now (more or less) POSIX conformant"... We should say this somewhere users are likely to find.

All the options that take regular expressions look like:

(lldb) help break set
...
       -p <regular-expression> ( --source-pattern-regexp <regular-expression> )

And then for any option value type, you can get help:

(lldb) help regular-expression
  <regular-expression> -- A regular expression.

Maybe it would be good to say a little more here?

With that addition I'm fine with this.

lldb/trunk/include/lldb/Breakpoint/BreakpointResolverFileRegex.h

 /// \class BreakpointResolverFileRegex BreakpointResolverFileRegex.h
 /// "lldb/Breakpoint/BreakpointResolverFileRegex.h" This class sets
 /// breakpoints by file and line.  Optionally, it will look for inlined
 /// instances of the file and line specification.
 
 class BreakpointResolverFileRegex : public BreakpointResolver {
 public:
   BreakpointResolverFileRegex(
-      Breakpoint *bkpt, RegularExpression &regex,
+      Breakpoint *bkpt, RegularExpression regex,
       const std::unordered_set<std::string> &func_name_set, bool exact_match);
 
   static BreakpointResolver *
   CreateFromStructuredData(Breakpoint *bkpt,
                            const StructuredData::Dictionary &options_dict,
                            Status &error);
 
   StructuredData::ObjectSP SerializeToStructuredData() override;

lldb/trunk/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/trunk/include/lldb/Core/AddressResolverName.h

 
 class AddressResolverName : public AddressResolver {
 public:
   AddressResolverName(const char *func_name,
                       AddressResolver::MatchType type = Exact);
 
   // Creates a function breakpoint by regular expression.  Takes over control
   // of the lifespan of func_regex.
-  AddressResolverName(RegularExpression &func_regex);
+  AddressResolverName(RegularExpression func_regex);
 
   AddressResolverName(const char *class_name, const char *method,
                       AddressResolver::MatchType type);
 
   ~AddressResolverName() override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context, Address *addr,

lldb/trunk/include/lldb/Interpreter/OptionValueRegex.h

public:
   Status
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
   Status
   SetValueFromString(const char *,
                      VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
-    m_regex.Clear();
+    m_regex = RegularExpression();
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;
 
   // Subclass specific functions
   const RegularExpression *GetCurrentValue() const {
     return (m_regex.IsValid() ? &m_regex : nullptr);
   }
 
   void SetCurrentValue(const char *value) {
     if (value && value[0])
       m_regex.Compile(llvm::StringRef(value));
     else
-      m_regex.Clear();
+      m_regex = RegularExpression();
   }
 
   bool IsValid() const { return m_regex.IsValid(); }
 
 protected:
   RegularExpression m_regex;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionValueRegex_h_

lldb/trunk/include/lldb/Utility/RegularExpression.h

 //===-- RegularExpression.h -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_RegularExpression_h_
 #define liblldb_RegularExpression_h_
 
-#ifdef _WIN32
-#include "../lib/Support/regex_impl.h"
-
-typedef llvm_regmatch_t regmatch_t;
-typedef llvm_regex_t regex_t;
-
-inline int regcomp(llvm_regex_t *a, const char *b, int c) {
-  return llvm_regcomp(a, b, c);
-}
-
-inline size_t regerror(int a, const llvm_regex_t *b, char *c, size_t d) {
-  return llvm_regerror(a, b, c, d);
-}
-
-inline int regexec(const llvm_regex_t *a, const char *b, size_t c,
-                   llvm_regmatch_t d[], int e) {
-  return llvm_regexec(a, b, c, d, e);
-}
-
-inline void regfree(llvm_regex_t *a) { llvm_regfree(a); }
-#else
-#ifdef __ANDROID__
-#include <regex>
-#endif
-#include <regex.h>
-#endif
-
-#include <string>
-#include <vector>
-
-#include <stddef.h>
-#include <stdint.h>
-
-namespace llvm {
-class StringRef;
-} // namespace llvm
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Regex.h"
 
 namespace lldb_private {
 
-/// \class RegularExpression RegularExpression.h
-/// "lldb/Utility/RegularExpression.h"
-/// A C++ wrapper class for regex.
-///
-/// This regular expression class wraps the posix regex functions \c
-/// regcomp(), \c regerror(), \c regexec(), and \c regfree() from the header
-/// file in \c /usr/include/regex\.h.
-class RegularExpression {
-public:
-  class Match {
-  public:
-    Match(uint32_t max_matches) : m_matches() {
-      if (max_matches > 0)
-        m_matches.resize(max_matches + 1);
-    }
-
-    void Clear() {
-      const size_t num_matches = m_matches.size();
-      regmatch_t invalid_match = {-1, -1};
-      for (size_t i = 0; i < num_matches; ++i)
-        m_matches[i] = invalid_match;
-    }
-
-    size_t GetSize() const { return m_matches.size(); }
-
-    regmatch_t *GetData() {
-      return (m_matches.empty() ? nullptr : m_matches.data());
-    }
-
-    bool GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
-                         std::string &match_str) const;
-
-    bool GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
-                         llvm::StringRef &match_str) const;
-
-  protected:
-    std::vector<regmatch_t>
-        m_matches; ///< Where parenthesized subexpressions results are stored
-  };
-
+class RegularExpression : public llvm::Regex {
   /// Default constructor.
   ///
   /// The default constructor that initializes the object state such that it
   /// contains no compiled regular expression.
-  RegularExpression();
+  RegularExpression() = default;
 
   explicit RegularExpression(llvm::StringRef string);
-
-  /// Destructor.
-  ///
-  /// Any previously compiled regular expression contained in this object will
-  /// be freed.
-  ~RegularExpression();
+  ~RegularExpression() = default;
 
   RegularExpression(const RegularExpression &rhs);
+  RegularExpression(RegularExpression &&rhs) = default;
 
-  const RegularExpression &operator=(const RegularExpression &rhs);
+  RegularExpression &operator=(RegularExpression &&rhs) = default;
+  RegularExpression &operator=(const RegularExpression &rhs) = default;
 
   /// Compile a regular expression.
   ///
   /// Compile a regular expression using the supplied regular expression text.
   /// The compiled regular expression lives in this object so that it can be
   /// readily used for regular expression matches. Execute() can be called
   /// after the regular expression is compiled. Any previously compiled
   /// regular expression contained in this object will be freed.
   ///
   /// \param[in] re
   ///     A NULL terminated C string that represents the regular
   ///     expression to compile.
   ///
-  /// \return
-  ///     \b true if the regular expression compiles successfully,
-  ///     \b false otherwise.
+  /// \return \b true if the regular expression compiles successfully, \b false
+  ///     otherwise.
   bool Compile(llvm::StringRef string);
-  bool Compile(const char *) = delete;
 
   /// Executes a regular expression.
   ///
   /// Execute a regular expression match using the compiled regular expression
   /// that is already in this object against the match string \a s. If any
   /// parens are used for regular expression matches \a match_count should
   /// indicate the number of regmatch_t values that are present in \a
   /// match_ptr.
   ///
   /// \param[in] string
   ///     The string to match against the compile regular expression.
   ///
   /// \param[in] match
   ///     A pointer to a RegularExpression::Match structure that was
   ///     properly initialized with the desired number of maximum
   ///     matches, or nullptr if no parenthesized matching is needed.
   ///
-  /// \return
-  ///     \b true if \a string matches the compiled regular
-  ///     expression, \b false otherwise.
-  bool Execute(llvm::StringRef string, Match *match = nullptr) const;
-  bool Execute(const char *, Match * = nullptr) = delete;
-
-  size_t GetErrorAsCString(char *err_str, size_t err_str_max_len) const;
-
-  /// Free the compiled regular expression.
-  ///
-  /// If this object contains a valid compiled regular expression, this
-  /// function will free any resources it was consuming.
-  void Free();
+  /// \return \b true if \a string matches the compiled regular expression, \b
+  ///     false otherwise.
+  bool Execute(llvm::StringRef string,
+               llvm::SmallVectorImpl<llvm::StringRef> *matches = nullptr) const;
 
   /// Access the regular expression text.
   ///
   /// Returns the text that was used to compile the current regular
   /// expression.
   ///
   /// \return
   ///     The NULL terminated C string that was used to compile the
   ///     current regular expression
   llvm::StringRef GetText() const;
 
   /// Test if valid.
   ///
   /// Test if this object contains a valid regular expression.
   ///
-  /// \return
-  ///     \b true if the regular expression compiled and is ready
-  ///     for execution, \b false otherwise.
+  /// \return \b true if the regular expression compiled and is ready for
+  ///     execution, \b false otherwise.
   bool IsValid() const;
 
-  void Clear() {
-    Free();
-    m_re.clear();
-    m_comp_err = 1;
-  }
-
-  int GetErrorCode() const { return m_comp_err; }
-
-  bool operator<(const RegularExpression &rhs) const;
+  /// Return an error if the regular expression failed to compile.
+  llvm::Error GetError() const;
 
 private:
-  // Member variables
-  std::string m_re; ///< A copy of the original regular expression text
-  int m_comp_err;   ///< Status code for the regular expression compilation
-  regex_t m_preg;   ///< The compiled regular expression
+  /// 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/trunk/source/Breakpoint/BreakpointResolverFileRegex.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // BreakpointResolverFileRegex:
 BreakpointResolverFileRegex::BreakpointResolverFileRegex(
-    Breakpoint *bkpt, RegularExpression &regex,
+    Breakpoint *bkpt, RegularExpression regex,
     const std::unordered_set<std::string> &func_names, bool exact_match)
     : BreakpointResolver(bkpt, BreakpointResolver::FileRegexResolver),
-      m_regex(regex), m_exact_match(exact_match), m_function_names(func_names) {
-}
+      m_regex(std::move(regex)), m_exact_match(exact_match),
+      m_function_names(func_names) {}
 
 BreakpointResolverFileRegex::~BreakpointResolverFileRegex() {}
 
 BreakpointResolver *BreakpointResolverFileRegex::CreateFromStructuredData(
     Breakpoint *bkpt, const StructuredData::Dictionary &options_dict,
     Status &error) {
   bool success;
 
for (size_t i = 0; i < num_names; i++) {
         error.SetErrorStringWithFormat(
             "BRFR::CFSD: Malformed element %zu in the names array.", i);
         return nullptr;
       }
       names_set.insert(name);
     }
   }
 
-  return new BreakpointResolverFileRegex(bkpt, regex, names_set, exact_match);
+  return new BreakpointResolverFileRegex(bkpt, std::move(regex), names_set,
+                                         exact_match);
 }
 
 StructuredData::ObjectSP
 BreakpointResolverFileRegex::SerializeToStructuredData() {
   StructuredData::DictionarySP options_dict_sp(
       new StructuredData::Dictionary());
 
   options_dict_sp->AddStringItem(GetKey(OptionNames::RegexString),

lldb/trunk/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(func_regex),
+      m_class_name(nullptr), m_regex(std::move(func_regex)),
       m_match_type(Breakpoint::Regexp), m_language(language),
       m_skip_prologue(skip_prologue) {}
 
 BreakpointResolverName::~BreakpointResolverName() = default;
 
 BreakpointResolverName::BreakpointResolverName(
     const BreakpointResolverName &rhs)
     : BreakpointResolver(rhs.m_breakpoint, BreakpointResolver::NameResolver,

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

case eSetTypeFunctionName: // Breakpoint by function name
                                        internal,
                                        m_options.m_hardware);
     } break;
 
     case eSetTypeFunctionRegexp: // Breakpoint by regular expression function
                                  // name
       {
         RegularExpression regexp(m_options.m_func_regexp);
-        if (!regexp.IsValid()) {
-          char err_str[1024];
-          regexp.GetErrorAsCString(err_str, sizeof(err_str));
+        if (llvm::Error err = regexp.GetError()) {
           result.AppendErrorWithFormat(
               "Function name regular expression could not be compiled: \"%s\"",
-              err_str);
+              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, 
case eSetTypeSourceRegexp: // Breakpoint by regexp on source text.
           result.SetStatus(eReturnStatusFailed);
           return false;
         } else {
           m_options.m_filenames.Append(file);
         }
       }
 
       RegularExpression regexp(m_options.m_source_text_regexp);
-      if (!regexp.IsValid()) {
-        char err_str[1024];
-        regexp.GetErrorAsCString(err_str, sizeof(err_str));
+      if (llvm::Error err = regexp.GetError()) {
         result.AppendErrorWithFormat(
             "Source text regular expression could not be compiled: \"%s\"",
-            err_str);
+            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,

lldb/trunk/source/Commands/CommandObjectFrame.cpp

if (variable_list) {
                   }
                 }
               } else if (num_matches == 0) {
                 result.GetErrorStream().Printf("error: no variables matched "
                                                "the regular expression '%s'.\n",
                                                entry.c_str());
               }
             } else {
-              char regex_error[1024];
-              if (regex.GetErrorAsCString(regex_error, sizeof(regex_error)))
-                result.GetErrorStream().Printf("error: %s\n", regex_error);
+              if (llvm::Error err = regex.GetError())
+                result.GetErrorStream().Printf(
+                    "error: %s\n", llvm::toString(std::move(err)).c_str());
               else
                 result.GetErrorStream().Printf(
                     "error: unknown regex error when compiling '%s'\n",
                     entry.c_str());
             }
           } else // No regex, either exact variable names or variable
                  // expressions.
           {

lldb/trunk/source/Core/AddressResolverName.cpp

if (!m_regex.Compile(m_func_name.GetStringRef())) {
 
       if (log)
         log->Warning("function name regexp: \"%s\" did not compile.",
                      m_func_name.AsCString());
     }
   }
 }
 
-AddressResolverName::AddressResolverName(RegularExpression &func_regex)
+AddressResolverName::AddressResolverName(RegularExpression func_regex)
     : AddressResolver(), m_func_name(nullptr), m_class_name(nullptr),
-      m_regex(func_regex), m_match_type(AddressResolver::Regexp) {}
+      m_regex(std::move(func_regex)), m_match_type(AddressResolver::Regexp) {}
 
 AddressResolverName::AddressResolverName(const char *class_name,
                                          const char *method,
                                          AddressResolver::MatchType type)
     : AddressResolver(), m_func_name(method), m_class_name(class_name),
       m_regex(), m_match_type(type) {}
 
 AddressResolverName::~AddressResolverName() = default;

lldb/trunk/source/Core/Disassembler.cpp

if (target_sp) {
         }
       }
     }
   }
   if (avoid_regex && sc.symbol != nullptr) {
     const char *function_name =
         sc.GetFunctionName(Mangled::ePreferDemangledWithoutArguments)
             .GetCString();
-    if (function_name) {
-      RegularExpression::Match regex_match(1);
-      if (avoid_regex->Execute(function_name, &regex_match)) {
-        // skip this source line
-        return true;
-      }
-    }
-  }
+    if (function_name && avoid_regex->Execute(function_name)) {
   // don't skip this source line
   return false;
 }
 
 bool Disassembler::PrintInstructions(Disassembler *disasm_ptr,
                                      Debugger &debugger, const ArchSpec &arch,
                                      const ExecutionContext &exe_ctx,
                                      uint32_t num_instructions,
if ((line.size() == 1) && line[0] == ']') {
       done = true;
       line.clear();
     }
 
     if (!line.empty()) {
       std::string value;
       static RegularExpression g_reg_exp(
           llvm::StringRef("^[ \t]*([^ \t]+)[ \t]*$"));
-      RegularExpression::Match regex_match(1);
-      bool reg_exp_success = g_reg_exp.Execute(line, &regex_match);
-      if (reg_exp_success)
-        regex_match.GetMatchAtIndex(line.c_str(), 1, value);
+      llvm::SmallVector<llvm::StringRef, 2> matches;
+      if (g_reg_exp.Execute(line, &matches))
+        value = matches[1].str();
       else
         value = line;
 
       OptionValueSP data_value_sp;
       switch (data_type) {
       case OptionValue::eTypeUInt64:
         data_value_sp = std::make_shared<OptionValueUInt64>(0, 0);
         data_value_sp->SetValueFromString(value);
if ((line.size() == 1) && (line[0] == '}')) {
       line.clear();
     }
 
     // Try to find a key-value pair in the current line and add it to the
     // dictionary.
     if (!line.empty()) {
       static RegularExpression g_reg_exp(llvm::StringRef(
           "^[ \t]*([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*=[ \t]*(.*)[ \t]*$"));
-      RegularExpression::Match regex_match(2);
 
-      bool reg_exp_success = g_reg_exp.Execute(line, &regex_match);
+      llvm::SmallVector<llvm::StringRef, 3> matches;
+
+      bool reg_exp_success = g_reg_exp.Execute(line, &matches);
       std::string key;
       std::string value;
       if (reg_exp_success) {
-        regex_match.GetMatchAtIndex(line.c_str(), 1, key);
-        regex_match.GetMatchAtIndex(line.c_str(), 2, value);
+        key = matches[1].str();
+        value = matches[2].str();
       } else {
         out_stream->Printf("Instruction::ReadDictionary: Failure executing "
                            "regular expression.\n");
         option_value_sp.reset();
         return option_value_sp;
       }
 
       ConstString const_key(key.c_str());

lldb/trunk/source/Host/common/Socket.cpp

Status Socket::UnixAbstractAccept(llvm::StringRef name,
   return error;
 }
 
 bool Socket::DecodeHostAndPort(llvm::StringRef host_and_port,
                                std::string &host_str, std::string &port_str,
                                int32_t &port, Status *error_ptr) {
   static RegularExpression g_regex(
       llvm::StringRef("([^:]+|\\[[0-9a-fA-F:]+.*\\]):([0-9]+)"));
-  RegularExpression::Match regex_match(2);
-  if (g_regex.Execute(host_and_port, &regex_match)) {
-    if (regex_match.GetMatchAtIndex(host_and_port, 1, host_str) &&
-        regex_match.GetMatchAtIndex(host_and_port, 2, port_str)) {
-      // IPv6 addresses are wrapped in [] when specified with ports
-      if (host_str.front() == '[' && host_str.back() == ']')
-        host_str = host_str.substr(1, host_str.size() - 2);
-      bool ok = false;
-      port = StringConvert::ToUInt32(port_str.c_str(), UINT32_MAX, 10, &ok);
-      if (ok && port <= UINT16_MAX) {
-        if (error_ptr)
-          error_ptr->Clear();
-        return true;
-      }
-      // port is too large
-      if (error_ptr)
-        error_ptr->SetErrorStringWithFormat(
-            "invalid host:port specification: '%s'",
-            host_and_port.str().c_str());
-      return false;
-    }
-  }
+  llvm::SmallVector<llvm::StringRef, 3> matches;
+  if (g_regex.Execute(host_and_port, &matches)) {
+    host_str = matches[1].str();
+    port_str = matches[2].str();
+          "invalid host:port specification: '%s'", host_and_port.str().c_str());
 
   // If this was unsuccessful, then check if it's simply a signed 32-bit
   // integer, representing a port with an empty host.
   host_str.clear();
   port_str.clear();
   if (to_integer(host_and_port, port, 10) && port < UINT16_MAX) {
     port_str = host_and_port;
     if (error_ptr)

lldb/trunk/source/Interpreter/CommandObject.cpp

CommandObject::ArgumentTableEntry CommandObject::g_arguments_data[] = {
     { eArgTypePid, "pid", CommandCompletions::eNoCompletion, { nullptr, false }, "The process ID number." },
     { eArgTypePlugin, "plugin", CommandCompletions::eNoCompletion, { nullptr, false }, "Help text goes here." },
     { eArgTypeProcessName, "process-name", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of the process." },
     { eArgTypePythonClass, "python-class", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of a Python class." },
     { eArgTypePythonFunction, "python-function", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of a Python function." },
     { eArgTypePythonScript, "python-script", CommandCompletions::eNoCompletion, { nullptr, false }, "Source code written in Python." },
     { eArgTypeQueueName, "queue-name", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of the thread queue." },
     { eArgTypeRegisterName, "register-name", CommandCompletions::eNoCompletion, { RegisterNameHelpTextCallback, true }, nullptr },
-    { eArgTypeRegularExpression, "regular-expression", CommandCompletions::eNoCompletion, { nullptr, false }, "A regular expression." },
+    { eArgTypeRegularExpression, "regular-expression", CommandCompletions::eNoCompletion, { nullptr, false }, "A POSIX-compliant extended regular expression." },
     { eArgTypeRunArgs, "run-args", CommandCompletions::eNoCompletion, { nullptr, false }, "Arguments to be passed to the target program when it starts executing." },
     { eArgTypeRunMode, "run-mode", CommandCompletions::eNoCompletion, { nullptr, false }, "Help text goes here." },
     { eArgTypeScriptedCommandSynchronicity, "script-cmd-synchronicity", CommandCompletions::eNoCompletion, { nullptr, false }, "The synchronicity to use to run scripted commands with regard to LLDB event system." },
     { eArgTypeScriptLang, "script-language", CommandCompletions::eNoCompletion, { nullptr, false }, "The scripting language to be used for script-based commands.  Currently only Python is valid." },
     { eArgTypeSearchWord, "search-word", CommandCompletions::eNoCompletion, { nullptr, false }, "Any word of interest for search purposes." },
     { eArgTypeSelector, "selector", CommandCompletions::eNoCompletion, { nullptr, false }, "An Objective-C selector name." },
     { eArgTypeSettingIndex, "setting-index", CommandCompletions::eNoCompletion, { nullptr, false }, "An index into a settings variable that is an array (try 'settings list' to see all the possible settings variables and their types)." },
     { eArgTypeSettingKey, "setting-key", CommandCompletions::eNoCompletion, { nullptr, false }, "A key into a settings variables that is a dictionary (try 'settings list' to see all the possible settings variables and their types)." },

lldb/trunk/source/Interpreter/CommandObjectRegexCommand.cpp

 
 // Destructor
 CommandObjectRegexCommand::~CommandObjectRegexCommand() {}
 
 bool CommandObjectRegexCommand::DoExecute(llvm::StringRef command,
                                           CommandReturnObject &result) {
   EntryCollection::const_iterator pos, end = m_entries.end();
   for (pos = m_entries.begin(); pos != end; ++pos) {
-    RegularExpression::Match regex_match(m_max_matches);
-
-    if (pos->regex.Execute(command, &regex_match)) {
+    llvm::SmallVector<llvm::StringRef, 4> matches;
+    if (pos->regex.Execute(command, &matches)) {
       std::string new_command(pos->command);
-      std::string match_str;
       char percent_var[8];
       size_t idx, percent_var_idx;
       for (uint32_t match_idx = 1; match_idx <= m_max_matches; ++match_idx) {
-        if (regex_match.GetMatchAtIndex(command, match_idx, match_str)) {
+        if (match_idx < matches.size()) {
+          const std::string match_str = matches[match_idx].str();
           const int percent_var_len =
               ::snprintf(percent_var, sizeof(percent_var), "%%%u", match_idx);
           for (idx = 0; (percent_var_idx = new_command.find(
                              percent_var, idx)) != std::string::npos;) {
             new_command.erase(percent_var_idx, percent_var_len);
             new_command.insert(percent_var_idx, match_str);
             idx += percent_var_idx + match_str.size();
           }

lldb/trunk/source/Interpreter/OptionArgParser.cpp

if (expr_result == eExpressionCompleted) {
     }
 
   } else {
     // Since the compiler can't handle things like "main + 12" we should try to
     // do this for now. The compiler doesn't like adding offsets to function
     // pointer types.
     static RegularExpression g_symbol_plus_offset_regex(
         "^(.*)([-\\+])[[:space:]]*(0x[0-9A-Fa-f]+|[0-9]+)[[:space:]]*$");
-    RegularExpression::Match regex_match(3);
-    if (g_symbol_plus_offset_regex.Execute(sref, &regex_match)) {
-      uint64_t offset = 0;
-      bool add = true;
-      std::string name;
-      std::string str;
-      if (regex_match.GetMatchAtIndex(s, 1, name)) {
-        if (regex_match.GetMatchAtIndex(s, 2, str)) {
-          add = str[0] == '+';
 
-          if (regex_match.GetMatchAtIndex(s, 3, str)) {
-            if (!llvm::StringRef(str).getAsInteger(0, offset)) {
-              Status error;
-              addr = ToAddress(exe_ctx, name.c_str(), LLDB_INVALID_ADDRESS,
-                               &error);
-              if (addr != LLDB_INVALID_ADDRESS) {
-                if (add)
-                  return addr + offset;
-                else
-                  return addr - offset;
-              }
-            }
-          }
-        }
-      }
-    }
+    llvm::SmallVector<llvm::StringRef, 4> matches;
+    if (g_symbol_plus_offset_regex.Execute(sref, &matches)) {
+      uint64_t offset = 0;
+      std::string name = matches[1].str();
+      std::string sign = matches[2].str();
+      std::string str_offset = matches[3].str();
+      if (!llvm::StringRef(str_offset).getAsInteger(0, offset)) {
+        addr = ToAddress(exe_ctx, name.c_str(), LLDB_INVALID_ADDRESS, &error);
+          if (sign[0] == '+')
 
     if (error_ptr) {
       error_set = true;
       error_ptr->SetErrorStringWithFormat(
           "address expression \"%s\" evaluation failed", s.str().c_str());
     }
   }
 
   if (error_ptr) {
     if (!error_set)
       error_ptr->SetErrorStringWithFormat("invalid address expression \"%s\"",
                                           s.str().c_str());
   }
   return fail_value;
 }

lldb/trunk/source/Interpreter/OptionValueRegex.cpp

case eVarSetOperationClear:
     NotifyValueChanged();
     break;
 
   case eVarSetOperationReplace:
   case eVarSetOperationAssign:
     if (m_regex.Compile(value)) {
       m_value_was_set = true;
       NotifyValueChanged();
+    } else if (llvm::Error err = m_regex.GetError()) {
+      error.SetErrorString(llvm::toString(std::move(err)));
     } else {
-      char regex_error[1024];
-      if (m_regex.GetErrorAsCString(regex_error, sizeof(regex_error)))
-        error.SetErrorString(regex_error);
-      else
-        error.SetErrorStringWithFormat("regex error %u",
-                                       m_regex.GetErrorCode());
+      error.SetErrorString("regex error");
     }
     break;
   }
   return error;
 }
 
 lldb::OptionValueSP OptionValueRegex::DeepCopy() const {
   return OptionValueSP(new OptionValueRegex(m_regex.GetText().str().c_str()));
 }

lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp

if (m_opcode.GetData(data)) {
             else
               m_does_branch = eLazyBoolNo;
           }
         }
 
         static RegularExpression s_regex(
             llvm::StringRef("[ \t]*([^ ^\t]+)[ \t]*([^ ^\t].*)?"));
 
-        RegularExpression::Match matches(3);
-
+        llvm::SmallVector<llvm::StringRef, 4> matches;
         if (s_regex.Execute(out_string, &matches)) {
-          matches.GetMatchAtIndex(out_string.c_str(), 1, m_opcode_name);
-          matches.GetMatchAtIndex(out_string.c_str(), 2, m_mnemonics);
+          m_opcode_name = matches[1].str();
+          m_mnemonics = matches[2].str();
         }
       }
     }
   }
 
   bool IsValid() const { return m_is_valid; }
 
   bool UsingFileAddress() const { return m_using_file_addr; }

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

 bool ParseCoordinate(llvm::StringRef coord_s, RSCoordinate &coord) {
   // takes an argument of the form 'num[,num][,num]'. Where 'coord_s' is a
   // comma separated 1,2 or 3-dimensional coordinate with the whitespace
   // trimmed. Missing coordinates are defaulted to zero. If parsing of any
   // elements fails the contents of &coord are undefined and `false` is
   // returned, `true` otherwise
 
   RegularExpression regex;
-  RegularExpression::Match regex_match(3);
+  llvm::SmallVector<llvm::StringRef, 4> matches;
 
   bool matched = false;
   if (regex.Compile(llvm::StringRef("^([0-9]+),([0-9]+),([0-9]+)$")) &&
-      regex.Execute(coord_s, &regex_match))
+      regex.Execute(coord_s, &matches))
     matched = true;
   else if (regex.Compile(llvm::StringRef("^([0-9]+),([0-9]+)$")) &&
-           regex.Execute(coord_s, &regex_match))
+           regex.Execute(coord_s, &matches))
     matched = true;
   else if (regex.Compile(llvm::StringRef("^([0-9]+)$")) &&
-           regex.Execute(coord_s, &regex_match))
+           regex.Execute(coord_s, &matches))
     matched = true;
 
   if (!matched)
     return false;
 
-  auto get_index = [&](int idx, uint32_t &i) -> bool {
+  auto get_index = [&](size_t idx, uint32_t &i) -> bool {
     std::string group;
     errno = 0;
-    if (regex_match.GetMatchAtIndex(coord_s.str().c_str(), idx + 1, group))
-      return !llvm::StringRef(group).getAsInteger<uint32_t>(10, i);
+    if (idx + 1 < matches.size()) {
+      return !llvm::StringRef(matches[idx + 1]).getAsInteger<uint32_t>(10, i);
+    }
     return true;
   };
 
   return get_index(0, coord.x) && get_index(1, coord.y) &&
          get_index(2, coord.z);
 }
 
 bool SkipPrologue(lldb::ModuleSP &module, Address &addr) {
bool ParseReductionTypes(llvm::StringRef option_val,
             // Currently not exposed by the runtime
             // .Case("halter", RSReduceBreakpointResolver::eKernelTypeHalter)
             .Default(0);
       };
 
       // Matching a comma separated list of known words is fairly
       // straightforward with PCRE, but we're using ERE, so we end up with a
       // little ugliness...
-      RegularExpression::Match match(/* max_matches */ 5);
       RegularExpression match_type_list(
           llvm::StringRef("^([[:alpha:]]+)(,[[:alpha:]]+){0,4}$"));
 
       assert(match_type_list.IsValid());
 
-      if (!match_type_list.Execute(option_val, &match)) {
+      if (!match_type_list.Execute(option_val)) {
         err_str.PutCString(
             "a comma-separated list of kernel types is required");
         return false;
       }
 
       // splitting on commas is much easier with llvm::StringRef than regex
       llvm::SmallVector<llvm::StringRef, 5> type_names;
       llvm::StringRef(option_val).split(type_names, ',');

lldb/trunk/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

if (reg_info.byte_offset == UINT32_MAX) {
         //  REGNAME[MSBIT:LSBIT]
         // REGNAME - name of the register to grab a slice of
         // MSBIT - the most significant bit at which the current register value
         // starts at
         // LSBIT - the least significant bit at which the current register value
         // ends at
         static RegularExpression g_bitfield_regex(
             llvm::StringRef("([A-Za-z_][A-Za-z0-9_]*)\\[([0-9]+):([0-9]+)\\]"));
-        RegularExpression::Match regex_match(3);
-        if (g_bitfield_regex.Execute(slice_str, &regex_match)) {
-          llvm::StringRef reg_name_str;
-          std::string msbit_str;
-          std::string lsbit_str;
-          if (regex_match.GetMatchAtIndex(slice_str, 1, reg_name_str) &&
-              regex_match.GetMatchAtIndex(slice_str, 2, msbit_str) &&
-              regex_match.GetMatchAtIndex(slice_str, 3, lsbit_str)) {
-            const uint32_t msbit =
-                StringConvert::ToUInt32(msbit_str.c_str(), UINT32_MAX);
-            const uint32_t lsbit =
-                StringConvert::ToUInt32(lsbit_str.c_str(), UINT32_MAX);
-            if (msbit != UINT32_MAX && lsbit != UINT32_MAX) {
-              if (msbit > lsbit) {
-                const uint32_t msbyte = msbit / 8;
-                const uint32_t lsbyte = lsbit / 8;
+        llvm::SmallVector<llvm::StringRef, 4> matches;
+        if (g_bitfield_regex.Execute(slice_str, &matches)) {
+          std::string reg_name_str = matches[1].str();
+          std::string msbit_str = matches[2].str();
+          std::string lsbit_str = matches[3].str();
 
-                ConstString containing_reg_name(reg_name_str);
 
-                const RegisterInfo *containing_reg_info =
-                    GetRegisterInfo(containing_reg_name);
-                if (containing_reg_info) {
-                  const uint32_t max_bit = containing_reg_info->byte_size * 8;
-                  if (msbit < max_bit && lsbit < max_bit) {
-                    m_invalidate_regs_map[containing_reg_info
-                                              ->kinds[eRegisterKindLLDB]]
-                        .push_back(i);
-                    m_value_regs_map[i].push_back(
-                        containing_reg_info->kinds[eRegisterKindLLDB]);
-                    m_invalidate_regs_map[i].push_back(
-                        containing_reg_info->kinds[eRegisterKindLLDB]);
 
-                    if (byte_order == eByteOrderLittle) {
-                      success = true;
-                      reg_info.byte_offset =
-                          containing_reg_info->byte_offset + lsbyte;
-                    } else if (byte_order == eByteOrderBig) {
-                      success = true;
-                      reg_info.byte_offset =
-                          containing_reg_info->byte_offset + msbyte;
-                    } else {
-                      llvm_unreachable("Invalid byte order");
-                    }
-                  } else {
-                    if (msbit > max_bit)
-                      printf("error: msbit (%u) must be less than the bitsize "
-                             "of the register (%u)\n",
-                             msbit, max_bit);
-                    else
-                      printf("error: lsbit (%u) must be less than the bitsize "
-                             "of the register (%u)\n",
-                             lsbit, max_bit);
-                  }
-                } else {
-                  printf("error: invalid concrete register \"%s\"\n",
-                         containing_reg_name.GetCString());
-                }
-              } else {
-                printf("error: msbit (%u) must be greater than lsbit (%u)\n",
-                       msbit, lsbit);
-              }
-            } else {
-              printf("error: msbit (%u) and lsbit (%u) must be valid\n", msbit,
-                     lsbit);
-            }
-          } else {
-            // TODO: print error invalid slice string that doesn't follow the
-            // format
-            printf("error: failed to extract regex matches for parsing the "
-                   "register bitfield regex\n");
-          }
-        } else {
-          // TODO: print error invalid slice string that doesn't follow the
-          // format
           printf("error: failed to match against register bitfield regex\n");
         }
       } else {
         StructuredData::Array *composite_reg_list = nullptr;
         if (reg_info_dict->GetValueForKeyAsArray("composite",
                                                  composite_reg_list)) {
           const size_t num_composite_regs = composite_reg_list->GetSize();
           if (num_composite_regs > 0) {

lldb/trunk/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

static FilterRuleSP CreateOperation(bool accept, size_t attribute_index,
     if (op_arg.empty()) {
       error.SetErrorString("regex filter type requires a regex "
                            "argument");
       return FilterRuleSP();
     }
 
     // Instantiate the regex so we can report any errors.
     auto regex = RegularExpression(op_arg);
-    if (!regex.IsValid()) {
-      char error_text[256];
-      error_text[0] = '\0';
-      regex.GetErrorAsCString(error_text, sizeof(error_text));
-      error.SetErrorString(error_text);
+    if (llvm::Error err = regex.GetError()) {
+      error.SetErrorString(llvm::toString(std::move(err)));
       return FilterRuleSP();
     }
 
     // We passed all our checks, this appears fine.
     error.Clear();
     return FilterRuleSP(new RegexFilterRule(accept, attribute_index, op_arg));
   }
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

if (producer_cstr) {
           llvm::StringRef("^4\\.[012]\\.[01] \\(Based on Apple "
                           "Inc\\. build [0-9]+\\) \\(LLVM build "
                           "[\\.0-9]+\\)$"));
       if (llvm_gcc_regex.Execute(llvm::StringRef(producer_cstr))) {
         m_producer = eProducerLLVMGCC;
       } else if (strstr(producer_cstr, "clang")) {
         static RegularExpression g_clang_version_regex(
             llvm::StringRef("clang-([0-9]+)\\.([0-9]+)\\.([0-9]+)"));
-        RegularExpression::Match regex_match(3);
+        llvm::SmallVector<llvm::StringRef, 4> matches;
         if (g_clang_version_regex.Execute(llvm::StringRef(producer_cstr),
-                                          &regex_match)) {
-          std::string str;
-          if (regex_match.GetMatchAtIndex(producer_cstr, 1, str))
-            m_producer_version_major =
-                StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
-          if (regex_match.GetMatchAtIndex(producer_cstr, 2, str))
-            m_producer_version_minor =
-                StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
-          if (regex_match.GetMatchAtIndex(producer_cstr, 3, str))
-            m_producer_version_update =
-                StringConvert::ToUInt32(str.c_str(), UINT32_MAX, 10);
+                                          &matches)) {
+              StringConvert::ToUInt32(matches[1].str().c_str(), UINT32_MAX, 10);
+              StringConvert::ToUInt32(matches[2].str().c_str(), UINT32_MAX, 10);
+              StringConvert::ToUInt32(matches[3].str().c_str(), UINT32_MAX, 10);
         }
         m_producer = eProducerClang;
       } else if (strstr(producer_cstr, "GNU"))
         m_producer = eProducerGCC;
     }
   }
   if (m_producer == eProducerInvalid)
     m_producer = eProcucerOther;

lldb/trunk/source/Symbol/ObjectFile.cpp

return GetData(section->GetFileOffset(), section->GetFileSize(),
                    section_data);
   }
 }
 
 bool ObjectFile::SplitArchivePathWithObject(const char *path_with_object,
                                             FileSpec &archive_file,
                                             ConstString &archive_object,
                                             bool must_exist) {
+  llvm::SmallVector<llvm::StringRef, 3> matches;
   RegularExpression g_object_regex(llvm::StringRef("(.*)\\(([^\\)]+)\\)$"));
-  RegularExpression::Match regex_match(2);
   if (g_object_regex.Execute(llvm::StringRef::withNullAsEmpty(path_with_object),
-                             &regex_match)) {
-    std::string path;
-    std::string obj;
-    if (regex_match.GetMatchAtIndex(path_with_object, 1, path) &&
-        regex_match.GetMatchAtIndex(path_with_object, 2, obj)) {
-      archive_file.SetFile(path, FileSpec::Style::native);
-      archive_object.SetCString(obj.c_str());
-      return !(must_exist && !FileSystem::Instance().Exists(archive_file));
-    }
-  }
+                             &matches)) {
+    std::string path = matches[1].str();
+    std::string obj = matches[2].str();
   return false;
 }
 
 void ObjectFile::ClearSymtab() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));

lldb/trunk/source/Symbol/Variable.cpp

if (error.Success()) {
       error.SetErrorString("unknown error");
     }
     return error;
   } break;
 
   default: {
     static RegularExpression g_regex(
         llvm::StringRef("^([A-Za-z_:][A-Za-z_0-9:]*)(.*)"));
-    RegularExpression::Match regex_match(1);
-    std::string variable_name;
+    llvm::SmallVector<llvm::StringRef, 2> matches;
     variable_list.Clear();
-    if (!g_regex.Execute(variable_expr_path, &regex_match)) {
-      error.SetErrorStringWithFormat(
-          "unable to extract a variable name from '%s'",
-          variable_expr_path.str().c_str());
-      return error;
-    }
-    if (!regex_match.GetMatchAtIndex(variable_expr_path, 1, variable_name)) {
+    if (!g_regex.Execute(variable_expr_path, &matches)) {
       error.SetErrorStringWithFormat(
           "unable to extract a variable name from '%s'",
           variable_expr_path.str().c_str());
       return error;
     }
+    std::string variable_name = matches[1].str();
     if (!callback(baton, variable_name.c_str(), variable_list)) {
       error.SetErrorString("unknown error");
       return error;
     }
     uint32_t i = 0;
     while (i < variable_list.GetSize()) {
       VariableSP var_sp(variable_list.GetVariableAtIndex(i));
       ValueObjectSP valobj_sp;

lldb/trunk/source/Target/ThreadPlanStepInRange.cpp

bool ThreadPlanStepInRange::FrameMatchesAvoidCriteria() {
   if (avoid_regexp_to_use != nullptr) {
     SymbolContext sc = frame->GetSymbolContext(
         eSymbolContextFunction | eSymbolContextBlock | eSymbolContextSymbol);
     if (sc.symbol != nullptr) {
       const char *frame_function_name =
           sc.GetFunctionName(Mangled::ePreferDemangledWithoutArguments)
               .GetCString();
       if (frame_function_name) {
-        size_t num_matches = 0;
-        Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
-        if (log)
-          num_matches = 1;
-
-        RegularExpression::Match regex_match(num_matches);
-
+        llvm::SmallVector<llvm::StringRef, 2> matches;
         bool return_value =
-            avoid_regexp_to_use->Execute(frame_function_name, &regex_match);
-        if (return_value) {
-          if (log) {
-            std::string match;
-            regex_match.GetMatchAtIndex(frame_function_name, 0, match);
-            LLDB_LOGF(log,
-                      "Stepping out of function \"%s\" because it matches "
-                      "the avoid regexp \"%s\" - match substring: \"%s\".",
-                      frame_function_name,
-                      avoid_regexp_to_use->GetText().str().c_str(),
-                      match.c_str());
-          }
-        }
+            avoid_regexp_to_use->Execute(frame_function_name, &matches);
+        if (return_value && matches.size() > 1) {
+          std::string match = matches[1].str();
+          LLDB_LOGF(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP),
         return return_value;
       }
     }
   }
   return false;
 }
 
 bool ThreadPlanStepInRange::DefaultShouldStopHereCallback(

lldb/trunk/source/Utility/RegularExpression.cpp

 //===-- RegularExpression.cpp -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/RegularExpression.h"
 
-#include "llvm/ADT/StringRef.h"
-
 #include <string>
 
-// Enable enhanced mode if it is available. This allows for things like \d for
-// digit, \s for space, and many more, but it isn't available everywhere.
-#if defined(REG_ENHANCED)
-#define DEFAULT_COMPILE_FLAGS (REG_ENHANCED | REG_EXTENDED)
-#else
-#define DEFAULT_COMPILE_FLAGS (REG_EXTENDED)
-#endif
-
 using namespace lldb_private;
 
-RegularExpression::RegularExpression() : m_re(), m_comp_err(1), m_preg() {
-  memset(&m_preg, 0, sizeof(m_preg));
-}
-
-// Constructor that compiles "re" using "flags" and stores the resulting
-// compiled regular expression into this object.
-RegularExpression::RegularExpression(llvm::StringRef str)
-    : RegularExpression() {
-  Compile(str);
-}
+RegularExpression::RegularExpression(llvm::StringRef str) { Compile(str); }
 
 RegularExpression::RegularExpression(const RegularExpression &rhs)
     : RegularExpression() {
   Compile(rhs.GetText());
 }
 
-const RegularExpression &RegularExpression::
-operator=(const RegularExpression &rhs) {
-  if (&rhs != this)
-    Compile(rhs.GetText());
-  return *this;
-}
-
-// Destructor
-//
-// Any previously compiled regular expression contained in this object will be
-// freed.
-RegularExpression::~RegularExpression() { Free(); }
-
-// Compile a regular expression using the supplied regular expression text and
-// flags. The compiled regular expression lives in this object so that it can
-// be readily used for regular expression matches. Execute() can be called
-// after the regular expression is compiled. Any previously compiled regular
-// expression contained in this object will be freed.
-//
-// RETURNS
-//  True if the regular expression compiles successfully, false
-//  otherwise.
 bool RegularExpression::Compile(llvm::StringRef str) {
-  Free();
-
-  // regcomp() on darwin does not recognize "" as a valid regular expression,
-  // so we substitute it with an equivalent non-empty one.
-  m_re = str.empty() ? "()" : str;
-  m_comp_err = ::regcomp(&m_preg, m_re.c_str(), DEFAULT_COMPILE_FLAGS);
-  return m_comp_err == 0;
+  m_regex_text = str;
+  m_regex = llvm::Regex(str);
+  return IsValid();
 }
 
-// Execute a regular expression match using the compiled regular expression
-// that is already in this object against the match string "s". If any parens
-// are used for regular expression matches "match_count" should indicate the
-// number of regmatch_t values that are present in "match_ptr". The regular
-// expression will be executed using the "execute_flags".
-bool RegularExpression::Execute(llvm::StringRef str, Match *match) const {
-  int err = 1;
-  if (m_comp_err == 0) {
-    // Argument to regexec must be null-terminated.
-    std::string reg_str = str;
-    if (match) {
-      err = ::regexec(&m_preg, reg_str.c_str(), match->GetSize(),
-                      match->GetData(), 0);
-    } else {
-      err = ::regexec(&m_preg, reg_str.c_str(), 0, nullptr, 0);
-    }
-  }
+bool RegularExpression::Execute(
+    llvm::StringRef str,
+    llvm::SmallVectorImpl<llvm::StringRef> *matches) const {
+  return m_regex.match(str, matches);
 
-  if (err != 0) {
-    // The regular expression didn't compile, so clear the matches
-    if (match)
-      match->Clear();
-    return false;
-  }
-  return true;
+bool RegularExpression::IsValid() const {
+  std::string discarded;
+  return m_regex.isValid(discarded);
 }
 
-bool RegularExpression::Match::GetMatchAtIndex(llvm::StringRef s, uint32_t idx,
-                                               std::string &match_str) const {
-  llvm::StringRef match_str_ref;
-  if (GetMatchAtIndex(s, idx, match_str_ref)) {
-    match_str = match_str_ref.str();
-    return true;
-  }
-  return false;
-}
-
-bool RegularExpression::Match::GetMatchAtIndex(
-    llvm::StringRef s, uint32_t idx, llvm::StringRef &match_str) const {
-  if (idx < m_matches.size()) {
-    if (m_matches[idx].rm_eo == -1 && m_matches[idx].rm_so == -1)
-      return false;
-
-    if (m_matches[idx].rm_eo == m_matches[idx].rm_so) {
-      // Matched the empty string...
-      match_str = llvm::StringRef();
-      return true;
-    } else if (m_matches[idx].rm_eo > m_matches[idx].rm_so) {
-      match_str = s.substr(m_matches[idx].rm_so,
-                           m_matches[idx].rm_eo - m_matches[idx].rm_so);
-      return true;
-    }
-  }
-  return false;
-}
-
-// Returns true if the regular expression compiled and is ready for execution.
-bool RegularExpression::IsValid() const { return m_comp_err == 0; }
-
-// Returns the text that was used to compile the current regular expression.
-llvm::StringRef RegularExpression::GetText() const { return m_re; }
-
-// Free any contained compiled regular expressions.
-void RegularExpression::Free() {
-  if (m_comp_err == 0) {
-    m_re.clear();
-    regfree(&m_preg);
-    // Set a compile error since we no longer have a valid regex
-    m_comp_err = 1;
-  }
-}
-
-size_t RegularExpression::GetErrorAsCString(char *err_str,
-                                            size_t err_str_max_len) const {
-  if (m_comp_err == 0) {
-    if (err_str && err_str_max_len)
-      *err_str = '\0';
-    return 0;
-  }
-
-  return ::regerror(m_comp_err, &m_preg, err_str, err_str_max_len);
-}
+llvm::StringRef RegularExpression::GetText() const { return m_regex_text; }
 
-bool RegularExpression::operator<(const RegularExpression &rhs) const {
-  return (m_re < rhs.m_re);
+llvm::Error RegularExpression::GetError() const {
+  std::string error;
+  if (!m_regex.isValid(error))
+    return llvm::make_error<llvm::StringError>(llvm::inconvertibleErrorCode(),
+                                               error);
+  return llvm::Error::success();
 }

lldb/trunk/unittests/Utility/CMakeLists.txt

add_lldb_unittest(UtilityTests
   ListenerTest.cpp
   LogTest.cpp
   NameMatchesTest.cpp
   PredicateTest.cpp
   ProcessInfoTest.cpp
   RangeMapTest.cpp
   RangeTest.cpp
   RegisterValueTest.cpp
-  ReproducerTest.cpp
+  RegularExpressionTest.cpp
   ReproducerInstrumentationTest.cpp
+  ReproducerTest.cpp
   ScalarTest.cpp
   StateTest.cpp
   StatusTest.cpp
   StreamTeeTest.cpp
   StreamTest.cpp
   StringExtractorTest.cpp
   StringLexerTest.cpp
   StringListTest.cpp

lldb/trunk/unittests/Utility/NameMatchesTest.cpp

TEST(NameMatchesTest, EndsWith) {
   EXPECT_TRUE(NameMatches("", NameMatch::EndsWith, ""));
   EXPECT_FALSE(NameMatches("foo", NameMatch::EndsWith, "b"));
   EXPECT_FALSE(NameMatches("", NameMatch::EndsWith, "b"));
 }
 
 TEST(NameMatchesTest, RegularExpression) {
   EXPECT_TRUE(NameMatches("foobar", NameMatch::RegularExpression, "foo"));
   EXPECT_TRUE(NameMatches("foobar", NameMatch::RegularExpression, "f[oa]o"));
-  EXPECT_TRUE(NameMatches("foo", NameMatch::RegularExpression, ""));
-  EXPECT_TRUE(NameMatches("", NameMatch::RegularExpression, ""));
+  EXPECT_FALSE(NameMatches("foo", NameMatch::RegularExpression, ""));
+  EXPECT_FALSE(NameMatches("", NameMatch::RegularExpression, ""));
   EXPECT_FALSE(NameMatches("foo", NameMatch::RegularExpression, "b"));
   EXPECT_FALSE(NameMatches("", NameMatch::RegularExpression, "b"));
   EXPECT_FALSE(NameMatches("^a", NameMatch::RegularExpression, "^a"));
 }

lldb/trunk/unittests/Utility/RegularExpressionTest.cpp

+//===-- RegularExpressionTest.cpp -----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/RegularExpression.h"
+#include "llvm/ADT/SmallVector.h"
+#include "gtest/gtest.h"
+
+using namespace lldb_private;
+using namespace llvm;
+
+TEST(RegularExpression, Valid) {
+  RegularExpression r1("^[0-9]+$");
+  cantFail(r1.GetError());
+  EXPECT_TRUE(r1.IsValid());
+  EXPECT_EQ("^[0-9]+$", r1.GetText());
+  EXPECT_TRUE(r1.Execute("916"));
+}
+
+TEST(RegularExpression, CopyAssignment) {
+  RegularExpression r1("^[0-9]+$");
+  RegularExpression r2 = r1;
+  cantFail(r2.GetError());
+  EXPECT_TRUE(r2.IsValid());
+  EXPECT_EQ("^[0-9]+$", r2.GetText());
+  EXPECT_TRUE(r2.Execute("916"));
+}
+
+TEST(RegularExpression, Empty) {
+  RegularExpression r1("");
+  Error err = r1.GetError();
+  EXPECT_TRUE(static_cast<bool>(err));
+  consumeError(std::move(err));
+  EXPECT_FALSE(r1.IsValid());
+  EXPECT_EQ("", r1.GetText());
+  EXPECT_FALSE(r1.Execute("916"));
+}
+
+TEST(RegularExpression, Invalid) {
+  RegularExpression r1("a[b-");
+  Error err = r1.GetError();
+  EXPECT_TRUE(static_cast<bool>(err));
+  consumeError(std::move(err));
+  EXPECT_FALSE(r1.IsValid());
+  EXPECT_EQ("a[b-", r1.GetText());
+  EXPECT_FALSE(r1.Execute("ab"));
+}
+
+TEST(RegularExpression, Match) {
+  RegularExpression r1("[0-9]+([a-f])?:([0-9]+)");
+  cantFail(r1.GetError());
+  EXPECT_TRUE(r1.IsValid());
+  EXPECT_EQ("[0-9]+([a-f])?:([0-9]+)", r1.GetText());
+
+  SmallVector<StringRef, 3> matches;
+  EXPECT_TRUE(r1.Execute("9a:513b", &matches));
+  EXPECT_EQ(3u, matches.size());
+  EXPECT_EQ("9a:513", matches[0].str());
+  EXPECT_EQ("a", matches[1].str());
+  EXPECT_EQ("513", matches[2].str());
+}