Adding type-string based blacklist for sanitizers

[byoungyoung]

Summary

While I'm working on applying Undefined Sanitizer's vptr, I found that existing blacklisting methods (source file names or function names) do not fit well to handle many false positive cases for Undefined Sanitizer (e.g., a template class, which causes a false positive, is used in all over different places).

Thus, we have added type-string based blacklisting. Please note that this blacklisting is not based on any LLVM internal types (e.g., Module/Function), but simply based on generic "string" types. This is because UBsan instruments in the Clang's CodeGen phase and unrolls type information into the "string" from Clang specific QualType, which is not visible for LLVM.

[samsonov]

Hi!

Thanks for working on this! Sorry for delay in the review, I am currently working on moving sanitizer blacklist functionality (except for the stuff used in DFSsan) to Clang, and will return to this patch when this is done (then this patch will hopefully be minimized!)

[byoungyoung]

Thanks Alex!

include/llvm/Transforms/Utils/SpecialCaseList.h

 
   ~SpecialCaseList();
 
+  /// Returns whether this type string is listed in the given category,
+  /// which may be ommitted to search the empty category.
+  bool isIn(const StringRef TypeStr,
+            const StringRef Category = StringRef()) const;
+
   /// 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;

lib/Transforms/Utils/SpecialCaseList.cpp

   }
 }
 
+bool SpecialCaseList::isIn(const StringRef TypeStr,
+                           const StringRef Category) const {
+  return inSectionCategory("type", TypeStr, Category);
+}
+
 bool SpecialCaseList::isIn(const Function& F, const StringRef Category) const {
   return isIn(*F.getParent(), Category) ||
          inSectionCategory("fun", F.getName(), Category);

unittests/Transforms/Utils/SpecialCaseList.cpp

   EXPECT_FALSE(SCL->isIn(*Bar, "functional"));
 }
 
+TEST_F(SpecialCaseListTest, TypeIsIn) {
+  Module M("hello", Ctx);
+  GlobalVariable *Bar = makeGlobal("bar", "bar_t", M);
+
+  std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList("type:bar_t\n"));
+  EXPECT_TRUE(SCL->isIn(*Bar));
+
+  SCL.reset(makeSpecialCaseList("type:b*\n"));
+  EXPECT_TRUE(SCL->isIn(*Bar));
+
+  SCL.reset(makeSpecialCaseList("type:*_t\n"));
+  EXPECT_TRUE(SCL->isIn(*Bar));
+
+  SCL.reset(makeSpecialCaseList("type:bar\n"));
+  EXPECT_FALSE(SCL->isIn(*Bar));
+}
+
 TEST_F(SpecialCaseListTest, GlobalIsIn) {
   Module M("hello", Ctx);
   GlobalVariable *Foo = makeGlobal("foo", "t1", M);