[analyzer] Address Jordan's nitpicks as per code review of r170625.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@170832 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/StaticAnalyzer/Core/CheckerManager.h b/include/clang/StaticAnalyzer/Core/CheckerManager.h
index 80e06c1e8421aeb633500b74630f238547bdf544..12de1082a9b977dd19ad6b615960fadfa3ba01e4 100644 (file)
--- a/include/clang/StaticAnalyzer/Core/CheckerManager.h
+++ b/include/clang/StaticAnalyzer/Core/CheckerManager.h
@@ -318,22 +318,23 @@ public:
   /// \brief Run checkers when pointers escape.
   ///
   /// This notifies the checkers about pointer escape, which occurs whenever
-  /// the analzyer cannot track the symbol any more. For example, as a
+  /// the analyzer cannot track the symbol any more. For example, as a
   /// result of assigning a pointer into a global or when it's passed to a 
   /// function call the analyzer cannot model.
   /// 
   /// \param State The state at the point of escape.
   /// \param Escaped The list of escaped symbols.
   /// \param Call The corresponding CallEvent, if the symbols escape as 
-  /// parameters to the given call.
+  ///        parameters to the given call.
   /// \returns Checkers can modify the state by returning a new one.
-  ProgramStateRef runCheckersForPointerEscape(ProgramStateRef State,
-                                             const InvalidatedSymbols &Escaped,
-                                             const CallEvent *Call);
+  ProgramStateRef 
+  runCheckersForPointerEscape(ProgramStateRef State,
+                              const InvalidatedSymbols &Escaped,
+                              const CallEvent *Call);
 
   /// \brief Run checkers for handling assumptions on symbolic values.
   ProgramStateRef runCheckersForEvalAssume(ProgramStateRef state,
-                                               SVal Cond, bool Assumption);
+                                           SVal Cond, bool Assumption);
 
   /// \brief Run checkers for evaluating a call.
   ///

diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h b/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
index 7c56062152bcc7982a3712170920847120152c3c..df3f45f63fcde630f6ce9efca9d332e21781ffd1 100644 (file)
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
@@ -459,9 +459,11 @@ protected:
                 SVal location, SVal Val, bool atDeclInit = false,
                 const ProgramPoint *PP = 0);
 
+  /// Call PointerEscape callback when a value escapes as a result of bind.
   ProgramStateRef processPointerEscapedOnBind(ProgramStateRef State,
                                               SVal Loc, SVal Val);
-
+  /// Call PointerEscape callback when a value escapes as a result of
+  /// region invalidation.
   ProgramStateRef processPointerEscapedOnInvalidateRegions(
                             ProgramStateRef State,
                             const InvalidatedSymbols *Invalidated,

diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h b/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h
index 0857d127b7476901b2c2df49922c6b5e09b640b7..ef2278c94f98be62e4517d93e163adeb0db53aa8 100644 (file)
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h
@@ -220,19 +220,21 @@ public:
   ///
   /// \param Regions the set of regions to be invalidated.
   /// \param E the expression that caused the invalidation.
-  /// \param BlockCount the current basic block count.
-  /// \param ResultsInPointerEscape the flag is set to true when
-  /// the invalidation is due to escape of a symbol (representing a pointer).
-  /// For example, due to it being passed as an argument in a call.
+  /// \param BlockCount The number of times the current basic block has been
+  //         visited.
+  /// \param CausedByPointerEscape the flag is set to true when
+  ///        the invalidation is due to escape of a symbol (representing a
+  ///        pointer). For example, due to it being passed as an argument in a
+  ///        call.
   /// \param IS the set of invalidated symbols.
-  /// \param If Call is non-null, the invalidated regions were directly
-  /// invalidated by the call - as parameters.
+  /// \param Call if non-null, the invalidated regions represent parameters to
+  ///        the call and should be considered directly invalidated.
   ProgramStateRef invalidateRegions(ArrayRef<const MemRegion *> Regions,
-                               const Expr *E, unsigned BlockCount,
-                               const LocationContext *LCtx,
-                               bool ResultsInPointerEscape,
-                               InvalidatedSymbols *IS = 0,
-                               const CallEvent *Call = 0) const;
+                                    const Expr *E, unsigned BlockCount,
+                                    const LocationContext *LCtx,
+                                    bool CausedByPointerEscape,
+                                    InvalidatedSymbols *IS = 0,
+                                    const CallEvent *Call = 0) const;
 
   /// enterStackFrame - Returns the state for entry to the given stack frame,
   ///  preserving the current state.

