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,50 @@ 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(); -} - -SpecialCaseList *SpecialCaseList::createOrDie(const StringRef Path) { - std::string Error; - if (SpecialCaseList *SCL = create(Path, Error)) - return SCL; - report_fatal_error(Error); + return loadFromBuffer(FileOrErr.get().get(), 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"); + StringMap> Regexps; int LineNo = 1; for (SmallVectorImpl::iterator I = Lines.begin(), E = Lines.end(); I != E; ++I, ++LineNo) { @@ -143,13 +140,10 @@ } // 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())); + for (const auto &Prefix : Regexps) { + for (const auto &Category : Prefix.second) { + Entries[Prefix.getKey()][Category.getKey()].RegExps.push_back( + make_unique(Category.second)); } } 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. @@ -258,7 +258,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; @@ -341,19 +342,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" @@ -18,8 +19,11 @@ class SpecialCaseListTest : public ::testing::Test { protected: SpecialCaseList *makeSpecialCaseList(StringRef List, std::string &Error) { + auto SCL = make_unique(); std::unique_ptr MB(MemoryBuffer::getMemBuffer(List)); - return SpecialCaseList::create(MB.get(), Error); + if (!SCL->loadFromBuffer(MB.get(), Error)) + return nullptr; + return SCL.release(); } SpecialCaseList *makeSpecialCaseList(StringRef List) { @@ -112,7 +116,9 @@ 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':")); }