[clang][Summary] refactor summary attributes

isuckatcs · isuckatcs · commit 016dcdb4707a · 2025-06-14T14:50:19.000+02:00
diff --git a/clang/include/clang/Sema/SummaryAttribute.h b/clang/include/clang/Sema/SummaryAttribute.h
@@ -3,37 +3,40 @@
 
 #include "clang/AST/Decl.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
-#include <string>
 
 namespace clang {
-enum SummaryAttributeKind {
+enum SummaryAttrKind {
   NO_WRITE_GLOBAL,
 };
 
 class FunctionSummary;
+class SummaryContext;
 
-class SummaryAttribute {
-  const SummaryAttributeKind Kind;
-  std::string_view Serialzed;
+class SummaryAttr {
+  const SummaryAttrKind Kind;
+  const char *Spelling;
+
+protected:
+  SummaryAttr(SummaryAttrKind Kind, const char *Spelling)
+      : Kind(Kind), Spelling(Spelling){};
 
 public:
-  SummaryAttribute(SummaryAttributeKind Attr, const char *Str)
-      : Kind(Attr), Serialzed(Str) {}
-  virtual ~SummaryAttribute() = default;
+  virtual ~SummaryAttr() = default;
 
-  SummaryAttributeKind getKind() { return Kind; }
+  SummaryAttrKind getKind() const { return Kind; }
+  const char *getSpelling() const { return Spelling; }
 
   virtual bool infer(const FunctionDecl *FD) const = 0;
   virtual bool merge(const FunctionSummary &Caller,
                      const FunctionSummary &Callee) const = 0;
 
-  virtual std::string serialize() const { return std::string(Serialzed); };
+  virtual std::string serialize() const { return std::string(Spelling); };
   virtual bool parse(std::string_view input) const {
-    return input == Serialzed;
+    return input == Spelling;
   };
 };
 
-class NoWriteGlobalAttr : public SummaryAttribute {
+class NoWriteGlobalAttr : public SummaryAttr {
   class Callback : public ast_matchers::MatchFinder::MatchCallback {
   public:
     bool WriteGlobal = false;
@@ -42,12 +45,17 @@ class NoWriteGlobalAttr : public SummaryAttribute {
     run(const ast_matchers::MatchFinder::MatchResult &Result) override final;
   };
 
-public:
-  NoWriteGlobalAttr() : SummaryAttribute(NO_WRITE_GLOBAL, "no_write_global") {}
+  NoWriteGlobalAttr() : SummaryAttr(NO_WRITE_GLOBAL, "no_write_global") {}
 
+public:
   bool infer(const FunctionDecl *FD) const override final;
   bool merge(const FunctionSummary &Caller,
              const FunctionSummary &Callee) const override final;
+
+  static bool classof(const SummaryAttr *A) {
+    return A->getKind() == NO_WRITE_GLOBAL;
+  }
+  friend class SummaryContext;
 };
 } // namespace clang
 
diff --git a/clang/include/clang/Sema/SummaryContext.h b/clang/include/clang/Sema/SummaryContext.h
@@ -8,21 +8,27 @@
 namespace clang {
 class FunctionSummary {
   SmallVector<char> ID;
-  std::set<const SummaryAttribute *> Attrs;
+  std::set<const SummaryAttr *> Attrs;
   std::set<SmallVector<char>> Calls;
 
 public:
-  FunctionSummary(SmallVector<char> ID,
-                  std::set<const SummaryAttribute *> Attrs,
+  FunctionSummary(SmallVector<char> ID, std::set<const SummaryAttr *> Attrs,
                   std::set<SmallVector<char>> Calls);
 
   SmallVector<char> getID() const { return ID; }
-  const std::set<const SummaryAttribute *> &getAttributes() const {
-    return Attrs;
-  }
+  const std::set<const SummaryAttr *> &getAttributes() const { return Attrs; }
   const std::set<SmallVector<char>> &getCalls() const { return Calls; }
 
-  void replaceAttributes(std::set<const SummaryAttribute *> Attrs) {
+  template <typename T> bool hasAttribute() const {
+    for (auto &&attr : Attrs) {
+      if (llvm::isa<T>(attr))
+        return true;
+    }
+
+    return false;
+  }
+
+  void replaceAttributes(std::set<const SummaryAttr *> Attrs) {
     this->Attrs = std::move(Attrs);
   }
 };
@@ -31,18 +37,18 @@ class SummaryContext {
   std::map<SmallVector<char>, const FunctionSummary *> IDToSummary;
   std::vector<std::unique_ptr<FunctionSummary>> FunctionSummaries;
 
-  std::map<SummaryAttributeKind, const SummaryAttribute *> KindToAttribute;
-  std::vector<std::unique_ptr<SummaryAttribute>> Attributes;
+  std::map<SummaryAttrKind, const SummaryAttr *> KindToAttribute;
+  std::vector<std::unique_ptr<SummaryAttr>> Attributes;
 
-  void CreateSummary(SmallVector<char> ID,
-                     std::set<const SummaryAttribute *> Attrs,
+  void CreateSummary(SmallVector<char> ID, std::set<const SummaryAttr *> Attrs,
                      std::set<SmallVector<char>> Calls);
   bool ReduceFunctionSummary(FunctionSummary &FunctionSummary);
 
+  template <typename T> void registerAttr();
+
 public:
   SummaryContext();
 
-  const SummaryAttribute *GetAttribute(SummaryAttributeKind kind) const;
   const FunctionSummary *GetSummary(const FunctionDecl *FD) const;
   void SummarizeFunctionBody(const FunctionDecl *FD);
 
diff --git a/clang/lib/Sema/SummaryContext.cpp b/clang/lib/Sema/SummaryContext.cpp
@@ -40,44 +40,41 @@ class CallCollector : public ast_matchers::MatchFinder::MatchCallback {
 };
 } // namespace
 
-FunctionSummary::FunctionSummary(
-    SmallVector<char> ID, std::set<const SummaryAttribute *> FunctionAttrs,
-    std::set<SmallVector<char>> Calls)
+FunctionSummary::FunctionSummary(SmallVector<char> ID,
+                                 std::set<const SummaryAttr *> FunctionAttrs,
+                                 std::set<SmallVector<char>> Calls)
     : ID(std::move(ID)), Attrs(std::move(FunctionAttrs)),
       Calls(std::move(Calls)) {}
 
-SummaryContext::SummaryContext() {
-  Attributes.emplace_back(std::make_unique<NoWriteGlobalAttr>());
+template <typename T> void SummaryContext::registerAttr() {
+  std::unique_ptr<T> attr(new T());
+  SummaryAttrKind Kind = attr->getKind();
 
-  for (auto &&Attr : Attributes) {
-    assert(KindToAttribute.count(Attr->getKind()) == 0 &&
-           "Attr already registered");
-    KindToAttribute[Attr->getKind()] = Attr.get();
-  }
+  if (KindToAttribute.count(Kind))
+    return;
+
+  KindToAttribute[Kind] = Attributes.emplace_back(std::move(attr)).get();
 }
 
+SummaryContext::SummaryContext() { registerAttr<NoWriteGlobalAttr>(); }
+
 void SummaryContext::CreateSummary(SmallVector<char> ID,
-                                   std::set<const SummaryAttribute *> Attrs,
+                                   std::set<const SummaryAttr *> Attrs,
                                    std::set<SmallVector<char>> Calls) {
   auto Summary = std::make_unique<FunctionSummary>(
       std::move(ID), std::move(Attrs), std::move(Calls));
   auto *SummaryPtr = FunctionSummaries.emplace_back(std::move(Summary)).get();
   IDToSummary[SummaryPtr->getID()] = SummaryPtr;
 }
 
-const SummaryAttribute *
-SummaryContext::GetAttribute(SummaryAttributeKind kind) const {
-  return KindToAttribute.at(kind);
-}
-
 const FunctionSummary *
 SummaryContext::GetSummary(const FunctionDecl *FD) const {
   auto USR = GetUSR(FD);
   return IDToSummary.count(USR) ? IDToSummary.at(USR) : nullptr;
 }
 
 void SummaryContext::SummarizeFunctionBody(const FunctionDecl *FD) {
-  std::set<const SummaryAttribute *> Attrs;
+  std::set<const SummaryAttr *> Attrs;
 
   for (auto &&Attr : Attributes) {
     if (Attr->infer(FD))
@@ -92,7 +89,7 @@ void SummaryContext::ParseSummaryFromJSON(const llvm::json::Array &Summary) {
     const llvm::json::Object *FunctionSummary = it->getAsObject();
 
     SmallString<128> ID(*FunctionSummary->getString("id"));
-    std::set<const SummaryAttribute *> FunctionAttrs;
+    std::set<const SummaryAttr *> FunctionAttrs;
     const llvm::json::Array *FunctionAttributes =
         FunctionSummary->getObject("attrs")->getArray("function");
     for(auto attrIt = FunctionAttributes->begin(); attrIt != FunctionAttributes->end(); ++attrIt) {
@@ -117,7 +114,7 @@ bool SummaryContext::ReduceFunctionSummary(FunctionSummary &Function) {
   bool changed = false;
 
   for (auto &&call : Function.getCalls()) {
-    std::set<const SummaryAttribute *> reducedAttrs;
+    std::set<const SummaryAttr *> reducedAttrs;
 
     // If we don't have a summary about a called function, we forget
     // everything about the current one as well.
diff --git a/clang/lib/StaticAnalyzer/Core/CallEvent.cpp b/clang/lib/StaticAnalyzer/Core/CallEvent.cpp
@@ -280,12 +280,11 @@ ProgramStateRef CallEvent::invalidateRegions(unsigned BlockCount,
   bool ShouldPreserveGlobals = false;
   const SummaryContext *SummaryCtx =
       State->getStateManager().getOwningEngine().getSummaryCtx();
-  if (SummaryCtx) {
-    const auto *Summary =
-        SummaryCtx->GetSummary(llvm::dyn_cast<FunctionDecl>(getDecl()));
+  const FunctionDecl *FD = llvm::dyn_cast<FunctionDecl>(getDecl());
+  if (SummaryCtx && FD) {
+    const auto *Summary = SummaryCtx->GetSummary(FD);
     ShouldPreserveGlobals =
-        Summary && Summary->getAttributes().count(
-                       SummaryCtx->GetAttribute(NO_WRITE_GLOBAL));
+        Summary && Summary->hasAttribute<NoWriteGlobalAttr>();
   }
 
   // Invalidate designated regions using the batch invalidation API.