diff --git a/lib/StaticAnalyzer/Checkers/CStringChecker.cpp b/lib/StaticAnalyzer/Checkers/CStringChecker.cpp
index 9fbf97641f396aad8c11de9f0961624d51ead83f..889b2363f67a486406705ea72b2bcfc773e733ac 100644 (file)
--- a/lib/StaticAnalyzer/Checkers/CStringChecker.cpp
+++ b/lib/StaticAnalyzer/Checkers/CStringChecker.cpp
@@ -817,7 +817,7 @@ ProgramStateRef CStringChecker::InvalidateBuffer(CheckerContext &C,
     // Invalidate this region.
     const LocationContext *LCtx = C.getPredecessor()->getLocationContext();
     return state->invalidateRegions(R, E, C.blockCount(), LCtx,
-                                    /*ResultsInPointerEscape*/ false);
+                                    /*CausedByPointerEscape*/ false);
   }
 
   // If we have a non-region value by chance, just remove the binding.

diff --git a/lib/StaticAnalyzer/Checkers/CheckerDocumentation.cpp b/lib/StaticAnalyzer/Checkers/CheckerDocumentation.cpp
index fa2c4ffb11526e7303ee70b510fce654a235dd16..a6e0931abd0f3c2bd333bfeff306a89eb20ce2f0 100644 (file)
--- a/lib/StaticAnalyzer/Checkers/CheckerDocumentation.cpp
+++ b/lib/StaticAnalyzer/Checkers/CheckerDocumentation.cpp
@@ -257,7 +257,7 @@ public:
   /// \brief Called when pointers escape.
   ///
   /// This notifies the checkers about pointer escape, which occurs whenever
-  /// the analzyer cannot track the symbol any more. For example, as a
+  /// the analyzer cannot track the symbol any more. For example, as a
   /// result of assigning a pointer into a global or when it's passed to a 
   /// function call the analyzer cannot model.
   /// 

diff --git a/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp b/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp
index b57c6e2b4fbcc01aa15b63db2473000bb3c0bf32..150b4be34ccc5a1e9a95ade62718aaf4ec2aa7da 100644 (file)
--- a/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp
+++ b/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp
@@ -3179,7 +3179,7 @@ bool RetainCountChecker::evalCall(const CallExpr *CE, CheckerContext &C) const {
 
     // Invalidate the argument region.
     state = state->invalidateRegions(ArgRegion, CE, C.blockCount(), LCtx,
-                                     /*ResultsInPointerEscape*/ false);
+                                     /*CausedByPointerEscape*/ false);
 
     // Restore the refcount status of the argument.
     if (Binding)

diff --git a/lib/StaticAnalyzer/Core/CallEvent.cpp b/lib/StaticAnalyzer/Core/CallEvent.cpp
index 3709fd94eda3e7a8c35d15ba6fbfcab9435461aa..a75efc60b95ba6656b63582eec86208fa19b8448 100644 (file)
--- a/lib/StaticAnalyzer/Core/CallEvent.cpp
+++ b/lib/StaticAnalyzer/Core/CallEvent.cpp
@@ -199,7 +199,7 @@ ProgramStateRef CallEvent::invalidateRegions(unsigned BlockCount,
   //  global variables.
   return Result->invalidateRegions(RegionsToInvalidate, getOriginExpr(),
                                    BlockCount, getLocationContext(),
-                                   /*ResultsInPointerEscape*/ true,
+                                   /*CausedByPointerEscape*/ true,
                                    /*Symbols=*/0, this);
 }
 

