Change llvm::Regex to expose a fallible constructor.

[dlj]

Summary

Currently, if llvm::Regex is constructed with an invalid pattern, it only
exposes this fact if the call site checks isValid(). The Regex class itself also
statefully maintains a (mutable) error code internally, which means its match()
function is not const.

This change adds a "fallible constructor" to llvm::Regex:
http://llvm.org/docs/ProgrammersManual.html#fallible-constructors
and then plumbs it through LLVM code. (Follow-up changes are prepared to update
uses in Clang.)

I plan to expand RegexError to handle the error values directly (see regerror.c)
and return it from match(), which will remove the last of the error state from
Regex, allowing match() to become const. Right away, though, this change deletes
the last vestiges of stateful error codes from the internal regex implementation
(regexec.c). This allows constructing cheap errors that require only the code,
and do not need to refer to the compiled regex. These error cases (REG_ATOI and
REG_ITOA) never happen in LLVM code, and are not POSIX-standard.

[vsk]

If the goal is to make sure regex errors are checked, we could avoid a substantial amount of API churn by asserting 'no error' in every method in Regex.

If you also want to make match() const, we'll need to get rid of the isValid method and the error field. That probably means adding an optional out-param to the Regex constructor for error descriptions.

[dlj]

• Add comments for unhandled errors that will assert-fail.
• Augment error handling in LinePrinter.
• Fix a broken regex in ARMScheduleR52.td (empty subexpressions are not allowed by our regex library).

[dlj]

In D27463#615399, @vsk wrote:

If the goal is to make sure regex errors are checked, we could avoid a substantial amount of API churn by asserting 'no error' in every method in Regex.

That's the end goal I'm aiming for in the current change, but by a different route: for regexes compiled from static char[] constants, I'm just letting the Expected<Regex> propagate the error. It's a bit subtle, but I'll add comments. With asserts disabled, a failed compilation for a constant will simply look like it didn't match.

For "constants," I think this is the right thing. It limits API churn, since things that should never fail don't need to propagate an error, they just assert. For non-constants, I'm intending to propagate errors in whatever way is consistent.

(Perhaps unsurprisingly, there are, in fact, some broken regex literals in the code base.)

If you also want to make match() const, we'll need to get rid of the isValid method and the error field. That probably means adding an optional out-param to the Regex constructor for error descriptions.

Right, I was planning to eliminate the error field in a separate change. The Expected<> wrapper obviates the need for an out-parameter to the constructor, though. Anywhere an out-param would be used can use the Expected<> instead.

[dlj]

In D27463#616162, @dlj wrote:

In D27463#615399, @vsk wrote:

If the goal is to make sure regex errors are checked, we could avoid a substantial amount of API churn by asserting 'no error' in every method in Regex.

That's the end goal I'm aiming for in the current change, but by a different route: for regexes compiled from static char[] constants, I'm just letting the Expected<Regex> propagate the error.

err, rather, *not* propagate the error -- and crash with asserts enabled.

[vsk]

That's the end goal I'm aiming for in the current change, but by a different route: for regexes compiled from static char[] constants, I'm just letting the Expected<Regex> propagate the error.

err, rather, *not* propagate the error -- and crash with asserts enabled.

I think it'd be better to add in 'no error' asserts to the methods in Regex. The advantages are that (1) we can catch broken regexes / broken tests up front, instead of waiting for downstream projects to opt-in to the new constructor, (2) it doesn't require any code changes outside of the Regex class (except to fix broken code), and (3) it doesn't introduce any unchecked uses of Expected, which IMO is an abuse of the error handling API.

[dlj]

• Make Regex handle empty patterns without asserting an error.

[dlj]

In D27463#616195, @vsk wrote:

That's the end goal I'm aiming for in the current change, but by a different route: for regexes compiled from static char[] constants, I'm just letting the Expected<Regex> propagate the error.

err, rather, *not* propagate the error -- and crash with asserts enabled.

I think it'd be better to add in 'no error' asserts to the methods in Regex. The advantages are that (1) we can catch broken regexes / broken tests up front, instead of waiting for downstream projects to opt-in to the new constructor,

So just to be clear... you're proposing a different breaking change, such that an invalid regex causes an assertion failure, instead of silently clamping to "no match?" That still cements the need for the error field, though; and it also seems to block making match() const -- the semantics of isValid would silently change, such that isValid() would stop reporting errors that arise during match().

The alternative proposal also has a different, more philosophical problem: it opens a broad window for validation escape in new uses of Regex. I already see plenty of rollbacks for things that only fail with asserts enabled. Without a stronger contract of "never match an invalid regex," it would just add another sharp edge, and I'm worried it would start to cut. Making the error check part of the type seems like a reasonable speed bump to ensure that the right assumptions are being made.

As for the broken users: I'm fixing the ones within the LLVM projects now. Once those patches are in, I can get rid of the constructor (probably needs a short intermediate state for out-of-tree users to notice, though). It seems better to do the cleanup work now instead of "kicking the can" on the stateful error.

(2) it doesn't require any code changes outside of the Regex class (except to fix broken code),

This smells slightly like a false economy to me... there aren't many call sites, and I'm finding bugs already. I get why we wouldn't want a ton of churn, but the end state seems worth it to me (i.e., Regex becomes const-correct and has no internal error state).

(3) it doesn't introduce any unchecked uses of Expected, which IMO is an abuse of the error handling API.

Unfortunately, there just isn't a concise, usable alternative. Code with existing error paths are fine, but otherwise a debug-only assertion crash is probably the best alternative. (In fact, that's probably what I would do in most of those cases, anyhow).

One example (but not the only example) are AST matchers: the macro matchers are basically painted into an API corner, so an assertion really seems like the best option. I could probably add DEBUG() checks, but at least they can explicitly clamp to false in a release build.

Class constructors are another (plentiful) example: if there's a reasonable way to defer errors, I can do that now; but in many cases there isn't, so signalling the failure *somehow* -- even if it's only with debug assertions -- seems strictly superior.

[dlj]

Ping?

[rsmith]

Generally the new interface makes sense to me, but deliberately ignoring the error to provoke an assertion seems a bit subtle.

lib/IR/AutoUpgrade.cpp

106–107

Rather than adding this comment in various places, what do you think about also adding a static Regex Regex::compileKnownValid(StringRef) that encapsulates the compile + assert-if-not-valid logic?

[chandlerc]

include/llvm/Support/YAMLTraits.h

459–462

No need for braces IMO.

462–463

In addition to what Richard said, I would also try to use a pattern that ends up working more like:

if (auto MyMatcher = Regex::compile(...))
  return MyMatcher->match(...);
else
  llvm_unreachable("boom");

This will give us nice assert like behavior in assert builds and will actually kill the other edge in optimized builds.

lib/IR/DiagnosticInfo.cpp

44–54

Do you mind reflowing all of this to use early return so that there are less braces and indentation?

[dlj]

• Add comments for unhandled errors that will assert-fail, and augment error handling in LinePrinter.
• Added compileKnownGood, plus examples of llvm_unreachable approach.
• Minor style fixes.

[dlj]

• Style nits.

[dlj]

lib/IR/DiagnosticInfo.cpp

44–54

Better?

[chandlerc]

include/llvm/Support/YAMLTraits.h

462–463

