Index: include/llvm/Support/SpecialCaseList.h
===================================================================
--- include/llvm/Support/SpecialCaseList.h
+++ include/llvm/Support/SpecialCaseList.h
@@ -59,17 +59,26 @@
  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
Index: lib/Support/SpecialCaseList.cpp
===================================================================
--- lib/Support/SpecialCaseList.cpp
+++ lib/Support/SpecialCaseList.cpp
@@ -55,27 +55,29 @@
 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");
@@ -112,7 +114,7 @@
     }
 
     // See if we can store Regexp in Strings.
-    if (Regex::isLiteralERE(Regexp)) {
+    if (IsLiteral || Regex::isLiteralERE(Regexp)) {
       Entries[Prefix][Category].Strings.insert(Regexp);
       continue;
     }
Index: lib/Transforms/Instrumentation/DataFlowSanitizer.cpp
===================================================================
--- lib/Transforms/Instrumentation/DataFlowSanitizer.cpp
+++ lib/Transforms/Instrumentation/DataFlowSanitizer.cpp
@@ -359,7 +359,8 @@
                                      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;
Index: test/Instrumentation/DataFlowSanitizer/Inputs/abilist.txt
===================================================================
--- test/Instrumentation/DataFlowSanitizer/Inputs/abilist.txt
+++ test/Instrumentation/DataFlowSanitizer/Inputs/abilist.txt
@@ -1,8 +1,14 @@
-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
Index: unittests/Support/SpecialCaseListTest.cpp
===================================================================
--- unittests/Support/SpecialCaseListTest.cpp
+++ unittests/Support/SpecialCaseListTest.cpp
@@ -17,10 +17,15 @@
 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) {
@@ -121,7 +126,7 @@
             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':"));
 }
 
@@ -159,4 +164,12 @@
   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"));
+}
+
 }