Index: clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp =================================================================== --- clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp +++ clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp @@ -298,6 +298,7 @@ MemRegionManager &MmrMgr; const SourceManager &SM; const PrintingPolicy &PP; + bugreporter::TrackingKind TKind; /// Recursion limit for dereferencing fields when looking for the /// region of interest. @@ -318,10 +319,10 @@ using RegionVector = SmallVector; public: - NoStoreFuncVisitor(const SubRegion *R) + NoStoreFuncVisitor(const SubRegion *R, bugreporter::TrackingKind TKind) : RegionOfInterest(R), MmrMgr(*R->getMemRegionManager()), SM(MmrMgr.getContext().getSourceManager()), - PP(MmrMgr.getContext().getPrintingPolicy()) {} + PP(MmrMgr.getContext().getPrintingPolicy()), TKind(TKind) {} void Profile(llvm::FoldingSetNodeID &ID) const override { static int Tag = 0; @@ -612,6 +613,9 @@ } while (N); } +static llvm::StringLiteral WillBeUsedForACondition = + ", which participates in a condition later"; + PathDiagnosticPieceRef NoStoreFuncVisitor::maybeEmitNote( BugReport &R, const CallEvent &Call, const ExplodedNode *N, const RegionVector &FieldChain, const MemRegion *MatchedRegion, @@ -658,6 +662,8 @@ return nullptr; os << "'"; + if (TKind == bugreporter::TrackingKind::Condition) + os << WillBeUsedForACondition; return std::make_shared(L, os.str()); } @@ -1068,6 +1074,9 @@ if (!L.isValid() || !L.asLocation().isValid()) return nullptr; + if (TKind == bugreporter::TrackingKind::Condition) + Out << WillBeUsedForACondition; + auto EventPiece = std::make_shared(L, Out.str()); // If we determined that the note is meaningless, make it prunable, and @@ -1485,6 +1494,9 @@ if (os.str().empty()) showBRDefaultDiagnostics(os, R, V); + if (TKind == bugreporter::TrackingKind::Condition) + os << WillBeUsedForACondition; + // Construct a new PathDiagnosticPiece. ProgramPoint P = StoreSite->getLocation(); PathDiagnosticLocation L; @@ -1969,7 +1981,7 @@ // Mark both the variable region and its contents as interesting. SVal V = LVState->getRawSVal(loc::MemRegionVal(R)); report.addVisitor( - llvm::make_unique(cast(R))); + llvm::make_unique(cast(R), TKind)); MacroNullReturnSuppressionVisitor::addMacroVisitorIfNecessary( LVNode, R, EnableNullFPSuppression, report, V); Index: clang/test/Analysis/track-control-dependency-conditions.cpp =================================================================== --- clang/test/Analysis/track-control-dependency-conditions.cpp +++ clang/test/Analysis/track-control-dependency-conditions.cpp @@ -29,24 +29,24 @@ bool coin(); void foo() { - flag = coin(); // tracking-note{{Value assigned to 'flag'}} + flag = coin(); // tracking-note-re{{{{^}}Value assigned to 'flag', which participates in a condition later{{$}}}} } void test() { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} flag = 1; foo(); // TODO: Add nodes here about flag's value being invalidated. - if (flag) // expected-note {{Assuming 'flag' is 0}} - // expected-note@-1{{Taking false branch}} + if (flag) // expected-note-re {{{{^}}Assuming 'flag' is 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking false branch{{$}}}} x = new int; - foo(); // tracking-note{{Calling 'foo'}} - // tracking-note@-1{{Returning from 'foo'}} + foo(); // tracking-note-re{{{{^}}Calling 'foo'{{$}}}} + // tracking-note-re@-1{{{{^}}Returning from 'foo'{{$}}}} - if (flag) // expected-note {{Assuming 'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + if (flag) // expected-note-re {{{{^}}Assuming 'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} @@ -58,7 +58,7 @@ bool coin(); void foo() { - flag = coin(); // tracking-note{{Value assigned to 'flag'}} + flag = coin(); // tracking-note-re{{{{^}}Value assigned to 'flag', which participates in a condition later{{$}}}} } void test() { @@ -66,18 +66,18 @@ flag = 1; foo(); - if (flag) // expected-note {{Assuming 'flag' is 0}} - // expected-note@-1{{Taking false branch}} + if (flag) // expected-note-re {{{{^}}Assuming 'flag' is 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking false branch{{$}}}} x = new int; - x = 0; // expected-note{{Null pointer value stored to 'x'}} + x = 0; // expected-note-re{{{{^}}Null pointer value stored to 'x'{{$}}}} - foo(); // tracking-note{{Calling 'foo'}} - // tracking-note@-1{{Returning from 'foo'}} + foo(); // tracking-note-re{{{{^}}Calling 'foo'{{$}}}} + // tracking-note-re@-1{{{{^}}Returning from 'foo'{{$}}}} - if (flag) // expected-note {{Assuming 'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + if (flag) // expected-note-re {{{{^}}Assuming 'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} @@ -90,25 +90,25 @@ void foo() { // coin() could write bar, do it's invalidated. - flag = coin(); // tracking-note{{Value assigned to 'flag'}} - // tracking-note@-1{{Value assigned to 'bar'}} + flag = coin(); // tracking-note-re{{{{^}}Value assigned to 'flag', which participates in a condition later{{$}}}} + // tracking-note-re@-1{{{{^}}Value assigned to 'bar', which participates in a condition later{{$}}}} } int bar; void test() { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} flag = 1; - foo(); // tracking-note{{Calling 'foo'}} - // tracking-note@-1{{Returning from 'foo'}} + foo(); // tracking-note-re{{{{^}}Calling 'foo'{{$}}}} + // tracking-note-re@-1{{{{^}}Returning from 'foo'{{$}}}} - if (bar) // expected-note {{Assuming 'bar' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'bar'}} - if (flag) // expected-note {{Assuming 'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + if (bar) // expected-note-re {{{{^}}Assuming 'bar' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'bar'{{$}}}} + if (flag) // expected-note-re {{{{^}}Assuming 'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} @@ -125,11 +125,11 @@ int bar; void test() { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} - if (int flag = foo()) // debug-note{{Tracking condition 'flag'}} - // expected-note@-1{{Assuming 'flag' is not equal to 0}} - // expected-note@-2{{Taking true branch}} + if (int flag = foo()) // debug-note-re{{{{^}}Tracking condition 'flag'{{$}}}} + // expected-note-re@-1{{{{^}}Assuming 'flag' is not equal to 0{{$}}}} + // expected-note-re@-2{{{{^}}Taking true branch{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} @@ -144,12 +144,12 @@ }; void test() { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} if (ConvertsToBool()) - // debug-note@-1{{Tracking condition 'ConvertsToBool()'}} - // expected-note@-2{{Assuming the condition is true}} - // expected-note@-3{{Taking true branch}} + // debug-note-re@-1{{{{^}}Tracking condition 'ConvertsToBool()'{{$}}}} + // expected-note-re@-2{{{{^}}Assuming the condition is true{{$}}}} + // expected-note-re@-3{{{{^}}Taking true branch{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -159,9 +159,9 @@ namespace note_from_different_but_not_nested_stackframe { void nullptrDeref(int *ptr, bool True) { - if (True) // expected-note{{'True' is true}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'True}} + if (True) // expected-note-re{{{{^}}'True' is true{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'True'{{$}}}} *ptr = 5; // expected-note@-1{{Dereference of null pointer (loaded from variable 'ptr')}} // expected-warning@-2{{Dereference of null pointer (loaded from variable 'ptr')}} @@ -169,11 +169,11 @@ void f() { int *ptr = nullptr; - // expected-note@-1{{'ptr' initialized to a null pointer value}} + // expected-note-re@-1{{{{^}}'ptr' initialized to a null pointer value{{$}}}} bool True = true; nullptrDeref(ptr, True); - // expected-note@-1{{Passing null pointer value via 1st parameter 'ptr'}} - // expected-note@-2{{Calling 'nullptrDeref'}} + // expected-note-re@-1{{{{^}}Passing null pointer value via 1st parameter 'ptr'{{$}}}} + // expected-note-re@-2{{{{^}}Calling 'nullptrDeref'{{$}}}} } } // end of namespace note_from_different_but_not_nested_stackframe @@ -184,26 +184,26 @@ int *getIntPtr(); void storeValue(int **i) { - *i = getIntPtr(); // tracking-note{{Value assigned to 'i'}} + *i = getIntPtr(); // tracking-note-re{{{{^}}Value assigned to 'i', which participates in a condition later{{$}}}} } int *conjurePointer() { int *i; - storeValue(&i); // tracking-note{{Calling 'storeValue'}} - // tracking-note@-1{{Returning from 'storeValue'}} - return i; // tracking-note{{Returning pointer (loaded from 'i')}} + storeValue(&i); // tracking-note-re{{{{^}}Calling 'storeValue'{{$}}}} + // tracking-note-re@-1{{{{^}}Returning from 'storeValue'{{$}}}} + return i; // tracking-note-re{{{{^}}Returning pointer (loaded from 'i'), which participates in a condition later{{$}}}} } void f(int *ptr) { - if (ptr) // expected-note{{Assuming 'ptr' is null}} - // expected-note@-1{{Taking false branch}} + if (ptr) // expected-note-re{{{{^}}Assuming 'ptr' is null{{$}}}} + // expected-note-re@-1{{{{^}}Taking false branch{{$}}}} ; if (!conjurePointer()) - // tracking-note@-1{{Calling 'conjurePointer'}} - // tracking-note@-2{{Returning from 'conjurePointer'}} - // debug-note@-3{{Tracking condition '!conjurePointer()'}} - // expected-note@-4{{Assuming the condition is true}} - // expected-note@-5{{Taking true branch}} + // tracking-note-re@-1{{{{^}}Calling 'conjurePointer'{{$}}}} + // tracking-note-re@-2{{{{^}}Returning from 'conjurePointer'{{$}}}} + // debug-note-re@-3{{{{^}}Tracking condition '!conjurePointer()'{{$}}}} + // expected-note-re@-4{{{{^}}Assuming the condition is true{{$}}}} + // expected-note-re@-5{{{{^}}Taking true branch{{$}}}} *ptr = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -220,13 +220,13 @@ } void f(int *ptr) { - if (ptr) // expected-note{{Assuming 'ptr' is null}} - // expected-note@-1{{Taking false branch}} + if (ptr) // expected-note-re{{{{^}}Assuming 'ptr' is null{{$}}}} + // expected-note-re@-1{{{{^}}Taking false branch{{$}}}} ; if (!conjurePointer()) - // debug-note@-1{{Tracking condition '!conjurePointer()'}} - // expected-note@-2{{Assuming the condition is true}} - // expected-note@-3{{Taking true branch}} + // debug-note-re@-1{{{{^}}Tracking condition '!conjurePointer()'{{$}}}} + // expected-note-re@-2{{{{^}}Assuming the condition is true{{$}}}} + // expected-note-re@-3{{{{^}}Taking true branch{{$}}}} *ptr = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -241,12 +241,12 @@ } void f() { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} if (cast(conjure())) - // debug-note@-1{{Tracking condition 'cast(conjure())'}} - // expected-note@-2{{Assuming the condition is false}} - // expected-note@-3{{Taking false branch}} + // debug-note-re@-1{{{{^}}Tracking condition 'cast(conjure())'{{$}}}} + // expected-note-re@-2{{{{^}}Assuming the condition is false{{$}}}} + // expected-note-re@-3{{{{^}}Taking false branch{{$}}}} return; *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} @@ -260,13 +260,13 @@ bool flipCoin() { return coin(); } void i(int *ptr) { - if (ptr) // expected-note{{Assuming 'ptr' is null}} - // expected-note@-1{{Taking false branch}} + if (ptr) // expected-note-re{{{{^}}Assuming 'ptr' is null{{$}}}} + // expected-note-re@-1{{{{^}}Taking false branch{{$}}}} ; if (!flipCoin()) - // debug-note@-1{{Tracking condition '!flipCoin()'}} - // expected-note@-2{{Assuming the condition is true}} - // expected-note@-3{{Taking true branch}} + // debug-note-re@-1{{{{^}}Tracking condition '!flipCoin()'{{$}}}} + // expected-note-re@-2{{{{^}}Assuming the condition is true{{$}}}} + // expected-note-re@-3{{{{^}}Taking true branch{{$}}}} *ptr = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -276,23 +276,23 @@ bool coin(); bool flipCoin() { - if (coin()) // tracking-note{{Assuming the condition is false}} - // tracking-note@-1{{Taking false branch}} - // debug-note@-2{{Tracking condition 'coin()'}} + if (coin()) // tracking-note-re{{{{^}}Assuming the condition is false{{$}}}} + // tracking-note-re@-1{{{{^}}Taking false branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'coin()'{{$}}}} return true; - return coin(); // tracking-note{{Returning value}} + return coin(); // tracking-note-re{{{{^}}Returning value, which participates in a condition later{{$}}}} } void i(int *ptr) { - if (ptr) // expected-note{{Assuming 'ptr' is null}} - // expected-note@-1{{Taking false branch}} + if (ptr) // expected-note-re{{{{^}}Assuming 'ptr' is null{{$}}}} + // expected-note-re@-1{{{{^}}Taking false branch{{$}}}} ; if (!flipCoin()) - // tracking-note@-1{{Calling 'flipCoin'}} - // tracking-note@-2{{Returning from 'flipCoin'}} - // debug-note@-3{{Tracking condition '!flipCoin()'}} - // expected-note@-4{{Assuming the condition is true}} - // expected-note@-5{{Taking true branch}} + // tracking-note-re@-1{{{{^}}Calling 'flipCoin'{{$}}}} + // tracking-note-re@-2{{{{^}}Returning from 'flipCoin'{{$}}}} + // debug-note-re@-3{{{{^}}Tracking condition '!flipCoin()'{{$}}}} + // expected-note-re@-4{{{{^}}Assuming the condition is true{{$}}}} + // expected-note-re@-5{{{{^}}Taking true branch{{$}}}} *ptr = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -307,22 +307,22 @@ bool flipCoin() { if (super_complicated_template_hackery::value) - // tracking-note@-1{{'value' is false}} - // tracking-note@-2{{Taking false branch}} + // tracking-note-re@-1{{{{^}}'value' is false{{$}}}} + // tracking-note-re@-2{{{{^}}Taking false branch{{$}}}} return true; - return coin(); // tracking-note{{Returning value}} + return coin(); // tracking-note-re{{{{^}}Returning value, which participates in a condition later{{$}}}} } void i(int *ptr) { - if (ptr) // expected-note{{Assuming 'ptr' is null}} - // expected-note@-1{{Taking false branch}} + if (ptr) // expected-note-re{{{{^}}Assuming 'ptr' is null{{$}}}} + // expected-note-re@-1{{{{^}}Taking false branch{{$}}}} ; if (!flipCoin()) - // tracking-note@-1{{Calling 'flipCoin'}} - // tracking-note@-2{{Returning from 'flipCoin'}} - // debug-note@-3{{Tracking condition '!flipCoin()'}} - // expected-note@-4{{Assuming the condition is true}} - // expected-note@-5{{Taking true branch}} + // tracking-note-re@-1{{{{^}}Calling 'flipCoin'{{$}}}} + // tracking-note-re@-2{{{{^}}Returning from 'flipCoin'{{$}}}} + // debug-note-re@-3{{{{^}}Tracking condition '!flipCoin()'{{$}}}} + // expected-note-re@-4{{{{^}}Assuming the condition is true{{$}}}} + // expected-note-re@-5{{{{^}}Taking true branch{{$}}}} *ptr = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -333,10 +333,10 @@ void f() { int flag = getInt(); - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} - if (flag) // expected-note{{Assuming 'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} + if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -350,10 +350,10 @@ y = 1; flag = y; - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} - if (flag) // expected-note{{'flag' is 1}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} + if (flag) // expected-note-re{{{{^}}'flag' is 1{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -366,18 +366,18 @@ void foo() { int y; y = 1; - flag = y; // tracking-note{{The value 1 is assigned to 'flag'}} + flag = y; // tracking-note-re{{{{^}}The value 1 is assigned to 'flag', which participates in a condition later{{$}}}} } void f(int y) { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} - foo(); // tracking-note{{Calling 'foo'}} - // tracking-note@-1{{Returning from 'foo'}} + foo(); // tracking-note-re{{{{^}}Calling 'foo'{{$}}}} + // tracking-note-re@-1{{{{^}}Returning from 'foo'{{$}}}} - if (flag) // expected-note{{'flag' is 1}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + if (flag) // expected-note-re{{{{^}}'flag' is 1{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -388,20 +388,20 @@ int getInt(); void foo() { - flag = getInt(); // tracking-note{{Value assigned to 'flag'}} + flag = getInt(); // tracking-note-re{{{{^}}Value assigned to 'flag', which participates in a condition later{{$}}}} } void f() { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} int y = 0; - foo(); // tracking-note{{Calling 'foo'}} - // tracking-note@-1{{Returning from 'foo'}} + foo(); // tracking-note-re{{{{^}}Calling 'foo'{{$}}}} + // tracking-note-re@-1{{{{^}}Returning from 'foo'{{$}}}} y = flag; - if (y) // expected-note{{Assuming 'y' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'y'}} + if (y) // expected-note-re{{{{^}}Assuming 'y' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'y'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -412,20 +412,20 @@ [[noreturn]] void halt(); void assert(int b) { - if (!b) // tracking-note{{Assuming 'b' is not equal to 0}} - // tracking-note@-1{{Taking false branch}} + if (!b) // tracking-note-re{{{{^}}Assuming 'b' is not equal to 0{{$}}}} + // tracking-note-re@-1{{{{^}}Taking false branch{{$}}}} halt(); } void f(int flag) { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} - assert(flag); // tracking-note{{Calling 'assert'}} - // tracking-note@-1{{Returning from 'assert'}} + assert(flag); // tracking-note-re{{{{^}}Calling 'assert'{{$}}}} + // tracking-note-re@-1{{{{^}}Returning from 'assert'{{$}}}} - if (flag) // expected-note{{'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + if (flag) // expected-note-re{{{{^}}'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -437,22 +437,22 @@ [[noreturn]] void halt(); void assert(int b) { - if (!b) // tracking-note{{Assuming 'b' is not equal to 0}} - // tracking-note@-1{{Taking false branch}} + if (!b) // tracking-note-re{{{{^}}Assuming 'b' is not equal to 0{{$}}}} + // tracking-note-re@-1{{{{^}}Taking false branch{{$}}}} halt(); } int getInt(); void f(int flag) { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} flag = getInt(); - assert(flag); // tracking-note{{Calling 'assert'}} - // tracking-note@-1{{Returning from 'assert'}} + assert(flag); // tracking-note-re{{{{^}}Calling 'assert'{{$}}}} + // tracking-note-re@-1{{{{^}}Returning from 'assert'{{$}}}} - if (flag) // expected-note{{'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + if (flag) // expected-note-re{{{{^}}'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -476,17 +476,17 @@ } void f(int flag) { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} flag = getInt(); bar(); - assert(cond1); // expected-note{{Assuming 'cond1' is not equal to 0}} - // expected-note@-1{{'?' condition is true}} + assert(cond1); // expected-note-re{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}'?' condition is true{{$}}}} - if (flag) // expected-note{{'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -513,20 +513,20 @@ } void f(int flag) { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} flag = getInt(); bar(); assert(cond1 && cond2); - // expected-note@-1{{Assuming 'cond1' is not equal to 0}} - // expected-note@-2{{Assuming 'cond2' is not equal to 0}} - // expected-note@-3{{'?' condition is true}} - // expected-note@-4{{Left side of '&&' is true}} - - if (flag) // expected-note{{'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + // expected-note-re@-1{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}} + // expected-note-re@-2{{{{^}}Assuming 'cond2' is not equal to 0{{$}}}} + // expected-note-re@-3{{{{^}}'?' condition is true{{$}}}} + // expected-note-re@-4{{{{^}}Left side of '&&' is true{{$}}}} + + if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -554,18 +554,18 @@ } void f(int flag) { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} flag = getInt(); bar(); assert(cond1 || cond2); - // expected-note@-1{{Assuming 'cond1' is not equal to 0}} - // expected-note@-2{{Left side of '||' is true}} + // expected-note-re@-1{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}} + // expected-note-re@-2{{{{^}}Left side of '||' is true{{$}}}} - if (flag) // expected-note{{'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -593,18 +593,18 @@ } void f(int flag) { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} flag = getInt(); bar(); - assert(cond1); // expected-note{{Assuming 'cond1' is not equal to 0}} - // expected-note@-1{{Taking false branch}} - // expected-note@-2{{Loop condition is false. Exiting loop}} + assert(cond1); // expected-note-re{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking false branch{{$}}}} + // expected-note-re@-2{{{{^}}Loop condition is false. Exiting loop{{$}}}} - if (flag) // expected-note{{'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -634,21 +634,21 @@ } void f(int flag) { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} flag = getInt(); bar(); assert(cond1 && cond2); - // expected-note@-1{{Assuming 'cond1' is not equal to 0}} - // expected-note@-2{{Left side of '&&' is true}} - // expected-note@-3{{Assuming the condition is false}} - // expected-note@-4{{Taking false branch}} - // expected-note@-5{{Loop condition is false. Exiting loop}} - - if (flag) // expected-note{{'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + // expected-note-re@-1{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}} + // expected-note-re@-2{{{{^}}Left side of '&&' is true{{$}}}} + // expected-note-re@-3{{{{^}}Assuming the condition is false{{$}}}} + // expected-note-re@-4{{{{^}}Taking false branch{{$}}}} + // expected-note-re@-5{{{{^}}Loop condition is false. Exiting loop{{$}}}} + + if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -678,20 +678,20 @@ } void f(int flag) { - int *x = 0; // expected-note{{'x' initialized to a null pointer value}} + int *x = 0; // expected-note-re{{{{^}}'x' initialized to a null pointer value{{$}}}} flag = getInt(); bar(); assert(cond1 || cond2); - // expected-note@-1{{Assuming 'cond1' is not equal to 0}} - // expected-note@-2{{Left side of '||' is true}} - // expected-note@-3{{Taking false branch}} - // expected-note@-4{{Loop condition is false. Exiting loop}} - - if (flag) // expected-note{{'flag' is not equal to 0}} - // expected-note@-1{{Taking true branch}} - // debug-note@-2{{Tracking condition 'flag'}} + // expected-note-re@-1{{{{^}}Assuming 'cond1' is not equal to 0{{$}}}} + // expected-note-re@-2{{{{^}}Left side of '||' is true{{$}}}} + // expected-note-re@-3{{{{^}}Taking false branch{{$}}}} + // expected-note-re@-4{{{{^}}Loop condition is false. Exiting loop{{$}}}} + + if (flag) // expected-note-re{{{{^}}Assuming 'flag' is not equal to 0{{$}}}} + // expected-note-re@-1{{{{^}}Taking true branch{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} *x = 5; // expected-warning{{Dereference of null pointer}} // expected-note@-1{{Dereference of null pointer}} } @@ -704,7 +704,7 @@ bool coin(); void bar(int &flag) { - flag = coin(); // tracking-note{{Value assigned to 'flag'}} + flag = coin(); // tracking-note-re{{{{^}}Value assigned to 'flag', which participates in a condition later{{$}}}} } void bar2(int &flag2) { @@ -712,19 +712,19 @@ } void f(int *x) { - if (x) // expected-note{{Assuming 'x' is null}} - // debug-note@-1{{Tracking condition 'x'}} - // expected-note@-2{{Taking false branch}} + if (x) // expected-note-re{{{{^}}Assuming 'x' is null{{$}}}} + // debug-note-re@-1{{{{^}}Tracking condition 'x'{{$}}}} + // expected-note-re@-2{{{{^}}Taking false branch{{$}}}} return; int flag, flag2; - bar(flag); // tracking-note{{Calling 'bar'}} - // tracking-note@-1{{Returning from 'bar'}} + bar(flag); // tracking-note-re{{{{^}}Calling 'bar'{{$}}}} + // tracking-note-re@-1{{{{^}}Returning from 'bar'{{$}}}} bar2(flag2); - if (flag && flag2) // expected-note {{Assuming 'flag' is 0}} - // expected-note@-1{{Left side of '&&' is false}} - // debug-note@-2{{Tracking condition 'flag'}} + if (flag && flag2) // expected-note-re {{{{^}}Assuming 'flag' is 0{{$}}}} + // expected-note-re@-1{{{{^}}Left side of '&&' is false{{$}}}} + // debug-note-re@-2{{{{^}}Tracking condition 'flag'{{$}}}} return; *x = 5; // expected-warning{{Dereference of null pointer}}