I would just re-use compileKnownValid everywhere instead of having to inline the llvm_unreachable.

[chandlerc]

Haven't made it all the way through, but I think it would be helpful to apply some of the comments so far across all the changes here.

lib/Passes/PassBuilder.cpp

149–150

Is it important to use ExitOnError here? I'm thinkign something like compileKnownValid might be more appropriate.

lib/Support/SpecialCaseList.cpp

127

This isn't used any more. I think you can simplify the code a lot by just getting the error, and inverting the condition below.

157

This also seems like it could be compileKnownValid, as you have validated them above.

lib/Target/AArch64/Utils/AArch64BaseInfo.cpp

91–92

compileKnownValid again?

tools/llvm-cov/CodeCoverage.cpp

608–611

I still would prefer early error exiting here so:

auto RegexOrError = ...
if (!RegexORError) {
  ...
  return ...;
}
...

tools/llvm-pdbdump/LinePrinter.h

46–52

Use continue on error to reduce non-error indentation?

include/llvm/Support/Regex.h

 // to support backreferences in matches.
 // This implementation also supports matching strings with embedded NUL chars.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_REGEX_H
 #define LLVM_SUPPORT_REGEX_H
 
+#include "llvm/Support/Error.h"
 #include <string>
 
 struct llvm_regex;
 
 namespace llvm {
   class StringRef;
   template<typename T> class SmallVectorImpl;
 
+  /// An error from constructing or evaluating a regex.
+  class RegexError : public ErrorInfo<RegexError> {
+  public:
+    static char ID;
+
+    /// Constructs this error to describe \p EC (see regex_impl.h).
+    explicit RegexError(int EC);
+
+    void log(raw_ostream &OS) const override { OS << message(); }
+    std::string message() const override;
+    std::error_code convertToErrorCode() const override {
+      return llvm::inconvertibleErrorCode();
+    }
+
+  private:
+    int EC;
+  };
+
   class Regex {
   public:
     enum {
       NoFlags=0,
       /// Compile for matching that ignores upper/lower case distinctions.
       IgnoreCase=1,
       /// Compile for newline-sensitive matching. With this flag '[^' bracket
       /// expressions and '.' never match newline. A ^ anchor matches the
       /// null string after any newline in the string in addition to its normal
       /// function, and the $ anchor matches the null string before any
       /// newline in the string in addition to its normal function.
       Newline=2,
       /// By default, the POSIX extended regular expression (ERE) syntax is
       /// assumed. Pass this flag to turn on basic regular expressions (BRE)
       /// instead.
       BasicRegex=4
     };
 
+    /// Compiles the given regular expression \p Regex and returns it, or a
+    /// RegexError if the pattern is invalid.
+    static Expected<Regex> compile(StringRef Regex, unsigned Flags = NoFlags);
+
+    /// Compiles the given regular expression \p Regex and returns it.
+    /// Causes a runtime error if the expression is not valid.
+    static Regex compileKnownValid(StringRef Regex, unsigned Flags = NoFlags);
+
     Regex();
     /// Compiles the given regular expression \p Regex.
     Regex(StringRef Regex, unsigned Flags = NoFlags);
     Regex(const Regex &) = delete;
     Regex &operator=(Regex regex) {
       std::swap(preg, regex.preg);
       std::swap(error, regex.error);
       return *this;

include/llvm/Support/YAMLTraits.h

inline bool isNumber(StringRef S) {
 
   static const char DecChars[] = "0123456789";
   if (S.find_first_not_of(DecChars) == StringRef::npos)
     return true;
 
   if (S.equals(".inf") || S.equals(".Inf") || S.equals(".INF"))
     return true;
 
-  Regex FloatMatcher("^(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?$");
-  if (FloatMatcher.match(S))
-    return true;
-
-  return false;
+  if (auto FloatMatcher = Regex::compile(
+          "^(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?$"))
+    return FloatMatcher->match(S);
+  else
+    llvm_unreachable("invalid regex");
 }
 
 inline bool isNumeric(StringRef S) {
   if ((S.front() == '-' || S.front() == '+') && isNumber(S.drop_front()))
     return true;
 
   if (isNumber(S))
     return true;

lib/IR/AutoUpgrade.cpp

if (Name.startswith("arm.neon.vclz")) {
                                "llvm.ctlz." + Name.substr(14), F->getParent());
       return true;
     }
     if (Name.startswith("arm.neon.vcnt")) {
       NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::ctpop,
                                         F->arg_begin()->getType());
       return true;
     }
-    Regex vldRegex("^arm\\.neon\\.vld([1234]|[234]lane)\\.v[a-z0-9]*$");
+    auto vldRegex = Regex::compileKnownValid(
+        "^arm\\.neon\\.vld([1234]|[234]lane)\\.v[a-z0-9]*$");
     if (vldRegex.match(Name)) {
       auto fArgs = F->getFunctionType()->params();
       SmallVector<Type *, 4> Tys(fArgs.begin(), fArgs.end());
       // Can't use Intrinsic::getDeclaration here as the return types might
       // then only be structurally equal.
-      FunctionType* fType = FunctionType::get(F->getReturnType(), Tys, false);
-      NewFn = Function::Create(fType, F->getLinkage(),
-                               "llvm." + Name + ".p0i8", F->getParent());
+      FunctionType *fType = FunctionType::get(F->getReturnType(), Tys, false);
+      NewFn = Function::Create(fType, F->getLinkage(), "llvm." + Name + ".p0i8",
+                               F->getParent());
       return true;
     }
-    Regex vstRegex("^arm\\.neon\\.vst([1234]|[234]lane)\\.v[a-z0-9]*$");
-    if (vstRegex.match(Name)) {
+    auto vstRegex = Regex::compile(
+        "^arm\\.neon\\.vst([1234]|[234]lane)\\.v[a-z0-9]*$");
+    if (vstRegex && vstRegex->match(Name)) {
       static const Intrinsic::ID StoreInts[] = {Intrinsic::arm_neon_vst1,
                                                 Intrinsic::arm_neon_vst2,
                                                 Intrinsic::arm_neon_vst3,
                                                 Intrinsic::arm_neon_vst4};
 
       static const Intrinsic::ID StoreLaneInts[] = {
         Intrinsic::arm_neon_vst2lane, Intrinsic::arm_neon_vst3lane,
         Intrinsic::arm_neon_vst4lane

lib/IR/DiagnosticInfo.cpp

 /// -pass-remarks* command line flags. Passes whose name matches this regexp
 /// will emit a diagnostic when calling the associated diagnostic function
 /// (emitOptimizationRemark, emitOptimizationRemarkMissed or
 /// emitOptimizationRemarkAnalysis).
 struct PassRemarksOpt {
   std::shared_ptr<Regex> Pattern;
 
   void operator=(const std::string &Val) {
     // Create a regexp object to match pass names for emitOptimizationRemark.
-    if (!Val.empty()) {
-      Pattern = std::make_shared<Regex>(Val);
-      std::string RegexError;
-      if (!Pattern->isValid(RegexError))
-        report_fatal_error("Invalid regular expression '" + Val +
-                               "' in -pass-remarks: " + RegexError,
-                           false);
-    }
-  }
+    if (Val.empty())
+      return;
+
+    if (auto RegexOrError = Regex::compile(Val))
+      Pattern = std::make_shared<Regex>(std::move(*RegexOrError));
+    else
+      report_fatal_error(
+          "Invalid regular expression '" + Val +
+              "' in -pass-remarks: " + toString(RegexOrError.takeError()),
 };
 
 static PassRemarksOpt PassRemarksOptLoc;
 static PassRemarksOpt PassRemarksMissedOptLoc;
 static PassRemarksOpt PassRemarksAnalysisOptLoc;
 
 // -pass-remarks
 //    Command line flag to enable emitOptimizationRemark()

lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/Utils/SymbolRewriter.h"
 #include "llvm/Transforms/Vectorize/LoopVectorize.h"
 #include "llvm/Transforms/Vectorize/SLPVectorizer.h"
 
 #include <type_traits>
 
 using namespace llvm;
 
-static Regex DefaultAliasRegex("^(default|lto-pre-link|lto)<(O[0123sz])>$");
+static Regex DefaultAliasRegex = ExitOnError("invalid regex literal")(
+    Regex::compile("^(default|lto-pre-link|lto)<(O[0123sz])>$"));
 
 static bool isOptimizingForSize(PassBuilder::OptimizationLevel Level) {
   switch (Level) {
   case PassBuilder::O0:
   case PassBuilder::O1:
   case PassBuilder::O2:
   case PassBuilder::O3:
     return false;

lib/Support/Regex.cpp

 #include "llvm/Support/Regex.h"
 #include "regex_impl.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include <string>
 using namespace llvm;
 
+char RegexError::ID;
+
+RegexError::RegexError(int EC) : EC(EC) {}
+
+std::string RegexError::message() const {
+  size_t len = llvm_regerror(EC, nullptr, nullptr, 0);
+  std::string Msg;
+  Msg.resize(len - 1);
+  llvm_regerror(EC, nullptr, &Msg[0], len);
+  return Msg;
+}
+
+Expected<Regex> Regex::compile(StringRef regex, unsigned Flags) {
+  // An empty regex is a valid POSIX extended RE (POSIX 1003.2), but
+  // regcomp unconditionally reports REG_BADPAT.
+  if (regex.empty() && !(Flags&REG_BASIC))
+    return Regex();
+  Regex R(regex, Flags);
+  if (R.error) {
+    return make_error<RegexError>(R.error);
+  }
+  return std::move(R);
+}
+
+Regex Regex::compileKnownValid(StringRef regex, unsigned Flags) {
+  if (auto regexp = compile(regex, Flags))
+    return std::move(*regexp);
+  else
+    llvm_unreachable("bad regexp");
+}
+
 Regex::Regex() : preg(nullptr), error(REG_BADPAT) {}
 
 Regex::Regex(StringRef regex, unsigned Flags) {
   unsigned flags = 0;
   preg = new llvm_regex();
   preg->re_endp = regex.end();
   if (Flags & IgnoreCase) 
     flags |= REG_ICASE;
if (preg) {
     llvm_regfree(preg);
     delete preg;
   }
 }
 
 bool Regex::isValid(std::string &Error) {
   if (!error)
     return true;
-  
-  size_t len = llvm_regerror(error, preg, nullptr, 0);
-  
-  Error.resize(len - 1);
-  llvm_regerror(error, preg, &Error[0], len);
+  Error = RegexError(error).message();
   return false;
 }
 
 /// getNumMatches - In a valid regex, return the number of parenthesized
 /// matches it contains.
 unsigned Regex::getNumMatches() const {
   return preg->re_nsub;
 }

lib/Support/SpecialCaseList.cpp

for (auto I = Lines.begin(), E = Lines.end(); I != E; ++I, ++LineNo) {
 
     // Replace * with .*
     for (size_t pos = 0; (pos = Regexp.find('*', pos)) != std::string::npos;
          pos += strlen(".*")) {
       Regexp.replace(pos, strlen("*"), ".*");
     }
 
     // Check that the regexp is valid.
-    Regex CheckRE(Regexp);
-    std::string REError;
-    if (!CheckRE.isValid(REError)) {
+    Regex CheckRE;
+    if (auto RegexpOrError = Regex::compile(Regexp)) {
+      CheckRE = std::move(*RegexpOrError);
+    } else {
       Error = (Twine("malformed regex in line ") + Twine(LineNo) + ": '" +
-               SplitLine.second + "': " + REError).str();
+               SplitLine.second + "': " + toString(RegexpOrError.takeError()))
+                  .str();
       return false;
     }
 
     // Add this regexp into the proper group by its prefix.
     if (!Regexps[Prefix][Category].empty())
       Regexps[Prefix][Category] += "|";
     Regexps[Prefix][Category] += "^" + Regexp + "$";
   }
   return true;
 }
 
 void SpecialCaseList::compile() {
   assert(!IsCompiled && "compile() should only be called once");
   // Iterate through each of the prefixes, and create Regexs for them.
   for (StringMap<StringMap<std::string>>::const_iterator I = Regexps.begin(),
                                                          E = Regexps.end();
        I != E; ++I) {
     for (StringMap<std::string>::const_iterator II = I->second.begin(),
                                                 IE = I->second.end();
          II != IE; ++II) {
-      Entries[I->getKey()][II->getKey()].RegEx.reset(new Regex(II->getValue()));
+      // The regexes were validated above, when they were added to the
+      // Regexps map.
+      Entries[I->getKey()][II->getKey()].RegEx = llvm::make_unique<Regex>(
+          ExitOnError("combined validated regexes were somehow invalid")(
+              Regex::compile(II->getValue())));
     }
   }
   Regexps.clear();
   IsCompiled = true;
 }
 
 SpecialCaseList::~SpecialCaseList() {}
 

lib/Support/regerror.c

 #include "regex_impl.h"
 
 #include "regutils.h"
 
 #ifdef _MSC_VER
 #define snprintf _snprintf
 #endif
 
-static const char *regatoi(const llvm_regex_t *, char *, int);
-
 static struct rerr {
   int code;
   const char *name;
   const char *explain;
 } rerrs[] = {
   { REG_NOMATCH,  "REG_NOMATCH",  "llvm_regexec() failed to match" },
   { REG_BADPAT, "REG_BADPAT", "invalid regular expression" },
   { REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element" },

  = extern size_t llvm_regerror(int, const llvm_regex_t *, char *, size_t);
  */
 /* ARGSUSED */
 size_t
 llvm_regerror(int errcode, const llvm_regex_t *preg, char *errbuf, size_t errbuf_size)
 {
   struct rerr *r;
   size_t len;
-  int target = errcode &~ REG_ITOA;
+  int target = errcode;
   const char *s;
-  char convbuf[50];
 
-  if (errcode == REG_ATOI)
-    s = regatoi(preg, convbuf, sizeof convbuf);
-  else {
-    for (r = rerrs; r->code != 0; r++)
-      if (r->code == target)
-        break;
-  
-    if (errcode&REG_ITOA) {
-      if (r->code != 0) {
-        assert(strlen(r->name) < sizeof(convbuf));
-        (void) llvm_strlcpy(convbuf, r->name, sizeof convbuf);
-      } else
-        (void)snprintf(convbuf, sizeof convbuf,
-            "REG_0x%x", target);
-      s = convbuf;
-    } else
-      s = r->explain;
-  }
-
   len = strlen(s) + 1;
   if (errbuf_size > 0) {
     llvm_strlcpy(errbuf, s, errbuf_size);
   }
 
   return(len);
 }
-
-/*
- - regatoi - internal routine to implement REG_ATOI
- */
-static const char *
-regatoi(const llvm_regex_t *preg, char *localbuf, int localbufsize)
-{
-  struct rerr *r;
-
-  for (r = rerrs; r->code != 0; r++)
-    if (strcmp(r->name, preg->re_endp) == 0)
-      break;
-  if (r->code == 0)
-    return("0");
-
-  (void)snprintf(localbuf, localbufsize, "%d", r->code);
-  return(localbuf);
-}

lib/Support/regex_impl.h

 #define REG_EBRACE   9
 #define REG_BADBR 10
 #define REG_ERANGE  11
 #define REG_ESPACE  12
 #define REG_BADRPT  13
 #define REG_EMPTY 14
 #define REG_ASSERT  15
 #define REG_INVARG  16
-#define REG_ATOI  255 /* convert name to number (!) */
-#define REG_ITOA  0400  /* convert number to name (!) */
 
 /* llvm_regexec() flags */
 #define REG_NOTBOL  00001
 #define REG_NOTEOL  00002
 #define REG_STARTEND  00004
 #define REG_TRACE 00400 /* tracing of execution */
 #define REG_LARGE 01000 /* force large representation */
 #define REG_BACKR 02000 /* force use of backref code */

lib/Target/AArch64/Utils/AArch64BaseInfo.cpp

namespace llvm {
   namespace AArch64SysReg {
 #define GET_SYSREG_IMPL
 #include "AArch64GenSystemOperands.inc"
   }
 }
 
 uint32_t AArch64SysReg::parseGenericRegister(StringRef Name) {
   // Try to parse an S<op0>_<op1>_<Cn>_<Cm>_<op2> register name
-  Regex GenericRegPattern("^S([0-3])_([0-7])_C([0-9]|1[0-5])_C([0-9]|1[0-5])_([0-7])$");
+  auto GenericRegPattern = Regex::compile(
+      "^S([0-3])_([0-7])_C([0-9]|1[0-5])_C([0-9]|1[0-5])_([0-7])$");
 
   std::string UpperName = Name.upper();
   SmallVector<StringRef, 5> Ops;
-  if (!GenericRegPattern.match(UpperName, &Ops))
+  // Note that if GenericRegPattern failed to compile, this does not handle
+  // that error and will crash with asserts enabled.
+  if (GenericRegPattern && !GenericRegPattern->match(UpperName, &Ops))
     return -1;
 
   uint32_t Op0 = 0, Op1 = 0, CRn = 0, CRm = 0, Op2 = 0;
   uint32_t Bits;
   Ops[1].getAsInteger(10, Op0);
   Ops[2].getAsInteger(10, Op1);
   Ops[3].getAsInteger(10, CRn);
   Ops[4].getAsInteger(10, CRm);

lib/Target/ARM/ARMScheduleR52.td

def : InstRW<[R52WriteALU_EX2, R52Read_EX1], (instregex "AD(C|D)S?ri","ANDS?ri",
       "t2ORRri", "t2RSBS?ri", "t2SBCri")>;
 
 def : InstRW<[R52WriteALU_EX2, R52Read_EX1, R52Read_EX1], (instregex "AD(C|D)S?rr",
       "ANDS?rr", "BICS?rr", "CRC*", "EORrr", "ORRrr", "RSBrr", "RSCrr", "SBCrr",
       "t2AD(C|D)S?rr", "t2ANDS?rr", "t2BICS?rr", "t2CRC", "t2EORrr", "t2SBCrr")>;
 
 def : InstRW<[R52WriteALU_EX2, R52Read_EX1, R52Read_ISS], (instregex "AD(C|D)S?rsi",
       "ANDS?rsi", "BICS?rsi", "EORrsi", "ORRrsi", "RSBrsi", "RSCrsi", "SBCrsi",
-      "t2AD(|D)S?rsi", "t2ANDS?rsi", "t2BICS?rsi", "t2EORrsi", "t2ORRrsi", "t2RSBrsi", "t2SBCrsi")>;
+      "t2ADD?S?rsi", "t2ANDS?rsi", "t2BICS?rsi", "t2EORrsi", "t2ORRrsi", "t2RSBrsi", "t2SBCrsi")>;
 
 def : InstRW<[R52WriteALU_EX2, R52Read_EX1, R52Read_ISS, R52Read_ISS],
       (instregex "AD(C|D)S?rsr", "ANDS?rsr", "BICS?rsr", "EORrsr", "MVNS?sr",
       "ORRrsrr", "RSBrsr", "RSCrsr", "SBCrsr")>;
 
 def : InstRW<[R52WriteALU_EX1],
     (instregex "ADR", "MOVSi", "MOVSsi", "MOVST?i16*", "MVNS?s?i", "t2MOVS?si")>;
 

lib/Transforms/Utils/SymbolRewriter.cpp

 template <RewriteDescriptor::Type DT, typename ValueType,
           ValueType *(llvm::Module::*Get)(StringRef) const,
           iterator_range<typename iplist<ValueType>::iterator>
           (llvm::Module::*Iterator)()>
 bool PatternRewriteDescriptor<DT, ValueType, Get, Iterator>::
 performOnModule(Module &M) {
   bool Changed = false;
   for (auto &C : (M.*Iterator)()) {
+    auto RegexOrError = Regex::compile(Pattern);
+    if (!RegexOrError) {
+      report_fatal_error("unable to transform " + C.getName() + " in " +
+                         M.getModuleIdentifier() + ": " +
+                         toString(RegexOrError.takeError()));
+    }
     std::string Error;
-
-    std::string Name = Regex(Pattern).sub(Transform, C.getName(), &Error);
+    std::string Name = RegexOrError->sub(Transform, C.getName(), &Error);
     if (!Error.empty())
-      report_fatal_error("unable to transforn " + C.getName() + " in " +
+      report_fatal_error("unable to transform " + C.getName() + " in " +
                          M.getModuleIdentifier() + ": " + Error);
 
     if (C.getName() == Name)
       continue;
 
     if (GlobalObject *GO = dyn_cast<GlobalObject>(&C))
       rewriteComdat(M, GO, C.getName(), Name);
 
for (auto &Field : *Descriptor) {
     Value = dyn_cast<yaml::ScalarNode>(Field.getValue());
     if (!Value) {
       YS.printError(Field.getValue(), "descriptor value must be a scalar");
       return false;
     }
 
     KeyValue = Key->getValue(KeyStorage);
     if (KeyValue.equals("source")) {
-      std::string Error;
-
       Source = Value->getValue(ValueStorage);
-      if (!Regex(Source).isValid(Error)) {
-        YS.printError(Field.getKey(), "invalid regex: " + Error);
+      auto RegexOrError = Regex::compile(Source);
+      if (!RegexOrError) {
+        YS.printError(Field.getKey(),
+                      "invalid regex: " + toString(RegexOrError.takeError()));
         return false;
       }
     } else if (KeyValue.equals("target")) {
       Target = Value->getValue(ValueStorage);
     } else if (KeyValue.equals("transform")) {
       Transform = Value->getValue(ValueStorage);
     } else if (KeyValue.equals("naked")) {
       std::string Undecorated;
for (auto &Field : *Descriptor) {
     Value = dyn_cast<yaml::ScalarNode>(Field.getValue());
     if (!Value) {
       YS.printError(Field.getValue(), "descriptor value must be a scalar");
       return false;
     }
 
     KeyValue = Key->getValue(KeyStorage);
     if (KeyValue.equals("source")) {
-      std::string Error;
-
       Source = Value->getValue(ValueStorage);
-      if (!Regex(Source).isValid(Error)) {
-        YS.printError(Field.getKey(), "invalid regex: " + Error);
+      auto RegexOrError = Regex::compile(Source);
+      if (!RegexOrError) {
+        YS.printError(Field.getKey(),
+                      "invalid regex: " + toString(RegexOrError.takeError()));
         return false;
       }
     } else if (KeyValue.equals("target")) {
       Target = Value->getValue(ValueStorage);
     } else if (KeyValue.equals("transform")) {
       Transform = Value->getValue(ValueStorage);
     } else {
       YS.printError(Field.getKey(), "unknown Key for Global Variable");
for (auto &Field : *Descriptor) {
     Value = dyn_cast<yaml::ScalarNode>(Field.getValue());
     if (!Value) {
       YS.printError(Field.getValue(), "descriptor value must be a scalar");
       return false;
     }
 
     KeyValue = Key->getValue(KeyStorage);
     if (KeyValue.equals("source")) {
-      std::string Error;
-
       Source = Value->getValue(ValueStorage);
-      if (!Regex(Source).isValid(Error)) {
-        YS.printError(Field.getKey(), "invalid regex: " + Error);
+      auto RegexOrError = Regex::compile(Source);
+      if (!RegexOrError) {
+        YS.printError(Field.getKey(),
+                      "invalid regex: " + toString(RegexOrError.takeError()));
         return false;
       }
     } else if (KeyValue.equals("target")) {
       Target = Value->getValue(ValueStorage);
     } else if (KeyValue.equals("transform")) {
       Transform = Value->getValue(ValueStorage);
     } else {
       YS.printError(Field.getKey(), "unknown key for Global Alias");

tools/llvm-cov/CodeCoverage.cpp

if (DemanglerOpts.size()) {
       ViewOpts.DemanglerOpts.swap(DemanglerOpts);
     }
 
     // Create the function filters
     if (!NameFilters.empty() || !NameRegexFilters.empty()) {
       auto NameFilterer = new CoverageFilters;
       for (const auto &Name : NameFilters)
         NameFilterer->push_back(llvm::make_unique<NameCoverageFilter>(Name));
-      for (const auto &Regex : NameRegexFilters)
-        NameFilterer->push_back(
-            llvm::make_unique<NameRegexCoverageFilter>(Regex));
+      for (const auto &Regex : NameRegexFilters) {
+        if (auto RegexOrError = llvm::Regex::compile(Regex)) {
+          NameFilterer->push_back(llvm::make_unique<NameRegexCoverageFilter>(
+              std::move(*RegexOrError)));
+        } else {
+          error("Invalid regex.", toString(RegexOrError.takeError()));
+          return 1;
+        }
+      }
       Filters.push_back(std::unique_ptr<CoverageFilter>(NameFilterer));
     }
     if (RegionCoverageLtFilter.getNumOccurrences() ||
         RegionCoverageGtFilter.getNumOccurrences() ||
         LineCoverageLtFilter.getNumOccurrences() ||
         LineCoverageGtFilter.getNumOccurrences()) {
       auto StatFilterer = new CoverageFilters;
       if (RegionCoverageLtFilter.getNumOccurrences())

tools/llvm-cov/CoverageFilters.h

 // These classes provide filtering for function coverage mapping records.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_COV_COVERAGEFILTERS_H
 #define LLVM_COV_COVERAGEFILTERS_H
 
 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
+#include "llvm/Support/Regex.h"
 #include <memory>
 #include <vector>
 
 namespace llvm {
 
 /// \brief Matches specific functions that pass the requirement of this filter.
 class CoverageFilter {
 public:

 public:
   NameCoverageFilter(StringRef Name) : Name(Name) {}
 
   bool matches(const coverage::FunctionRecord &Function) override;
 };
 
 /// \brief Matches functions whose name matches a certain regular expression.
 class NameRegexCoverageFilter : public CoverageFilter {
-  StringRef Regex;
+  llvm::Regex RE;
 
 public:
-  NameRegexCoverageFilter(StringRef Regex) : Regex(Regex) {}
+  NameRegexCoverageFilter(llvm::Regex RE) : RE(std::move(RE)) {}
 
   bool matches(const coverage::FunctionRecord &Function) override;
 };
 
 /// \brief Matches numbers that pass a certain threshold.
 template <typename T> class StatisticThresholdFilter {
 public:
   enum Operation { LessThan, GreaterThan };

tools/llvm-cov/CoverageFilters.cpp

 
 bool NameCoverageFilter::matches(const coverage::FunctionRecord &Function) {
   StringRef FuncName = Function.Name;
   return FuncName.find(Name) != StringRef::npos;
 }
 
 bool
 NameRegexCoverageFilter::matches(const coverage::FunctionRecord &Function) {
-  return llvm::Regex(Regex).match(Function.Name);
+  return RE.match(Function.Name);
 }
 
 bool RegionCoverageFilter::matches(const coverage::FunctionRecord &Function) {
   return PassesThreshold(FunctionCoverageSummary::get(Function)
                              .RegionCoverage.getPercentCovered());
 }
 
 bool LineCoverageFilter::matches(const coverage::FunctionRecord &Function) {

tools/llvm-extract/llvm-extract.cpp

if (!GA) {
       return 1;
     }
     GVs.insert(GA);
   }
 
   // Extract aliases via regular expression matching.
   for (size_t i = 0, e = ExtractRegExpAliases.size(); i != e; ++i) {
     std::string Error;
-    Regex RegEx(ExtractRegExpAliases[i]);
-    if (!RegEx.isValid(Error)) {
+    auto RegEx = Regex::compile(ExtractRegExpAliases[i]);
+    if (!RegEx) {
       errs() << argv[0] << ": '" << ExtractRegExpAliases[i] << "' "
-        "invalid regex: " << Error;
+        "invalid regex: " << toString(RegEx.takeError());
+      return 1;
     }
     bool match = false;
     for (Module::alias_iterator GA = M->alias_begin(), E = M->alias_end();
          GA != E; GA++) {
-      if (RegEx.match(GA->getName())) {
+      if (RegEx->match(GA->getName())) {
         GVs.insert(&*GA);
         match = true;
       }
     }
     if (!match) {
       errs() << argv[0] << ": program doesn't contain global named '"
              << ExtractRegExpAliases[i] << "'!\n";
       return 1;
if (!GV) {
       return 1;
     }
     GVs.insert(GV);
   }
 
   // Extract globals via regular expression matching.
   for (size_t i = 0, e = ExtractRegExpGlobals.size(); i != e; ++i) {
     std::string Error;
-    Regex RegEx(ExtractRegExpGlobals[i]);
-    if (!RegEx.isValid(Error)) {
+    auto RegEx = Regex::compile(ExtractRegExpGlobals[i]);
+    if (!RegEx) {
       errs() << argv[0] << ": '" << ExtractRegExpGlobals[i] << "' "
-        "invalid regex: " << Error;
+        "invalid regex: " << toString(RegEx.takeError());
+      return 1;
     }
     bool match = false;
     for (auto &GV : M->globals()) {
-      if (RegEx.match(GV.getName())) {
+      if (RegEx->match(GV.getName())) {
         GVs.insert(&GV);
         match = true;
       }
     }
     if (!match) {
       errs() << argv[0] << ": program doesn't contain global named '"
              << ExtractRegExpGlobals[i] << "'!\n";
       return 1;
if (!GV) {
       return 1;
     }
     GVs.insert(GV);
   }
   // Extract functions via regular expression matching.
   for (size_t i = 0, e = ExtractRegExpFuncs.size(); i != e; ++i) {
     std::string Error;
     StringRef RegExStr = ExtractRegExpFuncs[i];
-    Regex RegEx(RegExStr);
-    if (!RegEx.isValid(Error)) {
+    auto RegEx = Regex::compile(RegExStr);
+    if (!RegEx) {
       errs() << argv[0] << ": '" << ExtractRegExpFuncs[i] << "' "
-        "invalid regex: " << Error;
+        "invalid regex: " << toString(RegEx.takeError());
+      return 1;
     }
     bool match = false;
     for (Module::iterator F = M->begin(), E = M->end(); F != E;
          F++) {
-      if (RegEx.match(F->getName())) {
+      if (RegEx->match(F->getName())) {
         GVs.insert(&*F);
         match = true;
       }
     }
     if (!match) {
       errs() << argv[0] << ": program doesn't contain global named '"
              << ExtractRegExpFuncs[i] << "'!\n";
       return 1;

tools/llvm-pdbdump/LinePrinter.h

 
 namespace llvm {
 namespace pdb {
 
 class LinePrinter {
   friend class WithColor;
 
 public:
-  LinePrinter(int Indent, raw_ostream &Stream);
+  LinePrinter(int Indent, raw_ostream &Stream, Error* Err = nullptr);
 
   void Indent();
   void Unindent();
   void NewLine();
 
   raw_ostream &getStream() { return OS; }
   int getIndentLevel() const { return CurrentIndent; }
 
   bool IsTypeExcluded(llvm::StringRef TypeName);
   bool IsSymbolExcluded(llvm::StringRef SymbolName);
   bool IsCompilandExcluded(llvm::StringRef CompilandName);
 
 private:
   template <typename Iter>
-  void SetFilters(std::list<Regex> &List, Iter Begin, Iter End) {
+  void SetFilters(std::list<Regex> &List, Iter Begin, Iter End, Error *Err) {
+    ErrorAsOutParameter ErrAsOutParam(Err);
     List.clear();
-    for (; Begin != End; ++Begin)
-      List.emplace_back(StringRef(*Begin));
+    for (; Begin != End; ++Begin) {
+      if (auto RegexOrError = Regex::compile(*Begin)) {
+        List.emplace_back(std::move(*RegexOrError));
+      } else if (Err) {
+        *Err = joinErrors(std::move(*Err), RegexOrError.takeError());
+      } else {
+        consumeError(RegexOrError.takeError());
+      }
+    }
   }
 
   raw_ostream &OS;
   int IndentSpaces;
   int CurrentIndent;
 
   std::list<Regex> ExcludeCompilandFilters;
   std::list<Regex> ExcludeTypeFilters;

tools/llvm-pdbdump/LinePrinter.cpp

if (any_of(ExcludeFilters, match_pred))
     return true;
 
   return false;
 }
 }
 
 using namespace llvm;
 
-LinePrinter::LinePrinter(int Indent, llvm::raw_ostream &Stream)
+LinePrinter::LinePrinter(int Indent, llvm::raw_ostream &Stream, Error *Err)
     : OS(Stream), IndentSpaces(Indent), CurrentIndent(0) {
   SetFilters(ExcludeTypeFilters, opts::pretty::ExcludeTypes.begin(),
-             opts::pretty::ExcludeTypes.end());
+             opts::pretty::ExcludeTypes.end(), Err);
   SetFilters(ExcludeSymbolFilters, opts::pretty::ExcludeSymbols.begin(),
-             opts::pretty::ExcludeSymbols.end());
+             opts::pretty::ExcludeSymbols.end(), Err);
   SetFilters(ExcludeCompilandFilters, opts::pretty::ExcludeCompilands.begin(),
-             opts::pretty::ExcludeCompilands.end());
+             opts::pretty::ExcludeCompilands.end(), Err);
 
   SetFilters(IncludeTypeFilters, opts::pretty::IncludeTypes.begin(),
-             opts::pretty::IncludeTypes.end());
+             opts::pretty::IncludeTypes.end(), Err);
   SetFilters(IncludeSymbolFilters, opts::pretty::IncludeSymbols.begin(),
-             opts::pretty::IncludeSymbols.end());
+             opts::pretty::IncludeSymbols.end(), Err);
   SetFilters(IncludeCompilandFilters, opts::pretty::IncludeCompilands.begin(),
-             opts::pretty::IncludeCompilands.end());
+             opts::pretty::IncludeCompilands.end(), Err);
 }
 
 void LinePrinter::Indent() { CurrentIndent += IndentSpaces; }
 
 void LinePrinter::Unindent() {
   CurrentIndent = std::max(0, CurrentIndent - IndentSpaces);
 }
 

tools/llvm-pdbdump/llvm-pdbdump.cpp

 static void dumpPretty(StringRef Path) {
   std::unique_ptr<IPDBSession> Session;
 
   ExitOnErr(loadDataForPDB(PDB_ReaderType::DIA, Path, Session));
 
   if (opts::pretty::LoadAddress)
     Session->setLoadAddress(opts::pretty::LoadAddress);
 
-  LinePrinter Printer(2, outs());
+  Error Err = Error::success();
+  LinePrinter Printer(2, outs(), &Err);
+  ExitOnErr(std::move(Err));
 
   auto GlobalScope(Session->getGlobalScope());
   std::string FileName(GlobalScope->getSymbolsFileName());
 
   WithColor(Printer, PDB_ColorItem::None).get() << "Summary for ";
   WithColor(Printer, PDB_ColorItem::Path).get() << FileName;
   Printer.Indent();
   uint64_t FileSize = 0;
int main(int argc_, const char *argv_[]) {
   SpecificBumpPtrAllocator<char> ArgAllocator;
   ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
       argv, makeArrayRef(argv_, argc_), ArgAllocator)));
 
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   cl::ParseCommandLineOptions(argv.size(), argv.data(), "LLVM PDB Dumper\n");
   if (!opts::raw::DumpBlockRangeOpt.empty()) {
-    llvm::Regex R("^([0-9]+)(-([0-9]+))?$");
+    auto R = ExitOnErr(llvm::Regex::compile("^([0-9]+)(-([0-9]+))?$"));
     llvm::SmallVector<llvm::StringRef, 2> Matches;
     if (!R.match(opts::raw::DumpBlockRangeOpt, &Matches)) {
       errs() << "Argument '" << opts::raw::DumpBlockRangeOpt
              << "' invalid format.\n";
       errs().flush();
       exit(1);
     }
     opts::raw::DumpBlockRange.emplace();

tools/sancov/sancov.cc

struct FileHeader {
   uint32_t Bitness;
   uint32_t Magic;
 };
 
 static const uint32_t BinCoverageMagic = 0xC0BFFFFF;
 static const uint32_t Bitness32 = 0xFFFFFF32;
 static const uint32_t Bitness64 = 0xFFFFFF64;
 
-static Regex SancovFileRegex("(.*)\\.[0-9]+\\.sancov");
-static Regex SymcovFileRegex(".*\\.symcov");
+static Regex SancovFileRegex = ExitOnError("invalid regex literal")(
+    Regex::compile("(.*)\\.[0-9]+\\.sancov"));
+static Regex SymcovFileRegex =
+    ExitOnError("invalid regex literal")(Regex::compile(".*\\.symcov"));
 
 // --------- MAIN DATASTRUCTURES ----------
 
 // Contents of .sancov file: list of coverage point addresses that were
 // executed.
 struct RawCoverage {
   explicit RawCoverage(std::unique_ptr<std::set<uint64_t>> Addrs)
       : Addrs(std::move(Addrs)) {}

unittests/Support/RegexTest.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "gtest/gtest.h"
 #include <cstring>
 
 using namespace llvm;
 namespace {
 
 class RegexTest : public ::testing::Test {
+protected:
+  Regex makeRegex(StringRef Pattern) {
+    auto RegexOrError = Regex::compile(Pattern);
+    if (!RegexOrError) {
+      ADD_FAILURE() << toString(RegexOrError.takeError());
+      return Regex();
+    }
+    return std::move(*RegexOrError);
+  }
 };
 
 TEST_F(RegexTest, Basics) {
-  Regex r1("^[0-9]+$");
+  auto r1 = makeRegex("^[0-9]+$");
   EXPECT_TRUE(r1.match("916"));
   EXPECT_TRUE(r1.match("9"));
   EXPECT_FALSE(r1.match("9a"));
 
   SmallVector<StringRef, 1> Matches;
-  Regex r2("[0-9]+");
+  auto r2 = makeRegex("[0-9]+");
   EXPECT_TRUE(r2.match("aa216b", &Matches));
   EXPECT_EQ(1u, Matches.size());
   EXPECT_EQ("216", Matches[0].str());
 
-  Regex r3("[0-9]+([a-f])?:([0-9]+)");
+  auto r3 = makeRegex("[0-9]+([a-f])?:([0-9]+)");
   EXPECT_TRUE(r3.match("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());
 
   EXPECT_TRUE(r3.match("9:513b", &Matches));
   EXPECT_EQ(3u, Matches.size());
   EXPECT_EQ("9:513", Matches[0].str());
   EXPECT_EQ("", Matches[1].str());
   EXPECT_EQ("513", Matches[2].str());
 
-  Regex r4("a[^b]+b");
+  auto r4 = makeRegex("a[^b]+b");
   std::string String="axxb";
   String[2] = '\0';
   EXPECT_FALSE(r4.match("abb"));
   EXPECT_TRUE(r4.match(String, &Matches));
   EXPECT_EQ(1u, Matches.size());
   EXPECT_EQ(String, Matches[0].str());
 
   std::string NulPattern="X[0-9]+X([a-f])?:([0-9]+)";
   String="YX99a:513b";
   NulPattern[7] = '\0';
-  Regex r5(NulPattern);
+  auto r5 = makeRegex(NulPattern);
   EXPECT_FALSE(r5.match(String));
   EXPECT_FALSE(r5.match("X9"));
   String[3]='\0';
   EXPECT_TRUE(r5.match(String));
 }
 
 TEST_F(RegexTest, Backreferences) {
-  Regex r1("([a-z]+)_\\1");
+  auto r1 = makeRegex("([a-z]+)_\\1");
   SmallVector<StringRef, 4> Matches;
   EXPECT_TRUE(r1.match("abc_abc", &Matches));
   EXPECT_EQ(2u, Matches.size());
   EXPECT_FALSE(r1.match("abc_ab", &Matches));
 
-  Regex r2("a([0-9])b\\1c\\1");
+  auto r2 = makeRegex("a([0-9])b\\1c\\1");
   EXPECT_TRUE(r2.match("a4b4c4", &Matches));
   EXPECT_EQ(2u, Matches.size());
   EXPECT_EQ("4", Matches[1].str());
   EXPECT_FALSE(r2.match("a2b2c3"));
 
-  Regex r3("a([0-9])([a-z])b\\1\\2");
+  auto r3 = makeRegex("a([0-9])([a-z])b\\1\\2");
   EXPECT_TRUE(r3.match("a6zb6z", &Matches));
   EXPECT_EQ(3u, Matches.size());
   EXPECT_EQ("6", Matches[1].str());
   EXPECT_EQ("z", Matches[2].str());
   EXPECT_FALSE(r3.match("a6zb6y"));
   EXPECT_FALSE(r3.match("a6zb7z"));
 }
 
 TEST_F(RegexTest, Substitution) {
   std::string Error;
 
-  EXPECT_EQ("aNUMber", Regex("[0-9]+").sub("NUM", "a1234ber"));
+  EXPECT_EQ("aNUMber", makeRegex("[0-9]+").sub("NUM", "a1234ber"));
 
   // Standard Escapes
-  EXPECT_EQ("a\\ber", Regex("[0-9]+").sub("\\\\", "a1234ber", &Error));
+  EXPECT_EQ("a\\ber", makeRegex("[0-9]+").sub("\\\\", "a1234ber", &Error));
   EXPECT_EQ("", Error);
-  EXPECT_EQ("a\nber", Regex("[0-9]+").sub("\\n", "a1234ber", &Error));
+  EXPECT_EQ("a\nber", makeRegex("[0-9]+").sub("\\n", "a1234ber", &Error));
   EXPECT_EQ("", Error);
-  EXPECT_EQ("a\tber", Regex("[0-9]+").sub("\\t", "a1234ber", &Error));
+  EXPECT_EQ("a\tber", makeRegex("[0-9]+").sub("\\t", "a1234ber", &Error));
   EXPECT_EQ("", Error);
-  EXPECT_EQ("ajber", Regex("[0-9]+").sub("\\j", "a1234ber", &Error));
+  EXPECT_EQ("ajber", makeRegex("[0-9]+").sub("\\j", "a1234ber", &Error));
   EXPECT_EQ("", Error);
 
-  EXPECT_EQ("aber", Regex("[0-9]+").sub("\\", "a1234ber", &Error));
+  EXPECT_EQ("aber", makeRegex("[0-9]+").sub("\\", "a1234ber", &Error));
   EXPECT_EQ(Error, "replacement string contained trailing backslash");
   
   // Backreferences
-  EXPECT_EQ("aa1234bber", Regex("a[0-9]+b").sub("a\\0b", "a1234ber", &Error));
+  EXPECT_EQ("aa1234bber", makeRegex("a[0-9]+b").sub("a\\0b", "a1234ber", &Error));
   EXPECT_EQ("", Error);
 
-  EXPECT_EQ("a1234ber", Regex("a([0-9]+)b").sub("a\\1b", "a1234ber", &Error));
+  EXPECT_EQ("a1234ber", makeRegex("a([0-9]+)b").sub("a\\1b", "a1234ber", &Error));
   EXPECT_EQ("", Error);
 
-  EXPECT_EQ("aber", Regex("a[0-9]+b").sub("a\\100b", "a1234ber", &Error));
+  EXPECT_EQ("aber", makeRegex("a[0-9]+b").sub("a\\100b", "a1234ber", &Error));
   EXPECT_EQ(Error, "invalid backreference string '100'");
 }
 
 TEST_F(RegexTest, IsLiteralERE) {
   EXPECT_TRUE(Regex::isLiteralERE("abc"));
   EXPECT_FALSE(Regex::isLiteralERE("a(bc)"));
   EXPECT_FALSE(Regex::isLiteralERE("^abc"));
   EXPECT_FALSE(Regex::isLiteralERE("abc$"));
   EXPECT_FALSE(Regex::isLiteralERE("a|bc"));
   EXPECT_FALSE(Regex::isLiteralERE("abc*"));
   EXPECT_FALSE(Regex::isLiteralERE("abc+"));
   EXPECT_FALSE(Regex::isLiteralERE("abc?"));
   EXPECT_FALSE(Regex::isLiteralERE("abc."));
   EXPECT_FALSE(Regex::isLiteralERE("a[bc]"));
   EXPECT_FALSE(Regex::isLiteralERE("abc\\1"));
   EXPECT_FALSE(Regex::isLiteralERE("abc{1,2}"));
 }
 
 TEST_F(RegexTest, Escape) {
   EXPECT_EQ("a\\[bc\\]", Regex::escape("a[bc]"));
   EXPECT_EQ("abc\\{1\\\\,2\\}", Regex::escape("abc{1\\,2}"));
 }
 
 TEST_F(RegexTest, IsValid) {
-  std::string Error;
-  EXPECT_FALSE(Regex("(foo").isValid(Error));
-  EXPECT_EQ("parentheses not balanced", Error);
-  EXPECT_FALSE(Regex("a[b-").isValid(Error));
-  EXPECT_EQ("invalid character range", Error);
+  auto RE = Regex::compile("(foo");
+  EXPECT_EQ("parentheses not balanced", toString(RE.takeError()));
+  RE = Regex::compile("a[b-");
+  EXPECT_EQ("invalid character range", toString(RE.takeError()));
 }
 
 TEST_F(RegexTest, MoveConstruct) {
-  Regex r1("^[0-9]+$");
+  auto r1 = makeRegex("^[0-9]+$");
   Regex r2(std::move(r1));
   EXPECT_TRUE(r2.match("916"));
 }
 
 TEST_F(RegexTest, MoveAssign) {
-  Regex r1("^[0-9]+$");
-  Regex r2("abc");
+  auto r1 = makeRegex("^[0-9]+$");
+  auto r2 = makeRegex("abc");
   r2 = std::move(r1);
   EXPECT_TRUE(r2.match("916"));
   std::string Error;
   EXPECT_FALSE(r1.isValid(Error));
 }
 
 TEST_F(RegexTest, NoArgConstructor) {
   std::string Error;
   Regex r1;
   EXPECT_FALSE(r1.isValid(Error));
   EXPECT_EQ("invalid regular expression", Error);
-  r1 = Regex("abc");
+  r1 = makeRegex("abc");
   EXPECT_TRUE(r1.isValid(Error));
 }
 
 TEST_F(RegexTest, MatchInvalid) {
   Regex r1;
   std::string Error;
   EXPECT_FALSE(r1.isValid(Error));
   EXPECT_FALSE(r1.match("X"));
 }
 
 }

utils/FileCheck/FileCheck.cpp

if (!NoCanonicalizeWhiteSpace)
       RegExStr += " *";
     RegExStr += '$';
   }
 
   return false;
 }
 
 bool Pattern::AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM) {
-  Regex R(RS);
-  std::string Error;
-  if (!R.isValid(Error)) {
+  auto R = Regex::compile(RS);
+  if (!R) {
     SM.PrintMessage(SMLoc::getFromPointer(RS.data()), SourceMgr::DK_Error,
-                    "invalid regex: " + Error);
+                    "invalid regex: " + toString(R.takeError()));
     return true;
   }
 
   RegExStr += RS.str();
-  CurParen += R.getNumMatches();
+  CurParen += R->getNumMatches();
   return false;
 }
 
 void Pattern::AddBackrefToRegEx(unsigned BackrefNum) {
   assert(BackrefNum >= 1 && BackrefNum <= 9 && "Invalid backref number");
   std::string Backref = std::string("\\") + std::string(1, '0' + BackrefNum);
   RegExStr += Backref;
 }
for (const auto &VariableUse : VariableUses) {
       InsertOffset += Value.size();
     }
 
     // Match the newly constructed regex.
     RegExToMatch = TmpStr;
   }
 
   SmallVector<StringRef, 4> MatchInfo;
-  if (!Regex(RegExToMatch, Regex::Newline).match(Buffer, &MatchInfo))
+  auto R = Regex::compile(RegExToMatch, Regex::Newline);
+  // Note that if the regex is not valid, the following check does not handle
+  // the error, so this will crash with asserts enabled.
+  if (!R || !R->match(Buffer, &MatchInfo))
     return StringRef::npos;
 
   // Successful regex match.
   assert(!MatchInfo.empty() && "Didn't get any match");
   StringRef FullMatch = MatchInfo[0];
 
   // If this defines any variables, remember their values.
   for (const auto &VariableDef : VariableDefs) {
for (const Pattern &Pat : DagNotStrings) {
     LastPos = std::max(MatchPos + MatchLen, LastPos);
   }
 
   return LastPos;
 }
 
 // A check prefix must contain only alphanumeric, hyphens and underscores.
 static bool ValidateCheckPrefix(StringRef CheckPrefix) {
-  Regex Validator("^[a-zA-Z0-9_-]*$");
-  return Validator.match(CheckPrefix);
+  auto Validator = Regex::compile("^[a-zA-Z0-9_-]*$");
+  // Note that this does not handle errors returned by Regex::compile. If the
+  // regex string literal is invalid, this will crash when asserts are enabled.
+  return Validator && Validator->match(CheckPrefix);
 }
 
 static bool ValidateCheckPrefixes() {
   StringSet<> PrefixSet;
 
   for (StringRef Prefix : CheckPrefixes) {
     // Reject empty prefixes.
     if (Prefix == "")

utils/TableGen/CodeGenSchedule.cpp

for (DagInit::const_arg_iterator
         PrintFatalError(Loc, "instregex requires pattern string: "
           + Expr->getAsString());
       std::string pat = SI->getValue();
       // Implement a python-style prefix match.
       if (pat[0] != '^') {
         pat.insert(0, "^(");
         pat.insert(pat.end(), ')');
       }
-      RegexList.push_back(Regex(pat));
+      if (auto RegexOrError = Regex::compile(pat)) {
+        RegexList.push_back(std::move(*RegexOrError));
+      } else {
+        PrintFatalError(Loc,
+                        "instregex got invalid pattern string: " +
+                            toString(RegexOrError.takeError()) + ": " + pat);
+      }
     }
     for (const CodeGenInstruction *Inst : Target.getInstructionsByEnumValue()) {
       for (auto &R : RegexList) {
         if (R.match(Inst->TheDef->getName()))
           Elts.insert(Inst->TheDef);
       }
     }
   }