Add an IsLiteral parameter to SpecialCaseList (LLVM side).

[samsonov]

I'm ok with landing this change first, if you diff it against the trunk and provide default value for IsLiteral parameter so that we don't even have to change existing xsan code.

include/llvm/Support/SpecialCaseList.h

 class MemoryBuffer;
 class Regex;
 class StringRef;
 
 class SpecialCaseList {
  public:
   /// Parses the special case list from a file. If Path is empty, returns an
   /// empty special case list. On failure, reports a fatal error.
-  static std::unique_ptr<SpecialCaseList> createOrDie(const StringRef Path);
+  /// \param IsLiteral Whether the special case list entries are interpreted
+  /// literally.
+  static std::unique_ptr<SpecialCaseList> createOrDie(StringRef Path,
+                                                      bool IsLiteral);
 
   SpecialCaseList();
   ~SpecialCaseList();
 
   /// Parses the special case list from a file. Returns true if successful. On
   /// failure, writes an error message to \param Error.
-  bool loadFromFile(StringRef Path, std::string &Error);
+  /// \param IsLiteral Whether the special case list entries are interpreted
+  /// literally.
+  bool loadFromFile(StringRef Path, bool IsLiteral, std::string &Error);
+
   /// Parses the special case list from a memory buffer. Returns true if
   /// successful. On failure, writes an error message to \param Error.
-  bool loadFromBuffer(const MemoryBuffer *MB, std::string &Error);
+  /// \param IsLiteral Whether the special case list entries are interpreted
+  /// literally.
+  bool loadFromBuffer(const MemoryBuffer *MB, bool IsLiteral,
+                      std::string &Error);
 
   /// Returns true, if special case list contains a line
   /// \code
   ///   @Section:<E>=@Category
   /// \endcode
   /// and @Query satisfies a wildcard expression <E>.
   bool inSection(const StringRef Section, const StringRef Query,
                  const StringRef Category = StringRef()) const;

lib/Support/SpecialCaseList.cpp

bool match(StringRef Query) const {
     }
     return false;
   }
 };
 
 SpecialCaseList::SpecialCaseList() {}
 
 std::unique_ptr<SpecialCaseList>
