[compiler-rt] Add a HasSuppressionType method into SuppressionContext

[kubamracek]

Summary

Extending SuppressionContext to add a HasSuppressionType method that tells whether a certain suppression type is currently used or not. It's a step to implement issue suppressions for ASan, see http://reviews.llvm.org/D6280.

[samsonov]

LGTM

lib/sanitizer_common/tests/sanitizer_suppressions_test.cc

160

Can you fix the lint warning instead?

[kubamracek]

Landed in r222954.

lib/sanitizer_common/sanitizer_suppressions.h

struct Suppression {
   uptr weight;
 };
 
 class SuppressionContext {
  public:
   void Parse(const char *str);
   bool Match(const char* str, SuppressionType type, Suppression **s);
   uptr SuppressionCount() const;
+  bool HasSuppressionType(SuppressionType type) const;
   const Suppression *SuppressionAt(uptr i) const;
   void GetMatched(InternalMmapVector<Suppression *> *matched);
 
   // Create a SuppressionContext singleton if it hasn't been created earlier.
   // Not thread safe. Must be called early during initialization (but after
   // runtime flags are parsed).
   static void InitIfNecessary();
   // Returns a SuppressionContext singleton.
   static SuppressionContext *Get();
 
  private:
-  SuppressionContext() : suppressions_(1), can_parse_(true) {}
+  SuppressionContext();
   InternalMmapVector<Suppression> suppressions_;
+  bool has_suppresson_type_[SuppressionTypeCount];
   bool can_parse_;
 
   friend class SuppressionContextTest;
 };
 
 const char *SuppressionTypeString(SuppressionType t);
 
 bool TemplateMatch(char *templ, const char *str);
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_SUPPRESSIONS_H

lib/sanitizer_common/sanitizer_suppressions.cc

while (templ && templ[0]) {
     asterisk = false;
   }
   return true;
 }
 
 ALIGNED(64) static char placeholder[sizeof(SuppressionContext)];
 static SuppressionContext *suppression_ctx = 0;
 
+SuppressionContext::SuppressionContext() : suppressions_(1), can_parse_(true) {
+  internal_memset(has_suppresson_type_, 0, sizeof(has_suppresson_type_));
+}
+
 SuppressionContext *SuppressionContext::Get() {
   CHECK(suppression_ctx);
   return suppression_ctx;
 }
 
 void SuppressionContext::InitIfNecessary() {
   if (suppression_ctx)
     return;
Printf("%s: failed to read suppressions file '%s'\n", SanitizerToolName,
            common_flags()->suppressions);
     Die();
   }
   suppression_ctx->Parse(suppressions_from_file);
 }
 
 bool SuppressionContext::Match(const char *str, SuppressionType type,
                                Suppression **s) {
+  if (!has_suppresson_type_[type])
+    return false;
   can_parse_ = false;
   uptr i;
   for (i = 0; i < suppressions_.size(); i++)
     if (type == suppressions_[i].type &&
         TemplateMatch(suppressions_[i].templ, str))
       break;
   if (i == suppressions_.size()) return false;
   *s = &suppressions_[i];
if (line != end && line[0] != '#') {
       Suppression s;
       s.type = static_cast<SuppressionType>(type);
       s.templ = (char*)InternalAlloc(end2 - line + 1);
       internal_memcpy(s.templ, line, end2 - line);
       s.templ[end2 - line] = 0;
       s.hit_count = 0;
       s.weight = 0;
       suppressions_.push_back(s);
+      has_suppresson_type_[s.type] = true;
     }
     if (end[0] == 0)
       break;
     line = end + 1;
   }
 }
 
 uptr SuppressionContext::SuppressionCount() const {
   return suppressions_.size();
 }
 
+bool SuppressionContext::HasSuppressionType(SuppressionType type) const {
+  return has_suppresson_type_[type];
+}
+
 const Suppression *SuppressionContext::SuppressionAt(uptr i) const {
   CHECK_LT(i, suppressions_.size());
   return &suppressions_[i];
 }
 
 void SuppressionContext::GetMatched(
     InternalMmapVector<Suppression *> *matched) {
   for (uptr i = 0; i < suppressions_.size(); i++)

lib/sanitizer_common/tests/sanitizer_suppressions_test.cc

TEST_F(SuppressionContextTest, ParseType) {
   EXPECT_EQ((*Suppressions())[2].type, SuppressionMutex);
   EXPECT_EQ(0, strcmp((*Suppressions())[2].templ, "baz"));
   EXPECT_EQ((*Suppressions())[1].type, SuppressionThread);
   EXPECT_EQ(0, strcmp((*Suppressions())[1].templ, "bar"));
   EXPECT_EQ((*Suppressions())[0].type, SuppressionRace);
   EXPECT_EQ(0, strcmp((*Suppressions())[0].templ, "foo"));
 }
 
+TEST_F(SuppressionContextTest, HasSuppressionType) {
+  ctx_->Parse(
+    "race:foo\n"
+    "thread:bar\n"
+  );  // NOLINT
+  EXPECT_TRUE(ctx_->HasSuppressionType(SuppressionRace));
+  EXPECT_TRUE(ctx_->HasSuppressionType(SuppressionThread));
+  EXPECT_FALSE(ctx_->HasSuppressionType(SuppressionMutex));
+  EXPECT_FALSE(ctx_->HasSuppressionType(SuppressionSignal));
+}
+
 }  // namespace __sanitizer