Index: include/llvm/Support/SpecialCaseList.h =================================================================== --- include/llvm/Support/SpecialCaseList.h +++ include/llvm/Support/SpecialCaseList.h @@ -57,19 +57,20 @@ class SpecialCaseList { public: - /// Parses the special case list from a file. If Path is empty, returns - /// an empty special case list. On failure, returns 0 and writes an error - /// message to string. - static SpecialCaseList *create(const StringRef Path, std::string &Error); - /// Parses the special case list from a memory buffer. On failure, returns - /// 0 and writes an error message to string. - static SpecialCaseList *create(const MemoryBuffer *MB, std::string &Error); - /// Parses the special case list from a file. On failure, reports a fatal - /// error. - static SpecialCaseList *createOrDie(const StringRef Path); + /// 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 createOrDie(const StringRef Path); + 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); + /// 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); + /// Returns true, if special case list contains a line /// \code /// @Section:=@Category @@ -84,10 +85,6 @@ struct Entry; StringMap > Entries; - - SpecialCaseList(); - /// Parses just-constructed SpecialCaseList entries from a memory buffer. - bool parse(const MemoryBuffer *MB, std::string &Error); }; } // namespace llvm Index: include/llvm/Transforms/Instrumentation.h =================================================================== --- include/llvm/Transforms/Instrumentation.h +++ include/llvm/Transforms/Instrumentation.h @@ -15,6 +15,8 @@ #define LLVM_TRANSFORMS_INSTRUMENTATION_H #include "llvm/ADT/StringRef.h" +#include "llvm/Support/SpecialCaseList.h" +#include #if defined(__GNUC__) && defined(__linux__) && !defined(ANDROID) inline void *getDFSanArgTLSPtrForJIT() { @@ -74,15 +76,15 @@ FunctionPass *createThreadSanitizerPass(); // Insert DataFlowSanitizer (dynamic data flow analysis) instrumentation -ModulePass *createDataFlowSanitizerPass(StringRef ABIListFile = StringRef(), +ModulePass *createDataFlowSanitizerPass(std::unique_ptr ABIL, void *(*getArgTLS)() = nullptr, void *(*getRetValTLS)() = nullptr); #if defined(__GNUC__) && defined(__linux__) && !defined(ANDROID) -inline ModulePass *createDataFlowSanitizerPassForJIT(StringRef ABIListFile = - StringRef()) { - return createDataFlowSanitizerPass(ABIListFile, getDFSanArgTLSPtrForJIT, - getDFSanRetValTLSPtrForJIT); +inline ModulePass * +createDataFlowSanitizerPassForJIT(std::unique_ptr ABIList) { + return createDataFlowSanitizerPass( + std::move(ABIList), getDFSanArgTLSPtrForJIT, getDFSanRetValTLSPtrForJIT); } #endif Index: lib/Support/SpecialCaseList.cpp =================================================================== --- lib/Support/SpecialCaseList.cpp +++ lib/Support/SpecialCaseList.cpp @@ -36,53 +36,49 @@ struct SpecialCaseList::Entry { Entry() {} Entry(Entry &&Other) - : Strings(std::move(Other.Strings)), RegEx(std::move(Other.RegEx)) {} + : Strings(std::move(Other.Strings)), RegExps(std::move(Other.RegExps)) {} StringSet<> Strings; - std::unique_ptr RegEx; + std::vector> RegExps; bool match(StringRef Query) const { - return Strings.count(Query) || (RegEx && RegEx->match(Query)); + if (Strings.count(Query)) + return true; + for (auto &&RE : RegExps) { + if (RE->match(Query)) + return true; + } + return false; } }; -SpecialCaseList::SpecialCaseList() : Entries() {} +SpecialCaseList::SpecialCaseList() {} -SpecialCaseList *SpecialCaseList::create( - const StringRef Path, std::string &Error) { +std::unique_ptr +SpecialCaseList::createOrDie(const StringRef Path) { + auto SCL = make_unique(); if (Path.empty()) - return new SpecialCaseList(); + return std::move(SCL); + std::string Error; + if (!SCL->loadFromFile(Path, Error)) + report_fatal_error(Error); + return std::move(SCL); +} + +bool SpecialCaseList::loadFromFile(StringRef Path, std::string &Error) { ErrorOr> FileOrErr = MemoryBuffer::getFile(Path); if (std::error_code EC = FileOrErr.getError()) { Error = (Twine("Can't open file '") + Path + "': " + EC.message()).str(); return nullptr; } - return create(FileOrErr.get().get(), Error); -} - -SpecialCaseList *SpecialCaseList::create( - const MemoryBuffer *MB, std::string &Error) { - std::unique_ptr SCL(new SpecialCaseList()); - if (!SCL->parse(MB, Error)) - return nullptr; - return SCL.release(); + return loadFromBuffer(FileOrErr.get().get(), Error); } -SpecialCaseList *SpecialCaseList::createOrDie(const StringRef Path) { - std::string Error; - if (SpecialCaseList *SCL = create(Path, Error)) - return SCL; - report_fatal_error(Error); -} - -bool SpecialCaseList::parse(const MemoryBuffer *MB, std::string &Error) { +bool SpecialCaseList::loadFromBuffer(const MemoryBuffer *MB, std::string &Error) { // Iterate through each line in the blacklist file. SmallVector Lines; SplitString(MB->getBuffer(), Lines, "\n\r"); - StringMap > Regexps; - assert(Entries.empty() && - "parse() should be called on an empty SpecialCaseList"); int LineNo = 1; for (SmallVectorImpl::iterator I = Lines.begin(), E = Lines.end(); I != E; ++I, ++LineNo) { @@ -127,31 +123,19 @@ Regexp.replace(pos, strlen("*"), ".*"); } - // Check that the regexp is valid. - Regex CheckRE(Regexp); + auto RE = make_unique("^" + Regexp + "$"); std::string REError; - if (!CheckRE.isValid(REError)) { + // Check that the regexp is valid. + if (!RE->isValid(REError)) { Error = (Twine("Malformed regex in line ") + Twine(LineNo) + ": '" + SplitLine.second + "': " + REError).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 + "$"; + Entries[Prefix][Category].RegExps.push_back(std::move(RE)); } - // Iterate through each of the prefixes, and create Regexs for them. - for (StringMap >::const_iterator I = Regexps.begin(), - E = Regexps.end(); - I != E; ++I) { - for (StringMap::const_iterator II = I->second.begin(), - IE = I->second.end(); - II != IE; ++II) { - Entries[I->getKey()][II->getKey()].RegEx.reset(new Regex(II->getValue())); - } - } return true; } Index: lib/Transforms/Instrumentation/DataFlowSanitizer.cpp =================================================================== --- lib/Transforms/Instrumentation/DataFlowSanitizer.cpp +++ lib/Transforms/Instrumentation/DataFlowSanitizer.cpp @@ -139,7 +139,7 @@ std::unique_ptr SCL; public: - DFSanABIList(SpecialCaseList *SCL) : SCL(SCL) {} + DFSanABIList(std::unique_ptr SCL) : SCL(std::move(SCL)) {} /// Returns whether either this function or its source file are listed in the /// given category. @@ -259,7 +259,8 @@ Constant *getOrBuildTrampolineFunction(FunctionType *FT, StringRef FName); public: - DataFlowSanitizer(StringRef ABIListFile = StringRef(), + DataFlowSanitizer(std::unique_ptr ABIList = + std::unique_ptr(), void *(*getArgTLS)() = nullptr, void *(*getRetValTLS)() = nullptr); static char ID; @@ -346,19 +347,19 @@ INITIALIZE_PASS(DataFlowSanitizer, "dfsan", "DataFlowSanitizer: dynamic data flow analysis.", false, false) -ModulePass *llvm::createDataFlowSanitizerPass(StringRef ABIListFile, - void *(*getArgTLS)(), - void *(*getRetValTLS)()) { - return new DataFlowSanitizer(ABIListFile, getArgTLS, getRetValTLS); +ModulePass * +llvm::createDataFlowSanitizerPass(std::unique_ptr ABIList, + void *(*getArgTLS)(), + void *(*getRetValTLS)()) { + return new DataFlowSanitizer(std::move(ABIList), getArgTLS, getRetValTLS); } -DataFlowSanitizer::DataFlowSanitizer(StringRef ABIListFile, +DataFlowSanitizer::DataFlowSanitizer(std::unique_ptr ABIList, void *(*getArgTLS)(), void *(*getRetValTLS)()) : ModulePass(ID), GetArgTLSPtr(getArgTLS), GetRetvalTLSPtr(getRetValTLS), - ABIList(SpecialCaseList::createOrDie(ABIListFile.empty() ? ClABIListFile - : ABIListFile)) { -} + ABIList(ABIList ? std::move(ABIList) + : SpecialCaseList::createOrDie(ClABIListFile)) {} FunctionType *DataFlowSanitizer::getArgsFunctionType(FunctionType *T) { llvm::SmallVector ArgTypes; Index: unittests/Support/SpecialCaseListTest.cpp =================================================================== --- unittests/Support/SpecialCaseListTest.cpp +++ unittests/Support/SpecialCaseListTest.cpp @@ -7,6 +7,7 @@ // //===----------------------------------------------------------------------===// +#include "llvm/ADT/STLExtras.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/SpecialCaseList.h" #include "gtest/gtest.h" @@ -17,14 +18,21 @@ class SpecialCaseListTest : public ::testing::Test { protected: - SpecialCaseList *makeSpecialCaseList(StringRef List, std::string &Error) { + bool loadFromStr(SpecialCaseList *SCL, StringRef List, std::string &Error) { std::unique_ptr MB(MemoryBuffer::getMemBuffer(List)); - return SpecialCaseList::create(MB.get(), Error); + return SCL->loadFromBuffer(MB.get(), Error); } - SpecialCaseList *makeSpecialCaseList(StringRef List) { + std::unique_ptr makeSpecialCaseList(StringRef List, std::string &Error) { + auto SCL = make_unique(); + if (!loadFromStr(SCL.get(), List, Error)) + return nullptr; + return SCL; + } + + std::unique_ptr makeSpecialCaseList(StringRef List) { std::string Error; - SpecialCaseList *SCL = makeSpecialCaseList(List, Error); + auto SCL = makeSpecialCaseList(List, Error); assert(SCL); assert(Error == ""); return SCL; @@ -32,13 +40,13 @@ }; TEST_F(SpecialCaseListTest, Basic) { - std::unique_ptr SCL( + auto SCL = makeSpecialCaseList("# This is a comment.\n" "\n" "src:hello\n" "src:bye\n" "src:hi=category\n" - "src:z*=category\n")); + "src:z*=category\n"); EXPECT_TRUE(SCL->inSection("src", "hello")); EXPECT_TRUE(SCL->inSection("src", "bye")); EXPECT_TRUE(SCL->inSection("src", "hi", "category")); @@ -49,38 +57,37 @@ } TEST_F(SpecialCaseListTest, GlobalInitCompat) { - std::unique_ptr SCL( - makeSpecialCaseList("global:foo=init\n")); + auto SCL = makeSpecialCaseList("global:foo=init\n"); EXPECT_FALSE(SCL->inSection("global", "foo")); EXPECT_FALSE(SCL->inSection("global", "bar")); EXPECT_TRUE(SCL->inSection("global", "foo", "init")); EXPECT_FALSE(SCL->inSection("global", "bar", "init")); - SCL.reset(makeSpecialCaseList("global-init:foo\n")); + SCL = makeSpecialCaseList("global-init:foo\n"); EXPECT_FALSE(SCL->inSection("global", "foo")); EXPECT_FALSE(SCL->inSection("global", "bar")); EXPECT_TRUE(SCL->inSection("global", "foo", "init")); EXPECT_FALSE(SCL->inSection("global", "bar", "init")); - SCL.reset(makeSpecialCaseList("type:t2=init\n")); + SCL = makeSpecialCaseList("type:t2=init\n"); EXPECT_FALSE(SCL->inSection("type", "t1")); EXPECT_FALSE(SCL->inSection("type", "t2")); EXPECT_FALSE(SCL->inSection("type", "t1", "init")); EXPECT_TRUE(SCL->inSection("type", "t2", "init")); - SCL.reset(makeSpecialCaseList("global-init-type:t2\n")); + SCL = makeSpecialCaseList("global-init-type:t2\n"); EXPECT_FALSE(SCL->inSection("type", "t1")); EXPECT_FALSE(SCL->inSection("type", "t2")); EXPECT_FALSE(SCL->inSection("type", "t1", "init")); EXPECT_TRUE(SCL->inSection("type", "t2", "init")); - SCL.reset(makeSpecialCaseList("src:hello=init\n")); + SCL = makeSpecialCaseList("src:hello=init\n"); EXPECT_FALSE(SCL->inSection("src", "hello")); EXPECT_FALSE(SCL->inSection("src", "bye")); EXPECT_TRUE(SCL->inSection("src", "hello", "init")); EXPECT_FALSE(SCL->inSection("src", "bye", "init")); - SCL.reset(makeSpecialCaseList("global-init-src:hello\n")); + SCL = makeSpecialCaseList("global-init-src:hello\n"); EXPECT_FALSE(SCL->inSection("src", "hello")); EXPECT_FALSE(SCL->inSection("src", "bye")); EXPECT_TRUE(SCL->inSection("src", "hello", "init")); @@ -88,14 +95,14 @@ } TEST_F(SpecialCaseListTest, Substring) { - std::unique_ptr SCL(makeSpecialCaseList("src:hello\n" - "fun:foo\n" - "global:bar\n")); + auto SCL = makeSpecialCaseList("src:hello\n" + "fun:foo\n" + "global:bar\n"); EXPECT_FALSE(SCL->inSection("src", "othello")); EXPECT_FALSE(SCL->inSection("fun", "tomfoolery")); EXPECT_FALSE(SCL->inSection("global", "bartender")); - SCL.reset(makeSpecialCaseList("fun:*foo*\n")); + SCL = makeSpecialCaseList("fun:*foo*\n"); EXPECT_TRUE(SCL->inSection("fun", "tomfoolery")); EXPECT_TRUE(SCL->inSection("fun", "foobar")); } @@ -112,15 +119,44 @@ Error)); EXPECT_EQ("Malformed regex in line 2: 'fun(a': parentheses not balanced", Error); - EXPECT_EQ(nullptr, SpecialCaseList::create("unexisting", Error)); + + SpecialCaseList SCL; + EXPECT_FALSE(SCL.loadFromFile("unexisting", Error)); EXPECT_EQ(0U, Error.find("Can't open file 'unexisting':")); } TEST_F(SpecialCaseListTest, EmptySpecialCaseList) { - std::unique_ptr SCL(makeSpecialCaseList("")); + auto SCL = makeSpecialCaseList(""); EXPECT_FALSE(SCL->inSection("foo", "bar")); } -} +TEST_F(SpecialCaseListTest, MultipleLists) { + SpecialCaseList SCL; + std::string Error; + + EXPECT_FALSE(SCL.inSection("fun", "foo")); + EXPECT_FALSE(SCL.inSection("fun", "bar")); + ASSERT_TRUE(loadFromStr(&SCL, "fun:foo\n", Error)); + EXPECT_TRUE(SCL.inSection("fun", "foo")); + EXPECT_FALSE(SCL.inSection("fun", "bar")); + + ASSERT_TRUE(loadFromStr(&SCL, "fun:bar*\n", Error)); + + 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_FALSE(SCL.inSection("fun", "baz")); + + ASSERT_TRUE(loadFromStr(&SCL, "fun:baz\n", Error)); + + 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")); +} + +}