From: Peter Collingbourne Date: Tue, 9 Jul 2013 22:03:17 +0000 (+0000) Subject: Implement categories for special case lists. X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=commitdiff_plain;h=46e11c4c97fe1c424241e4098801456303a5c86e Implement categories for special case lists. A special case list can now specify categories for specific globals, which can be used to instruct an instrumentation pass to treat certain functions or global variables in a specific way, such as by omitting certain aspects of instrumentation while keeping others, or informing the instrumentation pass that a specific uninstrumentable function has certain semantics, thus allowing the pass to instrument callers according to those semantics. For example, AddressSanitizer now uses the "init" category instead of global-init prefixes for globals whose initializers should not be instrumented, but which in all other respects should be instrumented. The motivating use case is DataFlowSanitizer, which will have a number of different categories for uninstrumentable functions, such as "functional" which specifies that a function has pure functional semantics, or "discard" which indicates that a function's return value should not be labelled. Differential Revision: http://llvm-reviews.chandlerc.com/D1092 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@185978 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Transforms/Utils/SpecialCaseList.h b/include/llvm/Transforms/Utils/SpecialCaseList.h index 30e3e46ef5f..9f74953c7f8 100644 --- a/include/llvm/Transforms/Utils/SpecialCaseList.h +++ b/include/llvm/Transforms/Utils/SpecialCaseList.h @@ -1,4 +1,4 @@ -//===-- SpecialCaseList.h - blacklist for sanitizers ------------*- C++ -*-===// +//===-- SpecialCaseList.h - special case list for sanitizers ----*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -8,19 +8,34 @@ // // This is a utility class for instrumentation passes (like AddressSanitizer // or ThreadSanitizer) to avoid instrumenting some functions or global -// variables based on a user-supplied blacklist. +// variables based on a user-supplied list. // -// The blacklist disables instrumentation of various functions and global -// variables. Each line contains a prefix, followed by a wild card expression. -// Empty lines and lines starting with "#" are ignored. +// The list can also specify categories for specific globals, which can be used +// to instruct an instrumentation pass to treat certain functions or global +// variables in a specific way, such as by omitting certain aspects of +// instrumentation while keeping others, or informing the instrumentation pass +// that a specific uninstrumentable function has certain semantics, thus +// allowing the pass to instrument callers according to those semantics. +// +// For example, AddressSanitizer uses the "init" category for globals whose +// initializers should not be instrumented, but which in all other respects +// should be instrumented. +// +// Each line contains a prefix, followed by a colon and a wild card expression, +// followed optionally by an equals sign and an instrumentation-specific +// category. Empty lines and lines starting with "#" are ignored. // --- // # Blacklisted items: // fun:*_ZN4base6subtle* // global:*global_with_bad_access_or_initialization* -// global-init:*global_with_initialization_issues* -// global-init-type:*Namespace::ClassName* +// global:*global_with_initialization_issues*=init +// type:*Namespace::ClassName*=init // src:file_with_tricky_code.cc -// global-init-src:ignore-global-initializers-issues.cc +// src:ignore-global-initializers-issues.cc=init +// +// # Functions with pure functional semantics: +// fun:cos=functional +// fun:sin=functional // --- // Note that the wild card is in fact an llvm::Regex, but * is automatically // replaced with .* @@ -44,20 +59,43 @@ class SpecialCaseList { public: SpecialCaseList(const StringRef Path); SpecialCaseList(const MemoryBuffer *MB); + ~SpecialCaseList(); + + /// Returns whether either this function or its source file are listed in the + /// given category, which may be omitted to search the empty category. + bool isIn(const Function &F, const StringRef Category = StringRef()) const; + + /// Returns whether this global, its type or its source file are listed in the + /// given category, which may be omitted to search the empty category. + bool isIn(const GlobalVariable &G, + const StringRef Category = StringRef()) const; + + /// Returns whether this module is listed in the given category, which may be + /// omitted to search the empty category. + bool isIn(const Module &M, const StringRef Category = StringRef()) const; + + /// Returns whether either this function or its source file are listed in any + /// category. Category will contain the name of an arbitrary category in + /// which this function is listed. + bool findCategory(const Function &F, StringRef &Category) const; + + /// Returns whether this global, its type or its source file are listed in any + /// category. Category will contain the name of an arbitrary category in + /// which this global is listed. + bool findCategory(const GlobalVariable &G, StringRef &Category) const; + + /// Returns whether this module is listed in any category. Category will + /// contain the name of an arbitrary category in which this module is listed. + bool findCategory(const Module &M, StringRef &Category) const; - // Returns whether either this function or it's source file are blacklisted. - bool isIn(const Function &F) const; - // Returns whether either this global or it's source file are blacklisted. - bool isIn(const GlobalVariable &G) const; - // Returns whether this module is blacklisted by filename. - bool isIn(const Module &M) const; - // Returns whether a global should be excluded from initialization checking. - bool isInInit(const GlobalVariable &G) const; private: - StringMap Entries; + StringMap > Entries; void init(const MemoryBuffer *MB); - bool inSection(const StringRef Section, const StringRef Query) const; + bool findCategory(const StringRef Section, const StringRef Query, + StringRef &Category) const; + bool inSectionCategory(const StringRef Section, const StringRef Query, + const StringRef Category) const; }; } // namespace llvm diff --git a/lib/Transforms/Instrumentation/AddressSanitizer.cpp b/lib/Transforms/Instrumentation/AddressSanitizer.cpp index 28c5622863b..db0a28519cd 100644 --- a/lib/Transforms/Instrumentation/AddressSanitizer.cpp +++ b/lib/Transforms/Instrumentation/AddressSanitizer.cpp @@ -948,7 +948,7 @@ bool AddressSanitizerModule::runOnModule(Module &M) { bool GlobalHasDynamicInitializer = DynamicallyInitializedGlobals.Contains(G); // Don't check initialization order if this global is blacklisted. - GlobalHasDynamicInitializer &= !BL->isInInit(*G); + GlobalHasDynamicInitializer &= !BL->isIn(*G, "init"); StructType *NewTy = StructType::get(Ty, RightRedZoneTy, NULL); Constant *NewInitializer = ConstantStruct::get( diff --git a/lib/Transforms/Utils/SpecialCaseList.cpp b/lib/Transforms/Utils/SpecialCaseList.cpp index 8f6802ba023..a747230def2 100644 --- a/lib/Transforms/Utils/SpecialCaseList.cpp +++ b/lib/Transforms/Utils/SpecialCaseList.cpp @@ -1,4 +1,4 @@ -//===-- SpecialCaseList.cpp - blacklist for sanitizers --------------------===// +//===-- SpecialCaseList.cpp - special case list for sanitizers ------------===// // // The LLVM Compiler Infrastructure // @@ -9,13 +9,15 @@ // // This is a utility class for instrumentation passes (like AddressSanitizer // or ThreadSanitizer) to avoid instrumenting some functions or global -// variables based on a user-supplied blacklist. +// variables, or to instrument some functions or global variables in a specific +// way, based on a user-supplied list. // //===----------------------------------------------------------------------===// #include "llvm/Transforms/Utils/SpecialCaseList.h" #include "llvm/ADT/OwningPtr.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Function.h" @@ -50,7 +52,7 @@ void SpecialCaseList::init(const MemoryBuffer *MB) { // Iterate through each line in the blacklist file. SmallVector Lines; SplitString(MB->getBuffer(), Lines, "\n\r"); - StringMap Regexps; + StringMap > Regexps; for (SmallVectorImpl::iterator I = Lines.begin(), E = Lines.end(); I != E; ++I) { // Ignore empty lines and lines starting with "#" @@ -59,12 +61,27 @@ void SpecialCaseList::init(const MemoryBuffer *MB) { // Get our prefix and unparsed regexp. std::pair SplitLine = I->split(":"); StringRef Prefix = SplitLine.first; - std::string Regexp = SplitLine.second; - if (Regexp.empty()) { + if (SplitLine.second.empty()) { // Missing ':' in the line. report_fatal_error("malformed blacklist line: " + SplitLine.first); } + std::pair SplitRegexp = SplitLine.second.split("="); + std::string Regexp = SplitRegexp.first; + StringRef Category = SplitRegexp.second; + + // Backwards compatibility. + if (Prefix == "global-init") { + Prefix = "global"; + Category = "init"; + } else if (Prefix == "global-init-type") { + Prefix = "type"; + Category = "init"; + } else if (Prefix == "global-init-src") { + Prefix = "src"; + Category = "init"; + } + // Replace * with .* for (size_t pos = 0; (pos = Regexp.find("*", pos)) != std::string::npos; pos += strlen(".*")) { @@ -80,28 +97,40 @@ void SpecialCaseList::init(const MemoryBuffer *MB) { } // Add this regexp into the proper group by its prefix. - if (!Regexps[Prefix].empty()) - Regexps[Prefix] += "|"; - Regexps[Prefix] += Regexp; + if (!Regexps[Prefix][Category].empty()) + Regexps[Prefix][Category] += "|"; + Regexps[Prefix][Category] += Regexp; } // Iterate through each of the prefixes, and create Regexs for them. - for (StringMap::const_iterator I = Regexps.begin(), - E = Regexps.end(); I != E; ++I) { - Entries[I->getKey()] = new Regex(I->getValue()); + 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()] = new Regex(II->getValue()); + } } } -bool SpecialCaseList::isIn(const Function &F) const { - return isIn(*F.getParent()) || inSection("fun", F.getName()); +SpecialCaseList::~SpecialCaseList() { + for (StringMap >::iterator I = Entries.begin(), + E = Entries.end(); + I != E; ++I) { + DeleteContainerSeconds(I->second); + } } -bool SpecialCaseList::isIn(const GlobalVariable &G) const { - return isIn(*G.getParent()) || inSection("global", G.getName()); +bool SpecialCaseList::findCategory(const Function &F, + StringRef &Category) const { + return findCategory(*F.getParent(), Category) || + findCategory("fun", F.getName(), Category); } -bool SpecialCaseList::isIn(const Module &M) const { - return inSection("src", M.getModuleIdentifier()); +bool SpecialCaseList::isIn(const Function& F, const StringRef Category) const { + return isIn(*F.getParent(), Category) || + inSectionCategory("fun", F.getName(), Category); } static StringRef GetGVTypeString(const GlobalVariable &G) { @@ -115,19 +144,56 @@ static StringRef GetGVTypeString(const GlobalVariable &G) { return ""; } -bool SpecialCaseList::isInInit(const GlobalVariable &G) const { - return (isIn(*G.getParent()) || - inSection("global-init", G.getName()) || - inSection("global-init-type", GetGVTypeString(G)) || - inSection("global-init-src", G.getParent()->getModuleIdentifier())); +bool SpecialCaseList::findCategory(const GlobalVariable &G, + StringRef &Category) const { + return findCategory(*G.getParent(), Category) || + findCategory("global", G.getName(), Category) || + findCategory("type", GetGVTypeString(G), Category); +} + +bool SpecialCaseList::isIn(const GlobalVariable &G, + const StringRef Category) const { + return isIn(*G.getParent(), Category) || + inSectionCategory("global", G.getName(), Category) || + inSectionCategory("type", GetGVTypeString(G), Category); +} + +bool SpecialCaseList::findCategory(const Module &M, StringRef &Category) const { + return findCategory("src", M.getModuleIdentifier(), Category); +} + +bool SpecialCaseList::isIn(const Module &M, const StringRef Category) const { + return inSectionCategory("src", M.getModuleIdentifier(), Category); +} + +bool SpecialCaseList::findCategory(const StringRef Section, + const StringRef Query, + StringRef &Category) const { + StringMap >::const_iterator I = Entries.find(Section); + if (I == Entries.end()) return false; + + for (StringMap::const_iterator II = I->second.begin(), + IE = I->second.end(); + II != IE; ++II) { + Regex *FunctionRegex = II->getValue(); + if (FunctionRegex->match(Query)) { + Category = II->first(); + return true; + } + } + + return false; } -bool SpecialCaseList::inSection(const StringRef Section, - const StringRef Query) const { - StringMap::const_iterator I = Entries.find(Section); +bool SpecialCaseList::inSectionCategory(const StringRef Section, + const StringRef Query, + const StringRef Category) const { + StringMap >::const_iterator I = Entries.find(Section); if (I == Entries.end()) return false; + StringMap::const_iterator II = I->second.find(Category); + if (II == I->second.end()) return false; - Regex *FunctionRegex = I->getValue(); + Regex *FunctionRegex = II->getValue(); return FunctionRegex->match(Query); } diff --git a/unittests/Transforms/Utils/SpecialCaseList.cpp b/unittests/Transforms/Utils/SpecialCaseList.cpp index 1c10317e6af..d87dab00db9 100644 --- a/unittests/Transforms/Utils/SpecialCaseList.cpp +++ b/unittests/Transforms/Utils/SpecialCaseList.cpp @@ -82,6 +82,13 @@ TEST_F(SpecialCaseListTest, FunctionIsIn) { "fun:bar\n")); EXPECT_TRUE(SCL->isIn(*Foo)); EXPECT_TRUE(SCL->isIn(*Bar)); + + SCL.reset(makeSpecialCaseList("fun:foo=functional\n")); + EXPECT_TRUE(SCL->isIn(*Foo, "functional")); + StringRef Category; + EXPECT_TRUE(SCL->findCategory(*Foo, Category)); + EXPECT_EQ("functional", Category); + EXPECT_FALSE(SCL->isIn(*Bar, "functional")); } TEST_F(SpecialCaseListTest, GlobalIsIn) { @@ -92,26 +99,44 @@ TEST_F(SpecialCaseListTest, GlobalIsIn) { OwningPtr SCL(makeSpecialCaseList("global:foo\n")); EXPECT_TRUE(SCL->isIn(*Foo)); EXPECT_FALSE(SCL->isIn(*Bar)); - EXPECT_FALSE(SCL->isInInit(*Foo)); - EXPECT_FALSE(SCL->isInInit(*Bar)); + EXPECT_FALSE(SCL->isIn(*Foo, "init")); + EXPECT_FALSE(SCL->isIn(*Bar, "init")); + + SCL.reset(makeSpecialCaseList("global:foo=init\n")); + EXPECT_FALSE(SCL->isIn(*Foo)); + EXPECT_FALSE(SCL->isIn(*Bar)); + EXPECT_TRUE(SCL->isIn(*Foo, "init")); + EXPECT_FALSE(SCL->isIn(*Bar, "init")); SCL.reset(makeSpecialCaseList("global-init:foo\n")); EXPECT_FALSE(SCL->isIn(*Foo)); EXPECT_FALSE(SCL->isIn(*Bar)); - EXPECT_TRUE(SCL->isInInit(*Foo)); - EXPECT_FALSE(SCL->isInInit(*Bar)); + EXPECT_TRUE(SCL->isIn(*Foo, "init")); + EXPECT_FALSE(SCL->isIn(*Bar, "init")); + + SCL.reset(makeSpecialCaseList("type:t2=init\n")); + EXPECT_FALSE(SCL->isIn(*Foo)); + EXPECT_FALSE(SCL->isIn(*Bar)); + EXPECT_FALSE(SCL->isIn(*Foo, "init")); + EXPECT_TRUE(SCL->isIn(*Bar, "init")); SCL.reset(makeSpecialCaseList("global-init-type:t2\n")); EXPECT_FALSE(SCL->isIn(*Foo)); EXPECT_FALSE(SCL->isIn(*Bar)); - EXPECT_FALSE(SCL->isInInit(*Foo)); - EXPECT_TRUE(SCL->isInInit(*Bar)); + EXPECT_FALSE(SCL->isIn(*Foo, "init")); + EXPECT_TRUE(SCL->isIn(*Bar, "init")); + + SCL.reset(makeSpecialCaseList("src:hello=init\n")); + EXPECT_FALSE(SCL->isIn(*Foo)); + EXPECT_FALSE(SCL->isIn(*Bar)); + EXPECT_TRUE(SCL->isIn(*Foo, "init")); + EXPECT_TRUE(SCL->isIn(*Bar, "init")); SCL.reset(makeSpecialCaseList("global-init-src:hello\n")); EXPECT_FALSE(SCL->isIn(*Foo)); EXPECT_FALSE(SCL->isIn(*Bar)); - EXPECT_TRUE(SCL->isInInit(*Foo)); - EXPECT_TRUE(SCL->isInInit(*Bar)); + EXPECT_TRUE(SCL->isIn(*Foo, "init")); + EXPECT_TRUE(SCL->isIn(*Bar, "init")); } }