[analyzer] Enable control dependency condition tracking by default

[Szelethus]

Summary

This patch concludes my GSoC'19 project by enabling track-conditions by default.

[Szelethus]

Rebase.

[NoQ]

The code looks good and there seems to be a lot of test coverage :]

[Szelethus]

In D66381#1639679, @NoQ wrote:

The code looks good and there seems to be a lot of test coverage :]

Thank you! It would not have been possible on my own! And actually, there are a couple minor nits, such as caching the retrieved CFGBlock for each ExplodedNode (at least for the node we're calculating control dependencies for), so I'll address that soon™.

clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.def

 ANALYZER_OPTION(bool, DisplayCTUProgress, "display-ctu-progress",
                 "Whether to emit verbose output about "
                 "the analyzer's progress related to ctu.",
                 false)
 
 ANALYZER_OPTION(bool, ShouldTrackConditions, "track-conditions",
                 "Whether to track conditions that are a control dependency of "
                 "an already tracked variable.",
-                false)
+                true)
 
 ANALYZER_OPTION(bool, ShouldTrackConditionsDebug, "track-conditions-debug",
                 "Whether to place an event at each tracked condition.",
                 false)
 
 ANALYZER_OPTION(unsigned, CTUImportThreshold, "ctu-import-threshold",
                 "The maximal amount of translation units that is considered "
                 "for import when inlining functions during CTU analysis. "

clang/test/Analysis/analyzer-config.c

 // CHECK-NEXT: prune-paths = true
 // CHECK-NEXT: region-store-small-struct-limit = 2
 // CHECK-NEXT: report-in-main-source-file = false
 // CHECK-NEXT: serialize-stats = false
 // CHECK-NEXT: stable-report-filename = false
 // CHECK-NEXT: suppress-c++-stdlib = true
 // CHECK-NEXT: suppress-inlined-defensive-checks = true
 // CHECK-NEXT: suppress-null-return-paths = true
-// CHECK-NEXT: track-conditions = false
+// CHECK-NEXT: track-conditions = true
 // CHECK-NEXT: track-conditions-debug = false
 // CHECK-NEXT: unix.DynamicMemoryModeling:Optimistic = false
 // CHECK-NEXT: unroll-loops = false
 // CHECK-NEXT: widen-loops = false
 // CHECK-NEXT: [stats]
 // CHECK-NEXT: num-entries = 89

clang/test/Analysis/diagnostics/no-store-func-path-notes.m

 @implementation I
 - (int)initVar:(int *)var param:(int)param {
   if (param) { // expected-note{{'param' is 0}}
                // expected-note@-1{{Taking false branch}}
     *var = 1;
     return 0;
   }
   return 1; // expected-note{{Returning without writing to '*var'}}
+  // expected-note@-1{{Returning the value 1, which will be (a part of a) condition}}
 }
 @end
 
 int foo(I *i) {
   int x;                            //expected-note{{'x' declared without an initial value}}
   int out = [i initVar:&x param:0]; //expected-note{{Calling 'initVar:param:'}}
                                     //expected-note@-1{{Returning from 'initVar:param:'}}
   if (out)                          //expected-note{{'out' is 1}}

clang/test/Analysis/return-value-guaranteed.cpp

if (problem()) {
     // class-note@-2 {{Taking false branch}}
     return MCAsmParser::Error();
   }
 
   F.Field = 0;
   // class-note@-1 {{The value 0 is assigned to 'F.Field'}}
   return !MCAsmParser::Error();
   // class-note@-1 {{'MCAsmParser::Error' returns true}}
+  // class-note@-2 {{Returning zero, which will be (a part of a) condition}}
 }
 
 bool parseFile() {
   Foo F;
   if (parseFoo(F)) {
     // class-note@-1 {{Calling 'parseFoo'}}
     // class-note@-2 {{Returning from 'parseFoo'}}
     // class-note@-3 {{Taking false branch}}

 
 
 // We predefined 'MCAsmParser::Error' as returning true, but now it returns
 // false, which breaks our invariant. Test the notes.
 namespace test_break {
 struct MCAsmParser {
   static bool Error() {
     return false; // class-note {{'MCAsmParser::Error' returns false}}
+    // class-note@-1 {{Returning zero, which will be (a part of a) condition}}
   }
 };
 
 bool parseFoo(Foo &F) {
   if (problem()) {
     // class-note@-1 {{Assuming the condition is false}}
     // class-note@-2 {{Taking false branch}}
     return !MCAsmParser::Error();
   }
 
   F.Field = 0;
   // class-note@-1 {{The value 0 is assigned to 'F.Field'}}
   return MCAsmParser::Error();
   // class-note@-1 {{Calling 'MCAsmParser::Error'}}
   // class-note@-2 {{Returning from 'MCAsmParser::Error'}}
+  // class-note@-3 {{Returning zero, which will be (a part of a) condition}}
 }
 
 bool parseFile() {
   Foo F;
   if (parseFoo(F)) {
     // class-note@-1 {{Calling 'parseFoo'}}
     // class-note@-2 {{Returning from 'parseFoo'}}
     // class-note@-3 {{Taking false branch}}

clang/test/Analysis/track-control-dependency-conditions.cpp

 // RUN: %clang_analyze_cc1 %s \
 // RUN:   -verify=expected,tracking \
 // RUN:   -analyzer-config track-conditions=true \
 // RUN:   -analyzer-output=text \
 // RUN:   -analyzer-checker=core
 
 // RUN: not %clang_analyze_cc1 -verify %s \
 // RUN:   -analyzer-checker=core \
+// RUN:   -analyzer-config track-conditions=false \
 // RUN:   -analyzer-config track-conditions-debug=true \
 // RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-INVALID-DEBUG
 
 // CHECK-INVALID-DEBUG: (frontend): invalid input for analyzer-config option
 // CHECK-INVALID-DEBUG-SAME:        'track-conditions-debug', that expects
 // CHECK-INVALID-DEBUG-SAME:        'track-conditions' to also be enabled
 //
 // RUN: %clang_analyze_cc1 %s \
 // RUN:   -verify=expected,tracking,debug \
 // RUN:   -analyzer-config track-conditions=true \
 // RUN:   -analyzer-config track-conditions-debug=true \
 // RUN:   -analyzer-output=text \
 // RUN:   -analyzer-checker=core
 
 // RUN: %clang_analyze_cc1 %s -verify \
 // RUN:   -analyzer-output=text \
+// RUN:   -analyzer-config track-conditions=false \
 // RUN:   -analyzer-checker=core
 
 namespace example_1 {
 int flag;
 bool coin();
 
 void foo() {
   flag = coin(); // tracking-note{{Value assigned to 'flag', which will be (a part of a) condition}}