-SpecialCaseList::createOrDie(const StringRef Path) {
+SpecialCaseList::createOrDie(const StringRef Path, bool IsLiteral) {
   auto SCL = make_unique<SpecialCaseList>();
   if (Path.empty())
     return std::move(SCL);
   std::string Error;
-  if (!SCL->loadFromFile(Path, Error))
+  if (!SCL->loadFromFile(Path, IsLiteral, Error))
     report_fatal_error(Error);
   return std::move(SCL);
 }
 
-bool SpecialCaseList::loadFromFile(StringRef Path, std::string &Error) {
+bool SpecialCaseList::loadFromFile(StringRef Path, bool IsLiteral,
+                                   std::string &Error) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFile(Path);
   if (std::error_code EC = FileOrErr.getError()) {
     Error = (Twine("Can't open file '") + Path + "': " + EC.message()).str();
     return nullptr;
   }
-  return loadFromBuffer(FileOrErr.get().get(), Error);
+  return loadFromBuffer(FileOrErr.get().get(), IsLiteral, Error);
 }
 
-bool SpecialCaseList::loadFromBuffer(const MemoryBuffer *MB, std::string &Error) {
+bool SpecialCaseList::loadFromBuffer(const MemoryBuffer *MB, bool IsLiteral,
+                                     std::string &Error) {
   // Iterate through each line in the blacklist file.
   SmallVector<StringRef, 16> Lines;
   SplitString(MB->getBuffer(), Lines, "\n\r");
   int LineNo = 1;
   for (SmallVectorImpl<StringRef>::iterator I = Lines.begin(), E = Lines.end();
        I != E; ++I, ++LineNo) {
     // Ignore empty lines and lines starting with "#"
     if (I->empty() || I->startswith("#"))
if (Prefix == "global-init") {
       Prefix = "type";
       Category = "init";
     } else if (Prefix == "global-init-src") {
       Prefix = "src";
       Category = "init";
     }
 
     // See if we can store Regexp in Strings.
-    if (Regex::isLiteralERE(Regexp)) {
+    if (IsLiteral || Regex::isLiteralERE(Regexp)) {
       Entries[Prefix][Category].Strings.insert(Regexp);
       continue;
     }
 
     // Replace * with .*
     for (size_t pos = 0; (pos = Regexp.find("*", pos)) != std::string::npos;
          pos += strlen(".*")) {
       Regexp.replace(pos, strlen("*"), ".*");

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

llvm::createDataFlowSanitizerPass(std::unique_ptr<SpecialCaseList> ABIList,
   return new DataFlowSanitizer(std::move(ABIList), getArgTLS, getRetValTLS);
 }
 
 DataFlowSanitizer::DataFlowSanitizer(std::unique_ptr<SpecialCaseList> ABIList,
                                      void *(*getArgTLS)(),
                                      void *(*getRetValTLS)())
     : ModulePass(ID), GetArgTLSPtr(getArgTLS), GetRetvalTLSPtr(getRetValTLS),
       ABIList(ABIList ? std::move(ABIList)
-                      : SpecialCaseList::createOrDie(ClABIListFile)) {}
+                      : SpecialCaseList::createOrDie(ClABIListFile,
+                                                     /*IsLiteral=*/true)) {}
 
 FunctionType *DataFlowSanitizer::getArgsFunctionType(FunctionType *T) {
   llvm::SmallVector<Type *, 4> ArgTypes;
   std::copy(T->param_begin(), T->param_end(), std::back_inserter(ArgTypes));
   for (unsigned i = 0, e = T->getNumParams(); i != e; ++i)
     ArgTypes.push_back(ShadowTy);
   if (T->isVarArg())
     ArgTypes.push_back(ShadowPtrTy);

test/Instrumentation/DataFlowSanitizer/Inputs/abilist.txt

-fun:discard*=uninstrumented
-fun:discard*=discard
+fun:discard=uninstrumented
+fun:discard=discard
+fun:discardg=uninstrumented
+fun:discardg=discard
 
 fun:functional=uninstrumented
 fun:functional=functional
 
-fun:custom*=uninstrumented
-fun:custom*=custom
+fun:custom1=uninstrumented
+fun:custom1=custom
+fun:custom2=uninstrumented
+fun:custom2=custom
+fun:customcb=uninstrumented
+fun:customcb=custom

unittests/Support/SpecialCaseListTest.cpp

 #include "llvm/Support/SpecialCaseList.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 class SpecialCaseListTest : public ::testing::Test {
+public:
+  SpecialCaseListTest() : IsLiteral(false) {}
+
 protected:
+  bool IsLiteral;
+
   bool loadFromStr(SpecialCaseList *SCL, StringRef List, std::string &Error) {
     std::unique_ptr<MemoryBuffer> MB(MemoryBuffer::getMemBuffer(List));
-    return SCL->loadFromBuffer(MB.get(), Error);
+    return SCL->loadFromBuffer(MB.get(), IsLiteral, Error);
   }
 
   std::unique_ptr<SpecialCaseList> makeSpecialCaseList(StringRef List, std::string &Error) {
     auto SCL = make_unique<SpecialCaseList>();
     if (!loadFromStr(SCL.get(), List, Error))
       return nullptr;
     return SCL;
   }
EXPECT_EQ("Malformed regex in line 1: 'bad[a-': invalid character range",
             Error);
   EXPECT_EQ(nullptr, makeSpecialCaseList("src:a.c\n"
                                    "fun:fun(a\n",
                                    Error));
   EXPECT_EQ("Malformed regex in line 2: 'fun(a': parentheses not balanced",
             Error);
 
   SpecialCaseList SCL;
-  EXPECT_FALSE(SCL.loadFromFile("unexisting", Error));
+  EXPECT_FALSE(SCL.loadFromFile("unexisting", /*IsLiteral=*/false, Error));
   EXPECT_EQ(0U, Error.find("Can't open file 'unexisting':"));
 }
 
 TEST_F(SpecialCaseListTest, EmptySpecialCaseList) {
   auto SCL = makeSpecialCaseList("");
   EXPECT_FALSE(SCL->inSection("foo", "bar"));
 }
 
TEST_F(SpecialCaseListTest, MultipleLists) {
 
   EXPECT_TRUE(SCL.inSection("fun", "foo"));
   EXPECT_TRUE(SCL.inSection("fun", "bar"));
   EXPECT_TRUE(SCL.inSection("fun", "bartender"));
   EXPECT_FALSE(SCL.inSection("fun", "foobar"));
   EXPECT_TRUE(SCL.inSection("fun", "baz"));
 }
 
+TEST_F(SpecialCaseListTest, Literal) {
+  IsLiteral = true;
+
+  auto SCL = makeSpecialCaseList("fun:foo*bar\n");
+  EXPECT_TRUE(SCL->inSection("fun", "foo*bar"));
+  EXPECT_FALSE(SCL->inSection("fun", "fooobar"));
+}
+
 }