diff --git a/lib/StaticAnalyzer/Core/ExprEngine.cpp b/lib/StaticAnalyzer/Core/ExprEngine.cpp
index 6b3394046384b14fdae856ed23f9935c564b0fa9..2e2f00ddc4db55be0cb487b0df8f171abaef4a3a 100644 (file)
--- a/lib/StaticAnalyzer/Core/ExprEngine.cpp
+++ b/lib/StaticAnalyzer/Core/ExprEngine.cpp
@@ -1602,14 +1602,13 @@ public:
 };
 } // end anonymous namespace
 
-/// Call PointerEscape callback when a value escapes as a result of bind.
-/// A value escapes in three possible cases:
-/// (1) we are binding to something that is not a memory region.
-/// (2) we are binding to a memregion that does not have stack storage
-/// (3) we are binding to a memregion with stack storage that the store
-///     does not understand.
+// A value escapes in three possible cases:
+// (1) We are binding to something that is not a memory region.
+// (2) We are binding to a MemrRegion that does not have stack storage.
+// (3) We are binding to a MemRegion with stack storage that the store
+//     does not understand.
 ProgramStateRef ExprEngine::processPointerEscapedOnBind(ProgramStateRef State,
-                                                       SVal Loc, SVal Val) {
+                                                        SVal Loc, SVal Val) {
   // Are we storing to something that causes the value to "escape"?
   bool escapes = true;
 
@@ -1647,8 +1646,6 @@ ProgramStateRef ExprEngine::processPointerEscapedOnBind(ProgramStateRef State,
   return State;
 }
 
-/// Call PointerEscape callback when a value escapes as a result of
-/// region invalidation.
 ProgramStateRef 
 ExprEngine::processPointerEscapedOnInvalidateRegions(ProgramStateRef State,
     const InvalidatedSymbols *Invalidated,

diff --git a/lib/StaticAnalyzer/Core/ProgramState.cpp b/lib/StaticAnalyzer/Core/ProgramState.cpp
index 15662776d9eb92b1e398b770f650255e5f167d1f..73350d88eb627a35894f645d8be63f67ec1c8855 100644 (file)
--- a/lib/StaticAnalyzer/Core/ProgramState.cpp
+++ b/lib/StaticAnalyzer/Core/ProgramState.cpp
@@ -144,16 +144,16 @@ ProgramStateRef
 ProgramState::invalidateRegions(ArrayRef<const MemRegion *> Regions,
                                 const Expr *E, unsigned Count,
                                 const LocationContext *LCtx,
-                                bool ResultsInPointerEscape,
+                                bool CausedByPointerEscape,
                                 InvalidatedSymbols *IS,
                                 const CallEvent *Call) const {
   if (!IS) {
     InvalidatedSymbols invalidated;
     return invalidateRegionsImpl(Regions, E, Count, LCtx,
-                                 ResultsInPointerEscape,
+                                 CausedByPointerEscape,
                                  invalidated, Call);
   }
-  return invalidateRegionsImpl(Regions, E, Count, LCtx, ResultsInPointerEscape,
+  return invalidateRegionsImpl(Regions, E, Count, LCtx, CausedByPointerEscape,
                                *IS, Call);
 }
 
@@ -161,7 +161,7 @@ ProgramStateRef
 ProgramState::invalidateRegionsImpl(ArrayRef<const MemRegion *> Regions,
                                     const Expr *E, unsigned Count,
                                     const LocationContext *LCtx,
-                                    bool ResultsInPointerEscape,
+                                    bool CausedByPointerEscape,
                                     InvalidatedSymbols &IS,
                                     const CallEvent *Call) const {
   ProgramStateManager &Mgr = getStateManager();
@@ -175,7 +175,7 @@ ProgramState::invalidateRegionsImpl(ArrayRef<const MemRegion *> Regions,
 
     ProgramStateRef newState = makeWithStore(newStore);
 
-    if (ResultsInPointerEscape)
+    if (CausedByPointerEscape)
       newState = Eng->processPointerEscapedOnInvalidateRegions(newState,
                                                &IS, Regions, Invalidated, Call);