Adds -Wfree-nonheap-object to -Wmost

[cjdb]

Summary

We'd discussed adding the warning to -Wall in D89988. This patch honours that.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

7624

Would it make more sense to remove the DefaultIgnore rather than explicitly adding the diagnostic group to -Wmost?

[aaron.ballman]

LGTM! We may want to file a bug report for the static analyzer to not duplicate the diagnostics from the frontend now that this is no longer ignored by default.

[cjdb]

Merged in 4a47da2cf440c2f2006d9b04acfef4292de1e263.

[xbolva00]

Can you mention this new warning in release notes?

https://clang.llvm.org/docs/ReleaseNotes.html

clang/include/clang/Basic/DiagnosticGroups.td

 
 def FloatOverflowConversion : DiagGroup<"float-overflow-conversion">;
 def FloatZeroConversion : DiagGroup<"float-zero-conversion">;
 def FloatConversion :
   DiagGroup<"float-conversion", [FloatOverflowConversion,
                                  FloatZeroConversion]>;
 
 def FrameAddress : DiagGroup<"frame-address">;
+def FreeNonHeapObject : DiagGroup<"free-nonheap-object">;
 def DoublePromotion : DiagGroup<"double-promotion">;
 def EnumTooLarge : DiagGroup<"enum-too-large">;
 def UnsupportedNan : DiagGroup<"unsupported-nan">;
 def UnsupportedAbs : DiagGroup<"unsupported-abs">;
 def UnsupportedFPOpt : DiagGroup<"unsupported-floating-point-opt">;
 def UnsupportedCB : DiagGroup<"unsupported-cb">;
 def UnsupportedGPOpt : DiagGroup<"unsupported-gpopt">;
 def UnsupportedTargetOpt : DiagGroup<"unsupported-target-opt">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_not_tag_in_scope : Error<
   "no %select{struct|interface|union|class|enum}0 named %1 in %2">;
 
 def err_no_typeid_with_fno_rtti : Error<
   "use of typeid requires -frtti">;
 def err_no_dynamic_cast_with_fno_rtti : Error<
   "use of dynamic_cast requires -frtti">;
 def warn_no_dynamic_cast_with_rtti_disabled: Warning<
-  "dynamic_cast will not work since RTTI data is disabled by " 
+  "dynamic_cast will not work since RTTI data is disabled by "
   "%select{-fno-rtti-data|/GR-}0">, InGroup<RTTI>;
 def warn_no_typeid_with_rtti_disabled: Warning<
   "typeid will not work since RTTI data is disabled by "
   "%select{-fno-rtti-data|/GR-}0">, InGroup<RTTI>;
 
 def err_cannot_form_pointer_to_member_of_reference_type : Error<
   "cannot form a pointer-to-member to member %0 of reference type %1">;
 def err_incomplete_object_call : Error<
   "incomplete type in call to object of type %0">;
 
 def warn_condition_is_assignment : Warning<"using the result of an "
   "assignment as a condition without parentheses">,
   InGroup<Parentheses>;
 def warn_free_nonheap_object
   : Warning<"attempt to call %0 on non-heap object %1">,
-    InGroup<DiagGroup<"free-nonheap-object">>,
-    DefaultIgnore; // FIXME: add to -Wall after sufficient testing
+    InGroup<FreeNonHeapObject>;
 
 // Completely identical except off by default.
 def warn_condition_is_idiomatic_assignment : Warning<"using the result "
   "of an assignment as a condition without parentheses">,
   InGroup<DiagGroup<"idiomatic-parentheses">>, DefaultIgnore;
 def note_condition_assign_to_comparison : Note<
   "use '==' to turn this assignment into an equality comparison">;
 def note_condition_or_assign_to_comparison : Note<
   "use '!=' to turn this compound assignment into an inequality comparison">;

