[analyzer] StdLibraryFunctionsChecker: Add statistics

[balazske]

clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp

67

This may be misleading: It is every call event that is encountered, even if not handled specially (because no summary). (I would not call a function "handled" if we do nothing with it beneath a check if it needs to be handled really.) Probably "found" is better.

68

The # of calls with summary or The # of handled calls with associated summary ?
Probably only for me but I had difficulty to understand what this means.

72

Change "argumentum" to "argument"?

[steakhal]

Besides @balazske's comments, looks good to me.

clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp

504–505

At first, it was strange to check NewState != State since the addTransition will do this check regardless.
Then I recognized the statistic increment.
It makes sense to count only the new state transitions.

clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp

 
 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h"
+#include "llvm/ADT/Statistic.h"
 
 using namespace clang;
 using namespace clang::ento;
 
 namespace {
+
+#define DEBUG_TYPE "StdLibraryFunctionsChecker"
+STATISTIC(NumCall, "The # of calls handled by the checker");
+STATISTIC(NumFoundSummary, "The # of calls with associated summary");
+STATISTIC(NumArgConstraintViolated,
+          "The # of calls where an arg constraint is violated");
+STATISTIC(NumArgConstrained,
+          "The # of calls with applied argumentum constraints");
+STATISTIC(NumCaseApplied, "The # of calls with applied cases");
+
 class StdLibraryFunctionsChecker
     : public Checker<check::PreCall, check::PostCall, eval::Call> {
   /// Below is a series of typedefs necessary to define function specs.
   /// We avoid nesting types here because each additional qualifier
   /// would need to be repeated in every function spec.
   struct Summary;
 
   /// Specify how much the analyzer engine should entrust modeling this function
ProgramStateRef StdLibraryFunctionsChecker::ComparisonConstraint::apply(
   if (auto CompV = SVB.evalBinOp(State, Op, V, OtherV, CondT)
                        .getAs<DefinedOrUnknownSVal>())
     State = State->assume(*CompV, true);
   return State;
 }
 
 void StdLibraryFunctionsChecker::checkPreCall(const CallEvent &Call,
                                               CheckerContext &C) const {
+  ++NumCall;
   Optional<Summary> FoundSummary = findFunctionSummary(Call, C);
   if (!FoundSummary)
     return;
+  ++NumFoundSummary;
 
   const Summary &Summary = *FoundSummary;
   ProgramStateRef State = C.getState();
 
   ProgramStateRef NewState = State;
   for (const ValueConstraintPtr& VC : Summary.ArgConstraints) {
     ProgramStateRef SuccessSt = VC->apply(NewState, Call, Summary);
     ProgramStateRef FailureSt = VC->negate()->apply(NewState, Call, Summary);
     // The argument constraint is not satisfied.
     if (FailureSt && !SuccessSt) {
+      ++NumArgConstraintViolated;
       if (ExplodedNode *N = C.generateErrorNode(NewState))
         reportBug(Call, N, C);
       break;
     } else {
       // We will apply the constraint even if we cannot reason about the
       // argument. This means both SuccessSt and FailureSt can be true. If we
       // weren't applying the constraint that would mean that symbolic
       // execution continues on a code whose behaviour is undefined.
       assert(SuccessSt);
       NewState = SuccessSt;
     }
   }
-  if (NewState && NewState != State)
+  if (NewState && NewState != State) {
+    ++NumArgConstrained;
     C.addTransition(NewState);
   }
+}
 
 void StdLibraryFunctionsChecker::checkPostCall(const CallEvent &Call,
                                                CheckerContext &C) const {
   Optional<Summary> FoundSummary = findFunctionSummary(Call, C);
   if (!FoundSummary)
     return;
 
   // Now apply the constraints.
   const Summary &Summary = *FoundSummary;
   ProgramStateRef State = C.getState();
 
   // Apply case/branch specifications.
   for (const auto &VRS : Summary.CaseConstraints) {
     ProgramStateRef NewState = State;
     for (const auto &VR: VRS) {
       NewState = VR->apply(NewState, Call, Summary);
       if (!NewState)
         break;
     }
 
-    if (NewState && NewState != State)
+    if (NewState && NewState != State) {
+      ++NumCaseApplied;
       C.addTransition(NewState);
     }
   }
+}
 
 bool StdLibraryFunctionsChecker::evalCall(const CallEvent &Call,
                                           CheckerContext &C) const {
   Optional<Summary> FoundSummary = findFunctionSummary(Call, C);
   if (!FoundSummary)
     return false;
 
   const Summary &Summary = *FoundSummary;