Use std::regex.

[ruiu]

• Simplify

ELF/LinkerScript.h

struct OutputSectionCommand : BaseCommand {
   ConstraintKind Constraint = ConstraintKind::NoConstraint;
 };
 
 enum SortKind { SortNone, SortByName, SortByAlignment };
 
 struct InputSectionDescription : BaseCommand {
   InputSectionDescription() : BaseCommand(InputSectionKind) {}
   static bool classof(const BaseCommand *C);
-  StringRef FilePattern;
+  StringRef FilePattern; // TODO: use std::regex instead
   SortKind SortOuter = SortNone;
   SortKind SortInner = SortNone;
-  std::vector<StringRef> ExcludedFiles;
-  std::vector<StringRef> SectionPatterns;
+  std::vector<StringRef> ExcludedFiles;   // TODO: vector of std::regexs
+  std::vector<StringRef> SectionPatterns; // TODO: vector of std::regexs
 };
 
 struct AssertCommand : BaseCommand {
   AssertCommand(Expr E) : BaseCommand(AssertKind), Expression(E) {}
   static bool classof(const BaseCommand *C);
   Expr Expression;
 };
 
struct ScriptConfiguration {
   std::vector<PhdrsCommand> PhdrsCommands;
 
   bool HasContents = false;
 
   llvm::BumpPtrAllocator Alloc;
 
   // List of section patterns specified with KEEP commands. They will
   // be kept even if they are unused and --gc-sections is specified.
-  std::vector<StringRef> KeptSections;
+  std::vector<StringRef> KeptSections; // TODO: vector of regexs
 };
 
 extern ScriptConfiguration *ScriptConfig;
 
 // This is a runner of the linker script.
 template <class ELFT> class LinkerScript {
   typedef typename ELFT::uint uintX_t;
 

ELF/Strings.cpp

 //===- Strings.cpp -------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Strings.h"
 #include "Error.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Config/config.h"
 #include <algorithm>
+#include <regex>
 
 #ifdef HAVE_CXXABI_H
 #include <cxxabi.h>
 #endif
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::elf;
 
-// Returns true if S matches T. S can contain glob meta-characters.
-// The asterisk ('*') matches zero or more characters, and the question
-// mark ('?') matches one character.
-bool elf::globMatch(StringRef S, StringRef T) {
-  for (;;) {
-    if (S.empty())
-      return T.empty();
-    if (S[0] == '*') {
+static std::regex toRegex(StringRef S) {
+  std::string T;
+  bool InBracket = false;
+
+  // This is a hand-written state machine to convert
+  // a glob pattern to a regex.
+  while (!S.empty()) {
+    // Handle backslash escape.
+    if (S[0] == '\\') {
+      if (S.size() == 1) {
+        T += '\\';
+        break;
+      }
+      T += S[0];
+      T += S[1];
+      S = S.substr(2);
+      continue;
+    }
+
+    if (InBracket) {
+      if (S[0] == ']')
+        InBracket = false;
+      T += S[0];
       S = S.substr(1);
-      if (S.empty())
-        // Fast path. If a pattern is '*', it matches anything.
-        return true;
-      for (size_t I = 0, E = T.size(); I < E; ++I)
-        if (globMatch(S, T.substr(I)))
-          return true;
-      return false;
+      continue;
+    }
+
+    if (S[0] == '*') {
+      T += ".*";
+    } else if (S[0] == '?') {
+      T += '.';
+    } else if (S[0] == '[') {
+      T += '[';
+      InBracket = true;
+    } else {
+      T += S[0];
     }
-    if (T.empty() || (S[0] != T[0] && S[0] != '?'))
-      return false;
     S = S.substr(1);
-    T = T.substr(1);
   }
+  return std::regex(T, std::regex::basic | std::regex::optimize);
+}
+
+// Returns true if S matches T. S can contain glob meta-characters.
+// The asterisk ('*') matches zero or more characters, and the question
+// mark ('?') matches one character.
+bool elf::globMatch(StringRef S, StringRef T) {
+  return std::regex_match(T.begin(), T.end(), toRegex(S));
 }
 
 // Converts a hex string (e.g. "deadbeef") to a vector.
 std::vector<uint8_t> elf::parseHex(StringRef S) {
   std::vector<uint8_t> Hex;
   while (!S.empty()) {
     StringRef B = S.substr(0, 2);
     S = S.substr(2);