adds -Wfree-nonheap-object member var checks

[cjdb]

Summary

Checks to make sure that stdlib's (std::)free is being appropriately
used for member variables.

[aaron.ballman]

clang/lib/Sema/SemaChecking.cpp

10110–10112

const std::string&?

10123

const std::string&?

clang/test/Sema/warn-free-nonheap-object.cpp

17

Can you also verify that ::free(ptr) does not diagnose? (since that would require CFG)

[aaron.ballman]

LGTM!

clang/lib/Sema/SemaChecking.cpp

void Sema::CheckStrncatArguments(const CallExpr *CE,
   DstArg->printPretty(OS, nullptr, getPrintingPolicy());
   OS << ") - 1";
 
   Diag(SL, diag::note_strncat_wrong_size)
     << FixItHint::CreateReplacement(SR, OS.str());
 }
 
 namespace {
-void CheckFreeArgumentsAddressof(Sema &S, const std::string &CalleeName,
-                                 const UnaryOperator *UnaryExpr) {
-  if (UnaryExpr->getOpcode() != UnaryOperator::Opcode::UO_AddrOf)
-    return;
-
-  const auto *Lvalue = dyn_cast<DeclRefExpr>(UnaryExpr->getSubExpr());
-  if (Lvalue == nullptr)
-    return;
-
-  const auto *Var = dyn_cast<VarDecl>(Lvalue->getDecl());
-  if (Var == nullptr)
-    return;
-
+void CheckFreeArgumentsOnLvalue(Sema &S, const std::string &CalleeName,
+                                const UnaryOperator *UnaryExpr,
+                                const VarDecl *Var) {
   StorageClass Class = Var->getStorageClass();
   if (Class == StorageClass::SC_Extern ||
       Class == StorageClass::SC_PrivateExtern ||
       Var->getType()->isReferenceType())
     return;
 
   S.Diag(UnaryExpr->getBeginLoc(), diag::warn_free_nonheap_object)
       << CalleeName << Var;
 }
 
+void CheckFreeArgumentsOnLvalue(Sema &S, const std::string &CalleeName,
+                                const UnaryOperator *UnaryExpr, const Decl *D) {
+  if (const auto *Field = dyn_cast<FieldDecl>(D))
+    S.Diag(UnaryExpr->getBeginLoc(), diag::warn_free_nonheap_object)
+        << CalleeName << Field;
+}
+
+void CheckFreeArgumentsAddressof(Sema &S, const std::string &CalleeName,
+                                 const UnaryOperator *UnaryExpr) {
+  if (UnaryExpr->getOpcode() != UnaryOperator::Opcode::UO_AddrOf)
+    return;
+
+  if (const auto *Lvalue = dyn_cast<DeclRefExpr>(UnaryExpr->getSubExpr()))
+    if (const auto *Var = dyn_cast<VarDecl>(Lvalue->getDecl()))
+      return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr, Var);
+
+  if (const auto *Lvalue = dyn_cast<MemberExpr>(UnaryExpr->getSubExpr()))
+    return CheckFreeArgumentsOnLvalue(S, CalleeName, UnaryExpr,
+                                      Lvalue->getMemberDecl());
+}
+
 void CheckFreeArgumentsStackArray(Sema &S, const std::string &CalleeName,
                                   const DeclRefExpr *Lvalue) {
   if (!Lvalue->getType()->isArrayType())
     return;
 
   const auto *Var = dyn_cast<VarDecl>(Lvalue->getDecl());
   if (Var == nullptr)
     return;

clang/test/Sema/warn-free-nonheap-object.c

 // RUN: %clang_cc1 -Wfree-nonheap-object -fsyntax-only -verify %s
 
 typedef __SIZE_TYPE__ size_t;
 void *malloc(size_t);
 void free(void *);
 
+struct S {
+  int I;
+  char *P;
+};
+
 int GI;
 void test() {
   {
     free(&GI); // expected-warning {{attempt to call free on non-heap object 'GI'}}
   }
   {
     static int SI = 0;
     free(&SI); // expected-warning {{attempt to call free on non-heap object 'SI'}}
void test() {
     void *P = malloc(8);
     free(P);
   }
   {
     int A[] = {0, 1, 2, 3};
     free(A);  // expected-warning {{attempt to call free on non-heap object 'A'}}
     free(&A); // expected-warning {{attempt to call free on non-heap object 'A'}}
   }
+  {
+    struct S s;
+    free(&s.I); // expected-warning {{attempt to call free on non-heap object 'I'}}
+    free(s.P);
+  }
 }

clang/test/Sema/warn-free-nonheap-object.cpp

 // RUN: %clang_cc1 -Wfree-nonheap-object -std=c++11 -x c++ -fsyntax-only -verify %s
 
 extern "C" void free(void *) {}
 
 namespace std {
 using size_t = decltype(sizeof(0));
 void *malloc(size_t);
 void free(void *p);
 } // namespace std
 
 int GI;
 
 struct S {
   operator char *() { return ptr; }
 
+  void CFree() {
+    ::free(&ptr); // expected-warning {{attempt to call free on non-heap object 'ptr'}}
+    ::free(&I);   // expected-warning {{attempt to call free on non-heap object 'I'}}
+    ::free(ptr);
+  }
+
+  void CXXFree() {
+    std::free(&ptr); // expected-warning {{attempt to call std::free on non-heap object 'ptr'}}
+    std::free(&I);   // expected-warning {{attempt to call std::free on non-heap object 'I'}}
+    std::free(ptr);
+  }
+
 private:
   char *ptr = (char *)std::malloc(10);
+  static int I;
 };
 
+int S::I = 0;
+
 void test1() {
   {
     free(&GI); // expected-warning {{attempt to call free on non-heap object 'GI'}}
   }
   {
     static int SI = 0;
     free(&SI); // expected-warning {{attempt to call free on non-heap object 'SI'}}
   }
void test1() {
     int A[] = {0, 1, 2, 3};
     free(&A); // expected-warning {{attempt to call free on non-heap object 'A'}}
   }
   {
     S s;
     free(s);
     free(&s); // expected-warning {{attempt to call free on non-heap object 's'}}
   }
+  {
+    S s;
+    s.CFree();
+  }
 }
 
 void test2() {
   {
     std::free(&GI); // expected-warning {{attempt to call std::free on non-heap object 'GI'}}
   }
   {
     static int SI = 0;
void test2() {
     int A[] = {0, 1, 2, 3};
     std::free(&A); // expected-warning {{attempt to call std::free on non-heap object 'A'}}
   }
   {
     S s;
     std::free(s);
     std::free(&s); // expected-warning {{attempt to call std::free on non-heap object 's'}}
   }
+  {
+    S s;
+    s.CXXFree();
+  }
 }