add new attribute that checks if a function modifies a pointer argument

Author: isuckatcs

clang/include/clang/Summary/SummaryAttribute.h

@@ -5,9 +5,7 @@
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 namespace clang {
-enum SummaryAttrKind {
-  NO_WRITE_GLOBAL,
-};
+enum SummaryAttrKind { NO_WRITE_GLOBAL, NO_WRITE_PTR_PARAMETER };
 
 class FunctionSummary;
 class SummaryContext;
@@ -49,6 +47,22 @@ class NoWriteGlobalAttr : public SummaryAttr {
   }
   friend class SummaryContext;
 };
+
+// FIXME: create a macro for attr declarations?
+class NoWritePtrParameterAttr : public SummaryAttr {
+  NoWritePtrParameterAttr()
+      : SummaryAttr(NO_WRITE_PTR_PARAMETER, "no_write_ptr_parameter") {}
+
+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_PTR_PARAMETER;
+  }
+  friend class SummaryContext;
+};
 } // namespace clang
 
 #endif // LLVM_CLANG_SUMMARY_SUMMARYATTRIBUTEH

clang/lib/Summary/SummaryAttribute.cpp

@@ -36,4 +36,61 @@ bool NoWriteGlobalAttr::merge(const FunctionSummary &Caller,
   return !Caller.callsOpaqueObject() && Caller.getAttributes().count(this) &&
          Callee && Callee->getAttributes().count(this);
 }
+
+bool NoWritePtrParameterAttr::infer(const FunctionDecl *FD) const {
+  using namespace ast_matchers;
+  MatchFinder Finder;
+
+  class Callback : public ast_matchers::MatchFinder::MatchCallback {
+  public:
+    bool MayWritePtrParam = false;
+
+    void
+    run(const ast_matchers::MatchFinder::MatchResult &Result) override final {
+      const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("fn");
+      if (!FD)
+        return;
+
+      MayWritePtrParam = true;
+    }
+  } CB;
+
+  auto ptrParmDeclRef = declRefExpr(
+      allOf(unless(hasAncestor(unaryOperator(hasOperatorName("*")))),
+            to(parmVarDecl(hasType(pointerType())))));
+  auto ptrParmDereference = unaryOperator(allOf(
+      hasOperatorName("*"),
+      hasDescendant(declRefExpr(to(parmVarDecl(hasType(pointerType())))))));
+
+  Finder.addMatcher(
+      functionDecl(
+          anyOf(
+              // The value of the pointer is used to initialize a local
+              // variable.
+              forEachDescendant(
+                  varDecl(hasInitializer(hasDescendant(ptrParmDeclRef)))),
+              // The ptr parameter appears on the RHS of an assignment.
+              forEachDescendant(
+                  binaryOperator(isAssignmentOperator(),
+                                 hasRHS(hasDescendant(ptrParmDeclRef)))),
+              // The ptr is dereferenced on the LHS of an assignment.
+              forEachDescendant(binaryOperator(
+                  isAssignmentOperator(),
+                  hasLHS(anyOf(ptrParmDereference,
+                               hasDescendant(ptrParmDereference))))),
+              // The param is const casted
+              forEachDescendant(cxxConstCastExpr(hasDescendant(ptrParmDeclRef)))
+              // FIXME: handle member access
+              ))
+          .bind("fn"),
+      &CB);
+  Finder.match(*FD, FD->getASTContext());
+  return !CB.MayWritePtrParam;
+}
+
+bool NoWritePtrParameterAttr::merge(const FunctionSummary &Caller,
+                                    const FunctionSummary *Callee) const {
+  return !Caller.callsOpaqueObject() && Caller.getAttributes().count(this) &&
+         Callee && Callee->getAttributes().count(this);
+}
 } // namespace clang

clang/lib/Summary/SummaryContext.cpp

@@ -74,7 +74,10 @@ template <typename T> void SummaryContext::registerAttr() {
   KindToAttribute[Kind] = Attributes.emplace_back(std::move(attr)).get();
 }
 
-SummaryContext::SummaryContext() { registerAttr<NoWriteGlobalAttr>(); }
+SummaryContext::SummaryContext() {
+  registerAttr<NoWriteGlobalAttr>();
+  registerAttr<NoWritePtrParameterAttr>();
+}
 
 void SummaryContext::CreateSummary(SmallVector<char> ID,
                                    std::set<const SummaryAttr *> Attrs,