clang/test/Analysis/NewDelete-intersections.mm

 #include "Inputs/system-header-simulator-objc.h"
 
 typedef __typeof__(sizeof(int)) size_t;
 extern "C" void *malloc(size_t);
 extern "C" void *alloca(size_t);
 extern "C" void free(void *);
 
 void testMallocFreeNoWarn() {
-  int i;
-  free(&i); // no warn
-
   int *p1 = (int *)malloc(sizeof(int));
   free(++p1); // no warn
 
   int *p2 = (int *)malloc(sizeof(int));
   free(p2);
   free(p2); // no warn
 
   int *p3 = (int *)malloc(sizeof(int)); // no warn
 
   int *p4 = (int *)malloc(sizeof(int));
   free(p4);
   int j = *p4; // no warn
 
   int *p5 = (int *)alloca(sizeof(int));
   free(p5); // no warn
 }
 
 void testDeleteMalloced() {
   int *p1 = (int *)malloc(sizeof(int));
   delete p1;
   // mismatch-warning@-1{{Memory allocated by malloc() should be deallocated by free(), not 'delete'}}
 
   int *p2 = (int *)__builtin_alloca(sizeof(int));
   delete p2; // no warn
-} 
+}
 
 void testUseZeroAllocatedMalloced() {
   int *p1 = (int *)malloc(0);
   *p1 = 1; // no warn
 }
 
 //----- Test free standard new
 void testFreeOpNew() {

 
 void testObjcFreeNewed() {
   int *p = new int;
   NSData *nsdata = [NSData dataWithBytesNoCopy:p length:sizeof(int) freeWhenDone:1];
   // mismatch-warning@-1{{+dataWithBytesNoCopy:length:freeWhenDone: cannot take ownership of memory allocated by 'new'}}
 }
 
 void testFreeAfterDelete() {
-  int *p = new int;  
+  int *p = new int;
   delete p;
   free(p); // newdelete-warning{{Use of memory after it is freed}}
 }
 
 void testStandardPlacementNewAfterDelete() {
-  int *p = new int;  
+  int *p = new int;
   delete p;
   p = new (p) int; // newdelete-warning{{Use of memory after it is freed}}
 }

clang/test/Analysis/free.c

 // RUN: %clang_analyze_cc1 -fblocks -verify %s -analyzer-store=region \
 // RUN:   -analyzer-checker=core \
 // RUN:   -analyzer-checker=unix.Malloc
 //
 // RUN: %clang_analyze_cc1 -fblocks -verify %s -analyzer-store=region \
 // RUN:   -analyzer-checker=core \
 // RUN:   -analyzer-checker=unix.Malloc \
 // RUN:   -analyzer-config unix.DynamicMemoryModeling:Optimistic=true
 typedef __typeof(sizeof(int)) size_t;
 void free(void *);
 void *alloca(size_t);
 
 void t1 () {
   int a[] = { 1 };
-  free(a); // expected-warning {{Argument to free() is the address of the local variable 'a', which is not memory allocated by malloc()}}
+  free(a);
+  // expected-warning@-1{{Argument to free() is the address of the local variable 'a', which is not memory allocated by malloc()}}
+  // expected-warning@-2{{attempt to call free on non-heap object 'a'}}
 }
 
 void t2 () {
   int a = 1;
-  free(&a); // expected-warning {{Argument to free() is the address of the local variable 'a', which is not memory allocated by malloc()}}
+  free(&a);
+  // expected-warning@-1{{Argument to free() is the address of the local variable 'a', which is not memory allocated by malloc()}}
+  // expected-warning@-2{{attempt to call free on non-heap object 'a'}}
 }
 
 void t3 () {
   static int a[] = { 1 };
-  free(a); // expected-warning {{Argument to free() is the address of the static variable 'a', which is not memory allocated by malloc()}}
+  free(a);
+  // expected-warning@-1{{Argument to free() is the address of the static variable 'a', which is not memory allocated by malloc()}}
+  // expected-warning@-2{{attempt to call free on non-heap object 'a'}}
 }
 
 void t4 (char *x) {
   free(x); // no-warning
 }
 
 void t5 () {
   extern char *ptr();
void t12 () {
   free(p); // expected-warning {{Memory allocated by alloca() should not be deallocated}}
 }
 
 void t13 () {
   free(^{return;}); // expected-warning {{Argument to free() is a block, which is not memory allocated by malloc()}}
 }
 
 void t14 (char a) {
-  free(&a); // expected-warning {{Argument to free() is the address of the parameter 'a', which is not memory allocated by malloc()}}
+  free(&a);
+  // expected-warning@-1{{Argument to free() is the address of the parameter 'a', which is not memory allocated by malloc()}}
+  // expected-warning@-2{{attempt to call free on non-heap object 'a'}}
 }
 
 static int someGlobal[2];
 void t15 () {
-  free(someGlobal); // expected-warning {{Argument to free() is the address of the global variable 'someGlobal', which is not memory allocated by malloc()}}
+  free(someGlobal);
+  // expected-warning@-1{{Argument to free() is the address of the global variable 'someGlobal', which is not memory allocated by malloc()}}
+  // expected-warning@-2{{attempt to call free on non-heap object 'someGlobal'}}
 }
 
 void t16 (char **x, int offset) {
   // Unknown value
   free(x[offset]); // no-warning
 }