[clang] [DRAFT][analyzer][NFC] clang-format our folders (PR #82599)
Balazs Benics via cfe-commits
cfe-commits at lists.llvm.org
Thu Feb 22 00:24:38 PST 2024
https://github.com/steakhal created https://github.com/llvm/llvm-project/pull/82599
I figured I could reformat all (cpp,h) files of CSA to see if anything would need special formatting.
Let me know if you find debatable hunks.
clang-format version 19.0.0git (bc1c86b810e518a8e3fa90d5c26908c43788873d)
```
clang/include/clang/Analysis/**/*.{cpp,h}
clang/include/clang/StaticAnalyzer/**/*.{cpp,h}
clang/lib/Analysis/**/*.{cpp,h}
clang/lib/StaticAnalyzer/**/*.{cpp,h}
```
I don't intend to merge this PR; it is just to see how it would look, and how broad the changes would be for us.
>From c21867a39c74b23897158989081293558feb698c Mon Sep 17 00:00:00 2001
From: Balazs Benics <benicsbalazs at gmail.com>
Date: Thu, 22 Feb 2024 09:09:41 +0100
Subject: [PATCH] [analyzer][NFC] clang-format our folders
clang-format version 19.0.0git (bc1c86b810e518a8e3fa90d5c26908c43788873d)
clang/include/clang/Analysis/**/*.{cpp,h}
clang/include/clang/StaticAnalyzer/**/*.{cpp,h}
clang/lib/Analysis/**/*.{cpp,h}
clang/lib/StaticAnalyzer/**/*.{cpp,h}
---
.../clang/Analysis/Analyses/Consumed.h | 400 ++---
.../clang/Analysis/Analyses/Dominators.h | 50 +-
.../clang/Analysis/Analyses/LiveVariables.h | 9 +-
.../Analysis/Analyses/PostOrderCFGView.h | 8 +-
.../clang/Analysis/Analyses/ReachableCode.h | 21 +-
.../clang/Analysis/Analyses/ThreadSafety.h | 6 +-
.../Analysis/Analyses/ThreadSafetyCommon.h | 30 +-
.../Analysis/Analyses/ThreadSafetyLogical.h | 17 +-
.../clang/Analysis/Analyses/ThreadSafetyTIL.h | 422 ++---
.../Analysis/Analyses/ThreadSafetyTraverse.h | 266 +--
.../Analysis/Analyses/ThreadSafetyUtil.h | 17 +-
.../Analysis/Analyses/UninitializedValues.h | 13 +-
.../Analysis/Analyses/UnsafeBufferUsage.h | 4 +-
clang/include/clang/Analysis/AnyCall.h | 17 +-
clang/include/clang/Analysis/CFG.h | 305 ++--
clang/include/clang/Analysis/CFGStmtMap.h | 10 +-
clang/include/clang/Analysis/CallGraph.h | 30 +-
clang/include/clang/Analysis/CloneDetection.h | 4 +-
clang/include/clang/Analysis/CodeInjector.h | 2 +-
.../clang/Analysis/ConstructionContext.h | 73 +-
.../DomainSpecific/CocoaConventions.h | 16 +-
.../Analysis/DomainSpecific/ObjCNoReturn.h | 2 +-
.../Analysis/FlowSensitive/DataflowAnalysis.h | 12 +-
.../FlowSensitive/DataflowEnvironment.h | 26 +-
.../Analysis/FlowSensitive/DataflowValues.h | 78 +-
clang/include/clang/Analysis/PathDiagnostic.h | 142 +-
clang/include/clang/Analysis/ProgramPoint.h | 229 ++-
.../clang/Analysis/RetainSummaryManager.h | 180 +-
clang/include/clang/Analysis/SelectorExtras.h | 4 +-
.../clang/Analysis/Support/BumpVector.h | 51 +-
.../Checkers/BuiltinCheckerRegistration.h | 4 +-
.../Checkers/MPIFunctionClassifier.h | 43 +-
.../StaticAnalyzer/Checkers/SValExplainer.h | 26 +-
.../StaticAnalyzer/Core/AnalyzerOptions.h | 23 +-
.../Core/BugReporter/BugReporter.h | 88 +-
.../Core/BugReporter/BugReporterVisitors.h | 4 +-
.../StaticAnalyzer/Core/BugReporter/BugType.h | 2 +-
.../clang/StaticAnalyzer/Core/Checker.h | 213 +--
.../StaticAnalyzer/Core/CheckerManager.h | 211 +--
.../Core/PathDiagnosticConsumers.h | 9 +-
.../Core/PathSensitive/APSIntType.h | 6 +-
.../Core/PathSensitive/AnalysisManager.h | 41 +-
.../Core/PathSensitive/BasicValueFactory.h | 53 +-
.../Core/PathSensitive/BlockCounter.h | 11 +-
.../Core/PathSensitive/CallDescription.h | 6 +-
.../Core/PathSensitive/CheckerContext.h | 101 +-
.../Core/PathSensitive/CheckerHelpers.h | 2 +-
.../Core/PathSensitive/ConstraintManager.h | 8 +-
.../Core/PathSensitive/CoreEngine.h | 128 +-
.../Core/PathSensitive/Environment.h | 26 +-
.../Core/PathSensitive/ExplodedGraph.h | 126 +-
.../Core/PathSensitive/ExprEngine.h | 188 +-
.../Core/PathSensitive/FunctionSummary.h | 22 +-
.../Core/PathSensitive/LoopUnrolling.h | 4 +-
.../Core/PathSensitive/MemRegion.h | 213 +--
.../Core/PathSensitive/ProgramState.h | 284 ++-
.../Core/PathSensitive/ProgramStateTrait.h | 485 +++--
.../Core/PathSensitive/ProgramState_Fwd.h | 35 +-
.../Core/PathSensitive/SValBuilder.h | 60 +-
.../Core/PathSensitive/SValVisitor.h | 29 +-
.../StaticAnalyzer/Core/PathSensitive/SVals.h | 22 +-
.../StaticAnalyzer/Core/PathSensitive/Store.h | 46 +-
.../Core/PathSensitive/SummaryManager.h | 21 +-
.../Core/PathSensitive/SymExpr.h | 4 +-
.../Core/PathSensitive/SymbolManager.h | 146 +-
.../Core/PathSensitive/WorkList.h | 20 +-
.../Frontend/AnalysisConsumer.h | 2 +-
.../StaticAnalyzer/Frontend/CheckerRegistry.h | 1 -
.../StaticAnalyzer/Frontend/ModelConsumer.h | 4 +-
clang/lib/Analysis/AnalysisDeclContext.cpp | 56 +-
clang/lib/Analysis/BodyFarm.cpp | 130 +-
clang/lib/Analysis/CFG.cpp | 1235 +++++++------
.../lib/Analysis/CFGReachabilityAnalysis.cpp | 8 +-
clang/lib/Analysis/CFGStmtMap.cpp | 10 +-
clang/lib/Analysis/CallGraph.cpp | 43 +-
clang/lib/Analysis/CocoaConventions.cpp | 18 +-
clang/lib/Analysis/ConstructionContext.cpp | 38 +-
clang/lib/Analysis/Consumed.cpp | 176 +-
clang/lib/Analysis/Dominators.cpp | 6 +-
clang/lib/Analysis/ExprMutationAnalyzer.cpp | 8 +-
.../FlowSensitive/DataflowAnalysisContext.cpp | 8 +-
.../FlowSensitive/DataflowEnvironment.cpp | 12 +-
.../lib/Analysis/FlowSensitive/HTMLLogger.cpp | 19 +-
clang/lib/Analysis/FlowSensitive/Transfer.cpp | 4 +-
.../FlowSensitive/WatchedLiteralsSolver.cpp | 9 +-
clang/lib/Analysis/IssueHash.cpp | 7 +-
clang/lib/Analysis/LiveVariables.cpp | 291 +--
clang/lib/Analysis/MacroExpansionContext.cpp | 1 -
clang/lib/Analysis/ObjCNoReturn.cpp | 14 +-
clang/lib/Analysis/PathDiagnostic.cpp | 258 ++-
clang/lib/Analysis/PostOrderCFGView.cpp | 8 +-
clang/lib/Analysis/ProgramPoint.cpp | 53 +-
clang/lib/Analysis/ReachableCode.cpp | 334 ++--
clang/lib/Analysis/RetainSummaryManager.cpp | 263 ++-
clang/lib/Analysis/ThreadSafety.cpp | 640 ++++---
clang/lib/Analysis/ThreadSafetyCommon.cpp | 214 ++-
clang/lib/Analysis/ThreadSafetyLogical.cpp | 6 +-
clang/lib/Analysis/ThreadSafetyTIL.cpp | 82 +-
clang/lib/Analysis/UninitializedValues.cpp | 86 +-
clang/lib/Analysis/UnsafeBufferUsage.cpp | 263 ++-
.../CheckerOptionHandling.cpp | 2 +-
.../Checkers/AnalysisOrderChecker.cpp | 6 +-
.../Checkers/AnalyzerStatsChecker.cpp | 26 +-
.../Checkers/ArrayBoundChecker.cpp | 9 +-
.../Checkers/ArrayBoundCheckerV2.cpp | 6 +-
.../Checkers/BasicObjCFoundationChecks.cpp | 210 +--
.../Checkers/BitwiseShiftChecker.cpp | 85 +-
.../BlockInCriticalSectionChecker.cpp | 22 +-
.../Checkers/BuiltinFunctionChecker.cpp | 9 +-
.../Checkers/CStringChecker.cpp | 179 +-
.../Checkers/CStringSyntaxChecker.cpp | 50 +-
.../Checkers/CXXSelfAssignmentChecker.cpp | 9 +-
.../Checkers/CallAndMessageChecker.cpp | 46 +-
.../Checkers/CastSizeChecker.cpp | 9 +-
.../Checkers/CastToStructChecker.cpp | 20 +-
.../Checkers/CastValueChecker.cpp | 38 +-
.../Checkers/CheckObjCDealloc.cpp | 63 +-
.../Checkers/CheckObjCInstMethSignature.cpp | 22 +-
.../Checkers/CheckSecuritySyntaxOnly.cpp | 133 +-
.../Checkers/CheckSizeofPointer.cpp | 16 +-
.../Checkers/CheckerDocumentation.cpp | 72 +-
.../StaticAnalyzer/Checkers/ChrootChecker.cpp | 16 +-
.../StaticAnalyzer/Checkers/CloneChecker.cpp | 16 +-
.../Checkers/ContainerModeling.cpp | 114 +-
.../Checkers/ConversionChecker.cpp | 4 +-
.../Checkers/DeadStoresChecker.cpp | 140 +-
.../StaticAnalyzer/Checkers/DebugCheckers.cpp | 82 +-
.../Checkers/DebugContainerModeling.cpp | 35 +-
.../Checkers/DebugIteratorModeling.cpp | 32 +-
.../Checkers/DereferenceChecker.cpp | 98 +-
.../Checkers/DirectIvarAssignment.cpp | 41 +-
.../Checkers/DivZeroChecker.cpp | 7 +-
.../Checkers/DynamicTypeChecker.cpp | 4 +-
.../Checkers/DynamicTypePropagation.cpp | 22 +-
.../Checkers/FixedAddressChecker.cpp | 5 +-
.../Checkers/GCDAntipatternChecker.cpp | 114 +-
.../StaticAnalyzer/Checkers/GTestChecker.cpp | 4 +-
.../Checkers/GenericTaintChecker.cpp | 43 +-
.../Checkers/IdenticalExprChecker.cpp | 48 +-
.../Checkers/InnerPointerChecker.cpp | 9 +-
.../Checkers/InvalidatedIteratorChecker.cpp | 10 +-
.../lib/StaticAnalyzer/Checkers/Iterator.cpp | 29 +-
clang/lib/StaticAnalyzer/Checkers/Iterator.h | 40 +-
.../Checkers/IteratorModeling.cpp | 164 +-
.../Checkers/IteratorRangeChecker.cpp | 27 +-
.../Checkers/IvarInvalidationChecker.cpp | 156 +-
.../Checkers/LLVMConventionsChecker.cpp | 25 +-
.../Checkers/LocalizationChecker.cpp | 23 +-
.../StaticAnalyzer/Checkers/MIGChecker.cpp | 18 +-
.../Checkers/MPI-Checker/MPIBugReporter.cpp | 20 +-
.../Checkers/MPI-Checker/MPIBugReporter.h | 8 +-
.../Checkers/MPI-Checker/MPIChecker.cpp | 6 +-
.../Checkers/MPI-Checker/MPIChecker.h | 6 +-
.../MPI-Checker/MPIFunctionClassifier.cpp | 6 +-
.../Checkers/MPI-Checker/MPITypes.h | 6 +-
.../Checkers/MacOSKeychainAPIChecker.cpp | 94 +-
.../Checkers/MacOSXAPIChecker.cpp | 14 +-
.../StaticAnalyzer/Checkers/MallocChecker.cpp | 307 ++--
.../MallocOverflowSecurityChecker.cpp | 288 ++-
.../Checkers/MallocSizeofChecker.cpp | 30 +-
.../Checkers/MismatchedIteratorChecker.cpp | 11 +-
.../Checkers/MmapWriteExecChecker.cpp | 17 +-
.../StaticAnalyzer/Checkers/MoveChecker.cpp | 170 +-
.../Checkers/NSAutoreleasePoolChecker.cpp | 5 +-
.../Checkers/NSErrorChecker.cpp | 83 +-
.../Checkers/NoReturnFunctionChecker.cpp | 59 +-
.../Checkers/NonNullParamChecker.cpp | 5 +-
.../NonnullGlobalConstantsChecker.cpp | 11 +-
.../Checkers/NullabilityChecker.cpp | 33 +-
.../NumberObjectConversionChecker.cpp | 164 +-
.../Checkers/OSObjectCStyleCast.cpp | 18 +-
.../Checkers/ObjCAtSyncChecker.cpp | 4 +-
.../Checkers/ObjCAutoreleaseWriteChecker.cpp | 101 +-
.../Checkers/ObjCContainersASTChecker.cpp | 15 +-
.../Checkers/ObjCContainersChecker.cpp | 20 +-
.../Checkers/ObjCMissingSuperCallChecker.cpp | 67 +-
.../Checkers/ObjCPropertyChecker.cpp | 10 +-
.../Checkers/ObjCSelfInitChecker.cpp | 59 +-
.../Checkers/ObjCSuperDeallocChecker.cpp | 15 +-
.../Checkers/ObjCUnusedIVarsChecker.cpp | 22 +-
.../Checkers/PaddingChecker.cpp | 10 +-
.../Checkers/PointerIterationChecker.cpp | 24 +-
.../Checkers/PointerSortingChecker.cpp | 34 +-
.../Checkers/PointerSubChecker.cpp | 5 +-
.../Checkers/PthreadLockChecker.cpp | 4 +-
.../RetainCountChecker/RetainCountChecker.cpp | 442 +++--
.../RetainCountChecker/RetainCountChecker.h | 122 +-
.../RetainCountDiagnostics.cpp | 42 +-
.../RetainCountDiagnostics.h | 8 +-
.../Checkers/ReturnPointerRangeChecker.cpp | 7 +-
.../Checkers/ReturnUndefChecker.cpp | 5 +-
.../RunLoopAutoreleaseLeakChecker.cpp | 87 +-
.../Checkers/STLAlgorithmModeling.cpp | 70 +-
.../Checkers/SimpleStreamChecker.cpp | 44 +-
.../Checkers/StackAddrEscapeChecker.cpp | 3 +-
.../Checkers/TaintTesterChecker.cpp | 5 +-
.../Checkers/TestAfterDivZeroChecker.cpp | 2 +-
.../Checkers/TraversalChecker.cpp | 19 +-
.../Checkers/TrustNonnullChecker.cpp | 24 +-
.../Checkers/TrustReturnsNonnullChecker.cpp | 2 +-
.../Checkers/UndefCapturedBlockVarChecker.cpp | 12 +-
.../Checkers/UndefResultChecker.cpp | 11 +-
.../UndefinedArraySubscriptChecker.cpp | 12 +-
.../Checkers/UndefinedAssignmentChecker.cpp | 7 +-
.../UninitializedObject/UninitializedObject.h | 5 +-
.../UninitializedObjectChecker.cpp | 23 +-
.../Checkers/UnixAPIChecker.cpp | 67 +-
.../Checkers/UnreachableCodeChecker.cpp | 27 +-
.../StaticAnalyzer/Checkers/ValistChecker.cpp | 6 +-
.../StaticAnalyzer/Checkers/VforkChecker.cpp | 29 +-
.../Checkers/VirtualCallChecker.cpp | 6 +-
.../WebKit/NoUncountedMembersChecker.cpp | 9 +-
.../Checkers/WebKit/PtrTypesSemantics.cpp | 12 +-
.../Checkers/WebKit/PtrTypesSemantics.h | 8 +-
.../WebKit/UncountedCallArgsChecker.cpp | 8 +-
.../WebKit/UncountedLambdaCapturesChecker.cpp | 8 +-
clang/lib/StaticAnalyzer/Core/APSIntType.cpp | 4 +-
.../StaticAnalyzer/Core/AnalysisManager.cpp | 21 +-
.../StaticAnalyzer/Core/AnalyzerOptions.cpp | 31 +-
.../StaticAnalyzer/Core/BasicValueFactory.cpp | 180 +-
.../lib/StaticAnalyzer/Core/BlockCounter.cpp | 34 +-
clang/lib/StaticAnalyzer/Core/BugReporter.cpp | 562 +++---
.../Core/BugReporterVisitors.cpp | 196 +-
clang/lib/StaticAnalyzer/Core/CallEvent.cpp | 98 +-
clang/lib/StaticAnalyzer/Core/Checker.cpp | 6 +-
.../StaticAnalyzer/Core/CheckerContext.cpp | 3 +-
.../StaticAnalyzer/Core/CheckerManager.cpp | 519 +++---
clang/lib/StaticAnalyzer/Core/CoreEngine.cpp | 370 ++--
clang/lib/StaticAnalyzer/Core/Environment.cpp | 25 +-
.../lib/StaticAnalyzer/Core/ExplodedGraph.cpp | 56 +-
clang/lib/StaticAnalyzer/Core/ExprEngine.cpp | 1586 ++++++++---------
clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp | 641 +++----
.../lib/StaticAnalyzer/Core/ExprEngineCXX.cpp | 243 ++-
.../Core/ExprEngineCallAndReturn.cpp | 111 +-
.../StaticAnalyzer/Core/ExprEngineObjC.cpp | 25 +-
.../StaticAnalyzer/Core/HTMLDiagnostics.cpp | 154 +-
.../lib/StaticAnalyzer/Core/LoopUnrolling.cpp | 8 +-
.../lib/StaticAnalyzer/Core/LoopWidening.cpp | 3 +-
clang/lib/StaticAnalyzer/Core/MemRegion.cpp | 230 +--
.../StaticAnalyzer/Core/PlistDiagnostics.cpp | 227 ++-
.../Core/PrettyStackTraceLocationContext.h | 5 +-
.../lib/StaticAnalyzer/Core/ProgramState.cpp | 168 +-
.../Core/RangedConstraintManager.cpp | 2 +-
clang/lib/StaticAnalyzer/Core/RegionStore.cpp | 361 ++--
clang/lib/StaticAnalyzer/Core/SValBuilder.cpp | 32 +-
clang/lib/StaticAnalyzer/Core/SVals.cpp | 116 +-
.../StaticAnalyzer/Core/SimpleSValBuilder.cpp | 210 ++-
clang/lib/StaticAnalyzer/Core/Store.cpp | 231 ++-
.../lib/StaticAnalyzer/Core/SymbolManager.cpp | 120 +-
.../StaticAnalyzer/Core/TextDiagnostics.cpp | 6 +-
clang/lib/StaticAnalyzer/Core/WorkList.cpp | 97 +-
.../Frontend/AnalysisConsumer.cpp | 55 +-
.../Frontend/AnalyzerHelpFlags.cpp | 24 +-
.../Frontend/CheckerRegistry.cpp | 22 +-
.../StaticAnalyzer/Frontend/ModelInjector.cpp | 2 +-
.../StaticAnalyzer/Frontend/ModelInjector.h | 12 +-
256 files changed, 10208 insertions(+), 11290 deletions(-)
diff --git a/clang/include/clang/Analysis/Analyses/Consumed.h b/clang/include/clang/Analysis/Analyses/Consumed.h
index 3e2788cac3c9cb..0e4818f043b9e8 100644
--- a/clang/include/clang/Analysis/Analyses/Consumed.h
+++ b/clang/include/clang/Analysis/Analyses/Consumed.h
@@ -38,235 +38,235 @@ class VarDecl;
namespace consumed {
- class ConsumedStmtVisitor;
-
- enum ConsumedState {
- // No state information for the given variable.
- CS_None,
-
- CS_Unknown,
- CS_Unconsumed,
- CS_Consumed
- };
-
- using OptionalNotes = SmallVector<PartialDiagnosticAt, 1>;
- using DelayedDiag = std::pair<PartialDiagnosticAt, OptionalNotes>;
- using DiagList = std::list<DelayedDiag>;
-
- class ConsumedWarningsHandlerBase {
- public:
- virtual ~ConsumedWarningsHandlerBase();
-
- /// Emit the warnings and notes left by the analysis.
- virtual void emitDiagnostics() {}
-
- /// Warn that a variable's state doesn't match at the entry and exit
- /// of a loop.
- ///
- /// \param Loc -- The location of the end of the loop.
- ///
- /// \param VariableName -- The name of the variable that has a mismatched
- /// state.
- virtual void warnLoopStateMismatch(SourceLocation Loc,
- StringRef VariableName) {}
-
- /// Warn about parameter typestate mismatches upon return.
- ///
- /// \param Loc -- The SourceLocation of the return statement.
- ///
- /// \param ExpectedState -- The state the return value was expected to be
- /// in.
- ///
- /// \param ObservedState -- The state the return value was observed to be
- /// in.
- virtual void warnParamReturnTypestateMismatch(SourceLocation Loc,
- StringRef VariableName,
- StringRef ExpectedState,
- StringRef ObservedState) {}
-
- // FIXME: Add documentation.
- virtual void warnParamTypestateMismatch(SourceLocation LOC,
- StringRef ExpectedState,
- StringRef ObservedState) {}
-
- // FIXME: This can be removed when the attr propagation fix for templated
- // classes lands.
- /// Warn about return typestates set for unconsumable types.
- ///
- /// \param Loc -- The location of the attributes.
- ///
- /// \param TypeName -- The name of the unconsumable type.
- virtual void warnReturnTypestateForUnconsumableType(SourceLocation Loc,
- StringRef TypeName) {}
-
- /// Warn about return typestate mismatches.
- ///
- /// \param Loc -- The SourceLocation of the return statement.
- ///
- /// \param ExpectedState -- The state the return value was expected to be
- /// in.
- ///
- /// \param ObservedState -- The state the return value was observed to be
- /// in.
- virtual void warnReturnTypestateMismatch(SourceLocation Loc,
- StringRef ExpectedState,
- StringRef ObservedState) {}
-
- /// Warn about use-while-consumed errors.
- /// \param MethodName -- The name of the method that was incorrectly
- /// invoked.
- ///
- /// \param State -- The state the object was used in.
- ///
- /// \param Loc -- The SourceLocation of the method invocation.
- virtual void warnUseOfTempInInvalidState(StringRef MethodName,
- StringRef State,
- SourceLocation Loc) {}
-
- /// Warn about use-while-consumed errors.
- /// \param MethodName -- The name of the method that was incorrectly
- /// invoked.
- ///
- /// \param State -- The state the object was used in.
- ///
- /// \param VariableName -- The name of the variable that holds the unique
- /// value.
- ///
- /// \param Loc -- The SourceLocation of the method invocation.
- virtual void warnUseInInvalidState(StringRef MethodName,
- StringRef VariableName,
- StringRef State,
- SourceLocation Loc) {}
- };
-
- class ConsumedStateMap {
- using VarMapType = llvm::DenseMap<const VarDecl *, ConsumedState>;
- using TmpMapType =
- llvm::DenseMap<const CXXBindTemporaryExpr *, ConsumedState>;
-
- protected:
- bool Reachable = true;
- const Stmt *From = nullptr;
- VarMapType VarMap;
- TmpMapType TmpMap;
-
- public:
- ConsumedStateMap() = default;
- ConsumedStateMap(const ConsumedStateMap &Other)
- : Reachable(Other.Reachable), From(Other.From), VarMap(Other.VarMap) {}
-
- // The copy assignment operator is defined as deleted pending further
- // motivation.
- ConsumedStateMap &operator=(const ConsumedStateMap &) = delete;
-
- /// Warn if any of the parameters being tracked are not in the state
- /// they were declared to be in upon return from a function.
- void checkParamsForReturnTypestate(SourceLocation BlameLoc,
+class ConsumedStmtVisitor;
+
+enum ConsumedState {
+ // No state information for the given variable.
+ CS_None,
+
+ CS_Unknown,
+ CS_Unconsumed,
+ CS_Consumed
+};
+
+using OptionalNotes = SmallVector<PartialDiagnosticAt, 1>;
+using DelayedDiag = std::pair<PartialDiagnosticAt, OptionalNotes>;
+using DiagList = std::list<DelayedDiag>;
+
+class ConsumedWarningsHandlerBase {
+public:
+ virtual ~ConsumedWarningsHandlerBase();
+
+ /// Emit the warnings and notes left by the analysis.
+ virtual void emitDiagnostics() {}
+
+ /// Warn that a variable's state doesn't match at the entry and exit
+ /// of a loop.
+ ///
+ /// \param Loc -- The location of the end of the loop.
+ ///
+ /// \param VariableName -- The name of the variable that has a mismatched
+ /// state.
+ virtual void warnLoopStateMismatch(SourceLocation Loc,
+ StringRef VariableName) {}
+
+ /// Warn about parameter typestate mismatches upon return.
+ ///
+ /// \param Loc -- The SourceLocation of the return statement.
+ ///
+ /// \param ExpectedState -- The state the return value was expected to be
+ /// in.
+ ///
+ /// \param ObservedState -- The state the return value was observed to be
+ /// in.
+ virtual void warnParamReturnTypestateMismatch(SourceLocation Loc,
+ StringRef VariableName,
+ StringRef ExpectedState,
+ StringRef ObservedState) {}
+
+ // FIXME: Add documentation.
+ virtual void warnParamTypestateMismatch(SourceLocation LOC,
+ StringRef ExpectedState,
+ StringRef ObservedState) {}
+
+ // FIXME: This can be removed when the attr propagation fix for templated
+ // classes lands.
+ /// Warn about return typestates set for unconsumable types.
+ ///
+ /// \param Loc -- The location of the attributes.
+ ///
+ /// \param TypeName -- The name of the unconsumable type.
+ virtual void warnReturnTypestateForUnconsumableType(SourceLocation Loc,
+ StringRef TypeName) {}
+
+ /// Warn about return typestate mismatches.
+ ///
+ /// \param Loc -- The SourceLocation of the return statement.
+ ///
+ /// \param ExpectedState -- The state the return value was expected to be
+ /// in.
+ ///
+ /// \param ObservedState -- The state the return value was observed to be
+ /// in.
+ virtual void warnReturnTypestateMismatch(SourceLocation Loc,
+ StringRef ExpectedState,
+ StringRef ObservedState) {}
+
+ /// Warn about use-while-consumed errors.
+ /// \param MethodName -- The name of the method that was incorrectly
+ /// invoked.
+ ///
+ /// \param State -- The state the object was used in.
+ ///
+ /// \param Loc -- The SourceLocation of the method invocation.
+ virtual void warnUseOfTempInInvalidState(StringRef MethodName,
+ StringRef State,
+ SourceLocation Loc) {}
+
+ /// Warn about use-while-consumed errors.
+ /// \param MethodName -- The name of the method that was incorrectly
+ /// invoked.
+ ///
+ /// \param State -- The state the object was used in.
+ ///
+ /// \param VariableName -- The name of the variable that holds the unique
+ /// value.
+ ///
+ /// \param Loc -- The SourceLocation of the method invocation.
+ virtual void warnUseInInvalidState(StringRef MethodName,
+ StringRef VariableName, StringRef State,
+ SourceLocation Loc) {}
+};
+
+class ConsumedStateMap {
+ using VarMapType = llvm::DenseMap<const VarDecl *, ConsumedState>;
+ using TmpMapType =
+ llvm::DenseMap<const CXXBindTemporaryExpr *, ConsumedState>;
+
+protected:
+ bool Reachable = true;
+ const Stmt *From = nullptr;
+ VarMapType VarMap;
+ TmpMapType TmpMap;
+
+public:
+ ConsumedStateMap() = default;
+ ConsumedStateMap(const ConsumedStateMap &Other)
+ : Reachable(Other.Reachable), From(Other.From), VarMap(Other.VarMap) {}
+
+ // The copy assignment operator is defined as deleted pending further
+ // motivation.
+ ConsumedStateMap &operator=(const ConsumedStateMap &) = delete;
+
+ /// Warn if any of the parameters being tracked are not in the state
+ /// they were declared to be in upon return from a function.
+ void checkParamsForReturnTypestate(
+ SourceLocation BlameLoc,
ConsumedWarningsHandlerBase &WarningsHandler) const;
- /// Clear the TmpMap.
- void clearTemporaries();
+ /// Clear the TmpMap.
+ void clearTemporaries();
- /// Get the consumed state of a given variable.
- ConsumedState getState(const VarDecl *Var) const;
+ /// Get the consumed state of a given variable.
+ ConsumedState getState(const VarDecl *Var) const;
- /// Get the consumed state of a given temporary value.
- ConsumedState getState(const CXXBindTemporaryExpr *Tmp) const;
+ /// Get the consumed state of a given temporary value.
+ ConsumedState getState(const CXXBindTemporaryExpr *Tmp) const;
- /// Merge this state map with another map.
- void intersect(const ConsumedStateMap &Other);
+ /// Merge this state map with another map.
+ void intersect(const ConsumedStateMap &Other);
- void intersectAtLoopHead(const CFGBlock *LoopHead, const CFGBlock *LoopBack,
- const ConsumedStateMap *LoopBackStates,
- ConsumedWarningsHandlerBase &WarningsHandler);
+ void intersectAtLoopHead(const CFGBlock *LoopHead, const CFGBlock *LoopBack,
+ const ConsumedStateMap *LoopBackStates,
+ ConsumedWarningsHandlerBase &WarningsHandler);
- /// Return true if this block is reachable.
- bool isReachable() const { return Reachable; }
+ /// Return true if this block is reachable.
+ bool isReachable() const { return Reachable; }
- /// Mark the block as unreachable.
- void markUnreachable();
+ /// Mark the block as unreachable.
+ void markUnreachable();
- /// Set the source for a decision about the branching of states.
- /// \param Source -- The statement that was the origin of a branching
- /// decision.
- void setSource(const Stmt *Source) { this->From = Source; }
+ /// Set the source for a decision about the branching of states.
+ /// \param Source -- The statement that was the origin of a branching
+ /// decision.
+ void setSource(const Stmt *Source) { this->From = Source; }
- /// Set the consumed state of a given variable.
- void setState(const VarDecl *Var, ConsumedState State);
+ /// Set the consumed state of a given variable.
+ void setState(const VarDecl *Var, ConsumedState State);
- /// Set the consumed state of a given temporary value.
- void setState(const CXXBindTemporaryExpr *Tmp, ConsumedState State);
+ /// Set the consumed state of a given temporary value.
+ void setState(const CXXBindTemporaryExpr *Tmp, ConsumedState State);
- /// Remove the temporary value from our state map.
- void remove(const CXXBindTemporaryExpr *Tmp);
+ /// Remove the temporary value from our state map.
+ void remove(const CXXBindTemporaryExpr *Tmp);
- /// Tests to see if there is a mismatch in the states stored in two
- /// maps.
- ///
- /// \param Other -- The second map to compare against.
- bool operator!=(const ConsumedStateMap *Other) const;
- };
+ /// Tests to see if there is a mismatch in the states stored in two
+ /// maps.
+ ///
+ /// \param Other -- The second map to compare against.
+ bool operator!=(const ConsumedStateMap *Other) const;
+};
- class ConsumedBlockInfo {
- std::vector<std::unique_ptr<ConsumedStateMap>> StateMapsArray;
- std::vector<unsigned int> VisitOrder;
+class ConsumedBlockInfo {
+ std::vector<std::unique_ptr<ConsumedStateMap>> StateMapsArray;
+ std::vector<unsigned int> VisitOrder;
- public:
- ConsumedBlockInfo() = default;
+public:
+ ConsumedBlockInfo() = default;
- ConsumedBlockInfo(unsigned int NumBlocks, PostOrderCFGView *SortedGraph)
- : StateMapsArray(NumBlocks), VisitOrder(NumBlocks, 0) {
- unsigned int VisitOrderCounter = 0;
- for (const auto BI : *SortedGraph)
- VisitOrder[BI->getBlockID()] = VisitOrderCounter++;
- }
+ ConsumedBlockInfo(unsigned int NumBlocks, PostOrderCFGView *SortedGraph)
+ : StateMapsArray(NumBlocks), VisitOrder(NumBlocks, 0) {
+ unsigned int VisitOrderCounter = 0;
+ for (const auto BI : *SortedGraph)
+ VisitOrder[BI->getBlockID()] = VisitOrderCounter++;
+ }
- bool allBackEdgesVisited(const CFGBlock *CurrBlock,
- const CFGBlock *TargetBlock);
+ bool allBackEdgesVisited(const CFGBlock *CurrBlock,
+ const CFGBlock *TargetBlock);
- void addInfo(const CFGBlock *Block, ConsumedStateMap *StateMap,
- std::unique_ptr<ConsumedStateMap> &OwnedStateMap);
- void addInfo(const CFGBlock *Block,
- std::unique_ptr<ConsumedStateMap> StateMap);
+ void addInfo(const CFGBlock *Block, ConsumedStateMap *StateMap,
+ std::unique_ptr<ConsumedStateMap> &OwnedStateMap);
+ void addInfo(const CFGBlock *Block,
+ std::unique_ptr<ConsumedStateMap> StateMap);
- ConsumedStateMap* borrowInfo(const CFGBlock *Block);
+ ConsumedStateMap *borrowInfo(const CFGBlock *Block);
- void discardInfo(const CFGBlock *Block);
+ void discardInfo(const CFGBlock *Block);
- std::unique_ptr<ConsumedStateMap> getInfo(const CFGBlock *Block);
+ std::unique_ptr<ConsumedStateMap> getInfo(const CFGBlock *Block);
- bool isBackEdge(const CFGBlock *From, const CFGBlock *To);
- bool isBackEdgeTarget(const CFGBlock *Block);
- };
+ bool isBackEdge(const CFGBlock *From, const CFGBlock *To);
+ bool isBackEdgeTarget(const CFGBlock *Block);
+};
- /// A class that handles the analysis of uniqueness violations.
- class ConsumedAnalyzer {
- ConsumedBlockInfo BlockInfo;
- std::unique_ptr<ConsumedStateMap> CurrStates;
+/// A class that handles the analysis of uniqueness violations.
+class ConsumedAnalyzer {
+ ConsumedBlockInfo BlockInfo;
+ std::unique_ptr<ConsumedStateMap> CurrStates;
- ConsumedState ExpectedReturnState = CS_None;
+ ConsumedState ExpectedReturnState = CS_None;
- void determineExpectedReturnState(AnalysisDeclContext &AC,
- const FunctionDecl *D);
- bool splitState(const CFGBlock *CurrBlock,
- const ConsumedStmtVisitor &Visitor);
+ void determineExpectedReturnState(AnalysisDeclContext &AC,
+ const FunctionDecl *D);
+ bool splitState(const CFGBlock *CurrBlock,
+ const ConsumedStmtVisitor &Visitor);
- public:
- ConsumedWarningsHandlerBase &WarningsHandler;
+public:
+ ConsumedWarningsHandlerBase &WarningsHandler;
- ConsumedAnalyzer(ConsumedWarningsHandlerBase &WarningsHandler)
- : WarningsHandler(WarningsHandler) {}
+ ConsumedAnalyzer(ConsumedWarningsHandlerBase &WarningsHandler)
+ : WarningsHandler(WarningsHandler) {}
- ConsumedState getExpectedReturnState() const { return ExpectedReturnState; }
+ ConsumedState getExpectedReturnState() const { return ExpectedReturnState; }
- /// Check a function's CFG for consumed violations.
- ///
- /// We traverse the blocks in the CFG, keeping track of the state of each
- /// value who's type has uniqueness annotations. If methods are invoked in
- /// the wrong state a warning is issued. Each block in the CFG is traversed
- /// exactly once.
- void run(AnalysisDeclContext &AC);
- };
+ /// Check a function's CFG for consumed violations.
+ ///
+ /// We traverse the blocks in the CFG, keeping track of the state of each
+ /// value who's type has uniqueness annotations. If methods are invoked in
+ /// the wrong state a warning is issued. Each block in the CFG is traversed
+ /// exactly once.
+ void run(AnalysisDeclContext &AC);
+};
} // namespace consumed
diff --git a/clang/include/clang/Analysis/Analyses/Dominators.h b/clang/include/clang/Analysis/Analyses/Dominators.h
index 7dd54c5ce262cc..05d62dbaa63158 100644
--- a/clang/include/clang/Analysis/Analyses/Dominators.h
+++ b/clang/include/clang/Analysis/Analyses/Dominators.h
@@ -18,9 +18,9 @@
#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/GraphTraits.h"
#include "llvm/ADT/iterator.h"
-#include "llvm/Support/GenericIteratedDominanceFrontier.h"
#include "llvm/Support/GenericDomTree.h"
#include "llvm/Support/GenericDomTreeConstruction.h"
+#include "llvm/Support/GenericIteratedDominanceFrontier.h"
#include "llvm/Support/raw_ostream.h"
// FIXME: There is no good reason for the domtree to require a print method
@@ -38,8 +38,7 @@ namespace clang {
using DomTreeNode = llvm::DomTreeNodeBase<CFGBlock>;
/// Dominator tree builder for Clang's CFG based on llvm::DominatorTreeBase.
-template <bool IsPostDom>
-class CFGDominatorTreeImpl : public ManagedAnalysis {
+template <bool IsPostDom> class CFGDominatorTreeImpl : public ManagedAnalysis {
virtual void anchor();
public:
@@ -47,9 +46,7 @@ class CFGDominatorTreeImpl : public ManagedAnalysis {
CFGDominatorTreeImpl() = default;
- CFGDominatorTreeImpl(CFG *cfg) {
- buildDominatorTree(cfg);
- }
+ CFGDominatorTreeImpl(CFG *cfg) { buildDominatorTree(cfg); }
~CFGDominatorTreeImpl() override = default;
@@ -58,14 +55,10 @@ class CFGDominatorTreeImpl : public ManagedAnalysis {
CFG *getCFG() { return cfg; }
/// \returns the root CFGBlock of the dominators tree.
- CFGBlock *getRoot() const {
- return DT.getRoot();
- }
+ CFGBlock *getRoot() const { return DT.getRoot(); }
/// \returns the root DomTreeNode, which is the wrapper for CFGBlock.
- DomTreeNode *getRootNode() {
- return DT.getRootNode();
- }
+ DomTreeNode *getRootNode() { return DT.getRootNode(); }
/// Compares two dominator trees.
/// \returns false if the other dominator tree matches this dominator tree,
@@ -94,8 +87,7 @@ class CFGDominatorTreeImpl : public ManagedAnalysis {
void dump() {
llvm::errs() << "Immediate " << (IsPostDom ? "post " : "")
<< "dominance tree (Node#,IDom#):\n";
- for (CFG::const_iterator I = cfg->begin(),
- E = cfg->end(); I != E; ++I) {
+ for (CFG::const_iterator I = cfg->begin(), E = cfg->end(); I != E; ++I) {
assert(*I &&
"LLVM's Dominator tree builder uses nullpointers to signify the "
@@ -103,10 +95,8 @@ class CFGDominatorTreeImpl : public ManagedAnalysis {
DomTreeNode *IDom = DT.getNode(*I)->getIDom();
if (IDom && IDom->getBlock())
- llvm::errs() << "(" << (*I)->getBlockID()
- << ","
- << IDom->getBlock()->getBlockID()
- << ")\n";
+ llvm::errs() << "(" << (*I)->getBlockID() << ","
+ << IDom->getBlock()->getBlockID() << ")\n";
else {
bool IsEntryBlock = *I == &(*I)->getParent()->getEntry();
bool IsExitBlock = *I == &(*I)->getParent()->getExit();
@@ -125,8 +115,8 @@ class CFGDominatorTreeImpl : public ManagedAnalysis {
(void)IsDomTreeRoot;
(void)IsPostDomTreeRoot;
- llvm::errs() << "(" << (*I)->getBlockID()
- << "," << (*I)->getBlockID() << ")\n";
+ llvm::errs() << "(" << (*I)->getBlockID() << "," << (*I)->getBlockID()
+ << ")\n";
}
}
}
@@ -170,7 +160,7 @@ class CFGDominatorTreeImpl : public ManagedAnalysis {
virtual void releaseMemory() { DT.reset(); }
/// Converts the dominator tree to human readable form.
- virtual void print(raw_ostream &OS, const llvm::Module* M= nullptr) const {
+ virtual void print(raw_ostream &OS, const llvm::Module *M = nullptr) const {
DT.print(OS);
}
@@ -182,8 +172,8 @@ class CFGDominatorTreeImpl : public ManagedAnalysis {
using CFGDomTree = CFGDominatorTreeImpl</*IsPostDom*/ false>;
using CFGPostDomTree = CFGDominatorTreeImpl</*IsPostDom*/ true>;
-template<> void CFGDominatorTreeImpl<true>::anchor();
-template<> void CFGDominatorTreeImpl<false>::anchor();
+template <> void CFGDominatorTreeImpl<true>::anchor();
+template <> void CFGDominatorTreeImpl<false>::anchor();
} // end of namespace clang
@@ -191,8 +181,7 @@ namespace llvm {
namespace IDFCalculatorDetail {
/// Specialize ChildrenGetterTy to skip nullpointer successors.
-template <bool IsPostDom>
-struct ChildrenGetterTy<clang::CFGBlock, IsPostDom> {
+template <bool IsPostDom> struct ChildrenGetterTy<clang::CFGBlock, IsPostDom> {
using NodeRef = typename GraphTraits<clang::CFGBlock *>::NodeRef;
using ChildrenTy = SmallVector<NodeRef, 8>;
@@ -224,7 +213,7 @@ class ControlDependencyCalculator : public ManagedAnalysis {
public:
ControlDependencyCalculator(CFG *cfg)
- : PostDomTree(cfg), IDFCalc(PostDomTree.getBase()) {}
+ : PostDomTree(cfg), IDFCalc(PostDomTree.getBase()) {}
const CFGPostDomTree &getCFGPostDomTree() const { return PostDomTree; }
@@ -261,10 +250,8 @@ class ControlDependencyCalculator : public ManagedAnalysis {
"virtual root!");
for (CFGBlock *isControlDependency : getControlDependencies(BB))
- llvm::errs() << "(" << BB->getBlockID()
- << ","
- << isControlDependency->getBlockID()
- << ")\n";
+ llvm::errs() << "(" << BB->getBlockID() << ","
+ << isControlDependency->getBlockID() << ")\n";
}
}
};
@@ -297,7 +284,8 @@ template <> struct GraphTraits<clang::DomTreeNode *> {
}
};
-template <> struct GraphTraits<clang::CFGDomTree *>
+template <>
+struct GraphTraits<clang::CFGDomTree *>
: public GraphTraits<clang::DomTreeNode *> {
static NodeRef getEntryNode(clang::CFGDomTree *DT) {
return DT->getRootNode();
diff --git a/clang/include/clang/Analysis/Analyses/LiveVariables.h b/clang/include/clang/Analysis/Analyses/LiveVariables.h
index 8a3dd0c35e64c9..96aada4f90593b 100644
--- a/clang/include/clang/Analysis/Analyses/LiveVariables.h
+++ b/clang/include/clang/Analysis/Analyses/LiveVariables.h
@@ -29,7 +29,6 @@ class LiveVariables : public ManagedAnalysis {
public:
class LivenessValues {
public:
-
llvm::ImmutableSet<const Expr *> liveExprs;
llvm::ImmutableSet<const VarDecl *> liveDecls;
llvm::ImmutableSet<const BindingDecl *> liveBindings;
@@ -37,7 +36,7 @@ class LiveVariables : public ManagedAnalysis {
bool equals(const LivenessValues &V) const;
LivenessValues()
- : liveExprs(nullptr), liveDecls(nullptr), liveBindings(nullptr) {}
+ : liveExprs(nullptr), liveDecls(nullptr), liveBindings(nullptr) {}
LivenessValues(llvm::ImmutableSet<const Expr *> liveExprs,
llvm::ImmutableSet<const VarDecl *> LiveDecls,
@@ -53,14 +52,14 @@ class LiveVariables : public ManagedAnalysis {
class Observer {
virtual void anchor();
+
public:
virtual ~Observer() {}
/// A callback invoked right before invoking the
/// liveness transfer function on the given statement.
- virtual void observeStmt(const Stmt *S,
- const CFGBlock *currentBlock,
- const LivenessValues& V) {}
+ virtual void observeStmt(const Stmt *S, const CFGBlock *currentBlock,
+ const LivenessValues &V) {}
/// Called when the live variables analysis registers
/// that a variable is killed.
diff --git a/clang/include/clang/Analysis/Analyses/PostOrderCFGView.h b/clang/include/clang/Analysis/Analyses/PostOrderCFGView.h
index c4998bb2285f7c..f1e8546df0928e 100644
--- a/clang/include/clang/Analysis/Analyses/PostOrderCFGView.h
+++ b/clang/include/clang/Analysis/Analyses/PostOrderCFGView.h
@@ -40,7 +40,9 @@ class PostOrderCFGView : public ManagedAnalysis {
public:
// po_iterator requires this iterator, but the only interface needed is the
// value_type type.
- struct iterator { using value_type = const CFGBlock *; };
+ struct iterator {
+ using value_type = const CFGBlock *;
+ };
CFGBlockSet() = default;
CFGBlockSet(const CFG *G) : VisitedBlockIDs(G->getNumBlockIDs(), false) {}
@@ -135,9 +137,7 @@ class PostOrderCFGView : public ManagedAnalysis {
bool operator()(const CFGBlock *b1, const CFGBlock *b2) const;
};
- BlockOrderCompare getComparator() const {
- return BlockOrderCompare(*this);
- }
+ BlockOrderCompare getComparator() const { return BlockOrderCompare(*this); }
// Used by AnalyisContext to construct this object.
static const void *getTag();
diff --git a/clang/include/clang/Analysis/Analyses/ReachableCode.h b/clang/include/clang/Analysis/Analyses/ReachableCode.h
index f1b63f74b6c80a..44cb6633aaafa8 100644
--- a/clang/include/clang/Analysis/Analyses/ReachableCode.h
+++ b/clang/include/clang/Analysis/Analyses/ReachableCode.h
@@ -20,14 +20,14 @@
//===----------------------------------------------------------------------===//
namespace llvm {
- class BitVector;
+class BitVector;
}
namespace clang {
- class AnalysisDeclContext;
- class CFGBlock;
- class Preprocessor;
-}
+class AnalysisDeclContext;
+class CFGBlock;
+class Preprocessor;
+} // namespace clang
//===----------------------------------------------------------------------===//
// API.
@@ -37,15 +37,11 @@ namespace clang {
namespace reachable_code {
/// Classifications of unreachable code.
-enum UnreachableKind {
- UK_Return,
- UK_Break,
- UK_Loop_Increment,
- UK_Other
-};
+enum UnreachableKind { UK_Return, UK_Break, UK_Loop_Increment, UK_Other };
class Callback {
virtual void anchor();
+
public:
virtual ~Callback() {}
virtual void HandleUnreachable(UnreachableKind UK, SourceLocation L,
@@ -61,6 +57,7 @@ unsigned ScanReachableFromBlock(const CFGBlock *Start,
void FindUnreachableCode(AnalysisDeclContext &AC, Preprocessor &PP,
Callback &CB);
-}} // end namespace clang::reachable_code
+} // namespace reachable_code
+} // namespace clang
#endif
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafety.h b/clang/include/clang/Analysis/Analyses/ThreadSafety.h
index 0866b09bab2995..d76f5804bfa31b 100644
--- a/clang/include/clang/Analysis/Analyses/ThreadSafety.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafety.h
@@ -10,7 +10,8 @@
// A intra-procedural analysis for thread safety (e.g. deadlocks and race
// conditions), based off of an annotation system.
//
-// See http://clang.llvm.org/docs/LanguageExtensions.html#thread-safety-annotation-checking
+// See
+// http://clang.llvm.org/docs/LanguageExtensions.html#thread-safety-annotation-checking
// for more information.
//
//===----------------------------------------------------------------------===//
@@ -250,8 +251,7 @@ class ThreadSafetyHandler {
/// at the end of each block, and issue warnings for thread safety violations.
/// Each block in the CFG is traversed exactly once.
void runThreadSafetyAnalysis(AnalysisDeclContext &AC,
- ThreadSafetyHandler &Handler,
- BeforeSet **Bset);
+ ThreadSafetyHandler &Handler, BeforeSet **Bset);
void threadSafetyCleanup(BeforeSet *Cache);
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h b/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h
index 13e37ac2b56b64..b00fa4f71922d7 100644
--- a/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h
@@ -94,7 +94,7 @@ inline std::string toString(const til::SExpr *E) {
return ss.str();
}
-} // namespace sx
+} // namespace sx
// This class defines the interface of a clang CFG Visitor.
// CFGWalker will invoke the following methods.
@@ -168,8 +168,7 @@ class CFGWalker {
}
// Traverse the CFG, calling methods on V as appropriate.
- template <class Visitor>
- void walk(Visitor &V) {
+ template <class Visitor> void walk(Visitor &V) {
PostOrderCFGView::CFGBlockSet VisitedBlocks(CFGraph);
V.enterCFG(CFGraph, getDecl(), &CFGraph->getEntry());
@@ -181,7 +180,7 @@ class CFGWalker {
// Process predecessors, handling back edges last
if (V.visitPredecessors()) {
- SmallVector<CFGBlock*, 4> BackEdges;
+ SmallVector<CFGBlock *, 4> BackEdges;
// Process successors
for (CFGBlock::const_pred_iterator SI = CurrBlock->pred_begin(),
SE = CurrBlock->pred_end();
@@ -226,7 +225,7 @@ class CFGWalker {
// Process successors, handling back edges first.
if (V.visitSuccessors()) {
- SmallVector<CFGBlock*, 8> ForwardEdges;
+ SmallVector<CFGBlock *, 8> ForwardEdges;
// Process successors
for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(),
@@ -312,7 +311,7 @@ class CapabilityExpr {
sx::partiallyMatches(sexpr(), other.sexpr());
}
- const ValueDecl* valueDecl() const {
+ const ValueDecl *valueDecl() const {
if (negative() || sexpr() == nullptr)
return nullptr;
if (const auto *P = dyn_cast<til::Project>(sexpr()))
@@ -349,7 +348,7 @@ class SExprBuilder {
/// by the lock_returned attribute.
struct CallingContext {
// The previous context; or 0 if none.
- CallingContext *Prev;
+ CallingContext *Prev;
// The decl to which the attr is attached.
const NamedDecl *AttrDecl;
@@ -395,7 +394,7 @@ class SExprBuilder {
// Also performs substitution of variables; Ctx provides the context.
// Dispatches on the type of S.
til::SExpr *translate(const Stmt *S, CallingContext *Ctx);
- til::SCFG *buildCFG(CFGWalker &Walker);
+ til::SCFG *buildCFG(CFGWalker &Walker);
til::SExpr *lookupStmt(const Stmt *S);
@@ -410,8 +409,7 @@ class SExprBuilder {
// We implement the CFGVisitor API
friend class CFGWalker;
- til::SExpr *translateDeclRefExpr(const DeclRefExpr *DRE,
- CallingContext *Ctx) ;
+ til::SExpr *translateDeclRefExpr(const DeclRefExpr *DRE, CallingContext *Ctx);
til::SExpr *translateCXXThisExpr(const CXXThisExpr *TE, CallingContext *Ctx);
til::SExpr *translateMemberExpr(const MemberExpr *ME, CallingContext *Ctx);
til::SExpr *translateObjCIVarRefExpr(const ObjCIvarRefExpr *IVRE,
@@ -424,19 +422,19 @@ class SExprBuilder {
CallingContext *Ctx);
til::SExpr *translateUnaryOperator(const UnaryOperator *UO,
CallingContext *Ctx);
- til::SExpr *translateBinOp(til::TIL_BinaryOpcode Op,
- const BinaryOperator *BO,
+ til::SExpr *translateBinOp(til::TIL_BinaryOpcode Op, const BinaryOperator *BO,
CallingContext *Ctx, bool Reverse = false);
til::SExpr *translateBinAssign(til::TIL_BinaryOpcode Op,
- const BinaryOperator *BO,
- CallingContext *Ctx, bool Assign = false);
+ const BinaryOperator *BO, CallingContext *Ctx,
+ bool Assign = false);
til::SExpr *translateBinaryOperator(const BinaryOperator *BO,
CallingContext *Ctx);
til::SExpr *translateCastExpr(const CastExpr *CE, CallingContext *Ctx);
til::SExpr *translateArraySubscriptExpr(const ArraySubscriptExpr *E,
CallingContext *Ctx);
- til::SExpr *translateAbstractConditionalOperator(
- const AbstractConditionalOperator *C, CallingContext *Ctx);
+ til::SExpr *
+ translateAbstractConditionalOperator(const AbstractConditionalOperator *C,
+ CallingContext *Ctx);
til::SExpr *translateDeclStmt(const DeclStmt *S, CallingContext *Ctx);
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafetyLogical.h b/clang/include/clang/Analysis/Analyses/ThreadSafetyLogical.h
index 8d938c1b23c07d..6712199d7729d1 100644
--- a/clang/include/clang/Analysis/Analyses/ThreadSafetyLogical.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafetyLogical.h
@@ -20,12 +20,7 @@ namespace lexpr {
class LExpr {
public:
- enum Opcode {
- Terminal,
- And,
- Or,
- Not
- };
+ enum Opcode { Terminal, And, Or, Not };
Opcode kind() const { return Kind; }
/// Logical implication. Returns true if the LExpr implies RHS, i.e. if
@@ -55,7 +50,8 @@ class BinOp : public LExpr {
LExpr *LHS, *RHS;
protected:
- BinOp(LExpr *LHS, LExpr *RHS, Opcode Code) : LExpr(Code), LHS(LHS), RHS(RHS) {}
+ BinOp(LExpr *LHS, LExpr *RHS, Opcode Code)
+ : LExpr(Code), LHS(LHS), RHS(RHS) {}
public:
const LExpr *left() const { return LHS; }
@@ -99,9 +95,8 @@ bool LExpr::implies(const LExpr *RHS) const {
return lexpr::implies(this, RHS);
}
-}
-}
-}
+} // namespace lexpr
+} // namespace threadSafety
+} // namespace clang
#endif
-
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h b/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h
index 65dd66ee093fe4..bddbf236f7ad13 100644
--- a/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h
@@ -82,30 +82,30 @@ enum TIL_Opcode : unsigned char {
/// Opcode for unary arithmetic operations.
enum TIL_UnaryOpcode : unsigned char {
- UOP_Minus, // -
- UOP_BitNot, // ~
- UOP_LogicNot // !
+ UOP_Minus, // -
+ UOP_BitNot, // ~
+ UOP_LogicNot // !
};
/// Opcode for binary arithmetic operations.
enum TIL_BinaryOpcode : unsigned char {
- BOP_Add, // +
- BOP_Sub, // -
- BOP_Mul, // *
- BOP_Div, // /
- BOP_Rem, // %
- BOP_Shl, // <<
- BOP_Shr, // >>
- BOP_BitAnd, // &
- BOP_BitXor, // ^
- BOP_BitOr, // |
- BOP_Eq, // ==
- BOP_Neq, // !=
- BOP_Lt, // <
- BOP_Leq, // <=
- BOP_Cmp, // <=>
- BOP_LogicAnd, // && (no short-circuit)
- BOP_LogicOr // || (no short-circuit)
+ BOP_Add, // +
+ BOP_Sub, // -
+ BOP_Mul, // *
+ BOP_Div, // /
+ BOP_Rem, // %
+ BOP_Shl, // <<
+ BOP_Shr, // >>
+ BOP_BitAnd, // &
+ BOP_BitXor, // ^
+ BOP_BitOr, // |
+ BOP_Eq, // ==
+ BOP_Neq, // !=
+ BOP_Lt, // <
+ BOP_Leq, // <=
+ BOP_Cmp, // <=>
+ BOP_LogicAnd, // && (no short-circuit)
+ BOP_LogicOr // || (no short-circuit)
};
/// Opcode for cast operations.
@@ -128,14 +128,14 @@ enum TIL_CastOpcode : unsigned char {
CAST_objToPtr
};
-const TIL_Opcode COP_Min = COP_Future;
-const TIL_Opcode COP_Max = COP_Branch;
-const TIL_UnaryOpcode UOP_Min = UOP_Minus;
-const TIL_UnaryOpcode UOP_Max = UOP_LogicNot;
-const TIL_BinaryOpcode BOP_Min = BOP_Add;
-const TIL_BinaryOpcode BOP_Max = BOP_LogicOr;
-const TIL_CastOpcode CAST_Min = CAST_none;
-const TIL_CastOpcode CAST_Max = CAST_toInt;
+const TIL_Opcode COP_Min = COP_Future;
+const TIL_Opcode COP_Max = COP_Branch;
+const TIL_UnaryOpcode UOP_Min = UOP_Minus;
+const TIL_UnaryOpcode UOP_Max = UOP_LogicNot;
+const TIL_BinaryOpcode BOP_Min = BOP_Add;
+const TIL_BinaryOpcode BOP_Max = BOP_LogicOr;
+const TIL_CastOpcode CAST_Min = CAST_none;
+const TIL_CastOpcode CAST_Max = CAST_toInt;
/// Return the name of a unary opcode.
StringRef getUnaryOpcodeString(TIL_UnaryOpcode Op);
@@ -155,7 +155,7 @@ struct ValueType {
BT_Bool,
BT_Int,
BT_Float,
- BT_String, // String literals
+ BT_String, // String literals
BT_Pointer,
BT_ValueRef
};
@@ -175,8 +175,7 @@ struct ValueType {
inline static SizeType getSizeType(unsigned nbytes);
- template <class T>
- inline static ValueType getValueType();
+ template <class T> inline static ValueType getValueType();
BaseType Base;
SizeType Size;
@@ -188,88 +187,79 @@ struct ValueType {
inline ValueType::SizeType ValueType::getSizeType(unsigned nbytes) {
switch (nbytes) {
- case 1: return ST_8;
- case 2: return ST_16;
- case 4: return ST_32;
- case 8: return ST_64;
- case 16: return ST_128;
- default: return ST_0;
+ case 1:
+ return ST_8;
+ case 2:
+ return ST_16;
+ case 4:
+ return ST_32;
+ case 8:
+ return ST_64;
+ case 16:
+ return ST_128;
+ default:
+ return ST_0;
}
}
-template<>
-inline ValueType ValueType::getValueType<void>() {
+template <> inline ValueType ValueType::getValueType<void>() {
return ValueType(BT_Void, ST_0, false, 0);
}
-template<>
-inline ValueType ValueType::getValueType<bool>() {
+template <> inline ValueType ValueType::getValueType<bool>() {
return ValueType(BT_Bool, ST_1, false, 0);
}
-template<>
-inline ValueType ValueType::getValueType<int8_t>() {
+template <> inline ValueType ValueType::getValueType<int8_t>() {
return ValueType(BT_Int, ST_8, true, 0);
}
-template<>
-inline ValueType ValueType::getValueType<uint8_t>() {
+template <> inline ValueType ValueType::getValueType<uint8_t>() {
return ValueType(BT_Int, ST_8, false, 0);
}
-template<>
-inline ValueType ValueType::getValueType<int16_t>() {
+template <> inline ValueType ValueType::getValueType<int16_t>() {
return ValueType(BT_Int, ST_16, true, 0);
}
-template<>
-inline ValueType ValueType::getValueType<uint16_t>() {
+template <> inline ValueType ValueType::getValueType<uint16_t>() {
return ValueType(BT_Int, ST_16, false, 0);
}
-template<>
-inline ValueType ValueType::getValueType<int32_t>() {
+template <> inline ValueType ValueType::getValueType<int32_t>() {
return ValueType(BT_Int, ST_32, true, 0);
}
-template<>
-inline ValueType ValueType::getValueType<uint32_t>() {
+template <> inline ValueType ValueType::getValueType<uint32_t>() {
return ValueType(BT_Int, ST_32, false, 0);
}
-template<>
-inline ValueType ValueType::getValueType<int64_t>() {
+template <> inline ValueType ValueType::getValueType<int64_t>() {
return ValueType(BT_Int, ST_64, true, 0);
}
-template<>
-inline ValueType ValueType::getValueType<uint64_t>() {
+template <> inline ValueType ValueType::getValueType<uint64_t>() {
return ValueType(BT_Int, ST_64, false, 0);
}
-template<>
-inline ValueType ValueType::getValueType<float>() {
+template <> inline ValueType ValueType::getValueType<float>() {
return ValueType(BT_Float, ST_32, true, 0);
}
-template<>
-inline ValueType ValueType::getValueType<double>() {
+template <> inline ValueType ValueType::getValueType<double>() {
return ValueType(BT_Float, ST_64, true, 0);
}
-template<>
-inline ValueType ValueType::getValueType<long double>() {
+template <> inline ValueType ValueType::getValueType<long double>() {
return ValueType(BT_Float, ST_128, true, 0);
}
-template<>
-inline ValueType ValueType::getValueType<StringRef>() {
+template <> inline ValueType ValueType::getValueType<StringRef>() {
return ValueType(BT_String, getSizeType(sizeof(StringRef)), false, 0);
}
-template<>
-inline ValueType ValueType::getValueType<void*>() {
- return ValueType(BT_Pointer, getSizeType(sizeof(void*)), false, 0);
+template <> inline ValueType ValueType::getValueType<void *>() {
+ return ValueType(BT_Pointer, getSizeType(sizeof(void *)), false, 0);
}
/// Base class for AST nodes in the typed intermediate language.
@@ -293,9 +283,7 @@ class SExpr {
// template <class C> typename C::CType compare(CType* E, C& Cmp) {
// compare all subexpressions, following the comparator interface
// }
- void *operator new(size_t S, MemRegionRef &R) {
- return ::operator new(S, R);
- }
+ void *operator new(size_t S, MemRegionRef &R) { return ::operator new(S, R); }
/// SExpr objects must be created in an arena.
void *operator new(size_t) = delete;
@@ -314,7 +302,10 @@ class SExpr {
BasicBlock *block() const { return Block; }
/// Set the basic block and instruction ID for this expression.
- void setID(BasicBlock *B, unsigned id) { Block = B; SExprID = id; }
+ void setID(BasicBlock *B, unsigned id) {
+ Block = B;
+ SExprID = id;
+ }
protected:
SExpr(TIL_Opcode Op) : Opcode(Op) {}
@@ -371,12 +362,12 @@ class Variable : public SExpr {
}
Variable(SExpr *D, const ValueDecl *Cvd = nullptr)
- : SExpr(COP_Variable), Name(Cvd ? Cvd->getName() : "_x"),
- Definition(D), Cvdecl(Cvd) {
+ : SExpr(COP_Variable), Name(Cvd ? Cvd->getName() : "_x"), Definition(D),
+ Cvdecl(Cvd) {
Flags = VK_Let;
}
- Variable(const Variable &Vd, SExpr *D) // rewrite constructor
+ Variable(const Variable &Vd, SExpr *D) // rewrite constructor
: SExpr(Vd), Name(Vd.Name), Definition(D), Cvdecl(Vd.Cvdecl) {
Flags = Vd.kind();
}
@@ -398,7 +389,7 @@ class Variable : public SExpr {
SExpr *definition() { return Definition; }
const SExpr *definition() const { return Definition; }
- void setName(StringRef S) { Name = S; }
+ void setName(StringRef S) { Name = S; }
void setKind(VariableKind K) { Flags = K; }
void setDefinition(SExpr *E) { Definition = E; }
void setClangDecl(const ValueDecl *VD) { Cvdecl = VD; }
@@ -410,7 +401,7 @@ class Variable : public SExpr {
}
template <class C>
- typename C::CType compare(const Variable* E, C& Cmp) const {
+ typename C::CType compare(const Variable *E, C &Cmp) const {
return Cmp.compareVariableRefs(this, E);
}
@@ -434,11 +425,7 @@ class Variable : public SExpr {
/// Used to implement lazy copy and rewriting strategies.
class Future : public SExpr {
public:
- enum FutureStatus {
- FS_pending,
- FS_evaluating,
- FS_done
- };
+ enum FutureStatus { FS_pending, FS_evaluating, FS_done };
Future() : SExpr(COP_Future) {}
virtual ~Future() = delete;
@@ -469,15 +456,14 @@ class Future : public SExpr {
return Vs.traverse(Result, Ctx);
}
- template <class C>
- typename C::CType compare(const Future* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const Future *E, C &Cmp) const {
if (!Result || !E->Result)
return Cmp.comparePointers(this, E);
return Cmp.compare(Result, E->Result);
}
private:
- SExpr* force();
+ SExpr *force();
FutureStatus Status = FS_pending;
SExpr *Result = nullptr;
@@ -501,7 +487,7 @@ class Undefined : public SExpr {
}
template <class C>
- typename C::CType compare(const Undefined* E, C& Cmp) const {
+ typename C::CType compare(const Undefined *E, C &Cmp) const {
return Cmp.trueResult();
}
@@ -517,12 +503,13 @@ class Wildcard : public SExpr {
static bool classof(const SExpr *E) { return E->opcode() == COP_Wildcard; }
- template <class V> typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx) {
+ template <class V>
+ typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx) {
return Vs.reduceWildcard(*this);
}
template <class C>
- typename C::CType compare(const Wildcard* E, C& Cmp) const {
+ typename C::CType compare(const Wildcard *E, C &Cmp) const {
return Cmp.trueResult();
}
};
@@ -533,7 +520,8 @@ template <class T> class LiteralT;
class Literal : public SExpr {
public:
Literal(const Expr *C)
- : SExpr(COP_Literal), ValType(ValueType::getValueType<void>()), Cexpr(C) {}
+ : SExpr(COP_Literal), ValType(ValueType::getValueType<void>()), Cexpr(C) {
+ }
Literal(ValueType VT) : SExpr(COP_Literal), ValType(VT) {}
Literal(const Literal &) = default;
@@ -544,17 +532,16 @@ class Literal : public SExpr {
ValueType valueType() const { return ValType; }
- template<class T> const LiteralT<T>& as() const {
- return *static_cast<const LiteralT<T>*>(this);
+ template <class T> const LiteralT<T> &as() const {
+ return *static_cast<const LiteralT<T> *>(this);
}
- template<class T> LiteralT<T>& as() {
- return *static_cast<LiteralT<T>*>(this);
+ template <class T> LiteralT<T> &as() {
+ return *static_cast<LiteralT<T> *>(this);
}
template <class V> typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx);
- template <class C>
- typename C::CType compare(const Literal* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const Literal *E, C &Cmp) const {
// TODO: defer actual comparison to LiteralT
return Cmp.trueResult();
}
@@ -565,8 +552,7 @@ class Literal : public SExpr {
};
// Derived class for literal values, which stores the actual value.
-template<class T>
-class LiteralT : public Literal {
+template <class T> class LiteralT : public Literal {
public:
LiteralT(T Dat) : Literal(ValueType::getValueType<T>()), Val(Dat) {}
LiteralT(const LiteralT<T> &L) : Literal(L), Val(L.Val) {}
@@ -575,8 +561,8 @@ class LiteralT : public Literal {
// motivation.
LiteralT &operator=(const LiteralT<T> &) = delete;
- T value() const { return Val;}
- T& value() { return Val; }
+ T value() const { return Val; }
+ T &value() { return Val; }
private:
T Val;
@@ -631,7 +617,7 @@ typename V::R_SExpr Literal::traverse(V &Vs, typename V::R_Ctx Ctx) {
case ValueType::BT_String:
return Vs.reduceLiteralT(as<StringRef>());
case ValueType::BT_Pointer:
- return Vs.reduceLiteralT(as<void*>());
+ return Vs.reduceLiteralT(as<void *>());
case ValueType::BT_ValueRef:
break;
}
@@ -657,7 +643,7 @@ class LiteralPtr : public SExpr {
}
template <class C>
- typename C::CType compare(const LiteralPtr* E, C& Cmp) const {
+ typename C::CType compare(const LiteralPtr *E, C &Cmp) const {
if (!Cvdecl || !E->Cvdecl)
return Cmp.comparePointers(this, E);
return Cmp.comparePointers(Cvdecl, E->Cvdecl);
@@ -684,7 +670,7 @@ class Function : public SExpr {
static bool classof(const SExpr *E) { return E->opcode() == COP_Function; }
- Variable *variableDecl() { return VarDecl; }
+ Variable *variableDecl() { return VarDecl; }
const Variable *variableDecl() const { return VarDecl; }
SExpr *body() { return Body; }
@@ -702,9 +688,9 @@ class Function : public SExpr {
}
template <class C>
- typename C::CType compare(const Function* E, C& Cmp) const {
+ typename C::CType compare(const Function *E, C &Cmp) const {
typename C::CType Ct =
- Cmp.compare(VarDecl->definition(), E->VarDecl->definition());
+ Cmp.compare(VarDecl->definition(), E->VarDecl->definition());
if (Cmp.notTrue(Ct))
return Ct;
Cmp.enterScope(variableDecl(), E->variableDecl());
@@ -715,7 +701,7 @@ class Function : public SExpr {
private:
Variable *VarDecl;
- SExpr* Body;
+ SExpr *Body;
};
/// A self-applicable function.
@@ -758,7 +744,7 @@ class SFunction : public SExpr {
}
template <class C>
- typename C::CType compare(const SFunction* E, C& Cmp) const {
+ typename C::CType compare(const SFunction *E, C &Cmp) const {
Cmp.enterScope(variableDecl(), E->variableDecl());
typename C::CType Ct = Cmp.compare(body(), E->body());
Cmp.leaveScope();
@@ -767,7 +753,7 @@ class SFunction : public SExpr {
private:
Variable *VarDecl;
- SExpr* Body;
+ SExpr *Body;
};
/// A block of code -- e.g. the body of a function.
@@ -788,12 +774,11 @@ class Code : public SExpr {
template <class V>
typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx) {
auto Nt = Vs.traverse(ReturnType, Vs.typeCtx(Ctx));
- auto Nb = Vs.traverse(Body, Vs.lazyCtx(Ctx));
+ auto Nb = Vs.traverse(Body, Vs.lazyCtx(Ctx));
return Vs.reduceCode(*this, Nt, Nb);
}
- template <class C>
- typename C::CType compare(const Code* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const Code *E, C &Cmp) const {
typename C::CType Ct = Cmp.compare(returnType(), E->returnType());
if (Cmp.notTrue(Ct))
return Ct;
@@ -801,8 +786,8 @@ class Code : public SExpr {
}
private:
- SExpr* ReturnType;
- SExpr* Body;
+ SExpr *ReturnType;
+ SExpr *Body;
};
/// A typed, writable location in memory
@@ -823,12 +808,11 @@ class Field : public SExpr {
template <class V>
typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx) {
auto Nr = Vs.traverse(Range, Vs.typeCtx(Ctx));
- auto Nb = Vs.traverse(Body, Vs.lazyCtx(Ctx));
+ auto Nb = Vs.traverse(Body, Vs.lazyCtx(Ctx));
return Vs.reduceField(*this, Nr, Nb);
}
- template <class C>
- typename C::CType compare(const Field* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const Field *E, C &Cmp) const {
typename C::CType Ct = Cmp.compare(range(), E->range());
if (Cmp.notTrue(Ct))
return Ct;
@@ -836,8 +820,8 @@ class Field : public SExpr {
}
private:
- SExpr* Range;
- SExpr* Body;
+ SExpr *Range;
+ SExpr *Body;
};
/// Apply an argument to a function.
@@ -848,7 +832,7 @@ class Field : public SExpr {
class Apply : public SExpr {
public:
Apply(SExpr *F, SExpr *A) : SExpr(COP_Apply), Fun(F), Arg(A) {}
- Apply(const Apply &A, SExpr *F, SExpr *Ar) // rewrite constructor
+ Apply(const Apply &A, SExpr *F, SExpr *Ar) // rewrite constructor
: SExpr(A), Fun(F), Arg(Ar) {}
static bool classof(const SExpr *E) { return E->opcode() == COP_Apply; }
@@ -866,8 +850,7 @@ class Apply : public SExpr {
return Vs.reduceApply(*this, Nf, Na);
}
- template <class C>
- typename C::CType compare(const Apply* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const Apply *E, C &Cmp) const {
typename C::CType Ct = Cmp.compare(fun(), E->fun());
if (Cmp.notTrue(Ct))
return Ct;
@@ -875,8 +858,8 @@ class Apply : public SExpr {
}
private:
- SExpr* Fun;
- SExpr* Arg;
+ SExpr *Fun;
+ SExpr *Arg;
};
/// Apply a self-argument to a self-applicable function.
@@ -899,13 +882,12 @@ class SApply : public SExpr {
template <class V>
typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx) {
auto Nf = Vs.traverse(Sfun, Vs.subExprCtx(Ctx));
- typename V::R_SExpr Na = Arg ? Vs.traverse(Arg, Vs.subExprCtx(Ctx))
- : nullptr;
+ typename V::R_SExpr Na =
+ Arg ? Vs.traverse(Arg, Vs.subExprCtx(Ctx)) : nullptr;
return Vs.reduceSApply(*this, Nf, Na);
}
- template <class C>
- typename C::CType compare(const SApply* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const SApply *E, C &Cmp) const {
typename C::CType Ct = Cmp.compare(sfun(), E->sfun());
if (Cmp.notTrue(Ct) || (!arg() && !E->arg()))
return Ct;
@@ -913,8 +895,8 @@ class SApply : public SExpr {
}
private:
- SExpr* Sfun;
- SExpr* Arg;
+ SExpr *Sfun;
+ SExpr *Arg;
};
/// Project a named slot from a C++ struct or class.
@@ -935,8 +917,10 @@ class Project : public SExpr {
bool isArrow() const { return (Flags & 0x01) != 0; }
void setArrow(bool b) {
- if (b) Flags |= 0x01;
- else Flags &= 0xFFFE;
+ if (b)
+ Flags |= 0x01;
+ else
+ Flags &= 0xFFFE;
}
StringRef slotName() const {
@@ -956,8 +940,7 @@ class Project : public SExpr {
return Vs.reduceProject(*this, Nr);
}
- template <class C>
- typename C::CType compare(const Project* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const Project *E, C &Cmp) const {
typename C::CType Ct = Cmp.compare(record(), E->record());
if (Cmp.notTrue(Ct))
return Ct;
@@ -965,7 +948,7 @@ class Project : public SExpr {
}
private:
- SExpr* Rec;
+ SExpr *Rec;
mutable std::optional<std::string> SlotName;
const ValueDecl *Cvdecl;
};
@@ -990,23 +973,19 @@ class Call : public SExpr {
return Vs.reduceCall(*this, Nt);
}
- template <class C>
- typename C::CType compare(const Call* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const Call *E, C &Cmp) const {
return Cmp.compare(target(), E->target());
}
private:
- SExpr* Target;
+ SExpr *Target;
const CallExpr *Cexpr;
};
/// Allocate memory for a new value on the heap or stack.
class Alloc : public SExpr {
public:
- enum AllocKind {
- AK_Stack,
- AK_Heap
- };
+ enum AllocKind { AK_Stack, AK_Heap };
Alloc(SExpr *D, AllocKind K) : SExpr(COP_Alloc), Dtype(D) { Flags = K; }
Alloc(const Alloc &A, SExpr *Dt) : SExpr(A), Dtype(Dt) { Flags = A.kind(); }
@@ -1024,8 +1003,7 @@ class Alloc : public SExpr {
return Vs.reduceAlloc(*this, Nd);
}
- template <class C>
- typename C::CType compare(const Alloc* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const Alloc *E, C &Cmp) const {
typename C::CType Ct = Cmp.compareIntegers(kind(), E->kind());
if (Cmp.notTrue(Ct))
return Ct;
@@ -1033,7 +1011,7 @@ class Alloc : public SExpr {
}
private:
- SExpr* Dtype;
+ SExpr *Dtype;
};
/// Load a value from memory.
@@ -1053,13 +1031,12 @@ class Load : public SExpr {
return Vs.reduceLoad(*this, Np);
}
- template <class C>
- typename C::CType compare(const Load* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const Load *E, C &Cmp) const {
return Cmp.compare(pointer(), E->pointer());
}
private:
- SExpr* Ptr;
+ SExpr *Ptr;
};
/// Store a value to memory.
@@ -1071,21 +1048,20 @@ class Store : public SExpr {
static bool classof(const SExpr *E) { return E->opcode() == COP_Store; }
- SExpr *destination() { return Dest; } // Address to store to
+ SExpr *destination() { return Dest; } // Address to store to
const SExpr *destination() const { return Dest; }
- SExpr *source() { return Source; } // Value to store
+ SExpr *source() { return Source; } // Value to store
const SExpr *source() const { return Source; }
template <class V>
typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx) {
- auto Np = Vs.traverse(Dest, Vs.subExprCtx(Ctx));
+ auto Np = Vs.traverse(Dest, Vs.subExprCtx(Ctx));
auto Nv = Vs.traverse(Source, Vs.subExprCtx(Ctx));
return Vs.reduceStore(*this, Np, Nv);
}
- template <class C>
- typename C::CType compare(const Store* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const Store *E, C &Cmp) const {
typename C::CType Ct = Cmp.compare(destination(), E->destination());
if (Cmp.notTrue(Ct))
return Ct;
@@ -1093,8 +1069,8 @@ class Store : public SExpr {
}
private:
- SExpr* Dest;
- SExpr* Source;
+ SExpr *Dest;
+ SExpr *Source;
};
/// If p is a reference to an array, then p[i] is a reference to the i'th
@@ -1121,7 +1097,7 @@ class ArrayIndex : public SExpr {
}
template <class C>
- typename C::CType compare(const ArrayIndex* E, C& Cmp) const {
+ typename C::CType compare(const ArrayIndex *E, C &Cmp) const {
typename C::CType Ct = Cmp.compare(array(), E->array());
if (Cmp.notTrue(Ct))
return Ct;
@@ -1129,8 +1105,8 @@ class ArrayIndex : public SExpr {
}
private:
- SExpr* Array;
- SExpr* Index;
+ SExpr *Array;
+ SExpr *Index;
};
/// Pointer arithmetic, restricted to arrays only.
@@ -1158,7 +1134,7 @@ class ArrayAdd : public SExpr {
}
template <class C>
- typename C::CType compare(const ArrayAdd* E, C& Cmp) const {
+ typename C::CType compare(const ArrayAdd *E, C &Cmp) const {
typename C::CType Ct = Cmp.compare(array(), E->array());
if (Cmp.notTrue(Ct))
return Ct;
@@ -1166,8 +1142,8 @@ class ArrayAdd : public SExpr {
}
private:
- SExpr* Array;
- SExpr* Index;
+ SExpr *Array;
+ SExpr *Index;
};
/// Simple arithmetic unary operations, e.g. negate and not.
@@ -1195,17 +1171,15 @@ class UnaryOp : public SExpr {
return Vs.reduceUnaryOp(*this, Ne);
}
- template <class C>
- typename C::CType compare(const UnaryOp* E, C& Cmp) const {
- typename C::CType Ct =
- Cmp.compareIntegers(unaryOpcode(), E->unaryOpcode());
+ template <class C> typename C::CType compare(const UnaryOp *E, C &Cmp) const {
+ typename C::CType Ct = Cmp.compareIntegers(unaryOpcode(), E->unaryOpcode());
if (Cmp.notTrue(Ct))
return Ct;
return Cmp.compare(expr(), E->expr());
}
private:
- SExpr* Expr0;
+ SExpr *Expr0;
};
/// Simple arithmetic binary operations, e.g. +, -, etc.
@@ -1242,9 +1216,9 @@ class BinaryOp : public SExpr {
}
template <class C>
- typename C::CType compare(const BinaryOp* E, C& Cmp) const {
+ typename C::CType compare(const BinaryOp *E, C &Cmp) const {
typename C::CType Ct =
- Cmp.compareIntegers(binaryOpcode(), E->binaryOpcode());
+ Cmp.compareIntegers(binaryOpcode(), E->binaryOpcode());
if (Cmp.notTrue(Ct))
return Ct;
Ct = Cmp.compare(expr0(), E->expr0());
@@ -1254,8 +1228,8 @@ class BinaryOp : public SExpr {
}
private:
- SExpr* Expr0;
- SExpr* Expr1;
+ SExpr *Expr0;
+ SExpr *Expr1;
};
/// Cast expressions.
@@ -1281,17 +1255,15 @@ class Cast : public SExpr {
return Vs.reduceCast(*this, Ne);
}
- template <class C>
- typename C::CType compare(const Cast* E, C& Cmp) const {
- typename C::CType Ct =
- Cmp.compareIntegers(castOpcode(), E->castOpcode());
+ template <class C> typename C::CType compare(const Cast *E, C &Cmp) const {
+ typename C::CType Ct = Cmp.compareIntegers(castOpcode(), E->castOpcode());
if (Cmp.notTrue(Ct))
return Ct;
return Cmp.compare(expr(), E->expr());
}
private:
- SExpr* Expr0;
+ SExpr *Expr0;
};
class SCFG;
@@ -1313,7 +1285,7 @@ class Phi : public SExpr {
};
Phi() : SExpr(COP_Phi) {}
- Phi(MemRegionRef A, unsigned Nvals) : SExpr(COP_Phi), Values(A, Nvals) {}
+ Phi(MemRegionRef A, unsigned Nvals) : SExpr(COP_Phi), Values(A, Nvals) {}
Phi(const Phi &P, ValArray &&Vs) : SExpr(P), Values(std::move(Vs)) {}
static bool classof(const SExpr *E) { return E->opcode() == COP_Phi; }
@@ -1332,23 +1304,21 @@ class Phi : public SExpr {
template <class V>
typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx) {
- typename V::template Container<typename V::R_SExpr>
- Nvs(Vs, Values.size());
+ typename V::template Container<typename V::R_SExpr> Nvs(Vs, Values.size());
for (const auto *Val : Values)
- Nvs.push_back( Vs.traverse(Val, Vs.subExprCtx(Ctx)) );
+ Nvs.push_back(Vs.traverse(Val, Vs.subExprCtx(Ctx)));
return Vs.reducePhi(*this, Nvs);
}
- template <class C>
- typename C::CType compare(const Phi *E, C &Cmp) const {
+ template <class C> typename C::CType compare(const Phi *E, C &Cmp) const {
// TODO: implement CFG comparisons
return Cmp.comparePointers(this, E);
}
private:
ValArray Values;
- const ValueDecl* Cvdecl = nullptr;
+ const ValueDecl *Cvdecl = nullptr;
};
/// Base class for basic block terminators: Branch, Goto, and Return.
@@ -1366,7 +1336,7 @@ class Terminator : public SExpr {
ArrayRef<BasicBlock *> successors();
ArrayRef<BasicBlock *> successors() const {
- return const_cast<Terminator*>(this)->successors();
+ return const_cast<Terminator *>(this)->successors();
}
};
@@ -1399,8 +1369,7 @@ class Goto : public Terminator {
return Vs.reduceGoto(*this, Ntb);
}
- template <class C>
- typename C::CType compare(const Goto *E, C &Cmp) const {
+ template <class C> typename C::CType compare(const Goto *E, C &Cmp) const {
// TODO: implement CFG comparisons
return Cmp.comparePointers(this, E);
}
@@ -1449,8 +1418,7 @@ class Branch : public Terminator {
return Vs.reduceBranch(*this, Nc, Ntb, Nte);
}
- template <class C>
- typename C::CType compare(const Branch *E, C &Cmp) const {
+ template <class C> typename C::CType compare(const Branch *E, C &Cmp) const {
// TODO: implement CFG comparisons
return Cmp.comparePointers(this, E);
}
@@ -1464,8 +1432,8 @@ class Branch : public Terminator {
/// Only the exit block should end with a return statement.
class Return : public Terminator {
public:
- Return(SExpr* Rval) : Terminator(COP_Return), Retval(Rval) {}
- Return(const Return &R, SExpr* Rval) : Terminator(R), Retval(Rval) {}
+ Return(SExpr *Rval) : Terminator(COP_Return), Retval(Rval) {}
+ Return(const Return &R, SExpr *Rval) : Terminator(R), Retval(Rval) {}
static bool classof(const SExpr *E) { return E->opcode() == COP_Return; }
@@ -1481,22 +1449,24 @@ class Return : public Terminator {
return Vs.reduceReturn(*this, Ne);
}
- template <class C>
- typename C::CType compare(const Return *E, C &Cmp) const {
+ template <class C> typename C::CType compare(const Return *E, C &Cmp) const {
return Cmp.compare(Retval, E->Retval);
}
private:
- SExpr* Retval;
+ SExpr *Retval;
};
-inline ArrayRef<BasicBlock*> Terminator::successors() {
+inline ArrayRef<BasicBlock *> Terminator::successors() {
switch (opcode()) {
- case COP_Goto: return cast<Goto>(this)->successors();
- case COP_Branch: return cast<Branch>(this)->successors();
- case COP_Return: return cast<Return>(this)->successors();
- default:
- return std::nullopt;
+ case COP_Goto:
+ return cast<Goto>(this)->successors();
+ case COP_Branch:
+ return cast<Branch>(this)->successors();
+ case COP_Return:
+ return cast<Return>(this)->successors();
+ default:
+ return std::nullopt;
}
}
@@ -1525,12 +1495,12 @@ class BasicBlock : public SExpr {
TopologyNode() = default;
- bool isParentOf(const TopologyNode& OtherNode) {
+ bool isParentOf(const TopologyNode &OtherNode) {
return OtherNode.NodeID > NodeID &&
OtherNode.NodeID < NodeID + SizeOfSubTree;
}
- bool isParentOfOrEqual(const TopologyNode& OtherNode) {
+ bool isParentOfOrEqual(const TopologyNode &OtherNode) {
return OtherNode.NodeID >= NodeID &&
OtherNode.NodeID < NodeID + SizeOfSubTree;
}
@@ -1552,8 +1522,8 @@ class BasicBlock : public SExpr {
size_t numPredecessors() const { return Predecessors.size(); }
size_t numSuccessors() const { return successors().size(); }
- const SCFG* cfg() const { return CFGPtr; }
- SCFG* cfg() { return CFGPtr; }
+ const SCFG *cfg() const { return CFGPtr; }
+ SCFG *cfg() { return CFGPtr; }
const BasicBlock *parent() const { return DominatorNode.Parent; }
BasicBlock *parent() { return DominatorNode.Parent; }
@@ -1570,8 +1540,8 @@ class BasicBlock : public SExpr {
BlockArray &predecessors() { return Predecessors; }
const BlockArray &predecessors() const { return Predecessors; }
- ArrayRef<BasicBlock*> successors() { return TermInstr->successors(); }
- ArrayRef<BasicBlock*> successors() const { return TermInstr->successors(); }
+ ArrayRef<BasicBlock *> successors() { return TermInstr->successors(); }
+ ArrayRef<BasicBlock *> successors() const { return TermInstr->successors(); }
const Terminator *terminator() const { return TermInstr; }
Terminator *terminator() { return TermInstr; }
@@ -1603,7 +1573,7 @@ class BasicBlock : public SExpr {
unsigned addPredecessor(BasicBlock *Pred);
// Reserve space for Nargs arguments.
- void reserveArguments(unsigned Nargs) { Args.reserve(Nargs, Arena); }
+ void reserveArguments(unsigned Nargs) { Args.reserve(Nargs, Arena); }
// Reserve space for Nins instructions.
void reserveInstructions(unsigned Nins) { Instrs.reserve(Nins, Arena); }
@@ -1619,8 +1589,8 @@ class BasicBlock : public SExpr {
template <class V>
typename V::R_BasicBlock traverse(V &Vs, typename V::R_Ctx Ctx) {
- typename V::template Container<SExpr*> Nas(Vs, Args.size());
- typename V::template Container<SExpr*> Nis(Vs, Instrs.size());
+ typename V::template Container<SExpr *> Nas(Vs, Args.size());
+ typename V::template Container<SExpr *> Nis(Vs, Instrs.size());
// Entering the basic block should do any scope initialization.
Vs.enterBasicBlock(*this);
@@ -1701,7 +1671,7 @@ class SCFG : public SExpr {
SCFG(MemRegionRef A, unsigned Nblocks)
: SExpr(COP_SCFG), Arena(A), Blocks(A, Nblocks) {
Entry = new (A) BasicBlock(A);
- Exit = new (A) BasicBlock(A);
+ Exit = new (A) BasicBlock(A);
auto *V = new (A) Phi();
Exit->addArgument(V);
Exit->setTerminator(new (A) Return(V));
@@ -1755,7 +1725,7 @@ class SCFG : public SExpr {
}
void setEntry(BasicBlock *BB) { Entry = BB; }
- void setExit(BasicBlock *BB) { Exit = BB; }
+ void setExit(BasicBlock *BB) { Exit = BB; }
void computeNormalForm();
@@ -1765,14 +1735,13 @@ class SCFG : public SExpr {
typename V::template Container<BasicBlock *> Bbs(Vs, Blocks.size());
for (const auto *B : Blocks) {
- Bbs.push_back( B->traverse(Vs, Vs.subExprCtx(Ctx)) );
+ Bbs.push_back(B->traverse(Vs, Vs.subExprCtx(Ctx)));
}
Vs.exitCFG(*this);
return Vs.reduceSCFG(*this, Bbs);
}
- template <class C>
- typename C::CType compare(const SCFG *E, C &Cmp) const {
+ template <class C> typename C::CType compare(const SCFG *E, C &Cmp) const {
// TODO: implement CFG comparisons
return Cmp.comparePointers(this, E);
}
@@ -1793,7 +1762,7 @@ class SCFG : public SExpr {
/// This is a pseduo-term; it will be lowered to a variable or projection.
class Identifier : public SExpr {
public:
- Identifier(StringRef Id): SExpr(COP_Identifier), Name(Id) {}
+ Identifier(StringRef Id) : SExpr(COP_Identifier), Name(Id) {}
Identifier(const Identifier &) = default;
static bool classof(const SExpr *E) { return E->opcode() == COP_Identifier; }
@@ -1806,7 +1775,7 @@ class Identifier : public SExpr {
}
template <class C>
- typename C::CType compare(const Identifier* E, C& Cmp) const {
+ typename C::CType compare(const Identifier *E, C &Cmp) const {
return Cmp.compareStrings(name(), E->name());
}
@@ -1825,25 +1794,25 @@ class IfThenElse : public SExpr {
static bool classof(const SExpr *E) { return E->opcode() == COP_IfThenElse; }
- SExpr *condition() { return Condition; } // Address to store to
+ SExpr *condition() { return Condition; } // Address to store to
const SExpr *condition() const { return Condition; }
- SExpr *thenExpr() { return ThenExpr; } // Value to store
+ SExpr *thenExpr() { return ThenExpr; } // Value to store
const SExpr *thenExpr() const { return ThenExpr; }
- SExpr *elseExpr() { return ElseExpr; } // Value to store
+ SExpr *elseExpr() { return ElseExpr; } // Value to store
const SExpr *elseExpr() const { return ElseExpr; }
template <class V>
typename V::R_SExpr traverse(V &Vs, typename V::R_Ctx Ctx) {
auto Nc = Vs.traverse(Condition, Vs.subExprCtx(Ctx));
- auto Nt = Vs.traverse(ThenExpr, Vs.subExprCtx(Ctx));
- auto Ne = Vs.traverse(ElseExpr, Vs.subExprCtx(Ctx));
+ auto Nt = Vs.traverse(ThenExpr, Vs.subExprCtx(Ctx));
+ auto Ne = Vs.traverse(ElseExpr, Vs.subExprCtx(Ctx));
return Vs.reduceIfThenElse(*this, Nc, Nt, Ne);
}
template <class C>
- typename C::CType compare(const IfThenElse* E, C& Cmp) const {
+ typename C::CType compare(const IfThenElse *E, C &Cmp) const {
typename C::CType Ct = Cmp.compare(condition(), E->condition());
if (Cmp.notTrue(Ct))
return Ct;
@@ -1854,9 +1823,9 @@ class IfThenElse : public SExpr {
}
private:
- SExpr* Condition;
- SExpr* ThenExpr;
- SExpr* ElseExpr;
+ SExpr *Condition;
+ SExpr *ThenExpr;
+ SExpr *ElseExpr;
};
/// A let-expression, e.g. let x=t; u.
@@ -1873,7 +1842,7 @@ class Let : public SExpr {
static bool classof(const SExpr *E) { return E->opcode() == COP_Let; }
- Variable *variableDecl() { return VarDecl; }
+ Variable *variableDecl() { return VarDecl; }
const Variable *variableDecl() const { return VarDecl; }
SExpr *body() { return Body; }
@@ -1890,10 +1859,9 @@ class Let : public SExpr {
return Vs.reduceLet(*this, Nvd, E1);
}
- template <class C>
- typename C::CType compare(const Let* E, C& Cmp) const {
+ template <class C> typename C::CType compare(const Let *E, C &Cmp) const {
typename C::CType Ct =
- Cmp.compare(VarDecl->definition(), E->VarDecl->definition());
+ Cmp.compare(VarDecl->definition(), E->VarDecl->definition());
if (Cmp.notTrue(Ct))
return Ct;
Cmp.enterScope(variableDecl(), E->variableDecl());
@@ -1904,11 +1872,11 @@ class Let : public SExpr {
private:
Variable *VarDecl;
- SExpr* Body;
+ SExpr *Body;
};
const SExpr *getCanonicalVal(const SExpr *E);
-SExpr* simplifyToCanonicalVal(SExpr *E);
+SExpr *simplifyToCanonicalVal(SExpr *E);
void simplifyIncompleteArg(til::Phi *Ph);
} // namespace til
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h b/clang/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h
index 6fc55130655a29..1b3b4bd10e3b1a 100644
--- a/clang/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h
@@ -54,8 +54,7 @@ namespace til {
// They are defined in derived classes.
//
// Class R defines the basic interface types (R_SExpr).
-template <class Self, class R>
-class Traversal {
+template <class Self, class R> class Traversal {
public:
Self *self() { return static_cast<Self *>(this); }
@@ -65,7 +64,7 @@ class Traversal {
// E is a reference, so this can be use for in-place updates.
// The type T must be a subclass of SExpr.
template <class T>
- typename R::R_SExpr traverse(T* &E, typename R::R_Ctx Ctx) {
+ typename R::R_SExpr traverse(T *&E, typename R::R_Ctx Ctx) {
return traverseSExpr(E, Ctx);
}
@@ -78,9 +77,9 @@ class Traversal {
// Helper method to call traverseX(e) on the appropriate type.
typename R::R_SExpr traverseByCase(SExpr *E, typename R::R_Ctx Ctx) {
switch (E->opcode()) {
-#define TIL_OPCODE_DEF(X) \
- case COP_##X: \
- return self()->traverse##X(cast<X>(E), Ctx);
+#define TIL_OPCODE_DEF(X) \
+ case COP_##X: \
+ return self()->traverse##X(cast<X>(E), Ctx);
#include "ThreadSafetyOps.def"
#undef TIL_OPCODE_DEF
}
@@ -89,9 +88,9 @@ class Traversal {
// Traverse e, by static dispatch on the type "X" of e.
// Override these methods to do something for a particular kind of term.
-#define TIL_OPCODE_DEF(X) \
- typename R::R_SExpr traverse##X(X *e, typename R::R_Ctx Ctx) { \
- return e->traverse(*self(), Ctx); \
+#define TIL_OPCODE_DEF(X) \
+ typename R::R_SExpr traverse##X(X *e, typename R::R_Ctx Ctx) { \
+ return e->traverse(*self(), Ctx); \
}
#include "ThreadSafetyOps.def"
#undef TIL_OPCODE_DEF
@@ -193,8 +192,7 @@ class VisitReducer : public Traversal<Self, VisitReducerBase>,
R_SExpr reduceWildcard(Wildcard &Orig) { return true; }
R_SExpr reduceLiteral(Literal &Orig) { return true; }
- template<class T>
- R_SExpr reduceLiteralT(LiteralT<T> &Orig) { return true; }
+ template <class T> R_SExpr reduceLiteralT(LiteralT<T> &Orig) { return true; }
R_SExpr reduceLiteralPtr(Literal &Orig) { return true; }
R_SExpr reduceFunction(Function &Orig, Variable *Nvd, R_SExpr E0) {
@@ -205,17 +203,11 @@ class VisitReducer : public Traversal<Self, VisitReducerBase>,
return Nvd && E0;
}
- R_SExpr reduceCode(Code &Orig, R_SExpr E0, R_SExpr E1) {
- return E0 && E1;
- }
+ R_SExpr reduceCode(Code &Orig, R_SExpr E0, R_SExpr E1) { return E0 && E1; }
- R_SExpr reduceField(Field &Orig, R_SExpr E0, R_SExpr E1) {
- return E0 && E1;
- }
+ R_SExpr reduceField(Field &Orig, R_SExpr E0, R_SExpr E1) { return E0 && E1; }
- R_SExpr reduceApply(Apply &Orig, R_SExpr E0, R_SExpr E1) {
- return E0 && E1;
- }
+ R_SExpr reduceApply(Apply &Orig, R_SExpr E0, R_SExpr E1) { return E0 && E1; }
R_SExpr reduceSApply(SApply &Orig, R_SExpr E0, R_SExpr E1) {
return E0 && E1;
@@ -252,33 +244,23 @@ class VisitReducer : public Traversal<Self, VisitReducerBase>,
return (As.Success && Is.Success && T);
}
- R_SExpr reducePhi(Phi &Orig, Container<R_SExpr> &As) {
- return As.Success;
- }
+ R_SExpr reducePhi(Phi &Orig, Container<R_SExpr> &As) { return As.Success; }
- R_SExpr reduceGoto(Goto &Orig, BasicBlock *B) {
- return true;
- }
+ R_SExpr reduceGoto(Goto &Orig, BasicBlock *B) { return true; }
R_SExpr reduceBranch(Branch &O, R_SExpr C, BasicBlock *B0, BasicBlock *B1) {
return C;
}
- R_SExpr reduceReturn(Return &O, R_SExpr E) {
- return E;
- }
+ R_SExpr reduceReturn(Return &O, R_SExpr E) { return E; }
- R_SExpr reduceIdentifier(Identifier &Orig) {
- return true;
- }
+ R_SExpr reduceIdentifier(Identifier &Orig) { return true; }
R_SExpr reduceIfThenElse(IfThenElse &Orig, R_SExpr C, R_SExpr T, R_SExpr E) {
return C && T && E;
}
- R_SExpr reduceLet(Let &Orig, Variable *Nvd, R_SExpr B) {
- return Nvd && B;
- }
+ R_SExpr reduceLet(Let &Orig, Variable *Nvd, R_SExpr B) { return Nvd && B; }
Variable *enterScope(Variable &Orig, R_SExpr E0) { return &Orig; }
void exitScope(const Variable &Orig) {}
@@ -306,17 +288,16 @@ class VisitReducer : public Traversal<Self, VisitReducerBase>,
};
// Basic class for comparison operations over expressions.
-template <typename Self>
-class Comparator {
+template <typename Self> class Comparator {
protected:
Self *self() { return reinterpret_cast<Self *>(this); }
public:
- bool compareByCase(const SExpr *E1, const SExpr* E2) {
+ bool compareByCase(const SExpr *E1, const SExpr *E2) {
switch (E1->opcode()) {
-#define TIL_OPCODE_DEF(X) \
- case COP_##X: \
- return cast<X>(E1)->compare(cast<X>(E2), *self());
+#define TIL_OPCODE_DEF(X) \
+ case COP_##X: \
+ return cast<X>(E1)->compare(cast<X>(E2), *self());
#include "ThreadSafetyOps.def"
#undef TIL_OPCODE_DEF
}
@@ -335,10 +316,10 @@ class EqualsComparator : public Comparator<EqualsComparator> {
bool notTrue(CType ct) { return !ct; }
bool compareIntegers(unsigned i, unsigned j) { return i == j; }
- bool compareStrings (StringRef s, StringRef r) { return s == r; }
- bool comparePointers(const void* P, const void* Q) { return P == Q; }
+ bool compareStrings(StringRef s, StringRef r) { return s == r; }
+ bool comparePointers(const void *P, const void *Q) { return P == Q; }
- bool compare(const SExpr *E1, const SExpr* E2) {
+ bool compare(const SExpr *E1, const SExpr *E2) {
if (E1->opcode() != E2->opcode())
return false;
return compareByCase(E1, E2);
@@ -352,7 +333,7 @@ class EqualsComparator : public Comparator<EqualsComparator> {
return V1 == V2;
}
- static bool compareExprs(const SExpr *E1, const SExpr* E2) {
+ static bool compareExprs(const SExpr *E1, const SExpr *E2) {
EqualsComparator Eq;
return Eq.compare(E1, E2);
}
@@ -369,7 +350,7 @@ class MatchComparator : public Comparator<MatchComparator> {
bool notTrue(CType ct) { return !ct; }
bool compareIntegers(unsigned i, unsigned j) { return i == j; }
- bool compareStrings (StringRef s, StringRef r) { return s == r; }
+ bool compareStrings(StringRef s, StringRef r) { return s == r; }
bool comparePointers(const void *P, const void *Q) { return P == Q; }
bool compare(const SExpr *E1, const SExpr *E2) {
@@ -383,14 +364,14 @@ class MatchComparator : public Comparator<MatchComparator> {
}
// TODO -- handle alpha-renaming of variables
- void enterScope(const Variable* V1, const Variable* V2) {}
+ void enterScope(const Variable *V1, const Variable *V2) {}
void leaveScope() {}
- bool compareVariableRefs(const Variable* V1, const Variable* V2) {
+ bool compareVariableRefs(const Variable *V1, const Variable *V2) {
return V1 == V2;
}
- static bool compareExprs(const SExpr *E1, const SExpr* E2) {
+ static bool compareExprs(const SExpr *E1, const SExpr *E2) {
MatchComparator Matcher;
return Matcher.compare(E1, E2);
}
@@ -401,8 +382,7 @@ class MatchComparator : public Comparator<MatchComparator> {
// }
// Pretty printer for TIL expressions
-template <typename Self, typename StreamType>
-class PrettyPrinter {
+template <typename Self, typename StreamType> class PrettyPrinter {
private:
// Print out additional information.
bool Verbose;
@@ -425,9 +405,7 @@ class PrettyPrinter {
protected:
Self *self() { return reinterpret_cast<Self *>(this); }
- void newline(StreamType &SS) {
- SS << "\n";
- }
+ void newline(StreamType &SS) { SS << "\n"; }
// TODO: further distinguish between binary operations.
static const unsigned Prec_Atom = 0;
@@ -441,48 +419,79 @@ class PrettyPrinter {
// Return the precedence of a given node, for use in pretty printing.
unsigned precedence(const SExpr *E) {
switch (E->opcode()) {
- case COP_Future: return Prec_Atom;
- case COP_Undefined: return Prec_Atom;
- case COP_Wildcard: return Prec_Atom;
-
- case COP_Literal: return Prec_Atom;
- case COP_LiteralPtr: return Prec_Atom;
- case COP_Variable: return Prec_Atom;
- case COP_Function: return Prec_Decl;
- case COP_SFunction: return Prec_Decl;
- case COP_Code: return Prec_Decl;
- case COP_Field: return Prec_Decl;
-
- case COP_Apply: return Prec_Postfix;
- case COP_SApply: return Prec_Postfix;
- case COP_Project: return Prec_Postfix;
-
- case COP_Call: return Prec_Postfix;
- case COP_Alloc: return Prec_Other;
- case COP_Load: return Prec_Postfix;
- case COP_Store: return Prec_Other;
- case COP_ArrayIndex: return Prec_Postfix;
- case COP_ArrayAdd: return Prec_Postfix;
-
- case COP_UnaryOp: return Prec_Unary;
- case COP_BinaryOp: return Prec_Binary;
- case COP_Cast: return Prec_Atom;
-
- case COP_SCFG: return Prec_Decl;
- case COP_BasicBlock: return Prec_MAX;
- case COP_Phi: return Prec_Atom;
- case COP_Goto: return Prec_Atom;
- case COP_Branch: return Prec_Atom;
- case COP_Return: return Prec_Other;
-
- case COP_Identifier: return Prec_Atom;
- case COP_IfThenElse: return Prec_Other;
- case COP_Let: return Prec_Decl;
+ case COP_Future:
+ return Prec_Atom;
+ case COP_Undefined:
+ return Prec_Atom;
+ case COP_Wildcard:
+ return Prec_Atom;
+
+ case COP_Literal:
+ return Prec_Atom;
+ case COP_LiteralPtr:
+ return Prec_Atom;
+ case COP_Variable:
+ return Prec_Atom;
+ case COP_Function:
+ return Prec_Decl;
+ case COP_SFunction:
+ return Prec_Decl;
+ case COP_Code:
+ return Prec_Decl;
+ case COP_Field:
+ return Prec_Decl;
+
+ case COP_Apply:
+ return Prec_Postfix;
+ case COP_SApply:
+ return Prec_Postfix;
+ case COP_Project:
+ return Prec_Postfix;
+
+ case COP_Call:
+ return Prec_Postfix;
+ case COP_Alloc:
+ return Prec_Other;
+ case COP_Load:
+ return Prec_Postfix;
+ case COP_Store:
+ return Prec_Other;
+ case COP_ArrayIndex:
+ return Prec_Postfix;
+ case COP_ArrayAdd:
+ return Prec_Postfix;
+
+ case COP_UnaryOp:
+ return Prec_Unary;
+ case COP_BinaryOp:
+ return Prec_Binary;
+ case COP_Cast:
+ return Prec_Atom;
+
+ case COP_SCFG:
+ return Prec_Decl;
+ case COP_BasicBlock:
+ return Prec_MAX;
+ case COP_Phi:
+ return Prec_Atom;
+ case COP_Goto:
+ return Prec_Atom;
+ case COP_Branch:
+ return Prec_Atom;
+ case COP_Return:
+ return Prec_Other;
+
+ case COP_Identifier:
+ return Prec_Atom;
+ case COP_IfThenElse:
+ return Prec_Other;
+ case COP_Let:
+ return Prec_Decl;
}
return Prec_MAX;
}
- void printBlockLabel(StreamType & SS, const BasicBlock *BB, int index) {
+ void printBlockLabel(StreamType &SS, const BasicBlock *BB, int index) {
if (!BB) {
SS << "BB_null";
return;
@@ -495,7 +504,7 @@ class PrettyPrinter {
}
}
- void printSExpr(const SExpr *E, StreamType &SS, unsigned P, bool Sub=true) {
+ void printSExpr(const SExpr *E, StreamType &SS, unsigned P, bool Sub = true) {
if (!E) {
self()->printNull(SS);
return;
@@ -513,18 +522,16 @@ class PrettyPrinter {
}
switch (E->opcode()) {
-#define TIL_OPCODE_DEF(X) \
- case COP_##X: \
- self()->print##X(cast<X>(E), SS); \
- return;
+#define TIL_OPCODE_DEF(X) \
+ case COP_##X: \
+ self()->print##X(cast<X>(E), SS); \
+ return;
#include "ThreadSafetyOps.def"
#undef TIL_OPCODE_DEF
}
}
- void printNull(StreamType &SS) {
- SS << "#null";
- }
+ void printNull(StreamType &SS) { SS << "#null"; }
void printFuture(const Future *E, StreamType &SS) {
self()->printSExpr(E->maybeGetResult(), SS, Prec_Atom);
@@ -534,12 +541,9 @@ class PrettyPrinter {
SS << "#undefined";
}
- void printWildcard(const Wildcard *E, StreamType &SS) {
- SS << "*";
- }
+ void printWildcard(const Wildcard *E, StreamType &SS) { SS << "*"; }
- template<class T>
- void printLiteralT(const LiteralT<T> *E, StreamType &SS) {
+ template <class T> void printLiteralT(const LiteralT<T> *E, StreamType &SS) {
SS << E->value();
}
@@ -551,8 +555,7 @@ class PrettyPrinter {
if (E->clangExpr()) {
SS << getSourceLiteralString(E->clangExpr());
return;
- }
- else {
+ } else {
ValueType VT = E->valueType();
switch (VT.Base) {
case ValueType::BT_Void:
@@ -629,7 +632,8 @@ class PrettyPrinter {
SS << "<temporary>";
}
- void printVariable(const Variable *V, StreamType &SS, bool IsVarDecl=false) {
+ void printVariable(const Variable *V, StreamType &SS,
+ bool IsVarDecl = false) {
if (CStyle && V->kind() == Variable::VK_SFun)
SS << "this";
else
@@ -638,15 +642,15 @@ class PrettyPrinter {
void printFunction(const Function *E, StreamType &SS, unsigned sugared = 0) {
switch (sugared) {
- default:
- SS << "\\("; // Lambda
- break;
- case 1:
- SS << "("; // Slot declarations
- break;
- case 2:
- SS << ", "; // Curried functions
- break;
+ default:
+ SS << "\\("; // Lambda
+ break;
+ case 1:
+ SS << "("; // Slot declarations
+ break;
+ case 2:
+ SS << ", "; // Curried functions
+ break;
}
self()->printVariable(E->variableDecl(), SS, true);
SS << ": ";
@@ -670,14 +674,14 @@ class PrettyPrinter {
void printCode(const Code *E, StreamType &SS) {
SS << ": ";
- self()->printSExpr(E->returnType(), SS, Prec_Decl-1);
+ self()->printSExpr(E->returnType(), SS, Prec_Decl - 1);
SS << " -> ";
self()->printSExpr(E->body(), SS, Prec_Decl);
}
void printField(const Field *E, StreamType &SS) {
SS << ": ";
- self()->printSExpr(E->range(), SS, Prec_Decl-1);
+ self()->printSExpr(E->range(), SS, Prec_Decl - 1);
SS << " = ";
self()->printSExpr(E->body(), SS, Prec_Decl);
}
@@ -736,8 +740,7 @@ class PrettyPrinter {
if (T->opcode() == COP_Apply) {
self()->printApply(cast<Apply>(T), SS, true);
SS << ")";
- }
- else {
+ } else {
self()->printSExpr(T, SS, Prec_Postfix);
SS << "()";
}
@@ -745,7 +748,7 @@ class PrettyPrinter {
void printAlloc(const Alloc *E, StreamType &SS) {
SS << "new ";
- self()->printSExpr(E->dataType(), SS, Prec_Other-1);
+ self()->printSExpr(E->dataType(), SS, Prec_Other - 1);
}
void printLoad(const Load *E, StreamType &SS) {
@@ -755,9 +758,9 @@ class PrettyPrinter {
}
void printStore(const Store *E, StreamType &SS) {
- self()->printSExpr(E->destination(), SS, Prec_Other-1);
+ self()->printSExpr(E->destination(), SS, Prec_Other - 1);
SS << " := ";
- self()->printSExpr(E->source(), SS, Prec_Other-1);
+ self()->printSExpr(E->source(), SS, Prec_Other - 1);
}
void printArrayIndex(const ArrayIndex *E, StreamType &SS) {
@@ -779,9 +782,9 @@ class PrettyPrinter {
}
void printBinaryOp(const BinaryOp *E, StreamType &SS) {
- self()->printSExpr(E->expr0(), SS, Prec_Binary-1);
+ self()->printSExpr(E->expr0(), SS, Prec_Binary - 1);
SS << " " << getBinaryOpcodeString(E->binaryOpcode()) << " ";
- self()->printSExpr(E->expr1(), SS, Prec_Binary-1);
+ self()->printSExpr(E->expr1(), SS, Prec_Binary - 1);
}
void printCast(const Cast *E, StreamType &SS) {
@@ -830,8 +833,7 @@ class PrettyPrinter {
SS << "let " << V->name() << V->id() << " = ";
E = V->definition();
Sub = true;
- }
- else if (E->opcode() != COP_Store) {
+ } else if (E->opcode() != COP_Store) {
SS << "let _x" << E->id() << " = ";
}
self()->printSExpr(E, SS, Prec_MAX, Sub);
@@ -894,9 +896,7 @@ class PrettyPrinter {
self()->printSExpr(E->returnValue(), SS, Prec_Other);
}
- void printIdentifier(const Identifier *E, StreamType &SS) {
- SS << E->name();
- }
+ void printIdentifier(const Identifier *E, StreamType &SS) { SS << E->name(); }
void printIfThenElse(const IfThenElse *E, StreamType &SS) {
if (CStyle) {
@@ -919,9 +919,9 @@ class PrettyPrinter {
SS << "let ";
printVariable(E->variableDecl(), SS, true);
SS << " = ";
- printSExpr(E->variableDecl()->definition(), SS, Prec_Decl-1);
+ printSExpr(E->variableDecl()->definition(), SS, Prec_Decl - 1);
SS << "; ";
- printSExpr(E->body(), SS, Prec_Decl-1);
+ printSExpr(E->body(), SS, Prec_Decl - 1);
}
};
diff --git a/clang/include/clang/Analysis/Analyses/ThreadSafetyUtil.h b/clang/include/clang/Analysis/Analyses/ThreadSafetyUtil.h
index ac7b24cdb4a6c9..c858961609f2d9 100644
--- a/clang/include/clang/Analysis/Analyses/ThreadSafetyUtil.h
+++ b/clang/include/clang/Analysis/Analyses/ThreadSafetyUtil.h
@@ -186,7 +186,7 @@ template <class T> class SimpleArray {
Size -= n;
}
- void setValues(unsigned Sz, const T& C) {
+ void setValues(unsigned Sz, const T &C) {
assert(Sz <= Capacity);
Size = Sz;
for (unsigned i = 0; i < Sz; ++i) {
@@ -223,7 +223,7 @@ template <class T> class SimpleArray {
size_t Capacity = 0;
};
-} // namespace til
+} // namespace til
// A copy on write vector.
// The vector can be in one of three states:
@@ -231,8 +231,7 @@ template <class T> class SimpleArray {
// * read-only -- read operations are permitted.
// * writable -- read and write operations are permitted.
// The init(), destroy(), and makeWritable() methods will change state.
-template<typename T>
-class CopyOnWriteVector {
+template <typename T> class CopyOnWriteVector {
class VectorData {
public:
unsigned NumRefs = 1;
@@ -264,7 +263,7 @@ class CopyOnWriteVector {
~CopyOnWriteVector() { destroy(); }
// Returns true if this holds a valid vector.
- bool valid() const { return Data; }
+ bool valid() const { return Data; }
// Returns true if this vector is writable.
bool writable() const { return Data && Data->NumRefs == 1; }
@@ -294,7 +293,7 @@ class CopyOnWriteVector {
return;
}
if (Data->NumRefs == 1)
- return; // already writeable.
+ return; // already writeable.
--Data->NumRefs;
Data = new VectorData(*Data);
}
@@ -309,7 +308,7 @@ class CopyOnWriteVector {
const_iterator begin() const { return elements().cbegin(); }
const_iterator end() const { return elements().cend(); }
- const T& operator[](unsigned i) const { return elements()[i]; }
+ const T &operator[](unsigned i) const { return elements()[i]; }
unsigned size() const { return Data ? elements().size() : 0; }
@@ -330,7 +329,7 @@ class CopyOnWriteVector {
// Gets a mutable reference to the element at index(i).
// The vector must be writable.
- T& elem(unsigned i) {
+ T &elem(unsigned i) {
assert(writable() && "Vector is not writable!");
return Data->Vect[i];
}
@@ -351,7 +350,7 @@ class CopyOnWriteVector {
VectorData *Data = nullptr;
};
-inline std::ostream& operator<<(std::ostream& ss, const StringRef str) {
+inline std::ostream &operator<<(std::ostream &ss, const StringRef str) {
return ss.write(str.data(), str.size());
}
diff --git a/clang/include/clang/Analysis/Analyses/UninitializedValues.h b/clang/include/clang/Analysis/Analyses/UninitializedValues.h
index a2b37deddcec29..af6baf8f461849 100644
--- a/clang/include/clang/Analysis/Analyses/UninitializedValues.h
+++ b/clang/include/clang/Analysis/Analyses/UninitializedValues.h
@@ -55,9 +55,7 @@ class UninitUse {
UninitUse(const Expr *User, bool AlwaysUninit)
: User(User), AlwaysUninit(AlwaysUninit) {}
- void addUninitBranch(Branch B) {
- UninitBranches.push_back(B);
- }
+ void addUninitBranch(Branch B) { UninitBranches.push_back(B); }
void setUninitAfterCall() { UninitAfterCall = true; }
void setUninitAfterDecl() { UninitAfterDecl = true; }
@@ -87,10 +85,11 @@ class UninitUse {
/// Get the kind of uninitialized use.
Kind getKind() const {
- return AlwaysUninit ? Always :
- UninitAfterCall ? AfterCall :
- UninitAfterDecl ? AfterDecl :
- !branch_empty() ? Sometimes : Maybe;
+ return AlwaysUninit ? Always
+ : UninitAfterCall ? AfterCall
+ : UninitAfterDecl ? AfterDecl
+ : !branch_empty() ? Sometimes
+ : Maybe;
}
using branch_iterator = SmallVectorImpl<Branch>::const_iterator;
diff --git a/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h b/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h
index 5d16dcc824c50c..d195e162b71103 100644
--- a/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h
+++ b/clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h
@@ -35,11 +35,11 @@ class VariableGroupsManager {
/// `HasParm` is an optional argument that will be set to true if the set of
/// variables, where `Var` is in, contains parameters.
virtual VarGrpRef getGroupOfVar(const VarDecl *Var,
- bool *HasParm = nullptr) const =0;
+ bool *HasParm = nullptr) const = 0;
/// Returns the non-empty group of variables that include parameters of the
/// analyzing function, if such a group exists. An empty group, otherwise.
- virtual VarGrpRef getGroupOfParms() const =0;
+ virtual VarGrpRef getGroupOfParms() const = 0;
};
// FixitStrategy is a map from variables to the way we plan to emit fixes for
diff --git a/clang/include/clang/Analysis/AnyCall.h b/clang/include/clang/Analysis/AnyCall.h
index 48abce062d1330..1ff9bab54dfdc4 100644
--- a/clang/include/clang/Analysis/AnyCall.h
+++ b/clang/include/clang/Analysis/AnyCall.h
@@ -100,12 +100,11 @@ class AnyCall {
AnyCall(const FunctionDecl *D) : E(nullptr), D(D) {
if (isa<CXXConstructorDecl>(D)) {
K = Constructor;
- } else if (isa <CXXDestructorDecl>(D)) {
+ } else if (isa<CXXDestructorDecl>(D)) {
K = Destructor;
} else {
K = Function;
}
-
}
/// If @c E is a generic call (to ObjC method /function/block/etc),
@@ -194,17 +193,11 @@ class AnyCall {
return nullptr;
}
- const Decl *getDecl() const {
- return D;
- }
+ const Decl *getDecl() const { return D; }
- const Expr *getExpr() const {
- return E;
- }
+ const Expr *getExpr() const { return E; }
- Kind getKind() const {
- return K;
- }
+ Kind getKind() const { return K; }
void dump() const {
if (E)
@@ -214,6 +207,6 @@ class AnyCall {
}
};
-}
+} // namespace clang
#endif // LLVM_CLANG_ANALYSIS_ANYCALL_H
diff --git a/clang/include/clang/Analysis/CFG.h b/clang/include/clang/Analysis/CFG.h
index a7ff38c786a8fe..27784aff98ae7a 100644
--- a/clang/include/clang/Analysis/CFG.h
+++ b/clang/include/clang/Analysis/CFG.h
@@ -85,8 +85,8 @@ class CFGElement {
llvm::PointerIntPair<void *, 2> Data2;
CFGElement(Kind kind, const void *Ptr1, const void *Ptr2 = nullptr)
- : Data1(const_cast<void*>(Ptr1), ((unsigned) kind) & 0x3),
- Data2(const_cast<void*>(Ptr2), (((unsigned) kind) >> 2) & 0x3) {
+ : Data1(const_cast<void *>(Ptr1), ((unsigned)kind) & 0x3),
+ Data2(const_cast<void *>(Ptr2), (((unsigned)kind) >> 2) & 0x3) {
assert(getKind() == kind);
}
@@ -95,11 +95,10 @@ class CFGElement {
public:
/// Convert to the specified CFGElement type, asserting that this
/// CFGElement is of the desired type.
- template<typename T>
- T castAs() const {
+ template <typename T> T castAs() const {
assert(T::isKind(*this));
T t;
- CFGElement& e = t;
+ CFGElement &e = t;
e = *this;
return t;
}
@@ -110,7 +109,7 @@ class CFGElement {
if (!T::isKind(*this))
return std::nullopt;
T t;
- CFGElement& e = t;
+ CFGElement &e = t;
e = *this;
return t;
}
@@ -119,14 +118,12 @@ class CFGElement {
unsigned x = Data2.getInt();
x <<= 2;
x |= Data1.getInt();
- return (Kind) x;
+ return (Kind)x;
}
void dumpToStream(llvm::raw_ostream &OS) const;
- void dump() const {
- dumpToStream(llvm::errs());
- }
+ void dump() const { dumpToStream(llvm::errs()); }
};
class CFGStmt : public CFGElement {
@@ -171,9 +168,7 @@ class CFGConstructor : public CFGStmt {
CFGConstructor() = default;
- static bool isKind(const CFGElement &E) {
- return E.getKind() == Constructor;
- }
+ static bool isKind(const CFGElement &E) { return E.getKind() == Constructor; }
};
/// Represents a function call that returns a C++ object by value. This, like
@@ -229,8 +224,8 @@ class CFGInitializer : public CFGElement {
explicit CFGInitializer(const CXXCtorInitializer *initializer)
: CFGElement(Initializer, initializer) {}
- CXXCtorInitializer* getInitializer() const {
- return static_cast<CXXCtorInitializer*>(Data1.getPointer());
+ CXXCtorInitializer *getInitializer() const {
+ return static_cast<CXXCtorInitializer *>(Data1.getPointer());
}
private:
@@ -238,16 +233,13 @@ class CFGInitializer : public CFGElement {
CFGInitializer() = default;
- static bool isKind(const CFGElement &E) {
- return E.getKind() == Initializer;
- }
+ static bool isKind(const CFGElement &E) { return E.getKind() == Initializer; }
};
/// Represents C++ allocator call.
class CFGNewAllocator : public CFGElement {
public:
- explicit CFGNewAllocator(const CXXNewExpr *S)
- : CFGElement(NewAllocator, S) {}
+ explicit CFGNewAllocator(const CXXNewExpr *S) : CFGElement(NewAllocator, S) {}
// Get the new expression.
const CXXNewExpr *getAllocatorExpr() const {
@@ -322,7 +314,7 @@ class CFGScopeBegin : public CFGElement {
// Get statement that triggered a new scope.
const Stmt *getTriggerStmt() const {
- return static_cast<Stmt*>(Data2.getPointer());
+ return static_cast<Stmt *>(Data2.getPointer());
}
// Get VD that triggered a new scope.
@@ -368,7 +360,7 @@ class CFGImplicitDtor : public CFGElement {
CFGImplicitDtor() = default;
CFGImplicitDtor(Kind kind, const void *data1, const void *data2 = nullptr)
- : CFGElement(kind, data1, data2) {
+ : CFGElement(kind, data1, data2) {
assert(kind >= DTOR_BEGIN && kind <= DTOR_END);
}
@@ -414,18 +406,18 @@ class CFGCleanupFunction final : public CFGElement {
/// Represents C++ object destructor implicitly generated for automatic object
/// or temporary bound to const reference at the point of leaving its local
/// scope.
-class CFGAutomaticObjDtor: public CFGImplicitDtor {
+class CFGAutomaticObjDtor : public CFGImplicitDtor {
public:
CFGAutomaticObjDtor(const VarDecl *var, const Stmt *stmt)
: CFGImplicitDtor(AutomaticObjectDtor, var, stmt) {}
const VarDecl *getVarDecl() const {
- return static_cast<VarDecl*>(Data1.getPointer());
+ return static_cast<VarDecl *>(Data1.getPointer());
}
// Get statement end of which triggered the destructor call.
const Stmt *getTriggerStmt() const {
- return static_cast<Stmt*>(Data2.getPointer());
+ return static_cast<Stmt *>(Data2.getPointer());
}
private:
@@ -445,7 +437,7 @@ class CFGDeleteDtor : public CFGImplicitDtor {
: CFGImplicitDtor(DeleteDtor, RD, DE) {}
const CXXRecordDecl *getCXXRecordDecl() const {
- return static_cast<CXXRecordDecl*>(Data1.getPointer());
+ return static_cast<CXXRecordDecl *>(Data1.getPointer());
}
// Get Delete expression which triggered the destructor call.
@@ -467,11 +459,10 @@ class CFGDeleteDtor : public CFGImplicitDtor {
/// destructor.
class CFGBaseDtor : public CFGImplicitDtor {
public:
- CFGBaseDtor(const CXXBaseSpecifier *base)
- : CFGImplicitDtor(BaseDtor, base) {}
+ CFGBaseDtor(const CXXBaseSpecifier *base) : CFGImplicitDtor(BaseDtor, base) {}
const CXXBaseSpecifier *getBaseSpecifier() const {
- return static_cast<const CXXBaseSpecifier*>(Data1.getPointer());
+ return static_cast<const CXXBaseSpecifier *>(Data1.getPointer());
}
private:
@@ -479,9 +470,7 @@ class CFGBaseDtor : public CFGImplicitDtor {
CFGBaseDtor() = default;
- static bool isKind(const CFGElement &E) {
- return E.getKind() == BaseDtor;
- }
+ static bool isKind(const CFGElement &E) { return E.getKind() == BaseDtor; }
};
/// Represents C++ object destructor implicitly generated for member object in
@@ -492,7 +481,7 @@ class CFGMemberDtor : public CFGImplicitDtor {
: CFGImplicitDtor(MemberDtor, field, nullptr) {}
const FieldDecl *getFieldDecl() const {
- return static_cast<const FieldDecl*>(Data1.getPointer());
+ return static_cast<const FieldDecl *>(Data1.getPointer());
}
private:
@@ -500,9 +489,7 @@ class CFGMemberDtor : public CFGImplicitDtor {
CFGMemberDtor() = default;
- static bool isKind(const CFGElement &E) {
- return E.getKind() == MemberDtor;
- }
+ static bool isKind(const CFGElement &E) { return E.getKind() == MemberDtor; }
};
/// Represents C++ object destructor implicitly generated at the end of full
@@ -564,15 +551,11 @@ class CFGTerminator {
const Stmt *getStmt() const { return Data.getPointer(); }
Kind getKind() const { return static_cast<Kind>(Data.getInt()); }
- bool isStmtBranch() const {
- return getKind() == StmtBranch;
- }
+ bool isStmtBranch() const { return getKind() == StmtBranch; }
bool isTemporaryDtorsBranch() const {
return getKind() == TemporaryDtorsBranch;
}
- bool isVirtualBaseBranch() const {
- return getKind() == VirtualBaseBranch;
- }
+ bool isVirtualBaseBranch() const { return getKind() == VirtualBaseBranch; }
};
/// Represents a single basic block in a source-level CFG.
@@ -619,7 +602,7 @@ class CFGBlock {
void push_back(CFGElement e, BumpVectorContext &C) { Impl.push_back(e, C); }
reverse_iterator insert(reverse_iterator I, size_t Cnt, CFGElement E,
- BumpVectorContext &C) {
+ BumpVectorContext &C) {
return Impl.insert(I, Cnt, E, C);
}
@@ -635,7 +618,7 @@ class CFGBlock {
const_reverse_iterator rbegin() const { return Impl.begin(); }
const_reverse_iterator rend() const { return Impl.end(); }
- CFGElement operator[](size_t i) const {
+ CFGElement operator[](size_t i) const {
assert(i < Impl.size());
return Impl[Impl.size() - 1 - i];
}
@@ -692,9 +675,7 @@ class CFGBlock {
(*this)->dumpToStream(OS);
}
- void dump() const {
- dumpToStream(llvm::errs());
- }
+ void dump() const { dumpToStream(llvm::errs()); }
};
template <bool IsReverse, bool IsConst> class ElementRefIterator {
@@ -817,11 +798,7 @@ class CFGBlock {
/// where a block was substituted because the original (now alternate) block
/// is unreachable.
class AdjacentBlock {
- enum Kind {
- AB_Normal,
- AB_Unreachable,
- AB_Alternate
- };
+ enum Kind { AB_Normal, AB_Unreachable, AB_Alternate };
CFGBlock *ReachableBlock;
llvm::PointerIntPair<CFGBlock *, 2> UnreachableBlock;
@@ -835,9 +812,7 @@ class CFGBlock {
AdjacentBlock(CFGBlock *B, CFGBlock *AlternateBlock);
/// Get the reachable block, if one exists.
- CFGBlock *getReachableBlock() const {
- return ReachableBlock;
- }
+ CFGBlock *getReachableBlock() const { return ReachableBlock; }
/// Get the potentially unreachable block.
CFGBlock *getPossiblyUnreachableBlock() const {
@@ -846,20 +821,14 @@ class CFGBlock {
/// Provide an implicit conversion to CFGBlock* so that
/// AdjacentBlock can be substituted for CFGBlock*.
- operator CFGBlock*() const {
- return getReachableBlock();
- }
+ operator CFGBlock *() const { return getReachableBlock(); }
- CFGBlock& operator *() const {
- return *getReachableBlock();
- }
+ CFGBlock &operator*() const { return *getReachableBlock(); }
- CFGBlock* operator ->() const {
- return getReachableBlock();
- }
+ CFGBlock *operator->() const { return getReachableBlock(); }
bool isReachable() const {
- Kind K = (Kind) UnreachableBlock.getInt();
+ Kind K = (Kind)UnreachableBlock.getInt();
return K == AB_Normal || K == AB_Alternate;
}
};
@@ -898,18 +867,18 @@ class CFGBlock {
size_t getIndexInCFG() const;
- CFGElement front() const { return Elements.front(); }
- CFGElement back() const { return Elements.back(); }
+ CFGElement front() const { return Elements.front(); }
+ CFGElement back() const { return Elements.back(); }
- iterator begin() { return Elements.begin(); }
- iterator end() { return Elements.end(); }
- const_iterator begin() const { return Elements.begin(); }
- const_iterator end() const { return Elements.end(); }
+ iterator begin() { return Elements.begin(); }
+ iterator end() { return Elements.end(); }
+ const_iterator begin() const { return Elements.begin(); }
+ const_iterator end() const { return Elements.end(); }
- reverse_iterator rbegin() { return Elements.rbegin(); }
- reverse_iterator rend() { return Elements.rend(); }
- const_reverse_iterator rbegin() const { return Elements.rbegin(); }
- const_reverse_iterator rend() const { return Elements.rend(); }
+ reverse_iterator rbegin() { return Elements.rbegin(); }
+ reverse_iterator rend() { return Elements.rend(); }
+ const_reverse_iterator rbegin() const { return Elements.rbegin(); }
+ const_reverse_iterator rend() const { return Elements.rend(); }
using CFGElementRef = ElementRefImpl<false>;
using ConstCFGElementRef = ElementRefImpl<true>;
@@ -943,10 +912,10 @@ class CFGBlock {
return {rref_begin(), rref_end()};
}
- unsigned size() const { return Elements.size(); }
- bool empty() const { return Elements.empty(); }
+ unsigned size() const { return Elements.size(); }
+ bool empty() const { return Elements.empty(); }
- CFGElement operator[](size_t i) const { return Elements[i]; }
+ CFGElement operator[](size_t i) const { return Elements[i]; }
// CFG iterators
using pred_iterator = AdjacentBlocks::iterator;
@@ -963,48 +932,43 @@ class CFGBlock {
using succ_range = llvm::iterator_range<succ_iterator>;
using succ_const_range = llvm::iterator_range<const_succ_iterator>;
- pred_iterator pred_begin() { return Preds.begin(); }
- pred_iterator pred_end() { return Preds.end(); }
- const_pred_iterator pred_begin() const { return Preds.begin(); }
- const_pred_iterator pred_end() const { return Preds.end(); }
+ pred_iterator pred_begin() { return Preds.begin(); }
+ pred_iterator pred_end() { return Preds.end(); }
+ const_pred_iterator pred_begin() const { return Preds.begin(); }
+ const_pred_iterator pred_end() const { return Preds.end(); }
- pred_reverse_iterator pred_rbegin() { return Preds.rbegin(); }
- pred_reverse_iterator pred_rend() { return Preds.rend(); }
- const_pred_reverse_iterator pred_rbegin() const { return Preds.rbegin(); }
- const_pred_reverse_iterator pred_rend() const { return Preds.rend(); }
+ pred_reverse_iterator pred_rbegin() { return Preds.rbegin(); }
+ pred_reverse_iterator pred_rend() { return Preds.rend(); }
+ const_pred_reverse_iterator pred_rbegin() const { return Preds.rbegin(); }
+ const_pred_reverse_iterator pred_rend() const { return Preds.rend(); }
- pred_range preds() {
- return pred_range(pred_begin(), pred_end());
- }
+ pred_range preds() { return pred_range(pred_begin(), pred_end()); }
pred_const_range preds() const {
return pred_const_range(pred_begin(), pred_end());
}
- succ_iterator succ_begin() { return Succs.begin(); }
- succ_iterator succ_end() { return Succs.end(); }
- const_succ_iterator succ_begin() const { return Succs.begin(); }
- const_succ_iterator succ_end() const { return Succs.end(); }
+ succ_iterator succ_begin() { return Succs.begin(); }
+ succ_iterator succ_end() { return Succs.end(); }
+ const_succ_iterator succ_begin() const { return Succs.begin(); }
+ const_succ_iterator succ_end() const { return Succs.end(); }
- succ_reverse_iterator succ_rbegin() { return Succs.rbegin(); }
- succ_reverse_iterator succ_rend() { return Succs.rend(); }
- const_succ_reverse_iterator succ_rbegin() const { return Succs.rbegin(); }
- const_succ_reverse_iterator succ_rend() const { return Succs.rend(); }
+ succ_reverse_iterator succ_rbegin() { return Succs.rbegin(); }
+ succ_reverse_iterator succ_rend() { return Succs.rend(); }
+ const_succ_reverse_iterator succ_rbegin() const { return Succs.rbegin(); }
+ const_succ_reverse_iterator succ_rend() const { return Succs.rend(); }
- succ_range succs() {
- return succ_range(succ_begin(), succ_end());
- }
+ succ_range succs() { return succ_range(succ_begin(), succ_end()); }
succ_const_range succs() const {
return succ_const_range(succ_begin(), succ_end());
}
- unsigned succ_size() const { return Succs.size(); }
- bool succ_empty() const { return Succs.empty(); }
-
- unsigned pred_size() const { return Preds.size(); }
- bool pred_empty() const { return Preds.empty(); }
+ unsigned succ_size() const { return Succs.size(); }
+ bool succ_empty() const { return Succs.empty(); }
+ unsigned pred_size() const { return Preds.size(); }
+ bool pred_empty() const { return Preds.empty(); }
class FilterOptions {
public:
@@ -1018,10 +982,9 @@ class CFGBlock {
};
static bool FilterEdge(const FilterOptions &F, const CFGBlock *Src,
- const CFGBlock *Dst);
+ const CFGBlock *Dst);
- template <typename IMPL, bool IsPred>
- class FilteredCFGBlockIterator {
+ template <typename IMPL, bool IsPred> class FilteredCFGBlockIterator {
private:
IMPL I, E;
const FilterOptions F;
@@ -1039,7 +1002,9 @@ class CFGBlock {
bool hasMore() const { return I != E; }
FilteredCFGBlockIterator &operator++() {
- do { ++I; } while (hasMore() && Filter(*I));
+ do {
+ ++I;
+ } while (hasMore() && Filter(*I));
return *this;
}
@@ -1092,7 +1057,7 @@ class CFGBlock {
Stmt *getTerminatorCondition(bool StripParens = true);
const Stmt *getTerminatorCondition(bool StripParens = true) const {
- return const_cast<CFGBlock*>(this)->getTerminatorCondition(StripParens);
+ return const_cast<CFGBlock *>(this)->getTerminatorCondition(StripParens);
}
const Stmt *getLoopTarget() const { return LoopTarget; }
@@ -1108,8 +1073,9 @@ class CFGBlock {
void dump() const;
- void dump(const CFG *cfg, const LangOptions &LO, bool ShowColors = false) const;
- void print(raw_ostream &OS, const CFG* cfg, const LangOptions &LO,
+ void dump(const CFG *cfg, const LangOptions &LO,
+ bool ShowColors = false) const;
+ void print(raw_ostream &OS, const CFG *cfg, const LangOptions &LO,
bool ShowColors) const;
void printTerminator(raw_ostream &OS, const LangOptions &LO) const;
@@ -1132,19 +1098,17 @@ class CFGBlock {
Elements.push_back(CFGConstructor(CE, CC), C);
}
- void appendCXXRecordTypedCall(Expr *E,
- const ConstructionContext *CC,
+ void appendCXXRecordTypedCall(Expr *E, const ConstructionContext *CC,
BumpVectorContext &C) {
Elements.push_back(CFGCXXRecordTypedCall(E, CC), C);
}
void appendInitializer(CXXCtorInitializer *initializer,
- BumpVectorContext &C) {
+ BumpVectorContext &C) {
Elements.push_back(CFGInitializer(initializer), C);
}
- void appendNewAllocator(CXXNewExpr *NE,
- BumpVectorContext &C) {
+ void appendNewAllocator(CXXNewExpr *NE, BumpVectorContext &C) {
Elements.push_back(CFGNewAllocator(NE), C);
}
@@ -1185,7 +1149,8 @@ class CFGBlock {
Elements.push_back(CFGLoopExit(LoopStmt), C);
}
- void appendDeleteDtor(CXXRecordDecl *RD, CXXDeleteExpr *DE, BumpVectorContext &C) {
+ void appendDeleteDtor(CXXRecordDecl *RD, CXXDeleteExpr *DE,
+ BumpVectorContext &C) {
Elements.push_back(CFGDeleteDtor(RD, DE), C);
}
};
@@ -1288,13 +1253,13 @@ class CFG {
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
- CFGBlock & front() { return *Blocks.front(); }
- CFGBlock & back() { return *Blocks.back(); }
+ CFGBlock &front() { return *Blocks.front(); }
+ CFGBlock &back() { return *Blocks.back(); }
- iterator begin() { return Blocks.begin(); }
- iterator end() { return Blocks.end(); }
- const_iterator begin() const { return Blocks.begin(); }
- const_iterator end() const { return Blocks.end(); }
+ iterator begin() { return Blocks.begin(); }
+ iterator end() { return Blocks.end(); }
+ const_iterator begin() const { return Blocks.begin(); }
+ const_iterator end() const { return Blocks.end(); }
iterator nodes_begin() { return iterator(Blocks.begin()); }
iterator nodes_end() { return iterator(Blocks.end()); }
@@ -1307,10 +1272,10 @@ class CFG {
const_iterator nodes_begin() const { return const_iterator(Blocks.begin()); }
const_iterator nodes_end() const { return const_iterator(Blocks.end()); }
- reverse_iterator rbegin() { return Blocks.rbegin(); }
- reverse_iterator rend() { return Blocks.rend(); }
- const_reverse_iterator rbegin() const { return Blocks.rbegin(); }
- const_reverse_iterator rend() const { return Blocks.rend(); }
+ reverse_iterator rbegin() { return Blocks.rbegin(); }
+ reverse_iterator rend() { return Blocks.rend(); }
+ const_reverse_iterator rbegin() const { return Blocks.rbegin(); }
+ const_reverse_iterator rend() const { return Blocks.rend(); }
llvm::iterator_range<reverse_iterator> reverse_nodes() {
return {rbegin(), rend()};
@@ -1319,13 +1284,13 @@ class CFG {
return {rbegin(), rend()};
}
- CFGBlock & getEntry() { return *Entry; }
- const CFGBlock & getEntry() const { return *Entry; }
- CFGBlock & getExit() { return *Exit; }
- const CFGBlock & getExit() const { return *Exit; }
+ CFGBlock &getEntry() { return *Entry; }
+ const CFGBlock &getEntry() const { return *Entry; }
+ CFGBlock &getExit() { return *Exit; }
+ const CFGBlock &getExit() const { return *Exit; }
- CFGBlock * getIndirectGotoBlock() { return IndirectGotoBlock; }
- const CFGBlock * getIndirectGotoBlock() const { return IndirectGotoBlock; }
+ CFGBlock *getIndirectGotoBlock() { return IndirectGotoBlock; }
+ const CFGBlock *getIndirectGotoBlock() const { return IndirectGotoBlock; }
using try_block_iterator = std::vector<const CFGBlock *>::const_iterator;
using try_block_range = llvm::iterator_range<try_block_iterator>;
@@ -1334,9 +1299,7 @@ class CFG {
return TryDispatchBlocks.begin();
}
- try_block_iterator try_blocks_end() const {
- return TryDispatchBlocks.end();
- }
+ try_block_iterator try_blocks_end() const { return TryDispatchBlocks.end(); }
try_block_range try_blocks() const {
return try_block_range(try_blocks_begin(), try_blocks_end());
@@ -1350,8 +1313,7 @@ class CFG {
///
/// The CFG uses synthetic DeclStmts when a single AST DeclStmt contains
/// multiple decls.
- void addSyntheticDeclStmt(const DeclStmt *Synthetic,
- const DeclStmt *Source) {
+ void addSyntheticDeclStmt(const DeclStmt *Synthetic, const DeclStmt *Source) {
assert(Synthetic->isSingleDecl() && "Can handle single declarations only");
assert(Synthetic != Source && "Don't include original DeclStmts in map");
assert(!SyntheticDeclStmts.count(Synthetic) && "Already in map");
@@ -1426,22 +1388,18 @@ class CFG {
CFG() : Blocks(BlkBVC, 10) {}
- llvm::BumpPtrAllocator& getAllocator() {
- return BlkBVC.getAllocator();
- }
+ llvm::BumpPtrAllocator &getAllocator() { return BlkBVC.getAllocator(); }
- BumpVectorContext &getBumpVectorContext() {
- return BlkBVC;
- }
+ BumpVectorContext &getBumpVectorContext() { return BlkBVC; }
private:
CFGBlock *Entry = nullptr;
CFGBlock *Exit = nullptr;
// Special block to contain collective dispatch for indirect gotos
- CFGBlock* IndirectGotoBlock = nullptr;
+ CFGBlock *IndirectGotoBlock = nullptr;
- unsigned NumBlockIDs = 0;
+ unsigned NumBlockIDs = 0;
BumpVectorContext BlkBVC;
@@ -1468,7 +1426,7 @@ namespace llvm {
/// Implement simplify_type for CFGTerminator, so that we can dyn_cast from
/// CFGTerminator to a specific Stmt class.
-template <> struct simplify_type< ::clang::CFGTerminator> {
+template <> struct simplify_type<::clang::CFGTerminator> {
using SimpleType = ::clang::Stmt *;
static SimpleType getSimplifiedValue(::clang::CFGTerminator Val) {
@@ -1478,7 +1436,7 @@ template <> struct simplify_type< ::clang::CFGTerminator> {
// Traits for: CFGBlock
-template <> struct GraphTraits< ::clang::CFGBlock *> {
+template <> struct GraphTraits<::clang::CFGBlock *> {
using NodeRef = ::clang::CFGBlock *;
using ChildIteratorType = ::clang::CFGBlock::succ_iterator;
@@ -1487,7 +1445,7 @@ template <> struct GraphTraits< ::clang::CFGBlock *> {
static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); }
};
-template <> struct GraphTraits< const ::clang::CFGBlock *> {
+template <> struct GraphTraits<const ::clang::CFGBlock *> {
using NodeRef = const ::clang::CFGBlock *;
using ChildIteratorType = ::clang::CFGBlock::const_succ_iterator;
@@ -1496,7 +1454,7 @@ template <> struct GraphTraits< const ::clang::CFGBlock *> {
static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); }
};
-template <> struct GraphTraits<Inverse< ::clang::CFGBlock *>> {
+template <> struct GraphTraits<Inverse<::clang::CFGBlock *>> {
using NodeRef = ::clang::CFGBlock *;
using ChildIteratorType = ::clang::CFGBlock::const_pred_iterator;
@@ -1522,55 +1480,60 @@ template <> struct GraphTraits<Inverse<const ::clang::CFGBlock *>> {
// Traits for: CFG
-template <> struct GraphTraits< ::clang::CFG* >
- : public GraphTraits< ::clang::CFGBlock *> {
+template <>
+struct GraphTraits<::clang::CFG *> : public GraphTraits<::clang::CFGBlock *> {
using nodes_iterator = ::clang::CFG::iterator;
static NodeRef getEntryNode(::clang::CFG *F) { return &F->getEntry(); }
- static nodes_iterator nodes_begin(::clang::CFG* F) { return F->nodes_begin();}
- static nodes_iterator nodes_end(::clang::CFG* F) { return F->nodes_end(); }
- static unsigned size(::clang::CFG* F) { return F->size(); }
+ static nodes_iterator nodes_begin(::clang::CFG *F) {
+ return F->nodes_begin();
+ }
+ static nodes_iterator nodes_end(::clang::CFG *F) { return F->nodes_end(); }
+ static unsigned size(::clang::CFG *F) { return F->size(); }
};
-template <> struct GraphTraits<const ::clang::CFG* >
- : public GraphTraits<const ::clang::CFGBlock *> {
+template <>
+struct GraphTraits<const ::clang::CFG *>
+ : public GraphTraits<const ::clang::CFGBlock *> {
using nodes_iterator = ::clang::CFG::const_iterator;
static NodeRef getEntryNode(const ::clang::CFG *F) { return &F->getEntry(); }
- static nodes_iterator nodes_begin( const ::clang::CFG* F) {
+ static nodes_iterator nodes_begin(const ::clang::CFG *F) {
return F->nodes_begin();
}
- static nodes_iterator nodes_end( const ::clang::CFG* F) {
+ static nodes_iterator nodes_end(const ::clang::CFG *F) {
return F->nodes_end();
}
- static unsigned size(const ::clang::CFG* F) {
- return F->size();
- }
+ static unsigned size(const ::clang::CFG *F) { return F->size(); }
};
-template <> struct GraphTraits<Inverse< ::clang::CFG *>>
- : public GraphTraits<Inverse< ::clang::CFGBlock *>> {
+template <>
+struct GraphTraits<Inverse<::clang::CFG *>>
+ : public GraphTraits<Inverse<::clang::CFGBlock *>> {
using nodes_iterator = ::clang::CFG::iterator;
static NodeRef getEntryNode(::clang::CFG *F) { return &F->getExit(); }
- static nodes_iterator nodes_begin( ::clang::CFG* F) {return F->nodes_begin();}
- static nodes_iterator nodes_end( ::clang::CFG* F) { return F->nodes_end(); }
+ static nodes_iterator nodes_begin(::clang::CFG *F) {
+ return F->nodes_begin();
+ }
+ static nodes_iterator nodes_end(::clang::CFG *F) { return F->nodes_end(); }
};
-template <> struct GraphTraits<Inverse<const ::clang::CFG *>>
- : public GraphTraits<Inverse<const ::clang::CFGBlock *>> {
+template <>
+struct GraphTraits<Inverse<const ::clang::CFG *>>
+ : public GraphTraits<Inverse<const ::clang::CFGBlock *>> {
using nodes_iterator = ::clang::CFG::const_iterator;
static NodeRef getEntryNode(const ::clang::CFG *F) { return &F->getExit(); }
- static nodes_iterator nodes_begin(const ::clang::CFG* F) {
+ static nodes_iterator nodes_begin(const ::clang::CFG *F) {
return F->nodes_begin();
}
- static nodes_iterator nodes_end(const ::clang::CFG* F) {
+ static nodes_iterator nodes_end(const ::clang::CFG *F) {
return F->nodes_end();
}
};
diff --git a/clang/include/clang/Analysis/CFGStmtMap.h b/clang/include/clang/Analysis/CFGStmtMap.h
index 93cd9cfc5bdff2..14ab2d47e24ba2 100644
--- a/clang/include/clang/Analysis/CFGStmtMap.h
+++ b/clang/include/clang/Analysis/CFGStmtMap.h
@@ -34,18 +34,18 @@ class CFGStmtMap {
/// Returns a new CFGMap for the given CFG. It is the caller's
/// responsibility to 'delete' this object when done using it.
- static CFGStmtMap *Build(CFG* C, ParentMap *PM);
+ static CFGStmtMap *Build(CFG *C, ParentMap *PM);
/// Returns the CFGBlock the specified Stmt* appears in. For Stmt* that
/// are terminators, the CFGBlock is the block they appear as a terminator,
/// and not the block they appear as a block-level expression (e.g, '&&').
/// CaseStmts and LabelStmts map to the CFGBlock they label.
- CFGBlock *getBlock(Stmt * S);
+ CFGBlock *getBlock(Stmt *S);
- const CFGBlock *getBlock(const Stmt * S) const {
- return const_cast<CFGStmtMap*>(this)->getBlock(const_cast<Stmt*>(S));
+ const CFGBlock *getBlock(const Stmt *S) const {
+ return const_cast<CFGStmtMap *>(this)->getBlock(const_cast<Stmt *>(S));
}
};
-} // end clang namespace
+} // namespace clang
#endif
diff --git a/clang/include/clang/Analysis/CallGraph.h b/clang/include/clang/Analysis/CallGraph.h
index 78f8d115550178..65d6eb27bb308a 100644
--- a/clang/include/clang/Analysis/CallGraph.h
+++ b/clang/include/clang/Analysis/CallGraph.h
@@ -59,9 +59,7 @@ class CallGraph : public RecursiveASTVisitor<CallGraph> {
/// declaration.
///
/// Recursively walks the declaration to find all the dependent Decls as well.
- void addToCallGraph(Decl *D) {
- TraverseDecl(D);
- }
+ void addToCallGraph(Decl *D) { TraverseDecl(D); }
/// Determine if a declaration should be included in the graph.
static bool includeInGraph(const Decl *D);
@@ -84,9 +82,9 @@ class CallGraph : public RecursiveASTVisitor<CallGraph> {
/// Iterators through all the elements in the graph. Note, this gives
/// non-deterministic order.
iterator begin() { return FunctionMap.begin(); }
- iterator end() { return FunctionMap.end(); }
+ iterator end() { return FunctionMap.end(); }
const_iterator begin() const { return FunctionMap.begin(); }
- const_iterator end() const { return FunctionMap.end(); }
+ const_iterator end() const { return FunctionMap.end(); }
/// Get the number of nodes in the graph.
unsigned size() const { return FunctionMap.size(); }
@@ -240,30 +238,31 @@ template <> struct DenseMapInfo<clang::CallGraphNode::CallRecord> {
};
// Graph traits for iteration, viewing.
-template <> struct GraphTraits<clang::CallGraphNode*> {
+template <> struct GraphTraits<clang::CallGraphNode *> {
using NodeType = clang::CallGraphNode;
using NodeRef = clang::CallGraphNode *;
using ChildIteratorType = NodeType::iterator;
static NodeType *getEntryNode(clang::CallGraphNode *CGN) { return CGN; }
- static ChildIteratorType child_begin(NodeType *N) { return N->begin(); }
+ static ChildIteratorType child_begin(NodeType *N) { return N->begin(); }
static ChildIteratorType child_end(NodeType *N) { return N->end(); }
};
-template <> struct GraphTraits<const clang::CallGraphNode*> {
+template <> struct GraphTraits<const clang::CallGraphNode *> {
using NodeType = const clang::CallGraphNode;
using NodeRef = const clang::CallGraphNode *;
using ChildIteratorType = NodeType::const_iterator;
static NodeType *getEntryNode(const clang::CallGraphNode *CGN) { return CGN; }
- static ChildIteratorType child_begin(NodeType *N) { return N->begin();}
+ static ChildIteratorType child_begin(NodeType *N) { return N->begin(); }
static ChildIteratorType child_end(NodeType *N) { return N->end(); }
};
-template <> struct GraphTraits<clang::CallGraph*>
- : public GraphTraits<clang::CallGraphNode*> {
+template <>
+struct GraphTraits<clang::CallGraph *>
+ : public GraphTraits<clang::CallGraphNode *> {
static NodeType *getEntryNode(clang::CallGraph *CGN) {
- return CGN->getRoot(); // Start at the external node!
+ return CGN->getRoot(); // Start at the external node!
}
static clang::CallGraphNode *
@@ -279,15 +278,16 @@ template <> struct GraphTraits<clang::CallGraph*>
return nodes_iterator(CG->begin(), &CGGetValue);
}
- static nodes_iterator nodes_end (clang::CallGraph *CG) {
+ static nodes_iterator nodes_end(clang::CallGraph *CG) {
return nodes_iterator(CG->end(), &CGGetValue);
}
static unsigned size(clang::CallGraph *CG) { return CG->size(); }
};
-template <> struct GraphTraits<const clang::CallGraph*> :
- public GraphTraits<const clang::CallGraphNode*> {
+template <>
+struct GraphTraits<const clang::CallGraph *>
+ : public GraphTraits<const clang::CallGraphNode *> {
static NodeType *getEntryNode(const clang::CallGraph *CGN) {
return CGN->getRoot();
}
diff --git a/clang/include/clang/Analysis/CloneDetection.h b/clang/include/clang/Analysis/CloneDetection.h
index 3385579584b5a2..a6f44ea3e728fc 100644
--- a/clang/include/clang/Analysis/CloneDetection.h
+++ b/clang/include/clang/Analysis/CloneDetection.h
@@ -325,8 +325,8 @@ struct FilenamePatternConstraint {
FilenamePatternConstraint(StringRef IgnoredFilesPattern)
: IgnoredFilesPattern(IgnoredFilesPattern) {
- IgnoredFilesRegex = std::make_shared<llvm::Regex>("^(" +
- IgnoredFilesPattern.str() + "$)");
+ IgnoredFilesRegex =
+ std::make_shared<llvm::Regex>("^(" + IgnoredFilesPattern.str() + "$)");
}
bool isAutoGenerated(const CloneDetector::CloneGroup &Group);
diff --git a/clang/include/clang/Analysis/CodeInjector.h b/clang/include/clang/Analysis/CodeInjector.h
index a59dc0a9415901..16b04993c510d6 100644
--- a/clang/include/clang/Analysis/CodeInjector.h
+++ b/clang/include/clang/Analysis/CodeInjector.h
@@ -40,6 +40,6 @@ class CodeInjector {
virtual Stmt *getBody(const FunctionDecl *D) = 0;
virtual Stmt *getBody(const ObjCMethodDecl *D) = 0;
};
-}
+} // namespace clang
#endif
diff --git a/clang/include/clang/Analysis/ConstructionContext.h b/clang/include/clang/Analysis/ConstructionContext.h
index e19a2050009590..f0789f1006d197 100644
--- a/clang/include/clang/Analysis/ConstructionContext.h
+++ b/clang/include/clang/Analysis/ConstructionContext.h
@@ -16,9 +16,9 @@
#ifndef LLVM_CLANG_ANALYSIS_CONSTRUCTIONCONTEXT_H
#define LLVM_CLANG_ANALYSIS_CONSTRUCTIONCONTEXT_H
-#include "clang/Analysis/Support/BumpVector.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/ExprObjC.h"
+#include "clang/Analysis/Support/BumpVector.h"
namespace clang {
@@ -48,17 +48,26 @@ class ConstructionContextItem {
LLVM_DUMP_METHOD static StringRef getKindAsString(ItemKind K) {
switch (K) {
- case VariableKind: return "construct into local variable";
- case NewAllocatorKind: return "construct into new-allocator";
- case ReturnKind: return "construct into return address";
- case MaterializationKind: return "materialize temporary";
- case TemporaryDestructorKind: return "destroy temporary";
- case ElidedDestructorKind: return "elide destructor";
- case ElidableConstructorKind: return "elide constructor";
- case ArgumentKind: return "construct into argument";
- case LambdaCaptureKind:
- return "construct into lambda captured variable";
- case InitializerKind: return "construct into member variable";
+ case VariableKind:
+ return "construct into local variable";
+ case NewAllocatorKind:
+ return "construct into new-allocator";
+ case ReturnKind:
+ return "construct into return address";
+ case MaterializationKind:
+ return "materialize temporary";
+ case TemporaryDestructorKind:
+ return "destroy temporary";
+ case ElidedDestructorKind:
+ return "elide destructor";
+ case ElidableConstructorKind:
+ return "elide constructor";
+ case ArgumentKind:
+ return "construct into argument";
+ case LambdaCaptureKind:
+ return "construct into lambda captured variable";
+ case InitializerKind:
+ return "construct into member variable";
};
llvm_unreachable("Unknown ItemKind");
}
@@ -69,8 +78,7 @@ class ConstructionContextItem {
const unsigned Index = 0;
bool hasStatement() const {
- return Kind >= STATEMENT_KIND_BEGIN &&
- Kind <= STATEMENT_KIND_END;
+ return Kind >= STATEMENT_KIND_BEGIN && Kind <= STATEMENT_KIND_END;
}
bool hasIndex() const {
@@ -79,22 +87,19 @@ class ConstructionContextItem {
}
bool hasInitializer() const {
- return Kind >= INITIALIZER_KIND_BEGIN &&
- Kind <= INITIALIZER_KIND_END;
+ return Kind >= INITIALIZER_KIND_BEGIN && Kind <= INITIALIZER_KIND_END;
}
public:
// ConstructionContextItem should be simple enough so that it was easy to
// re-construct it from the AST node it captures. For that reason we provide
// simple implicit conversions from all sorts of supported AST nodes.
- ConstructionContextItem(const DeclStmt *DS)
- : Data(DS), Kind(VariableKind) {}
+ ConstructionContextItem(const DeclStmt *DS) : Data(DS), Kind(VariableKind) {}
ConstructionContextItem(const CXXNewExpr *NE)
: Data(NE), Kind(NewAllocatorKind) {}
- ConstructionContextItem(const ReturnStmt *RS)
- : Data(RS), Kind(ReturnKind) {}
+ ConstructionContextItem(const ReturnStmt *RS) : Data(RS), Kind(ReturnKind) {}
ConstructionContextItem(const MaterializeTemporaryExpr *MTE)
: Data(MTE), Kind(MaterializationKind) {}
@@ -235,7 +240,6 @@ class ConstructionContextLayer {
bool isStrictlyMoreSpecificThan(const ConstructionContextLayer *Other) const;
};
-
/// ConstructionContext's subclasses describe different ways of constructing
/// an object in C++. The context re-captures the essential parent AST nodes
/// of the CXXConstructExpr it is assigned to and presents these nodes
@@ -292,9 +296,9 @@ class ConstructionContext {
// object also needs to be materialized and delegates to
// createMaterializedTemporaryFromLayers() if necessary.
static const ConstructionContext *
- createBoundTemporaryFromLayers(
- BumpVectorContext &C, const CXXBindTemporaryExpr *BTE,
- const ConstructionContextLayer *ParentLayer);
+ createBoundTemporaryFromLayers(BumpVectorContext &C,
+ const CXXBindTemporaryExpr *BTE,
+ const ConstructionContextLayer *ParentLayer);
public:
/// Consume the construction context layer, together with its parent layers,
@@ -333,8 +337,7 @@ class VariableConstructionContext : public ConstructionContext {
}
static bool classof(const ConstructionContext *CC) {
- return CC->getKind() >= VARIABLE_BEGIN &&
- CC->getKind() <= VARIABLE_END;
+ return CC->getKind() >= VARIABLE_BEGIN && CC->getKind() <= VARIABLE_END;
}
};
@@ -501,9 +504,7 @@ class TemporaryObjectConstructionContext : public ConstructionContext {
public:
/// CXXBindTemporaryExpr here is non-null as long as the temporary has
/// a non-trivial destructor.
- const CXXBindTemporaryExpr *getCXXBindTemporaryExpr() const {
- return BTE;
- }
+ const CXXBindTemporaryExpr *getCXXBindTemporaryExpr() const { return BTE; }
/// MaterializeTemporaryExpr is non-null as long as the temporary is actually
/// used after construction, eg. by binding to a reference (lifetime
@@ -621,11 +622,12 @@ class SimpleReturnedValueConstructionContext
/// Represents a temporary object that is being immediately returned from a
/// function by value, eg. return t; or return T(123); in C++17.
/// In C++17 there is not going to be an elidable copy constructor at the
-/// return site. However, the usual temporary-related bureaucracy (CXXBindTemporaryExpr,
-/// MaterializeTemporaryExpr) is normally located in the caller function's AST.
-/// Note that if the object has trivial destructor, then this code is
-/// indistinguishable from a simple returned value constructor on the AST level;
-/// in this case we provide a simple returned value construction context.
+/// return site. However, the usual temporary-related bureaucracy
+/// (CXXBindTemporaryExpr, MaterializeTemporaryExpr) is normally located in the
+/// caller function's AST. Note that if the object has trivial destructor, then
+/// this code is indistinguishable from a simple returned value constructor on
+/// the AST level; in this case we provide a simple returned value construction
+/// context.
class CXX17ElidedCopyReturnedValueConstructionContext
: public ReturnedValueConstructionContext {
const CXXBindTemporaryExpr *BTE;
@@ -664,8 +666,7 @@ class ArgumentConstructionContext : public ConstructionContext {
explicit ArgumentConstructionContext(const Expr *CE, unsigned Index,
const CXXBindTemporaryExpr *BTE)
- : ConstructionContext(ArgumentKind), CE(CE),
- Index(Index), BTE(BTE) {
+ : ConstructionContext(ArgumentKind), CE(CE), Index(Index), BTE(BTE) {
assert(isa<CallExpr>(CE) || isa<CXXConstructExpr>(CE) ||
isa<ObjCMessageExpr>(CE));
// BTE is optional.
diff --git a/clang/include/clang/Analysis/DomainSpecific/CocoaConventions.h b/clang/include/clang/Analysis/DomainSpecific/CocoaConventions.h
index 8531d17767ba51..05556a33795d94 100644
--- a/clang/include/clang/Analysis/DomainSpecific/CocoaConventions.h
+++ b/clang/include/clang/Analysis/DomainSpecific/CocoaConventions.h
@@ -23,19 +23,19 @@ class QualType;
namespace ento {
namespace cocoa {
- bool isRefType(QualType RetTy, StringRef Prefix,
- StringRef Name = StringRef());
+bool isRefType(QualType RetTy, StringRef Prefix, StringRef Name = StringRef());
- bool isCocoaObjectRef(QualType T);
+bool isCocoaObjectRef(QualType T);
-}
+} // namespace cocoa
namespace coreFoundation {
- bool isCFObjectRef(QualType T);
+bool isCFObjectRef(QualType T);
- bool followsCreateRule(const FunctionDecl *FD);
-}
+bool followsCreateRule(const FunctionDecl *FD);
+} // namespace coreFoundation
-}} // end: "clang:ento"
+} // namespace ento
+} // namespace clang
#endif
diff --git a/clang/include/clang/Analysis/DomainSpecific/ObjCNoReturn.h b/clang/include/clang/Analysis/DomainSpecific/ObjCNoReturn.h
index 80d7cb8e03a18a..62afae9b8194fb 100644
--- a/clang/include/clang/Analysis/DomainSpecific/ObjCNoReturn.h
+++ b/clang/include/clang/Analysis/DomainSpecific/ObjCNoReturn.h
@@ -40,6 +40,6 @@ class ObjCNoReturn {
/// return.
bool isImplicitNoReturn(const ObjCMessageExpr *ME);
};
-}
+} // namespace clang
#endif
diff --git a/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h b/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h
index b95095d2184c0e..f29efb97215073 100644
--- a/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h
+++ b/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h
@@ -138,8 +138,8 @@ class DataflowAnalysis : public TypeErasedDataflowAnalysis {
// The first-choice implementation: use `widen` when it is available.
template <typename T>
- static auto widenInternal(Rank0, T &Current, const T &Prev)
- -> decltype(Current.widen(Prev)) {
+ static auto widenInternal(Rank0, T &Current,
+ const T &Prev) -> decltype(Current.widen(Prev)) {
return Current.widen(Prev);
}
@@ -247,13 +247,13 @@ runDataflowAnalysis(
// FIXME: Make all classes derived from `DataflowAnalysis` take an `Environment`
// parameter in their constructor so that we can get rid of this abomination.
template <typename AnalysisT>
-auto createAnalysis(ASTContext &ASTCtx, Environment &Env)
- -> decltype(AnalysisT(ASTCtx, Env)) {
+auto createAnalysis(ASTContext &ASTCtx,
+ Environment &Env) -> decltype(AnalysisT(ASTCtx, Env)) {
return AnalysisT(ASTCtx, Env);
}
template <typename AnalysisT>
-auto createAnalysis(ASTContext &ASTCtx, Environment &Env)
- -> decltype(AnalysisT(ASTCtx)) {
+auto createAnalysis(ASTContext &ASTCtx,
+ Environment &Env) -> decltype(AnalysisT(ASTCtx)) {
return AnalysisT(ASTCtx);
}
diff --git a/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h b/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h
index b3dc940705f870..896141f9b36031 100644
--- a/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h
+++ b/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h
@@ -157,12 +157,12 @@ class Environment {
// The default implementation reduces to just comparison, since comparison
// is required by the API, even if no widening is performed.
switch (compare(Type, Prev, PrevEnv, Current, CurrentEnv)) {
- case ComparisonResult::Same:
- return &Prev;
- case ComparisonResult::Different:
- return &Current;
- case ComparisonResult::Unknown:
- return nullptr;
+ case ComparisonResult::Same:
+ return &Prev;
+ case ComparisonResult::Different:
+ return &Current;
+ case ComparisonResult::Unknown:
+ return nullptr;
}
llvm_unreachable("all cases in switch covered");
}
@@ -542,22 +542,17 @@ class Environment {
}
/// Returns an atomic boolean value.
- BoolValue &makeAtomicBoolValue() const {
- return arena().makeAtomValue();
- }
+ BoolValue &makeAtomicBoolValue() const { return arena().makeAtomValue(); }
/// Returns a unique instance of boolean Top.
- BoolValue &makeTopBoolValue() const {
- return arena().makeTopValue();
- }
+ BoolValue &makeTopBoolValue() const { return arena().makeTopValue(); }
/// Returns a boolean value that represents the conjunction of `LHS` and
/// `RHS`. Subsequent calls with the same arguments, regardless of their
/// order, will return the same result. If the given boolean values represent
/// the same value, the result will be the value itself.
BoolValue &makeAnd(BoolValue &LHS, BoolValue &RHS) const {
- return arena().makeBoolValue(
- arena().makeAnd(LHS.formula(), RHS.formula()));
+ return arena().makeBoolValue(arena().makeAnd(LHS.formula(), RHS.formula()));
}
/// Returns a boolean value that represents the disjunction of `LHS` and
@@ -565,8 +560,7 @@ class Environment {
/// order, will return the same result. If the given boolean values represent
/// the same value, the result will be the value itself.
BoolValue &makeOr(BoolValue &LHS, BoolValue &RHS) const {
- return arena().makeBoolValue(
- arena().makeOr(LHS.formula(), RHS.formula()));
+ return arena().makeBoolValue(arena().makeOr(LHS.formula(), RHS.formula()));
}
/// Returns a boolean value that represents the negation of `Val`. Subsequent
diff --git a/clang/include/clang/Analysis/FlowSensitive/DataflowValues.h b/clang/include/clang/Analysis/FlowSensitive/DataflowValues.h
index 2248bcdf3a512f..661f9957890f25 100644
--- a/clang/include/clang/Analysis/FlowSensitive/DataflowValues.h
+++ b/clang/include/clang/Analysis/FlowSensitive/DataflowValues.h
@@ -28,8 +28,8 @@ namespace clang {
//===----------------------------------------------------------------------===//
namespace dataflow {
- struct forward_analysis_tag {};
- struct backward_analysis_tag {};
+struct forward_analysis_tag {};
+struct backward_analysis_tag {};
} // end namespace dataflow
//===----------------------------------------------------------------------===//
@@ -37,7 +37,7 @@ namespace dataflow {
//===----------------------------------------------------------------------===//
template <typename ValueTypes,
- typename _AnalysisDirTag = dataflow::forward_analysis_tag >
+ typename _AnalysisDirTag = dataflow::forward_analysis_tag>
class DataflowValues {
//===--------------------------------------------------------------------===//
@@ -45,12 +45,12 @@ class DataflowValues {
//===--------------------------------------------------------------------===//
public:
- typedef typename ValueTypes::ValTy ValTy;
- typedef typename ValueTypes::AnalysisDataTy AnalysisDataTy;
- typedef _AnalysisDirTag AnalysisDirTag;
- typedef llvm::DenseMap<ProgramPoint, ValTy> EdgeDataMapTy;
- typedef llvm::DenseMap<const CFGBlock*, ValTy> BlockDataMapTy;
- typedef llvm::DenseMap<const Stmt*, ValTy> StmtDataMapTy;
+ typedef typename ValueTypes::ValTy ValTy;
+ typedef typename ValueTypes::AnalysisDataTy AnalysisDataTy;
+ typedef _AnalysisDirTag AnalysisDirTag;
+ typedef llvm::DenseMap<ProgramPoint, ValTy> EdgeDataMapTy;
+ typedef llvm::DenseMap<const CFGBlock *, ValTy> BlockDataMapTy;
+ typedef llvm::DenseMap<const Stmt *, ValTy> StmtDataMapTy;
//===--------------------------------------------------------------------===//
// Predicates.
@@ -66,7 +66,7 @@ class DataflowValues {
bool isBackwardAnalysis() { return !isForwardAnalysis(); }
private:
- bool isForwardAnalysis(dataflow::forward_analysis_tag) { return true; }
+ bool isForwardAnalysis(dataflow::forward_analysis_tag) { return true; }
bool isForwardAnalysis(dataflow::backward_analysis_tag) { return false; }
//===--------------------------------------------------------------------===//
@@ -79,33 +79,32 @@ class DataflowValues {
/// InitializeValues - Invoked by the solver to initialize state needed for
/// dataflow analysis. This method is usually specialized by subclasses.
- void InitializeValues(const CFG& cfg) {}
-
+ void InitializeValues(const CFG &cfg) {}
/// getEdgeData - Retrieves the dataflow values associated with a
/// CFG edge.
- ValTy& getEdgeData(const BlockEdge &E) {
+ ValTy &getEdgeData(const BlockEdge &E) {
typename EdgeDataMapTy::iterator I = EdgeDataMap.find(E);
- assert (I != EdgeDataMap.end() && "No data associated with Edge.");
+ assert(I != EdgeDataMap.end() && "No data associated with Edge.");
return I->second;
}
- const ValTy& getEdgeData(const BlockEdge &E) const {
- return reinterpret_cast<DataflowValues*>(this)->getEdgeData(E);
+ const ValTy &getEdgeData(const BlockEdge &E) const {
+ return reinterpret_cast<DataflowValues *>(this)->getEdgeData(E);
}
/// getBlockData - Retrieves the dataflow values associated with a
/// specified CFGBlock. If the dataflow analysis is a forward analysis,
/// this data is associated with the END of the block. If the analysis
/// is a backwards analysis, it is associated with the ENTRY of the block.
- ValTy& getBlockData(const CFGBlock *B) {
+ ValTy &getBlockData(const CFGBlock *B) {
typename BlockDataMapTy::iterator I = BlockDataMap.find(B);
- assert (I != BlockDataMap.end() && "No data associated with block.");
+ assert(I != BlockDataMap.end() && "No data associated with block.");
return I->second;
}
- const ValTy& getBlockData(const CFGBlock *B) const {
- return const_cast<DataflowValues*>(this)->getBlockData(B);
+ const ValTy &getBlockData(const CFGBlock *B) const {
+ return const_cast<DataflowValues *>(this)->getBlockData(B);
}
/// getStmtData - Retrieves the dataflow values associated with a
@@ -114,58 +113,59 @@ class DataflowValues {
/// If the analysis is a backwards analysis, it is associated with
/// the point after a Stmt. This data is only computed for block-level
/// expressions, and only when requested when the analysis is executed.
- ValTy& getStmtData(const Stmt *S) {
- assert (StmtDataMap && "Dataflow values were not computed for statements.");
+ ValTy &getStmtData(const Stmt *S) {
+ assert(StmtDataMap && "Dataflow values were not computed for statements.");
typename StmtDataMapTy::iterator I = StmtDataMap->find(S);
- assert (I != StmtDataMap->end() && "No data associated with statement.");
+ assert(I != StmtDataMap->end() && "No data associated with statement.");
return I->second;
}
- const ValTy& getStmtData(const Stmt *S) const {
- return const_cast<DataflowValues*>(this)->getStmtData(S);
+ const ValTy &getStmtData(const Stmt *S) const {
+ return const_cast<DataflowValues *>(this)->getStmtData(S);
}
/// getEdgeDataMap - Retrieves the internal map between CFG edges and
/// dataflow values. Usually used by a dataflow solver to compute
/// values for blocks.
- EdgeDataMapTy& getEdgeDataMap() { return EdgeDataMap; }
- const EdgeDataMapTy& getEdgeDataMap() const { return EdgeDataMap; }
+ EdgeDataMapTy &getEdgeDataMap() { return EdgeDataMap; }
+ const EdgeDataMapTy &getEdgeDataMap() const { return EdgeDataMap; }
/// getBlockDataMap - Retrieves the internal map between CFGBlocks and
/// dataflow values. If the dataflow analysis operates in the forward
/// direction, the values correspond to the dataflow values at the start
/// of the block. Otherwise, for a backward analysis, the values correspond
/// to the dataflow values at the end of the block.
- BlockDataMapTy& getBlockDataMap() { return BlockDataMap; }
- const BlockDataMapTy& getBlockDataMap() const { return BlockDataMap; }
+ BlockDataMapTy &getBlockDataMap() { return BlockDataMap; }
+ const BlockDataMapTy &getBlockDataMap() const { return BlockDataMap; }
/// getStmtDataMap - Retrieves the internal map between Stmts and
/// dataflow values.
- StmtDataMapTy& getStmtDataMap() {
- if (!StmtDataMap) StmtDataMap = new StmtDataMapTy();
+ StmtDataMapTy &getStmtDataMap() {
+ if (!StmtDataMap)
+ StmtDataMap = new StmtDataMapTy();
return *StmtDataMap;
}
- const StmtDataMapTy& getStmtDataMap() const {
- return const_cast<DataflowValues*>(this)->getStmtDataMap();
+ const StmtDataMapTy &getStmtDataMap() const {
+ return const_cast<DataflowValues *>(this)->getStmtDataMap();
}
/// getAnalysisData - Retrieves the meta data associated with a
/// dataflow analysis for analyzing a particular CFG.
/// This is typically consumed by transfer function code (via the solver).
/// This can also be used by subclasses to interpret the dataflow values.
- AnalysisDataTy& getAnalysisData() { return AnalysisData; }
- const AnalysisDataTy& getAnalysisData() const { return AnalysisData; }
+ AnalysisDataTy &getAnalysisData() { return AnalysisData; }
+ const AnalysisDataTy &getAnalysisData() const { return AnalysisData; }
//===--------------------------------------------------------------------===//
// Internal data.
//===--------------------------------------------------------------------===//
protected:
- EdgeDataMapTy EdgeDataMap;
- BlockDataMapTy BlockDataMap;
- StmtDataMapTy* StmtDataMap;
- AnalysisDataTy AnalysisData;
+ EdgeDataMapTy EdgeDataMap;
+ BlockDataMapTy BlockDataMap;
+ StmtDataMapTy *StmtDataMap;
+ AnalysisDataTy AnalysisData;
};
} // end namespace clang
diff --git a/clang/include/clang/Analysis/PathDiagnostic.h b/clang/include/clang/Analysis/PathDiagnostic.h
index 90559e7efb06f0..db5d42a69c9047 100644
--- a/clang/include/clang/Analysis/PathDiagnostic.h
+++ b/clang/include/clang/Analysis/PathDiagnostic.h
@@ -116,8 +116,7 @@ class PathDiagnosticConsumer {
bool empty() const { return Set.empty(); }
- void addDiagnostic(const PathDiagnostic &PD,
- StringRef ConsumerName,
+ void addDiagnostic(const PathDiagnostic &PD, StringRef ConsumerName,
StringRef fileName);
PDFileEntry::ConsumerFiles *getFiles(const PathDiagnostic &PD);
@@ -245,8 +244,7 @@ class PathDiagnosticLocation {
}
/// Create a location corresponding to the given declaration.
- static PathDiagnosticLocation create(const Decl *D,
- const SourceManager &SM) {
+ static PathDiagnosticLocation create(const Decl *D, const SourceManager &SM) {
return PathDiagnosticLocation(D, SM);
}
@@ -264,25 +262,25 @@ class PathDiagnosticLocation {
}
/// Create a location for the beginning of the statement.
- static PathDiagnosticLocation createBegin(const Stmt *S,
- const SourceManager &SM,
- const LocationOrAnalysisDeclContext LAC);
+ static PathDiagnosticLocation
+ createBegin(const Stmt *S, const SourceManager &SM,
+ const LocationOrAnalysisDeclContext LAC);
/// Create a location for the end of the statement.
///
/// If the statement is a CompoundStatement, the location will point to the
/// closing brace instead of following it.
- static PathDiagnosticLocation createEnd(const Stmt *S,
- const SourceManager &SM,
- const LocationOrAnalysisDeclContext LAC);
+ static PathDiagnosticLocation
+ createEnd(const Stmt *S, const SourceManager &SM,
+ const LocationOrAnalysisDeclContext LAC);
/// Create the location for the operator of the binary expression.
/// Assumes the statement has a valid location.
static PathDiagnosticLocation createOperatorLoc(const BinaryOperator *BO,
const SourceManager &SM);
- static PathDiagnosticLocation createConditionalColonLoc(
- const ConditionalOperator *CO,
- const SourceManager &SM);
+ static PathDiagnosticLocation
+ createConditionalColonLoc(const ConditionalOperator *CO,
+ const SourceManager &SM);
/// For member expressions, return the location of the '.' or '->'.
/// Assumes the statement has a valid location.
@@ -307,15 +305,15 @@ class PathDiagnosticLocation {
/// Constructs a location for the end of the enclosing declaration body.
/// Defaults to the end of brace.
static PathDiagnosticLocation createDeclEnd(const LocationContext *LC,
- const SourceManager &SM);
+ const SourceManager &SM);
/// Create a location corresponding to the given valid ProgramPoint.
static PathDiagnosticLocation create(const ProgramPoint &P,
const SourceManager &SMng);
/// Convert the given location into a single kind location.
- static PathDiagnosticLocation createSingleLocation(
- const PathDiagnosticLocation &PDL);
+ static PathDiagnosticLocation
+ createSingleLocation(const PathDiagnosticLocation &PDL);
/// Construct a source location that corresponds to either the beginning
/// or the end of the given statement, or a nearby valid source location
@@ -332,38 +330,39 @@ class PathDiagnosticLocation {
return !(*this == X);
}
- bool isValid() const {
- return SM != nullptr;
- }
+ bool isValid() const { return SM != nullptr; }
- FullSourceLoc asLocation() const {
- return Loc;
- }
+ FullSourceLoc asLocation() const { return Loc; }
- PathDiagnosticRange asRange() const {
- return Range;
- }
+ PathDiagnosticRange asRange() const { return Range; }
- const Stmt *asStmt() const { assert(isValid()); return S; }
+ const Stmt *asStmt() const {
+ assert(isValid());
+ return S;
+ }
const Stmt *getStmtOrNull() const {
if (!isValid())
return nullptr;
return asStmt();
}
- const Decl *asDecl() const { assert(isValid()); return D; }
+ const Decl *asDecl() const {
+ assert(isValid());
+ return D;
+ }
bool hasRange() const { return K == StmtK || K == RangeK || K == DeclK; }
bool hasValidLocation() const { return asLocation().isValid(); }
- void invalidate() {
- *this = PathDiagnosticLocation();
- }
+ void invalidate() { *this = PathDiagnosticLocation(); }
void flatten();
- const SourceManager& getManager() const { assert(isValid()); return *SM; }
+ const SourceManager &getManager() const {
+ assert(isValid());
+ return *SM;
+ }
void Profile(llvm::FoldingSetNodeID &ID) const;
@@ -400,7 +399,7 @@ class PathDiagnosticLocationPair {
// Path "pieces" for path-sensitive diagnostics.
//===----------------------------------------------------------------------===//
-class PathDiagnosticPiece: public llvm::FoldingSetNode {
+class PathDiagnosticPiece : public llvm::FoldingSetNode {
public:
enum Kind { ControlFlow, Event, Macro, Call, Note, PopUp };
enum DisplayHint { Above, Below };
@@ -463,12 +462,10 @@ class PathDiagnosticPiece: public llvm::FoldingSetNode {
void addRange(SourceLocation B, SourceLocation E) {
if (!B.isValid() || !E.isValid())
return;
- ranges.push_back(SourceRange(B,E));
+ ranges.push_back(SourceRange(B, E));
}
- void addFixit(FixItHint F) {
- fixits.push_back(F);
- }
+ void addFixit(FixItHint F) { fixits.push_back(F); }
/// Return the SourceRanges associated with this PathDiagnosticPiece.
ArrayRef<SourceRange> getRanges() const { return ranges; }
@@ -478,13 +475,9 @@ class PathDiagnosticPiece: public llvm::FoldingSetNode {
virtual void Profile(llvm::FoldingSetNodeID &ID) const;
- void setAsLastInMainSourceFile() {
- LastInMainSourceFile = true;
- }
+ void setAsLastInMainSourceFile() { LastInMainSourceFile = true; }
- bool isLastInMainSourceFile() const {
- return LastInMainSourceFile;
- }
+ bool isLastInMainSourceFile() const { return LastInMainSourceFile; }
virtual void dump() const = 0;
};
@@ -510,14 +503,13 @@ class PathDiagnosticSpotPiece : public PathDiagnosticPiece {
PathDiagnosticLocation Pos;
public:
- PathDiagnosticSpotPiece(const PathDiagnosticLocation &pos,
- StringRef s,
- PathDiagnosticPiece::Kind k,
- bool addPosRange = true)
+ PathDiagnosticSpotPiece(const PathDiagnosticLocation &pos, StringRef s,
+ PathDiagnosticPiece::Kind k, bool addPosRange = true)
: PathDiagnosticPiece(s, k), Pos(pos) {
assert(Pos.isValid() && Pos.hasValidLocation() &&
"PathDiagnosticSpotPiece's must have a valid location.");
- if (addPosRange && Pos.hasRange()) addRange(Pos.asRange());
+ if (addPosRange && Pos.hasRange())
+ addRange(Pos.asRange());
}
PathDiagnosticLocation getLocation() const override { return Pos; }
@@ -535,8 +527,8 @@ class PathDiagnosticEventPiece : public PathDiagnosticSpotPiece {
std::optional<bool> IsPrunable;
public:
- PathDiagnosticEventPiece(const PathDiagnosticLocation &pos,
- StringRef s, bool addPosRange = true)
+ PathDiagnosticEventPiece(const PathDiagnosticLocation &pos, StringRef s,
+ bool addPosRange = true)
: PathDiagnosticSpotPiece(pos, s, Event, addPosRange) {}
~PathDiagnosticEventPiece() override;
@@ -580,8 +572,8 @@ class PathDiagnosticCallPiece : public PathDiagnosticPiece {
: PathDiagnosticPiece(Call), Caller(callerD), NoExit(false),
callReturn(callReturnPos) {}
PathDiagnosticCallPiece(PathPieces &oldPath, const Decl *caller)
- : PathDiagnosticPiece(Call), Caller(caller), NoExit(true),
- path(oldPath) {}
+ : PathDiagnosticPiece(Call), Caller(caller), NoExit(true), path(oldPath) {
+ }
public:
PathDiagnosticLocation callEnter;
@@ -614,8 +606,7 @@ class PathDiagnosticCallPiece : public PathDiagnosticPiece {
}
static std::shared_ptr<PathDiagnosticCallPiece>
- construct(const CallExitEnd &CE,
- const SourceManager &SM);
+ construct(const CallExitEnd &CE, const SourceManager &SM);
static PathDiagnosticCallPiece *construct(PathPieces &pieces,
const Decl *caller);
@@ -664,9 +655,7 @@ class PathDiagnosticControlFlowPiece : public PathDiagnosticPiece {
LPairs[0].setStart(L);
}
- void setEndLocation(const PathDiagnosticLocation &L) {
- LPairs[0].setEnd(L);
- }
+ void setEndLocation(const PathDiagnosticLocation &L) { LPairs[0].setEnd(L); }
void push_back(const PathDiagnosticLocationPair &X) { LPairs.push_back(X); }
@@ -722,7 +711,7 @@ class PathDiagnosticMacroPiece : public PathDiagnosticSpotPiece {
void Profile(llvm::FoldingSetNodeID &ID) const override;
};
-class PathDiagnosticNotePiece: public PathDiagnosticSpotPiece {
+class PathDiagnosticNotePiece : public PathDiagnosticSpotPiece {
public:
PathDiagnosticNotePiece(const PathDiagnosticLocation &Pos, StringRef S,
bool AddPosRange = true)
@@ -738,7 +727,7 @@ class PathDiagnosticNotePiece: public PathDiagnosticSpotPiece {
void Profile(llvm::FoldingSetNodeID &ID) const override;
};
-class PathDiagnosticPopUpPiece: public PathDiagnosticSpotPiece {
+class PathDiagnosticPopUpPiece : public PathDiagnosticSpotPiece {
public:
PathDiagnosticPopUpPiece(const PathDiagnosticLocation &Pos, StringRef S,
bool AddPosRange = true)
@@ -803,15 +792,16 @@ class PathDiagnostic : public llvm::FoldingSetNode {
}
/// Return a mutable version of 'path'.
- PathPieces &getMutablePieces() {
- return pathImpl;
- }
+ PathPieces &getMutablePieces() { return pathImpl; }
/// Return the unrolled size of the path.
unsigned full_size();
void pushActivePath(PathPieces *p) { pathStack.push_back(p); }
- void popActivePath() { if (!pathStack.empty()) pathStack.pop_back(); }
+ void popActivePath() {
+ if (!pathStack.empty())
+ pathStack.pop_back();
+ }
bool isWithinCall() const { return !pathStack.empty(); }
@@ -844,40 +834,26 @@ class PathDiagnostic : public llvm::FoldingSetNode {
meta_iterator meta_end() const { return OtherDesc.end(); }
void addMeta(StringRef s) { OtherDesc.push_back(std::string(s)); }
- const FilesToLineNumsMap &getExecutedLines() const {
- return *ExecutedLines;
- }
+ const FilesToLineNumsMap &getExecutedLines() const { return *ExecutedLines; }
- FilesToLineNumsMap &getExecutedLines() {
- return *ExecutedLines;
- }
+ FilesToLineNumsMap &getExecutedLines() { return *ExecutedLines; }
/// Return the semantic context where an issue occurred. If the
/// issue occurs along a path, this represents the "central" area
/// where the bug manifests.
const Decl *getDeclWithIssue() const { return DeclWithIssue; }
- void setDeclWithIssue(const Decl *D) {
- DeclWithIssue = D;
- }
+ void setDeclWithIssue(const Decl *D) { DeclWithIssue = D; }
- PathDiagnosticLocation getLocation() const {
- return Loc;
- }
+ PathDiagnosticLocation getLocation() const { return Loc; }
- void setLocation(PathDiagnosticLocation NewLoc) {
- Loc = NewLoc;
- }
+ void setLocation(PathDiagnosticLocation NewLoc) { Loc = NewLoc; }
/// Get the location on which the report should be uniqued.
- PathDiagnosticLocation getUniqueingLoc() const {
- return UniqueingLoc;
- }
+ PathDiagnosticLocation getUniqueingLoc() const { return UniqueingLoc; }
/// Get the declaration containing the uniqueing location.
- const Decl *getUniqueingDecl() const {
- return UniqueingDecl;
- }
+ const Decl *getUniqueingDecl() const { return UniqueingDecl; }
void flattenLocations() {
Loc.flatten();
diff --git a/clang/include/clang/Analysis/ProgramPoint.h b/clang/include/clang/Analysis/ProgramPoint.h
index b9339570e1ae70..0b2d2cd5503021 100644
--- a/clang/include/clang/Analysis/ProgramPoint.h
+++ b/clang/include/clang/Analysis/ProgramPoint.h
@@ -50,6 +50,7 @@ class ProgramPointTag {
class SimpleProgramPointTag : public ProgramPointTag {
std::string Desc;
+
public:
SimpleProgramPointTag(StringRef MsgProvider, StringRef Msg);
StringRef getTagDescription() const override;
@@ -57,33 +58,35 @@ class SimpleProgramPointTag : public ProgramPointTag {
class ProgramPoint {
public:
- enum Kind { BlockEdgeKind,
- BlockEntranceKind,
- BlockExitKind,
- PreStmtKind,
- PreStmtPurgeDeadSymbolsKind,
- PostStmtPurgeDeadSymbolsKind,
- PostStmtKind,
- PreLoadKind,
- PostLoadKind,
- PreStoreKind,
- PostStoreKind,
- PostConditionKind,
- PostLValueKind,
- PostAllocatorCallKind,
- MinPostStmtKind = PostStmtKind,
- MaxPostStmtKind = PostAllocatorCallKind,
- PostInitializerKind,
- CallEnterKind,
- CallExitBeginKind,
- CallExitEndKind,
- FunctionExitKind,
- PreImplicitCallKind,
- PostImplicitCallKind,
- MinImplicitCallKind = PreImplicitCallKind,
- MaxImplicitCallKind = PostImplicitCallKind,
- LoopExitKind,
- EpsilonKind};
+ enum Kind {
+ BlockEdgeKind,
+ BlockEntranceKind,
+ BlockExitKind,
+ PreStmtKind,
+ PreStmtPurgeDeadSymbolsKind,
+ PostStmtPurgeDeadSymbolsKind,
+ PostStmtKind,
+ PreLoadKind,
+ PostLoadKind,
+ PreStoreKind,
+ PostStoreKind,
+ PostConditionKind,
+ PostLValueKind,
+ PostAllocatorCallKind,
+ MinPostStmtKind = PostStmtKind,
+ MaxPostStmtKind = PostAllocatorCallKind,
+ PostInitializerKind,
+ CallEnterKind,
+ CallExitBeginKind,
+ CallExitEndKind,
+ FunctionExitKind,
+ PreImplicitCallKind,
+ PostImplicitCallKind,
+ MinImplicitCallKind = PreImplicitCallKind,
+ MaxImplicitCallKind = PostImplicitCallKind,
+ LoopExitKind,
+ EpsilonKind
+ };
private:
const void *Data1;
@@ -127,17 +130,16 @@ class ProgramPoint {
/// Create a new ProgramPoint object that is the same as the original
/// except for using the specified tag value.
ProgramPoint withTag(const ProgramPointTag *tag) const {
- return ProgramPoint(getData1(), getData2(), getKind(),
- getLocationContext(), tag);
+ return ProgramPoint(getData1(), getData2(), getKind(), getLocationContext(),
+ tag);
}
/// Convert to the specified ProgramPoint type, asserting that this
/// ProgramPoint is of the desired type.
- template<typename T>
- T castAs() const {
+ template <typename T> T castAs() const {
assert(T::isKind(*this));
T t;
- ProgramPoint& PP = t;
+ ProgramPoint &PP = t;
PP = *this;
return t;
}
@@ -148,7 +150,7 @@ class ProgramPoint {
if (!T::isKind(*this))
return std::nullopt;
T t;
- ProgramPoint& PP = t;
+ ProgramPoint &PP = t;
PP = *this;
return t;
}
@@ -159,7 +161,7 @@ class ProgramPoint {
x |= L.getInt();
x <<= 2;
x |= Data2.getInt();
- return (Kind) x;
+ return (Kind)x;
}
/// Is this a program point corresponding to purge/removal of dead
@@ -172,9 +174,7 @@ class ProgramPoint {
const ProgramPointTag *getTag() const { return Tag.getPointer(); }
- const LocationContext *getLocationContext() const {
- return L.getPointer();
- }
+ const LocationContext *getLocationContext() const { return L.getPointer(); }
const StackFrameContext *getStackFrame() const {
return getLocationContext()->getStackFrame();
@@ -187,7 +187,7 @@ class ProgramPoint {
return ID.ComputeHash();
}
- bool operator==(const ProgramPoint & RHS) const {
+ bool operator==(const ProgramPoint &RHS) const {
return Data1 == RHS.Data1 && Data2 == RHS.Data2 && L == RHS.L &&
Tag == RHS.Tag && ElemRef == RHS.ElemRef;
}
@@ -197,8 +197,8 @@ class ProgramPoint {
Tag != RHS.Tag || ElemRef != RHS.ElemRef;
}
- void Profile(llvm::FoldingSetNodeID& ID) const {
- ID.AddInteger((unsigned) getKind());
+ void Profile(llvm::FoldingSetNodeID &ID) const {
+ ID.AddInteger((unsigned)getKind());
ID.AddPointer(getData1());
ID.AddPointer(getData2());
ID.AddPointer(getLocationContext());
@@ -220,12 +220,12 @@ class BlockEntrance : public ProgramPoint {
public:
BlockEntrance(const CFGBlock *B, const LocationContext *L,
const ProgramPointTag *tag = nullptr)
- : ProgramPoint(B, BlockEntranceKind, L, tag) {
+ : ProgramPoint(B, BlockEntranceKind, L, tag) {
assert(B && "BlockEntrance requires non-null block");
}
const CFGBlock *getBlock() const {
- return reinterpret_cast<const CFGBlock*>(getData1());
+ return reinterpret_cast<const CFGBlock *>(getData1());
}
std::optional<CFGElement> getFirstElement() const {
@@ -244,15 +244,13 @@ class BlockEntrance : public ProgramPoint {
class BlockExit : public ProgramPoint {
public:
BlockExit(const CFGBlock *B, const LocationContext *L)
- : ProgramPoint(B, BlockExitKind, L) {}
+ : ProgramPoint(B, BlockExitKind, L) {}
const CFGBlock *getBlock() const {
- return reinterpret_cast<const CFGBlock*>(getData1());
+ return reinterpret_cast<const CFGBlock *>(getData1());
}
- const Stmt *getTerminator() const {
- return getBlock()->getTerminatorStmt();
- }
+ const Stmt *getTerminator() const { return getBlock()->getTerminatorStmt(); }
private:
friend class ProgramPoint;
@@ -267,17 +265,19 @@ class StmtPoint : public ProgramPoint {
public:
StmtPoint(const Stmt *S, const void *p2, Kind k, const LocationContext *L,
const ProgramPointTag *tag)
- : ProgramPoint(S, p2, k, L, tag) {
+ : ProgramPoint(S, p2, k, L, tag) {
assert(S);
}
- const Stmt *getStmt() const { return (const Stmt*) getData1(); }
+ const Stmt *getStmt() const { return (const Stmt *)getData1(); }
- template <typename T>
- const T* getStmtAs() const { return dyn_cast<T>(getStmt()); }
+ template <typename T> const T *getStmtAs() const {
+ return dyn_cast<T>(getStmt());
+ }
protected:
StmtPoint() = default;
+
private:
friend class ProgramPoint;
static bool isKind(const ProgramPoint &Location) {
@@ -286,14 +286,13 @@ class StmtPoint : public ProgramPoint {
}
};
-
class PreStmt : public StmtPoint {
public:
PreStmt(const Stmt *S, const LocationContext *L, const ProgramPointTag *tag,
const Stmt *SubStmt = nullptr)
- : StmtPoint(S, SubStmt, PreStmtKind, L, tag) {}
+ : StmtPoint(S, SubStmt, PreStmtKind, L, tag) {}
- const Stmt *getSubStmt() const { return (const Stmt*) getData2(); }
+ const Stmt *getSubStmt() const { return (const Stmt *)getData2(); }
private:
friend class ProgramPoint;
@@ -308,16 +307,16 @@ class PostStmt : public StmtPoint {
PostStmt() = default;
PostStmt(const Stmt *S, const void *data, Kind k, const LocationContext *L,
const ProgramPointTag *tag = nullptr)
- : StmtPoint(S, data, k, L, tag) {}
+ : StmtPoint(S, data, k, L, tag) {}
public:
explicit PostStmt(const Stmt *S, Kind k, const LocationContext *L,
const ProgramPointTag *tag = nullptr)
- : StmtPoint(S, nullptr, k, L, tag) {}
+ : StmtPoint(S, nullptr, k, L, tag) {}
explicit PostStmt(const Stmt *S, const LocationContext *L,
const ProgramPointTag *tag = nullptr)
- : StmtPoint(S, nullptr, PostStmtKind, L, tag) {}
+ : StmtPoint(S, nullptr, PostStmtKind, L, tag) {}
private:
friend class ProgramPoint;
@@ -329,8 +328,7 @@ class PostStmt : public StmtPoint {
class FunctionExitPoint : public ProgramPoint {
public:
- explicit FunctionExitPoint(const ReturnStmt *S,
- const LocationContext *LC,
+ explicit FunctionExitPoint(const ReturnStmt *S, const LocationContext *LC,
const ProgramPointTag *tag = nullptr)
: ProgramPoint(S, FunctionExitKind, LC, tag) {}
@@ -355,7 +353,7 @@ class PostCondition : public PostStmt {
public:
PostCondition(const Stmt *S, const LocationContext *L,
const ProgramPointTag *tag = nullptr)
- : PostStmt(S, PostConditionKind, L, tag) {}
+ : PostStmt(S, PostConditionKind, L, tag) {}
private:
friend class ProgramPoint;
@@ -368,9 +366,9 @@ class PostCondition : public PostStmt {
class LocationCheck : public StmtPoint {
protected:
LocationCheck() = default;
- LocationCheck(const Stmt *S, const LocationContext *L,
- ProgramPoint::Kind K, const ProgramPointTag *tag)
- : StmtPoint(S, nullptr, K, L, tag) {}
+ LocationCheck(const Stmt *S, const LocationContext *L, ProgramPoint::Kind K,
+ const ProgramPointTag *tag)
+ : StmtPoint(S, nullptr, K, L, tag) {}
private:
friend class ProgramPoint;
@@ -384,7 +382,7 @@ class PreLoad : public LocationCheck {
public:
PreLoad(const Stmt *S, const LocationContext *L,
const ProgramPointTag *tag = nullptr)
- : LocationCheck(S, L, PreLoadKind, tag) {}
+ : LocationCheck(S, L, PreLoadKind, tag) {}
private:
friend class ProgramPoint;
@@ -398,7 +396,7 @@ class PreStore : public LocationCheck {
public:
PreStore(const Stmt *S, const LocationContext *L,
const ProgramPointTag *tag = nullptr)
- : LocationCheck(S, L, PreStoreKind, tag) {}
+ : LocationCheck(S, L, PreStoreKind, tag) {}
private:
friend class ProgramPoint;
@@ -412,7 +410,7 @@ class PostLoad : public PostStmt {
public:
PostLoad(const Stmt *S, const LocationContext *L,
const ProgramPointTag *tag = nullptr)
- : PostStmt(S, PostLoadKind, L, tag) {}
+ : PostStmt(S, PostLoadKind, L, tag) {}
private:
friend class ProgramPoint;
@@ -430,16 +428,14 @@ class PostStore : public PostStmt {
/// used in the form it was uttered in the code.
PostStore(const Stmt *S, const LocationContext *L, const void *Loc,
const ProgramPointTag *tag = nullptr)
- : PostStmt(S, PostStoreKind, L, tag) {
+ : PostStmt(S, PostStoreKind, L, tag) {
assert(getData2() == nullptr);
setData2(Loc);
}
/// Returns the information about the location used in the store,
/// how it was uttered in the code.
- const void *getLocationValue() const {
- return getData2();
- }
+ const void *getLocationValue() const { return getData2(); }
private:
friend class ProgramPoint;
@@ -453,7 +449,7 @@ class PostLValue : public PostStmt {
public:
PostLValue(const Stmt *S, const LocationContext *L,
const ProgramPointTag *tag = nullptr)
- : PostStmt(S, PostLValueKind, L, tag) {}
+ : PostStmt(S, PostLValueKind, L, tag) {}
private:
friend class ProgramPoint;
@@ -468,8 +464,8 @@ class PostLValue : public PostStmt {
class PreStmtPurgeDeadSymbols : public StmtPoint {
public:
PreStmtPurgeDeadSymbols(const Stmt *S, const LocationContext *L,
- const ProgramPointTag *tag = nullptr)
- : StmtPoint(S, nullptr, PreStmtPurgeDeadSymbolsKind, L, tag) { }
+ const ProgramPointTag *tag = nullptr)
+ : StmtPoint(S, nullptr, PreStmtPurgeDeadSymbolsKind, L, tag) {}
private:
friend class ProgramPoint;
@@ -484,8 +480,8 @@ class PreStmtPurgeDeadSymbols : public StmtPoint {
class PostStmtPurgeDeadSymbols : public StmtPoint {
public:
PostStmtPurgeDeadSymbols(const Stmt *S, const LocationContext *L,
- const ProgramPointTag *tag = nullptr)
- : StmtPoint(S, nullptr, PostStmtPurgeDeadSymbolsKind, L, tag) { }
+ const ProgramPointTag *tag = nullptr)
+ : StmtPoint(S, nullptr, PostStmtPurgeDeadSymbolsKind, L, tag) {}
private:
friend class ProgramPoint;
@@ -498,17 +494,17 @@ class PostStmtPurgeDeadSymbols : public StmtPoint {
class BlockEdge : public ProgramPoint {
public:
BlockEdge(const CFGBlock *B1, const CFGBlock *B2, const LocationContext *L)
- : ProgramPoint(B1, B2, BlockEdgeKind, L) {
+ : ProgramPoint(B1, B2, BlockEdgeKind, L) {
assert(B1 && "BlockEdge: source block must be non-null");
assert(B2 && "BlockEdge: destination block must be non-null");
}
const CFGBlock *getSrc() const {
- return static_cast<const CFGBlock*>(getData1());
+ return static_cast<const CFGBlock *>(getData1());
}
const CFGBlock *getDst() const {
- return static_cast<const CFGBlock*>(getData2());
+ return static_cast<const CFGBlock *>(getData2());
}
private:
@@ -526,19 +522,16 @@ class PostInitializer : public ProgramPoint {
///
/// \param I The initializer.
/// \param Loc The location of the field being initialized.
- PostInitializer(const CXXCtorInitializer *I,
- const void *Loc,
+ PostInitializer(const CXXCtorInitializer *I, const void *Loc,
const LocationContext *L)
- : ProgramPoint(I, Loc, PostInitializerKind, L) {}
+ : ProgramPoint(I, Loc, PostInitializerKind, L) {}
const CXXCtorInitializer *getInitializer() const {
return static_cast<const CXXCtorInitializer *>(getData1());
}
/// Returns the location of the field.
- const void *getLocationValue() const {
- return getData2();
- }
+ const void *getLocationValue() const { return getData2(); }
private:
friend class ProgramPoint;
@@ -565,6 +558,7 @@ class ImplicitCallPoint : public ProgramPoint {
protected:
ImplicitCallPoint() = default;
+
private:
friend class ProgramPoint;
static bool isKind(const ProgramPoint &Location) {
@@ -629,7 +623,7 @@ class CallEnter : public ProgramPoint {
public:
CallEnter(const Stmt *stmt, const StackFrameContext *calleeCtx,
const LocationContext *callerCtx)
- : ProgramPoint(stmt, calleeCtx, CallEnterKind, callerCtx, nullptr) {}
+ : ProgramPoint(stmt, calleeCtx, CallEnterKind, callerCtx, nullptr) {}
const Stmt *getCallExpr() const {
return static_cast<const Stmt *>(getData1());
@@ -667,7 +661,7 @@ class CallExitBegin : public ProgramPoint {
public:
// CallExitBegin uses the callee's location context.
CallExitBegin(const StackFrameContext *L, const ReturnStmt *RS)
- : ProgramPoint(RS, CallExitBeginKind, L, nullptr) { }
+ : ProgramPoint(RS, CallExitBeginKind, L, nullptr) {}
const ReturnStmt *getReturnStmt() const {
return static_cast<const ReturnStmt *>(getData1());
@@ -688,7 +682,7 @@ class CallExitEnd : public ProgramPoint {
// CallExitEnd uses the caller's location context.
CallExitEnd(const StackFrameContext *CalleeCtx,
const LocationContext *CallerCtx)
- : ProgramPoint(CalleeCtx, CallExitEndKind, CallerCtx, nullptr) {}
+ : ProgramPoint(CalleeCtx, CallExitEndKind, CallerCtx, nullptr) {}
const StackFrameContext *getCalleeContext() const {
return static_cast<const StackFrameContext *>(getData1());
@@ -710,19 +704,19 @@ class CallExitEnd : public ProgramPoint {
/// result in a LoopExit program point.
class LoopExit : public ProgramPoint {
public:
- LoopExit(const Stmt *LoopStmt, const LocationContext *LC)
- : ProgramPoint(LoopStmt, nullptr, LoopExitKind, LC) {}
+ LoopExit(const Stmt *LoopStmt, const LocationContext *LC)
+ : ProgramPoint(LoopStmt, nullptr, LoopExitKind, LC) {}
- const Stmt *getLoopStmt() const {
- return static_cast<const Stmt *>(getData1());
- }
+ const Stmt *getLoopStmt() const {
+ return static_cast<const Stmt *>(getData1());
+ }
private:
- friend class ProgramPoint;
- LoopExit() = default;
- static bool isKind(const ProgramPoint &Location) {
- return Location.getKind() == LoopExitKind;
- }
+ friend class ProgramPoint;
+ LoopExit() = default;
+ static bool isKind(const ProgramPoint &Location) {
+ return Location.getKind() == LoopExitKind;
+ }
};
/// This is a meta program point, which should be skipped by all the diagnostic
@@ -732,7 +726,7 @@ class EpsilonPoint : public ProgramPoint {
EpsilonPoint(const LocationContext *L, const void *Data1,
const void *Data2 = nullptr,
const ProgramPointTag *tag = nullptr)
- : ProgramPoint(Data1, Data2, EpsilonKind, L, tag) {}
+ : ProgramPoint(Data1, Data2, EpsilonKind, L, tag) {}
const void *getData() const { return getData1(); }
@@ -746,32 +740,33 @@ class EpsilonPoint : public ProgramPoint {
} // end namespace clang
-
namespace llvm { // Traits specialization for DenseMap
template <> struct DenseMapInfo<clang::ProgramPoint> {
-static inline clang::ProgramPoint getEmptyKey() {
- uintptr_t x =
- reinterpret_cast<uintptr_t>(DenseMapInfo<void*>::getEmptyKey()) & ~0x7;
- return clang::BlockEntrance(reinterpret_cast<clang::CFGBlock*>(x), nullptr);
-}
-
-static inline clang::ProgramPoint getTombstoneKey() {
- uintptr_t x =
- reinterpret_cast<uintptr_t>(DenseMapInfo<void*>::getTombstoneKey()) & ~0x7;
- return clang::BlockEntrance(reinterpret_cast<clang::CFGBlock*>(x), nullptr);
-}
+ static inline clang::ProgramPoint getEmptyKey() {
+ uintptr_t x =
+ reinterpret_cast<uintptr_t>(DenseMapInfo<void *>::getEmptyKey()) & ~0x7;
+ return clang::BlockEntrance(reinterpret_cast<clang::CFGBlock *>(x),
+ nullptr);
+ }
-static unsigned getHashValue(const clang::ProgramPoint &Loc) {
- return Loc.getHashValue();
-}
+ static inline clang::ProgramPoint getTombstoneKey() {
+ uintptr_t x =
+ reinterpret_cast<uintptr_t>(DenseMapInfo<void *>::getTombstoneKey()) &
+ ~0x7;
+ return clang::BlockEntrance(reinterpret_cast<clang::CFGBlock *>(x),
+ nullptr);
+ }
-static bool isEqual(const clang::ProgramPoint &L,
- const clang::ProgramPoint &R) {
- return L == R;
-}
+ static unsigned getHashValue(const clang::ProgramPoint &Loc) {
+ return Loc.getHashValue();
+ }
+ static bool isEqual(const clang::ProgramPoint &L,
+ const clang::ProgramPoint &R) {
+ return L == R;
+ }
};
} // end namespace llvm
diff --git a/clang/include/clang/Analysis/RetainSummaryManager.h b/clang/include/clang/Analysis/RetainSummaryManager.h
index 86865b9da4214b..797daba7c24478 100644
--- a/clang/include/clang/Analysis/RetainSummaryManager.h
+++ b/clang/include/clang/Analysis/RetainSummaryManager.h
@@ -15,15 +15,15 @@
#ifndef LLVM_CLANG_ANALYSIS_RETAINSUMMARYMANAGER_H
#define LLVM_CLANG_ANALYSIS_RETAINSUMMARYMANAGER_H
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/FoldingSet.h"
-#include "llvm/ADT/ImmutableMap.h"
#include "clang/AST/Attr.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/ParentMap.h"
#include "clang/Analysis/AnyCall.h"
#include "clang/Analysis/SelectorExtras.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/ImmutableMap.h"
#include "llvm/ADT/STLExtras.h"
#include <optional>
@@ -119,6 +119,7 @@ enum ArgEffectKind {
class ArgEffect {
ArgEffectKind K;
ObjKind O;
+
public:
explicit ArgEffect(ArgEffectKind K = DoNothing, ObjKind O = ObjKind::AnyObj)
: K(K), O(O) {}
@@ -126,9 +127,7 @@ class ArgEffect {
ArgEffectKind getKind() const { return K; }
ObjKind getObjKind() const { return O; }
- ArgEffect withKind(ArgEffectKind NewK) {
- return ArgEffect(NewK, O);
- }
+ ArgEffect withKind(ArgEffectKind NewK) { return ArgEffect(NewK, O); }
bool operator==(const ArgEffect &Other) const {
return K == Other.K && O == Other.O;
@@ -178,9 +177,7 @@ class RetEffect {
return K == OwnedSymbol || K == OwnedWhenTrackedReceiver;
}
- bool notOwned() const {
- return K == NotOwnedSymbol;
- }
+ bool notOwned() const { return K == NotOwnedSymbol; }
bool operator==(const RetEffect &Other) const {
return K == Other.K && O == Other.O;
@@ -190,33 +187,26 @@ class RetEffect {
return RetEffect(OwnedWhenTrackedReceiver, ObjKind::ObjC);
}
- static RetEffect MakeOwned(ObjKind o) {
- return RetEffect(OwnedSymbol, o);
- }
+ static RetEffect MakeOwned(ObjKind o) { return RetEffect(OwnedSymbol, o); }
static RetEffect MakeNotOwned(ObjKind o) {
return RetEffect(NotOwnedSymbol, o);
}
- static RetEffect MakeNoRet() {
- return RetEffect(NoRet);
- }
- static RetEffect MakeNoRetHard() {
- return RetEffect(NoRetHard);
- }
+ static RetEffect MakeNoRet() { return RetEffect(NoRet); }
+ static RetEffect MakeNoRetHard() { return RetEffect(NoRetHard); }
};
/// A key identifying a summary.
class ObjCSummaryKey {
- IdentifierInfo* II;
+ IdentifierInfo *II;
Selector S;
+
public:
- ObjCSummaryKey(IdentifierInfo* ii, Selector s)
- : II(ii), S(s) {}
+ ObjCSummaryKey(IdentifierInfo *ii, Selector s) : II(ii), S(s) {}
ObjCSummaryKey(const ObjCInterfaceDecl *d, Selector s)
- : II(d ? d->getIdentifier() : nullptr), S(s) {}
+ : II(d ? d->getIdentifier() : nullptr), S(s) {}
- ObjCSummaryKey(Selector s)
- : II(nullptr), S(s) {}
+ ObjCSummaryKey(Selector s) : II(nullptr), S(s) {}
IdentifierInfo *getIdentifier() const { return II; }
Selector getSelector() const { return S; }
@@ -233,44 +223,42 @@ namespace llvm {
// Adapters for FoldingSet.
//===----------------------------------------------------------------------===//
template <> struct FoldingSetTrait<ArgEffect> {
-static inline void Profile(const ArgEffect X, FoldingSetNodeID &ID) {
- ID.AddInteger((unsigned) X.getKind());
- ID.AddInteger((unsigned) X.getObjKind());
-}
+ static inline void Profile(const ArgEffect X, FoldingSetNodeID &ID) {
+ ID.AddInteger((unsigned)X.getKind());
+ ID.AddInteger((unsigned)X.getObjKind());
+ }
};
template <> struct FoldingSetTrait<RetEffect> {
static inline void Profile(const RetEffect &X, FoldingSetNodeID &ID) {
- ID.AddInteger((unsigned) X.getKind());
- ID.AddInteger((unsigned) X.getObjKind());
-}
+ ID.AddInteger((unsigned)X.getKind());
+ ID.AddInteger((unsigned)X.getObjKind());
+ }
};
template <> struct DenseMapInfo<ObjCSummaryKey> {
static inline ObjCSummaryKey getEmptyKey() {
- return ObjCSummaryKey(DenseMapInfo<IdentifierInfo*>::getEmptyKey(),
+ return ObjCSummaryKey(DenseMapInfo<IdentifierInfo *>::getEmptyKey(),
DenseMapInfo<Selector>::getEmptyKey());
}
static inline ObjCSummaryKey getTombstoneKey() {
- return ObjCSummaryKey(DenseMapInfo<IdentifierInfo*>::getTombstoneKey(),
+ return ObjCSummaryKey(DenseMapInfo<IdentifierInfo *>::getTombstoneKey(),
DenseMapInfo<Selector>::getTombstoneKey());
}
static unsigned getHashValue(const ObjCSummaryKey &V) {
- typedef std::pair<IdentifierInfo*, Selector> PairTy;
- return DenseMapInfo<PairTy>::getHashValue(PairTy(V.getIdentifier(),
- V.getSelector()));
+ typedef std::pair<IdentifierInfo *, Selector> PairTy;
+ return DenseMapInfo<PairTy>::getHashValue(
+ PairTy(V.getIdentifier(), V.getSelector()));
}
- static bool isEqual(const ObjCSummaryKey& LHS, const ObjCSummaryKey& RHS) {
+ static bool isEqual(const ObjCSummaryKey &LHS, const ObjCSummaryKey &RHS) {
return LHS.getIdentifier() == RHS.getIdentifier() &&
LHS.getSelector() == RHS.getSelector();
}
-
};
-} // end llvm namespace
-
+} // namespace llvm
namespace clang {
namespace ento {
@@ -302,13 +290,10 @@ class RetainSummary {
RetEffect Ret;
public:
- RetainSummary(ArgEffects A,
- RetEffect R,
- ArgEffect defaultEff,
- ArgEffect ReceiverEff,
- ArgEffect ThisEff)
- : Args(A), DefaultArgEffect(defaultEff), Receiver(ReceiverEff),
- This(ThisEff), Ret(R) {}
+ RetainSummary(ArgEffects A, RetEffect R, ArgEffect defaultEff,
+ ArgEffect ReceiverEff, ArgEffect ThisEff)
+ : Args(A), DefaultArgEffect(defaultEff), Receiver(ReceiverEff),
+ This(ThisEff), Ret(R) {}
/// getArg - Return the argument effect on the argument specified by
/// idx (starting from 0).
@@ -324,9 +309,7 @@ class RetainSummary {
}
/// setDefaultArgEffect - Set the default argument effect.
- void setDefaultArgEffect(ArgEffect E) {
- DefaultArgEffect = E;
- }
+ void setDefaultArgEffect(ArgEffect E) { DefaultArgEffect = E; }
/// getRetEffect - Returns the effect on the return value of the call.
RetEffect getRetEffect() const { return Ret; }
@@ -334,7 +317,6 @@ class RetainSummary {
/// setRetEffect - Set the effect of the return value of the call.
void setRetEffect(RetEffect E) { Ret = E; }
-
/// Sets the effect on the receiver of the message.
void setReceiverEffect(ArgEffect e) { Receiver = e; }
@@ -352,9 +334,9 @@ class RetainSummary {
void setThisEffect(ArgEffect e) { This = e; }
bool isNoop() const {
- return Ret == RetEffect::MakeNoRet() && Receiver.getKind() == DoNothing
- && DefaultArgEffect.getKind() == MayEscape && This.getKind() == DoNothing
- && Args.isEmpty();
+ return Ret == RetEffect::MakeNoRet() && Receiver.getKind() == DoNothing &&
+ DefaultArgEffect.getKind() == MayEscape &&
+ This.getKind() == DoNothing && Args.isEmpty();
}
/// Test if two retain summaries are identical. Note that merely equivalent
@@ -366,7 +348,7 @@ class RetainSummary {
}
/// Profile this summary for inclusion in a FoldingSet.
- void Profile(llvm::FoldingSetNodeID& ID) const {
+ void Profile(llvm::FoldingSetNodeID &ID) const {
ID.Add(Args);
ID.Add(DefaultArgEffect);
ID.Add(Receiver);
@@ -375,9 +357,7 @@ class RetainSummary {
}
/// A retain summary is simple if it has no ArgEffects other than the default.
- bool isSimple() const {
- return Args.isEmpty();
- }
+ bool isSimple() const { return Args.isEmpty(); }
ArgEffects getArgEffects() const { return Args; }
@@ -390,10 +370,11 @@ class RetainSummary {
class ObjCSummaryCache {
typedef llvm::DenseMap<ObjCSummaryKey, const RetainSummary *> MapTy;
MapTy M;
+
public:
ObjCSummaryCache() {}
- const RetainSummary * find(const ObjCInterfaceDecl *D, Selector S) {
+ const RetainSummary *find(const ObjCInterfaceDecl *D, Selector S) {
// Do a lookup with the (D,S) pair. If we find a match return
// the iterator.
ObjCSummaryKey K(D, S);
@@ -410,7 +391,7 @@ class ObjCSummaryCache {
// generate initial summaries without having to worry about NSObject
// being declared.
// FIXME: We may change this at some point.
- for (ObjCInterfaceDecl *C=D->getSuperClass() ;; C=C->getSuperClass()) {
+ for (ObjCInterfaceDecl *C = D->getSuperClass();; C = C->getSuperClass()) {
if ((I = M.find(ObjCSummaryKey(C, S))) != M.end())
break;
@@ -425,7 +406,7 @@ class ObjCSummaryCache {
return Summ;
}
- const RetainSummary *find(IdentifierInfo* II, Selector S) {
+ const RetainSummary *find(IdentifierInfo *II, Selector S) {
// FIXME: Class method lookup. Right now we don't have a good way
// of going between IdentifierInfo* and the class hierarchy.
MapTy::iterator I = M.find(ObjCSummaryKey(II, S));
@@ -436,20 +417,16 @@ class ObjCSummaryCache {
return I == M.end() ? nullptr : I->second;
}
- const RetainSummary *& operator[](ObjCSummaryKey K) {
- return M[K];
- }
+ const RetainSummary *&operator[](ObjCSummaryKey K) { return M[K]; }
- const RetainSummary *& operator[](Selector S) {
- return M[ ObjCSummaryKey(S) ];
- }
+ const RetainSummary *&operator[](Selector S) { return M[ObjCSummaryKey(S)]; }
};
class RetainSummaryTemplate;
class RetainSummaryManager {
- typedef llvm::DenseMap<const FunctionDecl*, const RetainSummary *>
- FuncSummariesTy;
+ typedef llvm::DenseMap<const FunctionDecl *, const RetainSummary *>
+ FuncSummariesTy;
typedef ObjCSummaryCache ObjCMethodSummariesTy;
@@ -511,7 +488,7 @@ class RetainSummaryManager {
/// Free the OS object.
const RetainSummary *getOSSummaryFreeRule(const FunctionDecl *FD);
- const RetainSummary *getUnarySummary(const FunctionType* FT,
+ const RetainSummary *getUnarySummary(const FunctionType *FT,
ArgEffectKind AE);
const RetainSummary *getCFSummaryCreateRule(const FunctionDecl *FD);
@@ -558,61 +535,60 @@ class RetainSummaryManager {
ObjCMethodSummaries[S] = Summ;
}
- void addClassMethSummary(const char* Cls, const char* name,
+ void addClassMethSummary(const char *Cls, const char *name,
const RetainSummary *Summ, bool isNullary = true) {
- IdentifierInfo* ClsII = &Ctx.Idents.get(Cls);
- Selector S = isNullary ? GetNullarySelector(name, Ctx)
- : GetUnarySelector(name, Ctx);
- ObjCClassMethodSummaries[ObjCSummaryKey(ClsII, S)] = Summ;
+ IdentifierInfo *ClsII = &Ctx.Idents.get(Cls);
+ Selector S =
+ isNullary ? GetNullarySelector(name, Ctx) : GetUnarySelector(name, Ctx);
+ ObjCClassMethodSummaries[ObjCSummaryKey(ClsII, S)] = Summ;
}
- void addInstMethSummary(const char* Cls, const char* nullaryName,
+ void addInstMethSummary(const char *Cls, const char *nullaryName,
const RetainSummary *Summ) {
- IdentifierInfo* ClsII = &Ctx.Idents.get(Cls);
+ IdentifierInfo *ClsII = &Ctx.Idents.get(Cls);
Selector S = GetNullarySelector(nullaryName, Ctx);
- ObjCMethodSummaries[ObjCSummaryKey(ClsII, S)] = Summ;
+ ObjCMethodSummaries[ObjCSummaryKey(ClsII, S)] = Summ;
}
template <typename... Keywords>
void addMethodSummary(IdentifierInfo *ClsII, ObjCMethodSummariesTy &Summaries,
- const RetainSummary *Summ, Keywords *... Kws) {
+ const RetainSummary *Summ, Keywords *...Kws) {
Selector S = getKeywordSelector(Ctx, Kws...);
Summaries[ObjCSummaryKey(ClsII, S)] = Summ;
}
template <typename... Keywords>
void addInstMethSummary(const char *Cls, const RetainSummary *Summ,
- Keywords *... Kws) {
+ Keywords *...Kws) {
addMethodSummary(&Ctx.Idents.get(Cls), ObjCMethodSummaries, Summ, Kws...);
}
template <typename... Keywords>
void addClsMethSummary(const char *Cls, const RetainSummary *Summ,
- Keywords *... Kws) {
+ Keywords *...Kws) {
addMethodSummary(&Ctx.Idents.get(Cls), ObjCClassMethodSummaries, Summ,
Kws...);
}
template <typename... Keywords>
void addClsMethSummary(IdentifierInfo *II, const RetainSummary *Summ,
- Keywords *... Kws) {
+ Keywords *...Kws) {
addMethodSummary(II, ObjCClassMethodSummaries, Summ, Kws...);
}
- const RetainSummary * generateSummary(const FunctionDecl *FD,
- bool &AllowAnnotations);
+ const RetainSummary *generateSummary(const FunctionDecl *FD,
+ bool &AllowAnnotations);
/// Return a summary for OSObject, or nullptr if not found.
const RetainSummary *getSummaryForOSObject(const FunctionDecl *FD,
StringRef FName, QualType RetTy);
/// Return a summary for Objective-C or CF object, or nullptr if not found.
- const RetainSummary *getSummaryForObjCOrCFObject(
- const FunctionDecl *FD,
- StringRef FName,
- QualType RetTy,
- const FunctionType *FT,
- bool &AllowAnnotations);
+ const RetainSummary *getSummaryForObjCOrCFObject(const FunctionDecl *FD,
+ StringRef FName,
+ QualType RetTy,
+ const FunctionType *FT,
+ bool &AllowAnnotations);
/// Apply the annotation of @c pd in function @c FD
/// to the resulting summary stored in out-parameter @c Template.
@@ -659,15 +635,13 @@ class RetainSummaryManager {
bool isTrustedReferenceCountImplementation(const Decl *FD);
- const RetainSummary *getSummary(AnyCall C,
- bool HasNonZeroCallbackArg=false,
- bool IsReceiverUnconsumedSelf=false,
- QualType ReceiverType={});
+ const RetainSummary *getSummary(AnyCall C, bool HasNonZeroCallbackArg = false,
+ bool IsReceiverUnconsumedSelf = false,
+ QualType ReceiverType = {});
RetEffect getObjAllocRetEffect() const { return ObjCAllocRetE; }
private:
-
/// getMethodSummary - This version of getMethodSummary is used to query
/// the summary for the current method being analyzed.
const RetainSummary *getMethodSummary(const ObjCMethodDecl *MD);
@@ -679,8 +653,8 @@ class RetainSummaryManager {
QualType RetTy,
ObjCMethodSummariesTy &CachedSummaries);
- const RetainSummary *
- getInstanceMethodSummary(const ObjCMessageExpr *ME, QualType ReceiverType);
+ const RetainSummary *getInstanceMethodSummary(const ObjCMessageExpr *ME,
+ QualType ReceiverType);
const RetainSummary *getClassMethodSummary(const ObjCMessageExpr *ME);
@@ -697,8 +671,8 @@ class RetainSummaryManager {
void updateSummaryFromAnnotations(const RetainSummary *&Summ,
const FunctionDecl *FD);
- const RetainSummary *updateSummaryForNonZeroCallbackArg(const RetainSummary *S,
- AnyCall &C);
+ const RetainSummary *
+ updateSummaryForNonZeroCallbackArg(const RetainSummary *S, AnyCall &C);
/// Special case '[super init];' and '[self init];'
///
@@ -715,7 +689,8 @@ class RetainSummaryManager {
void updateSummaryForReceiverUnconsumedSelf(const RetainSummary *&S);
/// Set argument types for arguments which are not doing anything.
- void updateSummaryForArgumentTypes(const AnyCall &C, const RetainSummary *&RS);
+ void updateSummaryForArgumentTypes(const AnyCall &C,
+ const RetainSummary *&RS);
/// Determine whether a declaration @c D of correspondent type (return
/// type for functions/methods) @c QT has any of the given attributes,
@@ -733,7 +708,6 @@ class RetainSummaryManager {
friend class RetainSummaryTemplate;
};
-
// Used to avoid allocating long-term (BPAlloc'd) memory for default retain
// summaries. If a function or method looks like it has a default summary, but
// it has annotations, the annotations are added to the stack-based template
@@ -743,9 +717,11 @@ class RetainSummaryTemplate {
const RetainSummary *&RealSummary;
RetainSummary ScratchSummary;
bool Accessed;
+
public:
RetainSummaryTemplate(const RetainSummary *&real, RetainSummaryManager &mgr)
- : Manager(mgr), RealSummary(real), ScratchSummary(*real), Accessed(false) {}
+ : Manager(mgr), RealSummary(real), ScratchSummary(*real),
+ Accessed(false) {}
~RetainSummaryTemplate() {
if (Accessed)
diff --git a/clang/include/clang/Analysis/SelectorExtras.h b/clang/include/clang/Analysis/SelectorExtras.h
index 1e1daf5706bbf5..c41717632f595f 100644
--- a/clang/include/clang/Analysis/SelectorExtras.h
+++ b/clang/include/clang/Analysis/SelectorExtras.h
@@ -15,7 +15,7 @@ namespace clang {
template <typename... IdentifierInfos>
static inline Selector getKeywordSelector(ASTContext &Ctx,
- IdentifierInfos *... IIs) {
+ IdentifierInfos *...IIs) {
static_assert(sizeof...(IdentifierInfos) > 0,
"keyword selectors must have at least one argument");
SmallVector<IdentifierInfo *, 10> II({&Ctx.Idents.get(IIs)...});
@@ -25,7 +25,7 @@ static inline Selector getKeywordSelector(ASTContext &Ctx,
template <typename... IdentifierInfos>
static inline void lazyInitKeywordSelector(Selector &Sel, ASTContext &Ctx,
- IdentifierInfos *... IIs) {
+ IdentifierInfos *...IIs) {
if (!Sel.isNull())
return;
Sel = getKeywordSelector(Ctx, IIs...);
diff --git a/clang/include/clang/Analysis/Support/BumpVector.h b/clang/include/clang/Analysis/Support/BumpVector.h
index 6c3f11e9930675..f65331e5d3fb83 100644
--- a/clang/include/clang/Analysis/Support/BumpVector.h
+++ b/clang/include/clang/Analysis/Support/BumpVector.h
@@ -30,7 +30,7 @@
namespace clang {
class BumpVectorContext {
- llvm::PointerIntPair<llvm::BumpPtrAllocator*, 1> Alloc;
+ llvm::PointerIntPair<llvm::BumpPtrAllocator *, 1> Alloc;
public:
/// Construct a new BumpVectorContext that creates a new BumpPtrAllocator
@@ -64,17 +64,14 @@ class BumpVectorContext {
llvm::BumpPtrAllocator &getAllocator() { return *Alloc.getPointer(); }
};
-template<typename T>
-class BumpVector {
+template <typename T> class BumpVector {
T *Begin = nullptr;
T *End = nullptr;
T *Capacity = nullptr;
public:
// Default ctor - Initialize to empty.
- explicit BumpVector(BumpVectorContext &C, unsigned N) {
- reserve(C, N);
- }
+ explicit BumpVector(BumpVectorContext &C, unsigned N) { reserve(C, N); }
~BumpVector() {
if (std::is_class<T>::value) {
@@ -105,14 +102,16 @@ class BumpVector {
// reverse iterator creation methods.
reverse_iterator rbegin() { return reverse_iterator(end()); }
- const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const {
+ return const_reverse_iterator(end());
+ }
reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const {
return const_reverse_iterator(begin());
}
bool empty() const { return Begin == End; }
- size_type size() const { return End-Begin; }
+ size_type size() const { return End - Begin; }
reference operator[](unsigned idx) {
assert(Begin + idx < End);
@@ -123,19 +122,11 @@ class BumpVector {
return Begin[idx];
}
- reference front() {
- return begin()[0];
- }
- const_reference front() const {
- return begin()[0];
- }
+ reference front() { return begin()[0]; }
+ const_reference front() const { return begin()[0]; }
- reference back() {
- return end()[-1];
- }
- const_reference back() const {
- return end()[-1];
- }
+ reference back() { return end()[-1]; }
+ const_reference back() const { return end()[-1]; }
void pop_back() {
--End;
@@ -156,14 +147,10 @@ class BumpVector {
}
/// data - Return a pointer to the vector's buffer, even if empty().
- pointer data() {
- return pointer(Begin);
- }
+ pointer data() { return pointer(Begin); }
/// data - Return a pointer to the vector's buffer, even if empty().
- const_pointer data() const {
- return const_pointer(Begin);
- }
+ const_pointer data() const { return const_pointer(Begin); }
void push_back(const_reference Elt, BumpVectorContext &C) {
if (End < Capacity) {
@@ -179,7 +166,7 @@ class BumpVector {
/// insert - Insert some number of copies of element into a position. Return
/// iterator to position after last inserted copy.
iterator insert(iterator I, size_t Cnt, const_reference E,
- BumpVectorContext &C) {
+ BumpVectorContext &C) {
assert(I >= Begin && I <= End && "Iterator out of bounds.");
if (End + Cnt <= Capacity) {
Retry:
@@ -195,7 +182,7 @@ class BumpVector {
}
void reserve(BumpVectorContext &C, unsigned N) {
- if (unsigned(Capacity-Begin) < N)
+ if (unsigned(Capacity - Begin) < N)
grow(C, N);
}
@@ -232,9 +219,9 @@ class BumpVector {
// Define this out-of-line to dissuade the C++ compiler from inlining it.
template <typename T>
void BumpVector<T>::grow(BumpVectorContext &C, size_t MinSize) {
- size_t CurCapacity = Capacity-Begin;
+ size_t CurCapacity = Capacity - Begin;
size_t CurSize = size();
- size_t NewCapacity = 2*CurCapacity;
+ size_t NewCapacity = 2 * CurCapacity;
if (NewCapacity < MinSize)
NewCapacity = MinSize;
@@ -256,8 +243,8 @@ void BumpVector<T>::grow(BumpVectorContext &C, size_t MinSize) {
// For now, leak 'Begin'. We can add it back to a freelist in
// BumpVectorContext.
Begin = NewElts;
- End = NewElts+CurSize;
- Capacity = Begin+NewCapacity;
+ End = NewElts + CurSize;
+ Capacity = Begin + NewCapacity;
}
} // namespace clang
diff --git a/clang/include/clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h b/clang/include/clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h
index bdfe3901c5b801..c3a1c1612b5168 100644
--- a/clang/include/clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h
+++ b/clang/include/clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h
@@ -29,8 +29,8 @@ class CheckerManager;
#undef CHECKER
#undef GET_CHECKERS
-} // end ento namespace
+} // namespace ento
-} // end clang namespace
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h b/clang/include/clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h
index 6243bbd5d53bcd..5b19925f3cf6a9 100644
--- a/clang/include/clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h
+++ b/clang/include/clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h
@@ -68,29 +68,40 @@ class MPIFunctionClassifier {
// point-to-point functions
IdentifierInfo *IdentInfo_MPI_Send = nullptr, *IdentInfo_MPI_Isend = nullptr,
- *IdentInfo_MPI_Ssend = nullptr, *IdentInfo_MPI_Issend = nullptr,
- *IdentInfo_MPI_Bsend = nullptr, *IdentInfo_MPI_Ibsend = nullptr,
- *IdentInfo_MPI_Rsend = nullptr, *IdentInfo_MPI_Irsend = nullptr,
- *IdentInfo_MPI_Recv = nullptr, *IdentInfo_MPI_Irecv = nullptr;
+ *IdentInfo_MPI_Ssend = nullptr,
+ *IdentInfo_MPI_Issend = nullptr,
+ *IdentInfo_MPI_Bsend = nullptr,
+ *IdentInfo_MPI_Ibsend = nullptr,
+ *IdentInfo_MPI_Rsend = nullptr,
+ *IdentInfo_MPI_Irsend = nullptr, *IdentInfo_MPI_Recv = nullptr,
+ *IdentInfo_MPI_Irecv = nullptr;
// collective functions
IdentifierInfo *IdentInfo_MPI_Scatter = nullptr,
- *IdentInfo_MPI_Iscatter = nullptr, *IdentInfo_MPI_Gather = nullptr,
- *IdentInfo_MPI_Igather = nullptr, *IdentInfo_MPI_Allgather = nullptr,
- *IdentInfo_MPI_Iallgather = nullptr, *IdentInfo_MPI_Bcast = nullptr,
- *IdentInfo_MPI_Ibcast = nullptr, *IdentInfo_MPI_Reduce = nullptr,
- *IdentInfo_MPI_Ireduce = nullptr, *IdentInfo_MPI_Allreduce = nullptr,
- *IdentInfo_MPI_Iallreduce = nullptr, *IdentInfo_MPI_Alltoall = nullptr,
- *IdentInfo_MPI_Ialltoall = nullptr, *IdentInfo_MPI_Barrier = nullptr;
+ *IdentInfo_MPI_Iscatter = nullptr,
+ *IdentInfo_MPI_Gather = nullptr,
+ *IdentInfo_MPI_Igather = nullptr,
+ *IdentInfo_MPI_Allgather = nullptr,
+ *IdentInfo_MPI_Iallgather = nullptr,
+ *IdentInfo_MPI_Bcast = nullptr,
+ *IdentInfo_MPI_Ibcast = nullptr,
+ *IdentInfo_MPI_Reduce = nullptr,
+ *IdentInfo_MPI_Ireduce = nullptr,
+ *IdentInfo_MPI_Allreduce = nullptr,
+ *IdentInfo_MPI_Iallreduce = nullptr,
+ *IdentInfo_MPI_Alltoall = nullptr,
+ *IdentInfo_MPI_Ialltoall = nullptr,
+ *IdentInfo_MPI_Barrier = nullptr;
// additional functions
IdentifierInfo *IdentInfo_MPI_Comm_rank = nullptr,
- *IdentInfo_MPI_Comm_size = nullptr, *IdentInfo_MPI_Wait = nullptr,
- *IdentInfo_MPI_Waitall = nullptr;
+ *IdentInfo_MPI_Comm_size = nullptr,
+ *IdentInfo_MPI_Wait = nullptr,
+ *IdentInfo_MPI_Waitall = nullptr;
};
-} // end of namespace: mpi
-} // end of namespace: ento
-} // end of namespace: clang
+} // namespace mpi
+} // namespace ento
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Checkers/SValExplainer.h b/clang/include/clang/StaticAnalyzer/Checkers/SValExplainer.h
index 43a70f596a4da2..0305180064546f 100644
--- a/clang/include/clang/StaticAnalyzer/Checkers/SValExplainer.h
+++ b/clang/include/clang/StaticAnalyzer/Checkers/SValExplainer.h
@@ -57,13 +57,9 @@ class SValExplainer : public FullSValVisitor<SValExplainer, std::string> {
public:
SValExplainer(ASTContext &Ctx) : ACtx(Ctx) {}
- std::string VisitUnknownVal(UnknownVal V) {
- return "unknown value";
- }
+ std::string VisitUnknownVal(UnknownVal V) { return "unknown value"; }
- std::string VisitUndefinedVal(UndefinedVal V) {
- return "undefined value";
- }
+ std::string VisitUndefinedVal(UndefinedVal V) { return "undefined value"; }
std::string VisitMemRegionVal(loc::MemRegionVal V) {
const MemRegion *R = V.getRegion();
@@ -116,8 +112,8 @@ class SValExplainer : public FullSValVisitor<SValExplainer, std::string> {
}
std::string VisitSymbolDerived(const SymbolDerived *S) {
- return "value derived from (" + Visit(S->getParentSymbol()) +
- ") for " + Visit(S->getRegion());
+ return "value derived from (" + Visit(S->getParentSymbol()) + ") for " +
+ Visit(S->getRegion());
}
std::string VisitSymbolExtent(const SymbolExtent *S) {
@@ -143,8 +139,8 @@ class SValExplainer : public FullSValVisitor<SValExplainer, std::string> {
std::string VisitSymSymExpr(const SymSymExpr *S) {
return "(" + Visit(S->getLHS()) + ") " +
- std::string(BinaryOperator::getOpcodeStr(S->getOpcode())) +
- " (" + Visit(S->getRHS()) + ")";
+ std::string(BinaryOperator::getOpcodeStr(S->getOpcode())) + " (" +
+ Visit(S->getRHS()) + ")";
}
std::string VisitUnarySymExpr(const UnarySymExpr *S) {
@@ -162,8 +158,10 @@ class SValExplainer : public FullSValVisitor<SValExplainer, std::string> {
return "'this' object";
// Objective-C objects are not normal symbolic regions. At least,
// they're always on the heap.
- if (R->getSymbol()->getType()
- .getCanonicalType()->getAs<ObjCObjectPointerType>())
+ if (R->getSymbol()
+ ->getType()
+ .getCanonicalType()
+ ->getAs<ObjCObjectPointerType>())
return "object at " + Visit(R->getSymbol());
// Other heap-based symbolic regions are also special.
if (isa<HeapSpaceRegion>(R->getMemorySpace()))
@@ -277,8 +275,8 @@ class SValExplainer : public FullSValVisitor<SValExplainer, std::string> {
std::string Str;
llvm::raw_string_ostream OS(Str);
OS << V;
- return "a value unsupported by the explainer: (" +
- std::string(OS.str()) + ")";
+ return "a value unsupported by the explainer: (" + std::string(OS.str()) +
+ ")";
}
std::string VisitSymExpr(SymbolRef S) {
diff --git a/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h b/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h
index 276d11e80a5b21..80eb04e7d5f73e 100644
--- a/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h
+++ b/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h
@@ -35,7 +35,7 @@ class CheckerBase;
enum AnalysisConstraints {
#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) NAME##Model,
#include "clang/StaticAnalyzer/Core/Analyses.def"
-NumConstraints
+ NumConstraints
};
/// AnalysisDiagClients - Set of available diagnostic clients for rendering
@@ -43,22 +43,23 @@ NumConstraints
enum AnalysisDiagClients {
#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) PD_##NAME,
#include "clang/StaticAnalyzer/Core/Analyses.def"
-PD_NONE,
-NUM_ANALYSIS_DIAG_CLIENTS
+ PD_NONE,
+ NUM_ANALYSIS_DIAG_CLIENTS
};
/// AnalysisPurgeModes - Set of available strategies for dead symbol removal.
enum AnalysisPurgeMode {
#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) NAME,
#include "clang/StaticAnalyzer/Core/Analyses.def"
-NumPurgeModes
+ NumPurgeModes
};
-/// AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
+/// AnalysisInlineFunctionSelection - Set of inlining function selection
+/// heuristics.
enum AnalysisInliningMode {
#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) NAME,
#include "clang/StaticAnalyzer/Core/Analyses.def"
-NumInliningModes
+ NumInliningModes
};
/// Describes the different kinds of C++ member functions which can be
@@ -253,8 +254,7 @@ class AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {
SHALLOW_VAL, DEEP_VAL) \
ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, SHALLOW_VAL)
-#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
- TYPE NAME;
+#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) TYPE NAME;
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
#undef ANALYZER_OPTION
@@ -373,17 +373,14 @@ class AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {
bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K) const;
ento::PathDiagnosticConsumerOptions getDiagOpts() const {
- return {FullCompilerInvocation,
- ShouldDisplayMacroExpansions,
+ return {FullCompilerInvocation, ShouldDisplayMacroExpansions,
ShouldSerializeStats,
// The stable report filename option is deprecated because
// file names are now always stable. Now the old option acts as
// an alias to the new verbose filename option because this
// closely mimics the behavior under the old option.
ShouldWriteStableReportFilename || ShouldWriteVerboseReportFilename,
- AnalyzerWerror,
- ShouldApplyFixIts,
- ShouldDisplayCheckerNameForText};
+ AnalyzerWerror, ShouldApplyFixIts, ShouldDisplayCheckerNameForText};
}
};
diff --git a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h
index e762f7548e0b54..5ffb95e1385d37 100644
--- a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h
+++ b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h
@@ -109,9 +109,7 @@ class StackHintGeneratorForSymbol : public StackHintGenerator {
return Msg;
}
- virtual std::string getMessageForSymbolNotFound() {
- return Msg;
- }
+ virtual std::string getMessageForSymbolNotFound() { return Msg; }
};
/// This class provides an interface through which checkers can create
@@ -125,7 +123,7 @@ class BugReport {
friend class BugReporter;
Kind K;
- const BugType& BT;
+ const BugType &BT;
std::string ShortDescription;
std::string Description;
@@ -146,7 +144,7 @@ class BugReport {
Kind getKind() const { return K; }
- const BugType& getBugType() const { return BT; }
+ const BugType &getBugType() const { return BT; }
/// A verbose warning message that is appropriate for displaying next to
/// the source code that introduces the problem. The description should be
@@ -157,8 +155,8 @@ class BugReport {
StringRef getDescription() const { return Description; }
/// A short general warning message that is appropriate for displaying in
- /// the list of all reported bugs. It should describe what kind of bug is found
- /// but does not need to try to go into details of that specific bug.
+ /// the list of all reported bugs. It should describe what kind of bug is
+ /// found but does not need to try to go into details of that specific bug.
/// Grammatical conventions of getDescription() apply here as well.
StringRef getShortDescription(bool UseFallback = true) const {
if (ShortDescription.empty() && UseFallback)
@@ -220,15 +218,14 @@ class BugReport {
/// node will be used; add a single invalid range to specify absence of
/// ranges.
void addRange(SourceRange R) {
- assert((R.isValid() || Ranges.empty()) && "Invalid range can only be used "
- "to specify that the report does not have a range.");
+ assert((R.isValid() || Ranges.empty()) &&
+ "Invalid range can only be used "
+ "to specify that the report does not have a range.");
Ranges.push_back(R);
}
/// Get the SourceRanges associated with the report.
- virtual ArrayRef<SourceRange> getRanges() const {
- return Ranges;
- }
+ virtual ArrayRef<SourceRange> getRanges() const { return Ranges; }
/// Add a fix-it hint to the bug report.
///
@@ -237,15 +234,13 @@ class BugReport {
/// as conservative as possible because it is not uncommon for the user
/// to blindly apply all fixits to their project. Note that it is very hard
/// to produce a good fix-it hint for most path-sensitive warnings.
- void addFixItHint(const FixItHint &F) {
- Fixits.push_back(F);
- }
+ void addFixItHint(const FixItHint &F) { Fixits.push_back(F); }
llvm::ArrayRef<FixItHint> getFixits() const { return Fixits; }
/// Reports are uniqued to ensure that we do not emit multiple diagnostics
/// for each bug.
- virtual void Profile(llvm::FoldingSetNodeID& hash) const = 0;
+ virtual void Profile(llvm::FoldingSetNodeID &hash) const = 0;
};
class BasicBugReport : public BugReport {
@@ -265,17 +260,13 @@ class BasicBugReport : public BugReport {
return Location;
}
- const Decl *getDeclWithIssue() const override {
- return DeclWithIssue;
- }
+ const Decl *getDeclWithIssue() const override { return DeclWithIssue; }
PathDiagnosticLocation getUniqueingLocation() const override {
return getLocation();
}
- const Decl *getUniqueingDecl() const override {
- return getDeclWithIssue();
- }
+ const Decl *getUniqueingDecl() const override { return getDeclWithIssue(); }
/// Specifically set the Decl where an issue occurred. This isn't necessary
/// for BugReports that cover a path as it will be automatically inferred.
@@ -283,7 +274,7 @@ class BasicBugReport : public BugReport {
DeclWithIssue = declWithIssue;
}
- void Profile(llvm::FoldingSetNodeID& hash) const override;
+ void Profile(llvm::FoldingSetNodeID &hash) const override;
};
class PathSensitiveBugReport : public BugReport {
@@ -414,9 +405,7 @@ class PathSensitiveBugReport : public BugReport {
}
/// Get the declaration containing the uniqueing location.
- const Decl *getUniqueingDecl() const override {
- return UniqueingDecl;
- }
+ const Decl *getUniqueingDecl() const override { return UniqueingDecl; }
const Decl *getDeclWithIssue() const override;
@@ -465,9 +454,7 @@ class PathSensitiveBugReport : public BugReport {
///
/// Invalid reports are those that have been classified as likely false
/// positives after the fact.
- bool isValid() const {
- return Invalidations.empty();
- }
+ bool isValid() const { return Invalidations.empty(); }
/// Marks the current report as invalid, meaning that it is probably a false
/// positive and should not be reported to the user.
@@ -495,7 +482,7 @@ class PathSensitiveBugReport : public BugReport {
void addVisitor(std::unique_ptr<BugReporterVisitor> visitor);
template <class VisitorType, class... Args>
- void addVisitor(Args &&... ConstructorArgs) {
+ void addVisitor(Args &&...ConstructorArgs) {
addVisitor(
std::make_unique<VisitorType>(std::forward<Args>(ConstructorArgs)...));
}
@@ -527,9 +514,8 @@ class PathSensitiveBugReport : public BugReport {
/// Produce the hint for the given node. The node contains
/// information about the call for which the diagnostic can be generated.
- std::string
- getCallStackMessage(PathDiagnosticPieceRef Piece,
- const ExplodedNode *N) const {
+ std::string getCallStackMessage(PathDiagnosticPieceRef Piece,
+ const ExplodedNode *N) const {
auto I = StackHints.find(Piece);
if (I != StackHints.end())
return I->second->getMessage(N);
@@ -556,7 +542,7 @@ class BugReportEquivClass : public llvm::FoldingSetNode {
ArrayRef<std::unique_ptr<BugReport>> getReports() const { return Reports; }
- void Profile(llvm::FoldingSetNodeID& ID) const {
+ void Profile(llvm::FoldingSetNodeID &ID) const {
assert(!Reports.empty());
Reports.front()->Profile(ID);
}
@@ -570,7 +556,7 @@ class BugReporterData {
public:
virtual ~BugReporterData() = default;
- virtual ArrayRef<PathDiagnosticConsumer*> getPathDiagnosticConsumers() = 0;
+ virtual ArrayRef<PathDiagnosticConsumer *> getPathDiagnosticConsumers() = 0;
virtual ASTContext &getASTContext() = 0;
virtual SourceManager &getSourceManager() = 0;
virtual AnalyzerOptions &getAnalyzerOptions() = 0;
@@ -584,10 +570,10 @@ class BugReporterData {
/// The base class is used for generating path-insensitive
class BugReporter {
private:
- BugReporterData& D;
+ BugReporterData &D;
/// Generate and flush the diagnostics for the given bug report.
- void FlushReport(BugReportEquivClass& EQ);
+ void FlushReport(BugReportEquivClass &EQ);
/// The set of bug reports tracked by the BugReporter.
llvm::FoldingSet<BugReportEquivClass> EQClasses;
@@ -605,7 +591,7 @@ class BugReporter {
/// Generate and flush diagnostics for all bug reports.
void FlushReports();
- ArrayRef<PathDiagnosticConsumer*> getPathDiagnosticConsumers() {
+ ArrayRef<PathDiagnosticConsumer *> getPathDiagnosticConsumers() {
return D.getPathDiagnosticConsumers();
}
@@ -666,7 +652,7 @@ class BugReporter {
/// GRBugReporter is used for generating path-sensitive reports.
class PathSensitiveBugReporter final : public BugReporter {
- ExprEngine& Eng;
+ ExprEngine &Eng;
BugReport *findReportInEquivalenceClass(
BugReportEquivClass &eqClass,
@@ -677,8 +663,9 @@ class PathSensitiveBugReporter final : public BugReporter {
generateDiagnosticForConsumerMap(BugReport *exampleReport,
ArrayRef<PathDiagnosticConsumer *> consumers,
ArrayRef<BugReport *> bugReports) override;
+
public:
- PathSensitiveBugReporter(BugReporterData& d, ExprEngine& eng)
+ PathSensitiveBugReporter(BugReporterData &d, ExprEngine &eng)
: BugReporter(d), Eng(eng) {}
/// getGraph - Get the exploded graph created by the analysis engine
@@ -694,14 +681,13 @@ class PathSensitiveBugReporter final : public BugReporter {
/// \return A mapping from consumers to the corresponding diagnostics.
/// Iterates through the bug reports within a single equivalence class,
/// stops at a first non-invalidated report.
- std::unique_ptr<DiagnosticForConsumerMapTy> generatePathDiagnostics(
- ArrayRef<PathDiagnosticConsumer *> consumers,
- ArrayRef<PathSensitiveBugReport *> &bugReports);
+ std::unique_ptr<DiagnosticForConsumerMapTy>
+ generatePathDiagnostics(ArrayRef<PathDiagnosticConsumer *> consumers,
+ ArrayRef<PathSensitiveBugReport *> &bugReports);
void emitReport(std::unique_ptr<BugReport> R) override;
};
-
class BugReporterContext {
PathSensitiveBugReporter &BR;
@@ -712,17 +698,13 @@ class BugReporterContext {
virtual ~BugReporterContext() = default;
- PathSensitiveBugReporter& getBugReporter() { return BR; }
+ PathSensitiveBugReporter &getBugReporter() { return BR; }
- ProgramStateManager& getStateManager() const {
- return BR.getStateManager();
- }
+ ProgramStateManager &getStateManager() const { return BR.getStateManager(); }
- ASTContext &getASTContext() const {
- return BR.getContext();
- }
+ ASTContext &getASTContext() const { return BR.getContext(); }
- const SourceManager& getSourceManager() const {
+ const SourceManager &getSourceManager() const {
return BR.getSourceManager();
}
@@ -749,7 +731,7 @@ class DataTag : public ProgramPointTag {
public:
template <class DataTagType, class... Args>
- const DataTagType *make(Args &&... ConstructorArgs) {
+ const DataTagType *make(Args &&...ConstructorArgs) {
// We cannot use std::make_unique because we cannot access the private
// constructor from inside it.
Tags.emplace_back(
diff --git a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h
index d9b3d9352d3224..653d4632f20c60 100644
--- a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h
+++ b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h
@@ -280,7 +280,7 @@ class Tracker : public llvm::RefCountedBase<Tracker> {
///
/// See other overloads for explanation.
template <class HandlerType, class... Args>
- void addHighPriorityHandler(Args &&... ConstructorArgs) {
+ void addHighPriorityHandler(Args &&...ConstructorArgs) {
addHighPriorityHandler(std::make_unique<HandlerType>(
*this, std::forward<Args>(ConstructorArgs)...));
}
@@ -289,7 +289,7 @@ class Tracker : public llvm::RefCountedBase<Tracker> {
///
/// See other overloads for explanation.
template <class HandlerType, class... Args>
- void addLowPriorityHandler(Args &&... ConstructorArgs) {
+ void addLowPriorityHandler(Args &&...ConstructorArgs) {
addLowPriorityHandler(std::make_unique<HandlerType>(
*this, std::forward<Args>(ConstructorArgs)...));
}
diff --git a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h
index e50afd6d0da7e5..3fd3a5f5e6510c 100644
--- a/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h
+++ b/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h
@@ -66,5 +66,5 @@ class BugType {
} // namespace ento
-} // end clang namespace
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Core/Checker.h b/clang/include/clang/StaticAnalyzer/Core/Checker.h
index 2ec54a837c42c9..1212816ed952a6 100644
--- a/clang/include/clang/StaticAnalyzer/Core/Checker.h
+++ b/clang/include/clang/StaticAnalyzer/Core/Checker.h
@@ -21,33 +21,31 @@
namespace clang {
namespace ento {
- class BugReporter;
+class BugReporter;
namespace check {
-template <typename DECL>
-class ASTDecl {
+template <typename DECL> class ASTDecl {
template <typename CHECKER>
- static void _checkDecl(void *checker, const Decl *D, AnalysisManager& mgr,
+ static void _checkDecl(void *checker, const Decl *D, AnalysisManager &mgr,
BugReporter &BR) {
((const CHECKER *)checker)->checkASTDecl(cast<DECL>(D), mgr, BR);
}
- static bool _handlesDecl(const Decl *D) {
- return isa<DECL>(D);
- }
+ static bool _handlesDecl(const Decl *D) { return isa<DECL>(D); }
+
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForDecl(CheckerManager::CheckDeclFunc(checker,
- _checkDecl<CHECKER>),
- _handlesDecl);
+ mgr._registerForDecl(
+ CheckerManager::CheckDeclFunc(checker, _checkDecl<CHECKER>),
+ _handlesDecl);
}
};
class ASTCodeBody {
template <typename CHECKER>
- static void _checkBody(void *checker, const Decl *D, AnalysisManager& mgr,
+ static void _checkBody(void *checker, const Decl *D, AnalysisManager &mgr,
BugReporter &BR) {
((const CHECKER *)checker)->checkASTCodeBody(D, mgr, BR);
}
@@ -55,64 +53,59 @@ class ASTCodeBody {
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForBody(CheckerManager::CheckDeclFunc(checker,
- _checkBody<CHECKER>));
+ mgr._registerForBody(
+ CheckerManager::CheckDeclFunc(checker, _checkBody<CHECKER>));
}
};
class EndOfTranslationUnit {
template <typename CHECKER>
- static void _checkEndOfTranslationUnit(void *checker,
- const TranslationUnitDecl *TU,
- AnalysisManager& mgr,
- BugReporter &BR) {
+ static void
+ _checkEndOfTranslationUnit(void *checker, const TranslationUnitDecl *TU,
+ AnalysisManager &mgr, BugReporter &BR) {
((const CHECKER *)checker)->checkEndOfTranslationUnit(TU, mgr, BR);
}
public:
template <typename CHECKER>
- static void _register(CHECKER *checker, CheckerManager &mgr){
+ static void _register(CHECKER *checker, CheckerManager &mgr) {
mgr._registerForEndOfTranslationUnit(
- CheckerManager::CheckEndOfTranslationUnit(checker,
- _checkEndOfTranslationUnit<CHECKER>));
+ CheckerManager::CheckEndOfTranslationUnit(
+ checker, _checkEndOfTranslationUnit<CHECKER>));
}
};
-template <typename STMT>
-class PreStmt {
+template <typename STMT> class PreStmt {
template <typename CHECKER>
static void _checkStmt(void *checker, const Stmt *S, CheckerContext &C) {
((const CHECKER *)checker)->checkPreStmt(cast<STMT>(S), C);
}
- static bool _handlesStmt(const Stmt *S) {
- return isa<STMT>(S);
- }
+ static bool _handlesStmt(const Stmt *S) { return isa<STMT>(S); }
+
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForPreStmt(CheckerManager::CheckStmtFunc(checker,
- _checkStmt<CHECKER>),
- _handlesStmt);
+ mgr._registerForPreStmt(
+ CheckerManager::CheckStmtFunc(checker, _checkStmt<CHECKER>),
+ _handlesStmt);
}
};
-template <typename STMT>
-class PostStmt {
+template <typename STMT> class PostStmt {
template <typename CHECKER>
static void _checkStmt(void *checker, const Stmt *S, CheckerContext &C) {
((const CHECKER *)checker)->checkPostStmt(cast<STMT>(S), C);
}
- static bool _handlesStmt(const Stmt *S) {
- return isa<STMT>(S);
- }
+ static bool _handlesStmt(const Stmt *S) { return isa<STMT>(S); }
+
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForPostStmt(CheckerManager::CheckStmtFunc(checker,
- _checkStmt<CHECKER>),
- _handlesStmt);
+ mgr._registerForPostStmt(
+ CheckerManager::CheckStmtFunc(checker, _checkStmt<CHECKER>),
+ _handlesStmt);
}
};
@@ -126,8 +119,8 @@ class PreObjCMessage {
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForPreObjCMessage(
- CheckerManager::CheckObjCMessageFunc(checker, _checkObjCMessage<CHECKER>));
+ mgr._registerForPreObjCMessage(CheckerManager::CheckObjCMessageFunc(
+ checker, _checkObjCMessage<CHECKER>));
}
};
@@ -141,8 +134,8 @@ class ObjCMessageNil {
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForObjCMessageNil(
- CheckerManager::CheckObjCMessageFunc(checker, _checkObjCMessage<CHECKER>));
+ mgr._registerForObjCMessageNil(CheckerManager::CheckObjCMessageFunc(
+ checker, _checkObjCMessage<CHECKER>));
}
};
@@ -156,8 +149,8 @@ class PostObjCMessage {
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForPostObjCMessage(
- CheckerManager::CheckObjCMessageFunc(checker, _checkObjCMessage<CHECKER>));
+ mgr._registerForPostObjCMessage(CheckerManager::CheckObjCMessageFunc(
+ checker, _checkObjCMessage<CHECKER>));
}
};
@@ -172,7 +165,7 @@ class PreCall {
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
mgr._registerForPreCall(
- CheckerManager::CheckCallFunc(checker, _checkCall<CHECKER>));
+ CheckerManager::CheckCallFunc(checker, _checkCall<CHECKER>));
}
};
@@ -187,7 +180,7 @@ class PostCall {
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
mgr._registerForPostCall(
- CheckerManager::CheckCallFunc(checker, _checkCall<CHECKER>));
+ CheckerManager::CheckCallFunc(checker, _checkCall<CHECKER>));
}
};
@@ -202,7 +195,7 @@ class Location {
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
mgr._registerForLocation(
- CheckerManager::CheckLocationFunc(checker, _checkLocation<CHECKER>));
+ CheckerManager::CheckLocationFunc(checker, _checkLocation<CHECKER>));
}
};
@@ -217,7 +210,7 @@ class Bind {
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
mgr._registerForBind(
- CheckerManager::CheckBindFunc(checker, _checkBind<CHECKER>));
+ CheckerManager::CheckBindFunc(checker, _checkBind<CHECKER>));
}
};
@@ -231,8 +224,8 @@ class EndAnalysis {
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForEndAnalysis(
- CheckerManager::CheckEndAnalysisFunc(checker, _checkEndAnalysis<CHECKER>));
+ mgr._registerForEndAnalysis(CheckerManager::CheckEndAnalysisFunc(
+ checker, _checkEndAnalysis<CHECKER>));
}
};
@@ -260,24 +253,23 @@ class EndFunction {
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForEndFunction(
- CheckerManager::CheckEndFunctionFunc(checker, _checkEndFunction<CHECKER>));
+ mgr._registerForEndFunction(CheckerManager::CheckEndFunctionFunc(
+ checker, _checkEndFunction<CHECKER>));
}
};
class BranchCondition {
template <typename CHECKER>
static void _checkBranchCondition(void *checker, const Stmt *Condition,
- CheckerContext & C) {
+ CheckerContext &C) {
((const CHECKER *)checker)->checkBranchCondition(Condition, C);
}
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForBranchCondition(
- CheckerManager::CheckBranchConditionFunc(checker,
- _checkBranchCondition<CHECKER>));
+ mgr._registerForBranchCondition(CheckerManager::CheckBranchConditionFunc(
+ checker, _checkBranchCondition<CHECKER>));
}
};
@@ -291,9 +283,8 @@ class NewAllocator {
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForNewAllocator(
- CheckerManager::CheckNewAllocatorFunc(checker,
- _checkNewAllocator<CHECKER>));
+ mgr._registerForNewAllocator(CheckerManager::CheckNewAllocatorFunc(
+ checker, _checkNewAllocator<CHECKER>));
}
};
@@ -307,65 +298,58 @@ class LiveSymbols {
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForLiveSymbols(
- CheckerManager::CheckLiveSymbolsFunc(checker, _checkLiveSymbols<CHECKER>));
+ mgr._registerForLiveSymbols(CheckerManager::CheckLiveSymbolsFunc(
+ checker, _checkLiveSymbols<CHECKER>));
}
};
class DeadSymbols {
template <typename CHECKER>
- static void _checkDeadSymbols(void *checker,
- SymbolReaper &SR, CheckerContext &C) {
+ static void _checkDeadSymbols(void *checker, SymbolReaper &SR,
+ CheckerContext &C) {
((const CHECKER *)checker)->checkDeadSymbols(SR, C);
}
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForDeadSymbols(
- CheckerManager::CheckDeadSymbolsFunc(checker, _checkDeadSymbols<CHECKER>));
+ mgr._registerForDeadSymbols(CheckerManager::CheckDeadSymbolsFunc(
+ checker, _checkDeadSymbols<CHECKER>));
}
};
class RegionChanges {
template <typename CHECKER>
static ProgramStateRef
- _checkRegionChanges(void *checker,
- ProgramStateRef state,
+ _checkRegionChanges(void *checker, ProgramStateRef state,
const InvalidatedSymbols *invalidated,
ArrayRef<const MemRegion *> Explicits,
ArrayRef<const MemRegion *> Regions,
- const LocationContext *LCtx,
- const CallEvent *Call) {
- return ((const CHECKER *) checker)->checkRegionChanges(state, invalidated,
- Explicits, Regions,
- LCtx, Call);
+ const LocationContext *LCtx, const CallEvent *Call) {
+ return ((const CHECKER *)checker)
+ ->checkRegionChanges(state, invalidated, Explicits, Regions, LCtx,
+ Call);
}
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForRegionChanges(
- CheckerManager::CheckRegionChangesFunc(checker,
- _checkRegionChanges<CHECKER>));
+ mgr._registerForRegionChanges(CheckerManager::CheckRegionChangesFunc(
+ checker, _checkRegionChanges<CHECKER>));
}
};
class PointerEscape {
template <typename CHECKER>
static ProgramStateRef
- _checkPointerEscape(void *Checker,
- ProgramStateRef State,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind,
- RegionAndSymbolInvalidationTraits *ETraits) {
+ _checkPointerEscape(void *Checker, ProgramStateRef State,
+ const InvalidatedSymbols &Escaped, const CallEvent *Call,
+ PointerEscapeKind Kind,
+ RegionAndSymbolInvalidationTraits *ETraits) {
if (!ETraits)
- return ((const CHECKER *)Checker)->checkPointerEscape(State,
- Escaped,
- Call,
- Kind);
+ return ((const CHECKER *)Checker)
+ ->checkPointerEscape(State, Escaped, Call, Kind);
InvalidatedSymbols RegularEscape;
for (SymbolRef Sym : Escaped)
@@ -378,30 +362,25 @@ class PointerEscape {
if (RegularEscape.empty())
return State;
- return ((const CHECKER *)Checker)->checkPointerEscape(State,
- RegularEscape,
- Call,
- Kind);
+ return ((const CHECKER *)Checker)
+ ->checkPointerEscape(State, RegularEscape, Call, Kind);
}
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForPointerEscape(
- CheckerManager::CheckPointerEscapeFunc(checker,
- _checkPointerEscape<CHECKER>));
+ mgr._registerForPointerEscape(CheckerManager::CheckPointerEscapeFunc(
+ checker, _checkPointerEscape<CHECKER>));
}
};
class ConstPointerEscape {
template <typename CHECKER>
static ProgramStateRef
- _checkConstPointerEscape(void *Checker,
- ProgramStateRef State,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind,
- RegionAndSymbolInvalidationTraits *ETraits) {
+ _checkConstPointerEscape(void *Checker, ProgramStateRef State,
+ const InvalidatedSymbols &Escaped,
+ const CallEvent *Call, PointerEscapeKind Kind,
+ RegionAndSymbolInvalidationTraits *ETraits) {
if (!ETraits)
return State;
@@ -418,37 +397,33 @@ class ConstPointerEscape {
if (ConstEscape.empty())
return State;
- return ((const CHECKER *)Checker)->checkConstPointerEscape(State,
- ConstEscape,
- Call,
- Kind);
+ return ((const CHECKER *)Checker)
+ ->checkConstPointerEscape(State, ConstEscape, Call, Kind);
}
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
- mgr._registerForPointerEscape(
- CheckerManager::CheckPointerEscapeFunc(checker,
- _checkConstPointerEscape<CHECKER>));
+ mgr._registerForPointerEscape(CheckerManager::CheckPointerEscapeFunc(
+ checker, _checkConstPointerEscape<CHECKER>));
}
};
-
-template <typename EVENT>
-class Event {
+template <typename EVENT> class Event {
template <typename CHECKER>
static void _checkEvent(void *checker, const void *event) {
((const CHECKER *)checker)->checkEvent(*(const EVENT *)event);
}
+
public:
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
mgr._registerListenerForEvent<EVENT>(
- CheckerManager::CheckEventFunc(checker, _checkEvent<CHECKER>));
+ CheckerManager::CheckEventFunc(checker, _checkEvent<CHECKER>));
}
};
-} // end check namespace
+} // namespace check
namespace eval {
@@ -463,7 +438,7 @@ class Assume {
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
mgr._registerForEvalAssume(
- CheckerManager::EvalAssumeFunc(checker, _evalAssume<CHECKER>));
+ CheckerManager::EvalAssumeFunc(checker, _evalAssume<CHECKER>));
}
};
@@ -478,11 +453,11 @@ class Call {
template <typename CHECKER>
static void _register(CHECKER *checker, CheckerManager &mgr) {
mgr._registerForEvalCall(
- CheckerManager::EvalCallFunc(checker, _evalCall<CHECKER>));
+ CheckerManager::EvalCallFunc(checker, _evalCall<CHECKER>));
}
};
-} // end eval namespace
+} // namespace eval
class CheckerBase : public ProgramPointTag {
CheckerNameRef Name;
@@ -494,11 +469,11 @@ class CheckerBase : public ProgramPointTag {
/// See CheckerManager::runCheckersForPrintState.
virtual void printState(raw_ostream &Out, ProgramStateRef State,
- const char *NL, const char *Sep) const { }
+ const char *NL, const char *Sep) const {}
};
/// Dump checker name to stream.
-raw_ostream& operator<<(raw_ostream &Out, const CheckerBase &Checker);
+raw_ostream &operator<<(raw_ostream &Out, const CheckerBase &Checker);
/// Tag that can use a checker name as a message provider
/// (see SimpleProgramPointTag).
@@ -527,9 +502,9 @@ class Checker<CHECK1> : public CHECK1, public CheckerBase {
}
};
-template <typename EVENT>
-class EventDispatcher {
+template <typename EVENT> class EventDispatcher {
CheckerManager *Mgr = nullptr;
+
public:
EventDispatcher() = default;
@@ -539,9 +514,7 @@ class EventDispatcher {
static_cast<EventDispatcher<EVENT> *>(checker)->Mgr = &mgr;
}
- void dispatchEvent(const EVENT &event) const {
- Mgr->_dispatchEvent(event);
- }
+ void dispatchEvent(const EVENT &event) const { Mgr->_dispatchEvent(event); }
};
/// We dereferenced a location that may be null.
@@ -558,8 +531,8 @@ struct ImplicitNullDerefEvent {
static int Tag;
};
-} // end ento namespace
+} // namespace ento
-} // end clang namespace
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h b/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h
index a45ba1bc573e1e..3e22a3b4ec7d58 100644
--- a/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h
@@ -57,8 +57,7 @@ class SymbolReaper;
template <typename T> class CheckerFn;
-template <typename RET, typename... Ps>
-class CheckerFn<RET(Ps...)> {
+template <typename RET, typename... Ps> class CheckerFn<RET(Ps...)> {
using Func = RET (*)(void *, Ps...);
Func Fn;
@@ -68,9 +67,7 @@ class CheckerFn<RET(Ps...)> {
CheckerFn(CheckerBase *checker, Func fn) : Fn(fn), Checker(checker) {}
- RET operator()(Ps... ps) const {
- return Fn(Checker, ps...);
- }
+ RET operator()(Ps... ps) const { return Fn(Checker, ps...); }
};
/// Describes the different reasons a pointer escapes
@@ -88,7 +85,6 @@ enum PointerEscapeKind {
/// argument to a function.
PSK_IndirectEscapeOnCall,
-
/// Escape for a new symbol that was generated into a region
/// that the analyzer cannot follow during a conservative call.
PSK_EscapeOutParameters,
@@ -117,11 +113,7 @@ class CheckerNameRef {
operator StringRef() const { return Name; }
};
-enum class ObjCMessageVisitKind {
- Pre,
- Post,
- MessageNil
-};
+enum class ObjCMessageVisitKind { Pre, Post, MessageNil };
class CheckerManager {
ASTContext *Context = nullptr;
@@ -189,11 +181,11 @@ class CheckerManager {
using CheckerRef = CheckerBase *;
using CheckerTag = const void *;
- using CheckerDtor = CheckerFn<void ()>;
+ using CheckerDtor = CheckerFn<void()>;
-//===----------------------------------------------------------------------===//
-// Checker registration.
-//===----------------------------------------------------------------------===//
+ //===----------------------------------------------------------------------===//
+ // Checker registration.
+ //===----------------------------------------------------------------------===//
/// Used to register checkers.
/// All arguments are automatically passed through to the checker
@@ -201,7 +193,7 @@ class CheckerManager {
///
/// \returns a pointer to the checker object.
template <typename CHECKER, typename... AT>
- CHECKER *registerChecker(AT &&... Args) {
+ CHECKER *registerChecker(AT &&...Args) {
CheckerTag tag = getTag<CHECKER>();
CheckerRef &ref = CheckerTags[tag];
assert(!ref && "Checker already registered, use getChecker!");
@@ -214,8 +206,7 @@ class CheckerManager {
return checker;
}
- template <typename CHECKER>
- CHECKER *getChecker() {
+ template <typename CHECKER> CHECKER *getChecker() {
CheckerTag tag = getTag<CHECKER>();
assert(CheckerTags.count(tag) != 0 &&
"Requested checker is not registered! Maybe you should add it as a "
@@ -223,21 +214,21 @@ class CheckerManager {
return static_cast<CHECKER *>(CheckerTags[tag]);
}
-//===----------------------------------------------------------------------===//
-// Functions for running checkers for AST traversing.
-//===----------------------------------------------------------------------===//
+ //===----------------------------------------------------------------------===//
+ // Functions for running checkers for AST traversing.
+ //===----------------------------------------------------------------------===//
/// Run checkers handling Decls.
- void runCheckersOnASTDecl(const Decl *D, AnalysisManager& mgr,
+ void runCheckersOnASTDecl(const Decl *D, AnalysisManager &mgr,
BugReporter &BR);
/// Run checkers handling Decls containing a Stmt body.
- void runCheckersOnASTBody(const Decl *D, AnalysisManager& mgr,
+ void runCheckersOnASTBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR);
-//===----------------------------------------------------------------------===//
-// Functions for running checkers for path-sensitive checking.
-//===----------------------------------------------------------------------===//
+ //===----------------------------------------------------------------------===//
+ // Functions for running checkers for path-sensitive checking.
+ //===----------------------------------------------------------------------===//
/// Run checkers for pre-visiting Stmts.
///
@@ -245,10 +236,8 @@ class CheckerManager {
/// not include the control flow statements such as IfStmt.
///
/// \sa runCheckersForBranchCondition, runCheckersForPostStmt
- void runCheckersForPreStmt(ExplodedNodeSet &Dst,
- const ExplodedNodeSet &Src,
- const Stmt *S,
- ExprEngine &Eng) {
+ void runCheckersForPreStmt(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src,
+ const Stmt *S, ExprEngine &Eng) {
runCheckersForStmt(/*isPreVisit=*/true, Dst, Src, S, Eng);
}
@@ -258,19 +247,16 @@ class CheckerManager {
/// not include the control flow statements such as IfStmt.
///
/// \sa runCheckersForBranchCondition, runCheckersForPreStmt
- void runCheckersForPostStmt(ExplodedNodeSet &Dst,
- const ExplodedNodeSet &Src,
- const Stmt *S,
- ExprEngine &Eng,
+ void runCheckersForPostStmt(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src,
+ const Stmt *S, ExprEngine &Eng,
bool wasInlined = false) {
runCheckersForStmt(/*isPreVisit=*/false, Dst, Src, S, Eng, wasInlined);
}
/// Run checkers for visiting Stmts.
- void runCheckersForStmt(bool isPreVisit,
- ExplodedNodeSet &Dst, const ExplodedNodeSet &Src,
- const Stmt *S, ExprEngine &Eng,
- bool wasInlined = false);
+ void runCheckersForStmt(bool isPreVisit, ExplodedNodeSet &Dst,
+ const ExplodedNodeSet &Src, const Stmt *S,
+ ExprEngine &Eng, bool wasInlined = false);
/// Run checkers for pre-visiting obj-c messages.
void runCheckersForPreObjCMessage(ExplodedNodeSet &Dst,
@@ -283,8 +269,7 @@ class CheckerManager {
/// Run checkers for post-visiting obj-c messages.
void runCheckersForPostObjCMessage(ExplodedNodeSet &Dst,
const ExplodedNodeSet &Src,
- const ObjCMethodCall &msg,
- ExprEngine &Eng,
+ const ObjCMethodCall &msg, ExprEngine &Eng,
bool wasInlined = false) {
runCheckersForObjCMessage(ObjCMessageVisitKind::Post, Dst, Src, msg, Eng,
wasInlined);
@@ -327,36 +312,26 @@ class CheckerManager {
bool wasInlined = false);
/// Run checkers for load/store of a location.
- void runCheckersForLocation(ExplodedNodeSet &Dst,
- const ExplodedNodeSet &Src,
- SVal location,
- bool isLoad,
- const Stmt *NodeEx,
- const Stmt *BoundEx,
- ExprEngine &Eng);
+ void runCheckersForLocation(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src,
+ SVal location, bool isLoad, const Stmt *NodeEx,
+ const Stmt *BoundEx, ExprEngine &Eng);
/// Run checkers for binding of a value to a location.
- void runCheckersForBind(ExplodedNodeSet &Dst,
- const ExplodedNodeSet &Src,
- SVal location, SVal val,
- const Stmt *S, ExprEngine &Eng,
- const ProgramPoint &PP);
+ void runCheckersForBind(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src,
+ SVal location, SVal val, const Stmt *S,
+ ExprEngine &Eng, const ProgramPoint &PP);
/// Run checkers for end of analysis.
void runCheckersForEndAnalysis(ExplodedGraph &G, BugReporter &BR,
ExprEngine &Eng);
/// Run checkers on beginning of function.
- void runCheckersForBeginFunction(ExplodedNodeSet &Dst,
- const BlockEdge &L,
- ExplodedNode *Pred,
- ExprEngine &Eng);
+ void runCheckersForBeginFunction(ExplodedNodeSet &Dst, const BlockEdge &L,
+ ExplodedNode *Pred, ExprEngine &Eng);
/// Run checkers on end of function.
- void runCheckersForEndFunction(NodeBuilderContext &BC,
- ExplodedNodeSet &Dst,
- ExplodedNode *Pred,
- ExprEngine &Eng,
+ void runCheckersForEndFunction(NodeBuilderContext &BC, ExplodedNodeSet &Dst,
+ ExplodedNode *Pred, ExprEngine &Eng,
const ReturnStmt *RS);
/// Run checkers for branch condition.
@@ -385,8 +360,7 @@ class CheckerManager {
void runCheckersForDeadSymbols(ExplodedNodeSet &Dst,
const ExplodedNodeSet &Src,
SymbolReaper &SymReaper, const Stmt *S,
- ExprEngine &Eng,
- ProgramPoint::Kind K);
+ ExprEngine &Eng, ProgramPoint::Kind K);
/// Run checkers for region changes.
///
@@ -399,13 +373,11 @@ class CheckerManager {
/// i.e. all regions that may have been touched by this change.
/// \param Call The call expression wrapper if the regions are invalidated
/// by a call.
- ProgramStateRef
- runCheckersForRegionChanges(ProgramStateRef state,
- const InvalidatedSymbols *invalidated,
- ArrayRef<const MemRegion *> ExplicitRegions,
- ArrayRef<const MemRegion *> Regions,
- const LocationContext *LCtx,
- const CallEvent *Call);
+ ProgramStateRef runCheckersForRegionChanges(
+ ProgramStateRef state, const InvalidatedSymbols *invalidated,
+ ArrayRef<const MemRegion *> ExplicitRegions,
+ ArrayRef<const MemRegion *> Regions, const LocationContext *LCtx,
+ const CallEvent *Call);
/// Run checkers when pointers escape.
///
@@ -425,13 +397,12 @@ class CheckerManager {
ProgramStateRef
runCheckersForPointerEscape(ProgramStateRef State,
const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind,
+ const CallEvent *Call, PointerEscapeKind Kind,
RegionAndSymbolInvalidationTraits *ITraits);
/// Run checkers for handling assumptions on symbolic values.
- ProgramStateRef runCheckersForEvalAssume(ProgramStateRef state,
- SVal Cond, bool Assumption);
+ ProgramStateRef runCheckersForEvalAssume(ProgramStateRef state, SVal Cond,
+ bool Assumption);
/// Run checkers for evaluating a call.
///
@@ -442,8 +413,7 @@ class CheckerManager {
/// Run checkers for the entire Translation Unit.
void runCheckersOnEndOfTranslationUnit(const TranslationUnitDecl *TU,
- AnalysisManager &mgr,
- BugReporter &BR);
+ AnalysisManager &mgr, BugReporter &BR);
/// Run checkers for debug-printing a ProgramState.
///
@@ -468,7 +438,7 @@ class CheckerManager {
// these directly.
using CheckDeclFunc =
- CheckerFn<void (const Decl *, AnalysisManager&, BugReporter &)>;
+ CheckerFn<void(const Decl *, AnalysisManager &, BugReporter &)>;
using HandlesDeclFunc = bool (*)(const Decl *D);
@@ -476,17 +446,16 @@ class CheckerManager {
void _registerForBody(CheckDeclFunc checkfn);
-//===----------------------------------------------------------------------===//
-// Internal registration functions for path-sensitive checking.
-//===----------------------------------------------------------------------===//
+ //===----------------------------------------------------------------------===//
+ // Internal registration functions for path-sensitive checking.
+ //===----------------------------------------------------------------------===//
- using CheckStmtFunc = CheckerFn<void (const Stmt *, CheckerContext &)>;
+ using CheckStmtFunc = CheckerFn<void(const Stmt *, CheckerContext &)>;
using CheckObjCMessageFunc =
- CheckerFn<void (const ObjCMethodCall &, CheckerContext &)>;
+ CheckerFn<void(const ObjCMethodCall &, CheckerContext &)>;
- using CheckCallFunc =
- CheckerFn<void (const CallEvent &, CheckerContext &)>;
+ using CheckCallFunc = CheckerFn<void(const CallEvent &, CheckerContext &)>;
using CheckLocationFunc = CheckerFn<void(SVal location, bool isLoad,
const Stmt *S, CheckerContext &)>;
@@ -495,53 +464,46 @@ class CheckerManager {
CheckerFn<void(SVal location, SVal val, const Stmt *S, CheckerContext &)>;
using CheckEndAnalysisFunc =
- CheckerFn<void (ExplodedGraph &, BugReporter &, ExprEngine &)>;
+ CheckerFn<void(ExplodedGraph &, BugReporter &, ExprEngine &)>;
- using CheckBeginFunctionFunc = CheckerFn<void (CheckerContext &)>;
+ using CheckBeginFunctionFunc = CheckerFn<void(CheckerContext &)>;
using CheckEndFunctionFunc =
- CheckerFn<void (const ReturnStmt *, CheckerContext &)>;
+ CheckerFn<void(const ReturnStmt *, CheckerContext &)>;
using CheckBranchConditionFunc =
- CheckerFn<void (const Stmt *, CheckerContext &)>;
+ CheckerFn<void(const Stmt *, CheckerContext &)>;
using CheckNewAllocatorFunc =
CheckerFn<void(const CXXAllocatorCall &Call, CheckerContext &)>;
using CheckDeadSymbolsFunc =
- CheckerFn<void (SymbolReaper &, CheckerContext &)>;
+ CheckerFn<void(SymbolReaper &, CheckerContext &)>;
- using CheckLiveSymbolsFunc = CheckerFn<void (ProgramStateRef,SymbolReaper &)>;
+ using CheckLiveSymbolsFunc = CheckerFn<void(ProgramStateRef, SymbolReaper &)>;
- using CheckRegionChangesFunc =
- CheckerFn<ProgramStateRef (ProgramStateRef,
- const InvalidatedSymbols *symbols,
- ArrayRef<const MemRegion *> ExplicitRegions,
- ArrayRef<const MemRegion *> Regions,
- const LocationContext *LCtx,
- const CallEvent *Call)>;
+ using CheckRegionChangesFunc = CheckerFn<ProgramStateRef(
+ ProgramStateRef, const InvalidatedSymbols *symbols,
+ ArrayRef<const MemRegion *> ExplicitRegions,
+ ArrayRef<const MemRegion *> Regions, const LocationContext *LCtx,
+ const CallEvent *Call)>;
- using CheckPointerEscapeFunc =
- CheckerFn<ProgramStateRef (ProgramStateRef,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call, PointerEscapeKind Kind,
- RegionAndSymbolInvalidationTraits *ITraits)>;
+ using CheckPointerEscapeFunc = CheckerFn<ProgramStateRef(
+ ProgramStateRef, const InvalidatedSymbols &Escaped, const CallEvent *Call,
+ PointerEscapeKind Kind, RegionAndSymbolInvalidationTraits *ITraits)>;
using EvalAssumeFunc =
CheckerFn<ProgramStateRef(ProgramStateRef, SVal cond, bool assumption)>;
- using EvalCallFunc = CheckerFn<bool (const CallEvent &, CheckerContext &)>;
+ using EvalCallFunc = CheckerFn<bool(const CallEvent &, CheckerContext &)>;
- using CheckEndOfTranslationUnit =
- CheckerFn<void (const TranslationUnitDecl *, AnalysisManager &,
- BugReporter &)>;
+ using CheckEndOfTranslationUnit = CheckerFn<void(
+ const TranslationUnitDecl *, AnalysisManager &, BugReporter &)>;
using HandlesStmtFunc = bool (*)(const Stmt *D);
- void _registerForPreStmt(CheckStmtFunc checkfn,
- HandlesStmtFunc isForStmtFn);
- void _registerForPostStmt(CheckStmtFunc checkfn,
- HandlesStmtFunc isForStmtFn);
+ void _registerForPreStmt(CheckStmtFunc checkfn, HandlesStmtFunc isForStmtFn);
+ void _registerForPostStmt(CheckStmtFunc checkfn, HandlesStmtFunc isForStmtFn);
void _registerForPreObjCMessage(CheckObjCMessageFunc checkfn);
void _registerForPostObjCMessage(CheckObjCMessageFunc checkfn);
@@ -580,12 +542,12 @@ class CheckerManager {
void _registerForEndOfTranslationUnit(CheckEndOfTranslationUnit checkfn);
-//===----------------------------------------------------------------------===//
-// Internal registration functions for events.
-//===----------------------------------------------------------------------===//
+ //===----------------------------------------------------------------------===//
+ // Internal registration functions for events.
+ //===----------------------------------------------------------------------===//
using EventTag = void *;
- using CheckEventFunc = CheckerFn<void (const void *event)>;
+ using CheckEventFunc = CheckerFn<void(const void *event)>;
template <typename EVENT>
void _registerListenerForEvent(CheckEventFunc checkfn) {
@@ -593,14 +555,12 @@ class CheckerManager {
info.Checkers.push_back(checkfn);
}
- template <typename EVENT>
- void _registerDispatcherForEvent() {
+ template <typename EVENT> void _registerDispatcherForEvent() {
EventInfo &info = Events[&EVENT::Tag];
info.HasDispatcher = true;
}
- template <typename EVENT>
- void _dispatchEvent(const EVENT &event) const {
+ template <typename EVENT> void _dispatchEvent(const EVENT &event) const {
EventsTy::const_iterator I = Events.find(&EVENT::Tag);
if (I == Events.end())
return;
@@ -609,16 +569,19 @@ class CheckerManager {
Checker(&event);
}
-//===----------------------------------------------------------------------===//
-// Implementation details.
-//===----------------------------------------------------------------------===//
+ //===----------------------------------------------------------------------===//
+ // Implementation details.
+ //===----------------------------------------------------------------------===//
private:
- template <typename CHECKER>
- static void destruct(void *obj) { delete static_cast<CHECKER *>(obj); }
+ template <typename CHECKER> static void destruct(void *obj) {
+ delete static_cast<CHECKER *>(obj);
+ }
- template <typename T>
- static void *getTag() { static int tag; return &tag; }
+ template <typename T> static void *getTag() {
+ static int tag;
+ return &tag;
+ }
llvm::DenseMap<CheckerTag, CheckerRef> CheckerTags;
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h b/clang/include/clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h
index 2694aac478cd47..05f797a53f2b72 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h
@@ -1,4 +1,5 @@
-//===--- PathDiagnosticConsumers.h - Path Diagnostic Clients ------*- C++ -*-===//
+//===--- PathDiagnosticConsumers.h - Path Diagnostic Clients ------*- C++
+//-*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -30,7 +31,7 @@ class CrossTranslationUnitContext;
namespace ento {
class PathDiagnosticConsumer;
-typedef std::vector<PathDiagnosticConsumer*> PathDiagnosticConsumers;
+typedef std::vector<PathDiagnosticConsumer *> PathDiagnosticConsumers;
#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATEFN) \
void CREATEFN(PathDiagnosticConsumerOptions Diagopts, \
@@ -40,7 +41,7 @@ typedef std::vector<PathDiagnosticConsumer*> PathDiagnosticConsumers;
const MacroExpansionContext &MacroExpansions);
#include "clang/StaticAnalyzer/Core/Analyses.def"
-} // end 'ento' namespace
-} // end 'clang' namespace
+} // namespace ento
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h
index f1c50e721937bb..2b3627877c32e3 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h
@@ -25,7 +25,7 @@ class APSIntType {
: BitWidth(Width), IsUnsigned(Unsigned) {}
/* implicit */ APSIntType(const llvm::APSInt &Value)
- : BitWidth(Value.getBitWidth()), IsUnsigned(Value.isUnsigned()) {}
+ : BitWidth(Value.getBitWidth()), IsUnsigned(Value.isUnsigned()) {}
uint32_t getBitWidth() const { return BitWidth; }
bool isUnsigned() const { return IsUnsigned; }
@@ -102,7 +102,7 @@ class APSIntType {
}
};
-} // end ento namespace
-} // end clang namespace
+} // namespace ento
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h
index c76e9c0326afe7..344ebae082218c 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h
@@ -26,7 +26,7 @@ namespace clang {
class CodeInjector;
namespace ento {
- class CheckerManager;
+class CheckerManager;
class AnalysisManager : public BugReporterData {
virtual void anchor();
@@ -55,23 +55,17 @@ class AnalysisManager : public BugReporterData {
~AnalysisManager() override;
- void ClearContexts() {
- AnaCtxMgr.clear();
- }
+ void ClearContexts() { AnaCtxMgr.clear(); }
- AnalysisDeclContextManager& getAnalysisDeclContextManager() {
+ AnalysisDeclContextManager &getAnalysisDeclContextManager() {
return AnaCtxMgr;
}
Preprocessor &getPreprocessor() override { return PP; }
- StoreManagerCreator getStoreManagerCreator() {
- return CreateStoreMgr;
- }
+ StoreManagerCreator getStoreManagerCreator() { return CreateStoreMgr; }
- AnalyzerOptions& getAnalyzerOptions() override {
- return options;
- }
+ AnalyzerOptions &getAnalyzerOptions() override { return options; }
ConstraintManagerCreator getConstraintManagerCreator() {
return CreateConstraintMgr;
@@ -79,19 +73,15 @@ class AnalysisManager : public BugReporterData {
CheckerManager *getCheckerManager() const { return CheckerMgr; }
- ASTContext &getASTContext() override {
- return Ctx;
- }
+ ASTContext &getASTContext() override { return Ctx; }
SourceManager &getSourceManager() override {
return getASTContext().getSourceManager();
}
- const LangOptions &getLangOpts() const {
- return LangOpts;
- }
+ const LangOptions &getLangOpts() const { return LangOpts; }
- ArrayRef<PathDiagnosticConsumer*> getPathDiagnosticConsumers() override {
+ ArrayRef<PathDiagnosticConsumer *> getPathDiagnosticConsumers() override {
return PathConsumers;
}
@@ -101,16 +91,11 @@ class AnalysisManager : public BugReporterData {
return options.visualizeExplodedGraphWithGraphViz;
}
- bool shouldInlineCall() const {
- return options.getIPAMode() != IPAK_None;
- }
+ bool shouldInlineCall() const { return options.getIPAMode() != IPAK_None; }
- CFG *getCFG(Decl const *D) {
- return AnaCtxMgr.getContext(D)->getCFG();
- }
+ CFG *getCFG(Decl const *D) { return AnaCtxMgr.getContext(D)->getCFG(); }
- template <typename T>
- T *getAnalysis(Decl const *D) {
+ template <typename T> T *getAnalysis(Decl const *D) {
return AnaCtxMgr.getContext(D)->getAnalysis<T>();
}
@@ -153,8 +138,8 @@ class AnalysisManager : public BugReporterData {
}
};
-} // enAnaCtxMgrspace
+} // namespace ento
-} // end clang namespace
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h
index ec503b41b381a5..dfd43a528f0286 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BasicValueFactory.h
@@ -19,9 +19,9 @@
#include "clang/AST/Expr.h"
#include "clang/AST/Type.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/StoreRef.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/ImmutableList.h"
@@ -53,10 +53,10 @@ class CompoundValData : public llvm::FoldingSetNode {
QualType getType() const { return T; }
- static void Profile(llvm::FoldingSetNodeID& ID, QualType T,
+ static void Profile(llvm::FoldingSetNodeID &ID, QualType T,
llvm::ImmutableList<SVal> L);
- void Profile(llvm::FoldingSetNodeID& ID) { Profile(ID, T, L); }
+ void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, T, L); }
};
class LazyCompoundValData : public llvm::FoldingSetNode {
@@ -76,11 +76,10 @@ class LazyCompoundValData : public llvm::FoldingSetNode {
LLVM_ATTRIBUTE_RETURNS_NONNULL
const TypedValueRegion *getRegion() const { return region; }
- static void Profile(llvm::FoldingSetNodeID& ID,
- const StoreRef &store,
+ static void Profile(llvm::FoldingSetNodeID &ID, const StoreRef &store,
const TypedValueRegion *region);
- void Profile(llvm::FoldingSetNodeID& ID) { Profile(ID, store, region); }
+ void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, store, region); }
};
class PointerToMemberData : public llvm::FoldingSetNode {
@@ -115,7 +114,7 @@ class BasicValueFactory {
llvm::FoldingSet<llvm::FoldingSetNodeWrapper<llvm::APSInt>>;
ASTContext &Ctx;
- llvm::BumpPtrAllocator& BPAlloc;
+ llvm::BumpPtrAllocator &BPAlloc;
APSIntSetTy APSIntSet;
void *PersistentSVals = nullptr;
@@ -123,13 +122,13 @@ class BasicValueFactory {
llvm::ImmutableList<SVal>::Factory SValListFactory;
llvm::ImmutableList<const CXXBaseSpecifier *>::Factory CXXBaseListFactory;
- llvm::FoldingSet<CompoundValData> CompoundValDataSet;
+ llvm::FoldingSet<CompoundValData> CompoundValDataSet;
llvm::FoldingSet<LazyCompoundValData> LazyCompoundValDataSet;
llvm::FoldingSet<PointerToMemberData> PointerToMemberDataSet;
// This is private because external clients should use the factory
// method that takes a QualType.
- const llvm::APSInt& getValue(uint64_t X, unsigned BitWidth, bool isUnsigned);
+ const llvm::APSInt &getValue(uint64_t X, unsigned BitWidth, bool isUnsigned);
public:
BasicValueFactory(ASTContext &ctx, llvm::BumpPtrAllocator &Alloc)
@@ -140,9 +139,9 @@ class BasicValueFactory {
ASTContext &getContext() const { return Ctx; }
- const llvm::APSInt& getValue(const llvm::APSInt& X);
- const llvm::APSInt& getValue(const llvm::APInt& X, bool isUnsigned);
- const llvm::APSInt& getValue(uint64_t X, QualType T);
+ const llvm::APSInt &getValue(const llvm::APSInt &X);
+ const llvm::APSInt &getValue(const llvm::APInt &X, bool isUnsigned);
+ const llvm::APSInt &getValue(uint64_t X, QualType T);
/// Returns the type of the APSInt used to store values of the given QualType.
APSIntType getAPSIntType(QualType T) const {
@@ -165,8 +164,8 @@ class BasicValueFactory {
/// Convert - Create a new persistent APSInt with the same value as 'From'
/// but with the bitwidth and signedness of 'To'.
- const llvm::APSInt &Convert(const llvm::APSInt& To,
- const llvm::APSInt& From) {
+ const llvm::APSInt &Convert(const llvm::APSInt &To,
+ const llvm::APSInt &From) {
APSIntType TargetType(To);
if (TargetType == APSIntType(From))
return From;
@@ -244,8 +243,8 @@ class BasicValueFactory {
const CompoundValData *getCompoundValData(QualType T,
llvm::ImmutableList<SVal> Vals);
- const LazyCompoundValData *getLazyCompoundValData(const StoreRef &store,
- const TypedValueRegion *region);
+ const LazyCompoundValData *
+ getLazyCompoundValData(const StoreRef &store, const TypedValueRegion *region);
const PointerToMemberData *
getPointerToMemberData(const NamedDecl *ND,
@@ -263,9 +262,9 @@ class BasicValueFactory {
return CXXBaseListFactory.getEmptyList();
}
- llvm::ImmutableList<const CXXBaseSpecifier *> prependCXXBase(
- const CXXBaseSpecifier *CBS,
- llvm::ImmutableList<const CXXBaseSpecifier *> L) {
+ llvm::ImmutableList<const CXXBaseSpecifier *>
+ prependCXXBase(const CXXBaseSpecifier *CBS,
+ llvm::ImmutableList<const CXXBaseSpecifier *> L) {
return CXXBaseListFactory.add(CBS, L);
}
@@ -273,17 +272,17 @@ class BasicValueFactory {
accumCXXBase(llvm::iterator_range<CastExpr::path_const_iterator> PathRange,
const nonloc::PointerToMember &PTM, const clang::CastKind &kind);
- const llvm::APSInt* evalAPSInt(BinaryOperator::Opcode Op,
- const llvm::APSInt& V1,
- const llvm::APSInt& V2);
+ const llvm::APSInt *evalAPSInt(BinaryOperator::Opcode Op,
+ const llvm::APSInt &V1,
+ const llvm::APSInt &V2);
- const std::pair<SVal, uintptr_t>&
- getPersistentSValWithData(const SVal& V, uintptr_t Data);
+ const std::pair<SVal, uintptr_t> &getPersistentSValWithData(const SVal &V,
+ uintptr_t Data);
- const std::pair<SVal, SVal>&
- getPersistentSValPair(const SVal& V1, const SVal& V2);
+ const std::pair<SVal, SVal> &getPersistentSValPair(const SVal &V1,
+ const SVal &V2);
- const SVal* getPersistentSVal(SVal X);
+ const SVal *getPersistentSVal(SVal X);
};
} // namespace ento
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BlockCounter.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BlockCounter.h
index 46ff69e0c39681..7ea9f453fec10d 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BlockCounter.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/BlockCounter.h
@@ -39,21 +39,22 @@ class BlockCounter {
class Factory {
void *F;
+
public:
- Factory(llvm::BumpPtrAllocator& Alloc);
+ Factory(llvm::BumpPtrAllocator &Alloc);
~Factory();
BlockCounter GetEmptyCounter();
BlockCounter IncrementCount(BlockCounter BC,
- const StackFrameContext *CallSite,
- unsigned BlockID);
+ const StackFrameContext *CallSite,
+ unsigned BlockID);
};
friend class Factory;
};
-} // end GR namespace
+} // namespace ento
-} // end clang namespace
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h
index 965838a4408c23..822799dbab3aaa 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h
@@ -107,7 +107,8 @@ class CallDescription {
return CD1.matches(Call);
}
- /// \copydoc clang::ento::CallDescription::matchesAny(const CallEvent &, const CallDescription &)
+ /// \copydoc clang::ento::CallDescription::matchesAny(const CallEvent &, const
+ /// CallDescription &)
template <typename... Ts>
friend bool matchesAny(const CallEvent &Call, const CallDescription &CD1,
const Ts &...CDs) {
@@ -145,7 +146,8 @@ class CallDescription {
return CD1.matchesAsWritten(CE);
}
- /// \copydoc clang::ento::CallDescription::matchesAnyAsWritten(const CallExpr &, const CallDescription &)
+ /// \copydoc clang::ento::CallDescription::matchesAnyAsWritten(const CallExpr
+ /// &, const CallDescription &)
template <typename... Ts>
friend bool matchesAnyAsWritten(const CallExpr &CE,
const CallDescription &CD1,
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
index 9923c41e6ad2d1..338f3066fcdcb8 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
@@ -38,32 +38,21 @@ class CheckerContext {
/// call was inlined. In all other cases it will be false.
const bool wasInlined;
- CheckerContext(NodeBuilder &builder,
- ExprEngine &eng,
- ExplodedNode *pred,
- const ProgramPoint &loc,
- bool wasInlined = false)
- : Eng(eng),
- Pred(pred),
- Changed(false),
- Location(loc),
- NB(builder),
- wasInlined(wasInlined) {
+ CheckerContext(NodeBuilder &builder, ExprEngine &eng, ExplodedNode *pred,
+ const ProgramPoint &loc, bool wasInlined = false)
+ : Eng(eng), Pred(pred), Changed(false), Location(loc), NB(builder),
+ wasInlined(wasInlined) {
assert(Pred->getState() &&
"We should not call the checkers on an empty state.");
}
- AnalysisManager &getAnalysisManager() {
- return Eng.getAnalysisManager();
- }
+ AnalysisManager &getAnalysisManager() { return Eng.getAnalysisManager(); }
ConstraintManager &getConstraintManager() {
return Eng.getConstraintManager();
}
- StoreManager &getStoreManager() {
- return Eng.getStoreManager();
- }
+ StoreManager &getStoreManager() { return Eng.getStoreManager(); }
/// Returns the previous node in the exploded graph, which includes
/// the state of the program before the checker ran. Note, checkers should
@@ -77,13 +66,9 @@ class CheckerContext {
/// Returns the number of times the current block has been visited
/// along the analyzed path.
- unsigned blockCount() const {
- return NB.getContext().blockCount();
- }
+ unsigned blockCount() const { return NB.getContext().blockCount(); }
- ASTContext &getASTContext() {
- return Eng.getContext();
- }
+ ASTContext &getASTContext() { return Eng.getContext(); }
const ASTContext &getASTContext() const { return Eng.getContext(); }
@@ -100,11 +85,9 @@ class CheckerContext {
}
/// Return true if the current LocationContext has no caller context.
- bool inTopFrame() const { return getLocationContext()->inTopFrame(); }
+ bool inTopFrame() const { return getLocationContext()->inTopFrame(); }
- BugReporter &getBugReporter() {
- return Eng.getBugReporter();
- }
+ BugReporter &getBugReporter() { return Eng.getBugReporter(); }
const SourceManager &getSourceManager() {
return getBugReporter().getSourceManager();
@@ -112,17 +95,13 @@ class CheckerContext {
Preprocessor &getPreprocessor() { return getBugReporter().getPreprocessor(); }
- SValBuilder &getSValBuilder() {
- return Eng.getSValBuilder();
- }
+ SValBuilder &getSValBuilder() { return Eng.getSValBuilder(); }
SymbolManager &getSymbolManager() {
return getSValBuilder().getSymbolManager();
}
- ProgramStateManager &getStateManager() {
- return Eng.getStateManager();
- }
+ ProgramStateManager &getStateManager() { return Eng.getStateManager(); }
AnalysisDeclContext *getCurrentAnalysisDeclContext() const {
return Pred->getLocationContext()->getAnalysisDeclContext();
@@ -141,14 +120,12 @@ class CheckerContext {
static const MemRegion *getLocationRegionIfPostStore(const ExplodedNode *N) {
ProgramPoint L = N->getLocation();
if (std::optional<PostStore> PSL = L.getAs<PostStore>())
- return reinterpret_cast<const MemRegion*>(PSL->getLocationValue());
+ return reinterpret_cast<const MemRegion *>(PSL->getLocationValue());
return nullptr;
}
/// Get the value of arbitrary expressions at this point in the path.
- SVal getSVal(const Stmt *S) const {
- return Pred->getSVal(S);
- }
+ SVal getSVal(const Stmt *S) const { return Pred->getSVal(S); }
/// Returns true if the value of \p E is greater than or equal to \p
/// Val under unsigned comparison
@@ -208,8 +185,7 @@ class CheckerContext {
/// the default tag for the checker will be used.
ExplodedNode *generateErrorNode(ProgramStateRef State = nullptr,
const ProgramPointTag *Tag = nullptr) {
- return generateSink(State, Pred,
- (Tag ? Tag : Location.getTag()));
+ return generateSink(State, Pred, (Tag ? Tag : Location.getTag()));
}
/// Generate a transition to a node that will be used to report
@@ -221,11 +197,9 @@ class CheckerContext {
/// to the newly generated node.
/// @param Tag The tag to uniquely identify the creation site. If null,
/// the default tag for the checker will be used.
- ExplodedNode *generateErrorNode(ProgramStateRef State,
- ExplodedNode *Pred,
+ ExplodedNode *generateErrorNode(ProgramStateRef State, ExplodedNode *Pred,
const ProgramPointTag *Tag = nullptr) {
- return generateSink(State, Pred,
- (Tag ? Tag : Location.getTag()));
+ return generateSink(State, Pred, (Tag ? Tag : Location.getTag()));
}
/// Generate a transition to a node that will be used to report
@@ -251,8 +225,7 @@ class CheckerContext {
/// @param Tag The tag to uniquely identify the creation site. If null,
/// the default tag for the checker will be used.
ExplodedNode *
- generateNonFatalErrorNode(ProgramStateRef State,
- ExplodedNode *Pred,
+ generateNonFatalErrorNode(ProgramStateRef State, ExplodedNode *Pred,
const ProgramPointTag *Tag = nullptr) {
return addTransition(State, Pred, (Tag ? Tag : Location.getTag()));
}
@@ -285,13 +258,12 @@ class CheckerContext {
/// @param IsPrunable Whether the note is prunable. It allows BugReporter
/// to omit the note from the report if it would make the displayed
/// bug path significantly shorter.
- const NoteTag
- *getNoteTag(std::function<std::string(PathSensitiveBugReport &)> &&Cb,
- bool IsPrunable = false) {
- return getNoteTag(
- [Cb](BugReporterContext &,
- PathSensitiveBugReport &BR) { return Cb(BR); },
- IsPrunable);
+ const NoteTag *
+ getNoteTag(std::function<std::string(PathSensitiveBugReport &)> &&Cb,
+ bool IsPrunable = false) {
+ return getNoteTag([Cb](BugReporterContext &,
+ PathSensitiveBugReport &BR) { return Cb(BR); },
+ IsPrunable);
}
/// A shorthand version of getNoteTag that doesn't require you to accept
@@ -303,9 +275,9 @@ class CheckerContext {
/// bug path significantly shorter.
const NoteTag *getNoteTag(std::function<std::string()> &&Cb,
bool IsPrunable = false) {
- return getNoteTag([Cb](BugReporterContext &,
- PathSensitiveBugReport &) { return Cb(); },
- IsPrunable);
+ return getNoteTag(
+ [Cb](BugReporterContext &, PathSensitiveBugReport &) { return Cb(); },
+ IsPrunable);
}
/// A shorthand version of getNoteTag that accepts a plain note.
@@ -317,7 +289,7 @@ class CheckerContext {
const NoteTag *getNoteTag(StringRef Note, bool IsPrunable = false) {
return getNoteTag(
[Note = std::string(Note)](BugReporterContext &,
- PathSensitiveBugReport &) { return Note; },
+ PathSensitiveBugReport &) { return Note; },
IsPrunable);
}
@@ -328,9 +300,9 @@ class CheckerContext {
/// @param IsPrunable Whether the note is prunable. It allows BugReporter
/// to omit the note from the report if it would make the displayed
/// bug path significantly shorter.
- const NoteTag *getNoteTag(
- std::function<void(PathSensitiveBugReport &BR, llvm::raw_ostream &OS)> &&Cb,
- bool IsPrunable = false) {
+ const NoteTag *getNoteTag(std::function<void(PathSensitiveBugReport &BR,
+ llvm::raw_ostream &OS)> &&Cb,
+ bool IsPrunable = false) {
return getNoteTag(
[Cb](PathSensitiveBugReport &BR) -> std::string {
llvm::SmallString<128> Str;
@@ -391,10 +363,9 @@ class CheckerContext {
StringRef getMacroNameOrSpelling(SourceLocation &Loc);
private:
- ExplodedNode *addTransitionImpl(ProgramStateRef State,
- bool MarkAsSink,
- ExplodedNode *P = nullptr,
- const ProgramPointTag *Tag = nullptr) {
+ ExplodedNode *addTransitionImpl(ProgramStateRef State, bool MarkAsSink,
+ ExplodedNode *P = nullptr,
+ const ProgramPointTag *Tag = nullptr) {
// The analyzer may stop exploring if it sees a state it has previously
// visited ("cache out"). The early return here is a defensive check to
// prevent accidental caching out by checker API clients. Unless there is a
@@ -424,8 +395,8 @@ class CheckerContext {
}
};
-} // end GR namespace
+} // namespace ento
-} // end clang namespace
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h
index 65982457ad8393..6abfa58f8cf798 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h
@@ -34,7 +34,7 @@ bool containsStaticLocal(const Stmt *S);
bool containsBuiltinOffsetOf(const Stmt *S);
template <class T> bool containsStmt(const Stmt *S) {
if (isa<T>(S))
- return true;
+ return true;
for (const Stmt *Child : S->children())
if (Child && containsStmt<T>(Child))
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h
index 4de04bc4d397ac..f8f26ae6a731fc 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h
@@ -48,9 +48,7 @@ class ConditionTruthVal {
/// \return Stored value, assuming that the value is known.
/// Crashes otherwise.
- bool getValue() const {
- return *Val;
- }
+ bool getValue() const { return *Val; }
/// Return true if the constraint is perfectly constrained to 'true'.
bool isConstrainedTrue() const { return Val && *Val; }
@@ -105,7 +103,7 @@ class ConstraintManager {
/// Note that a ConstraintManager is not obligated to return a concretized
/// value for a symbol, even if it is perfectly constrained.
/// It might return null.
- virtual const llvm::APSInt* getSymVal(ProgramStateRef state,
+ virtual const llvm::APSInt *getSymVal(ProgramStateRef state,
SymbolRef sym) const {
return nullptr;
}
@@ -129,7 +127,7 @@ class ConstraintManager {
/// Scan all symbols referenced by the constraints. If the symbol is not
/// alive, remove it.
virtual ProgramStateRef removeDeadBindings(ProgramStateRef state,
- SymbolReaper& SymReaper) = 0;
+ SymbolReaper &SymReaper) = 0;
virtual void printJson(raw_ostream &Out, ProgramStateRef State,
const char *NL, unsigned int Space,
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
index 8dbe767cef9d7e..3be961e39b0863 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
@@ -105,8 +105,7 @@ class CoreEngine {
void setBlockCounter(BlockCounter C);
- void generateNode(const ProgramPoint &Loc,
- ProgramStateRef State,
+ void generateNode(const ProgramPoint &Loc, ProgramStateRef State,
ExplodedNode *Pred);
void HandleBlockEdge(const BlockEdge &E, ExplodedNode *Pred);
@@ -134,8 +133,7 @@ class CoreEngine {
public:
/// Construct a CoreEngine object to analyze the provided CFG.
- CoreEngine(ExprEngine &exprengine,
- FunctionSummariesTy *FS,
+ CoreEngine(ExprEngine &exprengine, FunctionSummariesTy *FS,
AnalyzerOptions &Opts);
CoreEngine(const CoreEngine &) = delete;
@@ -150,22 +148,21 @@ class CoreEngine {
ProgramStateRef InitState);
/// Returns true if there is still simulation state on the worklist.
- bool ExecuteWorkListWithInitialState(const LocationContext *L,
- unsigned Steps,
+ bool ExecuteWorkListWithInitialState(const LocationContext *L, unsigned Steps,
ProgramStateRef InitState,
ExplodedNodeSet &Dst);
/// Dispatch the work list item based on the given location information.
/// Use Pred parameter as the predecessor state.
- void dispatchWorkItem(ExplodedNode* Pred, ProgramPoint Loc,
- const WorkListUnit& WU);
+ void dispatchWorkItem(ExplodedNode *Pred, ProgramPoint Loc,
+ const WorkListUnit &WU);
// Functions for external checking of whether we have unfinished work
bool wasBlockAborted() const { return !blocksAborted.empty(); }
bool wasBlocksExhausted() const { return !blocksExhausted.empty(); }
- bool hasWorkRemaining() const { return wasBlocksExhausted() ||
- WList->hasWork() ||
- wasBlockAborted(); }
+ bool hasWorkRemaining() const {
+ return wasBlocksExhausted() || WList->hasWork() || wasBlockAborted();
+ }
/// Inform the CoreEngine that a basic block was aborted because
/// it could not be completely analyzed.
@@ -220,9 +217,8 @@ struct NodeBuilderContext {
/// Returns the number of times the current basic block has been
/// visited on the exploded graph path.
unsigned blockCount() const {
- return Eng.WList->getBlockCounter().getNumVisited(
- LC->getStackFrame(),
- Block->getBlockID());
+ return Eng.WList->getBlockCounter().getNumVisited(LC->getStackFrame(),
+ Block->getBlockID());
}
};
@@ -252,12 +248,10 @@ class NodeBuilder {
ExplodedNodeSet &Frontier;
/// Checks if the results are ready.
- virtual bool checkResults() {
- return Finalized;
- }
+ virtual bool checkResults() { return Finalized; }
bool hasNoSinksInFrontier() {
- for (const auto I : Frontier)
+ for (const auto I : Frontier)
if (I->isSink())
return false;
return true;
@@ -266,10 +260,8 @@ class NodeBuilder {
/// Allow subclasses to finalize results before result_begin() is executed.
virtual void finalizeResults() {}
- ExplodedNode *generateNodeImpl(const ProgramPoint &PP,
- ProgramStateRef State,
- ExplodedNode *Pred,
- bool MarkAsSink = false);
+ ExplodedNode *generateNodeImpl(const ProgramPoint &PP, ProgramStateRef State,
+ ExplodedNode *Pred, bool MarkAsSink = false);
public:
NodeBuilder(ExplodedNode *SrcNode, ExplodedNodeSet &DstSet,
@@ -288,8 +280,7 @@ class NodeBuilder {
virtual ~NodeBuilder() = default;
/// Generates a node in the ExplodedGraph.
- ExplodedNode *generateNode(const ProgramPoint &PP,
- ProgramStateRef State,
+ ExplodedNode *generateNode(const ProgramPoint &PP, ProgramStateRef State,
ExplodedNode *Pred) {
return generateNodeImpl(
PP, State, Pred,
@@ -301,8 +292,7 @@ class NodeBuilder {
/// When a node is marked as sink, the exploration from the node is stopped -
/// the node becomes the last node on the path and certain kinds of bugs are
/// suppressed.
- ExplodedNode *generateSink(const ProgramPoint &PP,
- ProgramStateRef State,
+ ExplodedNode *generateSink(const ProgramPoint &PP, ProgramStateRef State,
ExplodedNode *Pred) {
return generateNodeImpl(PP, State, Pred, true);
}
@@ -342,11 +332,11 @@ class NodeBuilder {
/// \class NodeBuilderWithSinks
/// This node builder keeps track of the generated sink nodes.
-class NodeBuilderWithSinks: public NodeBuilder {
+class NodeBuilderWithSinks : public NodeBuilder {
void anchor() override;
protected:
- SmallVector<ExplodedNode*, 2> sinksGenerated;
+ SmallVector<ExplodedNode *, 2> sinksGenerated;
ProgramPoint &Location;
public:
@@ -354,8 +344,7 @@ class NodeBuilderWithSinks: public NodeBuilder {
const NodeBuilderContext &Ctx, ProgramPoint &L)
: NodeBuilder(Pred, DstSet, Ctx), Location(L) {}
- ExplodedNode *generateNode(ProgramStateRef State,
- ExplodedNode *Pred,
+ ExplodedNode *generateNode(ProgramStateRef State, ExplodedNode *Pred,
const ProgramPointTag *Tag = nullptr) {
const ProgramPoint &LocalLoc = (Tag ? Location.withTag(Tag) : Location);
return NodeBuilder::generateNode(LocalLoc, State, Pred);
@@ -370,7 +359,7 @@ class NodeBuilderWithSinks: public NodeBuilder {
return N;
}
- const SmallVectorImpl<ExplodedNode*> &getSinks() const {
+ const SmallVectorImpl<ExplodedNode *> &getSinks() const {
return sinksGenerated;
}
};
@@ -379,7 +368,7 @@ class NodeBuilderWithSinks: public NodeBuilder {
/// This builder class is useful for generating nodes that resulted from
/// visiting a statement. The main difference from its parent NodeBuilder is
/// that it creates a statement specific ProgramPoint.
-class StmtNodeBuilder: public NodeBuilder {
+class StmtNodeBuilder : public NodeBuilder {
NodeBuilder *EnclosingBldr;
public:
@@ -408,30 +397,28 @@ class StmtNodeBuilder: public NodeBuilder {
using NodeBuilder::generateNode;
using NodeBuilder::generateSink;
- ExplodedNode *generateNode(const Stmt *S,
- ExplodedNode *Pred,
- ProgramStateRef St,
- const ProgramPointTag *tag = nullptr,
- ProgramPoint::Kind K = ProgramPoint::PostStmtKind){
- const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
- Pred->getLocationContext(), tag);
+ ExplodedNode *
+ generateNode(const Stmt *S, ExplodedNode *Pred, ProgramStateRef St,
+ const ProgramPointTag *tag = nullptr,
+ ProgramPoint::Kind K = ProgramPoint::PostStmtKind) {
+ const ProgramPoint &L =
+ ProgramPoint::getProgramPoint(S, K, Pred->getLocationContext(), tag);
return NodeBuilder::generateNode(L, St, Pred);
}
- ExplodedNode *generateSink(const Stmt *S,
- ExplodedNode *Pred,
- ProgramStateRef St,
- const ProgramPointTag *tag = nullptr,
- ProgramPoint::Kind K = ProgramPoint::PostStmtKind){
- const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
- Pred->getLocationContext(), tag);
+ ExplodedNode *
+ generateSink(const Stmt *S, ExplodedNode *Pred, ProgramStateRef St,
+ const ProgramPointTag *tag = nullptr,
+ ProgramPoint::Kind K = ProgramPoint::PostStmtKind) {
+ const ProgramPoint &L =
+ ProgramPoint::getProgramPoint(S, K, Pred->getLocationContext(), tag);
return NodeBuilder::generateSink(L, St, Pred);
}
};
/// BranchNodeBuilder is responsible for constructing the nodes
/// corresponding to the two branches of the if statement - true and false.
-class BranchNodeBuilder: public NodeBuilder {
+class BranchNodeBuilder : public NodeBuilder {
const CFGBlock *DstT;
const CFGBlock *DstF;
@@ -442,8 +429,8 @@ class BranchNodeBuilder: public NodeBuilder {
public:
BranchNodeBuilder(ExplodedNode *SrcNode, ExplodedNodeSet &DstSet,
- const NodeBuilderContext &C,
- const CFGBlock *dstT, const CFGBlock *dstF)
+ const NodeBuilderContext &C, const CFGBlock *dstT,
+ const CFGBlock *dstF)
: NodeBuilder(SrcNode, DstSet, C), DstT(dstT), DstF(dstF),
InFeasibleTrue(!DstT), InFeasibleFalse(!DstF) {
// The branch node builder does not generate autotransitions.
@@ -452,8 +439,8 @@ class BranchNodeBuilder: public NodeBuilder {
}
BranchNodeBuilder(const ExplodedNodeSet &SrcSet, ExplodedNodeSet &DstSet,
- const NodeBuilderContext &C,
- const CFGBlock *dstT, const CFGBlock *dstF)
+ const NodeBuilderContext &C, const CFGBlock *dstT,
+ const CFGBlock *dstF)
: NodeBuilder(SrcSet, DstSet, C), DstT(dstT), DstF(dstF),
InFeasibleTrue(!DstT), InFeasibleFalse(!DstF) {
takeNodes(SrcSet);
@@ -479,7 +466,7 @@ class BranchNodeBuilder: public NodeBuilder {
};
class IndirectGotoNodeBuilder {
- CoreEngine& Eng;
+ CoreEngine &Eng;
const CFGBlock *Src;
const CFGBlock &DispatchBlock;
const Expr *E;
@@ -487,7 +474,8 @@ class IndirectGotoNodeBuilder {
public:
IndirectGotoNodeBuilder(ExplodedNode *pred, const CFGBlock *src,
- const Expr *e, const CFGBlock *dispatch, CoreEngine* eng)
+ const Expr *e, const CFGBlock *dispatch,
+ CoreEngine *eng)
: Eng(*eng), Src(src), DispatchBlock(*dispatch), E(e), Pred(pred) {}
class iterator {
@@ -503,23 +491,23 @@ class IndirectGotoNodeBuilder {
// loops work.
const iterator &operator*() const { return *this; }
- iterator &operator++() { ++I; return *this; }
+ iterator &operator++() {
+ ++I;
+ return *this;
+ }
bool operator!=(const iterator &X) const { return I != X.I; }
const LabelDecl *getLabel() const {
return cast<LabelStmt>((*I)->getLabel())->getDecl();
}
- const CFGBlock *getBlock() const {
- return *I;
- }
+ const CFGBlock *getBlock() const { return *I; }
};
iterator begin() { return iterator(DispatchBlock.succ_begin()); }
iterator end() { return iterator(DispatchBlock.succ_end()); }
- ExplodedNode *generateNode(const iterator &I,
- ProgramStateRef State,
+ ExplodedNode *generateNode(const iterator &I, ProgramStateRef State,
bool isSink = false);
const Expr *getTarget() const { return E; }
@@ -532,14 +520,14 @@ class IndirectGotoNodeBuilder {
};
class SwitchNodeBuilder {
- CoreEngine& Eng;
+ CoreEngine &Eng;
const CFGBlock *Src;
const Expr *Condition;
ExplodedNode *Pred;
public:
SwitchNodeBuilder(ExplodedNode *pred, const CFGBlock *src,
- const Expr *condition, CoreEngine* eng)
+ const Expr *condition, CoreEngine *eng)
: Eng(*eng), Src(src), Condition(condition), Pred(pred) {}
class iterator {
@@ -550,28 +538,26 @@ class SwitchNodeBuilder {
iterator(CFGBlock::const_succ_reverse_iterator i) : I(i) {}
public:
- iterator &operator++() { ++I; return *this; }
+ iterator &operator++() {
+ ++I;
+ return *this;
+ }
bool operator!=(const iterator &X) const { return I != X.I; }
bool operator==(const iterator &X) const { return I == X.I; }
- const CaseStmt *getCase() const {
- return cast<CaseStmt>((*I)->getLabel());
- }
+ const CaseStmt *getCase() const { return cast<CaseStmt>((*I)->getLabel()); }
- const CFGBlock *getBlock() const {
- return *I;
- }
+ const CFGBlock *getBlock() const { return *I; }
};
- iterator begin() { return iterator(Src->succ_rbegin()+1); }
+ iterator begin() { return iterator(Src->succ_rbegin() + 1); }
iterator end() { return iterator(Src->succ_rend()); }
const SwitchStmt *getSwitch() const {
return cast<SwitchStmt>(Src->getTerminator());
}
- ExplodedNode *generateCaseStmtNode(const iterator &I,
- ProgramStateRef State);
+ ExplodedNode *generateCaseStmtNode(const iterator &I, ProgramStateRef State);
ExplodedNode *generateDefaultCaseNode(ProgramStateRef State,
bool isSink = false);
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h
index 498e36e1431fa5..78ab7231ad133e 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h
@@ -32,8 +32,8 @@ class SymbolReaper;
/// This allows the environment to manage context-sensitive bindings,
/// which is essentially for modeling recursive function analysis, among
/// other things.
-class EnvironmentEntry : public std::pair<const Stmt *,
- const StackFrameContext *> {
+class EnvironmentEntry
+ : public std::pair<const Stmt *, const StackFrameContext *> {
public:
EnvironmentEntry(const Stmt *s, const LocationContext *L);
@@ -41,15 +41,12 @@ class EnvironmentEntry : public std::pair<const Stmt *,
const LocationContext *getLocationContext() const { return second; }
/// Profile an EnvironmentEntry for inclusion in a FoldingSet.
- static void Profile(llvm::FoldingSetNodeID &ID,
- const EnvironmentEntry &E) {
+ static void Profile(llvm::FoldingSetNodeID &ID, const EnvironmentEntry &E) {
ID.AddPointer(E.getStmt());
ID.AddPointer(E.getLocationContext());
}
- void Profile(llvm::FoldingSetNodeID &ID) const {
- Profile(ID, *this);
- }
+ void Profile(llvm::FoldingSetNodeID &ID) const { Profile(ID, *this); }
};
/// An immutable map from EnvironemntEntries to SVals.
@@ -77,17 +74,15 @@ class Environment {
/// Profile - Profile the contents of an Environment object for use
/// in a FoldingSet.
- static void Profile(llvm::FoldingSetNodeID& ID, const Environment* env) {
+ static void Profile(llvm::FoldingSetNodeID &ID, const Environment *env) {
env->ExprBindings.Profile(ID);
}
/// Profile - Used to profile the contents of this object for inclusion
/// in a FoldingSet.
- void Profile(llvm::FoldingSetNodeID& ID) const {
- Profile(ID, this);
- }
+ void Profile(llvm::FoldingSetNodeID &ID) const { Profile(ID, this); }
- bool operator==(const Environment& RHS) const {
+ bool operator==(const Environment &RHS) const {
return ExprBindings == RHS.ExprBindings;
}
@@ -105,16 +100,13 @@ class EnvironmentManager {
public:
EnvironmentManager(llvm::BumpPtrAllocator &Allocator) : F(Allocator) {}
- Environment getInitialEnvironment() {
- return Environment(F.getEmptyMap());
- }
+ Environment getInitialEnvironment() { return Environment(F.getEmptyMap()); }
/// Bind a symbolic value to the given environment entry.
Environment bindExpr(Environment Env, const EnvironmentEntry &E, SVal V,
bool Invalidate);
- Environment removeDeadBindings(Environment Env,
- SymbolReaper &SymReaper,
+ Environment removeDeadBindings(Environment Env, SymbolReaper &SymReaper,
ProgramStateRef state);
};
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
index 2fb05ac46e8fad..57434f31f1f9d6 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
@@ -89,13 +89,11 @@ class ExplodedNode : public llvm::FoldingSetNode {
uintptr_t P;
public:
- NodeGroup(bool Flag = false) : P(Flag) {
- assert(getFlag() == Flag);
- }
+ NodeGroup(bool Flag = false) : P(Flag) { assert(getFlag() == Flag); }
- ExplodedNode * const *begin() const;
+ ExplodedNode *const *begin() const;
- ExplodedNode * const *end() const;
+ ExplodedNode *const *end() const;
unsigned size() const;
@@ -114,9 +112,7 @@ class ExplodedNode : public llvm::FoldingSetNode {
void replaceNode(ExplodedNode *node);
/// Returns whether this group was created with its flag set.
- bool getFlag() const {
- return (P & 1);
- }
+ bool getFlag() const { return (P & 1); }
};
/// Location - The program location (within a function body) associated
@@ -177,16 +173,14 @@ class ExplodedNode : public llvm::FoldingSetNode {
return getState()->getSVal(S, getLocationContext());
}
- static void Profile(llvm::FoldingSetNodeID &ID,
- const ProgramPoint &Loc,
- const ProgramStateRef &state,
- bool IsSink) {
+ static void Profile(llvm::FoldingSetNodeID &ID, const ProgramPoint &Loc,
+ const ProgramStateRef &state, bool IsSink) {
ID.Add(Loc);
ID.AddPointer(state.get());
ID.AddBoolean(IsSink);
}
- void Profile(llvm::FoldingSetNodeID& ID) const {
+ void Profile(llvm::FoldingSetNodeID &ID) const {
// We avoid copy constructors by not using accessors.
Profile(ID, Location, State, isSink());
}
@@ -202,16 +196,14 @@ class ExplodedNode : public llvm::FoldingSetNode {
bool isSink() const { return Succs.getFlag(); }
- bool hasSinglePred() const {
- return (pred_size() == 1);
- }
+ bool hasSinglePred() const { return (pred_size() == 1); }
ExplodedNode *getFirstPred() {
return pred_empty() ? nullptr : *(pred_begin());
}
const ExplodedNode *getFirstPred() const {
- return const_cast<ExplodedNode*>(this)->getFirstPred();
+ return const_cast<ExplodedNode *>(this)->getFirstPred();
}
ExplodedNode *getFirstSucc() {
@@ -219,20 +211,20 @@ class ExplodedNode : public llvm::FoldingSetNode {
}
const ExplodedNode *getFirstSucc() const {
- return const_cast<ExplodedNode*>(this)->getFirstSucc();
+ return const_cast<ExplodedNode *>(this)->getFirstSucc();
}
// Iterators over successor and predecessor vertices.
- using succ_iterator = ExplodedNode * const *;
+ using succ_iterator = ExplodedNode *const *;
using succ_range = llvm::iterator_range<succ_iterator>;
- using const_succ_iterator = const ExplodedNode * const *;
+ using const_succ_iterator = const ExplodedNode *const *;
using const_succ_range = llvm::iterator_range<const_succ_iterator>;
- using pred_iterator = ExplodedNode * const *;
+ using pred_iterator = ExplodedNode *const *;
using pred_range = llvm::iterator_range<pred_iterator>;
- using const_pred_iterator = const ExplodedNode * const *;
+ using const_pred_iterator = const ExplodedNode *const *;
using const_pred_range = llvm::iterator_range<const_pred_iterator>;
pred_iterator pred_begin() { return Preds.begin(); }
@@ -240,10 +232,10 @@ class ExplodedNode : public llvm::FoldingSetNode {
pred_range preds() { return {Preds.begin(), Preds.end()}; }
const_pred_iterator pred_begin() const {
- return const_cast<ExplodedNode*>(this)->pred_begin();
+ return const_cast<ExplodedNode *>(this)->pred_begin();
}
const_pred_iterator pred_end() const {
- return const_cast<ExplodedNode*>(this)->pred_end();
+ return const_cast<ExplodedNode *>(this)->pred_end();
}
const_pred_range preds() const { return {Preds.begin(), Preds.end()}; }
@@ -252,10 +244,10 @@ class ExplodedNode : public llvm::FoldingSetNode {
succ_range succs() { return {Succs.begin(), Succs.end()}; }
const_succ_iterator succ_begin() const {
- return const_cast<ExplodedNode*>(this)->succ_begin();
+ return const_cast<ExplodedNode *>(this)->succ_begin();
}
const_succ_iterator succ_end() const {
- return const_cast<ExplodedNode*>(this)->succ_end();
+ return const_cast<ExplodedNode *>(this)->succ_end();
}
const_succ_range succs() const { return {Succs.begin(), Succs.end()}; }
@@ -350,17 +342,14 @@ class ExplodedGraph {
/// this pair exists, it is created. IsNew is set to true if
/// the node was freshly created.
ExplodedNode *getNode(const ProgramPoint &L, ProgramStateRef State,
- bool IsSink = false,
- bool* IsNew = nullptr);
+ bool IsSink = false, bool *IsNew = nullptr);
/// Create a node for a (Location, State) pair,
/// but don't store it for deduplication later. This
/// is useful when copying an already completed
/// ExplodedGraph for further processing.
- ExplodedNode *createUncachedNode(const ProgramPoint &L,
- ProgramStateRef State,
- int64_t Id,
- bool IsSink = false);
+ ExplodedNode *createUncachedNode(const ProgramPoint &L, ProgramStateRef State,
+ int64_t Id, bool IsSink = false);
std::unique_ptr<ExplodedGraph> MakeEmptyGraph() const {
return std::make_unique<ExplodedGraph>();
@@ -416,7 +405,7 @@ class ExplodedGraph {
const_eop_iterator eop_end() const { return EndNodes.end(); }
- llvm::BumpPtrAllocator & getAllocator() { return BVC.getAllocator(); }
+ llvm::BumpPtrAllocator &getAllocator() { return BVC.getAllocator(); }
BumpVectorContext &getNodeAllocator() { return BVC; }
using NodeMap = llvm::DenseMap<const ExplodedNode *, ExplodedNode *>;
@@ -461,21 +450,22 @@ class ExplodedNodeSet {
public:
ExplodedNodeSet(ExplodedNode *N) {
- assert(N && !static_cast<ExplodedNode*>(N)->isSink());
+ assert(N && !static_cast<ExplodedNode *>(N)->isSink());
Impl.insert(N);
}
ExplodedNodeSet() = default;
void Add(ExplodedNode *N) {
- if (N && !static_cast<ExplodedNode*>(N)->isSink()) Impl.insert(N);
+ if (N && !static_cast<ExplodedNode *>(N)->isSink())
+ Impl.insert(N);
}
using iterator = ImplTy::iterator;
using const_iterator = ImplTy::const_iterator;
- unsigned size() const { return Impl.size(); }
- bool empty() const { return Impl.empty(); }
+ unsigned size() const { return Impl.size(); }
+ bool empty() const { return Impl.empty(); }
bool erase(ExplodedNode *N) { return Impl.remove(N); }
void clear() { Impl.clear(); }
@@ -502,40 +492,34 @@ class ExplodedNodeSet {
// GraphTraits
namespace llvm {
- template <> struct GraphTraits<clang::ento::ExplodedGraph *> {
- using GraphTy = clang::ento::ExplodedGraph *;
- using NodeRef = clang::ento::ExplodedNode *;
- using ChildIteratorType = clang::ento::ExplodedNode::succ_iterator;
- using nodes_iterator = llvm::df_iterator<GraphTy>;
-
- static NodeRef getEntryNode(const GraphTy G) {
- return *G->roots_begin();
- }
-
- static bool predecessorOfTrivial(NodeRef N) {
- return N->succ_size() == 1 && N->getFirstSucc()->isTrivial();
- }
-
- static ChildIteratorType child_begin(NodeRef N) {
- if (predecessorOfTrivial(N))
- return child_begin(*N->succ_begin());
- return N->succ_begin();
- }
-
- static ChildIteratorType child_end(NodeRef N) {
- if (predecessorOfTrivial(N))
- return child_end(N->getFirstSucc());
- return N->succ_end();
- }
-
- static nodes_iterator nodes_begin(const GraphTy G) {
- return df_begin(G);
- }
-
- static nodes_iterator nodes_end(const GraphTy G) {
- return df_end(G);
- }
- };
+template <> struct GraphTraits<clang::ento::ExplodedGraph *> {
+ using GraphTy = clang::ento::ExplodedGraph *;
+ using NodeRef = clang::ento::ExplodedNode *;
+ using ChildIteratorType = clang::ento::ExplodedNode::succ_iterator;
+ using nodes_iterator = llvm::df_iterator<GraphTy>;
+
+ static NodeRef getEntryNode(const GraphTy G) { return *G->roots_begin(); }
+
+ static bool predecessorOfTrivial(NodeRef N) {
+ return N->succ_size() == 1 && N->getFirstSucc()->isTrivial();
+ }
+
+ static ChildIteratorType child_begin(NodeRef N) {
+ if (predecessorOfTrivial(N))
+ return child_begin(*N->succ_begin());
+ return N->succ_begin();
+ }
+
+ static ChildIteratorType child_end(NodeRef N) {
+ if (predecessorOfTrivial(N))
+ return child_end(N->getFirstSucc());
+ return N->succ_end();
+ }
+
+ static nodes_iterator nodes_begin(const GraphTy G) { return df_begin(G); }
+
+ static nodes_iterator nodes_end(const GraphTy G) { return df_end(G); }
+};
} // namespace llvm
#endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_EXPLODEDGRAPH_H
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
index ed5c4adb5e3d56..48d76e64171bd3 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
@@ -21,18 +21,18 @@
#include "clang/Analysis/DomainSpecific/ObjCNoReturn.h"
#include "clang/Analysis/ProgramPoint.h"
#include "clang/Basic/LLVM.h"
-#include "clang/StaticAnalyzer/Core/CheckerManager.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h"
+#include "clang/StaticAnalyzer/Core/CheckerManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/Store.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/Store.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/WorkList.h"
#include "llvm/ADT/ArrayRef.h"
#include <cassert>
@@ -180,8 +180,8 @@ class ExprEngine {
public:
ExprEngine(cross_tu::CrossTranslationUnitContext &CTU, AnalysisManager &mgr,
- SetOfConstDecls *VisitedCalleesIn,
- FunctionSummariesTy *FS, InliningModes HowToInlineIn);
+ SetOfConstDecls *VisitedCalleesIn, FunctionSummariesTy *FS,
+ InliningModes HowToInlineIn);
virtual ~ExprEngine() = default;
@@ -217,8 +217,7 @@ class ExprEngine {
BugReporter &getBugReporter() { return BR; }
- cross_tu::CrossTranslationUnitContext *
- getCrossTranslationUnitContext() {
+ cross_tu::CrossTranslationUnitContext *getCrossTranslationUnitContext() {
return &CTU;
}
@@ -242,7 +241,7 @@ class ExprEngine {
/// Dump graph to the specified filename.
/// If filename is empty, generate a temporary one.
/// \return The filename the graph is written into.
- std::string DumpGraph(bool trim = false, StringRef Filename="");
+ std::string DumpGraph(bool trim = false, StringRef Filename = "");
/// Dump the graph consisting of the given nodes to a specified filename.
/// Generate a temporary filename if it's not provided.
@@ -289,10 +288,11 @@ class ExprEngine {
/// \p ReferenceStmt must either be a ReturnStmt or \c NULL. Otherwise,
/// it must be ProgramPoint::PreStmtPurgeDeadSymbolsKind (the default)
/// and \p ReferenceStmt must be valid (non-null).
- void removeDead(ExplodedNode *Node, ExplodedNodeSet &Out,
- const Stmt *ReferenceStmt, const LocationContext *LC,
- const Stmt *DiagnosticStmt = nullptr,
- ProgramPoint::Kind K = ProgramPoint::PreStmtPurgeDeadSymbolsKind);
+ void
+ removeDead(ExplodedNode *Node, ExplodedNodeSet &Out,
+ const Stmt *ReferenceStmt, const LocationContext *LC,
+ const Stmt *DiagnosticStmt = nullptr,
+ ProgramPoint::Kind K = ProgramPoint::PreStmtPurgeDeadSymbolsKind);
/// processCFGElement - Called by CoreEngine. Used to generate new successor
/// nodes by processing the 'effects' of a CFG element.
@@ -301,7 +301,7 @@ class ExprEngine {
void ProcessStmt(const Stmt *S, ExplodedNode *Pred);
- void ProcessLoopExit(const Stmt* S, ExplodedNode *Pred);
+ void ProcessLoopExit(const Stmt *S, ExplodedNode *Pred);
void ProcessInitializer(const CFGInitializer I, ExplodedNode *Pred);
@@ -309,16 +309,16 @@ class ExprEngine {
void ProcessNewAllocator(const CXXNewExpr *NE, ExplodedNode *Pred);
- void ProcessAutomaticObjDtor(const CFGAutomaticObjDtor D,
- ExplodedNode *Pred, ExplodedNodeSet &Dst);
- void ProcessDeleteDtor(const CFGDeleteDtor D,
- ExplodedNode *Pred, ExplodedNodeSet &Dst);
- void ProcessBaseDtor(const CFGBaseDtor D,
- ExplodedNode *Pred, ExplodedNodeSet &Dst);
- void ProcessMemberDtor(const CFGMemberDtor D,
- ExplodedNode *Pred, ExplodedNodeSet &Dst);
- void ProcessTemporaryDtor(const CFGTemporaryDtor D,
- ExplodedNode *Pred, ExplodedNodeSet &Dst);
+ void ProcessAutomaticObjDtor(const CFGAutomaticObjDtor D, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst);
+ void ProcessDeleteDtor(const CFGDeleteDtor D, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst);
+ void ProcessBaseDtor(const CFGBaseDtor D, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst);
+ void ProcessMemberDtor(const CFGMemberDtor D, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst);
+ void ProcessTemporaryDtor(const CFGTemporaryDtor D, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst);
/// Called by CoreEngine when processing the entrance of a CFGBlock.
void processCFGBlockEntrance(const BlockEdge &L,
@@ -327,12 +327,9 @@ class ExprEngine {
/// ProcessBranch - Called by CoreEngine. Used to generate successor
/// nodes by processing the 'effects' of a branch condition.
- void processBranch(const Stmt *Condition,
- NodeBuilderContext& BuilderCtx,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst,
- const CFGBlock *DstT,
- const CFGBlock *DstF);
+ void processBranch(const Stmt *Condition, NodeBuilderContext &BuilderCtx,
+ ExplodedNode *Pred, ExplodedNodeSet &Dst,
+ const CFGBlock *DstT, const CFGBlock *DstF);
/// Called by CoreEngine.
/// Used to generate successor nodes for temporary destructors depending
@@ -346,39 +343,34 @@ class ExprEngine {
/// Called by CoreEngine. Used to processing branching behavior
/// at static initializers.
void processStaticInitializer(const DeclStmt *DS,
- NodeBuilderContext& BuilderCtx,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst,
- const CFGBlock *DstT,
- const CFGBlock *DstF);
+ NodeBuilderContext &BuilderCtx,
+ ExplodedNode *Pred, ExplodedNodeSet &Dst,
+ const CFGBlock *DstT, const CFGBlock *DstF);
/// processIndirectGoto - Called by CoreEngine. Used to generate successor
/// nodes by processing the 'effects' of a computed goto jump.
- void processIndirectGoto(IndirectGotoNodeBuilder& builder);
+ void processIndirectGoto(IndirectGotoNodeBuilder &builder);
/// ProcessSwitch - Called by CoreEngine. Used to generate successor
/// nodes by processing the 'effects' of a switch statement.
- void processSwitch(SwitchNodeBuilder& builder);
+ void processSwitch(SwitchNodeBuilder &builder);
/// Called by CoreEngine. Used to notify checkers that processing a
/// function has begun. Called for both inlined and top-level functions.
- void processBeginOfFunction(NodeBuilderContext &BC,
- ExplodedNode *Pred, ExplodedNodeSet &Dst,
- const BlockEdge &L);
+ void processBeginOfFunction(NodeBuilderContext &BC, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst, const BlockEdge &L);
/// Called by CoreEngine. Used to notify checkers that processing a
/// function has ended. Called for both inlined and top-level functions.
- void processEndOfFunction(NodeBuilderContext& BC,
- ExplodedNode *Pred,
+ void processEndOfFunction(NodeBuilderContext &BC, ExplodedNode *Pred,
const ReturnStmt *RS = nullptr);
/// Remove dead bindings/symbols before exiting a function.
- void removeDeadOnEndOfFunction(NodeBuilderContext& BC,
- ExplodedNode *Pred,
+ void removeDeadOnEndOfFunction(NodeBuilderContext &BC, ExplodedNode *Pred,
ExplodedNodeSet &Dst);
/// Generate the entry node of the callee.
- void processCallEnter(NodeBuilderContext& BC, CallEnter CE,
+ void processCallEnter(NodeBuilderContext &BC, CallEnter CE,
ExplodedNode *Pred);
/// Generate the sequence of nodes that simulate the call exit and the post
@@ -393,20 +385,19 @@ class ExprEngine {
ProgramStateRef processAssume(ProgramStateRef state, SVal cond,
bool assumption);
- /// processRegionChanges - Called by ProgramStateManager whenever a change is made
+ /// processRegionChanges - Called by ProgramStateManager whenever a change is
+ /// made
/// to the store. Used to update checkers that track region values.
ProgramStateRef
processRegionChanges(ProgramStateRef state,
const InvalidatedSymbols *invalidated,
ArrayRef<const MemRegion *> ExplicitRegions,
ArrayRef<const MemRegion *> Regions,
- const LocationContext *LCtx,
- const CallEvent *Call);
+ const LocationContext *LCtx, const CallEvent *Call);
- inline ProgramStateRef
- processRegionChange(ProgramStateRef state,
- const MemRegion* MR,
- const LocationContext *LCtx) {
+ inline ProgramStateRef processRegionChange(ProgramStateRef state,
+ const MemRegion *MR,
+ const LocationContext *LCtx) {
return processRegionChanges(state, nullptr, MR, MR, LCtx, nullptr);
}
@@ -424,9 +415,7 @@ class ExprEngine {
}
// FIXME: Remove when we migrate over to just using SValBuilder.
- BasicValueFactory &getBasicVals() {
- return StateMgr.getBasicVals();
- }
+ BasicValueFactory &getBasicVals() { return StateMgr.getBasicVals(); }
SymbolManager &getSymbolManager() { return SymMgr; }
MemRegionManager &getRegionManager() { return MRMgr; }
@@ -450,8 +439,7 @@ class ExprEngine {
ExplodedNodeSet &Dst);
/// VisitArraySubscriptExpr - Transfer function for array accesses.
- void VisitArraySubscriptExpr(const ArraySubscriptExpr *Ex,
- ExplodedNode *Pred,
+ void VisitArraySubscriptExpr(const ArraySubscriptExpr *Ex, ExplodedNode *Pred,
ExplodedNodeSet &Dst);
/// VisitGCCAsmStmt - Transfer function logic for inline asm.
@@ -471,10 +459,9 @@ class ExprEngine {
ExplodedNodeSet &Dst);
/// VisitBinaryOperator - Transfer function logic for binary operators.
- void VisitBinaryOperator(const BinaryOperator* B, ExplodedNode *Pred,
+ void VisitBinaryOperator(const BinaryOperator *B, ExplodedNode *Pred,
ExplodedNodeSet &Dst);
-
/// VisitCall - Transfer function for function calls.
void VisitCallExpr(const CallExpr *CE, ExplodedNode *Pred,
ExplodedNodeSet &Dst);
@@ -503,7 +490,7 @@ class ExprEngine {
ExplodedNodeSet &Dst);
/// VisitLogicalExpr - Transfer function logic for '&&', '||'
- void VisitLogicalExpr(const BinaryOperator* B, ExplodedNode *Pred,
+ void VisitLogicalExpr(const BinaryOperator *B, ExplodedNode *Pred,
ExplodedNodeSet &Dst);
/// VisitMemberExpr - Transfer function for member expressions.
@@ -543,11 +530,11 @@ class ExprEngine {
ExplodedNode *Pred, ExplodedNodeSet &Dst);
/// VisitUnaryOperator - Transfer function logic for unary operators.
- void VisitUnaryOperator(const UnaryOperator* B, ExplodedNode *Pred,
+ void VisitUnaryOperator(const UnaryOperator *B, ExplodedNode *Pred,
ExplodedNodeSet &Dst);
/// Handle ++ and -- (both pre- and post-increment).
- void VisitIncrementDecrementOperator(const UnaryOperator* U,
+ void VisitIncrementDecrementOperator(const UnaryOperator *U,
ExplodedNode *Pred,
ExplodedNodeSet &Dst);
@@ -559,7 +546,7 @@ class ExprEngine {
ExplodedNodeSet &Dst);
void VisitCXXThisExpr(const CXXThisExpr *TE, ExplodedNode *Pred,
- ExplodedNodeSet & Dst);
+ ExplodedNodeSet &Dst);
void VisitCXXConstructExpr(const CXXConstructExpr *E, ExplodedNode *Pred,
ExplodedNodeSet &Dst);
@@ -568,12 +555,10 @@ class ExprEngine {
ExplodedNode *Pred, ExplodedNodeSet &Dst);
void VisitCXXDestructor(QualType ObjectType, const MemRegion *Dest,
- const Stmt *S, bool IsBaseDtor,
- ExplodedNode *Pred, ExplodedNodeSet &Dst,
- EvalCallOptions &Options);
+ const Stmt *S, bool IsBaseDtor, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst, EvalCallOptions &Options);
- void VisitCXXNewAllocatorCall(const CXXNewExpr *CNE,
- ExplodedNode *Pred,
+ void VisitCXXNewAllocatorCall(const CXXNewExpr *CNE, ExplodedNode *Pred,
ExplodedNodeSet &Dst);
void VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred,
@@ -584,17 +569,17 @@ class ExprEngine {
/// Create a C++ temporary object for an rvalue.
void CreateCXXTemporaryObject(const MaterializeTemporaryExpr *ME,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst);
+ ExplodedNode *Pred, ExplodedNodeSet &Dst);
- /// evalEagerlyAssumeBinOpBifurcation - Given the nodes in 'Src', eagerly assume symbolic
+ /// evalEagerlyAssumeBinOpBifurcation - Given the nodes in 'Src', eagerly
+ /// assume symbolic
/// expressions of the form 'x != 0' and generate new nodes (stored in Dst)
/// with those assumptions.
- void evalEagerlyAssumeBinOpBifurcation(ExplodedNodeSet &Dst, ExplodedNodeSet &Src,
- const Expr *Ex);
+ void evalEagerlyAssumeBinOpBifurcation(ExplodedNodeSet &Dst,
+ ExplodedNodeSet &Src, const Expr *Ex);
static std::pair<const ProgramPointTag *, const ProgramPointTag *>
- geteagerlyAssumeBinOpBifurcationTags();
+ geteagerlyAssumeBinOpBifurcationTags();
ProgramStateRef handleLValueBitCast(ProgramStateRef state, const Expr *Ex,
const LocationContext *LCtx, QualType T,
@@ -606,8 +591,8 @@ class ExprEngine {
StmtNodeBuilder &Bldr);
public:
- SVal evalBinOp(ProgramStateRef ST, BinaryOperator::Opcode Op,
- SVal LHS, SVal RHS, QualType T) {
+ SVal evalBinOp(ProgramStateRef ST, BinaryOperator::Opcode Op, SVal LHS,
+ SVal RHS, QualType T) {
return svalBuilder.evalBinOp(ST, Op, LHS, RHS, T);
}
@@ -635,20 +620,19 @@ class ExprEngine {
const LocationContext *LC);
/// Call PointerEscape callback when a value escapes as a result of bind.
- ProgramStateRef processPointerEscapedOnBind(
- ProgramStateRef State, ArrayRef<std::pair<SVal, SVal>> LocAndVals,
- const LocationContext *LCtx, PointerEscapeKind Kind,
- const CallEvent *Call);
+ ProgramStateRef
+ processPointerEscapedOnBind(ProgramStateRef State,
+ ArrayRef<std::pair<SVal, SVal>> LocAndVals,
+ const LocationContext *LCtx,
+ PointerEscapeKind Kind, const CallEvent *Call);
/// Call PointerEscape callback when a value escapes as a result of
/// region invalidation.
/// \param[in] ITraits Specifies invalidation traits for regions/symbols.
ProgramStateRef notifyCheckersOfPointerEscape(
- ProgramStateRef State,
- const InvalidatedSymbols *Invalidated,
- ArrayRef<const MemRegion *> ExplicitRegions,
- const CallEvent *Call,
- RegionAndSymbolInvalidationTraits &ITraits);
+ ProgramStateRef State, const InvalidatedSymbols *Invalidated,
+ ArrayRef<const MemRegion *> ExplicitRegions, const CallEvent *Call,
+ RegionAndSymbolInvalidationTraits &ITraits);
private:
/// evalBind - Handle the semantics of binding a value to a specific location.
@@ -657,10 +641,9 @@ class ExprEngine {
SVal location, SVal Val, bool atDeclInit = false,
const ProgramPoint *PP = nullptr);
- ProgramStateRef
- processPointerEscapedOnBind(ProgramStateRef State,
- SVal Loc, SVal Val,
- const LocationContext *LCtx);
+ ProgramStateRef processPointerEscapedOnBind(ProgramStateRef State, SVal Loc,
+ SVal Val,
+ const LocationContext *LCtx);
/// A simple wrapper when you only need to notify checkers of pointer-escape
/// of some values.
@@ -676,19 +659,16 @@ class ExprEngine {
// same as state->getLValue(Ex).
/// Simulate a read of the result of Ex.
void evalLoad(ExplodedNodeSet &Dst,
- const Expr *NodeEx, /* Eventually will be a CFGStmt */
- const Expr *BoundExpr,
- ExplodedNode *Pred,
- ProgramStateRef St,
- SVal location,
- const ProgramPointTag *tag = nullptr,
+ const Expr *NodeEx, /* Eventually will be a CFGStmt */
+ const Expr *BoundExpr, ExplodedNode *Pred, ProgramStateRef St,
+ SVal location, const ProgramPointTag *tag = nullptr,
QualType LoadTy = QualType());
// FIXME: 'tag' should be removed, and a LocationContext should be used
// instead.
void evalStore(ExplodedNodeSet &Dst, const Expr *AssignE, const Expr *StoreE,
- ExplodedNode *Pred, ProgramStateRef St, SVal TargetLV, SVal Val,
- const ProgramPointTag *tag = nullptr);
+ ExplodedNode *Pred, ProgramStateRef St, SVal TargetLV,
+ SVal Val, const ProgramPointTag *tag = nullptr);
/// Return the CFG element corresponding to the worklist element
/// that is currently being processed by ExprEngine.
@@ -763,11 +743,8 @@ class ExprEngine {
void evalLocation(ExplodedNodeSet &Dst,
const Stmt *NodeEx, /* This will eventually be a CFGStmt */
- const Stmt *BoundEx,
- ExplodedNode *Pred,
- ProgramStateRef St,
- SVal location,
- bool isLoad);
+ const Stmt *BoundEx, ExplodedNode *Pred, ProgramStateRef St,
+ SVal location, bool isLoad);
/// Count the stack depth and determine if the call is recursive.
void examineStackFrames(const Decl *D, const LocationContext *LCtx,
@@ -858,9 +835,8 @@ class ExprEngine {
/// Either inline or process the call conservatively (or both), based
/// on DynamicDispatchBifurcation data.
- void BifurcateCall(const MemRegion *BifurReg,
- const CallEvent &Call, const Decl *D, NodeBuilder &Bldr,
- ExplodedNode *Pred);
+ void BifurcateCall(const MemRegion *BifurReg, const CallEvent &Call,
+ const Decl *D, NodeBuilder &Bldr, ExplodedNode *Pred);
bool replayWithoutInlining(ExplodedNode *P, const LocationContext *CalleeLC);
@@ -1006,10 +982,10 @@ class ExprEngine {
/// The GDM stores the corresponding CallExpr pointer.
// FIXME: This does not use the nice trait macros because it must be accessible
// from multiple translation units.
-struct ReplayWithoutInlining{};
+struct ReplayWithoutInlining {};
template <>
-struct ProgramStateTrait<ReplayWithoutInlining> :
- public ProgramStatePartialTrait<const void*> {
+struct ProgramStateTrait<ReplayWithoutInlining>
+ : public ProgramStatePartialTrait<const void *> {
static void *GDMIndex();
};
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h
index 3ee0d229cfc299..dc6d969f41c8cc 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h
@@ -49,8 +49,8 @@ class FunctionSummariesTy {
unsigned TimesInlined : 32;
FunctionSummary()
- : TotalBasicBlocks(0), InlineChecked(0), MayInline(0),
- TimesInlined(0) {}
+ : TotalBasicBlocks(0), InlineChecked(0), MayInline(0), TimesInlined(0) {
+ }
};
using MapTy = llvm::DenseMap<const Decl *, FunctionSummary>;
@@ -81,9 +81,7 @@ class FunctionSummariesTy {
I->second.MayInline = 0;
}
- void markReachedMaxBlockCount(const Decl *D) {
- markShouldNotInline(D);
- }
+ void markReachedMaxBlockCount(const Decl *D) { markShouldNotInline(D); }
std::optional<bool> mayInline(const Decl *D) {
MapTy::const_iterator I = Map.find(D);
@@ -92,7 +90,7 @@ class FunctionSummariesTy {
return std::nullopt;
}
- void markVisitedBasicBlock(unsigned ID, const Decl* D, unsigned TotalIDs) {
+ void markVisitedBasicBlock(unsigned ID, const Decl *D, unsigned TotalIDs) {
MapTy::iterator I = findOrInsertSummary(D);
llvm::SmallBitVector &Blocks = I->second.VisitedBasicBlocks;
assert(ID < TotalIDs);
@@ -103,21 +101,21 @@ class FunctionSummariesTy {
Blocks.set(ID);
}
- unsigned getNumVisitedBasicBlocks(const Decl* D) {
+ unsigned getNumVisitedBasicBlocks(const Decl *D) {
MapTy::const_iterator I = Map.find(D);
if (I != Map.end())
return I->second.VisitedBasicBlocks.count();
return 0;
}
- unsigned getNumTimesInlined(const Decl* D) {
+ unsigned getNumTimesInlined(const Decl *D) {
MapTy::const_iterator I = Map.find(D);
if (I != Map.end())
return I->second.TimesInlined;
return 0;
}
- void bumpNumTimesInlined(const Decl* D) {
+ void bumpNumTimesInlined(const Decl *D) {
MapTy::iterator I = findOrInsertSummary(D);
I->second.TimesInlined++;
}
@@ -125,9 +123,9 @@ class FunctionSummariesTy {
/// Get the percentage of the reachable blocks.
unsigned getPercentBlocksReachable(const Decl *D) {
MapTy::const_iterator I = Map.find(D);
- if (I != Map.end())
- return ((I->second.VisitedBasicBlocks.count() * 100) /
- I->second.TotalBasicBlocks);
+ if (I != Map.end())
+ return ((I->second.VisitedBasicBlocks.count() * 100) /
+ I->second.TotalBasicBlocks);
return 0;
}
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/LoopUnrolling.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/LoopUnrolling.h
index eb2b0b343428f6..9bf2060e00499a 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/LoopUnrolling.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/LoopUnrolling.h
@@ -24,8 +24,8 @@
#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_LOOPUNROLLING_H
#include "clang/Analysis/CFG.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
namespace clang {
namespace ento {
@@ -35,7 +35,7 @@ bool isUnrolledState(ProgramStateRef State);
/// Updates the stack of loops contained by the ProgramState.
ProgramStateRef updateLoopStack(const Stmt *LoopStmt, ASTContext &ASTCtx,
- ExplodedNode* Pred, unsigned maxVisitOnPath);
+ ExplodedNode *Pred, unsigned maxVisitOnPath);
/// Updates the given ProgramState. In current implementation it removes the top
/// element of the stack of loops.
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
index 151d3e57c1cb81..0a21938ed48cd3 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
@@ -96,7 +96,7 @@ class RegionOffset {
class MemRegion : public llvm::FoldingSetNode {
public:
enum Kind {
-#define REGION(Id, Parent) Id ## Kind,
+#define REGION(Id, Parent) Id##Kind,
#define REGION_RANGE(Id, First, Last) BEGIN_##Id = First, END_##Id = Last,
#include "clang/StaticAnalyzer/Core/PathSensitive/Regions.def"
};
@@ -112,7 +112,7 @@ class MemRegion : public llvm::FoldingSetNode {
public:
ASTContext &getContext() const;
- virtual void Profile(llvm::FoldingSetNodeID& ID) const = 0;
+ virtual void Profile(llvm::FoldingSetNodeID &ID) const = 0;
virtual MemRegionManager &getMemRegionManager() const = 0;
@@ -171,7 +171,7 @@ class MemRegion : public llvm::FoldingSetNode {
Kind getKind() const { return kind; }
- template<typename RegionTy> const RegionTy* getAs() const;
+ template <typename RegionTy> const RegionTy *getAs() const;
template <typename RegionTy>
LLVM_ATTRIBUTE_RETURNS_NONNULL const RegionTy *castAs() const;
@@ -442,7 +442,7 @@ class SubRegion : public MemRegion {
virtual void anchor();
protected:
- const MemRegion* superRegion;
+ const MemRegion *superRegion;
SubRegion(const MemRegion *sReg, Kind k) : MemRegion(k), superRegion(sReg) {
assert(classof(this));
@@ -451,15 +451,13 @@ class SubRegion : public MemRegion {
public:
LLVM_ATTRIBUTE_RETURNS_NONNULL
- const MemRegion* getSuperRegion() const {
- return superRegion;
- }
+ const MemRegion *getSuperRegion() const { return superRegion; }
MemRegionManager &getMemRegionManager() const override;
- bool isSubRegionOf(const MemRegion* R) const override;
+ bool isSubRegionOf(const MemRegion *R) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() > END_MEMSPACES;
}
};
@@ -484,7 +482,7 @@ class AllocaRegion : public SubRegion {
assert(Ex);
}
- static void ProfileRegion(llvm::FoldingSetNodeID& ID, const Expr *Ex,
+ static void ProfileRegion(llvm::FoldingSetNodeID &ID, const Expr *Ex,
unsigned Cnt, const MemRegion *superRegion);
public:
@@ -493,11 +491,11 @@ class AllocaRegion : public SubRegion {
bool isBoundable() const override { return true; }
- void Profile(llvm::FoldingSetNodeID& ID) const override;
+ void Profile(llvm::FoldingSetNodeID &ID) const override;
void dumpToStream(raw_ostream &os) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == AllocaRegionKind;
}
};
@@ -520,18 +518,19 @@ class TypedRegion : public SubRegion {
bool isBoundable() const override { return true; }
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
unsigned k = R->getKind();
return k >= BEGIN_TYPED_REGIONS && k <= END_TYPED_REGIONS;
}
};
-/// TypedValueRegion - An abstract class representing regions having a typed value.
+/// TypedValueRegion - An abstract class representing regions having a typed
+/// value.
class TypedValueRegion : public TypedRegion {
void anchor() override;
protected:
- TypedValueRegion(const MemRegion* sReg, Kind k) : TypedRegion(sReg, k) {
+ TypedValueRegion(const MemRegion *sReg, Kind k) : TypedRegion(sReg, k) {
assert(classof(this));
}
@@ -552,7 +551,7 @@ class TypedValueRegion : public TypedRegion {
return T.getTypePtrOrNull() ? T.getDesugaredType(Context) : T;
}
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
unsigned k = R->getKind();
return k >= BEGIN_TYPED_VALUE_REGIONS && k <= END_TYPED_VALUE_REGIONS;
}
@@ -569,7 +568,7 @@ class CodeTextRegion : public TypedRegion {
public:
bool isBoundable() const override { return false; }
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
Kind k = R->getKind();
return k >= BEGIN_CODE_TEXT_REGIONS && k <= END_CODE_TEXT_REGIONS;
}
@@ -581,13 +580,13 @@ class FunctionCodeRegion : public CodeTextRegion {
const NamedDecl *FD;
- FunctionCodeRegion(const NamedDecl *fd, const CodeSpaceRegion* sreg)
+ FunctionCodeRegion(const NamedDecl *fd, const CodeSpaceRegion *sreg)
: CodeTextRegion(sreg, FunctionCodeRegionKind), FD(fd) {
assert(isa<ObjCMethodDecl>(fd) || isa<FunctionDecl>(fd));
}
- static void ProfileRegion(llvm::FoldingSetNodeID& ID, const NamedDecl *FD,
- const MemRegion*);
+ static void ProfileRegion(llvm::FoldingSetNodeID &ID, const NamedDecl *FD,
+ const MemRegion *);
public:
QualType getLocationType() const override {
@@ -604,15 +603,13 @@ class FunctionCodeRegion : public CodeTextRegion {
return {};
}
- const NamedDecl *getDecl() const {
- return FD;
- }
+ const NamedDecl *getDecl() const { return FD; }
void dumpToStream(raw_ostream &os) const override;
- void Profile(llvm::FoldingSetNodeID& ID) const override;
+ void Profile(llvm::FoldingSetNodeID &ID) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == FunctionCodeRegionKind;
}
};
@@ -630,36 +627,32 @@ class BlockCodeRegion : public CodeTextRegion {
AnalysisDeclContext *AC;
CanQualType locTy;
- BlockCodeRegion(const BlockDecl *bd, CanQualType lTy,
- AnalysisDeclContext *ac, const CodeSpaceRegion* sreg)
+ BlockCodeRegion(const BlockDecl *bd, CanQualType lTy, AnalysisDeclContext *ac,
+ const CodeSpaceRegion *sreg)
: CodeTextRegion(sreg, BlockCodeRegionKind), BD(bd), AC(ac), locTy(lTy) {
assert(bd);
assert(ac);
assert(lTy->getTypePtr()->isBlockPointerType());
}
- static void ProfileRegion(llvm::FoldingSetNodeID& ID, const BlockDecl *BD,
- CanQualType, const AnalysisDeclContext*,
- const MemRegion*);
+ static void ProfileRegion(llvm::FoldingSetNodeID &ID, const BlockDecl *BD,
+ CanQualType, const AnalysisDeclContext *,
+ const MemRegion *);
public:
- QualType getLocationType() const override {
- return locTy;
- }
+ QualType getLocationType() const override { return locTy; }
LLVM_ATTRIBUTE_RETURNS_NONNULL
- const BlockDecl *getDecl() const {
- return BD;
- }
+ const BlockDecl *getDecl() const { return BD; }
LLVM_ATTRIBUTE_RETURNS_NONNULL
AnalysisDeclContext *getAnalysisDeclContext() const { return AC; }
void dumpToStream(raw_ostream &os) const override;
- void Profile(llvm::FoldingSetNodeID& ID) const override;
+ void Profile(llvm::FoldingSetNodeID &ID) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == BlockCodeRegionKind;
}
};
@@ -687,11 +680,10 @@ class BlockDataRegion : public TypedRegion {
assert(bc->getDecl());
assert(lc);
assert(isa<GlobalImmutableSpaceRegion>(sreg) ||
- isa<StackLocalsSpaceRegion>(sreg) ||
- isa<UnknownSpaceRegion>(sreg));
+ isa<StackLocalsSpaceRegion>(sreg) || isa<UnknownSpaceRegion>(sreg));
}
- static void ProfileRegion(llvm::FoldingSetNodeID&, const BlockCodeRegion *,
+ static void ProfileRegion(llvm::FoldingSetNodeID &, const BlockCodeRegion *,
const LocationContext *, unsigned,
const MemRegion *);
@@ -705,18 +697,16 @@ class BlockDataRegion : public TypedRegion {
QualType getLocationType() const override { return BC->getLocationType(); }
class referenced_vars_iterator {
- const MemRegion * const *R;
- const MemRegion * const *OriginalR;
+ const MemRegion *const *R;
+ const MemRegion *const *OriginalR;
public:
- explicit referenced_vars_iterator(const MemRegion * const *r,
- const MemRegion * const *originalR)
+ explicit referenced_vars_iterator(const MemRegion *const *r,
+ const MemRegion *const *originalR)
: R(r), OriginalR(originalR) {}
LLVM_ATTRIBUTE_RETURNS_NONNULL
- const VarRegion *getCapturedRegion() const {
- return cast<VarRegion>(*R);
- }
+ const VarRegion *getCapturedRegion() const { return cast<VarRegion>(*R); }
LLVM_ATTRIBUTE_RETURNS_NONNULL
const VarRegion *getOriginalRegion() const {
@@ -755,9 +745,9 @@ class BlockDataRegion : public TypedRegion {
void dumpToStream(raw_ostream &os) const override;
- void Profile(llvm::FoldingSetNodeID& ID) const override;
+ void Profile(llvm::FoldingSetNodeID &ID) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == BlockDataRegionKind;
}
@@ -807,15 +797,14 @@ class SymbolicRegion : public SubRegion {
bool isBoundable() const override { return true; }
- void Profile(llvm::FoldingSetNodeID& ID) const override;
+ void Profile(llvm::FoldingSetNodeID &ID) const override;
- static void ProfileRegion(llvm::FoldingSetNodeID& ID,
- SymbolRef sym,
- const MemRegion* superRegion);
+ static void ProfileRegion(llvm::FoldingSetNodeID &ID, SymbolRef sym,
+ const MemRegion *superRegion);
void dumpToStream(raw_ostream &os) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == SymbolicRegionKind;
}
};
@@ -843,13 +832,13 @@ class StringRegion : public TypedValueRegion {
bool isBoundable() const override { return false; }
- void Profile(llvm::FoldingSetNodeID& ID) const override {
+ void Profile(llvm::FoldingSetNodeID &ID) const override {
ProfileRegion(ID, Str, superRegion);
}
void dumpToStream(raw_ostream &os) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == StringRegionKind;
}
};
@@ -878,13 +867,13 @@ class ObjCStringRegion : public TypedValueRegion {
bool isBoundable() const override { return false; }
- void Profile(llvm::FoldingSetNodeID& ID) const override {
+ void Profile(llvm::FoldingSetNodeID &ID) const override {
ProfileRegion(ID, Str, superRegion);
}
void dumpToStream(raw_ostream &os) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == ObjCStringRegionKind;
}
};
@@ -905,23 +894,23 @@ class CompoundLiteralRegion : public TypedValueRegion {
isa<StackLocalsSpaceRegion>(sReg));
}
- static void ProfileRegion(llvm::FoldingSetNodeID& ID,
+ static void ProfileRegion(llvm::FoldingSetNodeID &ID,
const CompoundLiteralExpr *CL,
- const MemRegion* superRegion);
+ const MemRegion *superRegion);
public:
QualType getValueType() const override { return CL->getType(); }
bool isBoundable() const override { return !CL->isFileScope(); }
- void Profile(llvm::FoldingSetNodeID& ID) const override;
+ void Profile(llvm::FoldingSetNodeID &ID) const override;
void dumpToStream(raw_ostream &os) const override;
LLVM_ATTRIBUTE_RETURNS_NONNULL
const CompoundLiteralExpr *getLiteralExpr() const { return CL; }
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == CompoundLiteralRegionKind;
}
};
@@ -936,7 +925,7 @@ class DeclRegion : public TypedValueRegion {
// TODO what does this return?
virtual const ValueDecl *getDecl() const = 0;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
unsigned k = R->getKind();
return k >= BEGIN_DECL_REGIONS && k <= END_DECL_REGIONS;
}
@@ -1011,7 +1000,7 @@ class NonParamVarRegion : public VarRegion {
void printPrettyAsExpr(raw_ostream &os) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == NonParamVarRegionKind;
}
};
@@ -1046,7 +1035,7 @@ class ParamVarRegion : public VarRegion {
const Expr *getOriginExpr() const { return OriginExpr; }
unsigned getIndex() const { return Index; }
- void Profile(llvm::FoldingSetNodeID& ID) const override;
+ void Profile(llvm::FoldingSetNodeID &ID) const override;
void dumpToStream(raw_ostream &os) const override;
@@ -1077,20 +1066,17 @@ class CXXThisRegion : public TypedValueRegion {
"Invalid region type!");
}
- static void ProfileRegion(llvm::FoldingSetNodeID &ID,
- const PointerType *PT,
+ static void ProfileRegion(llvm::FoldingSetNodeID &ID, const PointerType *PT,
const MemRegion *sReg);
public:
void Profile(llvm::FoldingSetNodeID &ID) const override;
- QualType getValueType() const override {
- return QualType(ThisPointerTy, 0);
- }
+ QualType getValueType() const override { return QualType(ThisPointerTy, 0); }
void dumpToStream(raw_ostream &os) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == CXXThisRegionKind;
}
@@ -1109,7 +1095,7 @@ class FieldRegion : public DeclRegion {
}
static void ProfileRegion(llvm::FoldingSetNodeID &ID, const FieldDecl *FD,
- const MemRegion* superRegion) {
+ const MemRegion *superRegion) {
ID.AddInteger(static_cast<unsigned>(FieldRegionKind));
ID.AddPointer(FD);
ID.AddPointer(superRegion);
@@ -1133,7 +1119,7 @@ class FieldRegion : public DeclRegion {
bool canPrintPrettyAsExpr() const override;
void printPrettyAsExpr(raw_ostream &os) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == FieldRegionKind;
}
};
@@ -1145,14 +1131,14 @@ class ObjCIvarRegion : public DeclRegion {
ObjCIvarRegion(const ObjCIvarDecl *ivd, const SubRegion *sReg);
- static void ProfileRegion(llvm::FoldingSetNodeID& ID, const ObjCIvarDecl *ivd,
- const MemRegion* superRegion);
+ static void ProfileRegion(llvm::FoldingSetNodeID &ID, const ObjCIvarDecl *ivd,
+ const MemRegion *superRegion);
public:
LLVM_ATTRIBUTE_RETURNS_NONNULL
const ObjCIvarDecl *getDecl() const override;
- void Profile(llvm::FoldingSetNodeID& ID) const override;
+ void Profile(llvm::FoldingSetNodeID &ID) const override;
QualType getValueType() const override;
@@ -1161,7 +1147,7 @@ class ObjCIvarRegion : public DeclRegion {
void dumpToStream(raw_ostream &os) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == ObjCIvarRegionKind;
}
};
@@ -1176,7 +1162,7 @@ class RegionRawOffset {
const MemRegion *Region;
CharUnits Offset;
- RegionRawOffset(const MemRegion* reg, CharUnits offset = CharUnits::Zero())
+ RegionRawOffset(const MemRegion *reg, CharUnits offset = CharUnits::Zero())
: Region(reg), Offset(offset) {}
public:
@@ -1207,8 +1193,8 @@ class ElementRegion : public TypedValueRegion {
"Invalid region type!");
}
- static void ProfileRegion(llvm::FoldingSetNodeID& ID, QualType elementType,
- SVal Idx, const MemRegion* superRegion);
+ static void ProfileRegion(llvm::FoldingSetNodeID &ID, QualType elementType,
+ SVal Idx, const MemRegion *superRegion);
public:
NonLoc getIndex() const { return Index; }
@@ -1222,9 +1208,9 @@ class ElementRegion : public TypedValueRegion {
void dumpToStream(raw_ostream &os) const override;
- void Profile(llvm::FoldingSetNodeID& ID) const override;
+ void Profile(llvm::FoldingSetNodeID &ID) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == ElementRegionKind;
}
};
@@ -1241,8 +1227,8 @@ class CXXTempObjectRegion : public TypedValueRegion {
assert(isa<StackLocalsSpaceRegion>(sReg));
}
- static void ProfileRegion(llvm::FoldingSetNodeID &ID,
- Expr const *E, const MemRegion *sReg);
+ static void ProfileRegion(llvm::FoldingSetNodeID &ID, Expr const *E,
+ const MemRegion *sReg);
public:
LLVM_ATTRIBUTE_RETURNS_NONNULL
@@ -1257,7 +1243,7 @@ class CXXTempObjectRegion : public TypedValueRegion {
void Profile(llvm::FoldingSetNodeID &ID) const override;
- static bool classof(const MemRegion* R) {
+ static bool classof(const MemRegion *R) {
return R->getKind() == CXXTempObjectRegionKind;
}
};
@@ -1379,8 +1365,7 @@ class CXXDerivedObjectRegion : public TypedValueRegion {
}
};
-template<typename RegionTy>
-const RegionTy* MemRegion::getAs() const {
+template <typename RegionTy> const RegionTy *MemRegion::getAs() const {
if (const auto *RT = dyn_cast<RegionTy>(this))
return RT;
@@ -1398,7 +1383,7 @@ LLVM_ATTRIBUTE_RETURNS_NONNULL const RegionTy *MemRegion::castAs() const {
class MemRegionManager {
ASTContext &Ctx;
- llvm::BumpPtrAllocator& A;
+ llvm::BumpPtrAllocator &A;
llvm::FoldingSet<MemRegion> Regions;
@@ -1407,11 +1392,11 @@ class MemRegionManager {
GlobalImmutableSpaceRegion *ImmutableGlobals = nullptr;
llvm::DenseMap<const StackFrameContext *, StackLocalsSpaceRegion *>
- StackLocalsSpaceRegions;
+ StackLocalsSpaceRegions;
llvm::DenseMap<const StackFrameContext *, StackArgumentsSpaceRegion *>
- StackArgumentsSpaceRegions;
+ StackArgumentsSpaceRegions;
llvm::DenseMap<const CodeTextRegion *, StaticGlobalSpaceRegion *>
- StaticsGlobalSpaceRegions;
+ StaticsGlobalSpaceRegions;
HeapSpaceRegion *heap = nullptr;
UnknownSpaceRegion *unknown = nullptr;
@@ -1443,9 +1428,9 @@ class MemRegionManager {
/// getGlobalsRegion - Retrieve the memory region associated with
/// global variables.
- const GlobalsSpaceRegion *getGlobalsRegion(
- MemRegion::Kind K = MemRegion::GlobalInternalSpaceRegionKind,
- const CodeTextRegion *R = nullptr);
+ const GlobalsSpaceRegion *
+ getGlobalsRegion(MemRegion::Kind K = MemRegion::GlobalInternalSpaceRegionKind,
+ const CodeTextRegion *R = nullptr);
/// getHeapRegion - Retrieve the memory region associated with the
/// generic "heap".
@@ -1463,7 +1448,7 @@ class MemRegionManager {
/// getCompoundLiteralRegion - Retrieve the region associated with a
/// given CompoundLiteral.
- const CompoundLiteralRegion*
+ const CompoundLiteralRegion *
getCompoundLiteralRegion(const CompoundLiteralExpr *CL,
const LocationContext *LC);
@@ -1507,8 +1492,8 @@ class MemRegionManager {
const ElementRegion *getElementRegionWithSuper(const ElementRegion *ER,
const SubRegion *superRegion) {
- return getElementRegion(ER->getElementType(), ER->getIndex(),
- superRegion, ER->getContext());
+ return getElementRegion(ER->getElementType(), ER->getIndex(), superRegion,
+ ER->getContext());
}
/// getFieldRegion - Retrieve or create the memory region associated with
@@ -1516,7 +1501,7 @@ class MemRegionManager {
/// memory region (which typically represents the memory representing
/// a structure or class).
const FieldRegion *getFieldRegion(const FieldDecl *fd,
- const SubRegion* superRegion);
+ const SubRegion *superRegion);
const FieldRegion *getFieldRegionWithSuper(const FieldRegion *FR,
const SubRegion *superRegion) {
@@ -1528,7 +1513,7 @@ class MemRegionManager {
/// to the containing region (which typically represents the Objective-C
/// object).
const ObjCIvarRegion *getObjCIvarRegion(const ObjCIvarDecl *ivd,
- const SubRegion* superRegion);
+ const SubRegion *superRegion);
const CXXTempObjectRegion *getCXXTempObjectRegion(Expr const *Ex,
LocationContext const *LC);
@@ -1585,27 +1570,23 @@ class MemRegionManager {
unsigned blockCount);
private:
- template <typename RegionTy, typename SuperTy,
- typename Arg1Ty>
- RegionTy* getSubRegion(const Arg1Ty arg1,
- const SuperTy* superRegion);
+ template <typename RegionTy, typename SuperTy, typename Arg1Ty>
+ RegionTy *getSubRegion(const Arg1Ty arg1, const SuperTy *superRegion);
- template <typename RegionTy, typename SuperTy,
- typename Arg1Ty, typename Arg2Ty>
- RegionTy* getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2,
- const SuperTy* superRegion);
+ template <typename RegionTy, typename SuperTy, typename Arg1Ty,
+ typename Arg2Ty>
+ RegionTy *getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2,
+ const SuperTy *superRegion);
- template <typename RegionTy, typename SuperTy,
- typename Arg1Ty, typename Arg2Ty, typename Arg3Ty>
- RegionTy* getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2,
- const Arg3Ty arg3,
- const SuperTy* superRegion);
+ template <typename RegionTy, typename SuperTy, typename Arg1Ty,
+ typename Arg2Ty, typename Arg3Ty>
+ RegionTy *getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2,
+ const Arg3Ty arg3, const SuperTy *superRegion);
- template <typename REG>
- const REG* LazyAllocate(REG*& region);
+ template <typename REG> const REG *LazyAllocate(REG *®ion);
template <typename REG, typename ARG>
- const REG* LazyAllocate(REG*& region, ARG a);
+ const REG *LazyAllocate(REG *®ion, ARG a);
};
//===----------------------------------------------------------------------===//
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h
index ca75c2a756a4a5..8ed765db41a515 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h
@@ -39,9 +39,9 @@ class AnalysisManager;
class CallEvent;
class CallEventManager;
-typedef std::unique_ptr<ConstraintManager>(*ConstraintManagerCreator)(
+typedef std::unique_ptr<ConstraintManager> (*ConstraintManagerCreator)(
ProgramStateManager &, ExprEngine *);
-typedef std::unique_ptr<StoreManager>(*StoreManagerCreator)(
+typedef std::unique_ptr<StoreManager> (*StoreManagerCreator)(
ProgramStateManager &);
//===----------------------------------------------------------------------===//
@@ -50,9 +50,9 @@ typedef std::unique_ptr<StoreManager>(*StoreManagerCreator)(
template <typename T> struct ProgramStateTrait {
typedef typename T::data_type data_type;
- static inline void *MakeVoidPtr(data_type D) { return (void*) D; }
- static inline data_type MakeData(void *const* P) {
- return P ? (data_type) *P : (data_type) 0;
+ static inline void *MakeVoidPtr(data_type D) { return (void *)D; }
+ static inline data_type MakeData(void *const *P) {
+ return P ? (data_type)*P : (data_type)0;
}
};
@@ -70,11 +70,11 @@ template <typename T> struct ProgramStateTrait {
/// values will never change.
class ProgramState : public llvm::FoldingSetNode {
public:
- typedef llvm::ImmutableSet<llvm::APSInt*> IntSetTy;
- typedef llvm::ImmutableMap<void*, void*> GenericDataMap;
+ typedef llvm::ImmutableSet<llvm::APSInt *> IntSetTy;
+ typedef llvm::ImmutableMap<void *, void *> GenericDataMap;
private:
- void operator=(const ProgramState& R) = delete;
+ void operator=(const ProgramState &R) = delete;
friend class ProgramStateManager;
friend class ExplodedGraph;
@@ -82,9 +82,9 @@ class ProgramState : public llvm::FoldingSetNode {
friend class NodeBuilder;
ProgramStateManager *stateMgr;
- Environment Env; // Maps a Stmt to its current SVal.
- Store store; // Maps a location to its current value.
- GenericDataMap GDM; // Custom data stored by a client of this class.
+ Environment Env; // Maps a Stmt to its current SVal.
+ Store store; // Maps a location to its current value.
+ GenericDataMap GDM; // Custom data stored by a client of this class.
// A state is infeasible if there is a contradiction among the constraints.
// An infeasible state is represented by a `nullptr`.
@@ -132,8 +132,8 @@ class ProgramState : public llvm::FoldingSetNode {
public:
/// This ctor is used when creating the first ProgramState object.
- ProgramState(ProgramStateManager *mgr, const Environment& env,
- StoreRef st, GenericDataMap gdm);
+ ProgramState(ProgramStateManager *mgr, const Environment &env, StoreRef st,
+ GenericDataMap gdm);
/// Copy ctor - We must explicitly define this or else the "Next" ptr
/// in FoldingSetNode will also get copied.
@@ -144,9 +144,7 @@ class ProgramState : public llvm::FoldingSetNode {
int64_t getID() const;
/// Return the ProgramStateManager associated with this state.
- ProgramStateManager &getStateManager() const {
- return *stateMgr;
- }
+ ProgramStateManager &getStateManager() const { return *stateMgr; }
AnalysisManager &getAnalysisManager() const;
@@ -155,13 +153,12 @@ class ProgramState : public llvm::FoldingSetNode {
/// getEnvironment - Return the environment associated with this state.
/// The environment is the mapping from expressions to values.
- const Environment& getEnvironment() const { return Env; }
+ const Environment &getEnvironment() const { return Env; }
/// Return the store associated with this state. The store
/// is a mapping from locations to values.
Store getStore() const { return store; }
-
/// getGDM - Return the generic data map associated with this state.
GenericDataMap getGDM() const { return GDM; }
@@ -170,7 +167,7 @@ class ProgramState : public llvm::FoldingSetNode {
/// Profile - Profile the contents of a ProgramState object for use in a
/// FoldingSet. Two ProgramState objects are considered equal if they
/// have the same Environment, Store, and GenericDataMap.
- static void Profile(llvm::FoldingSetNodeID& ID, const ProgramState *V) {
+ static void Profile(llvm::FoldingSetNodeID &ID, const ProgramState *V) {
V->Env.Profile(ID);
ID.AddPointer(V->store);
V->GDM.Profile(ID);
@@ -179,9 +176,7 @@ class ProgramState : public llvm::FoldingSetNode {
/// Profile - Used to profile the contents of this object for inclusion
/// in a FoldingSet.
- void Profile(llvm::FoldingSetNodeID& ID) const {
- Profile(ID, this);
- }
+ void Profile(llvm::FoldingSetNodeID &ID) const { Profile(ID, this); }
BasicValueFactory &getBasicVals() const;
SymbolManager &getSymbolManager() const;
@@ -190,12 +185,12 @@ class ProgramState : public llvm::FoldingSetNode {
// Constraints on values.
//==---------------------------------------------------------------------==//
//
- // Each ProgramState records constraints on symbolic values. These constraints
- // are managed using the ConstraintManager associated with a ProgramStateManager.
- // As constraints gradually accrue on symbolic values, added constraints
- // may conflict and indicate that a state is infeasible (as no real values
- // could satisfy all the constraints). This is the principal mechanism
- // for modeling path-sensitivity in ExprEngine/ProgramState.
+ // Each ProgramState records constraints on symbolic values. These
+ // constraints are managed using the ConstraintManager associated with a
+ // ProgramStateManager. As constraints gradually accrue on symbolic values,
+ // added constraints may conflict and indicate that a state is infeasible (as
+ // no real values could satisfy all the constraints). This is the principal
+ // mechanism for modeling path-sensitivity in ExprEngine/ProgramState.
//
// Various "assume" methods form the interface for adding constraints to
// symbolic values. A call to 'assume' indicates an assumption being placed
@@ -208,8 +203,8 @@ class ProgramState : public llvm::FoldingSetNode {
// (3) A binary value "Assumption" that indicates whether the constraint is
// assumed to be true or false.
//
- // The output of "assume*" is a new ProgramState object with the added constraints.
- // If no new state is feasible, NULL is returned.
+ // The output of "assume*" is a new ProgramState object with the added
+ // constraints. If no new state is feasible, NULL is returned.
//
/// Assumes that the value of \p cond is zero (if \p assumption is "false")
@@ -269,7 +264,7 @@ class ProgramState : public llvm::FoldingSetNode {
/// Utility method for getting regions.
LLVM_ATTRIBUTE_RETURNS_NONNULL
- const VarRegion* getRegion(const VarDecl *D, const LocationContext *LC) const;
+ const VarRegion *getRegion(const VarDecl *D, const LocationContext *LC) const;
//==---------------------------------------------------------------------==//
// Binding and retrieving values to/from the environment and symbolic store.
@@ -380,11 +375,11 @@ class ProgramState : public llvm::FoldingSetNode {
SVal getSVal(Loc LV, QualType T = QualType()) const;
/// Returns the "raw" SVal bound to LV before any value simplfication.
- SVal getRawSVal(Loc LV, QualType T= QualType()) const;
+ SVal getRawSVal(Loc LV, QualType T = QualType()) const;
/// Return the value bound to the specified location.
/// Returns UnknownVal() if none found.
- SVal getSVal(const MemRegion* R, QualType T = QualType()) const;
+ SVal getSVal(const MemRegion *R, QualType T = QualType()) const;
/// Return the value bound to the specified location, assuming
/// that the value is a scalar integer or an enumeration or a pointer.
@@ -401,7 +396,7 @@ class ProgramState : public llvm::FoldingSetNode {
/// directly when making multiple scans on the same state with the same
/// visitor to avoid repeated initialization cost.
/// \sa ScanReachableSymbols
- bool scanReachableSymbols(SVal val, SymbolVisitor& visitor) const;
+ bool scanReachableSymbols(SVal val, SymbolVisitor &visitor) const;
/// Visits the symbols reachable from the regions in the given
/// MemRegions range using the provided SymbolVisitor.
@@ -409,29 +404,29 @@ class ProgramState : public llvm::FoldingSetNode {
SymbolVisitor &visitor) const;
template <typename CB> CB scanReachableSymbols(SVal val) const;
- template <typename CB> CB
- scanReachableSymbols(llvm::iterator_range<region_iterator> Reachable) const;
+ template <typename CB>
+ CB scanReachableSymbols(
+ llvm::iterator_range<region_iterator> Reachable) const;
//==---------------------------------------------------------------------==//
// Accessing the Generic Data Map (GDM).
//==---------------------------------------------------------------------==//
- void *const* FindGDM(void *K) const;
+ void *const *FindGDM(void *K) const;
template <typename T>
[[nodiscard]] ProgramStateRef
add(typename ProgramStateTrait<T>::key_type K) const;
- template <typename T>
- typename ProgramStateTrait<T>::data_type
- get() const {
- return ProgramStateTrait<T>::MakeData(FindGDM(ProgramStateTrait<T>::GDMIndex()));
+ template <typename T> typename ProgramStateTrait<T>::data_type get() const {
+ return ProgramStateTrait<T>::MakeData(
+ FindGDM(ProgramStateTrait<T>::GDMIndex()));
}
- template<typename T>
+ template <typename T>
typename ProgramStateTrait<T>::lookup_type
get(typename ProgramStateTrait<T>::key_type key) const {
- void *const* d = FindGDM(ProgramStateTrait<T>::GDMIndex());
+ void *const *d = FindGDM(ProgramStateTrait<T>::GDMIndex());
return ProgramStateTrait<T>::Lookup(ProgramStateTrait<T>::MakeData(d), key);
}
@@ -464,10 +459,11 @@ class ProgramState : public llvm::FoldingSetNode {
typename ProgramStateTrait<T>::value_type E,
typename ProgramStateTrait<T>::context_type C) const;
- template<typename T>
+ template <typename T>
bool contains(typename ProgramStateTrait<T>::key_type key) const {
- void *const* d = FindGDM(ProgramStateTrait<T>::GDMIndex());
- return ProgramStateTrait<T>::Contains(ProgramStateTrait<T>::MakeData(d), key);
+ void *const *d = FindGDM(ProgramStateTrait<T>::GDMIndex());
+ return ProgramStateTrait<T>::Contains(ProgramStateTrait<T>::MakeData(d),
+ key);
}
// Pretty-printing.
@@ -487,11 +483,9 @@ class ProgramState : public llvm::FoldingSetNode {
/// \sa invalidateValues()
/// \sa invalidateRegions()
ProgramStateRef
- invalidateRegionsImpl(ArrayRef<SVal> Values,
- const Expr *E, unsigned BlockCount,
- const LocationContext *LCtx,
- bool ResultsInSymbolEscape,
- InvalidatedSymbols *IS,
+ invalidateRegionsImpl(ArrayRef<SVal> Values, const Expr *E,
+ unsigned BlockCount, const LocationContext *LCtx,
+ bool ResultsInSymbolEscape, InvalidatedSymbols *IS,
RegionAndSymbolInvalidationTraits *HTraits,
const CallEvent *Call) const;
};
@@ -503,17 +497,19 @@ class ProgramState : public llvm::FoldingSetNode {
class ProgramStateManager {
friend class ProgramState;
friend void ProgramStateRelease(const ProgramState *state);
+
private:
/// Eng - The ExprEngine that owns this state manager.
ExprEngine *Eng; /* Can be null. */
- EnvironmentManager EnvMgr;
- std::unique_ptr<StoreManager> StoreMgr;
- std::unique_ptr<ConstraintManager> ConstraintMgr;
+ EnvironmentManager EnvMgr;
+ std::unique_ptr<StoreManager> StoreMgr;
+ std::unique_ptr<ConstraintManager> ConstraintMgr;
- ProgramState::GenericDataMap::Factory GDMFactory;
+ ProgramState::GenericDataMap::Factory GDMFactory;
- typedef llvm::DenseMap<void*,std::pair<void*,void (*)(void*)> > GDMContextsTy;
+ typedef llvm::DenseMap<void *, std::pair<void *, void (*)(void *)>>
+ GDMContextsTy;
GDMContextsTy GDMContexts;
/// StateSet - FoldingSet containing all the states created for analyzing
@@ -533,11 +529,9 @@ class ProgramStateManager {
std::vector<ProgramState *> freeStates;
public:
- ProgramStateManager(ASTContext &Ctx,
- StoreManagerCreator CreateStoreManager,
- ConstraintManagerCreator CreateConstraintManager,
- llvm::BumpPtrAllocator& alloc,
- ExprEngine *expreng);
+ ProgramStateManager(ASTContext &Ctx, StoreManagerCreator CreateStoreManager,
+ ConstraintManagerCreator CreateConstraintManager,
+ llvm::BumpPtrAllocator &alloc, ExprEngine *expreng);
~ProgramStateManager();
@@ -550,24 +544,18 @@ class ProgramStateManager {
return svalBuilder->getBasicValueFactory();
}
- SValBuilder &getSValBuilder() {
- return *svalBuilder;
- }
+ SValBuilder &getSValBuilder() { return *svalBuilder; }
- const SValBuilder &getSValBuilder() const {
- return *svalBuilder;
- }
+ const SValBuilder &getSValBuilder() const { return *svalBuilder; }
- SymbolManager &getSymbolManager() {
- return svalBuilder->getSymbolManager();
- }
+ SymbolManager &getSymbolManager() { return svalBuilder->getSymbolManager(); }
const SymbolManager &getSymbolManager() const {
return svalBuilder->getSymbolManager();
}
- llvm::BumpPtrAllocator& getAllocator() { return Alloc; }
+ llvm::BumpPtrAllocator &getAllocator() { return Alloc; }
- MemRegionManager& getRegionManager() {
+ MemRegionManager &getRegionManager() {
return svalBuilder->getRegionManager();
}
const MemRegionManager &getRegionManager() const {
@@ -586,7 +574,6 @@ class ProgramStateManager {
SymbolReaper &SymReaper);
public:
-
SVal ArrayToPointer(Loc Array, QualType ElementTy) {
return StoreMgr->ArrayToPointer(Array, ElementTy);
}
@@ -597,13 +584,13 @@ class ProgramStateManager {
// Methods that query & manipulate the Store.
- void iterBindings(ProgramStateRef state, StoreManager::BindingsHandler& F) {
+ void iterBindings(ProgramStateRef state, StoreManager::BindingsHandler &F) {
StoreMgr->iterBindings(state->getStore(), F);
}
ProgramStateRef getPersistentState(ProgramState &Impl);
ProgramStateRef getPersistentStateWithGDM(ProgramStateRef FromState,
- ProgramStateRef GDMState);
+ ProgramStateRef GDMState);
bool haveEqualConstraints(ProgramStateRef S1, ProgramStateRef S2) const {
return ConstraintMgr->haveEqualConstraints(S1, S2);
@@ -621,15 +608,15 @@ class ProgramStateManager {
// Generic Data Map methods.
//==---------------------------------------------------------------------==//
//
- // ProgramStateManager and ProgramState support a "generic data map" that allows
- // different clients of ProgramState objects to embed arbitrary data within a
- // ProgramState object. The generic data map is essentially an immutable map
- // from a "tag" (that acts as the "key" for a client) and opaque values.
- // Tags/keys and values are simply void* values. The typical way that clients
- // generate unique tags are by taking the address of a static variable.
- // Clients are responsible for ensuring that data values referred to by a
- // the data pointer are immutable (and thus are essentially purely functional
- // data).
+ // ProgramStateManager and ProgramState support a "generic data map" that
+ // allows different clients of ProgramState objects to embed arbitrary data
+ // within a ProgramState object. The generic data map is essentially an
+ // immutable map from a "tag" (that acts as the "key" for a client) and opaque
+ // values. Tags/keys and values are simply void* values. The typical way that
+ // clients generate unique tags are by taking the address of a static
+ // variable. Clients are responsible for ensuring that data values referred to
+ // by a the data pointer are immutable (and thus are essentially purely
+ // functional data).
//
// The templated methods below use the ProgramStateTrait<T> class
// to resolve keys into the GDM and to return data values to clients.
@@ -637,46 +624,49 @@ class ProgramStateManager {
// Trait based GDM dispatch.
template <typename T>
- ProgramStateRef set(ProgramStateRef st, typename ProgramStateTrait<T>::data_type D) {
+ ProgramStateRef set(ProgramStateRef st,
+ typename ProgramStateTrait<T>::data_type D) {
return addGDM(st, ProgramStateTrait<T>::GDMIndex(),
ProgramStateTrait<T>::MakeVoidPtr(D));
}
- template<typename T>
+ template <typename T>
ProgramStateRef set(ProgramStateRef st,
- typename ProgramStateTrait<T>::key_type K,
- typename ProgramStateTrait<T>::value_type V,
- typename ProgramStateTrait<T>::context_type C) {
+ typename ProgramStateTrait<T>::key_type K,
+ typename ProgramStateTrait<T>::value_type V,
+ typename ProgramStateTrait<T>::context_type C) {
return addGDM(st, ProgramStateTrait<T>::GDMIndex(),
- ProgramStateTrait<T>::MakeVoidPtr(ProgramStateTrait<T>::Set(st->get<T>(), K, V, C)));
+ ProgramStateTrait<T>::MakeVoidPtr(
+ ProgramStateTrait<T>::Set(st->get<T>(), K, V, C)));
}
template <typename T>
ProgramStateRef add(ProgramStateRef st,
- typename ProgramStateTrait<T>::key_type K,
- typename ProgramStateTrait<T>::context_type C) {
+ typename ProgramStateTrait<T>::key_type K,
+ typename ProgramStateTrait<T>::context_type C) {
return addGDM(st, ProgramStateTrait<T>::GDMIndex(),
- ProgramStateTrait<T>::MakeVoidPtr(ProgramStateTrait<T>::Add(st->get<T>(), K, C)));
+ ProgramStateTrait<T>::MakeVoidPtr(
+ ProgramStateTrait<T>::Add(st->get<T>(), K, C)));
}
template <typename T>
ProgramStateRef remove(ProgramStateRef st,
- typename ProgramStateTrait<T>::key_type K,
- typename ProgramStateTrait<T>::context_type C) {
+ typename ProgramStateTrait<T>::key_type K,
+ typename ProgramStateTrait<T>::context_type C) {
return addGDM(st, ProgramStateTrait<T>::GDMIndex(),
- ProgramStateTrait<T>::MakeVoidPtr(ProgramStateTrait<T>::Remove(st->get<T>(), K, C)));
+ ProgramStateTrait<T>::MakeVoidPtr(
+ ProgramStateTrait<T>::Remove(st->get<T>(), K, C)));
}
- template <typename T>
- ProgramStateRef remove(ProgramStateRef st) {
+ template <typename T> ProgramStateRef remove(ProgramStateRef st) {
return removeGDM(st, ProgramStateTrait<T>::GDMIndex());
}
void *FindGDMContext(void *index,
- void *(*CreateContext)(llvm::BumpPtrAllocator&),
- void (*DeleteContext)(void*));
+ void *(*CreateContext)(llvm::BumpPtrAllocator &),
+ void (*DeleteContext)(void *));
template <typename T>
typename ProgramStateTrait<T>::context_type get_context() {
@@ -688,7 +678,6 @@ class ProgramStateManager {
}
};
-
//===----------------------------------------------------------------------===//
// Out-of-line method definitions for ProgramState.
//===----------------------------------------------------------------------===//
@@ -697,28 +686,27 @@ inline ConstraintManager &ProgramState::getConstraintManager() const {
return stateMgr->getConstraintManager();
}
-inline const VarRegion* ProgramState::getRegion(const VarDecl *D,
- const LocationContext *LC) const
-{
+inline const VarRegion *
+ProgramState::getRegion(const VarDecl *D, const LocationContext *LC) const {
return getStateManager().getRegionManager().getVarRegion(D, LC);
}
inline ProgramStateRef ProgramState::assume(DefinedOrUnknownSVal Cond,
- bool Assumption) const {
+ bool Assumption) const {
if (Cond.isUnknown())
return this;
- return getStateManager().ConstraintMgr
- ->assume(this, Cond.castAs<DefinedSVal>(), Assumption);
+ return getStateManager().ConstraintMgr->assume(
+ this, Cond.castAs<DefinedSVal>(), Assumption);
}
-inline std::pair<ProgramStateRef , ProgramStateRef >
+inline std::pair<ProgramStateRef, ProgramStateRef>
ProgramState::assume(DefinedOrUnknownSVal Cond) const {
if (Cond.isUnknown())
return std::make_pair(this, this);
- return getStateManager().ConstraintMgr
- ->assumeDual(this, Cond.castAs<DefinedSVal>());
+ return getStateManager().ConstraintMgr->assumeDual(
+ this, Cond.castAs<DefinedSVal>());
}
inline ProgramStateRef ProgramState::assumeInclusiveRange(
@@ -746,7 +734,8 @@ ProgramState::assumeInclusiveRange(DefinedOrUnknownSVal Val,
this, Val.castAs<NonLoc>(), From, To);
}
-inline ProgramStateRef ProgramState::bindLoc(SVal LV, SVal V, const LocationContext *LCtx) const {
+inline ProgramStateRef
+ProgramState::bindLoc(SVal LV, SVal V, const LocationContext *LCtx) const {
if (std::optional<Loc> L = LV.getAs<Loc>())
return bindLoc(*L, V, LCtx);
return this;
@@ -756,25 +745,25 @@ inline Loc ProgramState::getLValue(const CXXBaseSpecifier &BaseSpec,
const SubRegion *Super) const {
const auto *Base = BaseSpec.getType()->getAsCXXRecordDecl();
return loc::MemRegionVal(
- getStateManager().getRegionManager().getCXXBaseObjectRegion(
- Base, Super, BaseSpec.isVirtual()));
+ getStateManager().getRegionManager().getCXXBaseObjectRegion(
+ Base, Super, BaseSpec.isVirtual()));
}
inline Loc ProgramState::getLValue(const CXXRecordDecl *BaseClass,
const SubRegion *Super,
bool IsVirtual) const {
return loc::MemRegionVal(
- getStateManager().getRegionManager().getCXXBaseObjectRegion(
- BaseClass, Super, IsVirtual));
+ getStateManager().getRegionManager().getCXXBaseObjectRegion(
+ BaseClass, Super, IsVirtual));
}
inline Loc ProgramState::getLValue(const VarDecl *VD,
- const LocationContext *LC) const {
+ const LocationContext *LC) const {
return getStateManager().StoreMgr->getLValueVar(VD, LC);
}
inline Loc ProgramState::getLValue(const CompoundLiteralExpr *literal,
- const LocationContext *LC) const {
+ const LocationContext *LC) const {
return getStateManager().StoreMgr->getLValueCompoundLiteral(literal, LC);
}
@@ -796,14 +785,15 @@ inline SVal ProgramState::getLValue(const IndirectFieldDecl *D,
return Base;
}
-inline SVal ProgramState::getLValue(QualType ElementType, SVal Idx, SVal Base) const{
+inline SVal ProgramState::getLValue(QualType ElementType, SVal Idx,
+ SVal Base) const {
if (std::optional<NonLoc> N = Idx.getAs<NonLoc>())
return getStateManager().StoreMgr->getLValueElement(ElementType, *N, Base);
return UnknownVal();
}
inline SVal ProgramState::getSVal(const Stmt *Ex,
- const LocationContext *LCtx) const{
+ const LocationContext *LCtx) const {
return Env.getSVal(EnvironmentEntry(Ex, LCtx),
*getStateManager().svalBuilder);
}
@@ -825,10 +815,9 @@ inline SVal ProgramState::getRawSVal(Loc LV, QualType T) const {
return getStateManager().StoreMgr->getBinding(getStore(), LV, T);
}
-inline SVal ProgramState::getSVal(const MemRegion* R, QualType T) const {
+inline SVal ProgramState::getSVal(const MemRegion *R, QualType T) const {
return getStateManager().StoreMgr->getBinding(getStore(),
- loc::MemRegionVal(R),
- T);
+ loc::MemRegionVal(R), T);
}
inline BasicValueFactory &ProgramState::getBasicVals() const {
@@ -839,8 +828,9 @@ inline SymbolManager &ProgramState::getSymbolManager() const {
return getStateManager().getSymbolManager();
}
-template<typename T>
-ProgramStateRef ProgramState::add(typename ProgramStateTrait<T>::key_type K) const {
+template <typename T>
+ProgramStateRef
+ProgramState::add(typename ProgramStateTrait<T>::key_type K) const {
return getStateManager().add<T>(this, K, get_context<T>());
}
@@ -849,42 +839,45 @@ typename ProgramStateTrait<T>::context_type ProgramState::get_context() const {
return getStateManager().get_context<T>();
}
-template<typename T>
-ProgramStateRef ProgramState::remove(typename ProgramStateTrait<T>::key_type K) const {
+template <typename T>
+ProgramStateRef
+ProgramState::remove(typename ProgramStateTrait<T>::key_type K) const {
return getStateManager().remove<T>(this, K, get_context<T>());
}
-template<typename T>
-ProgramStateRef ProgramState::remove(typename ProgramStateTrait<T>::key_type K,
- typename ProgramStateTrait<T>::context_type C) const {
+template <typename T>
+ProgramStateRef
+ProgramState::remove(typename ProgramStateTrait<T>::key_type K,
+ typename ProgramStateTrait<T>::context_type C) const {
return getStateManager().remove<T>(this, K, C);
}
-template <typename T>
-ProgramStateRef ProgramState::remove() const {
+template <typename T> ProgramStateRef ProgramState::remove() const {
return getStateManager().remove<T>(this);
}
-template<typename T>
-ProgramStateRef ProgramState::set(typename ProgramStateTrait<T>::data_type D) const {
+template <typename T>
+ProgramStateRef
+ProgramState::set(typename ProgramStateTrait<T>::data_type D) const {
return getStateManager().set<T>(this, D);
}
-template<typename T>
-ProgramStateRef ProgramState::set(typename ProgramStateTrait<T>::key_type K,
- typename ProgramStateTrait<T>::value_type E) const {
+template <typename T>
+ProgramStateRef
+ProgramState::set(typename ProgramStateTrait<T>::key_type K,
+ typename ProgramStateTrait<T>::value_type E) const {
return getStateManager().set<T>(this, K, E, get_context<T>());
}
-template<typename T>
-ProgramStateRef ProgramState::set(typename ProgramStateTrait<T>::key_type K,
- typename ProgramStateTrait<T>::value_type E,
- typename ProgramStateTrait<T>::context_type C) const {
+template <typename T>
+ProgramStateRef
+ProgramState::set(typename ProgramStateTrait<T>::key_type K,
+ typename ProgramStateTrait<T>::value_type E,
+ typename ProgramStateTrait<T>::context_type C) const {
return getStateManager().set<T>(this, K, E, C);
}
-template <typename CB>
-CB ProgramState::scanReachableSymbols(SVal val) const {
+template <typename CB> CB ProgramState::scanReachableSymbols(SVal val) const {
CB cb(this);
scanReachableSymbols(val, cb);
return cb;
@@ -903,11 +896,12 @@ CB ProgramState::scanReachableSymbols(
/// SymbolVisitor. Terminates recursive traversal when the visitor function
/// returns false.
class ScanReachableSymbols {
- typedef llvm::DenseSet<const void*> VisitedItems;
+ typedef llvm::DenseSet<const void *> VisitedItems;
VisitedItems visited;
ProgramStateRef state;
SymbolVisitor &visitor;
+
public:
ScanReachableSymbols(ProgramStateRef st, SymbolVisitor &v)
: state(std::move(st)), visitor(v) {}
@@ -919,8 +913,8 @@ class ScanReachableSymbols {
bool scan(const SymExpr *sym);
};
-} // end ento namespace
+} // namespace ento
-} // end clang namespace
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h
index 15bec97c5be8fc..81f5d3ccf94701 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h
@@ -1,15 +1,16 @@
-//ProgramStateTrait.h - Partial implementations of ProgramStateTrait -*- C++ -*-
+// ProgramStateTrait.h - Partial implementations of ProgramStateTrait -*- C++
+// -*-
//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM
+// Exceptions. See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
-// This file defines partial implementations of template specializations of
-// the class ProgramStateTrait<>. ProgramStateTrait<> is used by ProgramState
-// to implement set/get methods for manipulating a ProgramState's
-// generic data map.
+// This file defines partial implementations of template specializations of
+// the class ProgramStateTrait<>. ProgramStateTrait<> is used by ProgramState
+// to implement set/get methods for manipulating a ProgramState's
+// generic data map.
//
//===----------------------------------------------------------------------===//
@@ -48,249 +49,231 @@ template <typename T, typename Enable = void> struct ProgramStatePartialTrait;
} \
}
- /// Declares a factory for objects of type \p Type in the program state
- /// manager. The type must provide a ::Factory sub-class. Commonly used for
- /// ImmutableMap, ImmutableSet, ImmutableList. The macro should not be used
- /// inside namespaces.
- #define REGISTER_FACTORY_WITH_PROGRAMSTATE(Type) \
- namespace clang { \
- namespace ento { \
- template <> \
- struct ProgramStateTrait<Type> \
- : public ProgramStatePartialTrait<Type> { \
- static void *GDMIndex() { static int Index; return &Index; } \
- }; \
- } \
- }
-
- /// Helper for registering a map trait.
- ///
- /// If the map type were written directly in the invocation of
- /// REGISTER_TRAIT_WITH_PROGRAMSTATE, the comma in the template arguments
- /// would be treated as a macro argument separator, which is wrong.
- /// This allows the user to specify a map type in a way that the preprocessor
- /// can deal with.
- #define CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value) llvm::ImmutableMap<Key, Value>
-
- /// Declares an immutable map of type \p NameTy, suitable for placement into
- /// the ProgramState. This is implementing using llvm::ImmutableMap.
- ///
- /// \code
- /// State = State->set<Name>(K, V);
- /// const Value *V = State->get<Name>(K); // Returns NULL if not in the map.
- /// State = State->remove<Name>(K);
- /// NameTy Map = State->get<Name>();
- /// \endcode
- ///
- /// The macro should not be used inside namespaces, or for traits that must
- /// be accessible from more than one translation unit.
- #define REGISTER_MAP_WITH_PROGRAMSTATE(Name, Key, Value) \
- REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, \
- CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value))
-
- /// Declares an immutable map type \p Name and registers the factory
- /// for such maps in the program state, but does not add the map itself
- /// to the program state. Useful for managing lifetime of maps that are used
- /// as elements of other program state data structures.
- #define REGISTER_MAP_FACTORY_WITH_PROGRAMSTATE(Name, Key, Value) \
- using Name = llvm::ImmutableMap<Key, Value>; \
- REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
-
-
- /// Declares an immutable set of type \p NameTy, suitable for placement into
- /// the ProgramState. This is implementing using llvm::ImmutableSet.
- ///
- /// \code
- /// State = State->add<Name>(E);
- /// State = State->remove<Name>(E);
- /// bool Present = State->contains<Name>(E);
- /// NameTy Set = State->get<Name>();
- /// \endcode
- ///
- /// The macro should not be used inside namespaces, or for traits that must
- /// be accessible from more than one translation unit.
- #define REGISTER_SET_WITH_PROGRAMSTATE(Name, Elem) \
- REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, llvm::ImmutableSet<Elem>)
-
- /// Declares an immutable set type \p Name and registers the factory
- /// for such sets in the program state, but does not add the set itself
- /// to the program state. Useful for managing lifetime of sets that are used
- /// as elements of other program state data structures.
- #define REGISTER_SET_FACTORY_WITH_PROGRAMSTATE(Name, Elem) \
- using Name = llvm::ImmutableSet<Elem>; \
- REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
-
-
- /// Declares an immutable list type \p NameTy, suitable for placement into
- /// the ProgramState. This is implementing using llvm::ImmutableList.
- ///
- /// \code
- /// State = State->add<Name>(E); // Adds to the /end/ of the list.
- /// bool Present = State->contains<Name>(E);
- /// NameTy List = State->get<Name>();
- /// \endcode
- ///
- /// The macro should not be used inside namespaces, or for traits that must
- /// be accessible from more than one translation unit.
- #define REGISTER_LIST_WITH_PROGRAMSTATE(Name, Elem) \
- REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, llvm::ImmutableList<Elem>)
-
- /// Declares an immutable list of type \p Name and registers the factory
- /// for such lists in the program state, but does not add the list itself
- /// to the program state. Useful for managing lifetime of lists that are used
- /// as elements of other program state data structures.
- #define REGISTER_LIST_FACTORY_WITH_PROGRAMSTATE(Name, Elem) \
- using Name = llvm::ImmutableList<Elem>; \
- REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
-
-
- // Partial-specialization for ImmutableMap.
- template <typename Key, typename Data, typename Info>
- struct ProgramStatePartialTrait<llvm::ImmutableMap<Key, Data, Info>> {
- using data_type = llvm::ImmutableMap<Key, Data, Info>;
- using context_type = typename data_type::Factory &;
- using key_type = Key;
- using value_type = Data;
- using lookup_type = const value_type *;
-
- static data_type MakeData(void *const *p) {
- return p ? data_type((typename data_type::TreeTy *) *p)
- : data_type(nullptr);
- }
-
- static void *MakeVoidPtr(data_type B) {
- return B.getRoot();
- }
-
- static lookup_type Lookup(data_type B, key_type K) {
- return B.lookup(K);
- }
-
- static data_type Set(data_type B, key_type K, value_type E,
- context_type F) {
- return F.add(B, K, E);
- }
-
- static data_type Remove(data_type B, key_type K, context_type F) {
- return F.remove(B, K);
- }
-
- static bool Contains(data_type B, key_type K) {
- return B.contains(K);
- }
-
- static context_type MakeContext(void *p) {
- return *((typename data_type::Factory *) p);
- }
-
- static void *CreateContext(llvm::BumpPtrAllocator& Alloc) {
- return new typename data_type::Factory(Alloc);
- }
-
- static void DeleteContext(void *Ctx) {
- delete (typename data_type::Factory *) Ctx;
- }
- };
-
- // Partial-specialization for ImmutableSet.
- template <typename Key, typename Info>
- struct ProgramStatePartialTrait<llvm::ImmutableSet<Key, Info>> {
- using data_type = llvm::ImmutableSet<Key, Info>;
- using context_type = typename data_type::Factory &;
- using key_type = Key;
-
- static data_type MakeData(void *const *p) {
- return p ? data_type((typename data_type::TreeTy *) *p)
- : data_type(nullptr);
- }
-
- static void *MakeVoidPtr(data_type B) {
- return B.getRoot();
- }
-
- static data_type Add(data_type B, key_type K, context_type F) {
- return F.add(B, K);
- }
-
- static data_type Remove(data_type B, key_type K, context_type F) {
- return F.remove(B, K);
- }
-
- static bool Contains(data_type B, key_type K) {
- return B.contains(K);
- }
-
- static context_type MakeContext(void *p) {
- return *((typename data_type::Factory *) p);
- }
-
- static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
- return new typename data_type::Factory(Alloc);
- }
-
- static void DeleteContext(void *Ctx) {
- delete (typename data_type::Factory *) Ctx;
- }
- };
-
- // Partial-specialization for ImmutableList.
- template <typename T>
- struct ProgramStatePartialTrait<llvm::ImmutableList<T>> {
- using data_type = llvm::ImmutableList<T>;
- using key_type = T;
- using context_type = typename data_type::Factory &;
-
- static data_type Add(data_type L, key_type K, context_type F) {
- return F.add(K, L);
- }
-
- static bool Contains(data_type L, key_type K) {
- return L.contains(K);
- }
-
- static data_type MakeData(void *const *p) {
- return p ? data_type((const llvm::ImmutableListImpl<T> *) *p)
- : data_type(nullptr);
- }
-
- static void *MakeVoidPtr(data_type D) {
- return const_cast<llvm::ImmutableListImpl<T> *>(D.getInternalPointer());
- }
-
- static context_type MakeContext(void *p) {
- return *((typename data_type::Factory *) p);
- }
-
- static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
- return new typename data_type::Factory(Alloc);
- }
-
- static void DeleteContext(void *Ctx) {
- delete (typename data_type::Factory *) Ctx;
- }
- };
-
- template <typename T> struct DefaultProgramStatePartialTraitImpl {
- using data_type = T;
- static T MakeData(void *const *P) { return P ? (T)(uintptr_t)*P : T{}; }
- static void *MakeVoidPtr(T D) { return (void *)(uintptr_t)D; }
- };
-
- // Partial specialization for integral types.
- template <typename T>
- struct ProgramStatePartialTrait<T,
- std::enable_if_t<std::is_integral<T>::value>>
- : DefaultProgramStatePartialTraitImpl<T> {};
-
- // Partial specialization for enums.
- template <typename T>
- struct ProgramStatePartialTrait<T, std::enable_if_t<std::is_enum<T>::value>>
- : DefaultProgramStatePartialTraitImpl<T> {};
-
- // Partial specialization for pointers.
- template <typename T>
- struct ProgramStatePartialTrait<T *, void>
- : DefaultProgramStatePartialTraitImpl<T *> {};
+/// Declares a factory for objects of type \p Type in the program state
+/// manager. The type must provide a ::Factory sub-class. Commonly used for
+/// ImmutableMap, ImmutableSet, ImmutableList. The macro should not be used
+/// inside namespaces.
+#define REGISTER_FACTORY_WITH_PROGRAMSTATE(Type) \
+ namespace clang { \
+ namespace ento { \
+ template <> \
+ struct ProgramStateTrait<Type> : public ProgramStatePartialTrait<Type> { \
+ static void *GDMIndex() { \
+ static int Index; \
+ return &Index; \
+ } \
+ }; \
+ } \
+ }
+
+/// Helper for registering a map trait.
+///
+/// If the map type were written directly in the invocation of
+/// REGISTER_TRAIT_WITH_PROGRAMSTATE, the comma in the template arguments
+/// would be treated as a macro argument separator, which is wrong.
+/// This allows the user to specify a map type in a way that the preprocessor
+/// can deal with.
+#define CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value) llvm::ImmutableMap<Key, Value>
+
+/// Declares an immutable map of type \p NameTy, suitable for placement into
+/// the ProgramState. This is implementing using llvm::ImmutableMap.
+///
+/// \code
+/// State = State->set<Name>(K, V);
+/// const Value *V = State->get<Name>(K); // Returns NULL if not in the map.
+/// State = State->remove<Name>(K);
+/// NameTy Map = State->get<Name>();
+/// \endcode
+///
+/// The macro should not be used inside namespaces, or for traits that must
+/// be accessible from more than one translation unit.
+#define REGISTER_MAP_WITH_PROGRAMSTATE(Name, Key, Value) \
+ REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, \
+ CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value))
+
+/// Declares an immutable map type \p Name and registers the factory
+/// for such maps in the program state, but does not add the map itself
+/// to the program state. Useful for managing lifetime of maps that are used
+/// as elements of other program state data structures.
+#define REGISTER_MAP_FACTORY_WITH_PROGRAMSTATE(Name, Key, Value) \
+ using Name = llvm::ImmutableMap<Key, Value>; \
+ REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
+
+/// Declares an immutable set of type \p NameTy, suitable for placement into
+/// the ProgramState. This is implementing using llvm::ImmutableSet.
+///
+/// \code
+/// State = State->add<Name>(E);
+/// State = State->remove<Name>(E);
+/// bool Present = State->contains<Name>(E);
+/// NameTy Set = State->get<Name>();
+/// \endcode
+///
+/// The macro should not be used inside namespaces, or for traits that must
+/// be accessible from more than one translation unit.
+#define REGISTER_SET_WITH_PROGRAMSTATE(Name, Elem) \
+ REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, llvm::ImmutableSet<Elem>)
+
+/// Declares an immutable set type \p Name and registers the factory
+/// for such sets in the program state, but does not add the set itself
+/// to the program state. Useful for managing lifetime of sets that are used
+/// as elements of other program state data structures.
+#define REGISTER_SET_FACTORY_WITH_PROGRAMSTATE(Name, Elem) \
+ using Name = llvm::ImmutableSet<Elem>; \
+ REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
+
+/// Declares an immutable list type \p NameTy, suitable for placement into
+/// the ProgramState. This is implementing using llvm::ImmutableList.
+///
+/// \code
+/// State = State->add<Name>(E); // Adds to the /end/ of the list.
+/// bool Present = State->contains<Name>(E);
+/// NameTy List = State->get<Name>();
+/// \endcode
+///
+/// The macro should not be used inside namespaces, or for traits that must
+/// be accessible from more than one translation unit.
+#define REGISTER_LIST_WITH_PROGRAMSTATE(Name, Elem) \
+ REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, llvm::ImmutableList<Elem>)
+
+/// Declares an immutable list of type \p Name and registers the factory
+/// for such lists in the program state, but does not add the list itself
+/// to the program state. Useful for managing lifetime of lists that are used
+/// as elements of other program state data structures.
+#define REGISTER_LIST_FACTORY_WITH_PROGRAMSTATE(Name, Elem) \
+ using Name = llvm::ImmutableList<Elem>; \
+ REGISTER_FACTORY_WITH_PROGRAMSTATE(Name)
+
+// Partial-specialization for ImmutableMap.
+template <typename Key, typename Data, typename Info>
+struct ProgramStatePartialTrait<llvm::ImmutableMap<Key, Data, Info>> {
+ using data_type = llvm::ImmutableMap<Key, Data, Info>;
+ using context_type = typename data_type::Factory &;
+ using key_type = Key;
+ using value_type = Data;
+ using lookup_type = const value_type *;
+
+ static data_type MakeData(void *const *p) {
+ return p ? data_type((typename data_type::TreeTy *)*p) : data_type(nullptr);
+ }
+
+ static void *MakeVoidPtr(data_type B) { return B.getRoot(); }
+
+ static lookup_type Lookup(data_type B, key_type K) { return B.lookup(K); }
+
+ static data_type Set(data_type B, key_type K, value_type E, context_type F) {
+ return F.add(B, K, E);
+ }
+
+ static data_type Remove(data_type B, key_type K, context_type F) {
+ return F.remove(B, K);
+ }
+
+ static bool Contains(data_type B, key_type K) { return B.contains(K); }
+
+ static context_type MakeContext(void *p) {
+ return *((typename data_type::Factory *)p);
+ }
+
+ static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
+ return new typename data_type::Factory(Alloc);
+ }
+
+ static void DeleteContext(void *Ctx) {
+ delete (typename data_type::Factory *)Ctx;
+ }
+};
+
+// Partial-specialization for ImmutableSet.
+template <typename Key, typename Info>
+struct ProgramStatePartialTrait<llvm::ImmutableSet<Key, Info>> {
+ using data_type = llvm::ImmutableSet<Key, Info>;
+ using context_type = typename data_type::Factory &;
+ using key_type = Key;
+
+ static data_type MakeData(void *const *p) {
+ return p ? data_type((typename data_type::TreeTy *)*p) : data_type(nullptr);
+ }
+
+ static void *MakeVoidPtr(data_type B) { return B.getRoot(); }
+
+ static data_type Add(data_type B, key_type K, context_type F) {
+ return F.add(B, K);
+ }
+
+ static data_type Remove(data_type B, key_type K, context_type F) {
+ return F.remove(B, K);
+ }
+
+ static bool Contains(data_type B, key_type K) { return B.contains(K); }
+
+ static context_type MakeContext(void *p) {
+ return *((typename data_type::Factory *)p);
+ }
+
+ static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
+ return new typename data_type::Factory(Alloc);
+ }
+
+ static void DeleteContext(void *Ctx) {
+ delete (typename data_type::Factory *)Ctx;
+ }
+};
+
+// Partial-specialization for ImmutableList.
+template <typename T> struct ProgramStatePartialTrait<llvm::ImmutableList<T>> {
+ using data_type = llvm::ImmutableList<T>;
+ using key_type = T;
+ using context_type = typename data_type::Factory &;
+
+ static data_type Add(data_type L, key_type K, context_type F) {
+ return F.add(K, L);
+ }
+
+ static bool Contains(data_type L, key_type K) { return L.contains(K); }
+
+ static data_type MakeData(void *const *p) {
+ return p ? data_type((const llvm::ImmutableListImpl<T> *)*p)
+ : data_type(nullptr);
+ }
+
+ static void *MakeVoidPtr(data_type D) {
+ return const_cast<llvm::ImmutableListImpl<T> *>(D.getInternalPointer());
+ }
+
+ static context_type MakeContext(void *p) {
+ return *((typename data_type::Factory *)p);
+ }
+
+ static void *CreateContext(llvm::BumpPtrAllocator &Alloc) {
+ return new typename data_type::Factory(Alloc);
+ }
+
+ static void DeleteContext(void *Ctx) {
+ delete (typename data_type::Factory *)Ctx;
+ }
+};
+
+template <typename T> struct DefaultProgramStatePartialTraitImpl {
+ using data_type = T;
+ static T MakeData(void *const *P) { return P ? (T)(uintptr_t)*P : T{}; }
+ static void *MakeVoidPtr(T D) { return (void *)(uintptr_t)D; }
+};
+
+// Partial specialization for integral types.
+template <typename T>
+struct ProgramStatePartialTrait<T, std::enable_if_t<std::is_integral<T>::value>>
+ : DefaultProgramStatePartialTraitImpl<T> {};
+
+// Partial specialization for enums.
+template <typename T>
+struct ProgramStatePartialTrait<T, std::enable_if_t<std::is_enum<T>::value>>
+ : DefaultProgramStatePartialTraitImpl<T> {};
+
+// Partial specialization for pointers.
+template <typename T>
+struct ProgramStatePartialTrait<T *, void>
+ : DefaultProgramStatePartialTraitImpl<T *> {};
} // namespace ento
} // namespace clang
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h
index 0ea26bf2e509bc..9a3f277dd6ddd5 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h
@@ -14,29 +14,28 @@
namespace clang {
namespace ento {
- class ProgramState;
- class ProgramStateManager;
- void ProgramStateRetain(const ProgramState *state);
- void ProgramStateRelease(const ProgramState *state);
-}
-}
+class ProgramState;
+class ProgramStateManager;
+void ProgramStateRetain(const ProgramState *state);
+void ProgramStateRelease(const ProgramState *state);
+} // namespace ento
+} // namespace clang
namespace llvm {
- template <> struct IntrusiveRefCntPtrInfo<const clang::ento::ProgramState> {
- static void retain(const clang::ento::ProgramState *state) {
- clang::ento::ProgramStateRetain(state);
- }
- static void release(const clang::ento::ProgramState *state) {
- clang::ento::ProgramStateRelease(state);
- }
- };
-}
+template <> struct IntrusiveRefCntPtrInfo<const clang::ento::ProgramState> {
+ static void retain(const clang::ento::ProgramState *state) {
+ clang::ento::ProgramStateRetain(state);
+ }
+ static void release(const clang::ento::ProgramState *state) {
+ clang::ento::ProgramStateRelease(state);
+ }
+};
+} // namespace llvm
namespace clang {
namespace ento {
- typedef IntrusiveRefCntPtr<const ProgramState> ProgramStateRef;
-}
+typedef IntrusiveRefCntPtr<const ProgramState> ProgramStateRef;
}
+} // namespace clang
#endif
-
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h
index d7cff49036cb81..14a507101b7a8c 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h
@@ -108,7 +108,8 @@ class SValBuilder {
/// Evaluates a given SVal. If the SVal has only one possible (integer) value,
/// that value is returned. Otherwise, returns NULL.
- virtual const llvm::APSInt *getKnownValue(ProgramStateRef state, SVal val) = 0;
+ virtual const llvm::APSInt *getKnownValue(ProgramStateRef state,
+ SVal val) = 0;
/// Tries to get the minimal possible (integer) value of a given SVal. If the
/// constraint manager cannot provide an useful answer, this returns NULL.
@@ -124,14 +125,14 @@ class SValBuilder {
virtual SVal simplifySVal(ProgramStateRef State, SVal Val) = 0;
/// Constructs a symbolic expression for two non-location values.
- SVal makeSymExprValNN(BinaryOperator::Opcode op,
- NonLoc lhs, NonLoc rhs, QualType resultTy);
+ SVal makeSymExprValNN(BinaryOperator::Opcode op, NonLoc lhs, NonLoc rhs,
+ QualType resultTy);
SVal evalUnaryOp(ProgramStateRef state, UnaryOperator::Opcode opc,
- SVal operand, QualType type);
+ SVal operand, QualType type);
- SVal evalBinOp(ProgramStateRef state, BinaryOperator::Opcode op,
- SVal lhs, SVal rhs, QualType type);
+ SVal evalBinOp(ProgramStateRef state, BinaryOperator::Opcode op, SVal lhs,
+ SVal rhs, QualType type);
/// \return Whether values in \p lhs and \p rhs are equal at \p state.
ConditionTruthVal areEqual(ProgramStateRef state, SVal lhs, SVal rhs);
@@ -150,9 +151,7 @@ class SValBuilder {
return Context.getLangOpts().CPlusPlus ? Context.BoolTy : Context.IntTy;
}
- QualType getArrayIndexType() const {
- return ArrayIndexTy;
- }
+ QualType getArrayIndexType() const { return ArrayIndexTy; }
BasicValueFactory &getBasicValueFactory() { return BasicVals; }
const BasicValueFactory &getBasicValueFactory() const { return BasicVals; }
@@ -167,15 +166,14 @@ class SValBuilder {
// Forwarding methods to SymbolManager.
- const SymbolConjured* conjureSymbol(const Stmt *stmt,
+ const SymbolConjured *conjureSymbol(const Stmt *stmt,
const LocationContext *LCtx,
- QualType type,
- unsigned visitCount,
+ QualType type, unsigned visitCount,
const void *symbolTag = nullptr) {
return SymMgr.conjureSymbol(stmt, LCtx, type, visitCount, symbolTag);
}
- const SymbolConjured* conjureSymbol(const Expr *expr,
+ const SymbolConjured *conjureSymbol(const Expr *expr,
const LocationContext *LCtx,
unsigned visitCount,
const void *symbolTag = nullptr) {
@@ -194,19 +192,15 @@ class SValBuilder {
/// The advantage of symbols derived/built from other symbols is that we
/// preserve the relation between related(or even equivalent) expressions, so
/// conjured symbols should be used sparingly.
- DefinedOrUnknownSVal conjureSymbolVal(const void *symbolTag,
- const Expr *expr,
+ DefinedOrUnknownSVal conjureSymbolVal(const void *symbolTag, const Expr *expr,
const LocationContext *LCtx,
unsigned count);
- DefinedOrUnknownSVal conjureSymbolVal(const void *symbolTag,
- const Expr *expr,
+ DefinedOrUnknownSVal conjureSymbolVal(const void *symbolTag, const Expr *expr,
const LocationContext *LCtx,
- QualType type,
- unsigned count);
+ QualType type, unsigned count);
DefinedOrUnknownSVal conjureSymbolVal(const Stmt *stmt,
const LocationContext *LCtx,
- QualType type,
- unsigned visitCount);
+ QualType type, unsigned visitCount);
/// Conjure a symbol representing heap allocated memory region.
///
@@ -232,13 +226,13 @@ class SValBuilder {
const LocationContext *LCtx,
unsigned Count);
- DefinedOrUnknownSVal getDerivedRegionValueSymbolVal(
- SymbolRef parentSymbol, const TypedValueRegion *region);
+ DefinedOrUnknownSVal
+ getDerivedRegionValueSymbolVal(SymbolRef parentSymbol,
+ const TypedValueRegion *region);
DefinedSVal getMetadataSymbolVal(const void *symbolTag,
- const MemRegion *region,
- const Expr *expr, QualType type,
- const LocationContext *LCtx,
+ const MemRegion *region, const Expr *expr,
+ QualType type, const LocationContext *LCtx,
unsigned count);
DefinedSVal getMemberPointer(const NamedDecl *ND);
@@ -283,10 +277,10 @@ class SValBuilder {
SVal convertToArrayIndex(SVal val);
- nonloc::ConcreteInt makeIntVal(const IntegerLiteral* integer) {
- return nonloc::ConcreteInt(
- BasicVals.getValue(integer->getValue(),
- integer->getType()->isUnsignedIntegerOrEnumerationType()));
+ nonloc::ConcreteInt makeIntVal(const IntegerLiteral *integer) {
+ return nonloc::ConcreteInt(BasicVals.getValue(
+ integer->getValue(),
+ integer->getType()->isUnsignedIntegerOrEnumerationType()));
}
nonloc::ConcreteInt makeBoolVal(const ObjCBoolLiteralExpr *boolean) {
@@ -295,7 +289,7 @@ class SValBuilder {
nonloc::ConcreteInt makeBoolVal(const CXXBoolLiteralExpr *boolean);
- nonloc::ConcreteInt makeIntVal(const llvm::APSInt& integer) {
+ nonloc::ConcreteInt makeIntVal(const llvm::APSInt &integer) {
return nonloc::ConcreteInt(BasicVals.getValue(integer));
}
@@ -303,7 +297,7 @@ class SValBuilder {
return loc::ConcreteInt(BasicVals.getValue(integer));
}
- NonLoc makeIntVal(const llvm::APInt& integer, bool isUnsigned) {
+ NonLoc makeIntVal(const llvm::APInt &integer, bool isUnsigned) {
return nonloc::ConcreteInt(BasicVals.getValue(integer, isUnsigned));
}
@@ -408,7 +402,7 @@ class SValBuilder {
const StackFrameContext *SFC);
};
-SValBuilder* createSimpleSValBuilder(llvm::BumpPtrAllocator &alloc,
+SValBuilder *createSimpleSValBuilder(llvm::BumpPtrAllocator &alloc,
ASTContext &context,
ProgramStateManager &stateMgr);
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValVisitor.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValVisitor.h
index b10f416f44356f..ed897d1ba42ee1 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValVisitor.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValVisitor.h
@@ -65,15 +65,15 @@ template <typename ImplClass, typename RetTy = void> class SValVisitor {
/// subclasses.
template <typename ImplClass, typename RetTy = void> class SymExprVisitor {
public:
-
-#define DISPATCH(CLASS) \
- return static_cast<ImplClass *>(this)->Visit ## CLASS(cast<CLASS>(S))
+#define DISPATCH(CLASS) \
+ return static_cast<ImplClass *>(this)->Visit##CLASS(cast<CLASS>(S))
RetTy Visit(SymbolRef S) {
// Dispatch to VisitSymbolFoo for each SymbolFoo.
switch (S->getKind()) {
-#define SYMBOL(Id, Parent) \
- case SymExpr::Id ## Kind: DISPATCH(Id);
+#define SYMBOL(Id, Parent) \
+ case SymExpr::Id##Kind: \
+ DISPATCH(Id);
#include "clang/StaticAnalyzer/Core/PathSensitive/Symbols.def"
}
llvm_unreachable("Unknown SymExpr kind!");
@@ -81,7 +81,8 @@ template <typename ImplClass, typename RetTy = void> class SymExprVisitor {
// If the implementation chooses not to implement a certain visit method, fall
// back on visiting the superclass.
-#define SYMBOL(Id, Parent) RetTy Visit ## Id(const Id *S) { DISPATCH(Parent); }
+#define SYMBOL(Id, Parent) \
+ RetTy Visit##Id(const Id *S) { DISPATCH(Parent); }
#define ABSTRACT_SYMBOL(Id, Parent) SYMBOL(Id, Parent)
#include "clang/StaticAnalyzer/Core/PathSensitive/Symbols.def"
@@ -95,14 +96,15 @@ template <typename ImplClass, typename RetTy = void> class SymExprVisitor {
/// subclasses.
template <typename ImplClass, typename RetTy = void> class MemRegionVisitor {
public:
-
-#define DISPATCH(CLASS) \
- return static_cast<ImplClass *>(this)->Visit ## CLASS(cast<CLASS>(R))
+#define DISPATCH(CLASS) \
+ return static_cast<ImplClass *>(this)->Visit##CLASS(cast<CLASS>(R))
RetTy Visit(const MemRegion *R) {
// Dispatch to VisitFooRegion for each FooRegion.
switch (R->getKind()) {
-#define REGION(Id, Parent) case MemRegion::Id ## Kind: DISPATCH(Id);
+#define REGION(Id, Parent) \
+ case MemRegion::Id##Kind: \
+ DISPATCH(Id);
#include "clang/StaticAnalyzer/Core/PathSensitive/Regions.def"
}
llvm_unreachable("Unknown MemRegion kind!");
@@ -110,10 +112,9 @@ template <typename ImplClass, typename RetTy = void> class MemRegionVisitor {
// If the implementation chooses not to implement a certain visit method, fall
// back on visiting the superclass.
-#define REGION(Id, Parent) \
- RetTy Visit ## Id(const Id *R) { DISPATCH(Parent); }
-#define ABSTRACT_REGION(Id, Parent) \
- REGION(Id, Parent)
+#define REGION(Id, Parent) \
+ RetTy Visit##Id(const Id *R) { DISPATCH(Parent); }
+#define ABSTRACT_REGION(Id, Parent) REGION(Id, Parent)
#include "clang/StaticAnalyzer/Core/PathSensitive/Regions.def"
// Base case, ignore it. :)
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h
index c60528b7685fe8..d370896e657adf 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h
@@ -248,8 +248,8 @@ class NonLoc : public DefinedSVal {
void dumpToStream(raw_ostream &Out) const;
static bool isCompoundType(QualType T) {
- return T->isArrayType() || T->isRecordType() ||
- T->isAnyComplexType() || T->isVectorType();
+ return T->isArrayType() || T->isRecordType() || T->isAnyComplexType() ||
+ T->isVectorType();
}
static bool classof(SVal V) {
@@ -290,13 +290,9 @@ class SymbolVal : public NonLoc {
}
LLVM_ATTRIBUTE_RETURNS_NONNULL
- SymbolRef getSymbol() const {
- return (const SymExpr *) Data;
- }
+ SymbolRef getSymbol() const { return (const SymExpr *)Data; }
- bool isExpression() const {
- return !isa<SymbolData>(getSymbol());
- }
+ bool isExpression() const { return !isa<SymbolData>(getSymbol()); }
static bool classof(SVal V) { return V.getKind() == SymbolValKind; }
};
@@ -343,7 +339,7 @@ class CompoundVal : public NonLoc {
public:
LLVM_ATTRIBUTE_RETURNS_NONNULL
- const CompoundValData* getValue() const {
+ const CompoundValData *getValue() const {
return castDataAs<CompoundValData>();
}
@@ -402,8 +398,7 @@ class PointerToMember : public NonLoc {
const NamedDecl *getDecl() const;
- template<typename AdjustedDecl>
- const AdjustedDecl *getDeclAs() const {
+ template <typename AdjustedDecl> const AdjustedDecl *getDeclAs() const {
return dyn_cast_or_null<AdjustedDecl>(getDecl());
}
@@ -450,10 +445,9 @@ class MemRegionVal : public Loc {
/// Get the underlining region and strip casts.
LLVM_ATTRIBUTE_RETURNS_NONNULL
- const MemRegion* stripCasts(bool StripBaseCasts = true) const;
+ const MemRegion *stripCasts(bool StripBaseCasts = true) const;
- template <typename REGION>
- const REGION* getRegionAs() const {
+ template <typename REGION> const REGION *getRegionAs() const {
return dyn_cast<REGION>(getRegion());
}
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h
index fac0c04ae2caab..efb5a1ddcfc8f7 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h
@@ -14,13 +14,13 @@
#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_STORE_H
#include "clang/AST/Type.h"
+#include "clang/Basic/LLVM.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/StoreRef.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
-#include "clang/Basic/LLVM.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/SmallVector.h"
@@ -128,9 +128,9 @@ class StoreManager {
/// getRegionManager - Returns the internal RegionManager object that is
/// used to query and manipulate MemRegion objects.
- MemRegionManager& getRegionManager() { return MRMgr; }
+ MemRegionManager &getRegionManager() { return MRMgr; }
- SValBuilder& getSValBuilder() { return svalBuilder; }
+ SValBuilder &getSValBuilder() { return svalBuilder; }
virtual Loc getLValueVar(const VarDecl *VD, const LocationContext *LC) {
return svalBuilder.makeLoc(MRMgr.getVarRegion(VD, LC));
@@ -161,8 +161,7 @@ class StoreManager {
SVal evalDerivedToBase(SVal Derived, const CXXBasePath &CastPath);
/// Evaluates a derived-to-base cast through a single level of derivation.
- SVal evalDerivedToBase(SVal Derived, QualType DerivedPtrType,
- bool IsVirtual);
+ SVal evalDerivedToBase(SVal Derived, QualType DerivedPtrType, bool IsVirtual);
/// Attempts to do a down cast. Used to model BaseToDerived and C++
/// dynamic_cast.
@@ -185,7 +184,8 @@ class StoreManager {
std::optional<const MemRegion *> castRegion(const MemRegion *region,
QualType CastToTy);
- virtual StoreRef removeDeadBindings(Store store, const StackFrameContext *LCtx,
+ virtual StoreRef removeDeadBindings(Store store,
+ const StackFrameContext *LCtx,
SymbolReaper &SymReaper) = 0;
virtual bool includedInBindings(Store store,
@@ -225,20 +225,18 @@ class StoreManager {
/// invalidated. This should include any regions explicitly invalidated
/// even if they do not currently have bindings. Pass \c NULL if this
/// information will not be used.
- virtual StoreRef invalidateRegions(Store store,
- ArrayRef<SVal> Values,
- const Expr *E, unsigned Count,
- const LocationContext *LCtx,
- const CallEvent *Call,
- InvalidatedSymbols &IS,
- RegionAndSymbolInvalidationTraits &ITraits,
- InvalidatedRegions *InvalidatedTopLevel,
- InvalidatedRegions *Invalidated) = 0;
+ virtual StoreRef invalidateRegions(Store store, ArrayRef<SVal> Values,
+ const Expr *E, unsigned Count,
+ const LocationContext *LCtx,
+ const CallEvent *Call,
+ InvalidatedSymbols &IS,
+ RegionAndSymbolInvalidationTraits &ITraits,
+ InvalidatedRegions *InvalidatedTopLevel,
+ InvalidatedRegions *Invalidated) = 0;
/// enterStackFrame - Let the StoreManager to do something when execution
/// engine is about to execute into a callee.
- StoreRef enterStackFrame(Store store,
- const CallEvent &Call,
+ StoreRef enterStackFrame(Store store, const CallEvent &Call,
const StackFrameContext *CalleeCtx);
/// Finds the transitive closure of symbols within the given region.
@@ -255,13 +253,13 @@ class StoreManager {
virtual ~BindingsHandler();
/// \return whether the iteration should continue.
- virtual bool HandleBinding(StoreManager& SMgr, Store store,
+ virtual bool HandleBinding(StoreManager &SMgr, Store store,
const MemRegion *region, SVal val) = 0;
};
class FindUniqueBinding : public BindingsHandler {
SymbolRef Sym;
- const MemRegion* Binding = nullptr;
+ const MemRegion *Binding = nullptr;
bool First = true;
public:
@@ -269,13 +267,13 @@ class StoreManager {
explicit operator bool() { return First && Binding; }
- bool HandleBinding(StoreManager& SMgr, Store store, const MemRegion* R,
+ bool HandleBinding(StoreManager &SMgr, Store store, const MemRegion *R,
SVal val) override;
const MemRegion *getRegion() { return Binding; }
};
/// iterBindings - Iterate over the bindings in the Store.
- virtual void iterBindings(Store store, BindingsHandler& f) = 0;
+ virtual void iterBindings(Store store, BindingsHandler &f) = 0;
protected:
const ElementRegion *MakeElementRegion(const SubRegion *baseRegion,
@@ -286,15 +284,13 @@ class StoreManager {
SVal getLValueFieldOrIvar(const Decl *decl, SVal base);
};
-inline StoreRef::StoreRef(Store store, StoreManager & smgr)
+inline StoreRef::StoreRef(Store store, StoreManager &smgr)
: store(store), mgr(smgr) {
if (store)
mgr.incrementReferenceCount(store);
}
-inline StoreRef::StoreRef(const StoreRef &sr)
- : store(sr.store), mgr(sr.mgr)
-{
+inline StoreRef::StoreRef(const StoreRef &sr) : store(sr.store), mgr(sr.mgr) {
if (store)
mgr.incrementReferenceCount(store);
}
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SummaryManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SummaryManager.h
index 1a56153da11e29..cd8892546af38a 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SummaryManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SummaryManager.h
@@ -20,7 +20,6 @@ namespace ento {
namespace summMgr {
-
/* Key kinds:
- C functions
@@ -34,24 +33,16 @@ namespace summMgr {
- Class, function name + parameter types + const
*/
-class SummaryKey {
-
-};
-
-} // end namespace clang::summMgr
-
-class SummaryManagerImpl {
-
-};
+class SummaryKey {};
+} // namespace summMgr
-template <typename T>
-class SummaryManager : SummaryManagerImpl {
+class SummaryManagerImpl {};
-};
+template <typename T> class SummaryManager : SummaryManagerImpl {};
-} // end GR namespace
+} // namespace ento
-} // end clang namespace
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h
index 862a30c0e73633..1ef083c3781fb8 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h
@@ -134,9 +134,7 @@ class SymbolData : public SymExpr {
SymbolID getSymbolID() const { return Sym; }
- unsigned computeComplexity() const override {
- return 1;
- };
+ unsigned computeComplexity() const override { return 1; };
// Implement isa<T> support.
static inline bool classof(const SymExpr *SE) {
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h
index 3b64d38ee2b233..d2ef0c2938cb97 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h
@@ -38,7 +38,7 @@ namespace ento {
class BasicValueFactory;
class StoreManager;
-///A symbol representing the value stored at a MemRegion.
+/// A symbol representing the value stored at a MemRegion.
class SymbolRegionValue : public SymbolData {
const TypedValueRegion *R;
@@ -50,14 +50,15 @@ class SymbolRegionValue : public SymbolData {
}
LLVM_ATTRIBUTE_RETURNS_NONNULL
- const TypedValueRegion* getRegion() const { return R; }
+ const TypedValueRegion *getRegion() const { return R; }
- static void Profile(llvm::FoldingSetNodeID& profile, const TypedValueRegion* R) {
- profile.AddInteger((unsigned) SymbolRegionValueKind);
+ static void Profile(llvm::FoldingSetNodeID &profile,
+ const TypedValueRegion *R) {
+ profile.AddInteger((unsigned)SymbolRegionValueKind);
profile.AddPointer(R);
}
- void Profile(llvm::FoldingSetNodeID& profile) override {
+ void Profile(llvm::FoldingSetNodeID &profile) override {
Profile(profile, R);
}
@@ -109,10 +110,10 @@ class SymbolConjured : public SymbolData {
void dumpToStream(raw_ostream &os) const override;
- static void Profile(llvm::FoldingSetNodeID& profile, const Stmt *S,
+ static void Profile(llvm::FoldingSetNodeID &profile, const Stmt *S,
QualType T, unsigned Count, const LocationContext *LCtx,
const void *SymbolTag) {
- profile.AddInteger((unsigned) SymbolConjuredKind);
+ profile.AddInteger((unsigned)SymbolConjuredKind);
profile.AddPointer(S);
profile.AddPointer(LCtx);
profile.Add(T);
@@ -120,7 +121,7 @@ class SymbolConjured : public SymbolData {
profile.AddPointer(SymbolTag);
}
- void Profile(llvm::FoldingSetNodeID& profile) override {
+ void Profile(llvm::FoldingSetNodeID &profile) override {
Profile(profile, S, T, Count, LCtx, SymbolTag);
}
@@ -156,14 +157,14 @@ class SymbolDerived : public SymbolData {
void dumpToStream(raw_ostream &os) const override;
const MemRegion *getOriginRegion() const override { return getRegion(); }
- static void Profile(llvm::FoldingSetNodeID& profile, SymbolRef parent,
+ static void Profile(llvm::FoldingSetNodeID &profile, SymbolRef parent,
const TypedValueRegion *r) {
- profile.AddInteger((unsigned) SymbolDerivedKind);
+ profile.AddInteger((unsigned)SymbolDerivedKind);
profile.AddPointer(r);
profile.AddPointer(parent);
}
- void Profile(llvm::FoldingSetNodeID& profile) override {
+ void Profile(llvm::FoldingSetNodeID &profile) override {
Profile(profile, parentSymbol, R);
}
@@ -194,12 +195,12 @@ class SymbolExtent : public SymbolData {
void dumpToStream(raw_ostream &os) const override;
- static void Profile(llvm::FoldingSetNodeID& profile, const SubRegion *R) {
- profile.AddInteger((unsigned) SymbolExtentKind);
+ static void Profile(llvm::FoldingSetNodeID &profile, const SubRegion *R) {
+ profile.AddInteger((unsigned)SymbolExtentKind);
profile.AddPointer(R);
}
- void Profile(llvm::FoldingSetNodeID& profile) override {
+ void Profile(llvm::FoldingSetNodeID &profile) override {
Profile(profile, R);
}
@@ -214,7 +215,7 @@ class SymbolExtent : public SymbolData {
/// dead-symbol sweeping AND their associated regions are still alive.
/// Intended for use by checkers.
class SymbolMetadata : public SymbolData {
- const MemRegion* R;
+ const MemRegion *R;
const Stmt *S;
QualType T;
const LocationContext *LCtx;
@@ -222,50 +223,50 @@ class SymbolMetadata : public SymbolData {
const void *Tag;
public:
- SymbolMetadata(SymbolID sym, const MemRegion* r, const Stmt *s, QualType t,
+ SymbolMetadata(SymbolID sym, const MemRegion *r, const Stmt *s, QualType t,
const LocationContext *LCtx, unsigned count, const void *tag)
: SymbolData(SymbolMetadataKind, sym), R(r), S(s), T(t), LCtx(LCtx),
Count(count), Tag(tag) {
- assert(r);
- assert(s);
- assert(isValidTypeForSymbol(t));
- assert(LCtx);
- assert(tag);
- }
+ assert(r);
+ assert(s);
+ assert(isValidTypeForSymbol(t));
+ assert(LCtx);
+ assert(tag);
+ }
- LLVM_ATTRIBUTE_RETURNS_NONNULL
- const MemRegion *getRegion() const { return R; }
+ LLVM_ATTRIBUTE_RETURNS_NONNULL
+ const MemRegion *getRegion() const { return R; }
- LLVM_ATTRIBUTE_RETURNS_NONNULL
- const Stmt *getStmt() const { return S; }
+ LLVM_ATTRIBUTE_RETURNS_NONNULL
+ const Stmt *getStmt() const { return S; }
- LLVM_ATTRIBUTE_RETURNS_NONNULL
- const LocationContext *getLocationContext() const { return LCtx; }
+ LLVM_ATTRIBUTE_RETURNS_NONNULL
+ const LocationContext *getLocationContext() const { return LCtx; }
- unsigned getCount() const { return Count; }
+ unsigned getCount() const { return Count; }
- LLVM_ATTRIBUTE_RETURNS_NONNULL
- const void *getTag() const { return Tag; }
+ LLVM_ATTRIBUTE_RETURNS_NONNULL
+ const void *getTag() const { return Tag; }
- QualType getType() const override;
+ QualType getType() const override;
- StringRef getKindStr() const override;
+ StringRef getKindStr() const override;
- void dumpToStream(raw_ostream &os) const override;
+ void dumpToStream(raw_ostream &os) const override;
- static void Profile(llvm::FoldingSetNodeID &profile, const MemRegion *R,
- const Stmt *S, QualType T, const LocationContext *LCtx,
- unsigned Count, const void *Tag) {
- profile.AddInteger((unsigned)SymbolMetadataKind);
- profile.AddPointer(R);
- profile.AddPointer(S);
- profile.Add(T);
- profile.AddPointer(LCtx);
- profile.AddInteger(Count);
- profile.AddPointer(Tag);
- }
+ static void Profile(llvm::FoldingSetNodeID &profile, const MemRegion *R,
+ const Stmt *S, QualType T, const LocationContext *LCtx,
+ unsigned Count, const void *Tag) {
+ profile.AddInteger((unsigned)SymbolMetadataKind);
+ profile.AddPointer(R);
+ profile.AddPointer(S);
+ profile.Add(T);
+ profile.AddPointer(LCtx);
+ profile.AddInteger(Count);
+ profile.AddPointer(Tag);
+ }
- void Profile(llvm::FoldingSetNodeID& profile) override {
+ void Profile(llvm::FoldingSetNodeID &profile) override {
Profile(profile, R, S, T, LCtx, Count, Tag);
}
@@ -307,15 +308,15 @@ class SymbolCast : public SymExpr {
void dumpToStream(raw_ostream &os) const override;
- static void Profile(llvm::FoldingSetNodeID& ID,
- const SymExpr *In, QualType From, QualType To) {
- ID.AddInteger((unsigned) SymbolCastKind);
+ static void Profile(llvm::FoldingSetNodeID &ID, const SymExpr *In,
+ QualType From, QualType To) {
+ ID.AddInteger((unsigned)SymbolCastKind);
ID.AddPointer(In);
ID.Add(From);
ID.Add(To);
}
- void Profile(llvm::FoldingSetNodeID& ID) override {
+ void Profile(llvm::FoldingSetNodeID &ID) override {
Profile(ID, Operand, FromTy, ToTy);
}
@@ -336,7 +337,8 @@ class UnarySymExpr : public SymExpr {
: SymExpr(UnarySymExprKind), Operand(In), Op(Op), T(T) {
// Note, some unary operators are modeled as a binary operator. E.g. ++x is
// modeled as x + 1.
- assert((Op == UO_Minus || Op == UO_Not) && "non-supported unary expression");
+ assert((Op == UO_Minus || Op == UO_Not) &&
+ "non-supported unary expression");
// Unary expressions are results of arithmetic. Pointer arithmetic is not
// handled by unary expressions, but it is instead handled by applying
// sub-regions to regions.
@@ -491,27 +493,26 @@ class SymbolManager {
SymbolDependTy SymbolDependencies;
unsigned SymbolCounter = 0;
- llvm::BumpPtrAllocator& BPAlloc;
+ llvm::BumpPtrAllocator &BPAlloc;
BasicValueFactory &BV;
ASTContext &Ctx;
public:
SymbolManager(ASTContext &ctx, BasicValueFactory &bv,
- llvm::BumpPtrAllocator& bpalloc)
+ llvm::BumpPtrAllocator &bpalloc)
: SymbolDependencies(16), BPAlloc(bpalloc), BV(bv), Ctx(ctx) {}
static bool canSymbolicate(QualType T);
/// Make a unique symbol for MemRegion R according to its kind.
- const SymbolRegionValue* getRegionValueSymbol(const TypedValueRegion* R);
+ const SymbolRegionValue *getRegionValueSymbol(const TypedValueRegion *R);
- const SymbolConjured* conjureSymbol(const Stmt *E,
- const LocationContext *LCtx,
- QualType T,
+ const SymbolConjured *conjureSymbol(const Stmt *E,
+ const LocationContext *LCtx, QualType T,
unsigned VisitCount,
const void *SymbolTag = nullptr);
- const SymbolConjured* conjureSymbol(const Expr *E,
+ const SymbolConjured *conjureSymbol(const Expr *E,
const LocationContext *LCtx,
unsigned VisitCount,
const void *SymbolTag = nullptr) {
@@ -533,20 +534,20 @@ class SymbolManager {
unsigned VisitCount,
const void *SymbolTag = nullptr);
- const SymbolCast* getCastSymbol(const SymExpr *Operand,
- QualType From, QualType To);
+ const SymbolCast *getCastSymbol(const SymExpr *Operand, QualType From,
+ QualType To);
const SymIntExpr *getSymIntExpr(const SymExpr *lhs, BinaryOperator::Opcode op,
- const llvm::APSInt& rhs, QualType t);
+ const llvm::APSInt &rhs, QualType t);
const SymIntExpr *getSymIntExpr(const SymExpr &lhs, BinaryOperator::Opcode op,
- const llvm::APSInt& rhs, QualType t) {
+ const llvm::APSInt &rhs, QualType t) {
return getSymIntExpr(&lhs, op, rhs, t);
}
- const IntSymExpr *getIntSymExpr(const llvm::APSInt& lhs,
- BinaryOperator::Opcode op,
- const SymExpr *rhs, QualType t);
+ const IntSymExpr *getIntSymExpr(const llvm::APSInt &lhs,
+ BinaryOperator::Opcode op, const SymExpr *rhs,
+ QualType t);
const SymSymExpr *getSymSymExpr(const SymExpr *lhs, BinaryOperator::Opcode op,
const SymExpr *rhs, QualType t);
@@ -554,9 +555,7 @@ class SymbolManager {
const UnarySymExpr *getUnarySymExpr(const SymExpr *operand,
UnaryOperator::Opcode op, QualType t);
- QualType getType(const SymExpr *SE) const {
- return SE->getType();
- }
+ QualType getType(const SymExpr *SE) const { return SE->getType(); }
/// Add artificial symbol dependency.
///
@@ -571,10 +570,7 @@ class SymbolManager {
/// A class responsible for cleaning up unused symbols.
class SymbolReaper {
- enum SymbolStatus {
- NotProcessed,
- HaveMarkedDependents
- };
+ enum SymbolStatus { NotProcessed, HaveMarkedDependents };
using SymbolSetTy = llvm::DenseSet<SymbolRef>;
using SymbolMapTy = llvm::DenseMap<SymbolRef, SymbolStatus>;
@@ -592,7 +588,7 @@ class SymbolReaper {
const StackFrameContext *LCtx;
const Stmt *Loc;
- SymbolManager& SymMgr;
+ SymbolManager &SymMgr;
StoreRef reapedStore;
llvm::DenseMap<const MemRegion *, unsigned> includedRegionCache;
@@ -640,9 +636,7 @@ class SymbolReaper {
///
/// This should only be called once all marking of dead symbols has completed.
/// (For checkers, this means only in the checkDeadSymbols callback.)
- bool isDead(SymbolRef sym) {
- return !isLive(sym);
- }
+ bool isDead(SymbolRef sym) { return !isLive(sym); }
void markLive(const MemRegion *region);
void markLazilyCopied(const MemRegion *region);
diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h
index 7beb7ddf5bce6f..196421ff8d1391 100644
--- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h
+++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h
@@ -31,18 +31,11 @@ class WorkListUnit {
unsigned blockIdx; // This is the index of the next statement.
public:
- WorkListUnit(ExplodedNode *N, BlockCounter C,
- const CFGBlock *B, unsigned idx)
- : node(N),
- counter(C),
- block(B),
- blockIdx(idx) {}
+ WorkListUnit(ExplodedNode *N, BlockCounter C, const CFGBlock *B, unsigned idx)
+ : node(N), counter(C), block(B), blockIdx(idx) {}
explicit WorkListUnit(ExplodedNode *N, BlockCounter C)
- : node(N),
- counter(C),
- block(nullptr),
- blockIdx(0) {}
+ : node(N), counter(C), block(nullptr), blockIdx(0) {}
/// Returns the node associated with the worklist unit.
ExplodedNode *getNode() const { return node; }
@@ -59,11 +52,12 @@ class WorkListUnit {
class WorkList {
BlockCounter CurrentCounter;
+
public:
virtual ~WorkList();
virtual bool hasWork() const = 0;
- virtual void enqueue(const WorkListUnit& U) = 0;
+ virtual void enqueue(const WorkListUnit &U) = 0;
void enqueue(ExplodedNode *N, const CFGBlock *B, unsigned idx) {
enqueue(WorkListUnit(N, CurrentCounter, B, idx));
@@ -87,8 +81,8 @@ class WorkList {
static std::unique_ptr<WorkList> makeUnexploredFirstPriorityLocationQueue();
};
-} // end ento namespace
+} // namespace ento
-} // end clang namespace
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h b/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h
index f3b1c1f2064598..145473866eb4e2 100644
--- a/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h
+++ b/clang/include/clang/StaticAnalyzer/Frontend/AnalysisConsumer.h
@@ -53,6 +53,6 @@ CreateAnalysisConsumer(CompilerInstance &CI);
} // namespace ento
-} // end clang namespace
+} // namespace clang
#endif
diff --git a/clang/include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h b/clang/include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h
index 43dbfb15851519..79c4a2c2a47acf 100644
--- a/clang/include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h
+++ b/clang/include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h
@@ -98,7 +98,6 @@ class CheckerRegistry {
/// checkers that depend on them.
void initializeRegistry(const CheckerManager &Mgr);
-
private:
/// Default initialization function for checkers -- since CheckerManager
/// includes this header, we need to make it a template parameter, and since
diff --git a/clang/include/clang/StaticAnalyzer/Frontend/ModelConsumer.h b/clang/include/clang/StaticAnalyzer/Frontend/ModelConsumer.h
index 7b7087622bc2f0..59e6ce8c8a7f9a 100644
--- a/clang/include/clang/StaticAnalyzer/Frontend/ModelConsumer.h
+++ b/clang/include/clang/StaticAnalyzer/Frontend/ModelConsumer.h
@@ -37,7 +37,7 @@ class ModelConsumer : public ASTConsumer {
private:
llvm::StringMap<Stmt *> &Bodies;
};
-}
-}
+} // namespace ento
+} // namespace clang
#endif
diff --git a/clang/lib/Analysis/AnalysisDeclContext.cpp b/clang/lib/Analysis/AnalysisDeclContext.cpp
index d3a1a993711fbf..d4c4d518f0a380 100644
--- a/clang/lib/Analysis/AnalysisDeclContext.cpp
+++ b/clang/lib/Analysis/AnalysisDeclContext.cpp
@@ -50,7 +50,8 @@
using namespace clang;
-using ManagedAnalysisMap = llvm::DenseMap<const void *, std::unique_ptr<ManagedAnalysis>>;
+using ManagedAnalysisMap =
+ llvm::DenseMap<const void *, std::unique_ptr<ManagedAnalysis>>;
AnalysisDeclContext::AnalysisDeclContext(AnalysisDeclContextManager *ADCMgr,
const Decl *D,
@@ -104,8 +105,7 @@ Stmt *AnalysisDeclContext::getBody(bool &IsAutosynthesized) const {
}
}
return Body;
- }
- else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
+ } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
Stmt *Body = MD->getBody();
if (ADCMgr && ADCMgr->synthesizeBodies()) {
Stmt *SynthesizedBody = ADCMgr->getBodyFarm().getBody(MD);
@@ -183,7 +183,7 @@ void AnalysisDeclContext::registerForcedBlockExpression(const Stmt *stmt) {
// Default construct an entry for 'stmt'.
if (const auto *e = dyn_cast<Expr>(stmt))
stmt = e->IgnoreParens();
- (void) (*forcedBlkExprs)[stmt];
+ (void)(*forcedBlkExprs)[stmt];
}
const CFGBlock *
@@ -192,7 +192,7 @@ AnalysisDeclContext::getBlockForRegisteredExpression(const Stmt *stmt) {
if (const auto *e = dyn_cast<Expr>(stmt))
stmt = e->IgnoreParens();
CFG::BuildOptions::ForcedBlkExprs::const_iterator itr =
- forcedBlkExprs->find(stmt);
+ forcedBlkExprs->find(stmt);
assert(itr != forcedBlkExprs->end());
return itr->second;
}
@@ -259,7 +259,8 @@ CFGStmtMap *AnalysisDeclContext::getCFGStmtMap() {
return nullptr;
}
-CFGReverseBlockReachabilityAnalysis *AnalysisDeclContext::getCFGReachablityAnalysis() {
+CFGReverseBlockReachabilityAnalysis *
+AnalysisDeclContext::getCFGReachablityAnalysis() {
if (CFA)
return CFA.get();
@@ -400,8 +401,7 @@ LocationContextManager &AnalysisDeclContext::getLocationContextManager() {
// FoldingSet profiling.
//===----------------------------------------------------------------------===//
-void LocationContext::ProfileCommon(llvm::FoldingSetNodeID &ID,
- ContextKind ck,
+void LocationContext::ProfileCommon(llvm::FoldingSetNodeID &ID, ContextKind ck,
AnalysisDeclContext *ctx,
const LocationContext *parent,
const void *data) {
@@ -430,8 +430,8 @@ const StackFrameContext *LocationContextManager::getStackFrame(
llvm::FoldingSetNodeID ID;
StackFrameContext::Profile(ID, ctx, parent, s, blk, blockCount, idx);
void *InsertPos;
- auto *L =
- cast_or_null<StackFrameContext>(Contexts.FindNodeOrInsertPos(ID, InsertPos));
+ auto *L = cast_or_null<StackFrameContext>(
+ Contexts.FindNodeOrInsertPos(ID, InsertPos));
if (!L) {
L = new StackFrameContext(ctx, parent, s, blk, blockCount, idx, ++NewID);
Contexts.InsertNode(L, InsertPos);
@@ -445,9 +445,8 @@ const BlockInvocationContext *LocationContextManager::getBlockInvocationContext(
llvm::FoldingSetNodeID ID;
BlockInvocationContext::Profile(ID, ADC, ParentLC, BD, Data);
void *InsertPos;
- auto *L =
- cast_or_null<BlockInvocationContext>(Contexts.FindNodeOrInsertPos(ID,
- InsertPos));
+ auto *L = cast_or_null<BlockInvocationContext>(
+ Contexts.FindNodeOrInsertPos(ID, InsertPos));
if (!L) {
L = new BlockInvocationContext(ADC, ParentLC, BD, Data, ++NewID);
Contexts.InsertNode(L, InsertPos);
@@ -588,14 +587,15 @@ LLVM_DUMP_METHOD void LocationContext::dump() const { printJson(llvm::errs()); }
namespace {
-class FindBlockDeclRefExprsVals : public StmtVisitor<FindBlockDeclRefExprsVals>{
+class FindBlockDeclRefExprsVals
+ : public StmtVisitor<FindBlockDeclRefExprsVals> {
BumpVector<const VarDecl *> &BEVals;
BumpVectorContext &BC;
llvm::SmallPtrSet<const VarDecl *, 4> Visited;
llvm::SmallPtrSet<const DeclContext *, 4> IgnoredContexts;
public:
- FindBlockDeclRefExprsVals(BumpVector<const VarDecl*> &bevals,
+ FindBlockDeclRefExprsVals(BumpVector<const VarDecl *> &bevals,
BumpVectorContext &bc)
: BEVals(bevals), BC(bc) {}
@@ -623,7 +623,8 @@ class FindBlockDeclRefExprsVals : public StmtVisitor<FindBlockDeclRefExprsVals>{
void VisitPseudoObjectExpr(PseudoObjectExpr *PE) {
for (PseudoObjectExpr::semantics_iterator it = PE->semantics_begin(),
- et = PE->semantics_end(); it != et; ++it) {
+ et = PE->semantics_end();
+ it != et; ++it) {
Expr *Semantic = *it;
if (auto *OVE = dyn_cast<OpaqueValueExpr>(Semantic))
Semantic = OVE->getSourceExpr();
@@ -636,14 +637,13 @@ class FindBlockDeclRefExprsVals : public StmtVisitor<FindBlockDeclRefExprsVals>{
using DeclVec = BumpVector<const VarDecl *>;
-static DeclVec* LazyInitializeReferencedDecls(const BlockDecl *BD,
- void *&Vec,
+static DeclVec *LazyInitializeReferencedDecls(const BlockDecl *BD, void *&Vec,
llvm::BumpPtrAllocator &A) {
if (Vec)
- return (DeclVec*) Vec;
+ return (DeclVec *)Vec;
BumpVectorContext BC(A);
- DeclVec *BV = (DeclVec*) A.Allocate<DeclVec>();
+ DeclVec *BV = (DeclVec *)A.Allocate<DeclVec>();
new (BV) DeclVec(BC, 10);
// Go through the capture list.
@@ -662,17 +662,18 @@ static DeclVec* LazyInitializeReferencedDecls(const BlockDecl *BD,
llvm::iterator_range<AnalysisDeclContext::referenced_decls_iterator>
AnalysisDeclContext::getReferencedBlockVars(const BlockDecl *BD) {
if (!ReferencedBlockVars)
- ReferencedBlockVars = new llvm::DenseMap<const BlockDecl*,void*>();
+ ReferencedBlockVars = new llvm::DenseMap<const BlockDecl *, void *>();
const DeclVec *V =
LazyInitializeReferencedDecls(BD, (*ReferencedBlockVars)[BD], A);
return llvm::make_range(V->begin(), V->end());
}
-std::unique_ptr<ManagedAnalysis> &AnalysisDeclContext::getAnalysisImpl(const void *tag) {
+std::unique_ptr<ManagedAnalysis> &
+AnalysisDeclContext::getAnalysisImpl(const void *tag) {
if (!ManagedAnalyses)
ManagedAnalyses = new ManagedAnalysisMap();
- ManagedAnalysisMap *M = (ManagedAnalysisMap*) ManagedAnalyses;
+ ManagedAnalysisMap *M = (ManagedAnalysisMap *)ManagedAnalyses;
return (*M)[tag];
}
@@ -685,18 +686,17 @@ ManagedAnalysis::~ManagedAnalysis() = default;
AnalysisDeclContext::~AnalysisDeclContext() {
delete forcedBlkExprs;
delete ReferencedBlockVars;
- delete (ManagedAnalysisMap*) ManagedAnalyses;
+ delete (ManagedAnalysisMap *)ManagedAnalyses;
}
LocationContext::~LocationContext() = default;
-LocationContextManager::~LocationContextManager() {
- clear();
-}
+LocationContextManager::~LocationContextManager() { clear(); }
void LocationContextManager::clear() {
for (llvm::FoldingSet<LocationContext>::iterator I = Contexts.begin(),
- E = Contexts.end(); I != E; ) {
+ E = Contexts.end();
+ I != E;) {
LocationContext *LC = &*I;
++I;
delete LC;
diff --git a/clang/lib/Analysis/BodyFarm.cpp b/clang/lib/Analysis/BodyFarm.cpp
index 127e843d4ead21..9a6f158bfde42e 100644
--- a/clang/lib/Analysis/BodyFarm.cpp
+++ b/clang/lib/Analysis/BodyFarm.cpp
@@ -43,7 +43,7 @@ static bool isDispatchBlock(QualType Ty) {
// Check if the block pointer type takes no arguments and
// returns void.
const FunctionProtoType *FT =
- BPT->getPointeeType()->getAs<FunctionProtoType>();
+ BPT->getPointeeType()->getAs<FunctionProtoType>();
return FT && FT->getReturnType()->isVoidType() && FT->getNumParams() == 0;
}
@@ -60,7 +60,7 @@ class ASTMaker {
BinaryOperator::Opcode Op);
/// Create a new compound stmt using the provided statements.
- CompoundStmt *makeCompound(ArrayRef<Stmt*>);
+ CompoundStmt *makeCompound(ArrayRef<Stmt *>);
/// Create a new DeclRefExpr for the referenced variable.
DeclRefExpr *makeDeclRefExpr(const VarDecl *D,
@@ -115,7 +115,7 @@ class ASTMaker {
private:
ASTContext &C;
};
-}
+} // namespace
BinaryOperator *ASTMaker::makeAssignment(const Expr *LHS, const Expr *RHS,
QualType Ty) {
@@ -126,8 +126,7 @@ BinaryOperator *ASTMaker::makeAssignment(const Expr *LHS, const Expr *RHS,
BinaryOperator *ASTMaker::makeComparison(const Expr *LHS, const Expr *RHS,
BinaryOperator::Opcode Op) {
- assert(BinaryOperator::isLogicalOp(Op) ||
- BinaryOperator::isComparisonOp(Op));
+ assert(BinaryOperator::isLogicalOp(Op) || BinaryOperator::isComparisonOp(Op));
return BinaryOperator::Create(
C, const_cast<Expr *>(LHS), const_cast<Expr *>(RHS), Op,
C.getLogicalOperationType(), VK_PRValue, OK_Ordinary, SourceLocation(),
@@ -139,9 +138,9 @@ CompoundStmt *ASTMaker::makeCompound(ArrayRef<Stmt *> Stmts) {
SourceLocation());
}
-DeclRefExpr *ASTMaker::makeDeclRefExpr(
- const VarDecl *D,
- bool RefersToEnclosingVariableOrCapture) {
+DeclRefExpr *
+ASTMaker::makeDeclRefExpr(const VarDecl *D,
+ bool RefersToEnclosingVariableOrCapture) {
QualType Type = D->getType().getNonReferenceType();
DeclRefExpr *DR = DeclRefExpr::Create(
@@ -164,9 +163,8 @@ ImplicitCastExpr *
ASTMaker::makeLvalueToRvalue(const VarDecl *Arg,
bool RefersToEnclosingVariableOrCapture) {
QualType Type = Arg->getType().getNonReferenceType();
- return makeLvalueToRvalue(makeDeclRefExpr(Arg,
- RefersToEnclosingVariableOrCapture),
- Type);
+ return makeLvalueToRvalue(
+ makeDeclRefExpr(Arg, RefersToEnclosingVariableOrCapture), Type);
}
ImplicitCastExpr *ASTMaker::makeImplicitCast(const Expr *Arg, QualType Ty,
@@ -191,7 +189,7 @@ CastExpr *ASTMaker::makeReferenceCast(const Expr *Arg, QualType Ty) {
Expr *ASTMaker::makeIntegralCast(const Expr *Arg, QualType Ty) {
if (Arg->getType() == Ty)
- return const_cast<Expr*>(Arg);
+ return const_cast<Expr *>(Arg);
return makeImplicitCast(Arg, Ty, CK_IntegralCast);
}
@@ -206,9 +204,9 @@ ObjCBoolLiteralExpr *ASTMaker::makeObjCBool(bool Val) {
ObjCIvarRefExpr *ASTMaker::makeObjCIvarRef(const Expr *Base,
const ObjCIvarDecl *IVar) {
- return new (C) ObjCIvarRefExpr(const_cast<ObjCIvarDecl*>(IVar),
+ return new (C) ObjCIvarRefExpr(const_cast<ObjCIvarDecl *>(IVar),
IVar->getType(), SourceLocation(),
- SourceLocation(), const_cast<Expr*>(Base),
+ SourceLocation(), const_cast<Expr *>(Base),
/*arrow=*/true, /*free=*/false);
}
@@ -231,7 +229,7 @@ MemberExpr *ASTMaker::makeMemberExpression(Expr *base, ValueDecl *MemberDecl,
C, base, IsArrow, SourceLocation(), NestedNameSpecifierLoc(),
SourceLocation(), MemberDecl, FoundDecl,
DeclarationNameInfo(MemberDecl->getDeclName(), SourceLocation()),
- /* TemplateArgumentListInfo=*/ nullptr, MemberDecl->getType(), ValueKind,
+ /* TemplateArgumentListInfo=*/nullptr, MemberDecl->getType(), ValueKind,
OK_Ordinary, NOUR_None);
}
@@ -240,7 +238,7 @@ ValueDecl *ASTMaker::findMemberField(const RecordDecl *RD, StringRef Name) {
CXXBasePaths Paths(
/* FindAmbiguities=*/false,
/* RecordPaths=*/false,
- /* DetectVirtual=*/ false);
+ /* DetectVirtual=*/false);
const IdentifierInfo &II = C.Idents.get(Name);
DeclarationName DeclName = C.DeclarationNames.getIdentifier(&II);
@@ -266,15 +264,13 @@ static CallExpr *create_call_once_funcptr_call(ASTContext &C, ASTMaker M,
DeclRefExpr *Call = M.makeDeclRefExpr(Callback);
Expr *SubExpr;
if (Ty->isRValueReferenceType()) {
- SubExpr = M.makeImplicitCast(
- Call, Ty.getNonReferenceType(), CK_LValueToRValue);
- } else if (Ty->isLValueReferenceType() &&
- Call->getType()->isFunctionType()) {
+ SubExpr =
+ M.makeImplicitCast(Call, Ty.getNonReferenceType(), CK_LValueToRValue);
+ } else if (Ty->isLValueReferenceType() && Call->getType()->isFunctionType()) {
Ty = C.getPointerType(Ty.getNonReferenceType());
SubExpr = M.makeImplicitCast(Call, Ty, CK_FunctionToPointerDecay);
- } else if (Ty->isLValueReferenceType()
- && Call->getType()->isPointerType()
- && Call->getType()->getPointeeType()->isFunctionType()){
+ } else if (Ty->isLValueReferenceType() && Call->getType()->isPointerType() &&
+ Call->getType()->getPointeeType()->isFunctionType()) {
SubExpr = Call;
} else {
llvm_unreachable("Unexpected state");
@@ -294,14 +290,14 @@ static CallExpr *create_call_once_lambda_call(ASTContext &C, ASTMaker M,
assert(callOperatorDecl != nullptr);
DeclRefExpr *callOperatorDeclRef =
- DeclRefExpr::Create(/* Ctx =*/ C,
- /* QualifierLoc =*/ NestedNameSpecifierLoc(),
- /* TemplateKWLoc =*/ SourceLocation(),
+ DeclRefExpr::Create(/* Ctx =*/C,
+ /* QualifierLoc =*/NestedNameSpecifierLoc(),
+ /* TemplateKWLoc =*/SourceLocation(),
const_cast<FunctionDecl *>(callOperatorDecl),
- /* RefersToEnclosingVariableOrCapture=*/ false,
- /* NameLoc =*/ SourceLocation(),
- /* T =*/ callOperatorDecl->getType(),
- /* VK =*/ VK_LValue);
+ /* RefersToEnclosingVariableOrCapture=*/false,
+ /* NameLoc =*/SourceLocation(),
+ /* T =*/callOperatorDecl->getType(),
+ /* VK =*/VK_LValue);
return CXXOperatorCallExpr::Create(
/*AstContext=*/C, OO_Call, callOperatorDeclRef,
@@ -410,7 +406,7 @@ static Stmt *create_call_once(ASTContext &C, const FunctionDecl *D) {
// Lambda requires callback itself inserted as a first parameter.
CallArgs.push_back(
M.makeDeclRefExpr(Callback,
- /* RefersToEnclosingVariableOrCapture=*/ true));
+ /* RefersToEnclosingVariableOrCapture=*/true));
CallbackFunctionType = CallbackRecordDecl->getLambdaCallOperator()
->getType()
->getAs<FunctionProtoType>();
@@ -426,9 +422,9 @@ static Stmt *create_call_once(ASTContext &C, const FunctionDecl *D) {
// First two arguments are used for the flag and for the callback.
if (D->getNumParams() != CallbackFunctionType->getNumParams() + 2) {
- LLVM_DEBUG(llvm::dbgs() << "Types of params of the callback do not match "
- << "params passed to std::call_once, "
- << "ignoring the call\n");
+ LLVM_DEBUG(llvm::dbgs()
+ << "Types of params of the callback do not match "
+ << "params passed to std::call_once, " << "ignoring the call\n");
return nullptr;
}
@@ -439,9 +435,9 @@ static Stmt *create_call_once(ASTContext &C, const FunctionDecl *D) {
const ParmVarDecl *PDecl = D->getParamDecl(ParamIdx);
assert(PDecl);
if (CallbackFunctionType->getParamType(ParamIdx - 2)
- .getNonReferenceType()
- .getCanonicalType() !=
- PDecl->getType().getNonReferenceType().getCanonicalType()) {
+ .getNonReferenceType()
+ .getCanonicalType() !=
+ PDecl->getType().getNonReferenceType().getCanonicalType()) {
LLVM_DEBUG(llvm::dbgs() << "Types of params of the callback do not match "
<< "params passed to std::call_once, "
<< "ignoring the call\n");
@@ -470,7 +466,6 @@ static Stmt *create_call_once(ASTContext &C, const FunctionDecl *D) {
M.makeDeclRefExpr(Flag,
/* RefersToEnclosingVariableOrCapture=*/true);
-
MemberExpr *Deref = M.makeMemberExpression(FlagDecl, FlagFieldDecl);
assert(Deref->isLValue());
QualType DerefType = Deref->getType();
@@ -553,28 +548,22 @@ static Stmt *create_dispatch_once(ASTContext &C, const FunctionDecl *D) {
C.LongTy, VK_PRValue, OK_Ordinary, SourceLocation(),
/*CanOverflow*/ false, FPOptionsOverride());
- BinaryOperator *B =
- M.makeAssignment(
- M.makeDereference(
- M.makeLvalueToRvalue(
- M.makeDeclRefExpr(Predicate), PredicateQPtrTy),
- PredicateTy),
- M.makeIntegralCast(DoneValue, PredicateTy),
- PredicateTy);
+ BinaryOperator *B = M.makeAssignment(
+ M.makeDereference(
+ M.makeLvalueToRvalue(M.makeDeclRefExpr(Predicate), PredicateQPtrTy),
+ PredicateTy),
+ M.makeIntegralCast(DoneValue, PredicateTy), PredicateTy);
// (3) Create the compound statement.
- Stmt *Stmts[] = { B, CE };
+ Stmt *Stmts[] = {B, CE};
CompoundStmt *CS = M.makeCompound(Stmts);
// (4) Create the 'if' condition.
- ImplicitCastExpr *LValToRval =
- M.makeLvalueToRvalue(
+ ImplicitCastExpr *LValToRval = M.makeLvalueToRvalue(
M.makeDereference(
- M.makeLvalueToRvalue(
- M.makeDeclRefExpr(Predicate),
- PredicateQPtrTy),
- PredicateTy),
- PredicateTy);
+ M.makeLvalueToRvalue(M.makeDeclRefExpr(Predicate), PredicateQPtrTy),
+ PredicateTy),
+ PredicateTy);
Expr *GuardCondition = M.makeComparison(LValToRval, DoneValue, BO_NE);
// (5) Create the 'if' statement.
@@ -615,8 +604,8 @@ static Stmt *create_dispatch_sync(ASTContext &C, const FunctionDecl *D) {
return CE;
}
-static Stmt *create_OSAtomicCompareAndSwap(ASTContext &C, const FunctionDecl *D)
-{
+static Stmt *create_OSAtomicCompareAndSwap(ASTContext &C,
+ const FunctionDecl *D) {
// There are exactly 3 arguments.
if (D->param_size() != 3)
return nullptr;
@@ -654,23 +643,21 @@ static Stmt *create_OSAtomicCompareAndSwap(ASTContext &C, const FunctionDecl *D)
ASTMaker M(C);
// Construct the comparison.
- Expr *Comparison =
- M.makeComparison(
+ Expr *Comparison = M.makeComparison(
M.makeLvalueToRvalue(M.makeDeclRefExpr(OldValue), OldValueTy),
M.makeLvalueToRvalue(
- M.makeDereference(
- M.makeLvalueToRvalue(M.makeDeclRefExpr(TheValue), TheValueTy),
+ M.makeDereference(
+ M.makeLvalueToRvalue(M.makeDeclRefExpr(TheValue), TheValueTy),
+ PointeeTy),
PointeeTy),
- PointeeTy),
BO_EQ);
// Construct the body of the IfStmt.
Stmt *Stmts[2];
- Stmts[0] =
- M.makeAssignment(
+ Stmts[0] = M.makeAssignment(
M.makeDereference(
- M.makeLvalueToRvalue(M.makeDeclRefExpr(TheValue), TheValueTy),
- PointeeTy),
+ M.makeLvalueToRvalue(M.makeDeclRefExpr(TheValue), TheValueTy),
+ PointeeTy),
M.makeLvalueToRvalue(M.makeDeclRefExpr(NewValue), NewValueTy),
NewValueTy);
@@ -733,13 +720,16 @@ Stmt *BodyFarm::getBody(const FunctionDecl *D) {
FF = create_call_once;
} else {
FF = llvm::StringSwitch<FunctionFarmer>(Name)
- .Case("dispatch_sync", create_dispatch_sync)
- .Case("dispatch_once", create_dispatch_once)
- .Default(nullptr);
+ .Case("dispatch_sync", create_dispatch_sync)
+ .Case("dispatch_once", create_dispatch_once)
+ .Default(nullptr);
}
- if (FF) { Val = FF(C, D); }
- else if (Injector) { Val = Injector->getBody(D); }
+ if (FF) {
+ Val = FF(C, D);
+ } else if (Injector) {
+ Val = Injector->getBody(D);
+ }
return *Val;
}
diff --git a/clang/lib/Analysis/CFG.cpp b/clang/lib/Analysis/CFG.cpp
index de70cbbf6cdb38..b1d09c8db05844 100644
--- a/clang/lib/Analysis/CFG.cpp
+++ b/clang/lib/Analysis/CFG.cpp
@@ -191,8 +191,7 @@ class AddStmtChoice {
AddStmtChoice(Kind a_kind = NotAlwaysAdd) : kind(a_kind) {}
- bool alwaysAdd(CFGBuilder &builder,
- const Stmt *stmt) const;
+ bool alwaysAdd(CFGBuilder &builder, const Stmt *stmt) const;
/// Return a copy of this object, except with the 'always-add' bit
/// set as specified.
@@ -232,7 +231,7 @@ class LocalScope {
/// const_iterator - Iterates local scope backwards and jumps to previous
/// scope on reaching the beginning of currently iterated scope.
class const_iterator {
- const LocalScope* Scope = nullptr;
+ const LocalScope *Scope = nullptr;
/// VarIter is guaranteed to be greater then 0 for every valid iterator.
/// Invalid iterator (with null Scope) has VarIter equal to 0.
@@ -246,15 +245,14 @@ class LocalScope {
/// Create valid iterator. In case when S.Prev is an invalid iterator and
/// I is equal to 0, this will create invalid iterator.
- const_iterator(const LocalScope& S, unsigned I)
- : Scope(&S), VarIter(I) {
+ const_iterator(const LocalScope &S, unsigned I) : Scope(&S), VarIter(I) {
// Iterator to "end" of scope is not allowed. Handle it by going up
// in scopes tree possibly up to invalid iterator in the root.
if (VarIter == 0 && Scope)
*this = Scope->Prev;
}
- VarDecl *const* operator->() const {
+ VarDecl *const *operator->() const {
assert(Scope && "Dereferencing invalid iterator is not allowed");
assert(VarIter != 0 && "Iterator has invalid value of VarIter member");
return &Scope->Vars[VarIter - 1];
@@ -266,9 +264,7 @@ class LocalScope {
return Scope->Vars[0];
}
- VarDecl *operator*() const {
- return *this->operator->();
- }
+ VarDecl *operator*() const { return *this->operator->(); }
const_iterator &operator++() {
if (!Scope)
@@ -289,13 +285,9 @@ class LocalScope {
bool operator==(const const_iterator &rhs) const {
return Scope == rhs.Scope && VarIter == rhs.VarIter;
}
- bool operator!=(const const_iterator &rhs) const {
- return !(*this == rhs);
- }
+ bool operator!=(const const_iterator &rhs) const { return !(*this == rhs); }
- explicit operator bool() const {
- return *this != const_iterator();
- }
+ explicit operator bool() const { return *this != const_iterator(); }
int distance(const_iterator L);
const_iterator shared_parent(const_iterator L);
@@ -321,9 +313,7 @@ class LocalScope {
/// Begin of scope in direction of CFG building (backwards).
const_iterator begin() const { return const_iterator(*this, Vars.size()); }
- void addVar(VarDecl *VD) {
- Vars.push_back(VD, ctx);
- }
+ void addVar(VarDecl *VD) { Vars.push_back(VD, ctx); }
};
} // namespace
@@ -449,15 +439,15 @@ reverse_children::reverse_children(Stmt *S) {
return;
}
switch (S->getStmtClass()) {
- // Note: Fill in this switch with more cases we want to optimize.
- case Stmt::InitListExprClass: {
- InitListExpr *IE = cast<InitListExpr>(S);
- children = llvm::ArrayRef(reinterpret_cast<Stmt **>(IE->getInits()),
- IE->getNumInits());
- return;
- }
- default:
- break;
+ // Note: Fill in this switch with more cases we want to optimize.
+ case Stmt::InitListExprClass: {
+ InitListExpr *IE = cast<InitListExpr>(S);
+ children = llvm::ArrayRef(reinterpret_cast<Stmt **>(IE->getInits()),
+ IE->getNumInits());
+ return;
+ }
+ default:
+ break;
}
// Default case for all other statements.
@@ -586,8 +576,8 @@ class CFGBuilder {
CFGBlock *VisitDeclSubExpr(DeclStmt *DS);
CFGBlock *VisitDefaultStmt(DefaultStmt *D);
CFGBlock *VisitDoStmt(DoStmt *D);
- CFGBlock *VisitExprWithCleanups(ExprWithCleanups *E,
- AddStmtChoice asc, bool ExternallyDestructed);
+ CFGBlock *VisitExprWithCleanups(ExprWithCleanups *E, AddStmtChoice asc,
+ bool ExternallyDestructed);
CFGBlock *VisitForStmt(ForStmt *F);
CFGBlock *VisitGotoStmt(GotoStmt *G);
CFGBlock *VisitGCCAsmStmt(GCCAsmStmt *G, AddStmtChoice asc);
@@ -703,16 +693,19 @@ class CFGBuilder {
// full expression.
CFGBlock *VisitForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
TempDtorContext &Context);
- CFGBlock *VisitChildrenForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
+ CFGBlock *VisitChildrenForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
TempDtorContext &Context);
CFGBlock *VisitBinaryOperatorForTemporaryDtors(BinaryOperator *E,
bool ExternallyDestructed,
TempDtorContext &Context);
- CFGBlock *VisitCXXBindTemporaryExprForTemporaryDtors(
- CXXBindTemporaryExpr *E, bool ExternallyDestructed, TempDtorContext &Context);
- CFGBlock *VisitConditionalOperatorForTemporaryDtors(
- AbstractConditionalOperator *E, bool ExternallyDestructed,
- TempDtorContext &Context);
+ CFGBlock *
+ VisitCXXBindTemporaryExprForTemporaryDtors(CXXBindTemporaryExpr *E,
+ bool ExternallyDestructed,
+ TempDtorContext &Context);
+ CFGBlock *
+ VisitConditionalOperatorForTemporaryDtors(AbstractConditionalOperator *E,
+ bool ExternallyDestructed,
+ TempDtorContext &Context);
void InsertTempDtorDecisionBlock(const TempDtorContext &Context,
CFGBlock *FalseSucc = nullptr);
@@ -759,13 +752,14 @@ class CFGBuilder {
// there's no need to do this manually in every Visit... function.
void cleanupConstructionContext(Expr *E);
- void autoCreateBlock() { if (!Block) Block = createBlock(); }
+ void autoCreateBlock() {
+ if (!Block)
+ Block = createBlock();
+ }
CFGBlock *createBlock(bool add_successor = true);
CFGBlock *createNoReturnBlock();
- CFGBlock *addStmt(Stmt *S) {
- return Visit(S, AddStmtChoice::AlwaysAdd);
- }
+ CFGBlock *addStmt(Stmt *S) { return Visit(S, AddStmtChoice::AlwaysAdd); }
CFGBlock *addInitializer(CXXCtorInitializer *I);
void addLoopExit(const Stmt *LoopStmt);
@@ -777,20 +771,19 @@ class CFGBuilder {
LocalScope::const_iterator E, Stmt *S);
void addImplicitDtorsForDestructor(const CXXDestructorDecl *DD);
void addScopeChangesHandling(LocalScope::const_iterator SrcPos,
- LocalScope::const_iterator DstPos,
- Stmt *S);
+ LocalScope::const_iterator DstPos, Stmt *S);
CFGBlock *createScopeChangesHandlingBlock(LocalScope::const_iterator SrcPos,
CFGBlock *SrcBlk,
LocalScope::const_iterator DstPost,
CFGBlock *DstBlk);
// Local scopes creation.
- LocalScope* createOrReuseLocalScope(LocalScope* Scope);
+ LocalScope *createOrReuseLocalScope(LocalScope *Scope);
void addLocalScopeForStmt(Stmt *S);
- LocalScope* addLocalScopeForDeclStmt(DeclStmt *DS,
- LocalScope* Scope = nullptr);
- LocalScope* addLocalScopeForVarDecl(VarDecl *VD, LocalScope* Scope = nullptr);
+ LocalScope *addLocalScopeForDeclStmt(DeclStmt *DS,
+ LocalScope *Scope = nullptr);
+ LocalScope *addLocalScopeForVarDecl(VarDecl *VD, LocalScope *Scope = nullptr);
void addLocalScopeAndDtors(Stmt *S);
@@ -815,7 +808,7 @@ class CFGBuilder {
// All block-level expressions should have already been IgnoreParens()ed.
assert(!isa<Expr>(S) || cast<Expr>(S)->IgnoreParens() == S);
- B->appendStmt(const_cast<Stmt*>(S), cfg->getBumpVectorContext());
+ B->appendStmt(const_cast<Stmt *>(S), cfg->getBumpVectorContext());
}
void appendConstructor(CFGBlock *B, CXXConstructExpr *CE) {
@@ -978,8 +971,8 @@ class CFGBuilder {
return TryResult();
const BinaryOperator *BitOp = dyn_cast<BinaryOperator>(BoolExpr);
- if (BitOp && (BitOp->getOpcode() == BO_And ||
- BitOp->getOpcode() == BO_Or)) {
+ if (BitOp &&
+ (BitOp->getOpcode() == BO_And || BitOp->getOpcode() == BO_Or)) {
const Expr *LHSExpr2 = BitOp->getLHS()->IgnoreParens();
const Expr *RHSExpr2 = BitOp->getRHS()->IgnoreParens();
@@ -1057,20 +1050,20 @@ class CFGBuilder {
const llvm::APSInt &Value2) {
assert(Value1.isSigned() == Value2.isSigned());
switch (Relation) {
- default:
- return TryResult();
- case BO_EQ:
- return TryResult(Value1 == Value2);
- case BO_NE:
- return TryResult(Value1 != Value2);
- case BO_LT:
- return TryResult(Value1 < Value2);
- case BO_LE:
- return TryResult(Value1 <= Value2);
- case BO_GT:
- return TryResult(Value1 > Value2);
- case BO_GE:
- return TryResult(Value1 >= Value2);
+ default:
+ return TryResult();
+ case BO_EQ:
+ return TryResult(Value1 == Value2);
+ case BO_NE:
+ return TryResult(Value1 != Value2);
+ case BO_LT:
+ return TryResult(Value1 < Value2);
+ case BO_LE:
+ return TryResult(Value1 <= Value2);
+ case BO_GT:
+ return TryResult(Value1 > Value2);
+ case BO_GE:
+ return TryResult(Value1 >= Value2);
}
}
@@ -1102,10 +1095,10 @@ class CFGBuilder {
TryResult Result = CheckLogicalOpWithNegatedVariable(LHSExpr, RHSExpr);
if (Result.isKnown())
- return Result;
+ return Result;
Result = CheckLogicalOpWithNegatedVariable(RHSExpr, LHSExpr);
if (Result.isKnown())
- return Result;
+ return Result;
const auto *LHS = dyn_cast<BinaryOperator>(LHSExpr);
const auto *RHS = dyn_cast<BinaryOperator>(RHSExpr);
@@ -1155,17 +1148,17 @@ class CFGBuilder {
// Values that will be used to determine if result of logical
// operator is always true/false
const llvm::APSInt Values[] = {
- // Value less than both Value1 and Value2
- llvm::APSInt::getMinValue(L1.getBitWidth(), L1.isUnsigned()),
- // L1
- L1,
- // Value between Value1 and Value2
- ((L1 < L2) ? L1 : L2) + llvm::APSInt(llvm::APInt(L1.getBitWidth(), 1),
- L1.isUnsigned()),
- // L2
- L2,
- // Value greater than both Value1 and Value2
- llvm::APSInt::getMaxValue(L1.getBitWidth(), L1.isUnsigned()),
+ // Value less than both Value1 and Value2
+ llvm::APSInt::getMinValue(L1.getBitWidth(), L1.isUnsigned()),
+ // L1
+ L1,
+ // Value between Value1 and Value2
+ ((L1 < L2) ? L1 : L2) +
+ llvm::APSInt(llvm::APInt(L1.getBitWidth(), 1), L1.isUnsigned()),
+ // L2
+ L2,
+ // Value greater than both Value1 and Value2
+ llvm::APSInt::getMaxValue(L1.getBitWidth(), L1.isUnsigned()),
};
// Check whether expression is always true/false by evaluating the following
@@ -1239,16 +1232,15 @@ class CFGBuilder {
bool tryEvaluate(Expr *S, Expr::EvalResult &outResult) {
if (!BuildOpts.PruneTriviallyFalseEdges)
return false;
- return !S->isTypeDependent() &&
- !S->isValueDependent() &&
+ return !S->isTypeDependent() && !S->isValueDependent() &&
S->EvaluateAsRValue(outResult, *Context);
}
/// tryEvaluateBool - Try and evaluate the Stmt and return 0 or 1
/// if we can evaluate to a known value, otherwise return -1.
TryResult tryEvaluateBool(Expr *S) {
- if (!BuildOpts.PruneTriviallyFalseEdges ||
- S->isTypeDependent() || S->isValueDependent())
+ if (!BuildOpts.PruneTriviallyFalseEdges || S->isTypeDependent() ||
+ S->isValueDependent())
return {};
if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(S)) {
@@ -1262,32 +1254,31 @@ class CFGBuilder {
TryResult Result = evaluateAsBooleanConditionNoCache(S);
CachedBoolEvals[S] = Result; // update or insert
return Result;
- }
- else {
+ } else {
switch (Bop->getOpcode()) {
- default: break;
- // For 'x & 0' and 'x * 0', we can determine that
- // the value is always false.
- case BO_Mul:
- case BO_And: {
- // If either operand is zero, we know the value
- // must be false.
- Expr::EvalResult LHSResult;
- if (Bop->getLHS()->EvaluateAsInt(LHSResult, *Context)) {
- llvm::APSInt IntVal = LHSResult.Val.getInt();
- if (!IntVal.getBoolValue()) {
- return TryResult(false);
- }
+ default:
+ break;
+ // For 'x & 0' and 'x * 0', we can determine that
+ // the value is always false.
+ case BO_Mul:
+ case BO_And: {
+ // If either operand is zero, we know the value
+ // must be false.
+ Expr::EvalResult LHSResult;
+ if (Bop->getLHS()->EvaluateAsInt(LHSResult, *Context)) {
+ llvm::APSInt IntVal = LHSResult.Val.getInt();
+ if (!IntVal.getBoolValue()) {
+ return TryResult(false);
}
- Expr::EvalResult RHSResult;
- if (Bop->getRHS()->EvaluateAsInt(RHSResult, *Context)) {
- llvm::APSInt IntVal = RHSResult.Val.getInt();
- if (!IntVal.getBoolValue()) {
- return TryResult(false);
- }
+ }
+ Expr::EvalResult RHSResult;
+ if (Bop->getRHS()->EvaluateAsInt(RHSResult, *Context)) {
+ llvm::APSInt IntVal = RHSResult.Val.getInt();
+ if (!IntVal.getBoolValue()) {
+ return TryResult(false);
}
}
- break;
+ } break;
}
}
}
@@ -1329,9 +1320,9 @@ class CFGBuilder {
return {};
} else if (Bop->isEqualityOp()) {
- TryResult BopRes = checkIncorrectEqualityOperator(Bop);
- if (BopRes.isKnown())
- return BopRes.isTrue();
+ TryResult BopRes = checkIncorrectEqualityOperator(Bop);
+ if (BopRes.isKnown())
+ return BopRes.isTrue();
} else if (Bop->isRelationalOp()) {
TryResult BopRes = checkIncorrectRelationalOperator(Bop);
if (BopRes.isKnown())
@@ -1425,7 +1416,8 @@ static const VariableArrayType *FindVA(const Type *t) {
void CFGBuilder::consumeConstructionContext(
const ConstructionContextLayer *Layer, Expr *E) {
assert((isa<CXXConstructExpr>(E) || isa<CallExpr>(E) ||
- isa<ObjCMessageExpr>(E)) && "Expression cannot construct an object!");
+ isa<ObjCMessageExpr>(E)) &&
+ "Expression cannot construct an object!");
if (const ConstructionContextLayer *PreviouslyStoredLayer =
ConstructionContextMap.lookup(E)) {
(void)PreviouslyStoredLayer;
@@ -1438,8 +1430,8 @@ void CFGBuilder::consumeConstructionContext(
}
}
-void CFGBuilder::findConstructionContexts(
- const ConstructionContextLayer *Layer, Stmt *Child) {
+void CFGBuilder::findConstructionContexts(const ConstructionContextLayer *Layer,
+ Stmt *Child) {
if (!BuildOpts.AddRichCXXConstructors)
return;
@@ -1451,7 +1443,7 @@ void CFGBuilder::findConstructionContexts(
Layer);
};
- switch(Child->getStmtClass()) {
+ switch (Child->getStmtClass()) {
case Stmt::CXXConstructExprClass:
case Stmt::CXXTemporaryObjectExprClass: {
// Support pre-C++17 copy elision AST.
@@ -1576,7 +1568,7 @@ std::unique_ptr<CFG> CFGBuilder::buildCFG(const Decl *D, Stmt *Statement) {
// as the exit block.
Succ = createBlock();
assert(Succ == &cfg->getExit());
- Block = nullptr; // the EXIT block is empty. Create all other blocks lazily.
+ Block = nullptr; // the EXIT block is empty. Create all other blocks lazily.
if (BuildOpts.AddImplicitDtors)
if (const CXXDestructorDecl *DD = dyn_cast_or_null<CXXDestructorDecl>(D))
@@ -1631,7 +1623,8 @@ std::unique_ptr<CFG> CFGBuilder::buildCFG(const Decl *D, Stmt *Statement) {
// Backpatch the gotos whose label -> block mappings we didn't know when we
// encountered them.
for (BackpatchBlocksTy::iterator I = BackpatchBlocks.begin(),
- E = BackpatchBlocks.end(); I != E; ++I ) {
+ E = BackpatchBlocks.end();
+ I != E; ++I) {
CFGBlock *B = I->block;
if (auto *G = dyn_cast<GotoStmt>(B->getTerminator())) {
@@ -1646,7 +1639,7 @@ std::unique_ptr<CFG> CFGBuilder::buildCFG(const Decl *D, Stmt *Statement) {
I->scopePosition, B, JT.scopePosition, JT.block);
addSuccessor(B, SuccBlk);
} else if (auto *G = dyn_cast<GCCAsmStmt>(B->getTerminator())) {
- CFGBlock *Successor = (I+1)->block;
+ CFGBlock *Successor = (I + 1)->block;
for (auto *L : G->labels()) {
LabelMapTy::iterator LI = LabelMap.find(L->getLabel());
// If there is no target for the goto, then we are looking at an
@@ -1666,13 +1659,15 @@ std::unique_ptr<CFG> CFGBuilder::buildCFG(const Decl *D, Stmt *Statement) {
// Add successors to the Indirect Goto Dispatch block (if we have one).
if (CFGBlock *B = cfg->getIndirectGotoBlock())
for (LabelSetTy::iterator I = AddressTakenLabels.begin(),
- E = AddressTakenLabels.end(); I != E; ++I ) {
+ E = AddressTakenLabels.end();
+ I != E; ++I) {
// Lookup the target block.
LabelMapTy::iterator LI = LabelMap.find(*I);
// If there is no target block that contains label, then we are looking
// at an incomplete AST. Handle this by not registering a successor.
- if (LI == LabelMap.end()) continue;
+ if (LI == LabelMap.end())
+ continue;
addSuccessor(B, LI->second.block);
}
@@ -1779,8 +1774,8 @@ static QualType getReferenceInitTemporaryType(const Expr *Init,
}
// Skip through the temporary-materialization expression.
- if (const MaterializeTemporaryExpr *MTE
- = dyn_cast<MaterializeTemporaryExpr>(Init)) {
+ if (const MaterializeTemporaryExpr *MTE =
+ dyn_cast<MaterializeTemporaryExpr>(Init)) {
Init = MTE->getSubExpr();
if (FoundMTE)
*FoundMTE = true;
@@ -1802,8 +1797,8 @@ static QualType getReferenceInitTemporaryType(const Expr *Init,
// TODO: Support adding LoopExit element to the CFG in case where the loop is
// ended by ReturnStmt, GotoStmt or ThrowExpr.
-void CFGBuilder::addLoopExit(const Stmt *LoopStmt){
- if(!BuildOpts.AddLoopExit)
+void CFGBuilder::addLoopExit(const Stmt *LoopStmt) {
+ if (!BuildOpts.AddLoopExit)
return;
autoCreateBlock();
appendLoopExit(Block, LoopStmt);
@@ -1866,7 +1861,7 @@ void CFGBuilder::addAutomaticObjDestruction(LocalScope::const_iterator B,
SmallVector<VarDecl *, 10> DeclsNeedDestruction;
DeclsNeedDestruction.reserve(B.distance(E));
- for (VarDecl* D : llvm::make_range(B, E))
+ for (VarDecl *D : llvm::make_range(B, E))
if (needsAutomaticDestruction(D))
DeclsNeedDestruction.push_back(D);
@@ -1926,7 +1921,7 @@ void CFGBuilder::addScopeExitHandling(LocalScope::const_iterator B,
// Objects with trivial destructor ends their lifetime when their storage
// is destroyed, for automatic variables, this happens when the end of the
// scope is added.
- for (VarDecl* D : llvm::make_range(B, E))
+ for (VarDecl *D : llvm::make_range(B, E))
if (!needsAutomaticDestruction(D))
DeclsTrivial.push_back(D);
@@ -2054,7 +2049,7 @@ void CFGBuilder::addImplicitDtorsForDestructor(const CXXDestructorDecl *DD) {
/// createOrReuseLocalScope - If Scope is NULL create new LocalScope. Either
/// way return valid LocalScope object.
-LocalScope* CFGBuilder::createOrReuseLocalScope(LocalScope* Scope) {
+LocalScope *CFGBuilder::createOrReuseLocalScope(LocalScope *Scope) {
if (Scope)
return Scope;
llvm::BumpPtrAllocator &alloc = cfg->getAllocator();
@@ -2088,8 +2083,8 @@ void CFGBuilder::addLocalScopeForStmt(Stmt *S) {
/// addLocalScopeForDeclStmt - Add LocalScope for declaration statement. Will
/// reuse Scope if not NULL.
-LocalScope* CFGBuilder::addLocalScopeForDeclStmt(DeclStmt *DS,
- LocalScope* Scope) {
+LocalScope *CFGBuilder::addLocalScopeForDeclStmt(DeclStmt *DS,
+ LocalScope *Scope) {
if (!BuildOpts.AddImplicitDtors && !BuildOpts.AddLifetime &&
!BuildOpts.AddScopes)
return Scope;
@@ -2147,8 +2142,8 @@ bool CFGBuilder::hasTrivialDestructor(const VarDecl *VD) const {
/// addLocalScopeForVarDecl - Add LocalScope for variable declaration. It will
/// create add scope for automatic objects and temporary objects bound to
/// const reference. Will reuse Scope if not NULL.
-LocalScope* CFGBuilder::addLocalScopeForVarDecl(VarDecl *VD,
- LocalScope* Scope) {
+LocalScope *CFGBuilder::addLocalScopeForVarDecl(VarDecl *VD,
+ LocalScope *Scope) {
if (!BuildOpts.AddImplicitDtors && !BuildOpts.AddLifetime &&
!BuildOpts.AddScopes)
return Scope;
@@ -2181,7 +2176,7 @@ void CFGBuilder::addLocalScopeAndDtors(Stmt *S) {
/// Visit - Walk the subtree of a statement and add extra
/// blocks for ternary operators, &&, and ||. We also process "," and
/// DeclStmts (which may contain nested control-flow).
-CFGBlock *CFGBuilder::Visit(Stmt * S, AddStmtChoice asc,
+CFGBlock *CFGBuilder::Visit(Stmt *S, AddStmtChoice asc,
bool ExternallyDestructed) {
if (!S) {
badCFG = true;
@@ -2196,216 +2191,216 @@ CFGBlock *CFGBuilder::Visit(Stmt * S, AddStmtChoice asc,
return VisitOMPExecutableDirective(D, asc);
switch (S->getStmtClass()) {
- default:
- return VisitStmt(S, asc);
+ default:
+ return VisitStmt(S, asc);
- case Stmt::ImplicitValueInitExprClass:
- if (BuildOpts.OmitImplicitValueInitializers)
- return Block;
- return VisitStmt(S, asc);
+ case Stmt::ImplicitValueInitExprClass:
+ if (BuildOpts.OmitImplicitValueInitializers)
+ return Block;
+ return VisitStmt(S, asc);
- case Stmt::InitListExprClass:
- return VisitInitListExpr(cast<InitListExpr>(S), asc);
+ case Stmt::InitListExprClass:
+ return VisitInitListExpr(cast<InitListExpr>(S), asc);
- case Stmt::AttributedStmtClass:
- return VisitAttributedStmt(cast<AttributedStmt>(S), asc);
+ case Stmt::AttributedStmtClass:
+ return VisitAttributedStmt(cast<AttributedStmt>(S), asc);
- case Stmt::AddrLabelExprClass:
- return VisitAddrLabelExpr(cast<AddrLabelExpr>(S), asc);
+ case Stmt::AddrLabelExprClass:
+ return VisitAddrLabelExpr(cast<AddrLabelExpr>(S), asc);
- case Stmt::BinaryConditionalOperatorClass:
- return VisitConditionalOperator(cast<BinaryConditionalOperator>(S), asc);
+ case Stmt::BinaryConditionalOperatorClass:
+ return VisitConditionalOperator(cast<BinaryConditionalOperator>(S), asc);
- case Stmt::BinaryOperatorClass:
- return VisitBinaryOperator(cast<BinaryOperator>(S), asc);
+ case Stmt::BinaryOperatorClass:
+ return VisitBinaryOperator(cast<BinaryOperator>(S), asc);
- case Stmt::BlockExprClass:
- return VisitBlockExpr(cast<BlockExpr>(S), asc);
+ case Stmt::BlockExprClass:
+ return VisitBlockExpr(cast<BlockExpr>(S), asc);
- case Stmt::BreakStmtClass:
- return VisitBreakStmt(cast<BreakStmt>(S));
+ case Stmt::BreakStmtClass:
+ return VisitBreakStmt(cast<BreakStmt>(S));
- case Stmt::CallExprClass:
- case Stmt::CXXOperatorCallExprClass:
- case Stmt::CXXMemberCallExprClass:
- case Stmt::UserDefinedLiteralClass:
- return VisitCallExpr(cast<CallExpr>(S), asc);
+ case Stmt::CallExprClass:
+ case Stmt::CXXOperatorCallExprClass:
+ case Stmt::CXXMemberCallExprClass:
+ case Stmt::UserDefinedLiteralClass:
+ return VisitCallExpr(cast<CallExpr>(S), asc);
- case Stmt::CaseStmtClass:
- return VisitCaseStmt(cast<CaseStmt>(S));
+ case Stmt::CaseStmtClass:
+ return VisitCaseStmt(cast<CaseStmt>(S));
- case Stmt::ChooseExprClass:
- return VisitChooseExpr(cast<ChooseExpr>(S), asc);
+ case Stmt::ChooseExprClass:
+ return VisitChooseExpr(cast<ChooseExpr>(S), asc);
- case Stmt::CompoundStmtClass:
- return VisitCompoundStmt(cast<CompoundStmt>(S), ExternallyDestructed);
+ case Stmt::CompoundStmtClass:
+ return VisitCompoundStmt(cast<CompoundStmt>(S), ExternallyDestructed);
- case Stmt::ConditionalOperatorClass:
- return VisitConditionalOperator(cast<ConditionalOperator>(S), asc);
+ case Stmt::ConditionalOperatorClass:
+ return VisitConditionalOperator(cast<ConditionalOperator>(S), asc);
- case Stmt::ContinueStmtClass:
- return VisitContinueStmt(cast<ContinueStmt>(S));
+ case Stmt::ContinueStmtClass:
+ return VisitContinueStmt(cast<ContinueStmt>(S));
- case Stmt::CXXCatchStmtClass:
- return VisitCXXCatchStmt(cast<CXXCatchStmt>(S));
+ case Stmt::CXXCatchStmtClass:
+ return VisitCXXCatchStmt(cast<CXXCatchStmt>(S));
- case Stmt::ExprWithCleanupsClass:
- return VisitExprWithCleanups(cast<ExprWithCleanups>(S),
- asc, ExternallyDestructed);
+ case Stmt::ExprWithCleanupsClass:
+ return VisitExprWithCleanups(cast<ExprWithCleanups>(S), asc,
+ ExternallyDestructed);
- case Stmt::CXXDefaultArgExprClass:
- case Stmt::CXXDefaultInitExprClass:
- // FIXME: The expression inside a CXXDefaultArgExpr is owned by the
- // called function's declaration, not by the caller. If we simply add
- // this expression to the CFG, we could end up with the same Expr
- // appearing multiple times (PR13385).
- //
- // It's likewise possible for multiple CXXDefaultInitExprs for the same
- // expression to be used in the same function (through aggregate
- // initialization).
- return VisitStmt(S, asc);
+ case Stmt::CXXDefaultArgExprClass:
+ case Stmt::CXXDefaultInitExprClass:
+ // FIXME: The expression inside a CXXDefaultArgExpr is owned by the
+ // called function's declaration, not by the caller. If we simply add
+ // this expression to the CFG, we could end up with the same Expr
+ // appearing multiple times (PR13385).
+ //
+ // It's likewise possible for multiple CXXDefaultInitExprs for the same
+ // expression to be used in the same function (through aggregate
+ // initialization).
+ return VisitStmt(S, asc);
- case Stmt::CXXBindTemporaryExprClass:
- return VisitCXXBindTemporaryExpr(cast<CXXBindTemporaryExpr>(S), asc);
+ case Stmt::CXXBindTemporaryExprClass:
+ return VisitCXXBindTemporaryExpr(cast<CXXBindTemporaryExpr>(S), asc);
- case Stmt::CXXConstructExprClass:
- return VisitCXXConstructExpr(cast<CXXConstructExpr>(S), asc);
+ case Stmt::CXXConstructExprClass:
+ return VisitCXXConstructExpr(cast<CXXConstructExpr>(S), asc);
- case Stmt::CXXNewExprClass:
- return VisitCXXNewExpr(cast<CXXNewExpr>(S), asc);
+ case Stmt::CXXNewExprClass:
+ return VisitCXXNewExpr(cast<CXXNewExpr>(S), asc);
- case Stmt::CXXDeleteExprClass:
- return VisitCXXDeleteExpr(cast<CXXDeleteExpr>(S), asc);
+ case Stmt::CXXDeleteExprClass:
+ return VisitCXXDeleteExpr(cast<CXXDeleteExpr>(S), asc);
- case Stmt::CXXFunctionalCastExprClass:
- return VisitCXXFunctionalCastExpr(cast<CXXFunctionalCastExpr>(S), asc);
+ case Stmt::CXXFunctionalCastExprClass:
+ return VisitCXXFunctionalCastExpr(cast<CXXFunctionalCastExpr>(S), asc);
- case Stmt::CXXTemporaryObjectExprClass:
- return VisitCXXTemporaryObjectExpr(cast<CXXTemporaryObjectExpr>(S), asc);
+ case Stmt::CXXTemporaryObjectExprClass:
+ return VisitCXXTemporaryObjectExpr(cast<CXXTemporaryObjectExpr>(S), asc);
- case Stmt::CXXThrowExprClass:
- return VisitCXXThrowExpr(cast<CXXThrowExpr>(S));
+ case Stmt::CXXThrowExprClass:
+ return VisitCXXThrowExpr(cast<CXXThrowExpr>(S));
- case Stmt::CXXTryStmtClass:
- return VisitCXXTryStmt(cast<CXXTryStmt>(S));
+ case Stmt::CXXTryStmtClass:
+ return VisitCXXTryStmt(cast<CXXTryStmt>(S));
- case Stmt::CXXTypeidExprClass:
- return VisitCXXTypeidExpr(cast<CXXTypeidExpr>(S), asc);
+ case Stmt::CXXTypeidExprClass:
+ return VisitCXXTypeidExpr(cast<CXXTypeidExpr>(S), asc);
- case Stmt::CXXForRangeStmtClass:
- return VisitCXXForRangeStmt(cast<CXXForRangeStmt>(S));
+ case Stmt::CXXForRangeStmtClass:
+ return VisitCXXForRangeStmt(cast<CXXForRangeStmt>(S));
- case Stmt::DeclStmtClass:
- return VisitDeclStmt(cast<DeclStmt>(S));
+ case Stmt::DeclStmtClass:
+ return VisitDeclStmt(cast<DeclStmt>(S));
- case Stmt::DefaultStmtClass:
- return VisitDefaultStmt(cast<DefaultStmt>(S));
+ case Stmt::DefaultStmtClass:
+ return VisitDefaultStmt(cast<DefaultStmt>(S));
- case Stmt::DoStmtClass:
- return VisitDoStmt(cast<DoStmt>(S));
+ case Stmt::DoStmtClass:
+ return VisitDoStmt(cast<DoStmt>(S));
- case Stmt::ForStmtClass:
- return VisitForStmt(cast<ForStmt>(S));
+ case Stmt::ForStmtClass:
+ return VisitForStmt(cast<ForStmt>(S));
- case Stmt::GotoStmtClass:
- return VisitGotoStmt(cast<GotoStmt>(S));
+ case Stmt::GotoStmtClass:
+ return VisitGotoStmt(cast<GotoStmt>(S));
- case Stmt::GCCAsmStmtClass:
- return VisitGCCAsmStmt(cast<GCCAsmStmt>(S), asc);
+ case Stmt::GCCAsmStmtClass:
+ return VisitGCCAsmStmt(cast<GCCAsmStmt>(S), asc);
- case Stmt::IfStmtClass:
- return VisitIfStmt(cast<IfStmt>(S));
+ case Stmt::IfStmtClass:
+ return VisitIfStmt(cast<IfStmt>(S));
- case Stmt::ImplicitCastExprClass:
- return VisitImplicitCastExpr(cast<ImplicitCastExpr>(S), asc);
+ case Stmt::ImplicitCastExprClass:
+ return VisitImplicitCastExpr(cast<ImplicitCastExpr>(S), asc);
- case Stmt::ConstantExprClass:
- return VisitConstantExpr(cast<ConstantExpr>(S), asc);
+ case Stmt::ConstantExprClass:
+ return VisitConstantExpr(cast<ConstantExpr>(S), asc);
- case Stmt::IndirectGotoStmtClass:
- return VisitIndirectGotoStmt(cast<IndirectGotoStmt>(S));
+ case Stmt::IndirectGotoStmtClass:
+ return VisitIndirectGotoStmt(cast<IndirectGotoStmt>(S));
- case Stmt::LabelStmtClass:
- return VisitLabelStmt(cast<LabelStmt>(S));
+ case Stmt::LabelStmtClass:
+ return VisitLabelStmt(cast<LabelStmt>(S));
- case Stmt::LambdaExprClass:
- return VisitLambdaExpr(cast<LambdaExpr>(S), asc);
+ case Stmt::LambdaExprClass:
+ return VisitLambdaExpr(cast<LambdaExpr>(S), asc);
- case Stmt::MaterializeTemporaryExprClass:
- return VisitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(S),
- asc);
+ case Stmt::MaterializeTemporaryExprClass:
+ return VisitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(S),
+ asc);
- case Stmt::MemberExprClass:
- return VisitMemberExpr(cast<MemberExpr>(S), asc);
+ case Stmt::MemberExprClass:
+ return VisitMemberExpr(cast<MemberExpr>(S), asc);
- case Stmt::NullStmtClass:
- return Block;
+ case Stmt::NullStmtClass:
+ return Block;
- case Stmt::ObjCAtCatchStmtClass:
- return VisitObjCAtCatchStmt(cast<ObjCAtCatchStmt>(S));
+ case Stmt::ObjCAtCatchStmtClass:
+ return VisitObjCAtCatchStmt(cast<ObjCAtCatchStmt>(S));
- case Stmt::ObjCAutoreleasePoolStmtClass:
- return VisitObjCAutoreleasePoolStmt(cast<ObjCAutoreleasePoolStmt>(S));
+ case Stmt::ObjCAutoreleasePoolStmtClass:
+ return VisitObjCAutoreleasePoolStmt(cast<ObjCAutoreleasePoolStmt>(S));
- case Stmt::ObjCAtSynchronizedStmtClass:
- return VisitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(S));
+ case Stmt::ObjCAtSynchronizedStmtClass:
+ return VisitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(S));
- case Stmt::ObjCAtThrowStmtClass:
- return VisitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(S));
+ case Stmt::ObjCAtThrowStmtClass:
+ return VisitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(S));
- case Stmt::ObjCAtTryStmtClass:
- return VisitObjCAtTryStmt(cast<ObjCAtTryStmt>(S));
+ case Stmt::ObjCAtTryStmtClass:
+ return VisitObjCAtTryStmt(cast<ObjCAtTryStmt>(S));
- case Stmt::ObjCForCollectionStmtClass:
- return VisitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(S));
+ case Stmt::ObjCForCollectionStmtClass:
+ return VisitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(S));
- case Stmt::ObjCMessageExprClass:
- return VisitObjCMessageExpr(cast<ObjCMessageExpr>(S), asc);
+ case Stmt::ObjCMessageExprClass:
+ return VisitObjCMessageExpr(cast<ObjCMessageExpr>(S), asc);
- case Stmt::OpaqueValueExprClass:
- return Block;
+ case Stmt::OpaqueValueExprClass:
+ return Block;
- case Stmt::PseudoObjectExprClass:
- return VisitPseudoObjectExpr(cast<PseudoObjectExpr>(S));
+ case Stmt::PseudoObjectExprClass:
+ return VisitPseudoObjectExpr(cast<PseudoObjectExpr>(S));
- case Stmt::ReturnStmtClass:
- case Stmt::CoreturnStmtClass:
- return VisitReturnStmt(S);
+ case Stmt::ReturnStmtClass:
+ case Stmt::CoreturnStmtClass:
+ return VisitReturnStmt(S);
- case Stmt::CoyieldExprClass:
- case Stmt::CoawaitExprClass:
- return VisitCoroutineSuspendExpr(cast<CoroutineSuspendExpr>(S), asc);
+ case Stmt::CoyieldExprClass:
+ case Stmt::CoawaitExprClass:
+ return VisitCoroutineSuspendExpr(cast<CoroutineSuspendExpr>(S), asc);
- case Stmt::SEHExceptStmtClass:
- return VisitSEHExceptStmt(cast<SEHExceptStmt>(S));
+ case Stmt::SEHExceptStmtClass:
+ return VisitSEHExceptStmt(cast<SEHExceptStmt>(S));
- case Stmt::SEHFinallyStmtClass:
- return VisitSEHFinallyStmt(cast<SEHFinallyStmt>(S));
+ case Stmt::SEHFinallyStmtClass:
+ return VisitSEHFinallyStmt(cast<SEHFinallyStmt>(S));
- case Stmt::SEHLeaveStmtClass:
- return VisitSEHLeaveStmt(cast<SEHLeaveStmt>(S));
+ case Stmt::SEHLeaveStmtClass:
+ return VisitSEHLeaveStmt(cast<SEHLeaveStmt>(S));
- case Stmt::SEHTryStmtClass:
- return VisitSEHTryStmt(cast<SEHTryStmt>(S));
+ case Stmt::SEHTryStmtClass:
+ return VisitSEHTryStmt(cast<SEHTryStmt>(S));
- case Stmt::UnaryExprOrTypeTraitExprClass:
- return VisitUnaryExprOrTypeTraitExpr(cast<UnaryExprOrTypeTraitExpr>(S),
- asc);
+ case Stmt::UnaryExprOrTypeTraitExprClass:
+ return VisitUnaryExprOrTypeTraitExpr(cast<UnaryExprOrTypeTraitExpr>(S),
+ asc);
- case Stmt::StmtExprClass:
- return VisitStmtExpr(cast<StmtExpr>(S), asc);
+ case Stmt::StmtExprClass:
+ return VisitStmtExpr(cast<StmtExpr>(S), asc);
- case Stmt::SwitchStmtClass:
- return VisitSwitchStmt(cast<SwitchStmt>(S));
+ case Stmt::SwitchStmtClass:
+ return VisitSwitchStmt(cast<SwitchStmt>(S));
- case Stmt::UnaryOperatorClass:
- return VisitUnaryOperator(cast<UnaryOperator>(S), asc);
+ case Stmt::UnaryOperatorClass:
+ return VisitUnaryOperator(cast<UnaryOperator>(S), asc);
- case Stmt::WhileStmtClass:
- return VisitWhileStmt(cast<WhileStmt>(S));
+ case Stmt::WhileStmtClass:
+ return VisitWhileStmt(cast<WhileStmt>(S));
- case Stmt::ArrayInitLoopExprClass:
- return VisitArrayInitLoopExpr(cast<ArrayInitLoopExpr>(S), asc);
+ case Stmt::ArrayInitLoopExprClass:
+ return VisitArrayInitLoopExpr(cast<ArrayInitLoopExpr>(S), asc);
}
}
@@ -2456,8 +2451,7 @@ CFGBlock *CFGBuilder::VisitInitListExpr(InitListExpr *ILE, AddStmtChoice asc) {
return B;
}
-CFGBlock *CFGBuilder::VisitAddrLabelExpr(AddrLabelExpr *A,
- AddStmtChoice asc) {
+CFGBlock *CFGBuilder::VisitAddrLabelExpr(AddrLabelExpr *A, AddStmtChoice asc) {
AddressTakenLabels.insert(A->getLabel());
if (asc.alwaysAdd(*this, A)) {
@@ -2512,15 +2506,13 @@ CFGBlock *CFGBuilder::VisitLogicalOperator(BinaryOperator *B) {
if (badCFG)
return nullptr;
- return VisitLogicalOperator(B, nullptr, ConfluenceBlock,
- ConfluenceBlock).first;
+ return VisitLogicalOperator(B, nullptr, ConfluenceBlock, ConfluenceBlock)
+ .first;
}
-std::pair<CFGBlock*, CFGBlock*>
-CFGBuilder::VisitLogicalOperator(BinaryOperator *B,
- Stmt *Term,
- CFGBlock *TrueBlock,
- CFGBlock *FalseBlock) {
+std::pair<CFGBlock *, CFGBlock *>
+CFGBuilder::VisitLogicalOperator(BinaryOperator *B, Stmt *Term,
+ CFGBlock *TrueBlock, CFGBlock *FalseBlock) {
// Introspect the RHS. If it is a nested logical operation, we recursively
// build the CFG using this function. Otherwise, resort to default
// CFG construction behavior.
@@ -2531,7 +2523,7 @@ CFGBuilder::VisitLogicalOperator(BinaryOperator *B,
if (BinaryOperator *B_RHS = dyn_cast<BinaryOperator>(RHS))
if (B_RHS->isLogicalOp()) {
std::tie(RHSBlock, ExitBlock) =
- VisitLogicalOperator(B_RHS, Term, TrueBlock, FalseBlock);
+ VisitLogicalOperator(B_RHS, Term, TrueBlock, FalseBlock);
break;
}
@@ -2551,8 +2543,7 @@ CFGBuilder::VisitLogicalOperator(BinaryOperator *B,
if (!Term) {
assert(TrueBlock == FalseBlock);
addSuccessor(RHSBlock, TrueBlock);
- }
- else {
+ } else {
RHSBlock->setTerminator(Term);
addSuccessor(RHSBlock, TrueBlock, !KnownVal.isFalse());
addSuccessor(RHSBlock, FalseBlock, !KnownVal.isTrue());
@@ -2560,8 +2551,7 @@ CFGBuilder::VisitLogicalOperator(BinaryOperator *B,
Block = RHSBlock;
RHSBlock = addStmt(RHS);
- }
- while (false);
+ } while (false);
if (badCFG)
return std::make_pair(nullptr, nullptr);
@@ -2611,7 +2601,7 @@ CFGBuilder::VisitLogicalOperator(BinaryOperator *B,
CFGBlock *CFGBuilder::VisitBinaryOperator(BinaryOperator *B,
AddStmtChoice asc) {
- // && or ||
+ // && or ||
if (B->isLogicalOp())
return VisitLogicalOperator(B);
@@ -2699,7 +2689,8 @@ CFGBlock *CFGBuilder::VisitCallExpr(CallExpr *C, AddStmtChoice asc) {
// We should only get a null bound type if processing a dependent
// CFG. Recover by assuming nothing.
- if (!boundType.isNull()) calleeType = boundType;
+ if (!boundType.isNull())
+ calleeType = boundType;
}
// If this is a call to a no-return function, this stops the block here.
@@ -2776,8 +2767,7 @@ CFGBlock *CFGBuilder::VisitCallExpr(CallExpr *C, AddStmtChoice asc) {
return VisitChildren(C);
}
-CFGBlock *CFGBuilder::VisitChooseExpr(ChooseExpr *C,
- AddStmtChoice asc) {
+CFGBlock *CFGBuilder::VisitChooseExpr(ChooseExpr *C, AddStmtChoice asc) {
CFGBlock *ConfluenceBlock = Block ? Block : createBlock();
appendStmt(ConfluenceBlock, C);
if (badCFG)
@@ -2798,7 +2788,7 @@ CFGBlock *CFGBuilder::VisitChooseExpr(ChooseExpr *C,
Block = createBlock(false);
// See if this is a known constant.
- const TryResult& KnownVal = tryEvaluateBool(C->getCond());
+ const TryResult &KnownVal = tryEvaluateBool(C->getCond());
addSuccessor(Block, KnownVal.isFalse() ? nullptr : LHSBlock);
addSuccessor(Block, KnownVal.isTrue() ? nullptr : RHSBlock);
Block->setTerminator(C);
@@ -2821,8 +2811,8 @@ CFGBlock *CFGBuilder::VisitCompoundStmt(CompoundStmt *C,
for (Stmt *S : llvm::reverse(C->body())) {
// If we hit a segment of code just containing ';' (NullStmts), we can
// get a null block back. In such cases, just use the LastBlock
- CFGBlock *newBlock = Visit(S, AddStmtChoice::AlwaysAdd,
- ExternallyDestructed);
+ CFGBlock *newBlock =
+ Visit(S, AddStmtChoice::AlwaysAdd, ExternallyDestructed);
if (newBlock)
LastBlock = newBlock;
@@ -2863,8 +2853,7 @@ CFGBlock *CFGBuilder::VisitConditionalOperator(AbstractConditionalOperator *C,
if (badCFG)
return nullptr;
Block = nullptr;
- }
- else
+ } else
LHSBlock = ConfluenceBlock;
// Create the block for the RHS expression.
@@ -2875,7 +2864,7 @@ CFGBlock *CFGBuilder::VisitConditionalOperator(AbstractConditionalOperator *C,
// If the condition is a logical '&&' or '||', build a more accurate CFG.
if (BinaryOperator *Cond =
- dyn_cast<BinaryOperator>(C->getCond()->IgnoreParens()))
+ dyn_cast<BinaryOperator>(C->getCond()->IgnoreParens()))
if (Cond->isLogicalOp())
return VisitLogicalOperator(Cond, C, LHSBlock, RHSBlock).first;
@@ -2883,7 +2872,7 @@ CFGBlock *CFGBuilder::VisitConditionalOperator(AbstractConditionalOperator *C,
Block = createBlock(false);
// See if this is a known constant.
- const TryResult& KnownVal = tryEvaluateBool(C->getCond());
+ const TryResult &KnownVal = tryEvaluateBool(C->getCond());
addSuccessor(Block, LHSBlock, !KnownVal.isFalse());
addSuccessor(Block, RHSBlock, !KnownVal.isTrue());
Block->setTerminator(C);
@@ -2924,7 +2913,8 @@ CFGBlock *CFGBuilder::VisitDeclStmt(DeclStmt *DS) {
// automatically freed with the CFG.
DeclGroupRef DG(*I);
Decl *D = *I;
- DeclStmt *DSNew = new (Context) DeclStmt(DG, D->getLocation(), GetEndLoc(D));
+ DeclStmt *DSNew =
+ new (Context) DeclStmt(DG, D->getLocation(), GetEndLoc(D));
cfg->addSyntheticDeclStmt(DSNew, DS);
// Append the fake DeclStmt to block.
@@ -3033,8 +3023,7 @@ CFGBlock *CFGBuilder::VisitDeclSubExpr(DeclStmt *DS) {
ExprWithCleanups *EC = cast<ExprWithCleanups>(Init);
if (CFGBlock *newBlock = Visit(EC->getSubExpr()))
LastBlock = newBlock;
- }
- else {
+ } else {
if (CFGBlock *newBlock = Visit(Init))
LastBlock = newBlock;
}
@@ -3043,7 +3032,7 @@ CFGBlock *CFGBuilder::VisitDeclSubExpr(DeclStmt *DS) {
// If the type of VD is a VLA, then we must process its size expressions.
// FIXME: This does not find the VLA if it is embedded in other types,
// like here: `int (*p_vla)[x];`
- for (const VariableArrayType* VA = FindVA(VD->getType().getTypePtr());
+ for (const VariableArrayType *VA = FindVA(VD->getType().getTypePtr());
VA != nullptr; VA = FindVA(VA->getElementType().getTypePtr())) {
if (CFGBlock *newBlock = addStmt(VA->getSizeExpr()))
LastBlock = newBlock;
@@ -3189,7 +3178,7 @@ CFGBlock *CFGBuilder::VisitIfStmt(IfStmt *I) {
// If the IfStmt contains a condition variable, add it and its
// initializer to the CFG.
- if (const DeclStmt* DS = I->getConditionVariableDeclStmt()) {
+ if (const DeclStmt *DS = I->getConditionVariableDeclStmt()) {
autoCreateBlock();
LastBlock = addStmt(const_cast<DeclStmt *>(DS));
}
@@ -3335,7 +3324,8 @@ CFGBlock *CFGBuilder::VisitSEHTryStmt(SEHTryStmt *Terminator) {
if (badCFG)
return nullptr;
SEHTrySuccessor = Block;
- } else SEHTrySuccessor = Succ;
+ } else
+ SEHTrySuccessor = Succ;
// FIXME: Implement __finally support.
if (Terminator->getFinallyHandler())
@@ -3544,7 +3534,6 @@ CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) {
Block = Succ = TransitionBlock = createBlock(false);
TransitionBlock->setLoopTarget(F);
-
// Loop iteration (after increment) should end with destructor of Condition
// variable (if any).
addAutomaticObjHandling(ScopePos, LoopBeginScopePos, F);
@@ -3563,11 +3552,10 @@ CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) {
Block = nullptr;
}
- // The starting block for the loop increment is the block that should
- // represent the 'loop target' for looping back to the start of the loop.
- ContinueJumpTarget = JumpTarget(Succ, ContinueScopePos);
- ContinueJumpTarget.block->setLoopTarget(F);
-
+ // The starting block for the loop increment is the block that should
+ // represent the 'loop target' for looping back to the start of the loop.
+ ContinueJumpTarget = JumpTarget(Succ, ContinueScopePos);
+ ContinueJumpTarget.block->setLoopTarget(F);
// If body is not a compound statement create implicit scope
// and add destructors.
@@ -3582,8 +3570,7 @@ CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) {
// In the case of "for (...;...;...);" we can have a null BodyBlock.
// Use the continue jump target as the proxy for the body.
BodyBlock = ContinueJumpTarget.block;
- }
- else if (badCFG)
+ } else if (badCFG)
return nullptr;
}
@@ -3602,7 +3589,7 @@ CFGBlock *CFGBuilder::VisitForStmt(ForStmt *F) {
dyn_cast_or_null<BinaryOperator>(C ? C->IgnoreParens() : nullptr))
if (Cond->isLogicalOp()) {
std::tie(EntryConditionBlock, ExitConditionBlock) =
- VisitLogicalOperator(Cond, F, BodyBlock, LoopSuccessor);
+ VisitLogicalOperator(Cond, F, BodyBlock, LoopSuccessor);
break;
}
@@ -3748,8 +3735,8 @@ CFGBlock *CFGBuilder::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
// Walk the 'element' expression to see if there are any side-effects. We
// generate new blocks as necessary. We DON'T add the statement by default to
// the CFG unless it contains control-flow.
- CFGBlock *EntryConditionBlock = Visit(S->getElement(),
- AddStmtChoice::NotAlwaysAdd);
+ CFGBlock *EntryConditionBlock =
+ Visit(S->getElement(), AddStmtChoice::NotAlwaysAdd);
if (Block) {
if (badCFG)
return nullptr;
@@ -3839,7 +3826,7 @@ CFGBlock *CFGBuilder::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
// Before that, evaluate all of the semantics in order. In
// CFG-land, that means appending them in reverse order.
- for (unsigned i = E->getNumSemanticExprs(); i != 0; ) {
+ for (unsigned i = E->getNumSemanticExprs(); i != 0;) {
Expr *Semantic = E->getSemanticExpr(--i);
// If the semantic is an opaque value, we're being asked to bind
@@ -3967,7 +3954,7 @@ CFGBlock *CFGBuilder::VisitWhileStmt(WhileStmt *W) {
return nullptr;
// See if this is a known constant.
- const TryResult& KnownVal = tryEvaluateBool(C);
+ const TryResult &KnownVal = tryEvaluateBool(C);
// Add the loop body entry as a successor to the condition.
addSuccessor(ExitConditionBlock, KnownVal.isFalse() ? nullptr : BodyBlock);
@@ -3975,7 +3962,7 @@ CFGBlock *CFGBuilder::VisitWhileStmt(WhileStmt *W) {
// false branch).
addSuccessor(ExitConditionBlock,
KnownVal.isTrue() ? nullptr : LoopSuccessor);
- } while(false);
+ } while (false);
// Link up the loop-back block to the entry condition block.
addSuccessor(TransitionBlock, EntryConditionBlock);
@@ -4309,7 +4296,8 @@ CFGBlock *CFGBuilder::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E,
CFGBlock *lastBlock = Block;
if (E->isArgumentType()) {
- for (const VariableArrayType *VA =FindVA(E->getArgumentType().getTypePtr());
+ for (const VariableArrayType *VA =
+ FindVA(E->getArgumentType().getTypePtr());
VA != nullptr; VA = FindVA(VA->getElementType().getTypePtr()))
lastBlock = addStmt(VA->getSizeExpr());
}
@@ -4350,7 +4338,8 @@ CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) {
if (badCFG)
return nullptr;
SwitchSuccessor = Block;
- } else SwitchSuccessor = Succ;
+ } else
+ SwitchSuccessor = Succ;
// Save the current "switch" context.
SaveAndRestore save_switch(SwitchTerminatedBlock),
@@ -4405,8 +4394,8 @@ CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) {
// case statements if the enumeration has no enumerators.
bool SwitchAlwaysHasSuccessor = false;
SwitchAlwaysHasSuccessor |= switchExclusivelyCovered;
- SwitchAlwaysHasSuccessor |= Terminator->isAllEnumCasesCovered() &&
- Terminator->getSwitchCaseList();
+ SwitchAlwaysHasSuccessor |=
+ Terminator->isAllEnumCasesCovered() && Terminator->getSwitchCaseList();
addSuccessor(SwitchTerminatedBlock, DefaultCaseBlock,
!SwitchAlwaysHasSuccessor);
@@ -4437,8 +4426,7 @@ CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) {
static bool shouldAddCase(bool &switchExclusivelyCovered,
const Expr::EvalResult *switchCond,
- const CaseStmt *CS,
- ASTContext &Ctx) {
+ const CaseStmt *CS, ASTContext &Ctx) {
if (!switchCond)
return true;
@@ -4453,8 +4441,7 @@ static bool shouldAddCase(bool &switchExclusivelyCovered,
if (condInt == lhsInt) {
addCase = true;
switchExclusivelyCovered = true;
- }
- else if (condInt > lhsInt) {
+ } else if (condInt > lhsInt) {
if (const Expr *RHS = CS->getRHS()) {
// Evaluate the RHS of the case value.
const llvm::APSInt &V2 = RHS->EvaluateKnownConstInt(Ctx);
@@ -4464,8 +4451,7 @@ static bool shouldAddCase(bool &switchExclusivelyCovered,
}
}
}
- }
- else
+ } else
addCase = true;
}
return addCase;
@@ -4489,10 +4475,11 @@ CFGBlock *CFGBuilder::VisitCaseStmt(CaseStmt *CS) {
else
TopBlock = currentBlock;
- addSuccessor(SwitchTerminatedBlock,
- shouldAddCase(switchExclusivelyCovered, switchCond,
- CS, *Context)
- ? currentBlock : nullptr);
+ addSuccessor(
+ SwitchTerminatedBlock,
+ shouldAddCase(switchExclusivelyCovered, switchCond, CS, *Context)
+ ? currentBlock
+ : nullptr);
LastBlock = currentBlock;
CS = cast<CaseStmt>(Sub);
@@ -4516,9 +4503,9 @@ CFGBlock *CFGBuilder::VisitCaseStmt(CaseStmt *CS) {
// Add this block to the list of successors for the block with the switch
// statement.
assert(SwitchTerminatedBlock);
- addSuccessor(SwitchTerminatedBlock, CaseBlock,
- shouldAddCase(switchExclusivelyCovered, switchCond,
- CS, *Context));
+ addSuccessor(
+ SwitchTerminatedBlock, CaseBlock,
+ shouldAddCase(switchExclusivelyCovered, switchCond, CS, *Context));
// We set Block to NULL to allow lazy creation of a new block (if necessary).
Block = nullptr;
@@ -4793,7 +4780,8 @@ CFGBlock *CFGBuilder::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
}
CFGBlock *CFGBuilder::VisitExprWithCleanups(ExprWithCleanups *E,
- AddStmtChoice asc, bool ExternallyDestructed) {
+ AddStmtChoice asc,
+ bool ExternallyDestructed) {
if (BuildOpts.AddTemporaryDtors) {
// If adding implicit destructors visit the full expression for adding
// destructors of temporaries.
@@ -4836,8 +4824,7 @@ CFGBlock *CFGBuilder::VisitCXXConstructExpr(CXXConstructExpr *C,
return VisitChildren(C);
}
-CFGBlock *CFGBuilder::VisitCXXNewExpr(CXXNewExpr *NE,
- AddStmtChoice asc) {
+CFGBlock *CFGBuilder::VisitCXXNewExpr(CXXNewExpr *NE, AddStmtChoice asc) {
autoCreateBlock();
appendStmt(Block, NE);
@@ -4855,14 +4842,14 @@ CFGBlock *CFGBuilder::VisitCXXNewExpr(CXXNewExpr *NE,
Block = Visit(*NE->getArraySize());
for (CXXNewExpr::arg_iterator I = NE->placement_arg_begin(),
- E = NE->placement_arg_end(); I != E; ++I)
+ E = NE->placement_arg_end();
+ I != E; ++I)
Block = Visit(*I);
return Block;
}
-CFGBlock *CFGBuilder::VisitCXXDeleteExpr(CXXDeleteExpr *DE,
- AddStmtChoice asc) {
+CFGBlock *CFGBuilder::VisitCXXDeleteExpr(CXXDeleteExpr *DE, AddStmtChoice asc) {
autoCreateBlock();
appendStmt(Block, DE);
QualType DTy = DE->getDestroyedType();
@@ -4948,94 +4935,93 @@ CFGBlock *CFGBuilder::VisitForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
return nullptr;
}
switch (E->getStmtClass()) {
- default:
- return VisitChildrenForTemporaryDtors(E, false, Context);
-
- case Stmt::InitListExprClass:
- return VisitChildrenForTemporaryDtors(E, ExternallyDestructed, Context);
-
- case Stmt::BinaryOperatorClass:
- return VisitBinaryOperatorForTemporaryDtors(cast<BinaryOperator>(E),
- ExternallyDestructed,
- Context);
-
- case Stmt::CXXBindTemporaryExprClass:
- return VisitCXXBindTemporaryExprForTemporaryDtors(
- cast<CXXBindTemporaryExpr>(E), ExternallyDestructed, Context);
-
- case Stmt::BinaryConditionalOperatorClass:
- case Stmt::ConditionalOperatorClass:
- return VisitConditionalOperatorForTemporaryDtors(
- cast<AbstractConditionalOperator>(E), ExternallyDestructed, Context);
-
- case Stmt::ImplicitCastExprClass:
- // For implicit cast we want ExternallyDestructed to be passed further.
- E = cast<CastExpr>(E)->getSubExpr();
- goto tryAgain;
-
- case Stmt::CXXFunctionalCastExprClass:
- // For functional cast we want ExternallyDestructed to be passed further.
- E = cast<CXXFunctionalCastExpr>(E)->getSubExpr();
- goto tryAgain;
-
- case Stmt::ConstantExprClass:
- E = cast<ConstantExpr>(E)->getSubExpr();
- goto tryAgain;
-
- case Stmt::ParenExprClass:
- E = cast<ParenExpr>(E)->getSubExpr();
- goto tryAgain;
-
- case Stmt::MaterializeTemporaryExprClass: {
- const MaterializeTemporaryExpr* MTE = cast<MaterializeTemporaryExpr>(E);
- ExternallyDestructed = (MTE->getStorageDuration() != SD_FullExpression);
- SmallVector<const Expr *, 2> CommaLHSs;
- SmallVector<SubobjectAdjustment, 2> Adjustments;
- // Find the expression whose lifetime needs to be extended.
- E = const_cast<Expr *>(
- cast<MaterializeTemporaryExpr>(E)
- ->getSubExpr()
- ->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
- // Visit the skipped comma operator left-hand sides for other temporaries.
- for (const Expr *CommaLHS : CommaLHSs) {
- VisitForTemporaryDtors(const_cast<Expr *>(CommaLHS),
- /*ExternallyDestructed=*/false, Context);
- }
- goto tryAgain;
+ default:
+ return VisitChildrenForTemporaryDtors(E, false, Context);
+
+ case Stmt::InitListExprClass:
+ return VisitChildrenForTemporaryDtors(E, ExternallyDestructed, Context);
+
+ case Stmt::BinaryOperatorClass:
+ return VisitBinaryOperatorForTemporaryDtors(cast<BinaryOperator>(E),
+ ExternallyDestructed, Context);
+
+ case Stmt::CXXBindTemporaryExprClass:
+ return VisitCXXBindTemporaryExprForTemporaryDtors(
+ cast<CXXBindTemporaryExpr>(E), ExternallyDestructed, Context);
+
+ case Stmt::BinaryConditionalOperatorClass:
+ case Stmt::ConditionalOperatorClass:
+ return VisitConditionalOperatorForTemporaryDtors(
+ cast<AbstractConditionalOperator>(E), ExternallyDestructed, Context);
+
+ case Stmt::ImplicitCastExprClass:
+ // For implicit cast we want ExternallyDestructed to be passed further.
+ E = cast<CastExpr>(E)->getSubExpr();
+ goto tryAgain;
+
+ case Stmt::CXXFunctionalCastExprClass:
+ // For functional cast we want ExternallyDestructed to be passed further.
+ E = cast<CXXFunctionalCastExpr>(E)->getSubExpr();
+ goto tryAgain;
+
+ case Stmt::ConstantExprClass:
+ E = cast<ConstantExpr>(E)->getSubExpr();
+ goto tryAgain;
+
+ case Stmt::ParenExprClass:
+ E = cast<ParenExpr>(E)->getSubExpr();
+ goto tryAgain;
+
+ case Stmt::MaterializeTemporaryExprClass: {
+ const MaterializeTemporaryExpr *MTE = cast<MaterializeTemporaryExpr>(E);
+ ExternallyDestructed = (MTE->getStorageDuration() != SD_FullExpression);
+ SmallVector<const Expr *, 2> CommaLHSs;
+ SmallVector<SubobjectAdjustment, 2> Adjustments;
+ // Find the expression whose lifetime needs to be extended.
+ E = const_cast<Expr *>(
+ cast<MaterializeTemporaryExpr>(E)
+ ->getSubExpr()
+ ->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
+ // Visit the skipped comma operator left-hand sides for other temporaries.
+ for (const Expr *CommaLHS : CommaLHSs) {
+ VisitForTemporaryDtors(const_cast<Expr *>(CommaLHS),
+ /*ExternallyDestructed=*/false, Context);
}
+ goto tryAgain;
+ }
- case Stmt::BlockExprClass:
- // Don't recurse into blocks; their subexpressions don't get evaluated
- // here.
- return Block;
+ case Stmt::BlockExprClass:
+ // Don't recurse into blocks; their subexpressions don't get evaluated
+ // here.
+ return Block;
- case Stmt::LambdaExprClass: {
- // For lambda expressions, only recurse into the capture initializers,
- // and not the body.
- auto *LE = cast<LambdaExpr>(E);
- CFGBlock *B = Block;
- for (Expr *Init : LE->capture_inits()) {
- if (Init) {
- if (CFGBlock *R = VisitForTemporaryDtors(
- Init, /*ExternallyDestructed=*/true, Context))
- B = R;
- }
+ case Stmt::LambdaExprClass: {
+ // For lambda expressions, only recurse into the capture initializers,
+ // and not the body.
+ auto *LE = cast<LambdaExpr>(E);
+ CFGBlock *B = Block;
+ for (Expr *Init : LE->capture_inits()) {
+ if (Init) {
+ if (CFGBlock *R = VisitForTemporaryDtors(
+ Init, /*ExternallyDestructed=*/true, Context))
+ B = R;
}
- return B;
}
+ return B;
+ }
- case Stmt::StmtExprClass:
- // Don't recurse into statement expressions; any cleanups inside them
- // will be wrapped in their own ExprWithCleanups.
- return Block;
+ case Stmt::StmtExprClass:
+ // Don't recurse into statement expressions; any cleanups inside them
+ // will be wrapped in their own ExprWithCleanups.
+ return Block;
- case Stmt::CXXDefaultArgExprClass:
- E = cast<CXXDefaultArgExpr>(E)->getExpr();
- goto tryAgain;
+ case Stmt::CXXDefaultArgExprClass:
+ E = cast<CXXDefaultArgExpr>(E)->getExpr();
+ goto tryAgain;
- case Stmt::CXXDefaultInitExprClass:
- E = cast<CXXDefaultInitExpr>(E)->getExpr();
- goto tryAgain;
+ case Stmt::CXXDefaultInitExprClass:
+ E = cast<CXXDefaultInitExpr>(E)->getExpr();
+ goto tryAgain;
}
}
@@ -5054,7 +5040,8 @@ CFGBlock *CFGBuilder::VisitChildrenForTemporaryDtors(Stmt *E,
CFGBlock *B = Block;
for (Stmt *Child : E->children())
if (Child)
- if (CFGBlock *R = VisitForTemporaryDtors(Child, ExternallyDestructed, Context))
+ if (CFGBlock *R =
+ VisitForTemporaryDtors(Child, ExternallyDestructed, Context))
B = R;
return B;
@@ -5066,7 +5053,8 @@ CFGBlock *CFGBuilder::VisitBinaryOperatorForTemporaryDtors(
// For the comma operator, the LHS expression is evaluated before the RHS
// expression, so prepend temporary destructors for the LHS first.
CFGBlock *LHSBlock = VisitForTemporaryDtors(E->getLHS(), false, Context);
- CFGBlock *RHSBlock = VisitForTemporaryDtors(E->getRHS(), ExternallyDestructed, Context);
+ CFGBlock *RHSBlock =
+ VisitForTemporaryDtors(E->getRHS(), ExternallyDestructed, Context);
return RHSBlock ? RHSBlock : LHSBlock;
}
@@ -5100,7 +5088,8 @@ CFGBlock *CFGBuilder::VisitBinaryOperatorForTemporaryDtors(
}
CFGBlock *CFGBuilder::VisitCXXBindTemporaryExprForTemporaryDtors(
- CXXBindTemporaryExpr *E, bool ExternallyDestructed, TempDtorContext &Context) {
+ CXXBindTemporaryExpr *E, bool ExternallyDestructed,
+ TempDtorContext &Context) {
// First add destructors for temporaries in subexpression.
// Because VisitCXXBindTemporaryExpr calls setDestructed:
CFGBlock *B = VisitForTemporaryDtors(E->getSubExpr(), true, Context);
@@ -5115,12 +5104,14 @@ CFGBlock *CFGBuilder::VisitCXXBindTemporaryExprForTemporaryDtors(
// create a new block for the destructor which does not have as a
// successor anything built thus far. Control won't flow out of this
// block.
- if (B) Succ = B;
+ if (B)
+ Succ = B;
Block = createNoReturnBlock();
} else if (Context.needsTempDtorBranch()) {
// If we need to introduce a branch, we add a new block that we will hook
// up to a decision block later.
- if (B) Succ = B;
+ if (B)
+ Succ = B;
Block = createBlock();
} else {
autoCreateBlock();
@@ -5159,7 +5150,8 @@ CFGBlock *CFGBuilder::VisitConditionalOperatorForTemporaryDtors(
CFGBlock *ConditionSucc = Succ;
TryResult ConditionVal = tryEvaluateBool(E->getCond());
TryResult NegatedVal = ConditionVal;
- if (NegatedVal.isKnown()) NegatedVal.negate();
+ if (NegatedVal.isKnown())
+ NegatedVal.negate();
TempDtorContext TrueContext(
bothKnownTrue(Context.KnownExecuted, ConditionVal));
@@ -5287,73 +5279,73 @@ bool CFG::isLinear() const {
const CXXDestructorDecl *
CFGImplicitDtor::getDestructorDecl(ASTContext &astContext) const {
switch (getKind()) {
- case CFGElement::Initializer:
- case CFGElement::NewAllocator:
- case CFGElement::LoopExit:
- case CFGElement::LifetimeEnds:
- case CFGElement::Statement:
- case CFGElement::Constructor:
- case CFGElement::CXXRecordTypedCall:
- case CFGElement::ScopeBegin:
- case CFGElement::ScopeEnd:
- case CFGElement::CleanupFunction:
- llvm_unreachable("getDestructorDecl should only be used with "
- "ImplicitDtors");
- case CFGElement::AutomaticObjectDtor: {
- const VarDecl *var = castAs<CFGAutomaticObjDtor>().getVarDecl();
- QualType ty = var->getType();
-
- // FIXME: See CFGBuilder::addLocalScopeForVarDecl.
- //
- // Lifetime-extending constructs are handled here. This works for a single
- // temporary in an initializer expression.
- if (ty->isReferenceType()) {
- if (const Expr *Init = var->getInit()) {
- ty = getReferenceInitTemporaryType(Init);
- }
- }
-
- while (const ArrayType *arrayType = astContext.getAsArrayType(ty)) {
- ty = arrayType->getElementType();
+ case CFGElement::Initializer:
+ case CFGElement::NewAllocator:
+ case CFGElement::LoopExit:
+ case CFGElement::LifetimeEnds:
+ case CFGElement::Statement:
+ case CFGElement::Constructor:
+ case CFGElement::CXXRecordTypedCall:
+ case CFGElement::ScopeBegin:
+ case CFGElement::ScopeEnd:
+ case CFGElement::CleanupFunction:
+ llvm_unreachable("getDestructorDecl should only be used with "
+ "ImplicitDtors");
+ case CFGElement::AutomaticObjectDtor: {
+ const VarDecl *var = castAs<CFGAutomaticObjDtor>().getVarDecl();
+ QualType ty = var->getType();
+
+ // FIXME: See CFGBuilder::addLocalScopeForVarDecl.
+ //
+ // Lifetime-extending constructs are handled here. This works for a single
+ // temporary in an initializer expression.
+ if (ty->isReferenceType()) {
+ if (const Expr *Init = var->getInit()) {
+ ty = getReferenceInitTemporaryType(Init);
}
-
- // The situation when the type of the lifetime-extending reference
- // does not correspond to the type of the object is supposed
- // to be handled by now. In particular, 'ty' is now the unwrapped
- // record type.
- const CXXRecordDecl *classDecl = ty->getAsCXXRecordDecl();
- assert(classDecl);
- return classDecl->getDestructor();
- }
- case CFGElement::DeleteDtor: {
- const CXXDeleteExpr *DE = castAs<CFGDeleteDtor>().getDeleteExpr();
- QualType DTy = DE->getDestroyedType();
- DTy = DTy.getNonReferenceType();
- const CXXRecordDecl *classDecl =
- astContext.getBaseElementType(DTy)->getAsCXXRecordDecl();
- return classDecl->getDestructor();
}
- case CFGElement::TemporaryDtor: {
- const CXXBindTemporaryExpr *bindExpr =
- castAs<CFGTemporaryDtor>().getBindTemporaryExpr();
- const CXXTemporary *temp = bindExpr->getTemporary();
- return temp->getDestructor();
+
+ while (const ArrayType *arrayType = astContext.getAsArrayType(ty)) {
+ ty = arrayType->getElementType();
}
- case CFGElement::MemberDtor: {
- const FieldDecl *field = castAs<CFGMemberDtor>().getFieldDecl();
- QualType ty = field->getType();
- while (const ArrayType *arrayType = astContext.getAsArrayType(ty)) {
- ty = arrayType->getElementType();
- }
+ // The situation when the type of the lifetime-extending reference
+ // does not correspond to the type of the object is supposed
+ // to be handled by now. In particular, 'ty' is now the unwrapped
+ // record type.
+ const CXXRecordDecl *classDecl = ty->getAsCXXRecordDecl();
+ assert(classDecl);
+ return classDecl->getDestructor();
+ }
+ case CFGElement::DeleteDtor: {
+ const CXXDeleteExpr *DE = castAs<CFGDeleteDtor>().getDeleteExpr();
+ QualType DTy = DE->getDestroyedType();
+ DTy = DTy.getNonReferenceType();
+ const CXXRecordDecl *classDecl =
+ astContext.getBaseElementType(DTy)->getAsCXXRecordDecl();
+ return classDecl->getDestructor();
+ }
+ case CFGElement::TemporaryDtor: {
+ const CXXBindTemporaryExpr *bindExpr =
+ castAs<CFGTemporaryDtor>().getBindTemporaryExpr();
+ const CXXTemporary *temp = bindExpr->getTemporary();
+ return temp->getDestructor();
+ }
+ case CFGElement::MemberDtor: {
+ const FieldDecl *field = castAs<CFGMemberDtor>().getFieldDecl();
+ QualType ty = field->getType();
- const CXXRecordDecl *classDecl = ty->getAsCXXRecordDecl();
- assert(classDecl);
- return classDecl->getDestructor();
+ while (const ArrayType *arrayType = astContext.getAsArrayType(ty)) {
+ ty = arrayType->getElementType();
}
- case CFGElement::BaseDtor:
- // Not yet supported.
- return nullptr;
+
+ const CXXRecordDecl *classDecl = ty->getAsCXXRecordDecl();
+ assert(classDecl);
+ return classDecl->getDestructor();
+ }
+ case CFGElement::BaseDtor:
+ // Not yet supported.
+ return nullptr;
}
llvm_unreachable("getKind() returned bogus value");
}
@@ -5372,8 +5364,7 @@ CFGBlock::AdjacentBlock::AdjacentBlock(CFGBlock *B, CFGBlock *AlternateBlock)
UnreachableBlock(B == AlternateBlock ? nullptr : AlternateBlock,
B == AlternateBlock ? AB_Alternate : AB_Normal) {}
-void CFGBlock::addSuccessor(AdjacentBlock Succ,
- BumpVectorContext &C) {
+void CFGBlock::addSuccessor(AdjacentBlock Succ, BumpVectorContext &C) {
if (CFGBlock *B = Succ.getReachableBlock())
B->Preds.push_back(AdjacentBlock(this, Succ.isReachable()), C);
@@ -5384,7 +5375,7 @@ void CFGBlock::addSuccessor(AdjacentBlock Succ,
}
bool CFGBlock::FilterEdge(const CFGBlock::FilterOptions &F,
- const CFGBlock *From, const CFGBlock *To) {
+ const CFGBlock *From, const CFGBlock *To) {
if (F.IgnoreNullPredecessors && !From)
return true;
@@ -5392,7 +5383,7 @@ bool CFGBlock::FilterEdge(const CFGBlock::FilterOptions &F,
// If the 'To' has no label or is labeled but the label isn't a
// CaseStmt then filter this edge.
if (const SwitchStmt *S =
- dyn_cast_or_null<SwitchStmt>(From->getTerminatorStmt())) {
+ dyn_cast_or_null<SwitchStmt>(From->getTerminatorStmt())) {
if (S->isAllEnumCasesCovered()) {
const Stmt *L = To->getLabel();
if (!L || !isa<CaseStmt>(L))
@@ -5410,7 +5401,7 @@ bool CFGBlock::FilterEdge(const CFGBlock::FilterOptions &F,
namespace {
-class StmtPrinterHelper : public PrinterHelper {
+class StmtPrinterHelper : public PrinterHelper {
using StmtMapTy = llvm::DenseMap<const Stmt *, std::pair<unsigned, unsigned>>;
using DeclMapTy = llvm::DenseMap<const Decl *, std::pair<unsigned, unsigned>>;
@@ -5421,58 +5412,54 @@ class StmtPrinterHelper : public PrinterHelper {
const LangOptions &LangOpts;
public:
- StmtPrinterHelper(const CFG* cfg, const LangOptions &LO)
- : LangOpts(LO) {
+ StmtPrinterHelper(const CFG *cfg, const LangOptions &LO) : LangOpts(LO) {
if (!cfg)
return;
- for (CFG::const_iterator I = cfg->begin(), E = cfg->end(); I != E; ++I ) {
+ for (CFG::const_iterator I = cfg->begin(), E = cfg->end(); I != E; ++I) {
unsigned j = 1;
- for (CFGBlock::const_iterator BI = (*I)->begin(), BEnd = (*I)->end() ;
- BI != BEnd; ++BI, ++j ) {
+ for (CFGBlock::const_iterator BI = (*I)->begin(), BEnd = (*I)->end();
+ BI != BEnd; ++BI, ++j) {
if (std::optional<CFGStmt> SE = BI->getAs<CFGStmt>()) {
- const Stmt *stmt= SE->getStmt();
+ const Stmt *stmt = SE->getStmt();
std::pair<unsigned, unsigned> P((*I)->getBlockID(), j);
StmtMap[stmt] = P;
switch (stmt->getStmtClass()) {
- case Stmt::DeclStmtClass:
- DeclMap[cast<DeclStmt>(stmt)->getSingleDecl()] = P;
- break;
- case Stmt::IfStmtClass: {
- const VarDecl *var = cast<IfStmt>(stmt)->getConditionVariable();
- if (var)
- DeclMap[var] = P;
- break;
- }
- case Stmt::ForStmtClass: {
- const VarDecl *var = cast<ForStmt>(stmt)->getConditionVariable();
- if (var)
- DeclMap[var] = P;
- break;
- }
- case Stmt::WhileStmtClass: {
- const VarDecl *var =
- cast<WhileStmt>(stmt)->getConditionVariable();
- if (var)
- DeclMap[var] = P;
- break;
- }
- case Stmt::SwitchStmtClass: {
- const VarDecl *var =
- cast<SwitchStmt>(stmt)->getConditionVariable();
- if (var)
- DeclMap[var] = P;
- break;
- }
- case Stmt::CXXCatchStmtClass: {
- const VarDecl *var =
- cast<CXXCatchStmt>(stmt)->getExceptionDecl();
- if (var)
- DeclMap[var] = P;
- break;
- }
- default:
- break;
+ case Stmt::DeclStmtClass:
+ DeclMap[cast<DeclStmt>(stmt)->getSingleDecl()] = P;
+ break;
+ case Stmt::IfStmtClass: {
+ const VarDecl *var = cast<IfStmt>(stmt)->getConditionVariable();
+ if (var)
+ DeclMap[var] = P;
+ break;
+ }
+ case Stmt::ForStmtClass: {
+ const VarDecl *var = cast<ForStmt>(stmt)->getConditionVariable();
+ if (var)
+ DeclMap[var] = P;
+ break;
+ }
+ case Stmt::WhileStmtClass: {
+ const VarDecl *var = cast<WhileStmt>(stmt)->getConditionVariable();
+ if (var)
+ DeclMap[var] = P;
+ break;
+ }
+ case Stmt::SwitchStmtClass: {
+ const VarDecl *var = cast<SwitchStmt>(stmt)->getConditionVariable();
+ if (var)
+ DeclMap[var] = P;
+ break;
+ }
+ case Stmt::CXXCatchStmtClass: {
+ const VarDecl *var = cast<CXXCatchStmt>(stmt)->getExceptionDecl();
+ if (var)
+ DeclMap[var] = P;
+ break;
+ }
+ default:
+ break;
}
}
}
@@ -5491,8 +5478,8 @@ class StmtPrinterHelper : public PrinterHelper {
if (I == StmtMap.end())
return false;
- if (currentBlock >= 0 && I->second.first == (unsigned) currentBlock
- && I->second.second == currStmt) {
+ if (currentBlock >= 0 && I->second.first == (unsigned)currentBlock &&
+ I->second.second == currStmt) {
return false;
}
@@ -5506,8 +5493,8 @@ class StmtPrinterHelper : public PrinterHelper {
if (I == DeclMap.end())
return false;
- if (currentBlock >= 0 && I->second.first == (unsigned) currentBlock
- && I->second.second == currStmt) {
+ if (currentBlock >= 0 && I->second.first == (unsigned)currentBlock &&
+ I->second.second == currStmt) {
return false;
}
@@ -5517,13 +5504,13 @@ class StmtPrinterHelper : public PrinterHelper {
};
class CFGBlockTerminatorPrint
- : public StmtVisitor<CFGBlockTerminatorPrint,void> {
+ : public StmtVisitor<CFGBlockTerminatorPrint, void> {
raw_ostream &OS;
- StmtPrinterHelper* Helper;
+ StmtPrinterHelper *Helper;
PrintingPolicy Policy;
public:
- CFGBlockTerminatorPrint(raw_ostream &os, StmtPrinterHelper* helper,
+ CFGBlockTerminatorPrint(raw_ostream &os, StmtPrinterHelper *helper,
const PrintingPolicy &Policy)
: OS(os), Helper(helper), Policy(Policy) {
this->Policy.IncludeNewlines = false;
@@ -5546,7 +5533,7 @@ class CFGBlockTerminatorPrint
}
void VisitForStmt(ForStmt *F) {
- OS << "for (" ;
+ OS << "for (";
if (F->getInit())
OS << "...";
OS << "; ";
@@ -5559,7 +5546,7 @@ class CFGBlockTerminatorPrint
}
void VisitWhileStmt(WhileStmt *W) {
- OS << "while " ;
+ OS << "while ";
if (Stmt *C = W->getCond())
C->printPretty(OS, Helper, Policy);
}
@@ -5581,7 +5568,7 @@ class CFGBlockTerminatorPrint
void VisitSEHTryStmt(SEHTryStmt *CS) { OS << "__try ..."; }
- void VisitAbstractConditionalOperator(AbstractConditionalOperator* C) {
+ void VisitAbstractConditionalOperator(AbstractConditionalOperator *C) {
if (Stmt *Cond = C->getCond())
Cond->printPretty(OS, Helper, Policy);
OS << " ? ... : ...";
@@ -5600,7 +5587,7 @@ class CFGBlockTerminatorPrint
T->printPretty(OS, Helper, Policy);
}
- void VisitBinaryOperator(BinaryOperator* B) {
+ void VisitBinaryOperator(BinaryOperator *B) {
if (!B->isLogicalOp()) {
VisitExpr(B);
return;
@@ -5610,20 +5597,18 @@ class CFGBlockTerminatorPrint
B->getLHS()->printPretty(OS, Helper, Policy);
switch (B->getOpcode()) {
- case BO_LOr:
- OS << " || ...";
- return;
- case BO_LAnd:
- OS << " && ...";
- return;
- default:
- llvm_unreachable("Invalid logical operator.");
+ case BO_LOr:
+ OS << " || ...";
+ return;
+ case BO_LAnd:
+ OS << " && ...";
+ return;
+ default:
+ llvm_unreachable("Invalid logical operator.");
}
}
- void VisitExpr(Expr *E) {
- E->printPretty(OS, Helper, Policy);
- }
+ void VisitExpr(Expr *E) { E->printPretty(OS, Helper, Policy); }
public:
void print(CFGTerminator T) {
@@ -5672,7 +5657,8 @@ static void print_construction_context(raw_ostream &OS,
switch (CC->getKind()) {
case ConstructionContext::SimpleConstructorInitializerKind: {
OS << ", ";
- const auto *SICC = cast<SimpleConstructorInitializerConstructionContext>(CC);
+ const auto *SICC =
+ cast<SimpleConstructorInitializerConstructionContext>(CC);
print_initializer(OS, Helper, SICC->getCXXCtorInitializer());
return;
}
@@ -5743,7 +5729,7 @@ static void print_construction_context(raw_ostream &OS,
return;
}
}
- for (auto I: Stmts)
+ for (auto I : Stmts)
if (I) {
OS << ", ";
Helper.handledStmt(const_cast<Stmt *>(I), OS);
@@ -5776,16 +5762,16 @@ static void print_elem(raw_ostream &OS, StmtPrinterHelper &Helper,
auto Children = Sub->children();
if (Children.begin() != Children.end()) {
OS << "({ ... ; ";
- Helper.handledStmt(*SE->getSubStmt()->body_rbegin(),OS);
+ Helper.handledStmt(*SE->getSubStmt()->body_rbegin(), OS);
OS << " })\n";
return;
}
}
// special printing for comma expressions.
- if (const BinaryOperator* B = dyn_cast<BinaryOperator>(S)) {
+ if (const BinaryOperator *B = dyn_cast<BinaryOperator>(S)) {
if (B->getOpcode() == BO_Comma) {
OS << "... , ";
- Helper.handledStmt(B->getRHS(),OS);
+ Helper.handledStmt(B->getRHS(), OS);
OS << '\n';
return;
}
@@ -5851,7 +5837,8 @@ static void print_elem(raw_ostream &OS, StmtPrinterHelper &Helper,
break;
case CFGElement::Kind::LoopExit:
- OS << E.castAs<CFGLoopExit>().getLoopStmt()->getStmtClassName() << " (LoopExit)\n";
+ OS << E.castAs<CFGLoopExit>().getLoopStmt()->getStmtClassName()
+ << " (LoopExit)\n";
break;
case CFGElement::Kind::ScopeBegin:
@@ -5870,7 +5857,8 @@ static void print_elem(raw_ostream &OS, StmtPrinterHelper &Helper,
case CFGElement::Kind::NewAllocator:
OS << "CFGNewAllocator(";
- if (const CXXNewExpr *AllocExpr = E.castAs<CFGNewAllocator>().getAllocatorExpr())
+ if (const CXXNewExpr *AllocExpr =
+ E.castAs<CFGNewAllocator>().getAllocatorExpr())
AllocExpr->getType().print(OS, PrintingPolicy(Helper.getLangOpts()));
OS << ")\n";
break;
@@ -5880,8 +5868,7 @@ static void print_elem(raw_ostream &OS, StmtPrinterHelper &Helper,
const CXXRecordDecl *RD = DE.getCXXRecordDecl();
if (!RD)
return;
- CXXDeleteExpr *DelExpr =
- const_cast<CXXDeleteExpr*>(DE.getDeleteExpr());
+ CXXDeleteExpr *DelExpr = const_cast<CXXDeleteExpr *>(DE.getDeleteExpr());
Helper.handledStmt(cast<Stmt>(DelExpr->getArgument()), OS);
OS << "->~" << RD->getName().str() << "()";
OS << " (Implicit destructor)\n";
@@ -5915,8 +5902,7 @@ static void print_elem(raw_ostream &OS, StmtPrinterHelper &Helper,
}
}
-static void print_block(raw_ostream &OS, const CFG* cfg,
- const CFGBlock &B,
+static void print_block(raw_ostream &OS, const CFG *cfg, const CFGBlock &B,
StmtPrinterHelper &Helper, bool print_edges,
bool ShowColors) {
Helper.setBlockID(B.getBlockID());
@@ -5942,7 +5928,7 @@ static void print_block(raw_ostream &OS, const CFG* cfg,
OS.resetColor();
// Print the label of this block.
- if (Stmt *Label = const_cast<Stmt*>(B.getLabel())) {
+ if (Stmt *Label = const_cast<Stmt *>(B.getLabel())) {
if (print_edges)
OS << " ";
@@ -5986,8 +5972,7 @@ static void print_block(raw_ostream &OS, const CFG* cfg,
// Iterate through the statements in the block and print them.
unsigned j = 1;
- for (CFGBlock::const_iterator I = B.begin(), E = B.end() ;
- I != E ; ++I, ++j ) {
+ for (CFGBlock::const_iterator I = B.begin(), E = B.end(); I != E; ++I, ++j) {
// Print the statement # in the basic block and the statement itself.
if (print_edges)
OS << " ";
@@ -6023,7 +6008,7 @@ static void print_block(raw_ostream &OS, const CFG* cfg,
const raw_ostream::Colors Color = raw_ostream::BLUE;
if (ShowColors)
OS.changeColor(Color);
- OS << " Preds " ;
+ OS << " Preds ";
if (ShowColors)
OS.resetColor();
OS << '(' << B.pred_size() << "):";
@@ -6086,8 +6071,7 @@ static void print_block(raw_ostream &OS, const CFG* cfg,
OS << " B" << B->getBlockID();
if (!Reachable)
OS << "(Unreachable)";
- }
- else {
+ } else {
OS << " NULL";
}
}
@@ -6112,7 +6096,7 @@ void CFG::print(raw_ostream &OS, const LangOptions &LO, bool ShowColors) const {
print_block(OS, this, getEntry(), Helper, true, ShowColors);
// Iterate through the CFGBlocks and print them one by one.
- for (const_iterator I = Blocks.begin(), E = Blocks.end() ; I != E ; ++I) {
+ for (const_iterator I = Blocks.begin(), E = Blocks.end(); I != E; ++I) {
// Skip the entry block, because we already printed it.
if (&(**I) == &getEntry() || &(**I) == &getExit())
continue;
@@ -6131,7 +6115,7 @@ size_t CFGBlock::getIndexInCFG() const {
}
/// dump - A simply pretty printer of a CFGBlock that outputs to stderr.
-void CFGBlock::dump(const CFG* cfg, const LangOptions &LO,
+void CFGBlock::dump(const CFG *cfg, const LangOptions &LO,
bool ShowColors) const {
print(llvm::errs(), cfg, LO, ShowColors);
}
@@ -6142,16 +6126,15 @@ LLVM_DUMP_METHOD void CFGBlock::dump() const {
/// print - A simple pretty printer of a CFGBlock that outputs to an ostream.
/// Generally this will only be called from CFG::print.
-void CFGBlock::print(raw_ostream &OS, const CFG* cfg,
- const LangOptions &LO, bool ShowColors) const {
+void CFGBlock::print(raw_ostream &OS, const CFG *cfg, const LangOptions &LO,
+ bool ShowColors) const {
StmtPrinterHelper Helper(cfg, LO);
print_block(OS, cfg, *this, Helper, true, ShowColors);
OS << '\n';
}
/// printTerminator - A simple pretty printer of the terminator of a CFGBlock.
-void CFGBlock::printTerminator(raw_ostream &OS,
- const LangOptions &LO) const {
+void CFGBlock::printTerminator(raw_ostream &OS, const LangOptions &LO) const {
CFGBlockTerminatorPrint TPrinter(OS, nullptr, PrintingPolicy(LO));
TPrinter.print(getTerminator());
}
@@ -6268,55 +6251,55 @@ Stmt *CFGBlock::getTerminatorCondition(bool StripParens) {
Expr *E = nullptr;
switch (Terminator->getStmtClass()) {
- default:
- break;
+ default:
+ break;
- case Stmt::CXXForRangeStmtClass:
- E = cast<CXXForRangeStmt>(Terminator)->getCond();
- break;
+ case Stmt::CXXForRangeStmtClass:
+ E = cast<CXXForRangeStmt>(Terminator)->getCond();
+ break;
- case Stmt::ForStmtClass:
- E = cast<ForStmt>(Terminator)->getCond();
- break;
+ case Stmt::ForStmtClass:
+ E = cast<ForStmt>(Terminator)->getCond();
+ break;
- case Stmt::WhileStmtClass:
- E = cast<WhileStmt>(Terminator)->getCond();
- break;
+ case Stmt::WhileStmtClass:
+ E = cast<WhileStmt>(Terminator)->getCond();
+ break;
- case Stmt::DoStmtClass:
- E = cast<DoStmt>(Terminator)->getCond();
- break;
+ case Stmt::DoStmtClass:
+ E = cast<DoStmt>(Terminator)->getCond();
+ break;
- case Stmt::IfStmtClass:
- E = cast<IfStmt>(Terminator)->getCond();
- break;
+ case Stmt::IfStmtClass:
+ E = cast<IfStmt>(Terminator)->getCond();
+ break;
- case Stmt::ChooseExprClass:
- E = cast<ChooseExpr>(Terminator)->getCond();
- break;
+ case Stmt::ChooseExprClass:
+ E = cast<ChooseExpr>(Terminator)->getCond();
+ break;
- case Stmt::IndirectGotoStmtClass:
- E = cast<IndirectGotoStmt>(Terminator)->getTarget();
- break;
+ case Stmt::IndirectGotoStmtClass:
+ E = cast<IndirectGotoStmt>(Terminator)->getTarget();
+ break;
- case Stmt::SwitchStmtClass:
- E = cast<SwitchStmt>(Terminator)->getCond();
- break;
+ case Stmt::SwitchStmtClass:
+ E = cast<SwitchStmt>(Terminator)->getCond();
+ break;
- case Stmt::BinaryConditionalOperatorClass:
- E = cast<BinaryConditionalOperator>(Terminator)->getCond();
- break;
+ case Stmt::BinaryConditionalOperatorClass:
+ E = cast<BinaryConditionalOperator>(Terminator)->getCond();
+ break;
- case Stmt::ConditionalOperatorClass:
- E = cast<ConditionalOperator>(Terminator)->getCond();
- break;
+ case Stmt::ConditionalOperatorClass:
+ E = cast<ConditionalOperator>(Terminator)->getCond();
+ break;
- case Stmt::BinaryOperatorClass: // '&&' and '||'
- E = cast<BinaryOperator>(Terminator)->getLHS();
- break;
+ case Stmt::BinaryOperatorClass: // '&&' and '||'
+ E = cast<BinaryOperator>(Terminator)->getLHS();
+ break;
- case Stmt::ObjCForCollectionStmtClass:
- return Terminator;
+ case Stmt::ObjCForCollectionStmtClass:
+ return Terminator;
}
if (!StripParens)
@@ -6334,29 +6317,29 @@ static StmtPrinterHelper *GraphHelper;
void CFG::viewCFG(const LangOptions &LO) const {
StmtPrinterHelper H(this, LO);
GraphHelper = &H;
- llvm::ViewGraph(this,"CFG");
+ llvm::ViewGraph(this, "CFG");
GraphHelper = nullptr;
}
namespace llvm {
-template<>
-struct DOTGraphTraits<const CFG*> : public DefaultDOTGraphTraits {
+template <> struct DOTGraphTraits<const CFG *> : public DefaultDOTGraphTraits {
DOTGraphTraits(bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
static std::string getNodeLabel(const CFGBlock *Node, const CFG *Graph) {
std::string OutSStr;
llvm::raw_string_ostream Out(OutSStr);
- print_block(Out,Graph, *Node, *GraphHelper, false, false);
- std::string& OutStr = Out.str();
+ print_block(Out, Graph, *Node, *GraphHelper, false, false);
+ std::string &OutStr = Out.str();
- if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
+ if (OutStr[0] == '\n')
+ OutStr.erase(OutStr.begin());
// Process string output to make it nicer...
for (unsigned i = 0; i != OutStr.length(); ++i)
- if (OutStr[i] == '\n') { // Left justify
+ if (OutStr[i] == '\n') { // Left justify
OutStr[i] = '\\';
- OutStr.insert(OutStr.begin()+i+1, 'l');
+ OutStr.insert(OutStr.begin() + i + 1, 'l');
}
return OutStr;
diff --git a/clang/lib/Analysis/CFGReachabilityAnalysis.cpp b/clang/lib/Analysis/CFGReachabilityAnalysis.cpp
index 2b5d6c466cde11..ed6d89ea45f46c 100644
--- a/clang/lib/Analysis/CFGReachabilityAnalysis.cpp
+++ b/clang/lib/Analysis/CFGReachabilityAnalysis.cpp
@@ -24,7 +24,7 @@ CFGReverseBlockReachabilityAnalysis::CFGReverseBlockReachabilityAnalysis(
: analyzed(cfg.getNumBlockIDs(), false) {}
bool CFGReverseBlockReachabilityAnalysis::isReachable(const CFGBlock *Src,
- const CFGBlock *Dst) {
+ const CFGBlock *Dst) {
const unsigned DstBlockID = Dst->getBlockID();
// If we haven't analyzed the destination node, run the analysis now
@@ -62,13 +62,13 @@ void CFGReverseBlockReachabilityAnalysis::mapReachability(const CFGBlock *Dst) {
if (!firstRun) {
// Don't insert Dst -> Dst unless it was a predecessor of itself
DstReachability[block->getBlockID()] = true;
- }
- else
+ } else
firstRun = false;
// Add the predecessors to the worklist.
for (CFGBlock::const_pred_iterator i = block->pred_begin(),
- e = block->pred_end(); i != e; ++i) {
+ e = block->pred_end();
+ i != e; ++i) {
if (*i)
worklist.push_back(*i);
}
diff --git a/clang/lib/Analysis/CFGStmtMap.cpp b/clang/lib/Analysis/CFGStmtMap.cpp
index c3a4581e1fb108..a44f8e89f72e0d 100644
--- a/clang/lib/Analysis/CFGStmtMap.cpp
+++ b/clang/lib/Analysis/CFGStmtMap.cpp
@@ -11,16 +11,16 @@
//
//===----------------------------------------------------------------------===//
-#include "llvm/ADT/DenseMap.h"
+#include "clang/Analysis/CFGStmtMap.h"
#include "clang/AST/ParentMap.h"
#include "clang/Analysis/CFG.h"
-#include "clang/Analysis/CFGStmtMap.h"
+#include "llvm/ADT/DenseMap.h"
#include <optional>
using namespace clang;
-typedef llvm::DenseMap<const Stmt*, CFGBlock*> SMap;
-static SMap *AsMap(void *m) { return (SMap*) m; }
+typedef llvm::DenseMap<const Stmt *, CFGBlock *> SMap;
+static SMap *AsMap(void *m) { return (SMap *)m; }
CFGStmtMap::~CFGStmtMap() { delete AsMap(M); }
@@ -61,7 +61,6 @@ static void Accumulate(SMap &SM, CFGBlock *B) {
continue;
Entry = B;
-
}
// Look at the label of the block.
@@ -88,4 +87,3 @@ CFGStmtMap *CFGStmtMap::Build(CFG *C, ParentMap *PM) {
return new CFGStmtMap(PM, SM);
}
-
diff --git a/clang/lib/Analysis/CallGraph.cpp b/clang/lib/Analysis/CallGraph.cpp
index f892980ed31386..04636076d9478d 100644
--- a/clang/lib/Analysis/CallGraph.cpp
+++ b/clang/lib/Analysis/CallGraph.cpp
@@ -101,14 +101,10 @@ class CGBuilder : public StmtVisitor<CGBuilder> {
}
// Include the evaluation of the default argument.
- void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
- Visit(E->getExpr());
- }
+ void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { Visit(E->getExpr()); }
// Include the evaluation of the default initializers in a class.
- void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
- Visit(E->getExpr());
- }
+ void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { Visit(E->getExpr()); }
// Adds may-call edges for the ObjC message sends.
void VisitObjCMessageExpr(ObjCMessageExpr *ME) {
@@ -146,9 +142,7 @@ void CallGraph::addNodesForBlocks(DeclContext *D) {
addNodesForBlocks(DC);
}
-CallGraph::CallGraph() {
- Root = getOrInsertNode(nullptr);
-}
+CallGraph::CallGraph() { Root = getOrInsertNode(nullptr); }
CallGraph::~CallGraph() = default;
@@ -175,7 +169,7 @@ bool CallGraph::includeCalleeInGraph(const Decl *D) {
return true;
}
-void CallGraph::addNodeForDecl(Decl* D, bool IsGlobal) {
+void CallGraph::addNodeForDecl(Decl *D, bool IsGlobal) {
assert(D);
// Allocate a new node, mark it as root, and process its calls.
@@ -196,7 +190,8 @@ void CallGraph::addNodeForDecl(Decl* D, bool IsGlobal) {
CallGraphNode *CallGraph::getNode(const Decl *F) const {
FunctionMapTy::const_iterator I = FunctionMap.find(F);
- if (I == FunctionMap.end()) return nullptr;
+ if (I == FunctionMap.end())
+ return nullptr;
return I->second.get();
}
@@ -222,7 +217,9 @@ void CallGraph::print(raw_ostream &OS) const {
// sure the output is deterministic.
llvm::ReversePostOrderTraversal<const CallGraph *> RPOT(this);
for (llvm::ReversePostOrderTraversal<const CallGraph *>::rpo_iterator
- I = RPOT.begin(), E = RPOT.end(); I != E; ++I) {
+ I = RPOT.begin(),
+ E = RPOT.end();
+ I != E; ++I) {
const CallGraphNode *N = *I;
OS << " Function: ";
@@ -232,8 +229,8 @@ void CallGraph::print(raw_ostream &OS) const {
N->print(OS);
OS << " calls: ";
- for (CallGraphNode::const_iterator CI = N->begin(),
- CE = N->end(); CI != CE; ++CI) {
+ for (CallGraphNode::const_iterator CI = N->begin(), CE = N->end(); CI != CE;
+ ++CI) {
assert(CI->Callee != Root && "No one can call the root node.");
CI->Callee->print(OS);
OS << " ";
@@ -243,29 +240,23 @@ void CallGraph::print(raw_ostream &OS) const {
OS.flush();
}
-LLVM_DUMP_METHOD void CallGraph::dump() const {
- print(llvm::errs());
-}
+LLVM_DUMP_METHOD void CallGraph::dump() const { print(llvm::errs()); }
-void CallGraph::viewGraph() const {
- llvm::ViewGraph(this, "CallGraph");
-}
+void CallGraph::viewGraph() const { llvm::ViewGraph(this, "CallGraph"); }
void CallGraphNode::print(raw_ostream &os) const {
if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(FD))
- return ND->printQualifiedName(os);
+ return ND->printQualifiedName(os);
os << "< >";
}
-LLVM_DUMP_METHOD void CallGraphNode::dump() const {
- print(llvm::errs());
-}
+LLVM_DUMP_METHOD void CallGraphNode::dump() const { print(llvm::errs()); }
namespace llvm {
template <>
-struct DOTGraphTraits<const CallGraph*> : public DefaultDOTGraphTraits {
- DOTGraphTraits (bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
+struct DOTGraphTraits<const CallGraph *> : public DefaultDOTGraphTraits {
+ DOTGraphTraits(bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
static std::string getNodeLabel(const CallGraphNode *Node,
const CallGraph *CG) {
diff --git a/clang/lib/Analysis/CocoaConventions.cpp b/clang/lib/Analysis/CocoaConventions.cpp
index 836859c2234585..58ec28c0b61300 100644
--- a/clang/lib/Analysis/CocoaConventions.cpp
+++ b/clang/lib/Analysis/CocoaConventions.cpp
@@ -21,8 +21,7 @@
using namespace clang;
using namespace ento;
-bool cocoa::isRefType(QualType RetTy, StringRef Prefix,
- StringRef Name) {
+bool cocoa::isRefType(QualType RetTy, StringRef Prefix, StringRef Name) {
// Recursively walk the typedef stack, allowing typedefs of reference types.
while (const TypedefType *TD = RetTy->getAs<TypedefType>()) {
StringRef TDName = TD->getDecl()->getIdentifier()->getName();
@@ -38,7 +37,7 @@ bool cocoa::isRefType(QualType RetTy, StringRef Prefix,
return false;
// Is the type void*?
- const PointerType* PT = RetTy->castAs<PointerType>();
+ const PointerType *PT = RetTy->castAs<PointerType>();
if (!PT || !PT->getPointeeType().getUnqualifiedType()->isVoidType())
return false;
@@ -49,9 +48,8 @@ bool cocoa::isRefType(QualType RetTy, StringRef Prefix,
/// Returns true when the passed-in type is a CF-style reference-counted
/// type from the DiskArbitration framework.
static bool isDiskArbitrationAPIRefType(QualType T) {
- return cocoa::isRefType(T, "DADisk") ||
- cocoa::isRefType(T, "DADissenter") ||
- cocoa::isRefType(T, "DASessionRef");
+ return cocoa::isRefType(T, "DADisk") || cocoa::isRefType(T, "DADissenter") ||
+ cocoa::isRefType(T, "DASessionRef");
}
bool coreFoundation::isCFObjectRef(QualType T) {
@@ -61,7 +59,6 @@ bool coreFoundation::isCFObjectRef(QualType T) {
isDiskArbitrationAPIRefType(T);
}
-
bool cocoa::isCocoaObjectRef(QualType Ty) {
if (!Ty->isObjCObjectPointerType())
return false;
@@ -87,7 +84,7 @@ bool cocoa::isCocoaObjectRef(QualType Ty) {
if (!ID->hasDefinition())
return true;
- for ( ; ID ; ID = ID->getSuperClass())
+ for (; ID; ID = ID->getSuperClass())
if (ID->getIdentifier()->getName() == "NSObject")
return true;
@@ -98,7 +95,8 @@ bool coreFoundation::followsCreateRule(const FunctionDecl *fn) {
// For now, *just* base this on the function name, not on anything else.
const IdentifierInfo *ident = fn->getIdentifier();
- if (!ident) return false;
+ if (!ident)
+ return false;
StringRef functionName = ident->getName();
StringRef::iterator it = functionName.begin();
@@ -107,7 +105,7 @@ bool coreFoundation::followsCreateRule(const FunctionDecl *fn) {
while (true) {
// Scan for the start of 'create' or 'copy'.
- for ( ; it != endI ; ++it) {
+ for (; it != endI; ++it) {
// Search for the first character. It can either be 'C' or 'c'.
char ch = *it;
if (ch == 'C' || ch == 'c') {
diff --git a/clang/lib/Analysis/ConstructionContext.cpp b/clang/lib/Analysis/ConstructionContext.cpp
index 8a862c06f13ad4..38ff8962486e3f 100644
--- a/clang/lib/Analysis/ConstructionContext.cpp
+++ b/clang/lib/Analysis/ConstructionContext.cpp
@@ -51,7 +51,9 @@ ConstructionContext::createMaterializedTemporaryFromLayers(
// If the object requires destruction and is not lifetime-extended,
// then it must have a BTE within its MTE, otherwise it shouldn't.
// FIXME: This should be an assertion.
- if (!BTE && !(MTE->getType().getCanonicalType()->getAsCXXRecordDecl()
+ if (!BTE && !(MTE->getType()
+ .getCanonicalType()
+ ->getAsCXXRecordDecl()
->hasTrivialDestructor() ||
MTE->getStorageDuration() != SD_FullExpression)) {
return nullptr;
@@ -83,8 +85,8 @@ ConstructionContext::createMaterializedTemporaryFromLayers(
// In this case, skip copy elision entirely.
return create<SimpleTemporaryObjectConstructionContext>(C, BTE, MTE);
}
- return create<ElidedTemporaryObjectConstructionContext>(
- C, BTE, MTE, ElidedCE, ElidedCC);
+ return create<ElidedTemporaryObjectConstructionContext>(C, BTE, MTE,
+ ElidedCE, ElidedCC);
}
// This is a normal temporary.
@@ -108,8 +110,11 @@ const ConstructionContext *ConstructionContext::createBoundTemporaryFromLayers(
switch (ParentItem.getKind()) {
case ConstructionContextItem::VariableKind: {
const auto *DS = cast<DeclStmt>(ParentItem.getStmt());
- assert(!cast<VarDecl>(DS->getSingleDecl())->getType().getCanonicalType()
- ->getAsCXXRecordDecl()->hasTrivialDestructor());
+ assert(!cast<VarDecl>(DS->getSingleDecl())
+ ->getType()
+ .getCanonicalType()
+ ->getAsCXXRecordDecl()
+ ->hasTrivialDestructor());
return create<CXX17ElidedCopyVariableConstructionContext>(C, DS, BTE);
}
case ConstructionContextItem::NewAllocatorKind: {
@@ -118,10 +123,12 @@ const ConstructionContext *ConstructionContext::createBoundTemporaryFromLayers(
case ConstructionContextItem::ReturnKind: {
assert(ParentLayer->isLast());
const auto *RS = cast<ReturnStmt>(ParentItem.getStmt());
- assert(!RS->getRetValue()->getType().getCanonicalType()
- ->getAsCXXRecordDecl()->hasTrivialDestructor());
- return create<CXX17ElidedCopyReturnedValueConstructionContext>(C, RS,
- BTE);
+ assert(!RS->getRetValue()
+ ->getType()
+ .getCanonicalType()
+ ->getAsCXXRecordDecl()
+ ->hasTrivialDestructor());
+ return create<CXX17ElidedCopyReturnedValueConstructionContext>(C, RS, BTE);
}
case ConstructionContextItem::MaterializationKind: {
@@ -151,8 +158,11 @@ const ConstructionContext *ConstructionContext::createBoundTemporaryFromLayers(
case ConstructionContextItem::InitializerKind: {
assert(ParentLayer->isLast());
const auto *I = ParentItem.getCXXCtorInitializer();
- assert(!I->getAnyMember()->getType().getCanonicalType()
- ->getAsCXXRecordDecl()->hasTrivialDestructor());
+ assert(!I->getAnyMember()
+ ->getType()
+ .getCanonicalType()
+ ->getAsCXXRecordDecl()
+ ->hasTrivialDestructor());
return create<CXX17ElidedCopyConstructorInitializerConstructionContext>(
C, I, BTE);
}
@@ -196,8 +206,10 @@ const ConstructionContext *ConstructionContext::createFromLayers(
}
case ConstructionContextItem::TemporaryDestructorKind: {
const auto *BTE = cast<CXXBindTemporaryExpr>(TopItem.getStmt());
- assert(BTE->getType().getCanonicalType()->getAsCXXRecordDecl()
- ->hasNonTrivialDestructor());
+ assert(BTE->getType()
+ .getCanonicalType()
+ ->getAsCXXRecordDecl()
+ ->hasNonTrivialDestructor());
return createBoundTemporaryFromLayers(C, BTE, TopLayer->getParent());
}
case ConstructionContextItem::ElidedDestructorKind: {
diff --git a/clang/lib/Analysis/Consumed.cpp b/clang/lib/Analysis/Consumed.cpp
index d01c7f688e8b5d..41bb960d7bf451 100644
--- a/clang/lib/Analysis/Consumed.cpp
+++ b/clang/lib/Analysis/Consumed.cpp
@@ -80,7 +80,8 @@ static SourceLocation getLastStmtLoc(const CFGBlock *Block) {
return StmtNode->getBeginLoc();
} else {
for (CFGBlock::const_reverse_iterator BI = Block->rbegin(),
- BE = Block->rend(); BI != BE; ++BI) {
+ BE = Block->rend();
+ BI != BE; ++BI) {
if (std::optional<CFGStmt> CS = BI->getAs<CFGStmt>())
return CS->getStmt()->getBeginLoc();
}
@@ -285,10 +286,7 @@ struct VarTestResult {
namespace clang {
namespace consumed {
-enum EffectiveOp {
- EO_And,
- EO_Or
-};
+enum EffectiveOp { EO_And, EO_Or };
class PropagationInfo {
enum {
@@ -322,33 +320,32 @@ class PropagationInfo {
PropagationInfo(const VarDecl *Var, ConsumedState TestsFor)
: InfoType(IT_VarTest) {
- VarTest.Var = Var;
+ VarTest.Var = Var;
VarTest.TestsFor = TestsFor;
}
PropagationInfo(const BinaryOperator *Source, EffectiveOp EOp,
const VarTestResult <est, const VarTestResult &RTest)
: InfoType(IT_BinTest) {
- BinTest.Source = Source;
- BinTest.EOp = EOp;
- BinTest.LTest = LTest;
- BinTest.RTest = RTest;
+ BinTest.Source = Source;
+ BinTest.EOp = EOp;
+ BinTest.LTest = LTest;
+ BinTest.RTest = RTest;
}
PropagationInfo(const BinaryOperator *Source, EffectiveOp EOp,
const VarDecl *LVar, ConsumedState LTestsFor,
const VarDecl *RVar, ConsumedState RTestsFor)
: InfoType(IT_BinTest) {
- BinTest.Source = Source;
- BinTest.EOp = EOp;
- BinTest.LTest.Var = LVar;
+ BinTest.Source = Source;
+ BinTest.EOp = EOp;
+ BinTest.LTest.Var = LVar;
BinTest.LTest.TestsFor = LTestsFor;
- BinTest.RTest.Var = RVar;
+ BinTest.RTest.Var = RVar;
BinTest.RTest.TestsFor = RTestsFor;
}
- PropagationInfo(ConsumedState State)
- : InfoType(IT_State), State(State) {}
+ PropagationInfo(ConsumedState State) : InfoType(IT_State), State(State) {}
PropagationInfo(const VarDecl *Var) : InfoType(IT_Var), Var(Var) {}
PropagationInfo(const CXXBindTemporaryExpr *Tmp)
: InfoType(IT_Tmp), Tmp(Tmp) {}
@@ -401,7 +398,7 @@ class PropagationInfo {
return BinTest.EOp;
}
- const BinaryOperator * testSourceNode() const {
+ const BinaryOperator *testSourceNode() const {
assert(InfoType == IT_BinTest);
return BinTest.Source;
}
@@ -429,10 +426,10 @@ class PropagationInfo {
invertConsumedUnconsumed(VarTest.TestsFor));
} else if (InfoType == IT_BinTest) {
- return PropagationInfo(BinTest.Source,
- BinTest.EOp == EO_And ? EO_Or : EO_And,
- BinTest.LTest.Var, invertConsumedUnconsumed(BinTest.LTest.TestsFor),
- BinTest.RTest.Var, invertConsumedUnconsumed(BinTest.RTest.TestsFor));
+ return PropagationInfo(
+ BinTest.Source, BinTest.EOp == EO_And ? EO_Or : EO_And,
+ BinTest.LTest.Var, invertConsumedUnconsumed(BinTest.LTest.TestsFor),
+ BinTest.RTest.Var, invertConsumedUnconsumed(BinTest.RTest.TestsFor));
} else {
return {};
}
@@ -442,9 +439,9 @@ class PropagationInfo {
} // namespace consumed
} // namespace clang
-static void
-setStateForVarOrTmp(ConsumedStateMap *StateMap, const PropagationInfo &PInfo,
- ConsumedState State) {
+static void setStateForVarOrTmp(ConsumedStateMap *StateMap,
+ const PropagationInfo &PInfo,
+ ConsumedState State) {
assert(PInfo.isVar() || PInfo.isTmp());
if (PInfo.isVar())
@@ -458,7 +455,7 @@ namespace consumed {
class ConsumedStmtVisitor : public ConstStmtVisitor<ConsumedStmtVisitor> {
using MapType = llvm::DenseMap<const Stmt *, PropagationInfo>;
- using PairType= std::pair<const Stmt *, PropagationInfo>;
+ using PairType = std::pair<const Stmt *, PropagationInfo>;
using InfoEntry = MapType::iterator;
using ConstInfoEntry = MapType::const_iterator;
@@ -492,8 +489,7 @@ class ConsumedStmtVisitor : public ConstStmtVisitor<ConsumedStmtVisitor> {
public:
void checkCallability(const PropagationInfo &PInfo,
- const FunctionDecl *FunDecl,
- SourceLocation BlameLoc);
+ const FunctionDecl *FunDecl, SourceLocation BlameLoc);
bool handleCall(const CallExpr *Call, const Expr *ObjArg,
const FunctionDecl *FunD);
@@ -525,9 +521,7 @@ class ConsumedStmtVisitor : public ConstStmtVisitor<ConsumedStmtVisitor> {
return {};
}
- void reset(ConsumedStateMap *NewStateMap) {
- StateMap = NewStateMap;
- }
+ void reset(ConsumedStateMap *NewStateMap) { StateMap = NewStateMap; }
};
} // namespace consumed
@@ -545,7 +539,7 @@ void ConsumedStmtVisitor::copyInfo(const Expr *From, const Expr *To,
ConsumedState NS) {
InfoEntry Entry = findInfo(From);
if (Entry != PropagationMap.end()) {
- PropagationInfo& PInfo = Entry->second;
+ PropagationInfo &PInfo = Entry->second;
ConsumedState CS = PInfo.getAsState(StateMap);
if (CS != CS_None)
insertInfo(To, PropagationInfo(CS));
@@ -558,7 +552,7 @@ void ConsumedStmtVisitor::copyInfo(const Expr *From, const Expr *To,
ConsumedState ConsumedStmtVisitor::getInfo(const Expr *From) {
InfoEntry Entry = findInfo(From);
if (Entry != PropagationMap.end()) {
- PropagationInfo& PInfo = Entry->second;
+ PropagationInfo &PInfo = Entry->second;
return PInfo.getAsState(StateMap);
}
return CS_None;
@@ -568,11 +562,11 @@ ConsumedState ConsumedStmtVisitor::getInfo(const Expr *From) {
void ConsumedStmtVisitor::setInfo(const Expr *To, ConsumedState NS) {
InfoEntry Entry = findInfo(To);
if (Entry != PropagationMap.end()) {
- PropagationInfo& PInfo = Entry->second;
+ PropagationInfo &PInfo = Entry->second;
if (PInfo.isPointerToValue())
setStateForVarOrTmp(StateMap, PInfo, NS);
} else if (NS != CS_None) {
- insertInfo(To, PropagationInfo(NS));
+ insertInfo(To, PropagationInfo(NS));
}
}
@@ -592,8 +586,8 @@ void ConsumedStmtVisitor::checkCallability(const PropagationInfo &PInfo,
return;
Analyzer.WarningsHandler.warnUseInInvalidState(
- FunDecl->getNameAsString(), PInfo.getVar()->getNameAsString(),
- stateToString(VarState), BlameLoc);
+ FunDecl->getNameAsString(), PInfo.getVar()->getNameAsString(),
+ stateToString(VarState), BlameLoc);
} else {
ConsumedState TmpState = PInfo.getAsState(StateMap);
@@ -601,7 +595,7 @@ void ConsumedStmtVisitor::checkCallability(const PropagationInfo &PInfo,
return;
Analyzer.WarningsHandler.warnUseOfTempInInvalidState(
- FunDecl->getNameAsString(), stateToString(TmpState), BlameLoc);
+ FunDecl->getNameAsString(), stateToString(TmpState), BlameLoc);
}
}
@@ -612,7 +606,7 @@ bool ConsumedStmtVisitor::handleCall(const CallExpr *Call, const Expr *ObjArg,
const FunctionDecl *FunD) {
unsigned Offset = 0;
if (isa<CXXOperatorCallExpr>(Call) && isa<CXXMethodDecl>(FunD))
- Offset = 1; // first argument is 'this'
+ Offset = 1; // first argument is 'this'
// check explicit parameters
for (unsigned Index = Offset; Index < Call->getNumArgs(); ++Index) {
@@ -636,8 +630,8 @@ bool ConsumedStmtVisitor::handleCall(const CallExpr *Call, const Expr *ObjArg,
if (ParamState != ExpectedState)
Analyzer.WarningsHandler.warnParamTypestateMismatch(
- Call->getArg(Index)->getExprLoc(),
- stateToString(ExpectedState), stateToString(ParamState));
+ Call->getArg(Index)->getExprLoc(), stateToString(ExpectedState),
+ stateToString(ParamState));
}
if (!(Entry->second.isVar() || Entry->second.isTmp()))
@@ -667,15 +661,13 @@ bool ConsumedStmtVisitor::handleCall(const CallExpr *Call, const Expr *ObjArg,
if (PInfo.isVar()) {
StateMap->setState(PInfo.getVar(), mapSetTypestateAttrState(STA));
return true;
- }
- else if (PInfo.isTmp()) {
+ } else if (PInfo.isTmp()) {
StateMap->setState(PInfo.getTmp(), mapSetTypestateAttrState(STA));
return true;
}
- }
- else if (isTestingFunction(FunD) && PInfo.isVar()) {
- PropagationMap.insert(PairType(Call,
- PropagationInfo(PInfo.getVar(), testsFor(FunD))));
+ } else if (isTestingFunction(FunD) && PInfo.isVar()) {
+ PropagationMap.insert(
+ PairType(Call, PropagationInfo(PInfo.getVar(), testsFor(FunD))));
}
}
return false;
@@ -701,7 +693,7 @@ void ConsumedStmtVisitor::propagateReturnType(const Expr *Call,
void ConsumedStmtVisitor::VisitBinaryOperator(const BinaryOperator *BinOp) {
switch (BinOp->getOpcode()) {
case BO_LAnd:
- case BO_LOr : {
+ case BO_LOr: {
InfoEntry LEntry = findInfo(BinOp->getLHS()),
REntry = findInfo(BinOp->getRHS());
@@ -710,20 +702,23 @@ void ConsumedStmtVisitor::VisitBinaryOperator(const BinaryOperator *BinOp) {
if (LEntry != PropagationMap.end() && LEntry->second.isVarTest()) {
LTest = LEntry->second.getVarTest();
} else {
- LTest.Var = nullptr;
+ LTest.Var = nullptr;
LTest.TestsFor = CS_None;
}
if (REntry != PropagationMap.end() && REntry->second.isVarTest()) {
RTest = REntry->second.getVarTest();
} else {
- RTest.Var = nullptr;
+ RTest.Var = nullptr;
RTest.TestsFor = CS_None;
}
if (!(LTest.Var == nullptr && RTest.Var == nullptr))
- PropagationMap.insert(PairType(BinOp, PropagationInfo(BinOp,
- static_cast<EffectiveOp>(BinOp->getOpcode() == BO_LOr), LTest, RTest)));
+ PropagationMap.insert(PairType(
+ BinOp,
+ PropagationInfo(
+ BinOp, static_cast<EffectiveOp>(BinOp->getOpcode() == BO_LOr),
+ LTest, RTest)));
break;
}
@@ -758,7 +753,7 @@ void ConsumedStmtVisitor::VisitCastExpr(const CastExpr *Cast) {
}
void ConsumedStmtVisitor::VisitCXXBindTemporaryExpr(
- const CXXBindTemporaryExpr *Temp) {
+ const CXXBindTemporaryExpr *Temp) {
InfoEntry Entry = findInfo(Temp->getSubExpr());
@@ -782,15 +777,14 @@ void ConsumedStmtVisitor::VisitCXXConstructExpr(const CXXConstructExpr *Call) {
ConsumedState RetState = mapReturnTypestateAttrState(RTA);
PropagationMap.insert(PairType(Call, PropagationInfo(RetState)));
} else if (Constructor->isDefaultConstructor()) {
- PropagationMap.insert(PairType(Call,
- PropagationInfo(consumed::CS_Consumed)));
+ PropagationMap.insert(
+ PairType(Call, PropagationInfo(consumed::CS_Consumed)));
} else if (Constructor->isMoveConstructor()) {
copyInfo(Call->getArg(0), Call, CS_Consumed);
} else if (Constructor->isCopyConstructor()) {
// Copy state from arg. If setStateOnRead then set arg to CS_Unknown.
ConsumedState NS =
- isSetOnReadPtrType(Constructor->getThisType()) ?
- CS_Unknown : CS_None;
+ isSetOnReadPtrType(Constructor->getThisType()) ? CS_Unknown : CS_None;
copyInfo(Call->getArg(0), Call, NS);
} else {
// TODO: Adjust state of args appropriately.
@@ -801,7 +795,7 @@ void ConsumedStmtVisitor::VisitCXXConstructExpr(const CXXConstructExpr *Call) {
void ConsumedStmtVisitor::VisitCXXMemberCallExpr(
const CXXMemberCallExpr *Call) {
- CXXMethodDecl* MD = Call->getMethodDecl();
+ CXXMethodDecl *MD = Call->getMethodDecl();
if (!MD)
return;
@@ -812,7 +806,8 @@ void ConsumedStmtVisitor::VisitCXXMemberCallExpr(
void ConsumedStmtVisitor::VisitCXXOperatorCallExpr(
const CXXOperatorCallExpr *Call) {
const auto *FunDecl = dyn_cast_or_null<FunctionDecl>(Call->getDirectCallee());
- if (!FunDecl) return;
+ if (!FunDecl)
+ return;
if (Call->getOperator() == OO_Equal) {
ConsumedState CS = getInfo(Call->getArg(1));
@@ -846,7 +841,7 @@ void ConsumedStmtVisitor::VisitDeclStmt(const DeclStmt *DeclS) {
}
void ConsumedStmtVisitor::VisitMaterializeTemporaryExpr(
- const MaterializeTemporaryExpr *Temp) {
+ const MaterializeTemporaryExpr *Temp) {
forwardInfo(Temp->getSubExpr(), Temp);
}
@@ -884,8 +879,8 @@ void ConsumedStmtVisitor::VisitReturnStmt(const ReturnStmt *Ret) {
if (RetState != ExpectedState)
Analyzer.WarningsHandler.warnReturnTypestateMismatch(
- Ret->getReturnLoc(), stateToString(ExpectedState),
- stateToString(RetState));
+ Ret->getReturnLoc(), stateToString(ExpectedState),
+ stateToString(RetState));
}
}
@@ -895,7 +890,8 @@ void ConsumedStmtVisitor::VisitReturnStmt(const ReturnStmt *Ret) {
void ConsumedStmtVisitor::VisitUnaryOperator(const UnaryOperator *UOp) {
InfoEntry Entry = findInfo(UOp->getSubExpr());
- if (Entry == PropagationMap.end()) return;
+ if (Entry == PropagationMap.end())
+ return;
switch (UOp->getOpcode()) {
case UO_AddrOf:
@@ -950,8 +946,7 @@ static void splitVarStateForIf(const IfStmt *IfNode, const VarTestResult &Test,
static void splitVarStateForIfBinOp(const PropagationInfo &PInfo,
ConsumedStateMap *ThenStates,
ConsumedStateMap *ElseStates) {
- const VarTestResult <est = PInfo.getLTest(),
- &RTest = PInfo.getRTest();
+ const VarTestResult <est = PInfo.getLTest(), &RTest = PInfo.getRTest();
ConsumedState LState = LTest.Var ? ThenStates->getState(LTest.Var) : CS_None,
RState = RTest.Var ? ThenStates->getState(RTest.Var) : CS_None;
@@ -1007,8 +1002,9 @@ bool ConsumedBlockInfo::allBackEdgesVisited(const CFGBlock *CurrBlock,
unsigned int CurrBlockOrder = VisitOrder[CurrBlock->getBlockID()];
for (CFGBlock::const_pred_iterator PI = TargetBlock->pred_begin(),
- PE = TargetBlock->pred_end(); PI != PE; ++PI) {
- if (*PI && CurrBlockOrder < VisitOrder[(*PI)->getBlockID()] )
+ PE = TargetBlock->pred_end();
+ PI != PE; ++PI) {
+ if (*PI && CurrBlockOrder < VisitOrder[(*PI)->getBlockID()])
return false;
}
return true;
@@ -1042,7 +1038,7 @@ void ConsumedBlockInfo::addInfo(const CFGBlock *Block,
}
}
-ConsumedStateMap* ConsumedBlockInfo::borrowInfo(const CFGBlock *Block) {
+ConsumedStateMap *ConsumedBlockInfo::borrowInfo(const CFGBlock *Block) {
assert(Block && "Block pointer must not be NULL");
assert(StateMapsArray[Block->getBlockID()] && "Block has no block info");
@@ -1064,7 +1060,7 @@ ConsumedBlockInfo::getInfo(const CFGBlock *Block) {
bool ConsumedBlockInfo::isBackEdge(const CFGBlock *From, const CFGBlock *To) {
assert(From && "From block must not be NULL");
- assert(To && "From block must not be NULL");
+ assert(To && "From block must not be NULL");
return VisitOrder[From->getBlockID()] > VisitOrder[To->getBlockID()];
}
@@ -1079,15 +1075,17 @@ bool ConsumedBlockInfo::isBackEdgeTarget(const CFGBlock *Block) {
unsigned int BlockVisitOrder = VisitOrder[Block->getBlockID()];
for (CFGBlock::const_pred_iterator PI = Block->pred_begin(),
- PE = Block->pred_end(); PI != PE; ++PI) {
+ PE = Block->pred_end();
+ PI != PE; ++PI) {
if (*PI && BlockVisitOrder < VisitOrder[(*PI)->getBlockID()])
return true;
}
return false;
}
-void ConsumedStateMap::checkParamsForReturnTypestate(SourceLocation BlameLoc,
- ConsumedWarningsHandlerBase &WarningsHandler) const {
+void ConsumedStateMap::checkParamsForReturnTypestate(
+ SourceLocation BlameLoc,
+ ConsumedWarningsHandlerBase &WarningsHandler) const {
for (const auto &DM : VarMap) {
if (isa<ParmVarDecl>(DM.first)) {
@@ -1099,16 +1097,14 @@ void ConsumedStateMap::checkParamsForReturnTypestate(SourceLocation BlameLoc,
ConsumedState ExpectedState = mapReturnTypestateAttrState(RTA);
if (DM.second != ExpectedState)
- WarningsHandler.warnParamReturnTypestateMismatch(BlameLoc,
- Param->getNameAsString(), stateToString(ExpectedState),
- stateToString(DM.second));
+ WarningsHandler.warnParamReturnTypestateMismatch(
+ BlameLoc, Param->getNameAsString(), stateToString(ExpectedState),
+ stateToString(DM.second));
}
}
}
-void ConsumedStateMap::clearTemporaries() {
- TmpMap.clear();
-}
+void ConsumedStateMap::clearTemporaries() { TmpMap.clear(); }
ConsumedState ConsumedStateMap::getState(const VarDecl *Var) const {
VarMapType::const_iterator Entry = VarMap.find(Var);
@@ -1144,13 +1140,14 @@ void ConsumedStateMap::intersect(const ConsumedStateMap &Other) {
continue;
if (LocalState != DM.second)
- VarMap[DM.first] = CS_Unknown;
+ VarMap[DM.first] = CS_Unknown;
}
}
-void ConsumedStateMap::intersectAtLoopHead(const CFGBlock *LoopHead,
- const CFGBlock *LoopBack, const ConsumedStateMap *LoopBackStates,
- ConsumedWarningsHandlerBase &WarningsHandler) {
+void ConsumedStateMap::intersectAtLoopHead(
+ const CFGBlock *LoopHead, const CFGBlock *LoopBack,
+ const ConsumedStateMap *LoopBackStates,
+ ConsumedWarningsHandlerBase &WarningsHandler) {
ConsumedState LocalState;
SourceLocation BlameLoc = getLastStmtLoc(LoopBack);
@@ -1216,12 +1213,11 @@ void ConsumedAnalyzer::determineExpectedReturnState(AnalysisDeclContext &AC,
} else
ExpectedReturnState = mapReturnTypestateAttrState(RTSAttr);
} else if (isConsumableType(ReturnType)) {
- if (isAutoCastType(ReturnType)) // We can auto-cast the state to the
- ExpectedReturnState = CS_None; // expected state.
+ if (isAutoCastType(ReturnType)) // We can auto-cast the state to the
+ ExpectedReturnState = CS_None; // expected state.
else
ExpectedReturnState = mapConsumableAttrState(ReturnType);
- }
- else
+ } else
ExpectedReturnState = CS_None;
}
@@ -1251,8 +1247,8 @@ bool ConsumedAnalyzer::splitState(const CFGBlock *CurrBlock,
} else {
return false;
}
- } else if (const auto *BinOp =
- dyn_cast_or_null<BinaryOperator>(CurrBlock->getTerminator().getStmt())) {
+ } else if (const auto *BinOp = dyn_cast_or_null<BinaryOperator>(
+ CurrBlock->getTerminator().getStmt())) {
PInfo = Visitor.getInfo(BinOp->getLHS());
if (!PInfo.isVarTest()) {
if ((BinOp = dyn_cast_or_null<BinaryOperator>(BinOp->getLHS()))) {
@@ -1384,8 +1380,10 @@ void ConsumedAnalyzer::run(AnalysisDeclContext &AC) {
auto *RawState = CurrStates.get();
for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(),
- SE = CurrBlock->succ_end(); SI != SE; ++SI) {
- if (*SI == nullptr) continue;
+ SE = CurrBlock->succ_end();
+ SI != SE; ++SI) {
+ if (*SI == nullptr)
+ continue;
if (BlockInfo.isBackEdge(CurrBlock, *SI)) {
BlockInfo.borrowInfo(*SI)->intersectAtLoopHead(
diff --git a/clang/lib/Analysis/Dominators.cpp b/clang/lib/Analysis/Dominators.cpp
index f7ad68673d0f24..6823b7f5876d73 100644
--- a/clang/lib/Analysis/Dominators.cpp
+++ b/clang/lib/Analysis/Dominators.cpp
@@ -10,10 +10,8 @@
namespace clang {
-template <>
-void CFGDominatorTreeImpl</*IsPostDom=*/true>::anchor() {}
+template <> void CFGDominatorTreeImpl</*IsPostDom=*/true>::anchor() {}
-template <>
-void CFGDominatorTreeImpl</*IsPostDom=*/false>::anchor() {}
+template <> void CFGDominatorTreeImpl</*IsPostDom=*/false>::anchor() {}
} // end of namespace clang
diff --git a/clang/lib/Analysis/ExprMutationAnalyzer.cpp b/clang/lib/Analysis/ExprMutationAnalyzer.cpp
index bb042760d297a7..3cf1a456afd105 100644
--- a/clang/lib/Analysis/ExprMutationAnalyzer.cpp
+++ b/clang/lib/Analysis/ExprMutationAnalyzer.cpp
@@ -181,8 +181,12 @@ const auto isMoveOnly = [] {
};
template <class T> struct NodeID;
-template <> struct NodeID<Expr> { static constexpr StringRef value = "expr"; };
-template <> struct NodeID<Decl> { static constexpr StringRef value = "decl"; };
+template <> struct NodeID<Expr> {
+ static constexpr StringRef value = "expr";
+};
+template <> struct NodeID<Decl> {
+ static constexpr StringRef value = "decl";
+};
constexpr StringRef NodeID<Expr>::value;
constexpr StringRef NodeID<Decl>::value;
diff --git a/clang/lib/Analysis/FlowSensitive/DataflowAnalysisContext.cpp b/clang/lib/Analysis/FlowSensitive/DataflowAnalysisContext.cpp
index f4c4af022f51f6..c9a2db8c6ce7ed 100644
--- a/clang/lib/Analysis/FlowSensitive/DataflowAnalysisContext.cpp
+++ b/clang/lib/Analysis/FlowSensitive/DataflowAnalysisContext.cpp
@@ -143,8 +143,7 @@ void DataflowAnalysisContext::addFlowConditionConstraint(
Atom Token, const Formula &Constraint) {
auto Res = FlowConditionConstraints.try_emplace(Token, &Constraint);
if (!Res.second) {
- Res.first->second =
- &arena().makeAnd(*Res.first->second, Constraint);
+ Res.first->second = &arena().makeAnd(*Res.first->second, Constraint);
}
}
@@ -155,9 +154,8 @@ Atom DataflowAnalysisContext::forkFlowCondition(Atom Token) {
return ForkToken;
}
-Atom
-DataflowAnalysisContext::joinFlowConditions(Atom FirstToken,
- Atom SecondToken) {
+Atom DataflowAnalysisContext::joinFlowConditions(Atom FirstToken,
+ Atom SecondToken) {
Atom Token = arena().makeFlowConditionToken();
FlowConditionDeps[Token].insert(FirstToken);
FlowConditionDeps[Token].insert(SecondToken);
diff --git a/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp b/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp
index 0cfc26ea952cda..78fce2dc650125 100644
--- a/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp
+++ b/clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp
@@ -446,7 +446,7 @@ void Environment::initFieldsGlobalsAndFuncs(const FunctionDecl *FuncDecl) {
// Add all fields mentioned in default member initializers.
for (const FieldDecl *F : CtorDecl->getParent()->fields())
if (const auto *I = F->getInClassInitializer())
- getFieldsGlobalsAndFuncs(*I, Fields, Vars, Funcs);
+ getFieldsGlobalsAndFuncs(*I, Fields, Vars, Funcs);
}
getFieldsGlobalsAndFuncs(*FuncDecl->getBody(), Fields, Vars, Funcs);
@@ -486,8 +486,8 @@ Environment Environment::pushCall(const CallExpr *Call) const {
if (const auto *MethodCall = dyn_cast<CXXMemberCallExpr>(Call)) {
if (const Expr *Arg = MethodCall->getImplicitObjectArgument()) {
if (!isa<CXXThisExpr>(Arg))
- Env.ThisPointeeLoc =
- cast<RecordStorageLocation>(getStorageLocation(*Arg));
+ Env.ThisPointeeLoc =
+ cast<RecordStorageLocation>(getStorageLocation(*Arg));
// Otherwise (when the argument is `this`), retain the current
// environment's `ThisPointeeLoc`.
}
@@ -972,7 +972,7 @@ StorageLocation &Environment::createObjectInternal(const ValueDecl *D,
// be null.
if (InitExpr) {
if (auto *InitExprLoc = getStorageLocation(*InitExpr))
- return *InitExprLoc;
+ return *InitExprLoc;
}
// Even though we have an initializer, we might not get an
@@ -1073,9 +1073,7 @@ void Environment::dump(raw_ostream &OS) const {
DACtx->dumpFlowCondition(FlowConditionToken, OS);
}
-void Environment::dump() const {
- dump(llvm::dbgs());
-}
+void Environment::dump() const { dump(llvm::dbgs()); }
RecordStorageLocation *getImplicitObjectLocation(const CXXMemberCallExpr &MCE,
const Environment &Env) {
diff --git a/clang/lib/Analysis/FlowSensitive/HTMLLogger.cpp b/clang/lib/Analysis/FlowSensitive/HTMLLogger.cpp
index ff4e18de2c70f1..83587e1f8b1c29 100644
--- a/clang/lib/Analysis/FlowSensitive/HTMLLogger.cpp
+++ b/clang/lib/Analysis/FlowSensitive/HTMLLogger.cpp
@@ -101,12 +101,12 @@ class ModelDumper {
case Value::Kind::FormulaBool:
break;
case Value::Kind::Pointer:
- JOS.attributeObject(
- "pointee", [&] { dump(cast<PointerValue>(V).getPointeeLoc()); });
+ JOS.attributeObject("pointee",
+ [&] { dump(cast<PointerValue>(V).getPointeeLoc()); });
break;
}
- for (const auto& Prop : V.properties())
+ for (const auto &Prop : V.properties())
JOS.attributeObject(("p:" + Prop.first()).str(),
[&] { dump(*Prop.second); });
@@ -143,7 +143,7 @@ class ModelDumper {
}
}
- llvm::DenseSet<const void*> Visited;
+ llvm::DenseSet<const void *> Visited;
llvm::json::OStream &JOS;
const Environment &Env;
};
@@ -241,9 +241,7 @@ class HTMLLogger : public Logger {
BlockConverged[B.getBlockID()] = false;
ElementIndex = 0;
}
- void enterElement(const CFGElement &E) override {
- ++ElementIndex;
- }
+ void enterElement(const CFGElement &E) override { ++ElementIndex; }
static std::string blockID(unsigned Block) {
return llvm::formatv("B{0}", Block);
@@ -421,7 +419,7 @@ class HTMLLogger : public Logger {
std::vector<TokenInfo> State(Code.size());
for (const auto *Block : CFC->getCFG()) {
unsigned EltIndex = 0;
- for (const auto& Elt : *Block) {
+ for (const auto &Elt : *Block) {
++EltIndex;
if (const auto S = Elt.getAs<CFGStmt>()) {
auto EltRange = clang::Lexer::makeFileCharRange(
@@ -458,7 +456,7 @@ class HTMLLogger : public Logger {
for (unsigned I = 0; I < Code.size(); ++I) {
// Don't actually write a <span> around each character, only break spans
// when the TokenInfo changes.
- bool NeedOpen = I == 0 || !(State[I] == State[I-1]);
+ bool NeedOpen = I == 0 || !(State[I] == State[I - 1]);
bool NeedClose = I + 1 == Code.size() || !(State[I] == State[I + 1]);
if (NeedOpen) {
*OS << "<span ";
@@ -469,7 +467,8 @@ class HTMLLogger : public Logger {
*OS << "</code>\n<code class='line' data-line='" << Line++ << "'>";
else
llvm::printHTMLEscaped(Code.substr(I, 1), *OS);
- if (NeedClose) *OS << "</span>";
+ if (NeedClose)
+ *OS << "</span>";
}
*OS << "</code>\n";
*OS << "</template>";
diff --git a/clang/lib/Analysis/FlowSensitive/Transfer.cpp b/clang/lib/Analysis/FlowSensitive/Transfer.cpp
index cd1f04e53cff68..32367135c76b58 100644
--- a/clang/lib/Analysis/FlowSensitive/Transfer.cpp
+++ b/clang/lib/Analysis/FlowSensitive/Transfer.cpp
@@ -689,7 +689,7 @@ class TransferVisitor : public ConstStmtVisitor<TransferVisitor> {
size_t InitIdx = 0;
// Initialize base classes.
- if (auto* R = S->getType()->getAsCXXRecordDecl()) {
+ if (auto *R = S->getType()->getAsCXXRecordDecl()) {
assert(FieldsForInit.size() + R->getNumBases() == Inits.size());
for ([[maybe_unused]] const CXXBaseSpecifier &Base : R->bases()) {
assert(InitIdx < Inits.size());
@@ -719,7 +719,7 @@ class TransferVisitor : public ConstStmtVisitor<TransferVisitor> {
(Field->getType()->isReferenceType() &&
Field->getType().getCanonicalType()->getPointeeType() ==
Init->getType().getCanonicalType()));
- auto& Loc = Env.createObject(Field->getType(), Init);
+ auto &Loc = Env.createObject(Field->getType(), Init);
FieldLocs.insert({Field, &Loc});
}
diff --git a/clang/lib/Analysis/FlowSensitive/WatchedLiteralsSolver.cpp b/clang/lib/Analysis/FlowSensitive/WatchedLiteralsSolver.cpp
index 3ef36375353246..d11048d98b7c20 100644
--- a/clang/lib/Analysis/FlowSensitive/WatchedLiteralsSolver.cpp
+++ b/clang/lib/Analysis/FlowSensitive/WatchedLiteralsSolver.cpp
@@ -23,9 +23,8 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/STLExtras.h"
-
+#include "llvm/ADT/SmallVector.h"
namespace clang {
namespace dataflow {
@@ -191,8 +190,7 @@ struct CNFFormula {
/// proper SAT solver.
struct CNFFormulaBuilder {
// Formula should outlive CNFFormulaBuilder.
- explicit CNFFormulaBuilder(CNFFormula &CNF)
- : Formula(CNF) {}
+ explicit CNFFormulaBuilder(CNFFormula &CNF) : Formula(CNF) {}
/// Adds the `L1 v ... v Ln` clause to the formula. Applies
/// simplifications, based on single-literal clauses.
@@ -209,8 +207,7 @@ struct CNFFormulaBuilder {
llvm::SmallVector<Literal> Simplified;
for (auto L : Literals) {
assert(L != NullLit &&
- llvm::all_of(Simplified,
- [L](Literal S) { return S != L; }));
+ llvm::all_of(Simplified, [L](Literal S) { return S != L; }));
auto X = var(L);
if (trueVars.contains(X)) { // X must be true
if (isPosLit(L))
diff --git a/clang/lib/Analysis/IssueHash.cpp b/clang/lib/Analysis/IssueHash.cpp
index 4d56e774b76aa0..e77ad71554cc63 100644
--- a/clang/lib/Analysis/IssueHash.cpp
+++ b/clang/lib/Analysis/IssueHash.cpp
@@ -134,7 +134,8 @@ static StringRef GetNthLineOfFile(std::optional<llvm::MemoryBufferRef> Buffer,
return *LI;
}
-static std::string NormalizeLine(const SourceManager &SM, const FullSourceLoc &L,
+static std::string NormalizeLine(const SourceManager &SM,
+ const FullSourceLoc &L,
const LangOptions &LangOpts) {
static StringRef Whitespaces = " \t\n";
@@ -192,8 +193,8 @@ std::string clang::getIssueString(const FullSourceLoc &IssueLoc,
return (llvm::Twine(CheckerName) + Delimiter +
GetEnclosingDeclContextSignature(IssueDecl) + Delimiter +
Twine(IssueLoc.getExpansionColumnNumber()) + Delimiter +
- NormalizeLine(IssueLoc.getManager(), IssueLoc, LangOpts) +
- Delimiter + WarningMessage)
+ NormalizeLine(IssueLoc.getManager(), IssueLoc, LangOpts) + Delimiter +
+ WarningMessage)
.str();
}
diff --git a/clang/lib/Analysis/LiveVariables.cpp b/clang/lib/Analysis/LiveVariables.cpp
index 6d03dd05ca3d27..4381d6dc9e29be 100644
--- a/clang/lib/Analysis/LiveVariables.cpp
+++ b/clang/lib/Analysis/LiveVariables.cpp
@@ -31,22 +31,23 @@ class LiveVariablesImpl {
llvm::ImmutableSet<const Expr *>::Factory ESetFact;
llvm::ImmutableSet<const VarDecl *>::Factory DSetFact;
llvm::ImmutableSet<const BindingDecl *>::Factory BSetFact;
- llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues> blocksEndToLiveness;
- llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues> blocksBeginToLiveness;
+ llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues>
+ blocksEndToLiveness;
+ llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues>
+ blocksBeginToLiveness;
llvm::DenseMap<const Stmt *, LiveVariables::LivenessValues> stmtsToLiveness;
llvm::DenseMap<const DeclRefExpr *, unsigned> inAssignment;
const bool killAtAssign;
- LiveVariables::LivenessValues
- merge(LiveVariables::LivenessValues valsA,
- LiveVariables::LivenessValues valsB);
+ LiveVariables::LivenessValues merge(LiveVariables::LivenessValues valsA,
+ LiveVariables::LivenessValues valsB);
LiveVariables::LivenessValues
runOnBlock(const CFGBlock *block, LiveVariables::LivenessValues val,
LiveVariables::Observer *obs = nullptr);
- void dumpBlockLiveness(const SourceManager& M);
- void dumpExprLiveness(const SourceManager& M);
+ void dumpBlockLiveness(const SourceManager &M);
+ void dumpExprLiveness(const SourceManager &M);
LiveVariablesImpl(AnalysisDeclContext &ac, bool KillAtAssign)
: analysisContext(ac),
@@ -56,9 +57,7 @@ class LiveVariablesImpl {
};
} // namespace
-static LiveVariablesImpl &getImpl(void *x) {
- return *((LiveVariablesImpl *) x);
-}
+static LiveVariablesImpl &getImpl(void *x) { return *((LiveVariablesImpl *)x); }
//===----------------------------------------------------------------------===//
// Operations and queries on LivenessValues.
@@ -84,19 +83,18 @@ bool LiveVariables::LivenessValues::isLive(const VarDecl *D) const {
}
namespace {
- template <typename SET>
- SET mergeSets(SET A, SET B) {
- if (A.isEmpty())
- return B;
+template <typename SET> SET mergeSets(SET A, SET B) {
+ if (A.isEmpty())
+ return B;
- for (typename SET::iterator it = B.begin(), ei = B.end(); it != ei; ++it) {
- A = A.add(*it);
- }
- return A;
+ for (typename SET::iterator it = B.begin(), ei = B.end(); it != ei; ++it) {
+ A = A.add(*it);
}
+ return A;
+}
} // namespace
-void LiveVariables::Observer::anchor() { }
+void LiveVariables::Observer::anchor() {}
LiveVariables::LivenessValues
LiveVariablesImpl::merge(LiveVariables::LivenessValues valsA,
@@ -107,13 +105,15 @@ LiveVariablesImpl::merge(LiveVariables::LivenessValues valsA,
SSetRefB(valsB.liveExprs.getRootWithoutRetain(),
ESetFact.getTreeFactory());
- llvm::ImmutableSetRef<const VarDecl *>
- DSetRefA(valsA.liveDecls.getRootWithoutRetain(), DSetFact.getTreeFactory()),
- DSetRefB(valsB.liveDecls.getRootWithoutRetain(), DSetFact.getTreeFactory());
+ llvm::ImmutableSetRef<const VarDecl *> DSetRefA(
+ valsA.liveDecls.getRootWithoutRetain(), DSetFact.getTreeFactory()),
+ DSetRefB(valsB.liveDecls.getRootWithoutRetain(),
+ DSetFact.getTreeFactory());
- llvm::ImmutableSetRef<const BindingDecl *>
- BSetRefA(valsA.liveBindings.getRootWithoutRetain(), BSetFact.getTreeFactory()),
- BSetRefB(valsB.liveBindings.getRootWithoutRetain(), BSetFact.getTreeFactory());
+ llvm::ImmutableSetRef<const BindingDecl *> BSetRefA(
+ valsA.liveBindings.getRootWithoutRetain(), BSetFact.getTreeFactory()),
+ BSetRefB(valsB.liveBindings.getRootWithoutRetain(),
+ BSetFact.getTreeFactory());
SSetRefA = mergeSets(SSetRefA, SSetRefB);
DSetRefA = mergeSets(DSetRefA, DSetRefB);
@@ -134,9 +134,7 @@ bool LiveVariables::LivenessValues::equals(const LivenessValues &V) const {
// Query methods.
//===----------------------------------------------------------------------===//
-static bool isAlwaysAlive(const VarDecl *D) {
- return D->hasGlobalStorage();
-}
+static bool isAlwaysAlive(const VarDecl *D) { return D->hasGlobalStorage(); }
bool LiveVariables::isLive(const CFGBlock *B, const VarDecl *D) {
return isAlwaysAlive(D) || getImpl(impl).blocksEndToLiveness[B].isLive(D);
@@ -160,12 +158,12 @@ class TransferFunctions : public StmtVisitor<TransferFunctions> {
LiveVariables::LivenessValues &val;
LiveVariables::Observer *observer;
const CFGBlock *currentBlock;
+
public:
- TransferFunctions(LiveVariablesImpl &im,
- LiveVariables::LivenessValues &Val,
+ TransferFunctions(LiveVariablesImpl &im, LiveVariables::LivenessValues &Val,
LiveVariables::Observer *Observer,
const CFGBlock *CurrentBlock)
- : LV(im), val(Val), observer(Observer), currentBlock(CurrentBlock) {}
+ : LV(im), val(Val), observer(Observer), currentBlock(CurrentBlock) {}
void VisitBinaryOperator(BinaryOperator *BO);
void VisitBlockExpr(BlockExpr *BE);
@@ -227,93 +225,93 @@ void TransferFunctions::Visit(Stmt *S) {
// Mark all children expressions live.
switch (S->getStmtClass()) {
- default:
- break;
- case Stmt::StmtExprClass: {
- // For statement expressions, look through the compound statement.
- S = cast<StmtExpr>(S)->getSubStmt();
- break;
- }
- case Stmt::CXXMemberCallExprClass: {
- // Include the implicit "this" pointer as being live.
- CXXMemberCallExpr *CE = cast<CXXMemberCallExpr>(S);
- if (Expr *ImplicitObj = CE->getImplicitObjectArgument()) {
- AddLiveExpr(val.liveExprs, LV.ESetFact, ImplicitObj);
- }
- break;
- }
- case Stmt::ObjCMessageExprClass: {
- // In calls to super, include the implicit "self" pointer as being live.
- ObjCMessageExpr *CE = cast<ObjCMessageExpr>(S);
- if (CE->getReceiverKind() == ObjCMessageExpr::SuperInstance)
- val.liveDecls = LV.DSetFact.add(val.liveDecls,
- LV.analysisContext.getSelfDecl());
- break;
+ default:
+ break;
+ case Stmt::StmtExprClass: {
+ // For statement expressions, look through the compound statement.
+ S = cast<StmtExpr>(S)->getSubStmt();
+ break;
+ }
+ case Stmt::CXXMemberCallExprClass: {
+ // Include the implicit "this" pointer as being live.
+ CXXMemberCallExpr *CE = cast<CXXMemberCallExpr>(S);
+ if (Expr *ImplicitObj = CE->getImplicitObjectArgument()) {
+ AddLiveExpr(val.liveExprs, LV.ESetFact, ImplicitObj);
}
- case Stmt::DeclStmtClass: {
- const DeclStmt *DS = cast<DeclStmt>(S);
- if (const VarDecl *VD = dyn_cast<VarDecl>(DS->getSingleDecl())) {
- for (const VariableArrayType* VA = FindVA(VD->getType());
- VA != nullptr; VA = FindVA(VA->getElementType())) {
- AddLiveExpr(val.liveExprs, LV.ESetFact, VA->getSizeExpr());
- }
+ break;
+ }
+ case Stmt::ObjCMessageExprClass: {
+ // In calls to super, include the implicit "self" pointer as being live.
+ ObjCMessageExpr *CE = cast<ObjCMessageExpr>(S);
+ if (CE->getReceiverKind() == ObjCMessageExpr::SuperInstance)
+ val.liveDecls =
+ LV.DSetFact.add(val.liveDecls, LV.analysisContext.getSelfDecl());
+ break;
+ }
+ case Stmt::DeclStmtClass: {
+ const DeclStmt *DS = cast<DeclStmt>(S);
+ if (const VarDecl *VD = dyn_cast<VarDecl>(DS->getSingleDecl())) {
+ for (const VariableArrayType *VA = FindVA(VD->getType()); VA != nullptr;
+ VA = FindVA(VA->getElementType())) {
+ AddLiveExpr(val.liveExprs, LV.ESetFact, VA->getSizeExpr());
}
- break;
- }
- case Stmt::PseudoObjectExprClass: {
- // A pseudo-object operation only directly consumes its result
- // expression.
- Expr *child = cast<PseudoObjectExpr>(S)->getResultExpr();
- if (!child) return;
- if (OpaqueValueExpr *OV = dyn_cast<OpaqueValueExpr>(child))
- child = OV->getSourceExpr();
- child = child->IgnoreParens();
- val.liveExprs = LV.ESetFact.add(val.liveExprs, child);
- return;
- }
-
- // FIXME: These cases eventually shouldn't be needed.
- case Stmt::ExprWithCleanupsClass: {
- S = cast<ExprWithCleanups>(S)->getSubExpr();
- break;
- }
- case Stmt::CXXBindTemporaryExprClass: {
- S = cast<CXXBindTemporaryExpr>(S)->getSubExpr();
- break;
- }
- case Stmt::UnaryExprOrTypeTraitExprClass: {
- // No need to unconditionally visit subexpressions.
- return;
- }
- case Stmt::IfStmtClass: {
- // If one of the branches is an expression rather than a compound
- // statement, it will be bad if we mark it as live at the terminator
- // of the if-statement (i.e., immediately after the condition expression).
- AddLiveExpr(val.liveExprs, LV.ESetFact, cast<IfStmt>(S)->getCond());
- return;
- }
- case Stmt::WhileStmtClass: {
- // If the loop body is an expression rather than a compound statement,
- // it will be bad if we mark it as live at the terminator of the loop
- // (i.e., immediately after the condition expression).
- AddLiveExpr(val.liveExprs, LV.ESetFact, cast<WhileStmt>(S)->getCond());
- return;
}
- case Stmt::DoStmtClass: {
- // If the loop body is an expression rather than a compound statement,
- // it will be bad if we mark it as live at the terminator of the loop
- // (i.e., immediately after the condition expression).
- AddLiveExpr(val.liveExprs, LV.ESetFact, cast<DoStmt>(S)->getCond());
- return;
- }
- case Stmt::ForStmtClass: {
- // If the loop body is an expression rather than a compound statement,
- // it will be bad if we mark it as live at the terminator of the loop
- // (i.e., immediately after the condition expression).
- AddLiveExpr(val.liveExprs, LV.ESetFact, cast<ForStmt>(S)->getCond());
+ break;
+ }
+ case Stmt::PseudoObjectExprClass: {
+ // A pseudo-object operation only directly consumes its result
+ // expression.
+ Expr *child = cast<PseudoObjectExpr>(S)->getResultExpr();
+ if (!child)
return;
- }
+ if (OpaqueValueExpr *OV = dyn_cast<OpaqueValueExpr>(child))
+ child = OV->getSourceExpr();
+ child = child->IgnoreParens();
+ val.liveExprs = LV.ESetFact.add(val.liveExprs, child);
+ return;
+ }
+ // FIXME: These cases eventually shouldn't be needed.
+ case Stmt::ExprWithCleanupsClass: {
+ S = cast<ExprWithCleanups>(S)->getSubExpr();
+ break;
+ }
+ case Stmt::CXXBindTemporaryExprClass: {
+ S = cast<CXXBindTemporaryExpr>(S)->getSubExpr();
+ break;
+ }
+ case Stmt::UnaryExprOrTypeTraitExprClass: {
+ // No need to unconditionally visit subexpressions.
+ return;
+ }
+ case Stmt::IfStmtClass: {
+ // If one of the branches is an expression rather than a compound
+ // statement, it will be bad if we mark it as live at the terminator
+ // of the if-statement (i.e., immediately after the condition expression).
+ AddLiveExpr(val.liveExprs, LV.ESetFact, cast<IfStmt>(S)->getCond());
+ return;
+ }
+ case Stmt::WhileStmtClass: {
+ // If the loop body is an expression rather than a compound statement,
+ // it will be bad if we mark it as live at the terminator of the loop
+ // (i.e., immediately after the condition expression).
+ AddLiveExpr(val.liveExprs, LV.ESetFact, cast<WhileStmt>(S)->getCond());
+ return;
+ }
+ case Stmt::DoStmtClass: {
+ // If the loop body is an expression rather than a compound statement,
+ // it will be bad if we mark it as live at the terminator of the loop
+ // (i.e., immediately after the condition expression).
+ AddLiveExpr(val.liveExprs, LV.ESetFact, cast<DoStmt>(S)->getCond());
+ return;
+ }
+ case Stmt::ForStmtClass: {
+ // If the loop body is an expression rather than a compound statement,
+ // it will be bad if we mark it as live at the terminator of the loop
+ // (i.e., immediately after the condition expression).
+ AddLiveExpr(val.liveExprs, LV.ESetFact, cast<ForStmt>(S)->getCond());
+ return;
+ }
}
// HACK + FIXME: What is this? One could only guess that this is an attempt to
@@ -326,8 +324,7 @@ void TransferFunctions::Visit(Stmt *S) {
}
static bool writeShouldKill(const VarDecl *VD) {
- return VD && !VD->getType()->isReferenceType() &&
- !isAlwaysAlive(VD);
+ return VD && !VD->getType()->isReferenceType() && !isAlwaysAlive(VD);
}
void TransferFunctions::VisitBinaryOperator(BinaryOperator *B) {
@@ -344,10 +341,10 @@ void TransferFunctions::VisitBinaryOperator(BinaryOperator *B) {
Expr *LHS = B->getLHS()->IgnoreParens();
if (DeclRefExpr *DR = dyn_cast<DeclRefExpr>(LHS)) {
- const Decl* D = DR->getDecl();
+ const Decl *D = DR->getDecl();
bool Killed = false;
- if (const BindingDecl* BD = dyn_cast<BindingDecl>(D)) {
+ if (const BindingDecl *BD = dyn_cast<BindingDecl>(D)) {
Killed = !BD->getType()->isReferenceType();
if (Killed) {
if (const auto *HV = BD->getHoldingVar())
@@ -359,7 +356,6 @@ void TransferFunctions::VisitBinaryOperator(BinaryOperator *B) {
Killed = writeShouldKill(VD);
if (Killed)
val.liveDecls = LV.DSetFact.remove(val.liveDecls, VD);
-
}
if (Killed && observer)
@@ -378,7 +374,7 @@ void TransferFunctions::VisitBlockExpr(BlockExpr *BE) {
}
void TransferFunctions::VisitDeclRefExpr(DeclRefExpr *DR) {
- const Decl* D = DR->getDecl();
+ const Decl *D = DR->getDecl();
bool InAssignment = LV.inAssignment[DR];
if (const auto *BD = dyn_cast<BindingDecl>(D)) {
if (!InAssignment) {
@@ -421,8 +417,8 @@ void TransferFunctions::VisitObjCForCollectionStmt(ObjCForCollectionStmt *OS) {
Stmt *element = OS->getElement();
if (DeclStmt *DS = dyn_cast<DeclStmt>(element)) {
VD = cast<VarDecl>(DS->getSingleDecl());
- }
- else if ((DR = dyn_cast<DeclRefExpr>(cast<Expr>(element)->IgnoreParens()))) {
+ } else if ((DR =
+ dyn_cast<DeclRefExpr>(cast<Expr>(element)->IgnoreParens()))) {
VD = cast<VarDecl>(DR->getDecl());
}
@@ -433,9 +429,8 @@ void TransferFunctions::VisitObjCForCollectionStmt(ObjCForCollectionStmt *OS) {
}
}
-void TransferFunctions::
-VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *UE)
-{
+void TransferFunctions::VisitUnaryExprOrTypeTraitExpr(
+ UnaryExprOrTypeTraitExpr *UE) {
// While sizeof(var) doesn't technically extend the liveness of 'var', it
// does extent the liveness of metadata if 'var' is a VariableArrayType.
// We handle that special case here.
@@ -484,11 +479,12 @@ LiveVariablesImpl::runOnBlock(const CFGBlock *block,
// Visit the terminator (if any).
if (const Stmt *term = block->getTerminatorStmt())
- TF.Visit(const_cast<Stmt*>(term));
+ TF.Visit(const_cast<Stmt *>(term));
// Apply the transfer function for all Stmts in the block.
for (CFGBlock::const_reverse_iterator it = block->rbegin(),
- ei = block->rend(); it != ei; ++it) {
+ ei = block->rend();
+ it != ei; ++it) {
const CFGElement &elem = *it;
if (std::optional<CFGAutomaticObjDtor> Dtor =
@@ -501,7 +497,7 @@ LiveVariablesImpl::runOnBlock(const CFGBlock *block,
continue;
const Stmt *S = elem.castAs<CFGStmt>().getStmt();
- TF.Visit(const_cast<Stmt*>(S));
+ TF.Visit(const_cast<Stmt *>(S));
stmtsToLiveness[S] = val;
}
return val;
@@ -515,9 +511,7 @@ void LiveVariables::runOnAllBlocks(LiveVariables::Observer &obs) {
LiveVariables::LiveVariables(void *im) : impl(im) {}
-LiveVariables::~LiveVariables() {
- delete (LiveVariablesImpl*) impl;
-}
+LiveVariables::~LiveVariables() { delete (LiveVariablesImpl *)impl; }
std::unique_ptr<LiveVariables>
LiveVariables::computeLiveness(AnalysisDeclContext &AC, bool killAtAssign) {
@@ -552,7 +546,8 @@ LiveVariables::computeLiveness(AnalysisDeclContext &AC, bool killAtAssign) {
// Merge the values of all successor blocks.
LivenessValues val;
for (CFGBlock::const_succ_iterator it = block->succ_begin(),
- ei = block->succ_end(); it != ei; ++it) {
+ ei = block->succ_end();
+ it != ei; ++it) {
if (const CFGBlock *succ = *it) {
val = LV->merge(val, LV->blocksBeginToLiveness[succ]);
}
@@ -582,7 +577,8 @@ void LiveVariables::dumpBlockLiveness(const SourceManager &M) {
void LiveVariablesImpl::dumpBlockLiveness(const SourceManager &M) {
std::vector<const CFGBlock *> vec;
for (llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues>::iterator
- it = blocksEndToLiveness.begin(), ei = blocksEndToLiveness.end();
+ it = blocksEndToLiveness.begin(),
+ ei = blocksEndToLiveness.end();
it != ei; ++it) {
vec.push_back(it->first);
}
@@ -590,19 +586,20 @@ void LiveVariablesImpl::dumpBlockLiveness(const SourceManager &M) {
return A->getBlockID() < B->getBlockID();
});
- std::vector<const VarDecl*> declVec;
+ std::vector<const VarDecl *> declVec;
- for (std::vector<const CFGBlock *>::iterator
- it = vec.begin(), ei = vec.end(); it != ei; ++it) {
+ for (std::vector<const CFGBlock *>::iterator it = vec.begin(), ei = vec.end();
+ it != ei; ++it) {
llvm::errs() << "\n[ B" << (*it)->getBlockID()
<< " (live variables at block exit) ]\n";
LiveVariables::LivenessValues vals = blocksEndToLiveness[*it];
declVec.clear();
- for (llvm::ImmutableSet<const VarDecl *>::iterator si =
- vals.liveDecls.begin(),
- se = vals.liveDecls.end(); si != se; ++si) {
+ for (llvm::ImmutableSet<const VarDecl *>::iterator
+ si = vals.liveDecls.begin(),
+ se = vals.liveDecls.end();
+ si != se; ++si) {
declVec.push_back(*si);
}
@@ -610,10 +607,10 @@ void LiveVariablesImpl::dumpBlockLiveness(const SourceManager &M) {
return A->getBeginLoc() < B->getBeginLoc();
});
- for (std::vector<const VarDecl*>::iterator di = declVec.begin(),
- de = declVec.end(); di != de; ++di) {
- llvm::errs() << " " << (*di)->getDeclName().getAsString()
- << " <";
+ for (std::vector<const VarDecl *>::iterator di = declVec.begin(),
+ de = declVec.end();
+ di != de; ++di) {
+ llvm::errs() << " " << (*di)->getDeclName().getAsString() << " <";
(*di)->getLocation().print(llvm::errs(), M);
llvm::errs() << ">\n";
}
@@ -639,5 +636,11 @@ void LiveVariablesImpl::dumpExprLiveness(const SourceManager &M) {
}
}
-const void *LiveVariables::getTag() { static int x; return &x; }
-const void *RelaxedLiveVariables::getTag() { static int x; return &x; }
+const void *LiveVariables::getTag() {
+ static int x;
+ return &x;
+}
+const void *RelaxedLiveVariables::getTag() {
+ static int x;
+ return &x;
+}
diff --git a/clang/lib/Analysis/MacroExpansionContext.cpp b/clang/lib/Analysis/MacroExpansionContext.cpp
index 564e359668a510..a2a26a685fb192 100644
--- a/clang/lib/Analysis/MacroExpansionContext.cpp
+++ b/clang/lib/Analysis/MacroExpansionContext.cpp
@@ -229,4 +229,3 @@ void MacroExpansionContext::onTokenLexed(const Token &Tok) {
if (!Inserted)
It->getSecond().append(TokenAsString);
}
-
diff --git a/clang/lib/Analysis/ObjCNoReturn.cpp b/clang/lib/Analysis/ObjCNoReturn.cpp
index 9d7c365c3b9924..fed22877885122 100644
--- a/clang/lib/Analysis/ObjCNoReturn.cpp
+++ b/clang/lib/Analysis/ObjCNoReturn.cpp
@@ -11,9 +11,9 @@
//
//===----------------------------------------------------------------------===//
+#include "clang/Analysis/DomainSpecific/ObjCNoReturn.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/ExprObjC.h"
-#include "clang/Analysis/DomainSpecific/ObjCNoReturn.h"
using namespace clang;
@@ -26,25 +26,23 @@ static bool isSubclass(const ObjCInterfaceDecl *Class, IdentifierInfo *II) {
}
ObjCNoReturn::ObjCNoReturn(ASTContext &C)
- : RaiseSel(GetNullarySelector("raise", C)),
- NSExceptionII(&C.Idents.get("NSException"))
-{
+ : RaiseSel(GetNullarySelector("raise", C)),
+ NSExceptionII(&C.Idents.get("NSException")) {
// Generate selectors.
- SmallVector<IdentifierInfo*, 3> II;
+ SmallVector<IdentifierInfo *, 3> II;
// raise:format:
II.push_back(&C.Idents.get("raise"));
II.push_back(&C.Idents.get("format"));
NSExceptionInstanceRaiseSelectors[0] =
- C.Selectors.getSelector(II.size(), &II[0]);
+ C.Selectors.getSelector(II.size(), &II[0]);
// raise:format:arguments:
II.push_back(&C.Idents.get("arguments"));
NSExceptionInstanceRaiseSelectors[1] =
- C.Selectors.getSelector(II.size(), &II[0]);
+ C.Selectors.getSelector(II.size(), &II[0]);
}
-
bool ObjCNoReturn::isImplicitNoReturn(const ObjCMessageExpr *ME) {
Selector S = ME->getSelector();
diff --git a/clang/lib/Analysis/PathDiagnostic.cpp b/clang/lib/Analysis/PathDiagnostic.cpp
index 79f337a91ec8fa..7a64ed8c0db8e1 100644
--- a/clang/lib/Analysis/PathDiagnostic.cpp
+++ b/clang/lib/Analysis/PathDiagnostic.cpp
@@ -52,8 +52,7 @@ using namespace ento;
static StringRef StripTrailingDots(StringRef s) { return s.rtrim('.'); }
-PathDiagnosticPiece::PathDiagnosticPiece(StringRef s,
- Kind k, DisplayHint hint)
+PathDiagnosticPiece::PathDiagnosticPiece(StringRef s, Kind k, DisplayHint hint)
: str(StripTrailingDots(s)), kind(k), Hint(hint) {}
PathDiagnosticPiece::PathDiagnosticPiece(Kind k, DisplayHint hint)
@@ -288,19 +287,19 @@ static std::optional<bool> comparePiece(const PathDiagnosticPiece &X,
}
switch (X.getKind()) {
- case PathDiagnosticPiece::ControlFlow:
- return compareControlFlow(cast<PathDiagnosticControlFlowPiece>(X),
- cast<PathDiagnosticControlFlowPiece>(Y));
- case PathDiagnosticPiece::Macro:
- return compareMacro(cast<PathDiagnosticMacroPiece>(X),
- cast<PathDiagnosticMacroPiece>(Y));
- case PathDiagnosticPiece::Call:
- return compareCall(cast<PathDiagnosticCallPiece>(X),
- cast<PathDiagnosticCallPiece>(Y));
- case PathDiagnosticPiece::Event:
- case PathDiagnosticPiece::Note:
- case PathDiagnosticPiece::PopUp:
- return std::nullopt;
+ case PathDiagnosticPiece::ControlFlow:
+ return compareControlFlow(cast<PathDiagnosticControlFlowPiece>(X),
+ cast<PathDiagnosticControlFlowPiece>(Y));
+ case PathDiagnosticPiece::Macro:
+ return compareMacro(cast<PathDiagnosticMacroPiece>(X),
+ cast<PathDiagnosticMacroPiece>(Y));
+ case PathDiagnosticPiece::Call:
+ return compareCall(cast<PathDiagnosticCallPiece>(X),
+ cast<PathDiagnosticCallPiece>(Y));
+ case PathDiagnosticPiece::Event:
+ case PathDiagnosticPiece::Note:
+ case PathDiagnosticPiece::PopUp:
+ return std::nullopt;
}
llvm_unreachable("all cases handled");
}
@@ -388,7 +387,7 @@ static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) {
PathDiagnostic::meta_iterator YI = Y.meta_begin(), YE = Y.meta_end();
if (XE - XI != YE - YI)
return (XE - XI) < (YE - YI);
- for ( ; XI != XE ; ++XI, ++YI) {
+ for (; XI != XE; ++XI, ++YI) {
if (*XI != *YI)
return (*XI) < (*YI);
}
@@ -396,7 +395,7 @@ static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) {
}
void PathDiagnosticConsumer::FlushDiagnostics(
- PathDiagnosticConsumer::FilesMade *Files) {
+ PathDiagnosticConsumer::FilesMade *Files) {
if (flushed)
return;
@@ -447,12 +446,11 @@ void PathDiagnosticConsumer::FilesMade::addDiagnostic(const PathDiagnostic &PD,
}
// Allocate persistent storage for the file name.
- char *FileName_cstr = (char*) Alloc.Allocate(FileName.size(), 1);
+ char *FileName_cstr = (char *)Alloc.Allocate(FileName.size(), 1);
memcpy(FileName_cstr, FileName.data(), FileName.size());
- Entry->files.push_back(std::make_pair(ConsumerName,
- StringRef(FileName_cstr,
- FileName.size())));
+ Entry->files.push_back(
+ std::make_pair(ConsumerName, StringRef(FileName_cstr, FileName.size())));
}
PathDiagnosticConsumer::PDFileEntry::ConsumerFiles *
@@ -481,10 +479,10 @@ SourceLocation PathDiagnosticLocation::getValidSourceLocation(
// source code, so find an enclosing statement and use its location.
if (!L.isValid()) {
AnalysisDeclContext *ADC;
- if (LAC.is<const LocationContext*>())
- ADC = LAC.get<const LocationContext*>()->getAnalysisDeclContext();
+ if (LAC.is<const LocationContext *>())
+ ADC = LAC.get<const LocationContext *>()->getAnalysisDeclContext();
else
- ADC = LAC.get<AnalysisDeclContext*>();
+ ADC = LAC.get<AnalysisDeclContext *>();
ParentMap &PM = ADC->getParentMap();
@@ -510,7 +508,7 @@ SourceLocation PathDiagnosticLocation::getValidSourceLocation(
}
// FIXME: Ironically, this assert actually fails in some cases.
- //assert(L.isValid());
+ // assert(L.isValid());
return L;
}
@@ -525,17 +523,17 @@ getLocationForCaller(const StackFrameContext *SFC,
case CFGElement::Statement:
case CFGElement::Constructor:
case CFGElement::CXXRecordTypedCall:
- return PathDiagnosticLocation(Source.castAs<CFGStmt>().getStmt(),
- SM, CallerCtx);
+ return PathDiagnosticLocation(Source.castAs<CFGStmt>().getStmt(), SM,
+ CallerCtx);
case CFGElement::Initializer: {
const CFGInitializer &Init = Source.castAs<CFGInitializer>();
- return PathDiagnosticLocation(Init.getInitializer()->getInit(),
- SM, CallerCtx);
+ return PathDiagnosticLocation(Init.getInitializer()->getInit(), SM,
+ CallerCtx);
}
case CFGElement::AutomaticObjectDtor: {
const CFGAutomaticObjDtor &Dtor = Source.castAs<CFGAutomaticObjDtor>();
- return PathDiagnosticLocation::createEnd(Dtor.getTriggerStmt(),
- SM, CallerCtx);
+ return PathDiagnosticLocation::createEnd(Dtor.getTriggerStmt(), SM,
+ CallerCtx);
}
case CFGElement::DeleteDtor: {
const CFGDeleteDtor &Dtor = Source.castAs<CFGDeleteDtor>();
@@ -573,23 +571,19 @@ getLocationForCaller(const StackFrameContext *SFC,
}
PathDiagnosticLocation
-PathDiagnosticLocation::createBegin(const Decl *D,
- const SourceManager &SM) {
+PathDiagnosticLocation::createBegin(const Decl *D, const SourceManager &SM) {
return PathDiagnosticLocation(D->getBeginLoc(), SM, SingleLocK);
}
PathDiagnosticLocation
-PathDiagnosticLocation::createBegin(const Stmt *S,
- const SourceManager &SM,
+PathDiagnosticLocation::createBegin(const Stmt *S, const SourceManager &SM,
LocationOrAnalysisDeclContext LAC) {
assert(S && "Statement cannot be null");
- return PathDiagnosticLocation(getValidSourceLocation(S, LAC),
- SM, SingleLocK);
+ return PathDiagnosticLocation(getValidSourceLocation(S, LAC), SM, SingleLocK);
}
PathDiagnosticLocation
-PathDiagnosticLocation::createEnd(const Stmt *S,
- const SourceManager &SM,
+PathDiagnosticLocation::createEnd(const Stmt *S, const SourceManager &SM,
LocationOrAnalysisDeclContext LAC) {
if (const auto *CS = dyn_cast<CompoundStmt>(S))
return createEndBrace(CS, SM);
@@ -604,9 +598,8 @@ PathDiagnosticLocation::createOperatorLoc(const BinaryOperator *BO,
}
PathDiagnosticLocation
-PathDiagnosticLocation::createConditionalColonLoc(
- const ConditionalOperator *CO,
- const SourceManager &SM) {
+PathDiagnosticLocation::createConditionalColonLoc(const ConditionalOperator *CO,
+ const SourceManager &SM) {
return PathDiagnosticLocation(CO->getColonLoc(), SM, SingleLocK);
}
@@ -659,9 +652,9 @@ PathDiagnosticLocation::createDeclEnd(const LocationContext *LC,
}
PathDiagnosticLocation
-PathDiagnosticLocation::create(const ProgramPoint& P,
+PathDiagnosticLocation::create(const ProgramPoint &P,
const SourceManager &SMng) {
- const Stmt* S = nullptr;
+ const Stmt *S = nullptr;
if (std::optional<BlockEdge> BE = P.getAs<BlockEdge>()) {
const CFGBlock *BSrc = BE->getSrc();
if (BSrc->getTerminator().isVirtualBaseBranch()) {
@@ -676,7 +669,8 @@ PathDiagnosticLocation::create(const ProgramPoint& P,
// If the BlockEdge has no terminator condition statement but its
// source is the entry of the CFG (e.g. a checker crated the branch at
// the beginning of a function), use the function's declaration instead.
- assert(BSrc == &BSrc->getParent()->getEntry() && "CFGBlock has no "
+ assert(BSrc == &BSrc->getParent()->getEntry() &&
+ "CFGBlock has no "
"TerminatorCondition and is not the enrty block of the CFG");
return PathDiagnosticLocation::createBegin(
P.getLocationContext()->getDecl(), SMng);
@@ -696,12 +690,10 @@ PathDiagnosticLocation::create(const ProgramPoint& P,
return PathDiagnosticLocation(PIE->getLocation(), SMng);
} else if (std::optional<CallEnter> CE = P.getAs<CallEnter>()) {
return getLocationForCaller(CE->getCalleeContext(),
- CE->getLocationContext(),
- SMng);
+ CE->getLocationContext(), SMng);
} else if (std::optional<CallExitEnd> CEE = P.getAs<CallExitEnd>()) {
return getLocationForCaller(CEE->getCalleeContext(),
- CEE->getLocationContext(),
- SMng);
+ CEE->getLocationContext(), SMng);
} else if (auto CEB = P.getAs<CallExitBegin>()) {
if (const ReturnStmt *RS = CEB->getReturnStmt())
return PathDiagnosticLocation::createBegin(RS, SMng,
@@ -733,93 +725,92 @@ PathDiagnosticLocation::create(const ProgramPoint& P,
}
PathDiagnosticLocation PathDiagnosticLocation::createSingleLocation(
- const PathDiagnosticLocation &PDL) {
+ const PathDiagnosticLocation &PDL) {
FullSourceLoc L = PDL.asLocation();
return PathDiagnosticLocation(L, L.getManager(), SingleLocK);
}
FullSourceLoc
- PathDiagnosticLocation::genLocation(SourceLocation L,
- LocationOrAnalysisDeclContext LAC) const {
+PathDiagnosticLocation::genLocation(SourceLocation L,
+ LocationOrAnalysisDeclContext LAC) const {
assert(isValid());
// Note that we want a 'switch' here so that the compiler can warn us in
// case we add more cases.
switch (K) {
- case SingleLocK:
- case RangeK:
+ case SingleLocK:
+ case RangeK:
+ break;
+ case StmtK:
+ // Defensive checking.
+ if (!S)
break;
- case StmtK:
- // Defensive checking.
- if (!S)
- break;
- return FullSourceLoc(getValidSourceLocation(S, LAC),
- const_cast<SourceManager&>(*SM));
- case DeclK:
- // Defensive checking.
- if (!D)
- break;
- return FullSourceLoc(D->getLocation(), const_cast<SourceManager&>(*SM));
+ return FullSourceLoc(getValidSourceLocation(S, LAC),
+ const_cast<SourceManager &>(*SM));
+ case DeclK:
+ // Defensive checking.
+ if (!D)
+ break;
+ return FullSourceLoc(D->getLocation(), const_cast<SourceManager &>(*SM));
}
- return FullSourceLoc(L, const_cast<SourceManager&>(*SM));
+ return FullSourceLoc(L, const_cast<SourceManager &>(*SM));
}
PathDiagnosticRange
- PathDiagnosticLocation::genRange(LocationOrAnalysisDeclContext LAC) const {
+PathDiagnosticLocation::genRange(LocationOrAnalysisDeclContext LAC) const {
assert(isValid());
// Note that we want a 'switch' here so that the compiler can warn us in
// case we add more cases.
switch (K) {
- case SingleLocK:
- return PathDiagnosticRange(SourceRange(Loc,Loc), true);
- case RangeK:
+ case SingleLocK:
+ return PathDiagnosticRange(SourceRange(Loc, Loc), true);
+ case RangeK:
+ break;
+ case StmtK: {
+ const Stmt *S = asStmt();
+ switch (S->getStmtClass()) {
+ default:
break;
- case StmtK: {
- const Stmt *S = asStmt();
- switch (S->getStmtClass()) {
- default:
- break;
- case Stmt::DeclStmtClass: {
- const auto *DS = cast<DeclStmt>(S);
- if (DS->isSingleDecl()) {
- // Should always be the case, but we'll be defensive.
- return SourceRange(DS->getBeginLoc(),
- DS->getSingleDecl()->getLocation());
- }
- break;
- }
- // FIXME: Provide better range information for different
- // terminators.
- case Stmt::IfStmtClass:
- case Stmt::WhileStmtClass:
- case Stmt::DoStmtClass:
- case Stmt::ForStmtClass:
- case Stmt::ChooseExprClass:
- case Stmt::IndirectGotoStmtClass:
- case Stmt::SwitchStmtClass:
- case Stmt::BinaryConditionalOperatorClass:
- case Stmt::ConditionalOperatorClass:
- case Stmt::ObjCForCollectionStmtClass: {
- SourceLocation L = getValidSourceLocation(S, LAC);
- return SourceRange(L, L);
- }
+ case Stmt::DeclStmtClass: {
+ const auto *DS = cast<DeclStmt>(S);
+ if (DS->isSingleDecl()) {
+ // Should always be the case, but we'll be defensive.
+ return SourceRange(DS->getBeginLoc(),
+ DS->getSingleDecl()->getLocation());
}
- SourceRange R = S->getSourceRange();
- if (R.isValid())
- return R;
break;
}
- case DeclK:
- if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
- return MD->getSourceRange();
- if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
- if (Stmt *Body = FD->getBody())
- return Body->getSourceRange();
- }
- else {
- SourceLocation L = D->getLocation();
- return PathDiagnosticRange(SourceRange(L, L), true);
- }
+ // FIXME: Provide better range information for different
+ // terminators.
+ case Stmt::IfStmtClass:
+ case Stmt::WhileStmtClass:
+ case Stmt::DoStmtClass:
+ case Stmt::ForStmtClass:
+ case Stmt::ChooseExprClass:
+ case Stmt::IndirectGotoStmtClass:
+ case Stmt::SwitchStmtClass:
+ case Stmt::BinaryConditionalOperatorClass:
+ case Stmt::ConditionalOperatorClass:
+ case Stmt::ObjCForCollectionStmtClass: {
+ SourceLocation L = getValidSourceLocation(S, LAC);
+ return SourceRange(L, L);
+ }
+ }
+ SourceRange R = S->getSourceRange();
+ if (R.isValid())
+ return R;
+ break;
+ }
+ case DeclK:
+ if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
+ return MD->getSourceRange();
+ if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
+ if (Stmt *Body = FD->getBody())
+ return Body->getSourceRange();
+ } else {
+ SourceLocation L = D->getLocation();
+ return PathDiagnosticRange(SourceRange(L, L), true);
+ }
}
return SourceRange(Loc, Loc);
@@ -830,8 +821,7 @@ void PathDiagnosticLocation::flatten() {
K = RangeK;
S = nullptr;
D = nullptr;
- }
- else if (K == DeclK) {
+ } else if (K == DeclK) {
K = SingleLocK;
S = nullptr;
D = nullptr;
@@ -846,16 +836,14 @@ std::shared_ptr<PathDiagnosticCallPiece>
PathDiagnosticCallPiece::construct(const CallExitEnd &CE,
const SourceManager &SM) {
const Decl *caller = CE.getLocationContext()->getDecl();
- PathDiagnosticLocation pos = getLocationForCaller(CE.getCalleeContext(),
- CE.getLocationContext(),
- SM);
+ PathDiagnosticLocation pos =
+ getLocationForCaller(CE.getCalleeContext(), CE.getLocationContext(), SM);
return std::shared_ptr<PathDiagnosticCallPiece>(
new PathDiagnosticCallPiece(caller, pos));
}
PathDiagnosticCallPiece *
-PathDiagnosticCallPiece::construct(PathPieces &path,
- const Decl *caller) {
+PathDiagnosticCallPiece::construct(PathPieces &path, const Decl *caller) {
std::shared_ptr<PathDiagnosticCallPiece> C(
new PathDiagnosticCallPiece(path, caller));
path.clear();
@@ -879,9 +867,9 @@ void PathDiagnosticCallPiece::setCallee(const CallEnter &CE,
// Unless set here, the IsCalleeAnAutosynthesizedPropertyAccessor flag
// defaults to false.
if (const auto *MD = dyn_cast<ObjCMethodDecl>(Callee))
- IsCalleeAnAutosynthesizedPropertyAccessor = (
- MD->isPropertyAccessor() &&
- CalleeCtx->getAnalysisDeclContext()->isBodyAutosynthesized());
+ IsCalleeAnAutosynthesizedPropertyAccessor =
+ (MD->isPropertyAccessor() &&
+ CalleeCtx->getAnalysisDeclContext()->isBodyAutosynthesized());
}
static void describeTemplateParameters(raw_ostream &Out,
@@ -903,8 +891,8 @@ static void describeTemplateParameter(raw_ostream &Out,
static void describeTemplateParameters(raw_ostream &Out,
const ArrayRef<TemplateArgument> TAList,
- const LangOptions &LO,
- StringRef Prefix, StringRef Postfix) {
+ const LangOptions &LO, StringRef Prefix,
+ StringRef Postfix) {
if (TAList.empty())
return;
@@ -969,11 +957,11 @@ static bool describeCodeDecl(raw_ostream &Out, const Decl *D,
Out << "'" << *MD << "'";
}
} else if (MD->isCopyAssignmentOperator()) {
- Out << "copy assignment operator";
- describeClass(Out, MD->getParent(), " for ");
+ Out << "copy assignment operator";
+ describeClass(Out, MD->getParent(), " for ");
} else if (MD->isMoveAssignmentOperator()) {
- Out << "move assignment operator";
- describeClass(Out, MD->getParent(), " for ");
+ Out << "move assignment operator";
+ describeClass(Out, MD->getParent(), " for ");
} else {
if (MD->getParent()->getIdentifier())
Out << "'" << *MD->getParent() << "::" << *MD << "'";
@@ -989,7 +977,7 @@ static bool describeCodeDecl(raw_ostream &Out, const Decl *D,
// Adding template parameters.
if (const auto FD = dyn_cast<FunctionDecl>(D))
if (const TemplateArgumentList *TAList =
- FD->getTemplateSpecializationArgs())
+ FD->getTemplateSpecializationArgs())
describeTemplateParameters(Out, TAList->asArray(), FD->getLangOpts(), "<",
">");
@@ -1050,9 +1038,9 @@ PathDiagnosticCallPiece::getCallExitEvent() const {
if (!CallStackMessage.empty()) {
Out << CallStackMessage;
} else {
- bool DidDescribe = describeCodeDecl(Out, Callee,
- /*ExtendedDescription=*/false,
- "Returning from ");
+ bool DidDescribe =
+ describeCodeDecl(Out, Callee,
+ /*ExtendedDescription=*/false, "Returning from ");
if (!DidDescribe)
Out << "Returning to caller";
}
@@ -1088,10 +1076,10 @@ void PathDiagnosticLocation::Profile(llvm::FoldingSetNodeID &ID) const {
}
void PathDiagnosticPiece::Profile(llvm::FoldingSetNodeID &ID) const {
- ID.AddInteger((unsigned) getKind());
+ ID.AddInteger((unsigned)getKind());
ID.AddString(str);
// FIXME: Add profiling support for code hints.
- ID.AddInteger((unsigned) getDisplayHint());
+ ID.AddInteger((unsigned)getDisplayHint());
ArrayRef<SourceRange> Ranges = getRanges();
for (const auto &I : Ranges) {
ID.Add(I.getBegin());
diff --git a/clang/lib/Analysis/PostOrderCFGView.cpp b/clang/lib/Analysis/PostOrderCFGView.cpp
index 0c09c0f97ff68e..6ba64ed99bfce4 100644
--- a/clang/lib/Analysis/PostOrderCFGView.cpp
+++ b/clang/lib/Analysis/PostOrderCFGView.cpp
@@ -23,7 +23,8 @@ PostOrderCFGView::PostOrderCFGView(const CFG *cfg) {
CFGBlockSet BSet(cfg);
for (po_iterator I = po_iterator::begin(cfg, BSet),
- E = po_iterator::end(cfg, BSet); I != E; ++I) {
+ E = po_iterator::end(cfg, BSet);
+ I != E; ++I) {
BlockOrder[*I] = Blocks.size() + 1;
Blocks.push_back(*I);
}
@@ -37,7 +38,10 @@ PostOrderCFGView::create(AnalysisDeclContext &ctx) {
return std::make_unique<PostOrderCFGView>(cfg);
}
-const void *PostOrderCFGView::getTag() { static int x; return &x; }
+const void *PostOrderCFGView::getTag() {
+ static int x;
+ return &x;
+}
bool PostOrderCFGView::BlockOrderCompare::operator()(const CFGBlock *b1,
const CFGBlock *b2) const {
diff --git a/clang/lib/Analysis/ProgramPoint.cpp b/clang/lib/Analysis/ProgramPoint.cpp
index 2a91749affd2a6..1404f1d401e52a 100644
--- a/clang/lib/Analysis/ProgramPoint.cpp
+++ b/clang/lib/Analysis/ProgramPoint.cpp
@@ -21,26 +21,26 @@ ProgramPointTag::~ProgramPointTag() {}
ProgramPoint ProgramPoint::getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
const LocationContext *LC,
- const ProgramPointTag *tag){
+ const ProgramPointTag *tag) {
switch (K) {
- default:
- llvm_unreachable("Unhandled ProgramPoint kind");
- case ProgramPoint::PreStmtKind:
- return PreStmt(S, LC, tag);
- case ProgramPoint::PostStmtKind:
- return PostStmt(S, LC, tag);
- case ProgramPoint::PreLoadKind:
- return PreLoad(S, LC, tag);
- case ProgramPoint::PostLoadKind:
- return PostLoad(S, LC, tag);
- case ProgramPoint::PreStoreKind:
- return PreStore(S, LC, tag);
- case ProgramPoint::PostLValueKind:
- return PostLValue(S, LC, tag);
- case ProgramPoint::PostStmtPurgeDeadSymbolsKind:
- return PostStmtPurgeDeadSymbols(S, LC, tag);
- case ProgramPoint::PreStmtPurgeDeadSymbolsKind:
- return PreStmtPurgeDeadSymbols(S, LC, tag);
+ default:
+ llvm_unreachable("Unhandled ProgramPoint kind");
+ case ProgramPoint::PreStmtKind:
+ return PreStmt(S, LC, tag);
+ case ProgramPoint::PostStmtKind:
+ return PostStmt(S, LC, tag);
+ case ProgramPoint::PreLoadKind:
+ return PreLoad(S, LC, tag);
+ case ProgramPoint::PostLoadKind:
+ return PostLoad(S, LC, tag);
+ case ProgramPoint::PreStoreKind:
+ return PreStore(S, LC, tag);
+ case ProgramPoint::PostLValueKind:
+ return PostLValue(S, LC, tag);
+ case ProgramPoint::PostStmtPurgeDeadSymbolsKind:
+ return PostStmtPurgeDeadSymbols(S, LC, tag);
+ case ProgramPoint::PreStmtPurgeDeadSymbolsKind:
+ return PreStmtPurgeDeadSymbols(S, LC, tag);
}
}
@@ -58,8 +58,7 @@ void ProgramPoint::printJson(llvm::raw_ostream &Out, const char *NL) const {
Out << "\"kind\": \"";
switch (getKind()) {
case ProgramPoint::BlockEntranceKind:
- Out << "BlockEntrance\""
- << ", \"block_id\": "
+ Out << "BlockEntrance\"" << ", \"block_id\": "
<< castAs<BlockEntrance>().getBlock()->getBlockID();
break;
@@ -157,7 +156,7 @@ void ProgramPoint::printJson(llvm::raw_ostream &Out, const char *NL) const {
LHS->printJson(Out, nullptr, PP, AddQuotes);
} else {
Out << "null";
- }
+ }
Out << ", \"rhs\": ";
if (const Stmt *RHS = C->getRHS()) {
@@ -188,8 +187,8 @@ void ProgramPoint::printJson(llvm::raw_ostream &Out, const char *NL) const {
assert(S != nullptr && "Expecting non-null Stmt");
Out << "Statement\", \"stmt_kind\": \"" << S->getStmtClassName()
- << "\", \"stmt_id\": " << S->getID(Context)
- << ", \"pointer\": \"" << (const void *)S << "\", ";
+ << "\", \"stmt_id\": " << S->getID(Context) << ", \"pointer\": \""
+ << (const void *)S << "\", ";
if (const auto *CS = dyn_cast<CastExpr>(S))
Out << "\"cast_kind\": \"" << CS->getCastKindName() << "\", ";
@@ -236,8 +235,6 @@ void ProgramPoint::printJson(llvm::raw_ostream &Out, const char *NL) const {
SimpleProgramPointTag::SimpleProgramPointTag(StringRef MsgProvider,
StringRef Msg)
- : Desc((MsgProvider + " : " + Msg).str()) {}
+ : Desc((MsgProvider + " : " + Msg).str()) {}
-StringRef SimpleProgramPointTag::getTagDescription() const {
- return Desc;
-}
+StringRef SimpleProgramPointTag::getTagDescription() const { return Desc; }
diff --git a/clang/lib/Analysis/ReachableCode.cpp b/clang/lib/Analysis/ReachableCode.cpp
index acbe1470b38991..3c7f1122589465 100644
--- a/clang/lib/Analysis/ReachableCode.cpp
+++ b/clang/lib/Analysis/ReachableCode.cpp
@@ -45,8 +45,7 @@ static bool isTrivialExpression(const Expr *Ex) {
Ex = Ex->IgnoreParenCasts();
return isa<IntegerLiteral>(Ex) || isa<StringLiteral>(Ex) ||
isa<CXXBoolLiteralExpr>(Ex) || isa<ObjCBoolLiteralExpr>(Ex) ||
- isa<CharacterLiteral>(Ex) ||
- isEnumConstant(Ex);
+ isa<CharacterLiteral>(Ex) || isEnumConstant(Ex);
}
static bool isTrivialDoWhile(const CFGBlock *B, const Stmt *S) {
@@ -71,7 +70,7 @@ static bool isBuiltinUnreachable(const Stmt *S) {
static bool isBuiltinAssumeFalse(const CFGBlock *B, const Stmt *S,
ASTContext &C) {
- if (B->empty()) {
+ if (B->empty()) {
// Happens if S is B's terminator and B contains nothing else
// (e.g. a CFGBlock containing only a goto).
return false;
@@ -147,8 +146,7 @@ static SourceLocation getTopMostMacro(SourceLocation Loc, SourceManager &SM) {
}
/// Returns true if the statement is expanded from a configuration macro.
-static bool isExpandedFromConfigurationMacro(const Stmt *S,
- Preprocessor &PP,
+static bool isExpandedFromConfigurationMacro(const Stmt *S, Preprocessor &PP,
bool IgnoreYES_NO = false) {
// FIXME: This is not very precise. Here we just check to see if the
// value comes from a macro, but we can do much better. This is likely
@@ -186,8 +184,7 @@ static bool isConfigurationValue(const ValueDecl *D, Preprocessor &PP);
/// "sometimes unreachable" code. Such code is usually not interesting
/// to report as unreachable, and may mask truly unreachable code within
/// those blocks.
-static bool isConfigurationValue(const Stmt *S,
- Preprocessor &PP,
+static bool isConfigurationValue(const Stmt *S, Preprocessor &PP,
SourceRange *SilenceableCondVal = nullptr,
bool IncludeIntegers = true,
bool WrappedInParens = false) {
@@ -212,62 +209,61 @@ static bool isConfigurationValue(const Stmt *S,
bool IgnoreYES_NO = false;
switch (S->getStmtClass()) {
- case Stmt::CallExprClass: {
- const FunctionDecl *Callee =
+ case Stmt::CallExprClass: {
+ const FunctionDecl *Callee =
dyn_cast_or_null<FunctionDecl>(cast<CallExpr>(S)->getCalleeDecl());
- return Callee ? Callee->isConstexpr() : false;
- }
- case Stmt::DeclRefExprClass:
- return isConfigurationValue(cast<DeclRefExpr>(S)->getDecl(), PP);
- case Stmt::ObjCBoolLiteralExprClass:
- IgnoreYES_NO = true;
- [[fallthrough]];
- case Stmt::CXXBoolLiteralExprClass:
- case Stmt::IntegerLiteralClass: {
- const Expr *E = cast<Expr>(S);
- if (IncludeIntegers) {
- if (SilenceableCondVal && !SilenceableCondVal->getBegin().isValid())
- *SilenceableCondVal = E->getSourceRange();
- return WrappedInParens ||
- isExpandedFromConfigurationMacro(E, PP, IgnoreYES_NO);
- }
- return false;
- }
- case Stmt::MemberExprClass:
- return isConfigurationValue(cast<MemberExpr>(S)->getMemberDecl(), PP);
- case Stmt::UnaryExprOrTypeTraitExprClass:
- return true;
- case Stmt::BinaryOperatorClass: {
- const BinaryOperator *B = cast<BinaryOperator>(S);
- // Only include raw integers (not enums) as configuration
- // values if they are used in a logical or comparison operator
- // (not arithmetic).
- IncludeIntegers &= (B->isLogicalOp() || B->isComparisonOp());
- return isConfigurationValue(B->getLHS(), PP, SilenceableCondVal,
- IncludeIntegers) ||
- isConfigurationValue(B->getRHS(), PP, SilenceableCondVal,
- IncludeIntegers);
- }
- case Stmt::UnaryOperatorClass: {
- const UnaryOperator *UO = cast<UnaryOperator>(S);
- if (UO->getOpcode() != UO_LNot && UO->getOpcode() != UO_Minus)
- return false;
- bool SilenceableCondValNotSet =
- SilenceableCondVal && SilenceableCondVal->getBegin().isInvalid();
- bool IsSubExprConfigValue =
- isConfigurationValue(UO->getSubExpr(), PP, SilenceableCondVal,
- IncludeIntegers, WrappedInParens);
- // Update the silenceable condition value source range only if the range
- // was set directly by the child expression.
- if (SilenceableCondValNotSet &&
- SilenceableCondVal->getBegin().isValid() &&
- *SilenceableCondVal ==
- UO->getSubExpr()->IgnoreCasts()->getSourceRange())
- *SilenceableCondVal = UO->getSourceRange();
- return IsSubExprConfigValue;
+ return Callee ? Callee->isConstexpr() : false;
+ }
+ case Stmt::DeclRefExprClass:
+ return isConfigurationValue(cast<DeclRefExpr>(S)->getDecl(), PP);
+ case Stmt::ObjCBoolLiteralExprClass:
+ IgnoreYES_NO = true;
+ [[fallthrough]];
+ case Stmt::CXXBoolLiteralExprClass:
+ case Stmt::IntegerLiteralClass: {
+ const Expr *E = cast<Expr>(S);
+ if (IncludeIntegers) {
+ if (SilenceableCondVal && !SilenceableCondVal->getBegin().isValid())
+ *SilenceableCondVal = E->getSourceRange();
+ return WrappedInParens ||
+ isExpandedFromConfigurationMacro(E, PP, IgnoreYES_NO);
}
- default:
+ return false;
+ }
+ case Stmt::MemberExprClass:
+ return isConfigurationValue(cast<MemberExpr>(S)->getMemberDecl(), PP);
+ case Stmt::UnaryExprOrTypeTraitExprClass:
+ return true;
+ case Stmt::BinaryOperatorClass: {
+ const BinaryOperator *B = cast<BinaryOperator>(S);
+ // Only include raw integers (not enums) as configuration
+ // values if they are used in a logical or comparison operator
+ // (not arithmetic).
+ IncludeIntegers &= (B->isLogicalOp() || B->isComparisonOp());
+ return isConfigurationValue(B->getLHS(), PP, SilenceableCondVal,
+ IncludeIntegers) ||
+ isConfigurationValue(B->getRHS(), PP, SilenceableCondVal,
+ IncludeIntegers);
+ }
+ case Stmt::UnaryOperatorClass: {
+ const UnaryOperator *UO = cast<UnaryOperator>(S);
+ if (UO->getOpcode() != UO_LNot && UO->getOpcode() != UO_Minus)
return false;
+ bool SilenceableCondValNotSet =
+ SilenceableCondVal && SilenceableCondVal->getBegin().isInvalid();
+ bool IsSubExprConfigValue =
+ isConfigurationValue(UO->getSubExpr(), PP, SilenceableCondVal,
+ IncludeIntegers, WrappedInParens);
+ // Update the silenceable condition value source range only if the range
+ // was set directly by the child expression.
+ if (SilenceableCondValNotSet && SilenceableCondVal->getBegin().isValid() &&
+ *SilenceableCondVal ==
+ UO->getSubExpr()->IgnoreCasts()->getSourceRange())
+ *SilenceableCondVal = UO->getSourceRange();
+ return IsSubExprConfigValue;
+ }
+ default:
+ return false;
}
}
@@ -314,14 +310,13 @@ static bool shouldTreatSuccessorsAsReachable(const CFGBlock *B,
return isConfigurationValue(Cond, PP);
}
-static unsigned scanFromBlock(const CFGBlock *Start,
- llvm::BitVector &Reachable,
+static unsigned scanFromBlock(const CFGBlock *Start, llvm::BitVector &Reachable,
Preprocessor *PP,
bool IncludeSometimesUnreachableEdges) {
unsigned count = 0;
// Prep work queue
- SmallVector<const CFGBlock*, 32> WL;
+ SmallVector<const CFGBlock *, 32> WL;
// The entry block may have already been marked reachable
// by the caller.
@@ -347,25 +342,26 @@ static unsigned scanFromBlock(const CFGBlock *Start,
TreatAllSuccessorsAsReachable = false;
for (CFGBlock::const_succ_iterator I = item->succ_begin(),
- E = item->succ_end(); I != E; ++I) {
+ E = item->succ_end();
+ I != E; ++I) {
const CFGBlock *B = *I;
- if (!B) do {
- const CFGBlock *UB = I->getPossiblyUnreachableBlock();
- if (!UB)
- break;
-
- if (!TreatAllSuccessorsAsReachable) {
- assert(PP);
- TreatAllSuccessorsAsReachable =
- shouldTreatSuccessorsAsReachable(item, *PP);
- }
+ if (!B)
+ do {
+ const CFGBlock *UB = I->getPossiblyUnreachableBlock();
+ if (!UB)
+ break;
+
+ if (!TreatAllSuccessorsAsReachable) {
+ assert(PP);
+ TreatAllSuccessorsAsReachable =
+ shouldTreatSuccessorsAsReachable(item, *PP);
+ }
- if (*TreatAllSuccessorsAsReachable) {
- B = UB;
- break;
- }
- }
- while (false);
+ if (*TreatAllSuccessorsAsReachable) {
+ B = UB;
+ break;
+ }
+ } while (false);
if (B) {
unsigned blockID = B->getBlockID();
@@ -391,37 +387,34 @@ static unsigned scanMaybeReachableFromBlock(const CFGBlock *Start,
//===----------------------------------------------------------------------===//
namespace {
- class DeadCodeScan {
- llvm::BitVector Visited;
- llvm::BitVector &Reachable;
- SmallVector<const CFGBlock *, 10> WorkList;
- Preprocessor &PP;
- ASTContext &C;
+class DeadCodeScan {
+ llvm::BitVector Visited;
+ llvm::BitVector &Reachable;
+ SmallVector<const CFGBlock *, 10> WorkList;
+ Preprocessor &PP;
+ ASTContext &C;
- typedef SmallVector<std::pair<const CFGBlock *, const Stmt *>, 12>
- DeferredLocsTy;
+ typedef SmallVector<std::pair<const CFGBlock *, const Stmt *>, 12>
+ DeferredLocsTy;
- DeferredLocsTy DeferredLocs;
+ DeferredLocsTy DeferredLocs;
- public:
- DeadCodeScan(llvm::BitVector &reachable, Preprocessor &PP, ASTContext &C)
- : Visited(reachable.size()),
- Reachable(reachable),
- PP(PP), C(C) {}
+public:
+ DeadCodeScan(llvm::BitVector &reachable, Preprocessor &PP, ASTContext &C)
+ : Visited(reachable.size()), Reachable(reachable), PP(PP), C(C) {}
- void enqueue(const CFGBlock *block);
- unsigned scanBackwards(const CFGBlock *Start,
- clang::reachable_code::Callback &CB);
+ void enqueue(const CFGBlock *block);
+ unsigned scanBackwards(const CFGBlock *Start,
+ clang::reachable_code::Callback &CB);
- bool isDeadCodeRoot(const CFGBlock *Block);
+ bool isDeadCodeRoot(const CFGBlock *Block);
- const Stmt *findDeadCode(const CFGBlock *Block);
+ const Stmt *findDeadCode(const CFGBlock *Block);
- void reportDeadCode(const CFGBlock *B,
- const Stmt *S,
- clang::reachable_code::Callback &CB);
- };
-}
+ void reportDeadCode(const CFGBlock *B, const Stmt *S,
+ clang::reachable_code::Callback &CB);
+};
+} // namespace
void DeadCodeScan::enqueue(const CFGBlock *block) {
unsigned blockID = block->getBlockID();
@@ -435,7 +428,8 @@ bool DeadCodeScan::isDeadCodeRoot(const clang::CFGBlock *Block) {
bool isDeadRoot = true;
for (CFGBlock::const_pred_iterator I = Block->pred_begin(),
- E = Block->pred_end(); I != E; ++I) {
+ E = Block->pred_end();
+ I != E; ++I) {
if (const CFGBlock *PredBlock = *I) {
unsigned blockID = PredBlock->getBlockID();
if (Visited[blockID]) {
@@ -505,7 +499,8 @@ static bool isValidDeadStmt(const Stmt *S, const clang::CFGBlock *Block) {
}
const Stmt *DeadCodeScan::findDeadCode(const clang::CFGBlock *Block) {
- for (CFGBlock::const_iterator I = Block->begin(), E = Block->end(); I!=E; ++I)
+ for (CFGBlock::const_iterator I = Block->begin(), E = Block->end(); I != E;
+ ++I)
if (std::optional<CFGStmt> CS = I->getAs<CFGStmt>()) {
const Stmt *S = CS->getStmt();
if (isValidDeadStmt(S, Block))
@@ -551,7 +546,8 @@ unsigned DeadCodeScan::scanBackwards(const clang::CFGBlock *Start,
if (!S) {
// No dead code. Possibly an empty block. Look at dead predecessors.
for (CFGBlock::const_pred_iterator I = Block->pred_begin(),
- E = Block->pred_end(); I != E; ++I) {
+ E = Block->pred_end();
+ I != E; ++I) {
if (const CFGBlock *predBlock = *I)
enqueue(predBlock);
}
@@ -567,8 +563,7 @@ unsigned DeadCodeScan::scanBackwards(const clang::CFGBlock *Start,
if (isDeadCodeRoot(Block)) {
reportDeadCode(Block, S, CB);
count += scanMaybeReachableFromBlock(Block, PP, Reachable);
- }
- else {
+ } else {
// Record this statement as the possibly best location in a
// strongly-connected component of dead code for emitting a
// warning.
@@ -592,8 +587,7 @@ unsigned DeadCodeScan::scanBackwards(const clang::CFGBlock *Start,
return count;
}
-static SourceLocation GetUnreachableLoc(const Stmt *S,
- SourceRange &R1,
+static SourceLocation GetUnreachableLoc(const Stmt *S, SourceRange &R1,
SourceRange &R2) {
R1 = R2 = SourceRange();
@@ -601,64 +595,63 @@ static SourceLocation GetUnreachableLoc(const Stmt *S,
S = Ex->IgnoreParenImpCasts();
switch (S->getStmtClass()) {
- case Expr::BinaryOperatorClass: {
- const BinaryOperator *BO = cast<BinaryOperator>(S);
- return BO->getOperatorLoc();
- }
- case Expr::UnaryOperatorClass: {
- const UnaryOperator *UO = cast<UnaryOperator>(S);
- R1 = UO->getSubExpr()->getSourceRange();
- return UO->getOperatorLoc();
- }
- case Expr::CompoundAssignOperatorClass: {
- const CompoundAssignOperator *CAO = cast<CompoundAssignOperator>(S);
- R1 = CAO->getLHS()->getSourceRange();
- R2 = CAO->getRHS()->getSourceRange();
- return CAO->getOperatorLoc();
- }
- case Expr::BinaryConditionalOperatorClass:
- case Expr::ConditionalOperatorClass: {
- const AbstractConditionalOperator *CO =
- cast<AbstractConditionalOperator>(S);
- return CO->getQuestionLoc();
- }
- case Expr::MemberExprClass: {
- const MemberExpr *ME = cast<MemberExpr>(S);
- R1 = ME->getSourceRange();
- return ME->getMemberLoc();
- }
- case Expr::ArraySubscriptExprClass: {
- const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(S);
- R1 = ASE->getLHS()->getSourceRange();
- R2 = ASE->getRHS()->getSourceRange();
- return ASE->getRBracketLoc();
- }
- case Expr::CStyleCastExprClass: {
- const CStyleCastExpr *CSC = cast<CStyleCastExpr>(S);
- R1 = CSC->getSubExpr()->getSourceRange();
- return CSC->getLParenLoc();
- }
- case Expr::CXXFunctionalCastExprClass: {
- const CXXFunctionalCastExpr *CE = cast <CXXFunctionalCastExpr>(S);
- R1 = CE->getSubExpr()->getSourceRange();
- return CE->getBeginLoc();
- }
- case Stmt::CXXTryStmtClass: {
- return cast<CXXTryStmt>(S)->getHandler(0)->getCatchLoc();
- }
- case Expr::ObjCBridgedCastExprClass: {
- const ObjCBridgedCastExpr *CSC = cast<ObjCBridgedCastExpr>(S);
- R1 = CSC->getSubExpr()->getSourceRange();
- return CSC->getLParenLoc();
- }
- default: ;
+ case Expr::BinaryOperatorClass: {
+ const BinaryOperator *BO = cast<BinaryOperator>(S);
+ return BO->getOperatorLoc();
+ }
+ case Expr::UnaryOperatorClass: {
+ const UnaryOperator *UO = cast<UnaryOperator>(S);
+ R1 = UO->getSubExpr()->getSourceRange();
+ return UO->getOperatorLoc();
+ }
+ case Expr::CompoundAssignOperatorClass: {
+ const CompoundAssignOperator *CAO = cast<CompoundAssignOperator>(S);
+ R1 = CAO->getLHS()->getSourceRange();
+ R2 = CAO->getRHS()->getSourceRange();
+ return CAO->getOperatorLoc();
+ }
+ case Expr::BinaryConditionalOperatorClass:
+ case Expr::ConditionalOperatorClass: {
+ const AbstractConditionalOperator *CO =
+ cast<AbstractConditionalOperator>(S);
+ return CO->getQuestionLoc();
+ }
+ case Expr::MemberExprClass: {
+ const MemberExpr *ME = cast<MemberExpr>(S);
+ R1 = ME->getSourceRange();
+ return ME->getMemberLoc();
+ }
+ case Expr::ArraySubscriptExprClass: {
+ const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(S);
+ R1 = ASE->getLHS()->getSourceRange();
+ R2 = ASE->getRHS()->getSourceRange();
+ return ASE->getRBracketLoc();
+ }
+ case Expr::CStyleCastExprClass: {
+ const CStyleCastExpr *CSC = cast<CStyleCastExpr>(S);
+ R1 = CSC->getSubExpr()->getSourceRange();
+ return CSC->getLParenLoc();
+ }
+ case Expr::CXXFunctionalCastExprClass: {
+ const CXXFunctionalCastExpr *CE = cast<CXXFunctionalCastExpr>(S);
+ R1 = CE->getSubExpr()->getSourceRange();
+ return CE->getBeginLoc();
+ }
+ case Stmt::CXXTryStmtClass: {
+ return cast<CXXTryStmt>(S)->getHandler(0)->getCatchLoc();
+ }
+ case Expr::ObjCBridgedCastExprClass: {
+ const ObjCBridgedCastExpr *CSC = cast<ObjCBridgedCastExpr>(S);
+ R1 = CSC->getSubExpr()->getSourceRange();
+ return CSC->getLParenLoc();
+ }
+ default:;
}
R1 = S->getSourceRange();
return S->getBeginLoc();
}
-void DeadCodeScan::reportDeadCode(const CFGBlock *B,
- const Stmt *S,
+void DeadCodeScan::reportDeadCode(const CFGBlock *B, const Stmt *S,
clang::reachable_code::Callback &CB) {
// Classify the unreachable code found, or suppress it in some cases.
reachable_code::UnreachableKind UK = reachable_code::UK_Other;
@@ -668,8 +661,7 @@ void DeadCodeScan::reportDeadCode(const CFGBlock *B,
} else if (isTrivialDoWhile(B, S) || isBuiltinUnreachable(S) ||
isBuiltinAssumeFalse(B, S, C)) {
return;
- }
- else if (isDeadReturn(B, S)) {
+ } else if (isDeadReturn(B, S)) {
UK = reachable_code::UK_Return;
}
@@ -721,9 +713,10 @@ void DeadCodeScan::reportDeadCode(const CFGBlock *B,
// Reachability APIs.
//===----------------------------------------------------------------------===//
-namespace clang { namespace reachable_code {
+namespace clang {
+namespace reachable_code {
-void Callback::anchor() { }
+void Callback::anchor() {}
unsigned ScanReachableFromBlock(const CFGBlock *Start,
llvm::BitVector &Reachable) {
@@ -741,7 +734,7 @@ void FindUnreachableCode(AnalysisDeclContext &AC, Preprocessor &PP,
// If there are no unreachable blocks, we're done.
llvm::BitVector reachable(cfg->getNumBlockIDs());
unsigned numReachable =
- scanMaybeReachableFromBlock(&cfg->getEntry(), PP, reachable);
+ scanMaybeReachableFromBlock(&cfg->getEntry(), PP, reachable);
if (numReachable == cfg->getNumBlockIDs())
return;
@@ -769,4 +762,5 @@ void FindUnreachableCode(AnalysisDeclContext &AC, Preprocessor &PP,
}
}
-}} // end namespace clang::reachable_code
+} // namespace reachable_code
+} // namespace clang
diff --git a/clang/lib/Analysis/RetainSummaryManager.cpp b/clang/lib/Analysis/RetainSummaryManager.cpp
index 8d279d969b613e..c3d1153356b417 100644
--- a/clang/lib/Analysis/RetainSummaryManager.cpp
+++ b/clang/lib/Analysis/RetainSummaryManager.cpp
@@ -12,22 +12,19 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/Analysis/DomainSpecific/CocoaConventions.h"
#include "clang/Analysis/RetainSummaryManager.h"
#include "clang/AST/Attr.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/ParentMap.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Analysis/DomainSpecific/CocoaConventions.h"
#include <optional>
using namespace clang;
using namespace ento;
-template <class T>
-constexpr static bool isOneOf() {
- return false;
-}
+template <class T> constexpr static bool isOneOf() { return false; }
/// Helper function to check whether the class is one of the
/// rest of varargs.
@@ -63,7 +60,7 @@ struct GeneralizedConsumedAttr {
}
};
-}
+} // namespace
template <class T>
std::optional<ObjKind> RetainSummaryManager::hasAnyEnabledAttrOf(const Decl *D,
@@ -125,7 +122,7 @@ RetainSummaryManager::getPersistentSummary(const RetainSummary &OldSumm) {
CachedSummaryNode *N = SimpleSummaries.FindNodeOrInsertPos(ID, Pos);
if (!N) {
- N = (CachedSummaryNode *) BPAlloc.Allocate<CachedSummaryNode>();
+ N = (CachedSummaryNode *)BPAlloc.Allocate<CachedSummaryNode>();
new (N) CachedSummaryNode(OldSumm);
SimpleSummaries.InsertNode(N, Pos);
}
@@ -133,13 +130,12 @@ RetainSummaryManager::getPersistentSummary(const RetainSummary &OldSumm) {
return &N->getValue();
}
- RetainSummary *Summ = (RetainSummary *) BPAlloc.Allocate<RetainSummary>();
+ RetainSummary *Summ = (RetainSummary *)BPAlloc.Allocate<RetainSummary>();
new (Summ) RetainSummary(OldSumm);
return Summ;
}
-static bool isSubclass(const Decl *D,
- StringRef ClassName) {
+static bool isSubclass(const Decl *D, StringRef ClassName) {
using namespace ast_matchers;
DeclarationMatcher SubclassM =
cxxRecordDecl(isSameOrDerivedFrom(std::string(ClassName)));
@@ -164,10 +160,7 @@ static bool isOSObjectRequiredCast(StringRef S) {
return S == "requiredMetaCast";
}
-static bool isOSObjectThisCast(StringRef S) {
- return S == "metaCast";
-}
-
+static bool isOSObjectThisCast(StringRef S) { return S == "metaCast"; }
static bool isOSObjectPtr(QualType QT) {
return isOSObjectSubclass(QT->getPointeeCXXRecordDecl());
@@ -225,8 +218,7 @@ static bool isOSObjectRelated(const CXXMethodDecl *MD) {
return false;
}
-bool
-RetainSummaryManager::isKnownSmartPointer(QualType QT) {
+bool RetainSummaryManager::isKnownSmartPointer(QualType QT) {
QT = QT.getCanonicalType();
const auto *RD = QT->getAsCXXRecordDecl();
if (!RD)
@@ -291,11 +283,8 @@ RetainSummaryManager::getSummaryForOSObject(const FunctionDecl *FD,
}
const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
- const FunctionDecl *FD,
- StringRef FName,
- QualType RetTy,
- const FunctionType *FT,
- bool &AllowAnnotations) {
+ const FunctionDecl *FD, StringRef FName, QualType RetTy,
+ const FunctionType *FT, bool &AllowAnnotations) {
ArgEffects ScratchArgs(AF.getEmptyMap());
@@ -305,7 +294,7 @@ const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
// as 'void *arg', and then release it inside the thread.
// FIXME: We could build a much more precise model for these functions.
return getPersistentStopSummary();
- } else if(FName == "NSMakeCollectable") {
+ } else if (FName == "NSMakeCollectable") {
// Handle: id NSMakeCollectable(CFTypeRef)
AllowAnnotations = false;
return RetTy->isObjCIdType() ? getUnarySummary(FT, DoNothing)
@@ -314,10 +303,8 @@ const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
FName == "CMBufferQueueDequeueIfDataReadyAndRetain") {
// These API functions are known to NOT act as a CFRetain wrapper.
// They simply make a new object owned by the caller.
- return getPersistentSummary(RetEffect::MakeOwned(ObjKind::CF),
- ScratchArgs,
- ArgEffect(DoNothing),
- ArgEffect(DoNothing));
+ return getPersistentSummary(RetEffect::MakeOwned(ObjKind::CF), ScratchArgs,
+ ArgEffect(DoNothing), ArgEffect(DoNothing));
} else if (FName == "CFPlugInInstanceCreate") {
return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs);
} else if (FName == "IORegistryEntrySearchCFProperty" ||
@@ -335,16 +322,14 @@ const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
// These IOKit functions accept CF objects as arguments.
// They also consume them without an appropriate annotation.
ScratchArgs = AF.add(ScratchArgs, 1, ArgEffect(DecRef, ObjKind::CF));
- return getPersistentSummary(RetEffect::MakeNoRet(),
- ScratchArgs,
+ return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
ArgEffect(DoNothing), ArgEffect(DoNothing));
} else if (FName == "IOServiceAddNotification" ||
FName == "IOServiceAddMatchingNotification") {
// More IOKit functions suddenly accepting (and even more suddenly,
// consuming) CF objects.
ScratchArgs = AF.add(ScratchArgs, 2, ArgEffect(DecRef, ObjKind::CF));
- return getPersistentSummary(RetEffect::MakeNoRet(),
- ScratchArgs,
+ return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
ArgEffect(DoNothing), ArgEffect(DoNothing));
} else if (FName == "CVPixelBufferCreateWithBytes") {
// Eventually this can be improved by recognizing that the pixel
@@ -354,8 +339,7 @@ const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
// FIXME: This function also has an out parameter that returns an
// allocated object.
ScratchArgs = AF.add(ScratchArgs, 7, ArgEffect(StopTracking));
- return getPersistentSummary(RetEffect::MakeNoRet(),
- ScratchArgs,
+ return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
ArgEffect(DoNothing), ArgEffect(DoNothing));
} else if (FName == "CGBitmapContextCreateWithData") {
// This is similar to the CVPixelBufferCreateWithBytes situation above.
@@ -368,8 +352,7 @@ const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
} else if (FName == "CVPixelBufferCreateWithPlanarBytes") {
// Same as CVPixelBufferCreateWithBytes, just more arguments.
ScratchArgs = AF.add(ScratchArgs, 12, ArgEffect(StopTracking));
- return getPersistentSummary(RetEffect::MakeNoRet(),
- ScratchArgs,
+ return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
ArgEffect(DoNothing), ArgEffect(DoNothing));
} else if (FName == "VTCompressionSessionEncodeFrame" ||
FName == "VTCompressionSessionEncodeMultiImageFrame") {
@@ -379,8 +362,7 @@ const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
// To account for this possibility, conservatively stop tracking
// the context.
ScratchArgs = AF.add(ScratchArgs, 5, ArgEffect(StopTracking));
- return getPersistentSummary(RetEffect::MakeNoRet(),
- ScratchArgs,
+ return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
ArgEffect(DoNothing), ArgEffect(DoNothing));
} else if (FName == "dispatch_set_context" ||
FName == "xpc_connection_set_context") {
@@ -389,8 +371,7 @@ const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
// If we pass a context object that is memory managed, stop tracking it.
// Same with xpc_connection_set_finalizer_f().
ScratchArgs = AF.add(ScratchArgs, 1, ArgEffect(StopTracking));
- return getPersistentSummary(RetEffect::MakeNoRet(),
- ScratchArgs,
+ return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
ArgEffect(DoNothing), ArgEffect(DoNothing));
} else if (FName.starts_with("NSLog")) {
return getDoNothingSummary();
@@ -399,9 +380,8 @@ const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
// be deallocated by NSMapRemove.
ScratchArgs = AF.add(ScratchArgs, 1, ArgEffect(StopTracking));
ScratchArgs = AF.add(ScratchArgs, 2, ArgEffect(StopTracking));
- return getPersistentSummary(RetEffect::MakeNoRet(),
- ScratchArgs, ArgEffect(DoNothing),
- ArgEffect(DoNothing));
+ return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
+ ArgEffect(DoNothing), ArgEffect(DoNothing));
}
if (RetTy->isPointerType()) {
@@ -486,7 +466,8 @@ const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
: DoNothing;
return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
- ArgEffect(DoNothing), ArgEffect(E, ObjKind::CF));
+ ArgEffect(DoNothing),
+ ArgEffect(E, ObjKind::CF));
}
}
@@ -518,11 +499,9 @@ RetainSummaryManager::generateSummary(const FunctionDecl *FD,
if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
if (!isOSObjectRelated(MD))
- return getPersistentSummary(RetEffect::MakeNoRet(),
- ArgEffects(AF.getEmptyMap()),
- ArgEffect(DoNothing),
- ArgEffect(StopTracking),
- ArgEffect(DoNothing));
+ return getPersistentSummary(
+ RetEffect::MakeNoRet(), ArgEffects(AF.getEmptyMap()),
+ ArgEffect(DoNothing), ArgEffect(StopTracking), ArgEffect(DoNothing));
if (TrackObjCAndCFObjects)
if (const RetainSummary *S =
@@ -626,9 +605,8 @@ void RetainSummaryManager::updateSummaryForReceiverUnconsumedSelf(
Template->setRetEffect(RetEffect::MakeNoRet());
}
-
void RetainSummaryManager::updateSummaryForArgumentTypes(
- const AnyCall &C, const RetainSummary *&RS) {
+ const AnyCall &C, const RetainSummary *&RS) {
RetainSummaryTemplate Template(RS, *this);
unsigned parm_idx = 0;
@@ -659,8 +637,7 @@ void RetainSummaryManager::updateSummaryForArgumentTypes(
}
const RetainSummary *
-RetainSummaryManager::getSummary(AnyCall C,
- bool HasNonZeroCallbackArg,
+RetainSummaryManager::getSummary(AnyCall C, bool HasNonZeroCallbackArg,
bool IsReceiverUnconsumedSelf,
QualType ReceiverType) {
const RetainSummary *Summ;
@@ -701,7 +678,6 @@ RetainSummaryManager::getSummary(AnyCall C,
return Summ;
}
-
const RetainSummary *
RetainSummaryManager::getCFCreateGetRuleSummary(const FunctionDecl *FD) {
if (coreFoundation::followsCreateRule(FD))
@@ -764,7 +740,7 @@ RetainSummaryManager::canEval(const CallExpr *CE, const FunctionDecl *FD,
}
}
- const FunctionDecl* FDD = FD->getDefinition();
+ const FunctionDecl *FDD = FD->getDefinition();
if (FDD && isTrustedReferenceCountImplementation(FDD)) {
hasTrustedImplementationAnnotation = true;
return BehaviorSummary::Identity;
@@ -782,7 +758,7 @@ RetainSummaryManager::canEval(const CallExpr *CE, const FunctionDecl *FD,
}
const RetainSummary *
-RetainSummaryManager::getUnarySummary(const FunctionType* FT,
+RetainSummaryManager::getUnarySummary(const FunctionType *FT,
ArgEffectKind AE) {
// Unary functions have no arg effects by definition.
@@ -790,22 +766,20 @@ RetainSummaryManager::getUnarySummary(const FunctionType* FT,
// Verify that this is *really* a unary function. This can
// happen if people do weird things.
- const FunctionProtoType* FTP = dyn_cast<FunctionProtoType>(FT);
+ const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FT);
if (!FTP || FTP->getNumParams() != 1)
return getPersistentStopSummary();
ArgEffect Effect(AE, ObjKind::CF);
ScratchArgs = AF.add(ScratchArgs, 0, Effect);
- return getPersistentSummary(RetEffect::MakeNoRet(),
- ScratchArgs,
+ return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
ArgEffect(DoNothing), ArgEffect(DoNothing));
}
const RetainSummary *
RetainSummaryManager::getOSSummaryRetainRule(const FunctionDecl *FD) {
- return getPersistentSummary(RetEffect::MakeNoRet(),
- AF.getEmptyMap(),
+ return getPersistentSummary(RetEffect::MakeNoRet(), AF.getEmptyMap(),
/*ReceiverEff=*/ArgEffect(DoNothing),
/*DefaultEff=*/ArgEffect(DoNothing),
/*ThisEff=*/ArgEffect(IncRef, ObjKind::OS));
@@ -813,8 +787,7 @@ RetainSummaryManager::getOSSummaryRetainRule(const FunctionDecl *FD) {
const RetainSummary *
RetainSummaryManager::getOSSummaryReleaseRule(const FunctionDecl *FD) {
- return getPersistentSummary(RetEffect::MakeNoRet(),
- AF.getEmptyMap(),
+ return getPersistentSummary(RetEffect::MakeNoRet(), AF.getEmptyMap(),
/*ReceiverEff=*/ArgEffect(DoNothing),
/*DefaultEff=*/ArgEffect(DoNothing),
/*ThisEff=*/ArgEffect(DecRef, ObjKind::OS));
@@ -822,8 +795,7 @@ RetainSummaryManager::getOSSummaryReleaseRule(const FunctionDecl *FD) {
const RetainSummary *
RetainSummaryManager::getOSSummaryFreeRule(const FunctionDecl *FD) {
- return getPersistentSummary(RetEffect::MakeNoRet(),
- AF.getEmptyMap(),
+ return getPersistentSummary(RetEffect::MakeNoRet(), AF.getEmptyMap(),
/*ReceiverEff=*/ArgEffect(DoNothing),
/*DefaultEff=*/ArgEffect(DoNothing),
/*ThisEff=*/ArgEffect(Dealloc, ObjKind::OS));
@@ -854,9 +826,6 @@ RetainSummaryManager::getCFSummaryGetRule(const FunctionDecl *FD) {
ArgEffect(DoNothing), ArgEffect(DoNothing));
}
-
-
-
//===----------------------------------------------------------------------===//
// Summary creation for Selectors.
//===----------------------------------------------------------------------===//
@@ -887,8 +856,7 @@ RetainSummaryManager::getRetEffectFromAnnotations(QualType RetTy,
/// \return Whether the chain of typedefs starting from @c QT
/// has a typedef with a given name @c Name.
-static bool hasTypedefNamed(QualType QT,
- StringRef Name) {
+static bool hasTypedefNamed(QualType QT, StringRef Name) {
while (auto *T = QT->getAs<TypedefType>()) {
const auto &Context = T->getDecl()->getASTContext();
if (T->getDecl()->getIdentifier() == &Context.Idents.get(Name))
@@ -971,9 +939,8 @@ bool RetainSummaryManager::applyParamAnnotationEffect(
return false;
}
-void
-RetainSummaryManager::updateSummaryFromAnnotations(const RetainSummary *&Summ,
- const FunctionDecl *FD) {
+void RetainSummaryManager::updateSummaryFromAnnotations(
+ const RetainSummary *&Summ, const FunctionDecl *FD) {
if (!FD)
return;
@@ -982,8 +949,8 @@ RetainSummaryManager::updateSummaryFromAnnotations(const RetainSummary *&Summ,
// Effects on the parameters.
unsigned parm_idx = 0;
- for (auto pi = FD->param_begin(),
- pe = FD->param_end(); pi != pe; ++pi, ++parm_idx)
+ for (auto pi = FD->param_begin(), pe = FD->param_end(); pi != pe;
+ ++pi, ++parm_idx)
applyParamAnnotationEffect(*pi, parm_idx, FD, Template);
QualType RetTy = FD->getReturnType();
@@ -994,9 +961,8 @@ RetainSummaryManager::updateSummaryFromAnnotations(const RetainSummary *&Summ,
Template->setThisEffect(ArgEffect(DecRef, ObjKind::OS));
}
-void
-RetainSummaryManager::updateSummaryFromAnnotations(const RetainSummary *&Summ,
- const ObjCMethodDecl *MD) {
+void RetainSummaryManager::updateSummaryFromAnnotations(
+ const RetainSummary *&Summ, const ObjCMethodDecl *MD) {
if (!MD)
return;
@@ -1027,68 +993,68 @@ RetainSummaryManager::getStandardMethodSummary(const ObjCMethodDecl *MD,
// Check the method family, and apply any default annotations.
switch (MD ? MD->getMethodFamily() : S.getMethodFamily()) {
- case OMF_None:
- case OMF_initialize:
- case OMF_performSelector:
- // Assume all Objective-C methods follow Cocoa Memory Management rules.
- // FIXME: Does the non-threaded performSelector family really belong here?
- // The selector could be, say, @selector(copy).
- if (cocoa::isCocoaObjectRef(RetTy))
- ResultEff = RetEffect::MakeNotOwned(ObjKind::ObjC);
- else if (coreFoundation::isCFObjectRef(RetTy)) {
- // ObjCMethodDecl currently doesn't consider CF objects as valid return
- // values for alloc, new, copy, or mutableCopy, so we have to
- // double-check with the selector. This is ugly, but there aren't that
- // many Objective-C methods that return CF objects, right?
- if (MD) {
- switch (S.getMethodFamily()) {
- case OMF_alloc:
- case OMF_new:
- case OMF_copy:
- case OMF_mutableCopy:
- ResultEff = RetEffect::MakeOwned(ObjKind::CF);
- break;
- default:
- ResultEff = RetEffect::MakeNotOwned(ObjKind::CF);
- break;
- }
- } else {
+ case OMF_None:
+ case OMF_initialize:
+ case OMF_performSelector:
+ // Assume all Objective-C methods follow Cocoa Memory Management rules.
+ // FIXME: Does the non-threaded performSelector family really belong here?
+ // The selector could be, say, @selector(copy).
+ if (cocoa::isCocoaObjectRef(RetTy))
+ ResultEff = RetEffect::MakeNotOwned(ObjKind::ObjC);
+ else if (coreFoundation::isCFObjectRef(RetTy)) {
+ // ObjCMethodDecl currently doesn't consider CF objects as valid return
+ // values for alloc, new, copy, or mutableCopy, so we have to
+ // double-check with the selector. This is ugly, but there aren't that
+ // many Objective-C methods that return CF objects, right?
+ if (MD) {
+ switch (S.getMethodFamily()) {
+ case OMF_alloc:
+ case OMF_new:
+ case OMF_copy:
+ case OMF_mutableCopy:
+ ResultEff = RetEffect::MakeOwned(ObjKind::CF);
+ break;
+ default:
ResultEff = RetEffect::MakeNotOwned(ObjKind::CF);
+ break;
}
+ } else {
+ ResultEff = RetEffect::MakeNotOwned(ObjKind::CF);
}
- break;
- case OMF_init:
- ResultEff = ObjCInitRetE;
- ReceiverEff = ArgEffect(DecRef, ObjKind::ObjC);
- break;
- case OMF_alloc:
- case OMF_new:
- case OMF_copy:
- case OMF_mutableCopy:
- if (cocoa::isCocoaObjectRef(RetTy))
- ResultEff = ObjCAllocRetE;
- else if (coreFoundation::isCFObjectRef(RetTy))
- ResultEff = RetEffect::MakeOwned(ObjKind::CF);
- break;
- case OMF_autorelease:
- ReceiverEff = ArgEffect(Autorelease, ObjKind::ObjC);
- break;
- case OMF_retain:
- ReceiverEff = ArgEffect(IncRef, ObjKind::ObjC);
- break;
- case OMF_release:
- ReceiverEff = ArgEffect(DecRef, ObjKind::ObjC);
- break;
- case OMF_dealloc:
- ReceiverEff = ArgEffect(Dealloc, ObjKind::ObjC);
- break;
- case OMF_self:
- // -self is handled specially by the ExprEngine to propagate the receiver.
- break;
- case OMF_retainCount:
- case OMF_finalize:
- // These methods don't return objects.
- break;
+ }
+ break;
+ case OMF_init:
+ ResultEff = ObjCInitRetE;
+ ReceiverEff = ArgEffect(DecRef, ObjKind::ObjC);
+ break;
+ case OMF_alloc:
+ case OMF_new:
+ case OMF_copy:
+ case OMF_mutableCopy:
+ if (cocoa::isCocoaObjectRef(RetTy))
+ ResultEff = ObjCAllocRetE;
+ else if (coreFoundation::isCFObjectRef(RetTy))
+ ResultEff = RetEffect::MakeOwned(ObjKind::CF);
+ break;
+ case OMF_autorelease:
+ ReceiverEff = ArgEffect(Autorelease, ObjKind::ObjC);
+ break;
+ case OMF_retain:
+ ReceiverEff = ArgEffect(IncRef, ObjKind::ObjC);
+ break;
+ case OMF_release:
+ ReceiverEff = ArgEffect(DecRef, ObjKind::ObjC);
+ break;
+ case OMF_dealloc:
+ ReceiverEff = ArgEffect(Dealloc, ObjKind::ObjC);
+ break;
+ case OMF_self:
+ // -self is handled specially by the ExprEngine to propagate the receiver.
+ break;
+ case OMF_retainCount:
+ case OMF_finalize:
+ // These methods don't return objects.
+ break;
}
// If one of the arguments in the selector has the keyword 'delegate' we
@@ -1124,9 +1090,9 @@ RetainSummaryManager::getClassMethodSummary(const ObjCMessageExpr *ME) {
ME->getType(), ObjCClassMethodSummaries);
}
-const RetainSummary *RetainSummaryManager::getInstanceMethodSummary(
- const ObjCMessageExpr *ME,
- QualType ReceiverType) {
+const RetainSummary *
+RetainSummaryManager::getInstanceMethodSummary(const ObjCMessageExpr *ME,
+ QualType ReceiverType) {
const ObjCInterfaceDecl *ReceiverClass = nullptr;
// We do better tracking of the type of the object than the core ExprEngine.
@@ -1153,8 +1119,7 @@ const RetainSummary *RetainSummaryManager::getInstanceMethodSummary(
}
const RetainSummary *
-RetainSummaryManager::getMethodSummary(Selector S,
- const ObjCInterfaceDecl *ID,
+RetainSummaryManager::getMethodSummary(Selector S, const ObjCInterfaceDecl *ID,
const ObjCMethodDecl *MD, QualType RetTy,
ObjCMethodSummariesTy &CachedSummaries) {
@@ -1183,8 +1148,8 @@ void RetainSummaryManager::InitializeClassMethodSummaries() {
// Create the [NSAssertionHandler currentHander] summary.
addClassMethSummary("NSAssertionHandler", "currentHandler",
- getPersistentSummary(RetEffect::MakeNotOwned(ObjKind::ObjC),
- ScratchArgs));
+ getPersistentSummary(
+ RetEffect::MakeNotOwned(ObjKind::ObjC), ScratchArgs));
// Create the [NSAutoreleasePool addObject:] summary.
ScratchArgs = AF.add(ScratchArgs, 0, ArgEffect(Autorelease));
@@ -1209,10 +1174,10 @@ void RetainSummaryManager::InitializeMethodSummaries() {
InitSumm);
// The next methods are allocators.
- const RetainSummary *AllocSumm = getPersistentSummary(ObjCAllocRetE,
- ScratchArgs);
+ const RetainSummary *AllocSumm =
+ getPersistentSummary(ObjCAllocRetE, ScratchArgs);
const RetainSummary *CFAllocSumm =
- getPersistentSummary(RetEffect::MakeOwned(ObjKind::CF), ScratchArgs);
+ getPersistentSummary(RetEffect::MakeOwned(ObjKind::CF), ScratchArgs);
// Create the "retain" selector.
RetEffect NoRet = RetEffect::MakeNoRet();
@@ -1226,13 +1191,13 @@ void RetainSummaryManager::InitializeMethodSummaries() {
addNSObjectMethSummary(GetNullarySelector("release", Ctx), Summ);
// Create the -dealloc summary.
- Summ = getPersistentSummary(NoRet, ScratchArgs, ArgEffect(Dealloc,
- ObjKind::ObjC));
+ Summ = getPersistentSummary(NoRet, ScratchArgs,
+ ArgEffect(Dealloc, ObjKind::ObjC));
addNSObjectMethSummary(GetNullarySelector("dealloc", Ctx), Summ);
// Create the "autorelease" selector.
- Summ = getPersistentSummary(NoRet, ScratchArgs, ArgEffect(Autorelease,
- ObjKind::ObjC));
+ Summ = getPersistentSummary(NoRet, ScratchArgs,
+ ArgEffect(Autorelease, ObjKind::ObjC));
addNSObjectMethSummary(GetNullarySelector("autorelease", Ctx), Summ);
// For NSWindow, allocated objects are (initially) self-owned.
diff --git a/clang/lib/Analysis/ThreadSafety.cpp b/clang/lib/Analysis/ThreadSafety.cpp
index e25b843c9bf83e..da0c359ed72524 100644
--- a/clang/lib/Analysis/ThreadSafety.cpp
+++ b/clang/lib/Analysis/ThreadSafety.cpp
@@ -65,9 +65,9 @@ using namespace threadSafety;
ThreadSafetyHandler::~ThreadSafetyHandler() = default;
/// Issue a warning about an invalid lock expression
-static void warnInvalidLock(ThreadSafetyHandler &Handler,
- const Expr *MutexExp, const NamedDecl *D,
- const Expr *DeclExp, StringRef Kind) {
+static void warnInvalidLock(ThreadSafetyHandler &Handler, const Expr *MutexExp,
+ const NamedDecl *D, const Expr *DeclExp,
+ StringRef Kind) {
SourceLocation Loc;
if (DeclExp)
Loc = DeclExp->getExprLoc();
@@ -127,7 +127,7 @@ class FactEntry : public CapabilityExpr {
: CapabilityExpr(CE), LKind(LK), Source(Src), AcquireLoc(Loc) {}
virtual ~FactEntry() = default;
- LockKind kind() const { return LKind; }
+ LockKind kind() const { return LKind; }
SourceLocation loc() const { return AcquireLoc; }
bool asserted() const { return Source == Asserted; }
@@ -148,7 +148,7 @@ class FactEntry : public CapabilityExpr {
// Return true if LKind >= LK, where exclusive > shared
bool isAtLeast(LockKind LK) const {
- return (LKind == LK_Exclusive) || (LK == LK_Shared);
+ return (LKind == LK_Exclusive) || (LK == LK_Shared);
}
};
@@ -211,19 +211,19 @@ class FactSet {
return F;
}
- bool removeLock(FactManager& FM, const CapabilityExpr &CapE) {
+ bool removeLock(FactManager &FM, const CapabilityExpr &CapE) {
unsigned n = FactIDs.size();
if (n == 0)
return false;
- for (unsigned i = 0; i < n-1; ++i) {
+ for (unsigned i = 0; i < n - 1; ++i) {
if (FM[FactIDs[i]].matches(CapE)) {
- FactIDs[i] = FactIDs[n-1];
+ FactIDs[i] = FactIDs[n - 1];
FactIDs.pop_back();
return true;
}
}
- if (FM[FactIDs[n-1]].matches(CapE)) {
+ if (FM[FactIDs[n - 1]].matches(CapE)) {
FactIDs.pop_back();
return true;
}
@@ -231,15 +231,13 @@ class FactSet {
}
iterator findLockIter(FactManager &FM, const CapabilityExpr &CapE) {
- return std::find_if(begin(), end(), [&](FactID ID) {
- return FM[ID].matches(CapE);
- });
+ return std::find_if(begin(), end(),
+ [&](FactID ID) { return FM[ID].matches(CapE); });
}
const FactEntry *findLock(FactManager &FM, const CapabilityExpr &CapE) const {
- auto I = std::find_if(begin(), end(), [&](FactID ID) {
- return FM[ID].matches(CapE);
- });
+ auto I = std::find_if(begin(), end(),
+ [&](FactID ID) { return FM[ID].matches(CapE); });
return I != end() ? &FM[*I] : nullptr;
}
@@ -259,7 +257,7 @@ class FactSet {
return I != end() ? &FM[*I] : nullptr;
}
- bool containsMutexDecl(FactManager &FM, const ValueDecl* Vd) const {
+ bool containsMutexDecl(FactManager &FM, const ValueDecl *Vd) const {
auto I = std::find_if(begin(), end(), [&](FactID ID) -> bool {
return FM[ID].valueDecl() == Vd;
});
@@ -293,16 +291,15 @@ class BeforeSet {
public:
BeforeSet() = default;
- BeforeInfo* insertAttrExprs(const ValueDecl* Vd,
- ThreadSafetyAnalyzer& Analyzer);
+ BeforeInfo *insertAttrExprs(const ValueDecl *Vd,
+ ThreadSafetyAnalyzer &Analyzer);
BeforeInfo *getBeforeInfoForDecl(const ValueDecl *Vd,
ThreadSafetyAnalyzer &Analyzer);
- void checkBeforeAfter(const ValueDecl* Vd,
- const FactSet& FSet,
- ThreadSafetyAnalyzer& Analyzer,
- SourceLocation Loc, StringRef CapKind);
+ void checkBeforeAfter(const ValueDecl *Vd, const FactSet &FSet,
+ ThreadSafetyAnalyzer &Analyzer, SourceLocation Loc,
+ StringRef CapKind);
private:
BeforeMap BMap;
@@ -426,7 +423,7 @@ class LocalVariableMap {
}
/// Look up a definition, within the given context.
- const VarDefinition* lookup(const NamedDecl *D, Context Ctx) {
+ const VarDefinition *lookup(const NamedDecl *D, Context Ctx) {
const unsigned *i = Ctx.lookup(D);
if (!i)
return nullptr;
@@ -437,7 +434,7 @@ class LocalVariableMap {
/// Look up the definition for D within the given context. Returns
/// NULL if the expression is not statically known. If successful, also
/// modifies Ctx to hold the context of the return Expr.
- const Expr* lookupExpr(const NamedDecl *D, Context &Ctx) {
+ const Expr *lookupExpr(const NamedDecl *D, Context &Ctx) {
const unsigned *P = Ctx.lookup(D);
if (!P)
return nullptr;
@@ -459,7 +456,7 @@ class LocalVariableMap {
/// clients of the class to get the appropriate context when traversing the
/// CFG. It must be called for every assignment or DeclStmt.
Context getNextContext(unsigned &CtxIndex, const Stmt *S, Context C) {
- if (SavedContexts[CtxIndex+1].first == S) {
+ if (SavedContexts[CtxIndex + 1].first == S) {
CtxIndex++;
Context Result = SavedContexts[CtxIndex].second;
return Result;
@@ -478,7 +475,7 @@ class LocalVariableMap {
return;
}
Dec->printName(llvm::errs());
- llvm::errs() << "." << i << " " << ((const void*) Dec);
+ llvm::errs() << "." << i << " " << ((const void *)Dec);
}
/// Dumps an ASCII representation of the variable map to llvm::errs()
@@ -489,7 +486,8 @@ class LocalVariableMap {
dumpVarDefinitionName(i);
llvm::errs() << " = ";
- if (Exp) Exp->dump();
+ if (Exp)
+ Exp->dump();
else {
dumpVarDefinitionName(Ref);
llvm::errs() << "\n";
@@ -516,7 +514,7 @@ class LocalVariableMap {
friend class VarMapBuilder;
// Get the current context index
- unsigned getContextIndex() { return SavedContexts.size()-1; }
+ unsigned getContextIndex() { return SavedContexts.size() - 1; }
// Save the current context for later replay
void saveContext(const Stmt *S, Context C) {
@@ -591,7 +589,7 @@ namespace {
/// Visitor which builds a LocalVariableMap
class VarMapBuilder : public ConstStmtVisitor<VarMapBuilder> {
public:
- LocalVariableMap* VMap;
+ LocalVariableMap *VMap;
LocalVariableMap::Context Ctx;
VarMapBuilder(LocalVariableMap *VM, LocalVariableMap::Context C)
@@ -647,15 +645,15 @@ void VarMapBuilder::VisitBinaryOperator(const BinaryOperator *BO) {
// Computes the intersection of two contexts. The intersection is the
// set of variables which have the same definition in both contexts;
// variables with different definitions are discarded.
-LocalVariableMap::Context
-LocalVariableMap::intersectContexts(Context C1, Context C2) {
+LocalVariableMap::Context LocalVariableMap::intersectContexts(Context C1,
+ Context C2) {
Context Result = C1;
for (const auto &P : C1) {
const NamedDecl *Dec = P.first;
const unsigned *i2 = C2.lookup(Dec);
- if (!i2) // variable doesn't exist on second path
+ if (!i2) // variable doesn't exist on second path
Result = removeDefinition(Dec, Result);
- else if (*i2 != P.second) // variable exists, but has different definition
+ else if (*i2 != P.second) // variable exists, but has different definition
Result = clearDefinition(Dec, Result);
}
return Result;
@@ -682,7 +680,7 @@ void LocalVariableMap::intersectBackEdge(Context C1, Context C2) {
const unsigned *i2 = C2.lookup(P.first);
if (!i2 || (*i2 != i1))
- VDef->Ref = 0; // Mark this variable as undefined
+ VDef->Ref = 0; // Mark this variable as undefined
}
}
@@ -738,7 +736,8 @@ void LocalVariableMap::traverseCFG(CFG *CFGraph,
bool HasBackEdges = false;
bool CtxInit = true;
for (CFGBlock::const_pred_iterator PI = CurrBlock->pred_begin(),
- PE = CurrBlock->pred_end(); PI != PE; ++PI) {
+ PE = CurrBlock->pred_end();
+ PI != PE; ++PI) {
// if *PI -> CurrBlock is a back edge, so skip it
if (*PI == nullptr || !VisitedBlocks.alreadySet(*PI)) {
HasBackEdges = true;
@@ -751,11 +750,9 @@ void LocalVariableMap::traverseCFG(CFG *CFGraph,
if (CtxInit) {
CurrBlockInfo->EntryContext = PrevBlockInfo->ExitContext;
CtxInit = false;
- }
- else {
- CurrBlockInfo->EntryContext =
- intersectContexts(CurrBlockInfo->EntryContext,
- PrevBlockInfo->ExitContext);
+ } else {
+ CurrBlockInfo->EntryContext = intersectContexts(
+ CurrBlockInfo->EntryContext, PrevBlockInfo->ExitContext);
}
}
@@ -763,7 +760,7 @@ void LocalVariableMap::traverseCFG(CFG *CFGraph,
// intersectBackEdges later.
if (HasBackEdges)
CurrBlockInfo->EntryContext =
- createReferenceContext(CurrBlockInfo->EntryContext);
+ createReferenceContext(CurrBlockInfo->EntryContext);
// Create a starting context index for the current block
saveContext(nullptr, CurrBlockInfo->EntryContext);
@@ -773,27 +770,28 @@ void LocalVariableMap::traverseCFG(CFG *CFGraph,
VarMapBuilder VMapBuilder(this, CurrBlockInfo->EntryContext);
for (const auto &BI : *CurrBlock) {
switch (BI.getKind()) {
- case CFGElement::Statement: {
- CFGStmt CS = BI.castAs<CFGStmt>();
- VMapBuilder.Visit(CS.getStmt());
- break;
- }
- default:
- break;
+ case CFGElement::Statement: {
+ CFGStmt CS = BI.castAs<CFGStmt>();
+ VMapBuilder.Visit(CS.getStmt());
+ break;
+ }
+ default:
+ break;
}
}
CurrBlockInfo->ExitContext = VMapBuilder.Ctx;
// Mark variables on back edges as "unknown" if they've been changed.
for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(),
- SE = CurrBlock->succ_end(); SI != SE; ++SI) {
+ SE = CurrBlock->succ_end();
+ SI != SE; ++SI) {
// if CurrBlock -> *SI is *not* a back edge
if (*SI == nullptr || !VisitedBlocks.alreadySet(*SI))
continue;
CFGBlock *FirstLoopBlock = *SI;
Context LoopBegin = BlockInfo[FirstLoopBlock->getBlockID()].EntryContext;
- Context LoopEnd = CurrBlockInfo->ExitContext;
+ Context LoopEnd = CurrBlockInfo->ExitContext;
intersectBackEdge(LoopBegin, LoopEnd);
}
}
@@ -817,7 +815,8 @@ static void findBlockLocations(CFG *CFGraph,
CurrBlockInfo->EntryLoc = CurrBlockInfo->ExitLoc = S->getBeginLoc();
} else {
for (CFGBlock::const_reverse_iterator BI = CurrBlock->rbegin(),
- BE = CurrBlock->rend(); BI != BE; ++BI) {
+ BE = CurrBlock->rend();
+ BI != BE; ++BI) {
// FIXME: Handle other CFGElement kinds.
if (std::optional<CFGStmt> CS = BI->getAs<CFGStmt>()) {
CurrBlockInfo->ExitLoc = CS->getStmt()->getBeginLoc();
@@ -987,8 +986,8 @@ class ScopedLockableFactEntry : public FactEntry {
SourceLocation loc, ThreadSafetyHandler *Handler) const {
if (FSet.findLock(FactMan, Cp)) {
FSet.removeLock(FactMan, Cp);
- FSet.addLock(FactMan, std::make_unique<LockableFactEntry>(
- !Cp, LK_Exclusive, loc));
+ FSet.addLock(FactMan,
+ std::make_unique<LockableFactEntry>(!Cp, LK_Exclusive, loc));
} else if (Handler) {
SourceLocation PrevLoc;
if (const FactEntry *Neg = FSet.findLock(FactMan, !Cp))
@@ -1018,7 +1017,7 @@ class ThreadSafetyAnalyzer {
BeforeSet *GlobalBeforeSet;
public:
- ThreadSafetyAnalyzer(ThreadSafetyHandler &H, BeforeSet* Bset)
+ ThreadSafetyAnalyzer(ThreadSafetyHandler &H, BeforeSet *Bset)
: Arena(&Bpa), SxBuilder(Arena), Handler(H), GlobalBeforeSet(Bset) {}
bool inCurrentScope(const CapabilityExpr &CapE);
@@ -1034,16 +1033,14 @@ class ThreadSafetyAnalyzer {
template <class AttrType>
void getMutexIDs(CapExprSet &Mtxs, AttrType *Attr, const Expr *Exp,
- const NamedDecl *D,
- const CFGBlock *PredBlock, const CFGBlock *CurrBlock,
- Expr *BrE, bool Neg);
+ const NamedDecl *D, const CFGBlock *PredBlock,
+ const CFGBlock *CurrBlock, Expr *BrE, bool Neg);
- const CallExpr* getTrylockCallExpr(const Stmt *Cond, LocalVarContext C,
+ const CallExpr *getTrylockCallExpr(const Stmt *Cond, LocalVarContext C,
bool &Negate);
void getEdgeLockset(FactSet &Result, const FactSet &ExitSet,
- const CFGBlock* PredBlock,
- const CFGBlock *CurrBlock);
+ const CFGBlock *PredBlock, const CFGBlock *CurrBlock);
bool join(const FactEntry &a, const FactEntry &b, bool CanModify);
@@ -1075,8 +1072,9 @@ class ThreadSafetyAnalyzer {
} // namespace
/// Process acquired_before and acquired_after attributes on Vd.
-BeforeSet::BeforeInfo* BeforeSet::insertAttrExprs(const ValueDecl* Vd,
- ThreadSafetyAnalyzer& Analyzer) {
+BeforeSet::BeforeInfo *
+BeforeSet::insertAttrExprs(const ValueDecl *Vd,
+ ThreadSafetyAnalyzer &Analyzer) {
// Create a new entry for Vd.
BeforeInfo *Info = nullptr;
{
@@ -1090,39 +1088,37 @@ BeforeSet::BeforeInfo* BeforeSet::insertAttrExprs(const ValueDecl* Vd,
for (const auto *At : Vd->attrs()) {
switch (At->getKind()) {
- case attr::AcquiredBefore: {
- const auto *A = cast<AcquiredBeforeAttr>(At);
-
- // Read exprs from the attribute, and add them to BeforeVect.
- for (const auto *Arg : A->args()) {
- CapabilityExpr Cp =
- Analyzer.SxBuilder.translateAttrExpr(Arg, nullptr);
- if (const ValueDecl *Cpvd = Cp.valueDecl()) {
- Info->Vect.push_back(Cpvd);
- const auto It = BMap.find(Cpvd);
- if (It == BMap.end())
- insertAttrExprs(Cpvd, Analyzer);
- }
+ case attr::AcquiredBefore: {
+ const auto *A = cast<AcquiredBeforeAttr>(At);
+
+ // Read exprs from the attribute, and add them to BeforeVect.
+ for (const auto *Arg : A->args()) {
+ CapabilityExpr Cp = Analyzer.SxBuilder.translateAttrExpr(Arg, nullptr);
+ if (const ValueDecl *Cpvd = Cp.valueDecl()) {
+ Info->Vect.push_back(Cpvd);
+ const auto It = BMap.find(Cpvd);
+ if (It == BMap.end())
+ insertAttrExprs(Cpvd, Analyzer);
}
- break;
}
- case attr::AcquiredAfter: {
- const auto *A = cast<AcquiredAfterAttr>(At);
-
- // Read exprs from the attribute, and add them to BeforeVect.
- for (const auto *Arg : A->args()) {
- CapabilityExpr Cp =
- Analyzer.SxBuilder.translateAttrExpr(Arg, nullptr);
- if (const ValueDecl *ArgVd = Cp.valueDecl()) {
- // Get entry for mutex listed in attribute
- BeforeInfo *ArgInfo = getBeforeInfoForDecl(ArgVd, Analyzer);
- ArgInfo->Vect.push_back(Vd);
- }
+ break;
+ }
+ case attr::AcquiredAfter: {
+ const auto *A = cast<AcquiredAfterAttr>(At);
+
+ // Read exprs from the attribute, and add them to BeforeVect.
+ for (const auto *Arg : A->args()) {
+ CapabilityExpr Cp = Analyzer.SxBuilder.translateAttrExpr(Arg, nullptr);
+ if (const ValueDecl *ArgVd = Cp.valueDecl()) {
+ // Get entry for mutex listed in attribute
+ BeforeInfo *ArgInfo = getBeforeInfoForDecl(ArgVd, Analyzer);
+ ArgInfo->Vect.push_back(Vd);
}
- break;
}
- default:
- break;
+ break;
+ }
+ default:
+ break;
}
}
@@ -1143,15 +1139,14 @@ BeforeSet::getBeforeInfoForDecl(const ValueDecl *Vd,
}
/// Return true if any mutexes in FSet are in the acquired_before set of Vd.
-void BeforeSet::checkBeforeAfter(const ValueDecl* StartVd,
- const FactSet& FSet,
- ThreadSafetyAnalyzer& Analyzer,
+void BeforeSet::checkBeforeAfter(const ValueDecl *StartVd, const FactSet &FSet,
+ ThreadSafetyAnalyzer &Analyzer,
SourceLocation Loc, StringRef CapKind) {
- SmallVector<BeforeInfo*, 8> InfoVect;
+ SmallVector<BeforeInfo *, 8> InfoVect;
// Do a depth-first traversal of Vd.
// Return true if there are cycles.
- std::function<bool (const ValueDecl*)> traverse = [&](const ValueDecl* Vd) {
+ std::function<bool(const ValueDecl *)> traverse = [&](const ValueDecl *Vd) {
if (!Vd)
return false;
@@ -1210,16 +1205,14 @@ static const ValueDecl *getValueDecl(const Expr *Exp) {
namespace {
-template <typename Ty>
-class has_arg_iterator_range {
+template <typename Ty> class has_arg_iterator_range {
using yes = char[1];
using no = char[2];
template <typename Inner>
- static yes& test(Inner *I, decltype(I->args()) * = nullptr);
+ static yes &test(Inner *I, decltype(I->args()) * = nullptr);
- template <typename>
- static no& test(...);
+ template <typename> static no &test(...);
public:
static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
@@ -1268,8 +1261,7 @@ void ThreadSafetyAnalyzer::addLock(FactSet &FSet,
const FactEntry *Nen = FSet.findLock(FactMan, NegC);
if (Nen) {
FSet.removeLock(FactMan, NegC);
- }
- else {
+ } else {
if (inCurrentScope(*Entry) && !Entry->asserted())
Handler.handleNegativeNotHeld(Entry->getKind(), Entry->toString(),
NegC.toString(), Entry->loc());
@@ -1277,8 +1269,7 @@ void ThreadSafetyAnalyzer::addLock(FactSet &FSet,
}
// Check before/after constraints
- if (Handler.issueBetaWarnings() &&
- !Entry->asserted() && !Entry->declared()) {
+ if (Handler.issueBetaWarnings() && !Entry->asserted() && !Entry->declared()) {
GlobalBeforeSet->checkBeforeAfter(Entry->valueDecl(), FSet, *this,
Entry->loc(), Entry->getKind());
}
@@ -1333,7 +1324,7 @@ void ThreadSafetyAnalyzer::getMutexIDs(CapExprSet &Mtxs, AttrType *Attr,
warnInvalidLock(Handler, nullptr, D, Exp, Cp.getKind());
return;
}
- //else
+ // else
if (!Cp.shouldIgnore())
Mtxs.push_back_nodup(Cp);
return;
@@ -1345,7 +1336,7 @@ void ThreadSafetyAnalyzer::getMutexIDs(CapExprSet &Mtxs, AttrType *Attr,
warnInvalidLock(Handler, nullptr, D, Exp, Cp.getKind());
continue;
}
- //else
+ // else
if (!Cp.shouldIgnore())
Mtxs.push_back_nodup(Cp);
}
@@ -1358,8 +1349,8 @@ template <class AttrType>
void ThreadSafetyAnalyzer::getMutexIDs(CapExprSet &Mtxs, AttrType *Attr,
const Expr *Exp, const NamedDecl *D,
const CFGBlock *PredBlock,
- const CFGBlock *CurrBlock,
- Expr *BrE, bool Neg) {
+ const CFGBlock *CurrBlock, Expr *BrE,
+ bool Neg) {
// Find out which branch has the lock
bool branch = false;
if (const auto *BLE = dyn_cast_or_null<CXXBoolLiteralExpr>(BrE))
@@ -1374,7 +1365,8 @@ void ThreadSafetyAnalyzer::getMutexIDs(CapExprSet &Mtxs, AttrType *Attr,
// If we've taken the trylock branch, then add the lock
int i = 0;
for (CFGBlock::const_succ_iterator SI = PredBlock->succ_begin(),
- SE = PredBlock->succ_end(); SI != SE && i < 2; ++SI, ++i) {
+ SE = PredBlock->succ_end();
+ SI != SE && i < 2; ++SI, ++i) {
if (*SI == CurrBlock && i == branchnum)
getMutexIDs(Mtxs, Attr, Exp, D);
}
@@ -1398,7 +1390,7 @@ static bool getStaticBooleanValue(Expr *E, bool &TCond) {
// If Cond can be traced back to a function call, return the call expression.
// The negate variable should be called with false, and will be set to true
// if the function call is negated, e.g. if (!mu.tryLock(...))
-const CallExpr* ThreadSafetyAnalyzer::getTrylockCallExpr(const Stmt *Cond,
+const CallExpr *ThreadSafetyAnalyzer::getTrylockCallExpr(const Stmt *Cond,
LocalVarContext C,
bool &Negate) {
if (!Cond)
@@ -1408,8 +1400,7 @@ const CallExpr* ThreadSafetyAnalyzer::getTrylockCallExpr(const Stmt *Cond,
if (CallExp->getBuiltinCallee() == Builtin::BI__builtin_expect)
return getTrylockCallExpr(CallExp->getArg(0), C, Negate);
return CallExp;
- }
- else if (const auto *PE = dyn_cast<ParenExpr>(Cond))
+ } else if (const auto *PE = dyn_cast<ParenExpr>(Cond))
return getTrylockCallExpr(PE->getSubExpr(), C, Negate);
else if (const auto *CE = dyn_cast<ImplicitCastExpr>(Cond))
return getTrylockCallExpr(CE->getSubExpr(), C, Negate);
@@ -1418,27 +1409,27 @@ const CallExpr* ThreadSafetyAnalyzer::getTrylockCallExpr(const Stmt *Cond,
else if (const auto *DRE = dyn_cast<DeclRefExpr>(Cond)) {
const Expr *E = LocalVarMap.lookupExpr(DRE->getDecl(), C);
return getTrylockCallExpr(E, C, Negate);
- }
- else if (const auto *UOP = dyn_cast<UnaryOperator>(Cond)) {
+ } else if (const auto *UOP = dyn_cast<UnaryOperator>(Cond)) {
if (UOP->getOpcode() == UO_LNot) {
Negate = !Negate;
return getTrylockCallExpr(UOP->getSubExpr(), C, Negate);
}
return nullptr;
- }
- else if (const auto *BOP = dyn_cast<BinaryOperator>(Cond)) {
+ } else if (const auto *BOP = dyn_cast<BinaryOperator>(Cond)) {
if (BOP->getOpcode() == BO_EQ || BOP->getOpcode() == BO_NE) {
if (BOP->getOpcode() == BO_NE)
Negate = !Negate;
bool TCond = false;
if (getStaticBooleanValue(BOP->getRHS(), TCond)) {
- if (!TCond) Negate = !Negate;
+ if (!TCond)
+ Negate = !Negate;
return getTrylockCallExpr(BOP->getLHS(), C, Negate);
}
TCond = false;
if (getStaticBooleanValue(BOP->getLHS(), TCond)) {
- if (!TCond) Negate = !Negate;
+ if (!TCond)
+ Negate = !Negate;
return getTrylockCallExpr(BOP->getRHS(), C, Negate);
}
return nullptr;
@@ -1468,7 +1459,7 @@ const CallExpr* ThreadSafetyAnalyzer::getTrylockCallExpr(const Stmt *Cond,
/// Find the lockset that holds on the edge between PredBlock
/// and CurrBlock. The edge set is the exit set of PredBlock (passed
/// as the ExitSet parameter) plus any trylocks, which are conditionally held.
-void ThreadSafetyAnalyzer::getEdgeLockset(FactSet& Result,
+void ThreadSafetyAnalyzer::getEdgeLockset(FactSet &Result,
const FactSet &ExitSet,
const CFGBlock *PredBlock,
const CFGBlock *CurrBlock) {
@@ -1488,7 +1479,7 @@ void ThreadSafetyAnalyzer::getEdgeLockset(FactSet& Result,
return;
auto *FunDecl = dyn_cast_or_null<NamedDecl>(Exp->getCalleeDecl());
- if(!FunDecl || !FunDecl->hasAttrs())
+ if (!FunDecl || !FunDecl->hasAttrs())
return;
CapExprSet ExclusiveLocksToAdd;
@@ -1497,27 +1488,27 @@ void ThreadSafetyAnalyzer::getEdgeLockset(FactSet& Result,
// If the condition is a call to a Trylock function, then grab the attributes
for (const auto *Attr : FunDecl->attrs()) {
switch (Attr->getKind()) {
- case attr::TryAcquireCapability: {
- auto *A = cast<TryAcquireCapabilityAttr>(Attr);
- getMutexIDs(A->isShared() ? SharedLocksToAdd : ExclusiveLocksToAdd, A,
- Exp, FunDecl, PredBlock, CurrBlock, A->getSuccessValue(),
- Negate);
- break;
- };
- case attr::ExclusiveTrylockFunction: {
- const auto *A = cast<ExclusiveTrylockFunctionAttr>(Attr);
- getMutexIDs(ExclusiveLocksToAdd, A, Exp, FunDecl, PredBlock, CurrBlock,
- A->getSuccessValue(), Negate);
- break;
- }
- case attr::SharedTrylockFunction: {
- const auto *A = cast<SharedTrylockFunctionAttr>(Attr);
- getMutexIDs(SharedLocksToAdd, A, Exp, FunDecl, PredBlock, CurrBlock,
- A->getSuccessValue(), Negate);
- break;
- }
- default:
- break;
+ case attr::TryAcquireCapability: {
+ auto *A = cast<TryAcquireCapabilityAttr>(Attr);
+ getMutexIDs(A->isShared() ? SharedLocksToAdd : ExclusiveLocksToAdd, A,
+ Exp, FunDecl, PredBlock, CurrBlock, A->getSuccessValue(),
+ Negate);
+ break;
+ };
+ case attr::ExclusiveTrylockFunction: {
+ const auto *A = cast<ExclusiveTrylockFunctionAttr>(Attr);
+ getMutexIDs(ExclusiveLocksToAdd, A, Exp, FunDecl, PredBlock, CurrBlock,
+ A->getSuccessValue(), Negate);
+ break;
+ }
+ case attr::SharedTrylockFunction: {
+ const auto *A = cast<SharedTrylockFunctionAttr>(Attr);
+ getMutexIDs(SharedLocksToAdd, A, Exp, FunDecl, PredBlock, CurrBlock,
+ A->getSuccessValue(), Negate);
+ break;
+ }
+ default:
+ break;
}
}
@@ -1631,7 +1622,7 @@ void ThreadSafetyAnalyzer::warnIfMutexNotHeld(
if (LDat) {
// Warn that there's no precise match.
std::string PartMatchStr = LDat->toString();
- StringRef PartMatchName(PartMatchStr);
+ StringRef PartMatchName(PartMatchStr);
Handler.handleMutexNotHeld(Cp.getKind(), D, POK, Cp.toString(), LK, Loc,
&PartMatchName);
} else {
@@ -1762,7 +1753,8 @@ void ThreadSafetyAnalyzer::checkPtAccess(const FactSet &FSet, const Expr *Exp,
// Pass by reference warnings are under a different flag.
ProtectedOperationKind PtPOK = POK_VarDereference;
- if (POK == POK_PassByRef) PtPOK = POK_PtPassByRef;
+ if (POK == POK_PassByRef)
+ PtPOK = POK_PtPassByRef;
if (POK == POK_ReturnByRef)
PtPOK = POK_PtReturnByRef;
@@ -1820,96 +1812,96 @@ void BuildLockset::handleCall(const Expr *Exp, const NamedDecl *D,
Loc = Exp->getExprLoc();
}
- for(const Attr *At : D->attrs()) {
+ for (const Attr *At : D->attrs()) {
switch (At->getKind()) {
- // When we encounter a lock function, we need to add the lock to our
- // lockset.
- case attr::AcquireCapability: {
- const auto *A = cast<AcquireCapabilityAttr>(At);
- Analyzer->getMutexIDs(A->isShared() ? SharedLocksToAdd
- : ExclusiveLocksToAdd,
- A, Exp, D, Self);
- break;
- }
+ // When we encounter a lock function, we need to add the lock to our
+ // lockset.
+ case attr::AcquireCapability: {
+ const auto *A = cast<AcquireCapabilityAttr>(At);
+ Analyzer->getMutexIDs(A->isShared() ? SharedLocksToAdd
+ : ExclusiveLocksToAdd,
+ A, Exp, D, Self);
+ break;
+ }
- // An assert will add a lock to the lockset, but will not generate
- // a warning if it is already there, and will not generate a warning
- // if it is not removed.
- case attr::AssertExclusiveLock: {
- const auto *A = cast<AssertExclusiveLockAttr>(At);
-
- CapExprSet AssertLocks;
- Analyzer->getMutexIDs(AssertLocks, A, Exp, D, Self);
- for (const auto &AssertLock : AssertLocks)
- Analyzer->addLock(
- FSet, std::make_unique<LockableFactEntry>(
- AssertLock, LK_Exclusive, Loc, FactEntry::Asserted));
- break;
- }
- case attr::AssertSharedLock: {
- const auto *A = cast<AssertSharedLockAttr>(At);
-
- CapExprSet AssertLocks;
- Analyzer->getMutexIDs(AssertLocks, A, Exp, D, Self);
- for (const auto &AssertLock : AssertLocks)
- Analyzer->addLock(
- FSet, std::make_unique<LockableFactEntry>(
- AssertLock, LK_Shared, Loc, FactEntry::Asserted));
- break;
- }
+ // An assert will add a lock to the lockset, but will not generate
+ // a warning if it is already there, and will not generate a warning
+ // if it is not removed.
+ case attr::AssertExclusiveLock: {
+ const auto *A = cast<AssertExclusiveLockAttr>(At);
+
+ CapExprSet AssertLocks;
+ Analyzer->getMutexIDs(AssertLocks, A, Exp, D, Self);
+ for (const auto &AssertLock : AssertLocks)
+ Analyzer->addLock(
+ FSet, std::make_unique<LockableFactEntry>(
+ AssertLock, LK_Exclusive, Loc, FactEntry::Asserted));
+ break;
+ }
+ case attr::AssertSharedLock: {
+ const auto *A = cast<AssertSharedLockAttr>(At);
+
+ CapExprSet AssertLocks;
+ Analyzer->getMutexIDs(AssertLocks, A, Exp, D, Self);
+ for (const auto &AssertLock : AssertLocks)
+ Analyzer->addLock(FSet,
+ std::make_unique<LockableFactEntry>(
+ AssertLock, LK_Shared, Loc, FactEntry::Asserted));
+ break;
+ }
- case attr::AssertCapability: {
- const auto *A = cast<AssertCapabilityAttr>(At);
- CapExprSet AssertLocks;
- Analyzer->getMutexIDs(AssertLocks, A, Exp, D, Self);
- for (const auto &AssertLock : AssertLocks)
- Analyzer->addLock(FSet, std::make_unique<LockableFactEntry>(
- AssertLock,
- A->isShared() ? LK_Shared : LK_Exclusive,
- Loc, FactEntry::Asserted));
- break;
- }
+ case attr::AssertCapability: {
+ const auto *A = cast<AssertCapabilityAttr>(At);
+ CapExprSet AssertLocks;
+ Analyzer->getMutexIDs(AssertLocks, A, Exp, D, Self);
+ for (const auto &AssertLock : AssertLocks)
+ Analyzer->addLock(FSet, std::make_unique<LockableFactEntry>(
+ AssertLock,
+ A->isShared() ? LK_Shared : LK_Exclusive,
+ Loc, FactEntry::Asserted));
+ break;
+ }
- // When we encounter an unlock function, we need to remove unlocked
- // mutexes from the lockset, and flag a warning if they are not there.
- case attr::ReleaseCapability: {
- const auto *A = cast<ReleaseCapabilityAttr>(At);
- if (A->isGeneric())
- Analyzer->getMutexIDs(GenericLocksToRemove, A, Exp, D, Self);
- else if (A->isShared())
- Analyzer->getMutexIDs(SharedLocksToRemove, A, Exp, D, Self);
- else
- Analyzer->getMutexIDs(ExclusiveLocksToRemove, A, Exp, D, Self);
- break;
- }
+ // When we encounter an unlock function, we need to remove unlocked
+ // mutexes from the lockset, and flag a warning if they are not there.
+ case attr::ReleaseCapability: {
+ const auto *A = cast<ReleaseCapabilityAttr>(At);
+ if (A->isGeneric())
+ Analyzer->getMutexIDs(GenericLocksToRemove, A, Exp, D, Self);
+ else if (A->isShared())
+ Analyzer->getMutexIDs(SharedLocksToRemove, A, Exp, D, Self);
+ else
+ Analyzer->getMutexIDs(ExclusiveLocksToRemove, A, Exp, D, Self);
+ break;
+ }
- case attr::RequiresCapability: {
- const auto *A = cast<RequiresCapabilityAttr>(At);
- for (auto *Arg : A->args()) {
- Analyzer->warnIfMutexNotHeld(FSet, D, Exp,
- A->isShared() ? AK_Read : AK_Written,
- Arg, POK_FunctionCall, Self, Loc);
- // use for adopting a lock
- if (!Scp.shouldIgnore())
- Analyzer->getMutexIDs(ScopedReqsAndExcludes, A, Exp, D, Self);
- }
- break;
+ case attr::RequiresCapability: {
+ const auto *A = cast<RequiresCapabilityAttr>(At);
+ for (auto *Arg : A->args()) {
+ Analyzer->warnIfMutexNotHeld(FSet, D, Exp,
+ A->isShared() ? AK_Read : AK_Written, Arg,
+ POK_FunctionCall, Self, Loc);
+ // use for adopting a lock
+ if (!Scp.shouldIgnore())
+ Analyzer->getMutexIDs(ScopedReqsAndExcludes, A, Exp, D, Self);
}
+ break;
+ }
- case attr::LocksExcluded: {
- const auto *A = cast<LocksExcludedAttr>(At);
- for (auto *Arg : A->args()) {
- Analyzer->warnIfMutexHeld(FSet, D, Exp, Arg, Self, Loc);
- // use for deferring a lock
- if (!Scp.shouldIgnore())
- Analyzer->getMutexIDs(ScopedReqsAndExcludes, A, Exp, D, Self);
- }
- break;
+ case attr::LocksExcluded: {
+ const auto *A = cast<LocksExcludedAttr>(At);
+ for (auto *Arg : A->args()) {
+ Analyzer->warnIfMutexHeld(FSet, D, Exp, Arg, Self, Loc);
+ // use for deferring a lock
+ if (!Scp.shouldIgnore())
+ Analyzer->getMutexIDs(ScopedReqsAndExcludes, A, Exp, D, Self);
}
+ break;
+ }
- // Ignore attributes unrelated to thread-safety
- default:
- break;
+ // Ignore attributes unrelated to thread-safety
+ default:
+ break;
}
}
@@ -1955,14 +1947,14 @@ void BuildLockset::handleCall(const Expr *Exp, const NamedDecl *D,
/// VisitCastExpr.
void BuildLockset::VisitUnaryOperator(const UnaryOperator *UO) {
switch (UO->getOpcode()) {
- case UO_PostDec:
- case UO_PostInc:
- case UO_PreDec:
- case UO_PreInc:
- checkAccess(UO->getSubExpr(), AK_Written);
- break;
- default:
- break;
+ case UO_PostDec:
+ case UO_PostInc:
+ case UO_PreDec:
+ case UO_PreInc:
+ checkAccess(UO->getSubExpr(), AK_Written);
+ break;
+ default:
+ break;
}
}
@@ -2038,51 +2030,51 @@ void BuildLockset::VisitCallExpr(const CallExpr *Exp) {
} else if (const auto *OE = dyn_cast<CXXOperatorCallExpr>(Exp)) {
OverloadedOperatorKind OEop = OE->getOperator();
switch (OEop) {
- case OO_Equal:
- case OO_PlusEqual:
- case OO_MinusEqual:
- case OO_StarEqual:
- case OO_SlashEqual:
- case OO_PercentEqual:
- case OO_CaretEqual:
- case OO_AmpEqual:
- case OO_PipeEqual:
- case OO_LessLessEqual:
- case OO_GreaterGreaterEqual:
- checkAccess(OE->getArg(1), AK_Read);
- [[fallthrough]];
- case OO_PlusPlus:
- case OO_MinusMinus:
- checkAccess(OE->getArg(0), AK_Written);
- break;
- case OO_Star:
- case OO_ArrowStar:
- case OO_Arrow:
- case OO_Subscript:
- if (!(OEop == OO_Star && OE->getNumArgs() > 1)) {
- // Grrr. operator* can be multiplication...
- checkPtAccess(OE->getArg(0), AK_Read);
- }
- [[fallthrough]];
- default: {
- // TODO: get rid of this, and rely on pass-by-ref instead.
- const Expr *Obj = OE->getArg(0);
- checkAccess(Obj, AK_Read);
- // Check the remaining arguments. For method operators, the first
- // argument is the implicit self argument, and doesn't appear in the
- // FunctionDecl, but for non-methods it does.
- const FunctionDecl *FD = OE->getDirectCallee();
- examineArguments(FD, std::next(OE->arg_begin()), OE->arg_end(),
- /*SkipFirstParam*/ !isa<CXXMethodDecl>(FD));
- break;
+ case OO_Equal:
+ case OO_PlusEqual:
+ case OO_MinusEqual:
+ case OO_StarEqual:
+ case OO_SlashEqual:
+ case OO_PercentEqual:
+ case OO_CaretEqual:
+ case OO_AmpEqual:
+ case OO_PipeEqual:
+ case OO_LessLessEqual:
+ case OO_GreaterGreaterEqual:
+ checkAccess(OE->getArg(1), AK_Read);
+ [[fallthrough]];
+ case OO_PlusPlus:
+ case OO_MinusMinus:
+ checkAccess(OE->getArg(0), AK_Written);
+ break;
+ case OO_Star:
+ case OO_ArrowStar:
+ case OO_Arrow:
+ case OO_Subscript:
+ if (!(OEop == OO_Star && OE->getNumArgs() > 1)) {
+ // Grrr. operator* can be multiplication...
+ checkPtAccess(OE->getArg(0), AK_Read);
}
+ [[fallthrough]];
+ default: {
+ // TODO: get rid of this, and rely on pass-by-ref instead.
+ const Expr *Obj = OE->getArg(0);
+ checkAccess(Obj, AK_Read);
+ // Check the remaining arguments. For method operators, the first
+ // argument is the implicit self argument, and doesn't appear in the
+ // FunctionDecl, but for non-methods it does.
+ const FunctionDecl *FD = OE->getDirectCallee();
+ examineArguments(FD, std::next(OE->arg_begin()), OE->arg_end(),
+ /*SkipFirstParam*/ !isa<CXXMethodDecl>(FD));
+ break;
+ }
}
} else {
examineArguments(Exp->getDirectCallee(), Exp->arg_begin(), Exp->arg_end());
}
auto *D = dyn_cast_or_null<NamedDecl>(Exp->getCalleeDecl());
- if(!D || !D->hasAttrs())
+ if (!D || !D->hasAttrs())
return;
handleCall(Exp, D);
}
@@ -2090,7 +2082,7 @@ void BuildLockset::VisitCallExpr(const CallExpr *Exp) {
void BuildLockset::VisitCXXConstructExpr(const CXXConstructExpr *Exp) {
const CXXConstructorDecl *D = Exp->getConstructor();
if (D && D->isCopyConstructor()) {
- const Expr* Source = Exp->getArg(0);
+ const Expr *Source = Exp->getArg(0);
checkAccess(Source, AK_Read);
} else {
examineArguments(D, Exp->arg_begin(), Exp->arg_end());
@@ -2287,14 +2279,14 @@ void ThreadSafetyAnalyzer::runAnalysis(AnalysisDeclContext &AC) {
// to 'this', so checks on member variable access is disabled, but we should
// still enable checks on other objects.
if (isa<CXXConstructorDecl>(D))
- return; // Don't check inside constructors.
+ return; // Don't check inside constructors.
if (isa<CXXDestructorDecl>(D))
- return; // Don't check inside destructors.
+ return; // Don't check inside destructors.
Handler.enterFunction(CurrentFunction);
BlockInfo.resize(CFGraph->getNumBlockIDs(),
- CFGBlockInfo::getEmptyBlockInfo(LocalVarMap));
+ CFGBlockInfo::getEmptyBlockInfo(LocalVarMap));
// We need to explore the CFG via a "topological" ordering.
// That way, we will be guaranteed to have information about required
@@ -2303,7 +2295,7 @@ void ThreadSafetyAnalyzer::runAnalysis(AnalysisDeclContext &AC) {
PostOrderCFGView::CFGBlockSet VisitedBlocks(CFGraph);
CFGBlockInfo &Initial = BlockInfo[CFGraph->getEntry().getBlockID()];
- CFGBlockInfo &Final = BlockInfo[CFGraph->getExit().getBlockID()];
+ CFGBlockInfo &Final = BlockInfo[CFGraph->getExit().getBlockID()];
// Mark entry block as reachable
Initial.Reachable = true;
@@ -2414,7 +2406,8 @@ void ThreadSafetyAnalyzer::runAnalysis(AnalysisDeclContext &AC) {
// all code paths.
bool LocksetInitialized = false;
for (CFGBlock::const_pred_iterator PI = CurrBlock->pred_begin(),
- PE = CurrBlock->pred_end(); PI != PE; ++PI) {
+ PE = CurrBlock->pred_end();
+ PI != PE; ++PI) {
// if *PI -> CurrBlock is a back edge
if (*PI == nullptr || !VisitedBlocks.alreadySet(*PI))
continue;
@@ -2456,51 +2449,51 @@ void ThreadSafetyAnalyzer::runAnalysis(AnalysisDeclContext &AC) {
// Visit all the statements in the basic block.
for (const auto &BI : *CurrBlock) {
switch (BI.getKind()) {
- case CFGElement::Statement: {
- CFGStmt CS = BI.castAs<CFGStmt>();
- LocksetBuilder.Visit(CS.getStmt());
- break;
- }
- // Ignore BaseDtor and MemberDtor for now.
- case CFGElement::AutomaticObjectDtor: {
- CFGAutomaticObjDtor AD = BI.castAs<CFGAutomaticObjDtor>();
- const auto *DD = AD.getDestructorDecl(AC.getASTContext());
- if (!DD->hasAttrs())
- break;
-
- LocksetBuilder.handleCall(nullptr, DD,
- SxBuilder.createVariable(AD.getVarDecl()),
- AD.getTriggerStmt()->getEndLoc());
+ case CFGElement::Statement: {
+ CFGStmt CS = BI.castAs<CFGStmt>();
+ LocksetBuilder.Visit(CS.getStmt());
+ break;
+ }
+ // Ignore BaseDtor and MemberDtor for now.
+ case CFGElement::AutomaticObjectDtor: {
+ CFGAutomaticObjDtor AD = BI.castAs<CFGAutomaticObjDtor>();
+ const auto *DD = AD.getDestructorDecl(AC.getASTContext());
+ if (!DD->hasAttrs())
break;
- }
- case CFGElement::CleanupFunction: {
- const CFGCleanupFunction &CF = BI.castAs<CFGCleanupFunction>();
- LocksetBuilder.handleCall(/*Exp=*/nullptr, CF.getFunctionDecl(),
- SxBuilder.createVariable(CF.getVarDecl()),
- CF.getVarDecl()->getLocation());
- break;
- }
+ LocksetBuilder.handleCall(nullptr, DD,
+ SxBuilder.createVariable(AD.getVarDecl()),
+ AD.getTriggerStmt()->getEndLoc());
+ break;
+ }
- case CFGElement::TemporaryDtor: {
- auto TD = BI.castAs<CFGTemporaryDtor>();
-
- // Clean up constructed object even if there are no attributes to
- // keep the number of objects in limbo as small as possible.
- if (auto Object = ConstructedObjects.find(
- TD.getBindTemporaryExpr()->getSubExpr());
- Object != ConstructedObjects.end()) {
- const auto *DD = TD.getDestructorDecl(AC.getASTContext());
- if (DD->hasAttrs())
- // TODO: the location here isn't quite correct.
- LocksetBuilder.handleCall(nullptr, DD, Object->second,
- TD.getBindTemporaryExpr()->getEndLoc());
- ConstructedObjects.erase(Object);
- }
- break;
+ case CFGElement::CleanupFunction: {
+ const CFGCleanupFunction &CF = BI.castAs<CFGCleanupFunction>();
+ LocksetBuilder.handleCall(/*Exp=*/nullptr, CF.getFunctionDecl(),
+ SxBuilder.createVariable(CF.getVarDecl()),
+ CF.getVarDecl()->getLocation());
+ break;
+ }
+
+ case CFGElement::TemporaryDtor: {
+ auto TD = BI.castAs<CFGTemporaryDtor>();
+
+ // Clean up constructed object even if there are no attributes to
+ // keep the number of objects in limbo as small as possible.
+ if (auto Object = ConstructedObjects.find(
+ TD.getBindTemporaryExpr()->getSubExpr());
+ Object != ConstructedObjects.end()) {
+ const auto *DD = TD.getDestructorDecl(AC.getASTContext());
+ if (DD->hasAttrs())
+ // TODO: the location here isn't quite correct.
+ LocksetBuilder.handleCall(nullptr, DD, Object->second,
+ TD.getBindTemporaryExpr()->getEndLoc());
+ ConstructedObjects.erase(Object);
}
- default:
- break;
+ break;
+ }
+ default:
+ break;
}
}
CurrBlockInfo->ExitSet = LocksetBuilder.FSet;
@@ -2510,7 +2503,8 @@ void ThreadSafetyAnalyzer::runAnalysis(AnalysisDeclContext &AC) {
// the one held at the beginning of FirstLoopBlock. We can look up the
// Lockset held at the beginning of FirstLoopBlock in the EntryLockSets map.
for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(),
- SE = CurrBlock->succ_end(); SI != SE; ++SI) {
+ SE = CurrBlock->succ_end();
+ SI != SE; ++SI) {
// if CurrBlock -> *SI is *not* a back edge
if (*SI == nullptr || !VisitedBlocks.alreadySet(*SI))
continue;
@@ -2554,10 +2548,10 @@ void threadSafety::threadSafetyCleanup(BeforeSet *Cache) { delete Cache; }
/// of access.
LockKind threadSafety::getLockKindFromAccessKind(AccessKind AK) {
switch (AK) {
- case AK_Read :
- return LK_Shared;
- case AK_Written :
- return LK_Exclusive;
+ case AK_Read:
+ return LK_Shared;
+ case AK_Written:
+ return LK_Exclusive;
}
llvm_unreachable("Unknown AccessKind");
}
diff --git a/clang/lib/Analysis/ThreadSafetyCommon.cpp b/clang/lib/Analysis/ThreadSafetyCommon.cpp
index 2fe0f85897c3bc..7062e1f074767b 100644
--- a/clang/lib/Analysis/ThreadSafetyCommon.cpp
+++ b/clang/lib/Analysis/ThreadSafetyCommon.cpp
@@ -40,23 +40,23 @@ using namespace threadSafety;
// From ThreadSafetyUtil.h
std::string threadSafety::getSourceLiteralString(const Expr *CE) {
switch (CE->getStmtClass()) {
- case Stmt::IntegerLiteralClass:
- return toString(cast<IntegerLiteral>(CE)->getValue(), 10, true);
- case Stmt::StringLiteralClass: {
- std::string ret("\"");
- ret += cast<StringLiteral>(CE)->getString();
- ret += "\"";
- return ret;
- }
- case Stmt::CharacterLiteralClass:
- case Stmt::CXXNullPtrLiteralExprClass:
- case Stmt::GNUNullExprClass:
- case Stmt::CXXBoolLiteralExprClass:
- case Stmt::FloatingLiteralClass:
- case Stmt::ImaginaryLiteralClass:
- case Stmt::ObjCStringLiteralClass:
- default:
- return "#lit";
+ case Stmt::IntegerLiteralClass:
+ return toString(cast<IntegerLiteral>(CE)->getValue(), 10, true);
+ case Stmt::StringLiteralClass: {
+ std::string ret("\"");
+ ret += cast<StringLiteral>(CE)->getString();
+ ret += "\"";
+ return ret;
+ }
+ case Stmt::CharacterLiteralClass:
+ case Stmt::CXXNullPtrLiteralExprClass:
+ case Stmt::GNUNullExprClass:
+ case Stmt::CXXBoolLiteralExprClass:
+ case Stmt::FloatingLiteralClass:
+ case Stmt::ImaginaryLiteralClass:
+ case Stmt::ObjCStringLiteralClass:
+ default:
+ return "#lit";
}
}
@@ -127,18 +127,18 @@ CapabilityExpr SExprBuilder::translateAttrExpr(const Expr *AttrExp,
if (!DeclExp)
/* We'll use Self. */;
else if (const auto *ME = dyn_cast<MemberExpr>(DeclExp)) {
- Ctx.SelfArg = ME->getBase();
+ Ctx.SelfArg = ME->getBase();
Ctx.SelfArrow = ME->isArrow();
} else if (const auto *CE = dyn_cast<CXXMemberCallExpr>(DeclExp)) {
- Ctx.SelfArg = CE->getImplicitObjectArgument();
+ Ctx.SelfArg = CE->getImplicitObjectArgument();
Ctx.SelfArrow = isCalleeArrow(CE->getCallee());
- Ctx.NumArgs = CE->getNumArgs();
- Ctx.FunArgs = CE->getArgs();
+ Ctx.NumArgs = CE->getNumArgs();
+ Ctx.FunArgs = CE->getArgs();
} else if (const auto *CE = dyn_cast<CallExpr>(DeclExp)) {
Ctx.NumArgs = CE->getNumArgs();
Ctx.FunArgs = CE->getArgs();
} else if (const auto *CE = dyn_cast<CXXConstructExpr>(DeclExp)) {
- Ctx.SelfArg = nullptr; // Will be set below
+ Ctx.SelfArg = nullptr; // Will be set below
Ctx.NumArgs = CE->getNumArgs();
Ctx.FunArgs = CE->getArgs();
}
@@ -158,14 +158,14 @@ CapabilityExpr SExprBuilder::translateAttrExpr(const Expr *AttrExp,
ClassifyDiagnostic(
cast<CXXMethodDecl>(D)->getFunctionObjectParameterType()),
false);
- else // For most attributes.
+ else // For most attributes.
return translateAttrExpr(AttrExp, &Ctx);
}
// If the attribute has no arguments, then assume the argument is "this".
if (!AttrExp)
return translateAttrExpr(cast<const Expr *>(Ctx.SelfArg), nullptr);
- else // For most attributes.
+ else // For most attributes.
return translateAttrExpr(AttrExp, &Ctx);
}
@@ -176,7 +176,7 @@ CapabilityExpr SExprBuilder::translateAttrExpr(const Expr *AttrExp,
if (!AttrExp)
return CapabilityExpr();
- if (const auto* SLit = dyn_cast<StringLiteral>(AttrExp)) {
+ if (const auto *SLit = dyn_cast<StringLiteral>(AttrExp)) {
if (SLit->getString() == StringRef("*"))
// The "*" expr is a universal lock, which essentially turns off
// checks until it is removed from the lockset.
@@ -193,8 +193,7 @@ CapabilityExpr SExprBuilder::translateAttrExpr(const Expr *AttrExp,
Neg = true;
AttrExp = OE->getArg(0);
}
- }
- else if (const auto *UO = dyn_cast<UnaryOperator>(AttrExp)) {
+ } else if (const auto *UO = dyn_cast<UnaryOperator>(AttrExp)) {
if (UO->getOpcode() == UO_LNot) {
Neg = true;
AttrExp = UO->getSubExpr();
@@ -264,11 +263,11 @@ til::SExpr *SExprBuilder::translate(const Stmt *S, CallingContext *Ctx) {
case Stmt::ArraySubscriptExprClass:
return translateArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Ctx);
case Stmt::ConditionalOperatorClass:
- return translateAbstractConditionalOperator(
- cast<ConditionalOperator>(S), Ctx);
+ return translateAbstractConditionalOperator(cast<ConditionalOperator>(S),
+ Ctx);
case Stmt::BinaryConditionalOperatorClass:
return translateAbstractConditionalOperator(
- cast<BinaryConditionalOperator>(S), Ctx);
+ cast<BinaryConditionalOperator>(S), Ctx);
// We treat these as no-ops
case Stmt::ConstantExprClass:
@@ -381,7 +380,7 @@ static const CXXMethodDecl *getFirstVirtualDecl(const CXXMethodDecl *D) {
D = D->getCanonicalDecl();
auto OverriddenMethods = D->overridden_methods();
if (OverriddenMethods.begin() == OverriddenMethods.end())
- return D; // Method does not override anything
+ return D; // Method does not override anything
// FIXME: this does not work with multiple inheritance.
D = *OverriddenMethods.begin();
}
@@ -391,7 +390,7 @@ static const CXXMethodDecl *getFirstVirtualDecl(const CXXMethodDecl *D) {
til::SExpr *SExprBuilder::translateMemberExpr(const MemberExpr *ME,
CallingContext *Ctx) {
til::SExpr *BE = translate(ME->getBase(), Ctx);
- til::SExpr *E = new (Arena) til::SApply(BE);
+ til::SExpr *E = new (Arena) til::SApply(BE);
const auto *D = cast<ValueDecl>(ME->getMemberDecl()->getCanonicalDecl());
if (const auto *VD = dyn_cast<CXXMethodDecl>(D))
@@ -443,8 +442,9 @@ til::SExpr *SExprBuilder::translateCallExpr(const CallExpr *CE,
return new (Arena) til::Call(E, CE);
}
-til::SExpr *SExprBuilder::translateCXXMemberCallExpr(
- const CXXMemberCallExpr *ME, CallingContext *Ctx) {
+til::SExpr *
+SExprBuilder::translateCXXMemberCallExpr(const CXXMemberCallExpr *ME,
+ CallingContext *Ctx) {
if (CapabilityExprMode) {
// Ignore calls to get() on smart pointers.
if (ME->getMethodDecl()->getNameAsString() == "get" &&
@@ -458,8 +458,9 @@ til::SExpr *SExprBuilder::translateCXXMemberCallExpr(
ME->getImplicitObjectArgument());
}
-til::SExpr *SExprBuilder::translateCXXOperatorCallExpr(
- const CXXOperatorCallExpr *OCE, CallingContext *Ctx) {
+til::SExpr *
+SExprBuilder::translateCXXOperatorCallExpr(const CXXOperatorCallExpr *OCE,
+ CallingContext *Ctx) {
if (CapabilityExprMode) {
// Ignore operator * and operator -> on smart pointers.
OverloadedOperatorKind k = OCE->getOperator();
@@ -503,13 +504,13 @@ til::SExpr *SExprBuilder::translateUnaryOperator(const UnaryOperator *UO,
case UO_Minus:
return new (Arena)
- til::UnaryOp(til::UOP_Minus, translate(UO->getSubExpr(), Ctx));
+ til::UnaryOp(til::UOP_Minus, translate(UO->getSubExpr(), Ctx));
case UO_Not:
return new (Arena)
- til::UnaryOp(til::UOP_BitNot, translate(UO->getSubExpr(), Ctx));
+ til::UnaryOp(til::UOP_BitNot, translate(UO->getSubExpr(), Ctx));
case UO_LNot:
return new (Arena)
- til::UnaryOp(til::UOP_LogicNot, translate(UO->getSubExpr(), Ctx));
+ til::UnaryOp(til::UOP_LogicNot, translate(UO->getSubExpr(), Ctx));
// Currently unsupported
case UO_Real:
@@ -524,18 +525,17 @@ til::SExpr *SExprBuilder::translateUnaryOperator(const UnaryOperator *UO,
til::SExpr *SExprBuilder::translateBinOp(til::TIL_BinaryOpcode Op,
const BinaryOperator *BO,
CallingContext *Ctx, bool Reverse) {
- til::SExpr *E0 = translate(BO->getLHS(), Ctx);
- til::SExpr *E1 = translate(BO->getRHS(), Ctx);
- if (Reverse)
- return new (Arena) til::BinaryOp(Op, E1, E0);
- else
- return new (Arena) til::BinaryOp(Op, E0, E1);
+ til::SExpr *E0 = translate(BO->getLHS(), Ctx);
+ til::SExpr *E1 = translate(BO->getRHS(), Ctx);
+ if (Reverse)
+ return new (Arena) til::BinaryOp(Op, E1, E0);
+ else
+ return new (Arena) til::BinaryOp(Op, E0, E1);
}
til::SExpr *SExprBuilder::translateBinAssign(til::TIL_BinaryOpcode Op,
const BinaryOperator *BO,
- CallingContext *Ctx,
- bool Assign) {
+ CallingContext *Ctx, bool Assign) {
const Expr *LHS = BO->getLHS();
const Expr *RHS = BO->getRHS();
til::SExpr *E0 = translate(LHS, Ctx);
@@ -565,37 +565,67 @@ til::SExpr *SExprBuilder::translateBinaryOperator(const BinaryOperator *BO,
case BO_PtrMemI:
return new (Arena) til::Undefined(BO);
- case BO_Mul: return translateBinOp(til::BOP_Mul, BO, Ctx);
- case BO_Div: return translateBinOp(til::BOP_Div, BO, Ctx);
- case BO_Rem: return translateBinOp(til::BOP_Rem, BO, Ctx);
- case BO_Add: return translateBinOp(til::BOP_Add, BO, Ctx);
- case BO_Sub: return translateBinOp(til::BOP_Sub, BO, Ctx);
- case BO_Shl: return translateBinOp(til::BOP_Shl, BO, Ctx);
- case BO_Shr: return translateBinOp(til::BOP_Shr, BO, Ctx);
- case BO_LT: return translateBinOp(til::BOP_Lt, BO, Ctx);
- case BO_GT: return translateBinOp(til::BOP_Lt, BO, Ctx, true);
- case BO_LE: return translateBinOp(til::BOP_Leq, BO, Ctx);
- case BO_GE: return translateBinOp(til::BOP_Leq, BO, Ctx, true);
- case BO_EQ: return translateBinOp(til::BOP_Eq, BO, Ctx);
- case BO_NE: return translateBinOp(til::BOP_Neq, BO, Ctx);
- case BO_Cmp: return translateBinOp(til::BOP_Cmp, BO, Ctx);
- case BO_And: return translateBinOp(til::BOP_BitAnd, BO, Ctx);
- case BO_Xor: return translateBinOp(til::BOP_BitXor, BO, Ctx);
- case BO_Or: return translateBinOp(til::BOP_BitOr, BO, Ctx);
- case BO_LAnd: return translateBinOp(til::BOP_LogicAnd, BO, Ctx);
- case BO_LOr: return translateBinOp(til::BOP_LogicOr, BO, Ctx);
-
- case BO_Assign: return translateBinAssign(til::BOP_Eq, BO, Ctx, true);
- case BO_MulAssign: return translateBinAssign(til::BOP_Mul, BO, Ctx);
- case BO_DivAssign: return translateBinAssign(til::BOP_Div, BO, Ctx);
- case BO_RemAssign: return translateBinAssign(til::BOP_Rem, BO, Ctx);
- case BO_AddAssign: return translateBinAssign(til::BOP_Add, BO, Ctx);
- case BO_SubAssign: return translateBinAssign(til::BOP_Sub, BO, Ctx);
- case BO_ShlAssign: return translateBinAssign(til::BOP_Shl, BO, Ctx);
- case BO_ShrAssign: return translateBinAssign(til::BOP_Shr, BO, Ctx);
- case BO_AndAssign: return translateBinAssign(til::BOP_BitAnd, BO, Ctx);
- case BO_XorAssign: return translateBinAssign(til::BOP_BitXor, BO, Ctx);
- case BO_OrAssign: return translateBinAssign(til::BOP_BitOr, BO, Ctx);
+ case BO_Mul:
+ return translateBinOp(til::BOP_Mul, BO, Ctx);
+ case BO_Div:
+ return translateBinOp(til::BOP_Div, BO, Ctx);
+ case BO_Rem:
+ return translateBinOp(til::BOP_Rem, BO, Ctx);
+ case BO_Add:
+ return translateBinOp(til::BOP_Add, BO, Ctx);
+ case BO_Sub:
+ return translateBinOp(til::BOP_Sub, BO, Ctx);
+ case BO_Shl:
+ return translateBinOp(til::BOP_Shl, BO, Ctx);
+ case BO_Shr:
+ return translateBinOp(til::BOP_Shr, BO, Ctx);
+ case BO_LT:
+ return translateBinOp(til::BOP_Lt, BO, Ctx);
+ case BO_GT:
+ return translateBinOp(til::BOP_Lt, BO, Ctx, true);
+ case BO_LE:
+ return translateBinOp(til::BOP_Leq, BO, Ctx);
+ case BO_GE:
+ return translateBinOp(til::BOP_Leq, BO, Ctx, true);
+ case BO_EQ:
+ return translateBinOp(til::BOP_Eq, BO, Ctx);
+ case BO_NE:
+ return translateBinOp(til::BOP_Neq, BO, Ctx);
+ case BO_Cmp:
+ return translateBinOp(til::BOP_Cmp, BO, Ctx);
+ case BO_And:
+ return translateBinOp(til::BOP_BitAnd, BO, Ctx);
+ case BO_Xor:
+ return translateBinOp(til::BOP_BitXor, BO, Ctx);
+ case BO_Or:
+ return translateBinOp(til::BOP_BitOr, BO, Ctx);
+ case BO_LAnd:
+ return translateBinOp(til::BOP_LogicAnd, BO, Ctx);
+ case BO_LOr:
+ return translateBinOp(til::BOP_LogicOr, BO, Ctx);
+
+ case BO_Assign:
+ return translateBinAssign(til::BOP_Eq, BO, Ctx, true);
+ case BO_MulAssign:
+ return translateBinAssign(til::BOP_Mul, BO, Ctx);
+ case BO_DivAssign:
+ return translateBinAssign(til::BOP_Div, BO, Ctx);
+ case BO_RemAssign:
+ return translateBinAssign(til::BOP_Rem, BO, Ctx);
+ case BO_AddAssign:
+ return translateBinAssign(til::BOP_Add, BO, Ctx);
+ case BO_SubAssign:
+ return translateBinAssign(til::BOP_Sub, BO, Ctx);
+ case BO_ShlAssign:
+ return translateBinAssign(til::BOP_Shl, BO, Ctx);
+ case BO_ShrAssign:
+ return translateBinAssign(til::BOP_Shr, BO, Ctx);
+ case BO_AndAssign:
+ return translateBinAssign(til::BOP_BitAnd, BO, Ctx);
+ case BO_XorAssign:
+ return translateBinAssign(til::BOP_BitXor, BO, Ctx);
+ case BO_OrAssign:
+ return translateBinAssign(til::BOP_BitOr, BO, Ctx);
case BO_Comma:
// The clang CFG should have already processed both sides.
@@ -645,8 +675,7 @@ SExprBuilder::translateArraySubscriptExpr(const ArraySubscriptExpr *E,
return new (Arena) til::ArrayIndex(E0, E1);
}
-til::SExpr *
-SExprBuilder::translateAbstractConditionalOperator(
+til::SExpr *SExprBuilder::translateAbstractConditionalOperator(
const AbstractConditionalOperator *CO, CallingContext *Ctx) {
auto *C = translate(CO->getCond(), Ctx);
auto *T = translate(CO->getTrueExpr(), Ctx);
@@ -654,13 +683,13 @@ SExprBuilder::translateAbstractConditionalOperator(
return new (Arena) til::IfThenElse(C, T, E);
}
-til::SExpr *
-SExprBuilder::translateDeclStmt(const DeclStmt *S, CallingContext *Ctx) {
+til::SExpr *SExprBuilder::translateDeclStmt(const DeclStmt *S,
+ CallingContext *Ctx) {
DeclGroupRef DGrp = S->getDeclGroup();
for (auto *I : DGrp) {
if (auto *VD = dyn_cast_or_null<VarDecl>(I)) {
Expr *E = VD->getInit();
- til::SExpr* SE = translate(E, Ctx);
+ til::SExpr *SE = translate(E, Ctx);
// Add local variables with trivial type to the variable map
QualType T = VD->getType();
@@ -678,7 +707,7 @@ SExprBuilder::translateDeclStmt(const DeclStmt *S, CallingContext *Ctx) {
// update the statement map so that S refers to E. Returns a new variable
// that refers to E.
// If E is trivial returns E.
-til::SExpr *SExprBuilder::addStatement(til::SExpr* E, const Stmt *S,
+til::SExpr *SExprBuilder::addStatement(til::SExpr *E, const Stmt *S,
const ValueDecl *VD) {
if (!E || !CurrentBB || E->block() || til::ThreadSafetyTIL::isTrivial(E))
return E;
@@ -725,7 +754,7 @@ til::SExpr *SExprBuilder::updateVarDecl(const ValueDecl *VD, til::SExpr *E) {
auto It = LVarIdxMap.find(VD);
if (It == LVarIdxMap.end()) {
til::SExpr *Ptr = new (Arena) til::LiteralPtr(VD);
- til::SExpr *St = new (Arena) til::Store(Ptr, E);
+ til::SExpr *St = new (Arena) til::Store(Ptr, E);
return St;
}
CurrentLVarMap.makeWritable();
@@ -785,12 +814,12 @@ void SExprBuilder::mergeEntryMap(LVarDefinitionMap Map) {
return;
}
if (CurrentLVarMap.sameAs(Map))
- return; // Easy merge: maps from different predecessors are unchanged.
+ return; // Easy merge: maps from different predecessors are unchanged.
unsigned NPreds = CurrentBB->numPredecessors();
unsigned ESz = CurrentLVarMap.size();
unsigned MSz = Map.size();
- unsigned Sz = std::min(ESz, MSz);
+ unsigned Sz = std::min(ESz, MSz);
for (unsigned i = 0; i < Sz; ++i) {
if (CurrentLVarMap[i].first != Map[i].first) {
@@ -880,7 +909,7 @@ void SExprBuilder::enterCFG(CFG *Cfg, const NamedDecl *D,
// FIXME: right now we emulate params with loads; that should be fixed.
til::SExpr *Lp = new (Arena) til::LiteralPtr(Pm);
til::SExpr *Ld = new (Arena) til::Load(Lp);
- til::SExpr *V = addStatement(Ld, nullptr, Pm);
+ til::SExpr *V = addStatement(Ld, nullptr, Pm);
addVarDecl(Pm, V);
}
}
@@ -920,8 +949,8 @@ void SExprBuilder::handlePredecessorBackEdge(const CFGBlock *Pred) {
void SExprBuilder::enterCFGBlockBody(const CFGBlock *B) {
// The merge*() methods have created arguments.
// Push those arguments onto the basic block.
- CurrentBB->arguments().reserve(
- static_cast<unsigned>(CurrentArguments.size()), Arena);
+ CurrentBB->arguments().reserve(static_cast<unsigned>(CurrentArguments.size()),
+ Arena);
for (auto *A : CurrentArguments)
CurrentBB->addArgument(A);
}
@@ -942,7 +971,7 @@ void SExprBuilder::handleDestructorCall(const VarDecl *VD,
void SExprBuilder::exitCFGBlockBody(const CFGBlock *B) {
CurrentBB->instructions().reserve(
- static_cast<unsigned>(CurrentInstructions.size()), Arena);
+ static_cast<unsigned>(CurrentInstructions.size()), Arena);
for (auto *V : CurrentInstructions)
CurrentBB->addInstruction(V);
@@ -955,8 +984,7 @@ void SExprBuilder::exitCFGBlockBody(const CFGBlock *B) {
unsigned Idx = BB ? BB->findPredecessorIndex(CurrentBB) : 0;
auto *Tm = new (Arena) til::Goto(BB, Idx);
CurrentBB->setTerminator(Tm);
- }
- else if (N == 2) {
+ } else if (N == 2) {
til::SExpr *C = translate(B->getTerminatorCondition(true), nullptr);
til::BasicBlock *BB1 = *It ? lookupBlock(*It) : nullptr;
++It;
diff --git a/clang/lib/Analysis/ThreadSafetyLogical.cpp b/clang/lib/Analysis/ThreadSafetyLogical.cpp
index ac730770093e40..c1e1d23f5ab553 100644
--- a/clang/lib/Analysis/ThreadSafetyLogical.cpp
+++ b/clang/lib/Analysis/ThreadSafetyLogical.cpp
@@ -106,6 +106,6 @@ bool implies(const LExpr *LHS, const LExpr *RHS) {
// Start out by assuming that LHS and RHS are not negated.
return ::implies(LHS, false, RHS, false);
}
-}
-}
-}
+} // namespace lexpr
+} // namespace threadSafety
+} // namespace clang
diff --git a/clang/lib/Analysis/ThreadSafetyTIL.cpp b/clang/lib/Analysis/ThreadSafetyTIL.cpp
index 652f953d2a6db5..b9642e904e6dc6 100644
--- a/clang/lib/Analysis/ThreadSafetyTIL.cpp
+++ b/clang/lib/Analysis/ThreadSafetyTIL.cpp
@@ -18,37 +18,57 @@ using namespace til;
StringRef til::getUnaryOpcodeString(TIL_UnaryOpcode Op) {
switch (Op) {
- case UOP_Minus: return "-";
- case UOP_BitNot: return "~";
- case UOP_LogicNot: return "!";
+ case UOP_Minus:
+ return "-";
+ case UOP_BitNot:
+ return "~";
+ case UOP_LogicNot:
+ return "!";
}
return {};
}
StringRef til::getBinaryOpcodeString(TIL_BinaryOpcode Op) {
switch (Op) {
- case BOP_Mul: return "*";
- case BOP_Div: return "/";
- case BOP_Rem: return "%";
- case BOP_Add: return "+";
- case BOP_Sub: return "-";
- case BOP_Shl: return "<<";
- case BOP_Shr: return ">>";
- case BOP_BitAnd: return "&";
- case BOP_BitXor: return "^";
- case BOP_BitOr: return "|";
- case BOP_Eq: return "==";
- case BOP_Neq: return "!=";
- case BOP_Lt: return "<";
- case BOP_Leq: return "<=";
- case BOP_Cmp: return "<=>";
- case BOP_LogicAnd: return "&&";
- case BOP_LogicOr: return "||";
+ case BOP_Mul:
+ return "*";
+ case BOP_Div:
+ return "/";
+ case BOP_Rem:
+ return "%";
+ case BOP_Add:
+ return "+";
+ case BOP_Sub:
+ return "-";
+ case BOP_Shl:
+ return "<<";
+ case BOP_Shr:
+ return ">>";
+ case BOP_BitAnd:
+ return "&";
+ case BOP_BitXor:
+ return "^";
+ case BOP_BitOr:
+ return "|";
+ case BOP_Eq:
+ return "==";
+ case BOP_Neq:
+ return "!=";
+ case BOP_Lt:
+ return "<";
+ case BOP_Leq:
+ return "<=";
+ case BOP_Cmp:
+ return "<=>";
+ case BOP_LogicAnd:
+ return "&&";
+ case BOP_LogicOr:
+ return "||";
}
return {};
}
-SExpr* Future::force() {
+SExpr *Future::force() {
Status = FS_evaluating;
Result = compute();
Status = FS_done;
@@ -140,9 +160,9 @@ void til::simplifyIncompleteArg(til::Phi *Ph) {
for (unsigned i = 1, n = Ph->values().size(); i < n; ++i) {
SExpr *Ei = simplifyToCanonicalVal(Ph->values()[i]);
if (Ei == Ph)
- continue; // Recursive reference to itself. Don't count.
+ continue; // Recursive reference to itself. Don't count.
if (Ei != E0) {
- return; // Status is already set to MultiVal.
+ return; // Status is already set to MultiVal.
}
}
Ph->setStatus(Phi::PH_SingleVal);
@@ -164,7 +184,8 @@ unsigned BasicBlock::renumberInstrs(unsigned ID) {
// block, and ID should be the total number of blocks.
unsigned BasicBlock::topologicalSort(SimpleArray<BasicBlock *> &Blocks,
unsigned ID) {
- if (Visited) return ID;
+ if (Visited)
+ return ID;
Visited = true;
for (auto *Block : successors())
ID = Block->topologicalSort(Blocks, ID);
@@ -190,7 +211,8 @@ unsigned BasicBlock::topologicalFinalSort(SimpleArray<BasicBlock *> &Blocks,
unsigned ID) {
// Visited is assumed to have been set by the topologicalSort. This pass
// assumes !Visited means that we've visited this node before.
- if (!Visited) return ID;
+ if (!Visited)
+ return ID;
Visited = false;
if (DominatorNode.Parent)
ID = DominatorNode.Parent->topologicalFinalSort(Blocks, ID);
@@ -210,7 +232,8 @@ void BasicBlock::computeDominator() {
// Walk backwards from each predecessor to find the common dominator node.
for (auto *Pred : Predecessors) {
// Skip back-edges
- if (Pred->BlockID >= BlockID) continue;
+ if (Pred->BlockID >= BlockID)
+ continue;
// If we don't yet have a candidate for dominator yet, take this one.
if (Candidate == nullptr) {
Candidate = Pred;
@@ -237,7 +260,8 @@ void BasicBlock::computePostDominator() {
// Walk back from each predecessor to find the common post-dominator node.
for (auto *Succ : successors()) {
// Skip back-edges
- if (Succ->BlockID <= BlockID) continue;
+ if (Succ->BlockID <= BlockID)
+ continue;
// If we don't yet have a candidate for post-dominator yet, take this one.
if (Candidate == nullptr) {
Candidate = Succ;
@@ -279,7 +303,7 @@ static inline void computeNodeID(BasicBlock *B,
BasicBlock::TopologyNode *N = &(B->*TN);
if (N->Parent) {
BasicBlock::TopologyNode *P = &(N->Parent->*TN);
- N->NodeID += P->NodeID; // Fix NodeIDs relative to starting node.
+ N->NodeID += P->NodeID; // Fix NodeIDs relative to starting node.
}
}
@@ -308,7 +332,7 @@ void SCFG::computeNormalForm() {
// Once dominators have been computed, the final sort may be performed.
unsigned NumBlocks = Exit->topologicalFinalSort(Blocks, 0);
assert(static_cast<size_t>(NumBlocks) == Blocks.size());
- (void) NumBlocks;
+ (void)NumBlocks;
// Renumber the instructions now that we have a final sort.
renumberInstrs();
diff --git a/clang/lib/Analysis/UninitializedValues.cpp b/clang/lib/Analysis/UninitializedValues.cpp
index e9111ded64eb1f..2788a48738276b 100644
--- a/clang/lib/Analysis/UninitializedValues.cpp
+++ b/clang/lib/Analysis/UninitializedValues.cpp
@@ -64,7 +64,8 @@ static bool isTrackedVar(const VarDecl *vd, const DeclContext *dc) {
QualType ty = vd->getType();
if (const auto *RD = ty->getAsRecordDecl())
return recordIsNotEmpty(RD);
- return ty->isScalarType() || ty->isVectorType() || ty->isRVVSizelessBuiltinType();
+ return ty->isScalarType() || ty->isVectorType() ||
+ ty->isRVVSizelessBuiltinType();
}
return false;
}
@@ -96,8 +97,8 @@ class DeclToIndex {
void DeclToIndex::computeMap(const DeclContext &dc) {
unsigned count = 0;
DeclContext::specific_decl_iterator<VarDecl> I(dc.decls_begin()),
- E(dc.decls_end());
- for ( ; I != E; ++I) {
+ E(dc.decls_end());
+ for (; I != E; ++I) {
const VarDecl *vd = *I;
if (isTrackedVar(vd, &dc))
map[vd] = count++;
@@ -117,18 +118,16 @@ std::optional<unsigned> DeclToIndex::getValueIndex(const VarDecl *d) const {
// These values are defined in such a way that a merge can be done using
// a bitwise OR.
-enum Value { Unknown = 0x0, /* 00 */
- Initialized = 0x1, /* 01 */
- Uninitialized = 0x2, /* 10 */
- MayUninitialized = 0x3 /* 11 */ };
+enum Value {
+ Unknown = 0x0, /* 00 */
+ Initialized = 0x1, /* 01 */
+ Uninitialized = 0x2, /* 10 */
+ MayUninitialized = 0x3 /* 11 */
+};
-static bool isUninitialized(const Value v) {
- return v >= Uninitialized;
-}
+static bool isUninitialized(const Value v) { return v >= Uninitialized; }
-static bool isAlwaysUninit(const Value v) {
- return v == Uninitialized;
-}
+static bool isAlwaysUninit(const Value v) { return v == Uninitialized; }
namespace {
@@ -155,9 +154,7 @@ class CFGBlockValues {
void mergeIntoScratch(ValueVector const &source, bool isFirst);
bool updateValueVectorWithScratch(const CFGBlock *block);
- bool hasNoDeclarations() const {
- return declToIndex.size() == 0;
- }
+ bool hasNoDeclarations() const { return declToIndex.size() == 0; }
void resetScratch();
@@ -187,8 +184,7 @@ void CFGBlockValues::computeSetOfDeclarations(const DeclContext &dc) {
}
#if DEBUG_LOGGING
-static void printVector(const CFGBlock *block, ValueVector &bv,
- unsigned num) {
+static void printVector(const CFGBlock *block, ValueVector &bv, unsigned num) {
llvm::errs() << block->getBlockID() << " :";
for (const auto &i : bv)
llvm::errs() << ' ' << i;
@@ -201,8 +197,7 @@ void CFGBlockValues::setAllScratchValues(Value V) {
scratch[I] = V;
}
-void CFGBlockValues::mergeIntoScratch(ValueVector const &source,
- bool isFirst) {
+void CFGBlockValues::mergeIntoScratch(ValueVector const &source, bool isFirst) {
if (isFirst)
scratch = source;
else
@@ -220,9 +215,7 @@ bool CFGBlockValues::updateValueVectorWithScratch(const CFGBlock *block) {
return changed;
}
-void CFGBlockValues::resetScratch() {
- scratch.reset();
-}
+void CFGBlockValues::resetScratch() { scratch.reset(); }
ValueVector::reference CFGBlockValues::operator[](const VarDecl *vd) {
return scratch[*declToIndex.getValueIndex(vd)];
@@ -279,21 +272,13 @@ namespace {
/// escaped the analysis and will be treated as an initialization.
class ClassifyRefs : public StmtVisitor<ClassifyRefs> {
public:
- enum Class {
- Init,
- Use,
- SelfInit,
- ConstRefUse,
- Ignore
- };
+ enum Class { Init, Use, SelfInit, ConstRefUse, Ignore };
private:
const DeclContext *DC;
llvm::DenseMap<const DeclRefExpr *, Class> Classification;
- bool isTrackedVar(const VarDecl *VD) const {
- return ::isTrackedVar(VD, DC);
- }
+ bool isTrackedVar(const VarDecl *VD) const { return ::isTrackedVar(VD, DC); }
void classify(const Expr *E, Class C);
@@ -310,8 +295,8 @@ class ClassifyRefs : public StmtVisitor<ClassifyRefs> {
void operator()(Stmt *S) { Visit(S); }
Class get(const DeclRefExpr *DRE) const {
- llvm::DenseMap<const DeclRefExpr*, Class>::const_iterator I
- = Classification.find(DRE);
+ llvm::DenseMap<const DeclRefExpr *, Class>::const_iterator I =
+ Classification.find(DRE);
if (I != Classification.end())
return I->second;
@@ -443,8 +428,8 @@ void ClassifyRefs::VisitCallExpr(CallExpr *CE) {
// conservatively do not assume that it is used.
// If a value is passed by const reference to a function,
// it should already be initialized.
- for (CallExpr::arg_iterator I = CE->arg_begin(), E = CE->arg_end();
- I != E; ++I) {
+ for (CallExpr::arg_iterator I = CE->arg_begin(), E = CE->arg_end(); I != E;
+ ++I) {
if ((*I)->isGLValue()) {
if ((*I)->getType().isConstQualified())
classify((*I), isTrivialBody ? Ignore : ConstRefUse);
@@ -487,9 +472,8 @@ class TransferFunctions : public StmtVisitor<TransferFunctions> {
UninitVariablesHandler &handler;
public:
- TransferFunctions(CFGBlockValues &vals, const CFG &cfg,
- const CFGBlock *block, AnalysisDeclContext &ac,
- const ClassifyRefs &classification,
+ TransferFunctions(CFGBlockValues &vals, const CFG &cfg, const CFGBlock *block,
+ AnalysisDeclContext &ac, const ClassifyRefs &classification,
UninitVariablesHandler &handler)
: vals(vals), cfg(cfg), block(block), ac(ac),
classification(classification), objCNoRet(ac.getASTContext()),
@@ -569,7 +553,7 @@ class TransferFunctions : public StmtVisitor<TransferFunctions> {
// 'n' is definitely uninitialized for two edges into block 7 (from blocks 2
// and 4), so we report that any time either of those edges is taken (in
// each case when 'b == false'), 'n' is used uninitialized.
- SmallVector<const CFGBlock*, 32> Queue;
+ SmallVector<const CFGBlock *, 32> Queue;
SmallVector<unsigned, 32> SuccsVisited(cfg.getNumBlockIDs(), 0);
Queue.push_back(block);
// Specify that we've already visited all successors of the starting block.
@@ -633,7 +617,8 @@ class TransferFunctions : public StmtVisitor<TransferFunctions> {
// to a post-dominator block, and the variable is uninitialized on that
// edge, we have found a bug.
for (CFGBlock::const_succ_iterator I = Block->succ_begin(),
- E = Block->succ_end(); I != E; ++I) {
+ E = Block->succ_end();
+ I != E; ++I) {
const CFGBlock *Succ = *I;
if (Succ && SuccsVisited[Succ->getBlockID()] >= Succ->succ_size() &&
vals.getValue(Block, Succ, vd) == Uninitialized) {
@@ -721,8 +706,7 @@ void TransferFunctions::VisitCallExpr(CallExpr *ce) {
// mark variables as initialized if they have an initializer which is
// reachable from here.
vals.setAllScratchValues(Initialized);
- }
- else if (Callee->hasAttr<AnalyzerNoReturnAttr>()) {
+ } else if (Callee->hasAttr<AnalyzerNoReturnAttr>()) {
// Functions labeled like "analyzer_noreturn" are often used to denote
// "panic" functions that in special debug situations can still return,
// but for the most part should not be treated as returning. This is a
@@ -843,7 +827,8 @@ static bool runOnBlock(const CFGBlock *block, const CFG &cfg,
// Merge in values of predecessor blocks.
bool isFirst = true;
for (CFGBlock::const_pred_iterator I = block->pred_begin(),
- E = block->pred_end(); I != E; ++I) {
+ E = block->pred_end();
+ I != E; ++I) {
const CFGBlock *pred = *I;
if (!pred)
continue;
@@ -909,11 +894,8 @@ struct PruneBlocksHandler : public UninitVariablesHandler {
} // namespace
void clang::runUninitializedVariablesAnalysis(
- const DeclContext &dc,
- const CFG &cfg,
- AnalysisDeclContext &ac,
- UninitVariablesHandler &handler,
- UninitVariablesAnalysisStats &stats) {
+ const DeclContext &dc, const CFG &cfg, AnalysisDeclContext &ac,
+ UninitVariablesHandler &handler, UninitVariablesAnalysisStats &stats) {
CFGBlockValues vals(cfg);
vals.computeSetOfDeclarations(dc);
if (vals.hasNoDeclarations())
@@ -945,8 +927,8 @@ void clang::runUninitializedVariablesAnalysis(
PBH.currentBlock = block->getBlockID();
// Did the block change?
- bool changed = runOnBlock(block, cfg, ac, vals,
- classification, wasAnalyzed, PBH);
+ bool changed =
+ runOnBlock(block, cfg, ac, vals, classification, wasAnalyzed, PBH);
++stats.NumBlockVisits;
if (changed || !previouslyVisited[block->getBlockID()])
worklist.enqueueSuccessors(block);
diff --git a/clang/lib/Analysis/UnsafeBufferUsage.cpp b/clang/lib/Analysis/UnsafeBufferUsage.cpp
index 701f1ac852c256..e31dd0f0f511d2 100644
--- a/clang/lib/Analysis/UnsafeBufferUsage.cpp
+++ b/clang/lib/Analysis/UnsafeBufferUsage.cpp
@@ -130,42 +130,42 @@ class MatchDescendantVisitor
bool TraverseGenericSelectionExpr(GenericSelectionExpr *Node) {
// These are unevaluated, except the result expression.
- if(ignoreUnevaluatedContext)
+ if (ignoreUnevaluatedContext)
return TraverseStmt(Node->getResultExpr());
return VisitorBase::TraverseGenericSelectionExpr(Node);
}
bool TraverseUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node) {
// Unevaluated context.
- if(ignoreUnevaluatedContext)
+ if (ignoreUnevaluatedContext)
return true;
return VisitorBase::TraverseUnaryExprOrTypeTraitExpr(Node);
}
bool TraverseTypeOfExprTypeLoc(TypeOfExprTypeLoc Node) {
// Unevaluated context.
- if(ignoreUnevaluatedContext)
+ if (ignoreUnevaluatedContext)
return true;
return VisitorBase::TraverseTypeOfExprTypeLoc(Node);
}
bool TraverseDecltypeTypeLoc(DecltypeTypeLoc Node) {
// Unevaluated context.
- if(ignoreUnevaluatedContext)
+ if (ignoreUnevaluatedContext)
return true;
return VisitorBase::TraverseDecltypeTypeLoc(Node);
}
bool TraverseCXXNoexceptExpr(CXXNoexceptExpr *Node) {
// Unevaluated context.
- if(ignoreUnevaluatedContext)
+ if (ignoreUnevaluatedContext)
return true;
return VisitorBase::TraverseCXXNoexceptExpr(Node);
}
bool TraverseCXXTypeidExpr(CXXTypeidExpr *Node) {
// Unevaluated context.
- if(ignoreUnevaluatedContext)
+ if (ignoreUnevaluatedContext)
return true;
return VisitorBase::TraverseCXXTypeidExpr(Node);
}
@@ -213,24 +213,26 @@ class MatchDescendantVisitor
// Because we're dealing with raw pointers, let's define what we mean by that.
static auto hasPointerType() {
- return hasType(hasCanonicalType(pointerType()));
+ return hasType(hasCanonicalType(pointerType()));
}
-static auto hasArrayType() {
- return hasType(hasCanonicalType(arrayType()));
-}
+static auto hasArrayType() { return hasType(hasCanonicalType(arrayType())); }
-AST_MATCHER_P(Stmt, forEachDescendantEvaluatedStmt, internal::Matcher<Stmt>, innerMatcher) {
+AST_MATCHER_P(Stmt, forEachDescendantEvaluatedStmt, internal::Matcher<Stmt>,
+ innerMatcher) {
const DynTypedMatcher &DTM = static_cast<DynTypedMatcher>(innerMatcher);
- MatchDescendantVisitor Visitor(&DTM, Finder, Builder, ASTMatchFinder::BK_All, true);
+ MatchDescendantVisitor Visitor(&DTM, Finder, Builder, ASTMatchFinder::BK_All,
+ true);
return Visitor.findMatch(DynTypedNode::create(Node));
}
-AST_MATCHER_P(Stmt, forEachDescendantStmt, internal::Matcher<Stmt>, innerMatcher) {
+AST_MATCHER_P(Stmt, forEachDescendantStmt, internal::Matcher<Stmt>,
+ innerMatcher) {
const DynTypedMatcher &DTM = static_cast<DynTypedMatcher>(innerMatcher);
- MatchDescendantVisitor Visitor(&DTM, Finder, Builder, ASTMatchFinder::BK_All, false);
+ MatchDescendantVisitor Visitor(&DTM, Finder, Builder, ASTMatchFinder::BK_All,
+ false);
return Visitor.findMatch(DynTypedNode::create(Node));
}
@@ -268,10 +270,9 @@ static auto isInUnspecifiedLvalueContext(internal::Matcher<Expr> innerMatcher) {
hasLHS(innerMatcher)
)
));
-// clang-format on
+ // clang-format on
}
-
// Returns a matcher that matches any expression `e` such that `InnerMatcher`
// matches `e` and `e` is in an Unspecified Pointer Context (UPC).
static internal::Matcher<Stmt>
@@ -315,7 +316,7 @@ isInUnspecifiedPointerContext(internal::Matcher<Stmt> InnerMatcher) {
// clang-format on
return stmt(anyOf(CallArgMatcher, CastOperandMatcher, CompOperandMatcher,
- PtrSubtractionMatcher));
+ PtrSubtractionMatcher));
// FIXME: any more cases? (UPC excludes the RHS of an assignment. For now we
// don't have to check that.)
}
@@ -481,7 +482,9 @@ class Gadget {
#ifndef NDEBUG
StringRef getDebugName() const {
switch (K) {
-#define GADGET(x) case Kind::x: return #x;
+#define GADGET(x) \
+ case Kind::x: \
+ return #x;
#include "clang/Analysis/Analyses/UnsafeBufferUsageGadgets.def"
}
llvm_unreachable("Unhandled Gadget::Kind enum");
@@ -502,7 +505,6 @@ class Gadget {
Kind K;
};
-
/// Warning gadgets correspond to unsafe code patterns that warrants
/// an immediate warning.
class WarningGadget : public Gadget {
@@ -513,10 +515,10 @@ class WarningGadget : public Gadget {
bool isWarningGadget() const final { return true; }
};
-/// Fixable gadgets correspond to code patterns that aren't always unsafe but need to be
-/// properly recognized in order to emit fixes. For example, if a raw pointer-type
-/// variable is replaced by a safe C++ container, every use of such variable must be
-/// carefully considered and possibly updated.
+/// Fixable gadgets correspond to code patterns that aren't always unsafe but
+/// need to be properly recognized in order to emit fixes. For example, if a raw
+/// pointer-type variable is replaced by a safe C++ container, every use of such
+/// variable must be carefully considered and possibly updated.
class FixableGadget : public Gadget {
public:
FixableGadget(Kind K) : Gadget(K) {}
@@ -531,20 +533,19 @@ class FixableGadget : public Gadget {
return std::nullopt;
}
- /// Returns a list of two elements where the first element is the LHS of a pointer assignment
- /// statement and the second element is the RHS. This two-element list represents the fact that
- /// the LHS buffer gets its bounds information from the RHS buffer. This information will be used
- /// later to group all those variables whose types must be modified together to prevent type
- /// mismatches.
+ /// Returns a list of two elements where the first element is the LHS of a
+ /// pointer assignment statement and the second element is the RHS. This
+ /// two-element list represents the fact that the LHS buffer gets its bounds
+ /// information from the RHS buffer. This information will be used later to
+ /// group all those variables whose types must be modified together to prevent
+ /// type mismatches.
virtual std::optional<std::pair<const VarDecl *, const VarDecl *>>
getStrategyImplications() const {
return std::nullopt;
}
};
-static auto toSupportedVariable() {
- return to(varDecl());
-}
+static auto toSupportedVariable() { return to(varDecl()); }
using FixableGadgetList = std::vector<std::unique_ptr<FixableGadget>>;
using WarningGadgetList = std::vector<std::unique_ptr<WarningGadget>>;
@@ -565,10 +566,10 @@ class IncrementGadget : public WarningGadget {
}
static Matcher matcher() {
- return stmt(unaryOperator(
- hasOperatorName("++"),
- hasUnaryOperand(ignoringParenImpCasts(hasPointerType()))
- ).bind(OpTag));
+ return stmt(
+ unaryOperator(hasOperatorName("++"),
+ hasUnaryOperand(ignoringParenImpCasts(hasPointerType())))
+ .bind(OpTag));
}
const UnaryOperator *getBaseStmt() const override { return Op; }
@@ -600,10 +601,10 @@ class DecrementGadget : public WarningGadget {
}
static Matcher matcher() {
- return stmt(unaryOperator(
- hasOperatorName("--"),
- hasUnaryOperand(ignoringParenImpCasts(hasPointerType()))
- ).bind(OpTag));
+ return stmt(
+ unaryOperator(hasOperatorName("--"),
+ hasUnaryOperand(ignoringParenImpCasts(hasPointerType())))
+ .bind(OpTag));
}
const UnaryOperator *getBaseStmt() const override { return Op; }
@@ -754,26 +755,25 @@ class PointerInitGadget : public FixableGadget {
private:
static constexpr const char *const PointerInitLHSTag = "ptrInitLHS";
static constexpr const char *const PointerInitRHSTag = "ptrInitRHS";
- const VarDecl * PtrInitLHS; // the LHS pointer expression in `PI`
- const DeclRefExpr * PtrInitRHS; // the RHS pointer expression in `PI`
+ const VarDecl *PtrInitLHS; // the LHS pointer expression in `PI`
+ const DeclRefExpr *PtrInitRHS; // the RHS pointer expression in `PI`
public:
PointerInitGadget(const MatchFinder::MatchResult &Result)
: FixableGadget(Kind::PointerInit),
- PtrInitLHS(Result.Nodes.getNodeAs<VarDecl>(PointerInitLHSTag)),
- PtrInitRHS(Result.Nodes.getNodeAs<DeclRefExpr>(PointerInitRHSTag)) {}
+ PtrInitLHS(Result.Nodes.getNodeAs<VarDecl>(PointerInitLHSTag)),
+ PtrInitRHS(Result.Nodes.getNodeAs<DeclRefExpr>(PointerInitRHSTag)) {}
static bool classof(const Gadget *G) {
return G->getKind() == Kind::PointerInit;
}
static Matcher matcher() {
- auto PtrInitStmt = declStmt(hasSingleDecl(varDecl(
- hasInitializer(ignoringImpCasts(declRefExpr(
- hasPointerType(),
- toSupportedVariable()).
- bind(PointerInitRHSTag)))).
- bind(PointerInitLHSTag)));
+ auto PtrInitStmt = declStmt(hasSingleDecl(
+ varDecl(hasInitializer(ignoringImpCasts(
+ declRefExpr(hasPointerType(), toSupportedVariable())
+ .bind(PointerInitRHSTag))))
+ .bind(PointerInitLHSTag)));
return stmt(PtrInitStmt);
}
@@ -793,8 +793,7 @@ class PointerInitGadget : public FixableGadget {
virtual std::optional<std::pair<const VarDecl *, const VarDecl *>>
getStrategyImplications() const override {
- return std::make_pair(PtrInitLHS,
- cast<VarDecl>(PtrInitRHS->getDecl()));
+ return std::make_pair(PtrInitLHS, cast<VarDecl>(PtrInitRHS->getDecl()));
}
};
@@ -807,8 +806,8 @@ class PtrToPtrAssignmentGadget : public FixableGadget {
private:
static constexpr const char *const PointerAssignLHSTag = "ptrLHS";
static constexpr const char *const PointerAssignRHSTag = "ptrRHS";
- const DeclRefExpr * PtrLHS; // the LHS pointer expression in `PA`
- const DeclRefExpr * PtrRHS; // the RHS pointer expression in `PA`
+ const DeclRefExpr *PtrLHS; // the LHS pointer expression in `PA`
+ const DeclRefExpr *PtrRHS; // the RHS pointer expression in `PA`
public:
PtrToPtrAssignmentGadget(const MatchFinder::MatchResult &Result)
@@ -821,13 +820,13 @@ class PtrToPtrAssignmentGadget : public FixableGadget {
}
static Matcher matcher() {
- auto PtrAssignExpr = binaryOperator(allOf(hasOperatorName("="),
- hasRHS(ignoringParenImpCasts(declRefExpr(hasPointerType(),
- toSupportedVariable()).
- bind(PointerAssignRHSTag))),
- hasLHS(declRefExpr(hasPointerType(),
- toSupportedVariable()).
- bind(PointerAssignLHSTag))));
+ auto PtrAssignExpr = binaryOperator(
+ allOf(hasOperatorName("="),
+ hasRHS(ignoringParenImpCasts(
+ declRefExpr(hasPointerType(), toSupportedVariable())
+ .bind(PointerAssignRHSTag))),
+ hasLHS(declRefExpr(hasPointerType(), toSupportedVariable())
+ .bind(PointerAssignLHSTag))));
return stmt(isInUnspecifiedUntypedContext(PtrAssignExpr));
}
@@ -981,9 +980,8 @@ class ULCArraySubscriptGadget : public FixableGadget {
static Matcher matcher() {
auto ArrayOrPtr = anyOf(hasPointerType(), hasArrayType());
- auto BaseIsArrayOrPtrDRE =
- hasBase(ignoringParenImpCasts(declRefExpr(ArrayOrPtr,
- toSupportedVariable())));
+ auto BaseIsArrayOrPtrDRE = hasBase(
+ ignoringParenImpCasts(declRefExpr(ArrayOrPtr, toSupportedVariable())));
auto Target =
arraySubscriptExpr(BaseIsArrayOrPtrDRE).bind(ULCArraySubscriptTag);
@@ -1025,9 +1023,9 @@ class UPCStandalonePointerGadget : public FixableGadget {
static Matcher matcher() {
auto ArrayOrPtr = anyOf(hasPointerType(), hasArrayType());
- auto target = expr(
- ignoringParenImpCasts(declRefExpr(allOf(ArrayOrPtr,
- toSupportedVariable())).bind(DeclRefExprTag)));
+ auto target = expr(ignoringParenImpCasts(
+ declRefExpr(allOf(ArrayOrPtr, toSupportedVariable()))
+ .bind(DeclRefExprTag)));
return stmt(isInUnspecifiedPointerContext(target));
}
@@ -1036,9 +1034,7 @@ class UPCStandalonePointerGadget : public FixableGadget {
virtual const Stmt *getBaseStmt() const override { return Node; }
- virtual DeclUseList getClaimedVarUseSites() const override {
- return {Node};
- }
+ virtual DeclUseList getClaimedVarUseSites() const override { return {Node}; }
};
class PointerDereferenceGadget : public FixableGadget {
@@ -1103,10 +1099,10 @@ class UPCAddressofArraySubscriptGadget : public FixableGadget {
static Matcher matcher() {
return expr(isInUnspecifiedPointerContext(expr(ignoringImpCasts(
- unaryOperator(hasOperatorName("&"),
- hasUnaryOperand(arraySubscriptExpr(
- hasBase(ignoringParenImpCasts(declRefExpr(
- toSupportedVariable()))))))
+ unaryOperator(
+ hasOperatorName("&"),
+ hasUnaryOperand(arraySubscriptExpr(hasBase(
+ ignoringParenImpCasts(declRefExpr(toSupportedVariable()))))))
.bind(UPCAddressofArraySubscriptTag)))));
}
@@ -1195,13 +1191,13 @@ class DeclUseTracker {
class UPCPreIncrementGadget : public FixableGadget {
private:
static constexpr const char *const UPCPreIncrementTag =
- "PointerPreIncrementUnderUPC";
+ "PointerPreIncrementUnderUPC";
const UnaryOperator *Node; // the `++Ptr` node
public:
UPCPreIncrementGadget(const MatchFinder::MatchResult &Result)
- : FixableGadget(Kind::UPCPreIncrement),
- Node(Result.Nodes.getNodeAs<UnaryOperator>(UPCPreIncrementTag)) {
+ : FixableGadget(Kind::UPCPreIncrement),
+ Node(Result.Nodes.getNodeAs<UnaryOperator>(UPCPreIncrementTag)) {
assert(Node != nullptr && "Expecting a non-null matching result");
}
@@ -1215,10 +1211,9 @@ class UPCPreIncrementGadget : public FixableGadget {
// can have the matcher be general, so long as `getClaimedVarUseSites` does
// things right.
return stmt(isInUnspecifiedPointerContext(expr(ignoringImpCasts(
- unaryOperator(isPreInc(),
- hasUnaryOperand(declRefExpr(
- toSupportedVariable()))
- ).bind(UPCPreIncrementTag)))));
+ unaryOperator(isPreInc(),
+ hasUnaryOperand(declRefExpr(toSupportedVariable())))
+ .bind(UPCPreIncrementTag)))));
}
virtual std::optional<FixItList>
@@ -1782,9 +1777,9 @@ static SourceRange getSourceRangeToTokenEnd(const Decl *D,
const LangOptions &LangOpts) {
SourceLocation Begin = D->getBeginLoc();
SourceLocation
- End = // `D->getEndLoc` should always return the starting location of the
- // last token, so we should get the end of the token
- Lexer::getLocForEndOfToken(D->getEndLoc(), 0, SM, LangOpts);
+ End = // `D->getEndLoc` should always return the starting location of the
+ // last token, so we should get the end of the token
+ Lexer::getLocForEndOfToken(D->getEndLoc(), 0, SM, LangOpts);
return SourceRange(Begin, End);
}
@@ -1976,7 +1971,7 @@ PointerDereferenceGadget::getFixits(const FixitStrategy &S) const {
if (auto LocPastOperand =
getPastLoc(BaseDeclRefExpr, SM, Ctx.getLangOpts())) {
return FixItList{{FixItHint::CreateRemoval(derefRange),
- FixItHint::CreateInsertion(*LocPastOperand, "[0]")}};
+ FixItHint::CreateInsertion(*LocPastOperand, "[0]")}};
}
break;
}
@@ -2057,8 +2052,8 @@ fixUPCAddressofArraySubscriptWithSpan(const UnaryOperator *Node) {
if (!IndexString)
return std::nullopt;
- SS << "&" << (*DreString).str() << ".data()"
- << "[" << (*IndexString).str() << "]";
+ SS << "&" << (*DreString).str() << ".data()" << "[" << (*IndexString).str()
+ << "]";
}
return FixItList{
FixItHint::CreateReplacement(Node->getSourceRange(), SS.str())};
@@ -2162,7 +2157,8 @@ FixVarInitializerWithSpan(const Expr *Init, ASTContext &Ctx,
// NULL pointer, we use the default constructor to initialize the span
// object, i.e., a `std:span` variable declaration with no initializer.
// So the fix-it is just to remove the initializer.
- if (Init->isNullPointerConstant(Ctx,
+ if (Init->isNullPointerConstant(
+ Ctx,
// FIXME: Why does this function not ask for `const ASTContext
// &`? It should. Maybe worth an NFC patch later.
Expr::NullPointerConstantValueDependence::
@@ -2230,8 +2226,10 @@ FixVarInitializerWithSpan(const Expr *Init, ASTContext &Ctx,
}
#ifndef NDEBUG
-#define DEBUG_NOTE_DECL_FAIL(D, Msg) \
-Handler.addDebugNoteForVar((D), (D)->getBeginLoc(), "failed to produce fixit for declaration '" + (D)->getNameAsString() + "'" + (Msg))
+#define DEBUG_NOTE_DECL_FAIL(D, Msg) \
+ Handler.addDebugNoteForVar((D), (D)->getBeginLoc(), \
+ "failed to produce fixit for declaration '" + \
+ (D)->getNameAsString() + "'" + (Msg))
#else
#define DEBUG_NOTE_DECL_FAIL(D, Msg)
#endif
@@ -2239,8 +2237,8 @@ Handler.addDebugNoteForVar((D), (D)->getBeginLoc(), "failed to produce fixit for
// For the given variable declaration with a pointer-to-T type, returns the text
// `std::span<T>`. If it is unable to generate the text, returns
// `std::nullopt`.
-static std::optional<std::string> createSpanTypeForVarDecl(const VarDecl *VD,
- const ASTContext &Ctx) {
+static std::optional<std::string>
+createSpanTypeForVarDecl(const VarDecl *VD, const ASTContext &Ctx) {
assert(VD->getType()->isPointerType());
std::optional<Qualifiers> PteTyQualifiers = std::nullopt;
@@ -2277,8 +2275,8 @@ static std::optional<std::string> createSpanTypeForVarDecl(const VarDecl *VD,
// the non-empty fix-it list, if fix-its are successfuly generated; empty
// list otherwise.
static FixItList fixLocalVarDeclWithSpan(const VarDecl *D, ASTContext &Ctx,
- const StringRef UserFillPlaceHolder,
- UnsafeBufferUsageHandler &Handler) {
+ const StringRef UserFillPlaceHolder,
+ UnsafeBufferUsageHandler &Handler) {
if (hasUnsupportedSpecifiers(D, Ctx.getSourceManager()))
return {};
@@ -2431,9 +2429,9 @@ createOverloadsForFixedParams(const FixitStrategy &S, const FunctionDecl *FD,
// print parameter name if provided:
if (IdentifierInfo *II = Parm->getIdentifier())
SS << ' ' << II->getName().str();
- } else if (auto ParmTypeText = getRangeText(
- getSourceRangeToTokenEnd(Parm, SM, LangOpts),
- SM, LangOpts)) {
+ } else if (auto ParmTypeText =
+ getRangeText(getSourceRangeToTokenEnd(Parm, SM, LangOpts),
+ SM, LangOpts)) {
// print the whole `Parm` without modification:
SS << ParmTypeText->str();
} else
@@ -2577,7 +2575,8 @@ static FixItList fixVariableWithSpan(const VarDecl *VD,
UnsafeBufferUsageHandler &Handler) {
const DeclStmt *DS = Tracker.lookupDecl(VD);
if (!DS) {
- DEBUG_NOTE_DECL_FAIL(VD, " : variables declared this way not implemented yet");
+ DEBUG_NOTE_DECL_FAIL(VD,
+ " : variables declared this way not implemented yet");
return {};
}
if (!DS->isSingleDecl()) {
@@ -2979,8 +2978,8 @@ void clang::checkUnsafeBufferUsage(const Decl *D,
#endif
assert(D && D->getBody());
- // We do not want to visit a Lambda expression defined inside a method independently.
- // Instead, it should be visited along with the outer method.
+ // We do not want to visit a Lambda expression defined inside a method
+ // independently. Instead, it should be visited along with the outer method.
// FIXME: do we want to do the same thing for `BlockDecl`s?
if (const auto *fd = dyn_cast<CXXMethodDecl>(D)) {
if (fd->getParent()->isLambda() && fd->getParent()->isLocalClass())
@@ -2990,7 +2989,7 @@ void clang::checkUnsafeBufferUsage(const Decl *D,
// Do not emit fixit suggestions for functions declared in an
// extern "C" block.
if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
- for (FunctionDecl *FReDecl : FD->redecls()) {
+ for (FunctionDecl *FReDecl : FD->redecls()) {
if (FReDecl->isExternC()) {
EmitSuggestions = false;
break;
@@ -3002,7 +3001,7 @@ void clang::checkUnsafeBufferUsage(const Decl *D,
FixableGadgetSets FixablesForAllVars;
auto [FixableGadgets, WarningGadgets, Tracker] =
- findGadgets(D, Handler, EmitSuggestions);
+ findGadgets(D, Handler, EmitSuggestions);
if (!EmitSuggestions) {
// Our job is very easy without suggestions. Just warn about
@@ -3055,36 +3054,36 @@ void clang::checkUnsafeBufferUsage(const Decl *D,
// Filter out non-local vars and vars with unclaimed DeclRefExpr-s.
for (auto it = FixablesForAllVars.byVar.cbegin();
it != FixablesForAllVars.byVar.cend();) {
- // FIXME: need to deal with global variables later
- if ((!it->first->isLocalVarDecl() && !isa<ParmVarDecl>(it->first))) {
+ // FIXME: need to deal with global variables later
+ if ((!it->first->isLocalVarDecl() && !isa<ParmVarDecl>(it->first))) {
#ifndef NDEBUG
- Handler.addDebugNoteForVar(
- it->first, it->first->getBeginLoc(),
- ("failed to produce fixit for '" + it->first->getNameAsString() +
- "' : neither local nor a parameter"));
+ Handler.addDebugNoteForVar(it->first, it->first->getBeginLoc(),
+ ("failed to produce fixit for '" +
+ it->first->getNameAsString() +
+ "' : neither local nor a parameter"));
#endif
- it = FixablesForAllVars.byVar.erase(it);
- } else if (it->first->getType().getCanonicalType()->isReferenceType()) {
+ it = FixablesForAllVars.byVar.erase(it);
+ } else if (it->first->getType().getCanonicalType()->isReferenceType()) {
#ifndef NDEBUG
- Handler.addDebugNoteForVar(it->first, it->first->getBeginLoc(),
- ("failed to produce fixit for '" +
- it->first->getNameAsString() +
- "' : has a reference type"));
+ Handler.addDebugNoteForVar(it->first, it->first->getBeginLoc(),
+ ("failed to produce fixit for '" +
+ it->first->getNameAsString() +
+ "' : has a reference type"));
#endif
- it = FixablesForAllVars.byVar.erase(it);
- } else if (Tracker.hasUnclaimedUses(it->first)) {
- it = FixablesForAllVars.byVar.erase(it);
- } else if (it->first->isInitCapture()) {
+ it = FixablesForAllVars.byVar.erase(it);
+ } else if (Tracker.hasUnclaimedUses(it->first)) {
+ it = FixablesForAllVars.byVar.erase(it);
+ } else if (it->first->isInitCapture()) {
#ifndef NDEBUG
- Handler.addDebugNoteForVar(
- it->first, it->first->getBeginLoc(),
- ("failed to produce fixit for '" + it->first->getNameAsString() +
- "' : init capture"));
+ Handler.addDebugNoteForVar(it->first, it->first->getBeginLoc(),
+ ("failed to produce fixit for '" +
+ it->first->getNameAsString() +
+ "' : init capture"));
#endif
- it = FixablesForAllVars.byVar.erase(it);
- } else {
- ++it;
- }
+ it = FixablesForAllVars.byVar.erase(it);
+ } else {
+ ++it;
+ }
}
#ifndef NDEBUG
@@ -3115,7 +3114,7 @@ void clang::checkUnsafeBufferUsage(const Decl *D,
for (auto it : FixablesForAllVars.byVar) {
for (const FixableGadget *fixable : it.second) {
std::optional<std::pair<const VarDecl *, const VarDecl *>> ImplPair =
- fixable->getStrategyImplications();
+ fixable->getStrategyImplications();
if (ImplPair) {
std::pair<const VarDecl *, const VarDecl *> Impl = std::move(*ImplPair);
PtrAssignmentGraph[Impl.first].insert(Impl.second);
@@ -3144,10 +3143,10 @@ void clang::checkUnsafeBufferUsage(const Decl *D,
for (const auto &[Var, ignore] : UnsafeOps.byVar) {
if (VisitedVarsDirected.find(Var) == VisitedVarsDirected.end()) {
- std::queue<const VarDecl*> QueueDirected{};
+ std::queue<const VarDecl *> QueueDirected{};
QueueDirected.push(Var);
- while(!QueueDirected.empty()) {
- const VarDecl* CurrentVar = QueueDirected.front();
+ while (!QueueDirected.empty()) {
+ const VarDecl *CurrentVar = QueueDirected.front();
QueueDirected.pop();
VisitedVarsDirected.insert(CurrentVar);
auto AdjacentNodes = PtrAssignmentGraph[CurrentVar];
@@ -3178,11 +3177,11 @@ void clang::checkUnsafeBufferUsage(const Decl *D,
for (const auto &[Var, ignore] : UnsafeOps.byVar) {
if (VisitedVars.find(Var) == VisitedVars.end()) {
VarGrpTy &VarGroup = Groups.emplace_back();
- std::queue<const VarDecl*> Queue{};
+ std::queue<const VarDecl *> Queue{};
Queue.push(Var);
- while(!Queue.empty()) {
- const VarDecl* CurrentVar = Queue.front();
+ while (!Queue.empty()) {
+ const VarDecl *CurrentVar = Queue.front();
Queue.pop();
VisitedVars.insert(CurrentVar);
VarGroup.push_back(CurrentVar);
diff --git a/clang/lib/Analysis/plugins/CheckerOptionHandling/CheckerOptionHandling.cpp b/clang/lib/Analysis/plugins/CheckerOptionHandling/CheckerOptionHandling.cpp
index 32fba9c93752c6..6ecfe110066b00 100644
--- a/clang/lib/Analysis/plugins/CheckerOptionHandling/CheckerOptionHandling.cpp
+++ b/clang/lib/Analysis/plugins/CheckerOptionHandling/CheckerOptionHandling.cpp
@@ -30,7 +30,7 @@ extern "C" void clang_registerCheckers(CheckerRegistry ®istry) {
registry.addChecker(registerMyChecker, shouldRegisterMyChecker,
"example.MyChecker", "Example Description",
"example.mychecker.documentation.nonexistent.html",
- /*isHidden*/false);
+ /*isHidden*/ false);
registry.addCheckerOption(/*OptionType*/ "bool",
/*CheckerFullName*/ "example.MyChecker",
diff --git a/clang/lib/StaticAnalyzer/Checkers/AnalysisOrderChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/AnalysisOrderChecker.cpp
index 0e8cbc60689a70..09542bdbb57ac2 100644
--- a/clang/lib/StaticAnalyzer/Checkers/AnalysisOrderChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/AnalysisOrderChecker.cpp
@@ -52,8 +52,10 @@ class AnalysisOrderChecker
}
bool isCallbackEnabled(ProgramStateRef State, StringRef CallbackName) const {
- AnalyzerOptions &Opts = State->getStateManager().getOwningEngine()
- .getAnalysisManager().getAnalyzerOptions();
+ AnalyzerOptions &Opts = State->getStateManager()
+ .getOwningEngine()
+ .getAnalysisManager()
+ .getAnalyzerOptions();
return isCallbackEnabled(Opts, CallbackName);
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/AnalyzerStatsChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/AnalyzerStatsChecker.cpp
index a54f1b1e71d47b..a7b9b8b51cf33c 100644
--- a/clang/lib/StaticAnalyzer/Checkers/AnalyzerStatsChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/AnalyzerStatsChecker.cpp
@@ -27,24 +27,23 @@ using namespace ento;
#define DEBUG_TYPE "StatsChecker"
-STATISTIC(NumBlocks,
- "The # of blocks in top level functions");
+STATISTIC(NumBlocks, "The # of blocks in top level functions");
STATISTIC(NumBlocksUnreachable,
"The # of unreachable blocks in analyzing top level functions");
namespace {
class AnalyzerStatsChecker : public Checker<check::EndAnalysis> {
public:
- void checkEndAnalysis(ExplodedGraph &G, BugReporter &B,ExprEngine &Eng) const;
+ void checkEndAnalysis(ExplodedGraph &G, BugReporter &B,
+ ExprEngine &Eng) const;
};
-}
+} // namespace
-void AnalyzerStatsChecker::checkEndAnalysis(ExplodedGraph &G,
- BugReporter &B,
+void AnalyzerStatsChecker::checkEndAnalysis(ExplodedGraph &G, BugReporter &B,
ExprEngine &Eng) const {
const CFG *C = nullptr;
const SourceManager &SM = B.getSourceManager();
- llvm::SmallPtrSet<const CFGBlock*, 32> reachable;
+ llvm::SmallPtrSet<const CFGBlock *, 32> reachable;
// Root node should have the location context of the top most function.
const ExplodedNode *GraphRoot = *G.roots_begin();
@@ -105,11 +104,10 @@ void AnalyzerStatsChecker::checkEndAnalysis(ExplodedGraph &G,
NumBlocks += total;
std::string NameOfRootFunction = std::string(output.str());
- output << " -> Total CFGBlocks: " << total << " | Unreachable CFGBlocks: "
- << unreachable << " | Exhausted Block: "
- << (Eng.wasBlocksExhausted() ? "yes" : "no")
- << " | Empty WorkList: "
- << (Eng.hasEmptyWorkList() ? "yes" : "no");
+ output << " -> Total CFGBlocks: " << total
+ << " | Unreachable CFGBlocks: " << unreachable
+ << " | Exhausted Block: " << (Eng.wasBlocksExhausted() ? "yes" : "no")
+ << " | Empty WorkList: " << (Eng.hasEmptyWorkList() ? "yes" : "no");
B.EmitBasicReport(D, this, "Analyzer Statistics", "Internal Statistics",
output.str(), PathDiagnosticLocation(D, SM));
@@ -124,8 +122,8 @@ void AnalyzerStatsChecker::checkEndAnalysis(ExplodedGraph &G,
if (std::optional<CFGStmt> CS = CE.getAs<CFGStmt>()) {
SmallString<128> bufI;
llvm::raw_svector_ostream outputI(bufI);
- outputI << "(" << NameOfRootFunction << ")" <<
- ": The analyzer generated a sink at this point";
+ outputI << "(" << NameOfRootFunction << ")"
+ << ": The analyzer generated a sink at this point";
B.EmitBasicReport(
D, this, "Sink Point", "Internal Statistics", outputI.str(),
PathDiagnosticLocation::createBegin(CS->getStmt(), SM, LC));
diff --git a/clang/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp
index c990ad138f8905..92d8d6dbd51860 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp
@@ -23,17 +23,16 @@ using namespace clang;
using namespace ento;
namespace {
-class ArrayBoundChecker :
- public Checker<check::Location> {
+class ArrayBoundChecker : public Checker<check::Location> {
const BugType BT{this, "Out-of-bound array access"};
public:
- void checkLocation(SVal l, bool isLoad, const Stmt* S,
+ void checkLocation(SVal l, bool isLoad, const Stmt *S,
CheckerContext &C) const;
};
-}
+} // namespace
-void ArrayBoundChecker::checkLocation(SVal l, bool isLoad, const Stmt* LoadS,
+void ArrayBoundChecker::checkLocation(SVal l, bool isLoad, const Stmt *LoadS,
CheckerContext &C) const {
// Check for out of bound array element access.
const MemRegion *R = l.getAsRegion();
diff --git a/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp b/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp
index 05fc00a990d524..3de7f711c122e0 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp
@@ -279,11 +279,13 @@ static std::pair<ProgramStateRef, ProgramStateRef>
compareValueToThreshold(ProgramStateRef State, NonLoc Value, NonLoc Threshold,
SValBuilder &SVB, bool CheckEquality = false) {
if (auto ConcreteThreshold = Threshold.getAs<nonloc::ConcreteInt>()) {
- std::tie(Value, Threshold) = getSimplifiedOffsets(Value, *ConcreteThreshold, SVB);
+ std::tie(Value, Threshold) =
+ getSimplifiedOffsets(Value, *ConcreteThreshold, SVB);
}
if (auto ConcreteThreshold = Threshold.getAs<nonloc::ConcreteInt>()) {
QualType T = Value.getType(SVB.getContext());
- if (T->isUnsignedIntegerType() && ConcreteThreshold->getValue().isNegative()) {
+ if (T->isUnsignedIntegerType() &&
+ ConcreteThreshold->getValue().isNegative()) {
// In this case we reduced the bound check to a comparison of the form
// (symbol or value with unsigned type) < (negative number)
// which is always false. We are handling these cases separately because
diff --git a/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp b/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp
index c72a97cc01e914..2693e5b2197816 100644
--- a/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp
@@ -129,8 +129,7 @@ class NilArgChecker : public Checker<check::PreObjCMessage,
};
} // end anonymous namespace
-void NilArgChecker::warnIfNilExpr(const Expr *E,
- const char *Msg,
+void NilArgChecker::warnIfNilExpr(const Expr *E, const char *Msg,
CheckerContext &C) const {
auto Location = C.getSVal(E).getAs<Loc>();
if (!Location)
@@ -157,15 +156,13 @@ void NilArgChecker::warnIfNilExpr(const Expr *E,
}
}
-void NilArgChecker::warnIfNilArg(CheckerContext &C,
- const ObjCMethodCall &msg,
- unsigned int Arg,
- FoundationClass Class,
+void NilArgChecker::warnIfNilArg(CheckerContext &C, const ObjCMethodCall &msg,
+ unsigned int Arg, FoundationClass Class,
bool CanBeSubscript) const {
// Check if the argument is nil.
ProgramStateRef State = C.getState();
if (!State->isNull(msg.getArgSVal(Arg)).isConstrainedTrue())
- return;
+ return;
// NOTE: We cannot throw non-fatal errors from warnIfNilExpr,
// because it's called multiple times from some callers, so it'd cause
@@ -186,7 +183,7 @@ void NilArgChecker::warnIfNilArg(CheckerContext &C,
os << GetReceiverInterfaceName(msg) << "' cannot be nil";
} else {
assert(Arg == 1);
- os << "'"<< GetReceiverInterfaceName(msg) << "' key cannot be nil";
+ os << "'" << GetReceiverInterfaceName(msg) << "' key cannot be nil";
}
} else
llvm_unreachable("Missing foundation class for the subscript expr");
@@ -214,10 +211,8 @@ void NilArgChecker::warnIfNilArg(CheckerContext &C,
}
}
-void NilArgChecker::generateBugReport(ExplodedNode *N,
- StringRef Msg,
- SourceRange Range,
- const Expr *E,
+void NilArgChecker::generateBugReport(ExplodedNode *N, StringRef Msg,
+ SourceRange Range, const Expr *E,
CheckerContext &C) const {
if (!BT)
BT.reset(new APIMisuse(this, "nil argument"));
@@ -313,7 +308,7 @@ void NilArgChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
if (S == DictionaryWithObjectForKeySel || S == SetObjectForKeySel) {
Arg = 0;
- warnIfNilArg(C, msg, /* Arg */1, Class);
+ warnIfNilArg(C, msg, /* Arg */ 1, Class);
} else if (S == SetObjectForKeyedSubscriptSel) {
CanBeSubscript = true;
Arg = 1;
@@ -350,9 +345,10 @@ void NilArgChecker::checkPostStmt(const ObjCDictionaryLiteral *DL,
//===----------------------------------------------------------------------===//
namespace {
-class CFNumberChecker : public Checker< check::PreStmt<CallExpr> > {
+class CFNumberChecker : public Checker<check::PreStmt<CallExpr>> {
mutable std::unique_ptr<APIMisuse> BT;
mutable IdentifierInfo *ICreate = nullptr, *IGetValue = nullptr;
+
public:
CFNumberChecker() = default;
@@ -380,27 +376,41 @@ enum CFNumberType {
};
static std::optional<uint64_t> GetCFNumberSize(ASTContext &Ctx, uint64_t i) {
- static const unsigned char FixedSize[] = { 8, 16, 32, 64, 32, 64 };
+ static const unsigned char FixedSize[] = {8, 16, 32, 64, 32, 64};
if (i < kCFNumberCharType)
- return FixedSize[i-1];
+ return FixedSize[i - 1];
QualType T;
switch (i) {
- case kCFNumberCharType: T = Ctx.CharTy; break;
- case kCFNumberShortType: T = Ctx.ShortTy; break;
- case kCFNumberIntType: T = Ctx.IntTy; break;
- case kCFNumberLongType: T = Ctx.LongTy; break;
- case kCFNumberLongLongType: T = Ctx.LongLongTy; break;
- case kCFNumberFloatType: T = Ctx.FloatTy; break;
- case kCFNumberDoubleType: T = Ctx.DoubleTy; break;
- case kCFNumberCFIndexType:
- case kCFNumberNSIntegerType:
- case kCFNumberCGFloatType:
- // FIXME: We need a way to map from names to Type*.
- default:
- return std::nullopt;
+ case kCFNumberCharType:
+ T = Ctx.CharTy;
+ break;
+ case kCFNumberShortType:
+ T = Ctx.ShortTy;
+ break;
+ case kCFNumberIntType:
+ T = Ctx.IntTy;
+ break;
+ case kCFNumberLongType:
+ T = Ctx.LongTy;
+ break;
+ case kCFNumberLongLongType:
+ T = Ctx.LongLongTy;
+ break;
+ case kCFNumberFloatType:
+ T = Ctx.FloatTy;
+ break;
+ case kCFNumberDoubleType:
+ T = Ctx.DoubleTy;
+ break;
+ case kCFNumberCFIndexType:
+ case kCFNumberNSIntegerType:
+ case kCFNumberCGFloatType:
+ // FIXME: We need a way to map from names to Type*.
+ default:
+ return std::nullopt;
}
return Ctx.getTypeSize(T);
@@ -432,7 +442,7 @@ static const char* GetCFNumberTypeStr(uint64_t i) {
#endif
void CFNumberChecker::checkPreStmt(const CallExpr *CE,
- CheckerContext &C) const {
+ CheckerContext &C) const {
ProgramStateRef state = C.getState();
const FunctionDecl *FD = C.getCalleeDecl(CE);
if (!FD)
@@ -477,7 +487,7 @@ void CFNumberChecker::checkPreStmt(const CallExpr *CE,
if (!LV)
return;
- const TypedValueRegion* R = dyn_cast<TypedValueRegion>(LV->stripCasts());
+ const TypedValueRegion *R = dyn_cast<TypedValueRegion>(LV->stripCasts());
if (!R)
return;
@@ -503,27 +513,27 @@ void CFNumberChecker::checkPreStmt(const CallExpr *CE,
bool isCreate = (FD->getIdentifier() == ICreate);
if (isCreate) {
- os << (PrimitiveTypeSize == 8 ? "An " : "A ")
- << PrimitiveTypeSize << "-bit integer is used to initialize a "
+ os << (PrimitiveTypeSize == 8 ? "An " : "A ") << PrimitiveTypeSize
+ << "-bit integer is used to initialize a "
<< "CFNumber object that represents "
- << (CFNumberSize == 8 ? "an " : "a ")
- << CFNumberSize << "-bit integer; ";
+ << (CFNumberSize == 8 ? "an " : "a ") << CFNumberSize
+ << "-bit integer; ";
} else {
os << "A CFNumber object that represents "
- << (CFNumberSize == 8 ? "an " : "a ")
- << CFNumberSize << "-bit integer is used to initialize "
- << (PrimitiveTypeSize == 8 ? "an " : "a ")
- << PrimitiveTypeSize << "-bit integer; ";
+ << (CFNumberSize == 8 ? "an " : "a ") << CFNumberSize
+ << "-bit integer is used to initialize "
+ << (PrimitiveTypeSize == 8 ? "an " : "a ") << PrimitiveTypeSize
+ << "-bit integer; ";
}
if (PrimitiveTypeSize < CFNumberSize)
os << (CFNumberSize - PrimitiveTypeSize)
- << " bits of the CFNumber value will "
- << (isCreate ? "be garbage." : "overwrite adjacent storage.");
+ << " bits of the CFNumber value will "
+ << (isCreate ? "be garbage." : "overwrite adjacent storage.");
else
os << (PrimitiveTypeSize - CFNumberSize)
- << " bits of the integer value will be "
- << (isCreate ? "lost." : "garbage.");
+ << " bits of the integer value will be "
+ << (isCreate ? "lost." : "garbage.");
if (!BT)
BT.reset(new APIMisuse(this, "Bad use of CFNumber APIs"));
@@ -535,7 +545,8 @@ void CFNumberChecker::checkPreStmt(const CallExpr *CE,
}
//===----------------------------------------------------------------------===//
-// CFRetain/CFRelease/CFMakeCollectable/CFAutorelease checking for null arguments.
+// CFRetain/CFRelease/CFMakeCollectable/CFAutorelease checking for null
+// arguments.
//===----------------------------------------------------------------------===//
namespace {
@@ -641,8 +652,8 @@ void ClassReleaseChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
os << "The '";
S.print(os);
os << "' message should be sent to instances "
- "of class '" << Class->getName()
- << "' and not the class directly";
+ "of class '"
+ << Class->getName() << "' and not the class directly";
auto report = std::make_unique<PathSensitiveBugReport>(*BT, os.str(), N);
report->addRange(msg.getSourceRange());
@@ -674,8 +685,8 @@ class VariadicMethodTypeChecker : public Checker<check::PreObjCMessage> {
/// isVariadicMessage - Returns whether the given message is a variadic message,
/// where all arguments must be Objective-C types.
-bool
-VariadicMethodTypeChecker::isVariadicMessage(const ObjCMethodCall &msg) const {
+bool VariadicMethodTypeChecker::isVariadicMessage(
+ const ObjCMethodCall &msg) const {
const ObjCMethodDecl *MD = msg.getDecl();
if (!MD || !MD->isVariadic() || isa<ObjCProtocolDecl>(MD->getDeclContext()))
@@ -706,16 +717,16 @@ VariadicMethodTypeChecker::isVariadicMessage(const ObjCMethodCall &msg) const {
const ObjCInterfaceDecl *Class = msg.getReceiverInterface();
switch (findKnownClass(Class)) {
- case FC_NSArray:
- return S == arrayWithObjectsS;
- case FC_NSOrderedSet:
- return S == orderedSetWithObjectsS;
- case FC_NSSet:
- return S == setWithObjectsS;
- case FC_NSDictionary:
- return S == dictionaryWithObjectsAndKeysS;
- default:
- return false;
+ case FC_NSArray:
+ return S == arrayWithObjectsS;
+ case FC_NSOrderedSet:
+ return S == orderedSetWithObjectsS;
+ case FC_NSSet:
+ return S == setWithObjectsS;
+ case FC_NSDictionary:
+ return S == dictionaryWithObjectsAndKeysS;
+ default:
+ return false;
}
}
}
@@ -730,7 +741,7 @@ void VariadicMethodTypeChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
ASTContext &Ctx = C.getASTContext();
arrayWithObjectsS = GetUnarySelector("arrayWithObjects", Ctx);
dictionaryWithObjectsAndKeysS =
- GetUnarySelector("dictionaryWithObjectsAndKeys", Ctx);
+ GetUnarySelector("dictionaryWithObjectsAndKeys", Ctx);
setWithObjectsS = GetUnarySelector("setWithObjects", Ctx);
orderedSetWithObjectsS = GetUnarySelector("orderedSetWithObjects", Ctx);
@@ -739,7 +750,7 @@ void VariadicMethodTypeChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
}
if (!isVariadicMessage(msg))
- return;
+ return;
// We are not interested in the selector arguments since they have
// well-defined types, so the compiler will issue a warning for them.
@@ -815,10 +826,9 @@ REGISTER_MAP_WITH_PROGRAMSTATE(ContainerNonEmptyMap, SymbolRef, bool)
namespace {
class ObjCLoopChecker
- : public Checker<check::PostStmt<ObjCForCollectionStmt>,
- check::PostObjCMessage,
- check::DeadSymbols,
- check::PointerEscape > {
+ : public Checker<check::PostStmt<ObjCForCollectionStmt>,
+ check::PostObjCMessage, check::DeadSymbols,
+ check::PointerEscape> {
mutable IdentifierInfo *CountSelectorII = nullptr;
bool isCollectionCountMethod(const ObjCMethodCall &M,
@@ -920,9 +930,10 @@ static ProgramStateRef checkElementNonNil(CheckerContext &C,
/// Returns NULL state if the collection is known to contain elements
/// (or is known not to contain elements if the Assumption parameter is false.)
-static ProgramStateRef
-assumeCollectionNonEmpty(CheckerContext &C, ProgramStateRef State,
- SymbolRef CollectionS, bool Assumption) {
+static ProgramStateRef assumeCollectionNonEmpty(CheckerContext &C,
+ ProgramStateRef State,
+ SymbolRef CollectionS,
+ bool Assumption) {
if (!State || !CollectionS)
return State;
@@ -936,10 +947,9 @@ assumeCollectionNonEmpty(CheckerContext &C, ProgramStateRef State,
SValBuilder &SvalBuilder = C.getSValBuilder();
SVal CountGreaterThanZeroVal =
- SvalBuilder.evalBinOp(State, BO_GT,
- nonloc::SymbolVal(*CountS),
- SvalBuilder.makeIntVal(0, (*CountS)->getType()),
- SvalBuilder.getConditionType());
+ SvalBuilder.evalBinOp(State, BO_GT, nonloc::SymbolVal(*CountS),
+ SvalBuilder.makeIntVal(0, (*CountS)->getType()),
+ SvalBuilder.getConditionType());
std::optional<DefinedSVal> CountGreaterThanZero =
CountGreaterThanZeroVal.getAs<DefinedSVal>();
if (!CountGreaterThanZero) {
@@ -953,8 +963,7 @@ assumeCollectionNonEmpty(CheckerContext &C, ProgramStateRef State,
static ProgramStateRef
assumeCollectionNonEmpty(CheckerContext &C, ProgramStateRef State,
- const ObjCForCollectionStmt *FCS,
- bool Assumption) {
+ const ObjCForCollectionStmt *FCS, bool Assumption) {
if (!State)
return nullptr;
@@ -963,8 +972,9 @@ assumeCollectionNonEmpty(CheckerContext &C, ProgramStateRef State,
}
/// If the fist block edge is a back edge, we are reentering the loop.
-static bool alreadyExecutedAtLeastOneLoopIteration(const ExplodedNode *N,
- const ObjCForCollectionStmt *FCS) {
+static bool
+alreadyExecutedAtLeastOneLoopIteration(const ExplodedNode *N,
+ const ObjCForCollectionStmt *FCS) {
if (!N)
return false;
@@ -989,13 +999,13 @@ void ObjCLoopChecker::checkPostStmt(const ObjCForCollectionStmt *FCS,
// Check if this is the branch for the end of the loop.
if (!ExprEngine::hasMoreIteration(State, FCS, C.getLocationContext())) {
if (!alreadyExecutedAtLeastOneLoopIteration(C.getPredecessor(), FCS))
- State = assumeCollectionNonEmpty(C, State, FCS, /*Assumption*/false);
+ State = assumeCollectionNonEmpty(C, State, FCS, /*Assumption*/ false);
- // Otherwise, this is a branch that goes through the loop body.
+ // Otherwise, this is a branch that goes through the loop body.
} else {
State = checkCollectionNonNil(C, State, FCS);
State = checkElementNonNil(C, State, FCS);
- State = assumeCollectionNonEmpty(C, State, FCS, /*Assumption*/true);
+ State = assumeCollectionNonEmpty(C, State, FCS, /*Assumption*/ true);
}
if (!State)
@@ -1026,9 +1036,7 @@ void ObjCLoopChecker::checkPostObjCMessage(const ObjCMethodCall &M,
return;
FoundationClass Class = findKnownClass(ClassID);
- if (Class != FC_NSDictionary &&
- Class != FC_NSArray &&
- Class != FC_NSSet &&
+ if (Class != FC_NSDictionary && Class != FC_NSArray && Class != FC_NSSet &&
Class != FC_NSOrderedSet)
return;
@@ -1096,11 +1104,9 @@ static SymbolRef getMethodReceiverIfKnownImmutable(const CallEvent *Call) {
return Message->getReceiverSVal().getAsSymbol();
}
-ProgramStateRef
-ObjCLoopChecker::checkPointerEscape(ProgramStateRef State,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind) const {
+ProgramStateRef ObjCLoopChecker::checkPointerEscape(
+ ProgramStateRef State, const InvalidatedSymbols &Escaped,
+ const CallEvent *Call, PointerEscapeKind Kind) const {
SymbolRef ImmutableReceiver = getMethodReceiverIfKnownImmutable(Call);
// Remove the invalidated symbols from the collection count map.
@@ -1141,14 +1147,13 @@ namespace {
/// The checker restricts the return values of APIs known to
/// never (or almost never) return 'nil'.
class ObjCNonNilReturnValueChecker
- : public Checker<check::PostObjCMessage,
- check::PostStmt<ObjCArrayLiteral>,
- check::PostStmt<ObjCDictionaryLiteral>,
- check::PostStmt<ObjCBoxedExpr> > {
- mutable bool Initialized = false;
- mutable Selector ObjectAtIndex;
- mutable Selector ObjectAtIndexedSubscript;
- mutable Selector NullSelector;
+ : public Checker<check::PostObjCMessage, check::PostStmt<ObjCArrayLiteral>,
+ check::PostStmt<ObjCDictionaryLiteral>,
+ check::PostStmt<ObjCBoxedExpr>> {
+ mutable bool Initialized = false;
+ mutable Selector ObjectAtIndex;
+ mutable Selector ObjectAtIndexedSubscript;
+ mutable Selector NullSelector;
public:
ObjCNonNilReturnValueChecker() = default;
@@ -1174,10 +1179,8 @@ class ObjCNonNilReturnValueChecker
};
} // end anonymous namespace
-ProgramStateRef
-ObjCNonNilReturnValueChecker::assumeExprIsNonNull(const Expr *NonNullExpr,
- ProgramStateRef State,
- CheckerContext &C) const {
+ProgramStateRef ObjCNonNilReturnValueChecker::assumeExprIsNonNull(
+ const Expr *NonNullExpr, ProgramStateRef State, CheckerContext &C) const {
SVal Val = C.getSVal(NonNullExpr);
if (std::optional<DefinedOrUnknownSVal> DV =
Val.getAs<DefinedOrUnknownSVal>())
@@ -1185,15 +1188,15 @@ ObjCNonNilReturnValueChecker::assumeExprIsNonNull(const Expr *NonNullExpr,
return State;
}
-void ObjCNonNilReturnValueChecker::checkPostObjCMessage(const ObjCMethodCall &M,
- CheckerContext &C)
- const {
+void ObjCNonNilReturnValueChecker::checkPostObjCMessage(
+ const ObjCMethodCall &M, CheckerContext &C) const {
ProgramStateRef State = C.getState();
if (!Initialized) {
ASTContext &Ctx = C.getASTContext();
ObjectAtIndex = GetUnarySelector("objectAtIndex", Ctx);
- ObjectAtIndexedSubscript = GetUnarySelector("objectAtIndexedSubscript", Ctx);
+ ObjectAtIndexedSubscript =
+ GetUnarySelector("objectAtIndexedSubscript", Ctx);
NullSelector = GetNullarySelector("null", Ctx);
}
@@ -1294,6 +1297,7 @@ void ento::registerObjCNonNilReturnValueChecker(CheckerManager &mgr) {
mgr.registerChecker<ObjCNonNilReturnValueChecker>();
}
-bool ento::shouldRegisterObjCNonNilReturnValueChecker(const CheckerManager &mgr) {
+bool ento::shouldRegisterObjCNonNilReturnValueChecker(
+ const CheckerManager &mgr) {
return true;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/BitwiseShiftChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/BitwiseShiftChecker.cpp
index 339927c165fe00..6825740da5dc2d 100644
--- a/clang/lib/StaticAnalyzer/Checkers/BitwiseShiftChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/BitwiseShiftChecker.cpp
@@ -41,11 +41,12 @@ struct NoteTagTemplate {
};
constexpr NoteTagTemplate NoteTagTemplates[] = {
- {"", "right operand of bit shift is less than "},
- {"left operand of bit shift is non-negative", " and right operand is less than "},
- {"right operand of bit shift is non-negative", " but less than "},
- {"both operands of bit shift are non-negative", " and right operand is less than "}
-};
+ {"", "right operand of bit shift is less than "},
+ {"left operand of bit shift is non-negative",
+ " and right operand is less than "},
+ {"right operand of bit shift is non-negative", " but less than "},
+ {"both operands of bit shift are non-negative",
+ " and right operand is less than "}};
/// An implementation detail class which is introduced to split the checker
/// logic into several methods while maintaining a consistently updated state
@@ -80,9 +81,11 @@ class BitwiseShiftValidator {
return PedanticFlag && !Ctx.getASTContext().getLangOpts().CPlusPlus20;
}
- bool assumeRequirement(OperandSide Side, BinaryOperator::Opcode Cmp, unsigned Limit);
+ bool assumeRequirement(OperandSide Side, BinaryOperator::Opcode Cmp,
+ unsigned Limit);
- void recordAssumption(OperandSide Side, BinaryOperator::Opcode Cmp, unsigned Limit);
+ void recordAssumption(OperandSide Side, BinaryOperator::Opcode Cmp,
+ unsigned Limit);
const NoteTag *createNoteTag() const;
BugReportPtr createBugReport(StringRef ShortMsg, StringRef Msg) const;
@@ -182,10 +185,10 @@ BugReportPtr BitwiseShiftValidator::checkOvershift() {
}
}
- std::string ShortMsg = formatv(
- "{0} shift{1}{2} overflows the capacity of '{3}'",
- isLeftShift() ? "Left" : "Right", RightOpStr.empty() ? "" : " by",
- RightOpStr, LHSTy.getAsString());
+ std::string ShortMsg =
+ formatv("{0} shift{1}{2} overflows the capacity of '{3}'",
+ isLeftShift() ? "Left" : "Right", RightOpStr.empty() ? "" : " by",
+ RightOpStr, LHSTy.getAsString());
std::string Msg = formatv(
"The result of {0} shift is undefined because the right "
"operand{1} is{2} not smaller than {3}, the capacity of '{4}'",
@@ -212,15 +215,15 @@ BugReportPtr BitwiseShiftValidator::checkOperandNegative(OperandSide Side) {
if (assumeRequirement(Side, BO_GE, 0))
return nullptr;
- std::string ShortMsg = formatv("{0} operand is negative in {1} shift",
- Side == OperandSide::Left ? "Left" : "Right",
- shiftDir())
- .str();
- std::string Msg = formatv("The result of {0} shift is undefined "
- "because the {1} operand is negative",
- shiftDir(),
- Side == OperandSide::Left ? "left" : "right")
- .str();
+ std::string ShortMsg =
+ formatv("{0} operand is negative in {1} shift",
+ Side == OperandSide::Left ? "Left" : "Right", shiftDir())
+ .str();
+ std::string Msg =
+ formatv("The result of {0} shift is undefined "
+ "because the {1} operand is negative",
+ shiftDir(), Side == OperandSide::Left ? "left" : "right")
+ .str();
return createBugReport(ShortMsg, Msg);
}
@@ -265,8 +268,8 @@ BugReportPtr BitwiseShiftValidator::checkLeftShiftOverflow() {
const std::string CapacityMsg =
formatv("because '{0}' can hold only {1} bits ({2} the sign bit)",
- LHSTy.getAsString(), LeftAvailableBitWidth,
- ShouldPreserveSignBit ? "excluding" : "including");
+ LHSTy.getAsString(), LeftAvailableBitWidth,
+ ShouldPreserveSignBit ? "excluding" : "including");
const SVal Right = Ctx.getSVal(Op->getRHS());
@@ -277,9 +280,9 @@ BugReportPtr BitwiseShiftValidator::checkLeftShiftOverflow() {
const unsigned RHS = ConcreteRight->getValue().getExtValue();
assert(RHS > MaximalAllowedShift);
const unsigned OverflownBits = RHS - MaximalAllowedShift;
- ShortMsg = formatv(
- "The shift '{0} << {1}' overflows the capacity of '{2}'",
- Left->getValue(), ConcreteRight->getValue(), LHSTy.getAsString());
+ ShortMsg = formatv("The shift '{0} << {1}' overflows the capacity of '{2}'",
+ Left->getValue(), ConcreteRight->getValue(),
+ LHSTy.getAsString());
Msg = formatv(
"The shift '{0} << {1}' is undefined {2}, so {3} bit{4} overflow{5}",
Left->getValue(), ConcreteRight->getValue(), CapacityMsg, OverflownBits,
@@ -287,9 +290,8 @@ BugReportPtr BitwiseShiftValidator::checkLeftShiftOverflow() {
} else {
ShortMsg = formatv("Left shift of '{0}' overflows the capacity of '{1}'",
Left->getValue(), LHSTy.getAsString());
- Msg = formatv(
- "Left shift of '{0}' is undefined {1}, so some bits overflow",
- Left->getValue(), CapacityMsg);
+ Msg = formatv("Left shift of '{0}' is undefined {1}, so some bits overflow",
+ Left->getValue(), CapacityMsg);
}
return createBugReport(ShortMsg, Msg);
@@ -298,18 +300,18 @@ BugReportPtr BitwiseShiftValidator::checkLeftShiftOverflow() {
void BitwiseShiftValidator::recordAssumption(OperandSide Side,
BinaryOperator::Opcode Comparison,
unsigned Limit) {
- switch (Comparison) {
- case BO_GE:
- assert(Limit == 0);
- NonNegOperands |= (Side == OperandSide::Left ? NonNegLeft : NonNegRight);
- break;
- case BO_LT:
- assert(Side == OperandSide::Right);
- if (!UpperBoundBitCount || Limit < UpperBoundBitCount.value())
- UpperBoundBitCount = Limit;
- break;
- default:
- llvm_unreachable("this checker does not use other comparison operators");
+ switch (Comparison) {
+ case BO_GE:
+ assert(Limit == 0);
+ NonNegOperands |= (Side == OperandSide::Left ? NonNegLeft : NonNegRight);
+ break;
+ case BO_LT:
+ assert(Side == OperandSide::Right);
+ if (!UpperBoundBitCount || Limit < UpperBoundBitCount.value())
+ UpperBoundBitCount = Limit;
+ break;
+ default:
+ llvm_unreachable("this checker does not use other comparison operators");
}
}
@@ -330,7 +332,8 @@ const NoteTag *BitwiseShiftValidator::createNoteTag() const {
}
std::unique_ptr<PathSensitiveBugReport>
-BitwiseShiftValidator::createBugReport(StringRef ShortMsg, StringRef Msg) const {
+BitwiseShiftValidator::createBugReport(StringRef ShortMsg,
+ StringRef Msg) const {
ProgramStateRef State = Ctx.getState();
if (ExplodedNode *ErrNode = Ctx.generateErrorNode(State)) {
auto BR =
diff --git a/clang/lib/StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp
index 66e080adb1382b..2bad370957229a 100644
--- a/clang/lib/StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp
@@ -53,8 +53,7 @@ class BlockInCriticalSectionChecker : public Checker<check::PostCall> {
void initIdentifierInfo(ASTContext &Ctx) const;
- void reportBlockInCritSection(SymbolRef FileDescSym,
- const CallEvent &call,
+ void reportBlockInCritSection(SymbolRef FileDescSym, const CallEvent &call,
CheckerContext &C) const;
public:
@@ -79,17 +78,19 @@ void BlockInCriticalSectionChecker::initIdentifierInfo(ASTContext &Ctx) const {
* function is called instead of early returning it. To avoid this, a bool
* variable (IdentifierInfoInitialized) is used and the function will be run
* only once. */
- IILockGuard = &Ctx.Idents.get(ClassLockGuard);
+ IILockGuard = &Ctx.Idents.get(ClassLockGuard);
IIUniqueLock = &Ctx.Idents.get(ClassUniqueLock);
IdentifierInfoInitialized = true;
}
}
-bool BlockInCriticalSectionChecker::isBlockingFunction(const CallEvent &Call) const {
+bool BlockInCriticalSectionChecker::isBlockingFunction(
+ const CallEvent &Call) const {
return matchesAny(Call, SleepFn, GetcFn, FgetsFn, ReadFn, RecvFn);
}
-bool BlockInCriticalSectionChecker::isLockFunction(const CallEvent &Call) const {
+bool BlockInCriticalSectionChecker::isLockFunction(
+ const CallEvent &Call) const {
if (const auto *Ctor = dyn_cast<CXXConstructorCall>(&Call)) {
auto IdentifierInfo = Ctor->getDecl()->getParent()->getIdentifier();
if (IdentifierInfo == IILockGuard || IdentifierInfo == IIUniqueLock)
@@ -100,7 +101,8 @@ bool BlockInCriticalSectionChecker::isLockFunction(const CallEvent &Call) const
MtxTimedLock, MtxTryLock);
}
-bool BlockInCriticalSectionChecker::isUnlockFunction(const CallEvent &Call) const {
+bool BlockInCriticalSectionChecker::isUnlockFunction(
+ const CallEvent &Call) const {
if (const auto *Dtor = dyn_cast<CXXDestructorCall>(&Call)) {
const auto *DRecordDecl = cast<CXXRecordDecl>(Dtor->getDecl()->getParent());
auto IdentifierInfo = DRecordDecl->getIdentifier();
@@ -115,9 +117,8 @@ void BlockInCriticalSectionChecker::checkPostCall(const CallEvent &Call,
CheckerContext &C) const {
initIdentifierInfo(C.getASTContext());
- if (!isBlockingFunction(Call)
- && !isLockFunction(Call)
- && !isUnlockFunction(Call))
+ if (!isBlockingFunction(Call) && !isLockFunction(Call) &&
+ !isUnlockFunction(Call))
return;
ProgramStateRef State = C.getState();
@@ -155,6 +156,7 @@ void ento::registerBlockInCriticalSectionChecker(CheckerManager &mgr) {
mgr.registerChecker<BlockInCriticalSectionChecker>();
}
-bool ento::shouldRegisterBlockInCriticalSectionChecker(const CheckerManager &mgr) {
+bool ento::shouldRegisterBlockInCriticalSectionChecker(
+ const CheckerManager &mgr) {
return true;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp
index 01e46fa8591c07..4c81aaeef2f5d3 100644
--- a/clang/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp
@@ -28,7 +28,7 @@ class BuiltinFunctionChecker : public Checker<eval::Call> {
bool evalCall(const CallEvent &Call, CheckerContext &C) const;
};
-}
+} // namespace
bool BuiltinFunctionChecker::evalCall(const CallEvent &Call,
CheckerContext &C) const {
@@ -46,7 +46,7 @@ bool BuiltinFunctionChecker::evalCall(const CallEvent &Call,
case Builtin::BI__builtin_assume:
case Builtin::BI__assume: {
- assert (Call.getNumArgs() > 0);
+ assert(Call.getNumArgs() > 0);
SVal Arg = Call.getArgSVal(0);
if (Arg.isUndef())
return true; // Return true to model purity.
@@ -74,7 +74,7 @@ bool BuiltinFunctionChecker::evalCall(const CallEvent &Call,
// just return the value of the subexpression.
// __builtin_addressof is going from a reference to a pointer, but those
// are represented the same way in the analyzer.
- assert (Call.getNumArgs() > 0);
+ assert(Call.getNumArgs() > 0);
SVal Arg = Call.getArgSVal(0);
C.addTransition(state->BindExpr(CE, LCtx, Arg));
return true;
@@ -107,7 +107,8 @@ bool BuiltinFunctionChecker::evalCall(const CallEvent &Call,
SValBuilder &SVB = C.getSValBuilder();
SVal V = UnknownVal();
Expr::EvalResult EVResult;
- if (CE->EvaluateAsInt(EVResult, C.getASTContext(), Expr::SE_NoSideEffects)) {
+ if (CE->EvaluateAsInt(EVResult, C.getASTContext(),
+ Expr::SE_NoSideEffects)) {
// Make sure the result has the correct type.
llvm::APSInt Result = EVResult.Val.getInt();
BasicValueFactory &BVF = SVB.getBasicValueFactory();
diff --git a/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp
index b7b64c3da4f6c8..d9f84b141fa43c 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp
@@ -75,12 +75,9 @@ static QualType getCharPtrType(ASTContext &Ctx, CharKind CK) {
: Ctx.WideCharTy);
}
-class CStringChecker : public Checker< eval::Call,
- check::PreStmt<DeclStmt>,
- check::LiveSymbols,
- check::DeadSymbols,
- check::RegionChanges
- > {
+class CStringChecker
+ : public Checker<eval::Call, check::PreStmt<DeclStmt>, check::LiveSymbols,
+ check::DeadSymbols, check::RegionChanges> {
mutable std::unique_ptr<BugType> BT_Null, BT_Bounds, BT_Overlap,
BT_NotCString, BT_AdditionOverflow, BT_UninitRead;
@@ -105,7 +102,10 @@ class CStringChecker : public Checker< eval::Call,
CStringChecksFilter Filter;
- static void *getTag() { static int tag; return &tag; }
+ static void *getTag() {
+ static int tag;
+ return &tag;
+ }
bool evalCall(const CallEvent &Call, CheckerContext &C) const;
void checkPreStmt(const DeclStmt *DS, CheckerContext &C) const;
@@ -113,12 +113,10 @@ class CStringChecker : public Checker< eval::Call,
void checkDeadSymbols(SymbolReaper &SR, CheckerContext &C) const;
ProgramStateRef
- checkRegionChanges(ProgramStateRef state,
- const InvalidatedSymbols *,
- ArrayRef<const MemRegion *> ExplicitRegions,
- ArrayRef<const MemRegion *> Regions,
- const LocationContext *LCtx,
- const CallEvent *Call) const;
+ checkRegionChanges(ProgramStateRef state, const InvalidatedSymbols *,
+ ArrayRef<const MemRegion *> ExplicitRegions,
+ ArrayRef<const MemRegion *> Regions,
+ const LocationContext *LCtx, const CallEvent *Call) const;
using FnCheck = std::function<void(const CStringChecker *, CheckerContext &,
const CallEvent &)>;
@@ -222,28 +220,21 @@ class CStringChecker : public Checker< eval::Call,
bool IsBounded, bool IsBuiltin) const;
// Utility methods
- std::pair<ProgramStateRef , ProgramStateRef >
- static assumeZero(CheckerContext &C,
- ProgramStateRef state, SVal V, QualType Ty);
+ std::pair<ProgramStateRef, ProgramStateRef> static assumeZero(
+ CheckerContext &C, ProgramStateRef state, SVal V, QualType Ty);
static ProgramStateRef setCStringLength(ProgramStateRef state,
- const MemRegion *MR,
- SVal strLength);
+ const MemRegion *MR, SVal strLength);
static SVal getCStringLengthForRegion(CheckerContext &C,
- ProgramStateRef &state,
- const Expr *Ex,
- const MemRegion *MR,
- bool hypothetical);
- SVal getCStringLength(CheckerContext &C,
- ProgramStateRef &state,
- const Expr *Ex,
- SVal Buf,
+ ProgramStateRef &state, const Expr *Ex,
+ const MemRegion *MR, bool hypothetical);
+ SVal getCStringLength(CheckerContext &C, ProgramStateRef &state,
+ const Expr *Ex, SVal Buf,
bool hypothetical = false) const;
const StringLiteral *getCStringLiteral(CheckerContext &C,
ProgramStateRef &state,
- const Expr *expr,
- SVal val) const;
+ const Expr *expr, SVal val) const;
/// Invalidate the destination buffer determined by characters copied.
static ProgramStateRef
@@ -277,9 +268,8 @@ class CStringChecker : public Checker< eval::Call,
static bool SummarizeRegion(raw_ostream &os, ASTContext &Ctx,
const MemRegion *MR);
- static bool memsetAux(const Expr *DstBuffer, SVal CharE,
- const Expr *Size, CheckerContext &C,
- ProgramStateRef &State);
+ static bool memsetAux(const Expr *DstBuffer, SVal CharE, const Expr *Size,
+ CheckerContext &C, ProgramStateRef &State);
// Re-usable checks
ProgramStateRef checkNonNull(CheckerContext &C, ProgramStateRef State,
@@ -296,10 +286,8 @@ class CStringChecker : public Checker< eval::Call,
SizeArgExpr Size, AnyArgExpr First,
AnyArgExpr Second,
CharKind CK = CharKind::Regular) const;
- void emitOverlapBug(CheckerContext &C,
- ProgramStateRef state,
- const Stmt *First,
- const Stmt *Second) const;
+ void emitOverlapBug(CheckerContext &C, ProgramStateRef state,
+ const Stmt *First, const Stmt *Second) const;
void emitNullArgBug(CheckerContext &C, ProgramStateRef State, const Stmt *S,
StringRef WarningMsg) const;
@@ -309,11 +297,10 @@ class CStringChecker : public Checker< eval::Call,
const Stmt *S, StringRef WarningMsg) const;
void emitAdditionOverflowBug(CheckerContext &C, ProgramStateRef State) const;
void emitUninitializedReadBug(CheckerContext &C, ProgramStateRef State,
- const Expr *E) const;
+ const Expr *E) const;
ProgramStateRef checkAdditionOverflow(CheckerContext &C,
- ProgramStateRef state,
- NonLoc left,
- NonLoc right) const;
+ ProgramStateRef state, NonLoc left,
+ NonLoc right) const;
// Return true if the destination buffer of the copy function may be in bound.
// Expects SVal of Size to be positive and unsigned.
@@ -323,7 +310,7 @@ class CStringChecker : public Checker< eval::Call,
QualType LengthTy);
};
-} //end anonymous namespace
+} // end anonymous namespace
REGISTER_MAP_WITH_PROGRAMSTATE(CStringLength, const MemRegion *, SVal)
@@ -331,12 +318,12 @@ REGISTER_MAP_WITH_PROGRAMSTATE(CStringLength, const MemRegion *, SVal)
// Individual checks and utility methods.
//===----------------------------------------------------------------------===//
-std::pair<ProgramStateRef , ProgramStateRef >
+std::pair<ProgramStateRef, ProgramStateRef>
CStringChecker::assumeZero(CheckerContext &C, ProgramStateRef state, SVal V,
QualType Ty) {
std::optional<DefinedSVal> val = V.getAs<DefinedSVal>();
if (!val)
- return std::pair<ProgramStateRef , ProgramStateRef >(state, state);
+ return std::pair<ProgramStateRef, ProgramStateRef>(state, state);
SValBuilder &svalBuilder = C.getSValBuilder();
DefinedOrUnknownSVal zero = svalBuilder.makeZeroVal(Ty);
@@ -635,7 +622,8 @@ ProgramStateRef CStringChecker::CheckOverlap(CheckerContext &C,
}
void CStringChecker::emitOverlapBug(CheckerContext &C, ProgramStateRef state,
- const Stmt *First, const Stmt *Second) const {
+ const Stmt *First,
+ const Stmt *Second) const {
ExplodedNode *N = C.generateErrorNode(state);
if (!N)
return;
@@ -754,9 +742,9 @@ void CStringChecker::emitAdditionOverflowBug(CheckerContext &C,
}
ProgramStateRef CStringChecker::checkAdditionOverflow(CheckerContext &C,
- ProgramStateRef state,
- NonLoc left,
- NonLoc right) const {
+ ProgramStateRef state,
+ NonLoc left,
+ NonLoc right) const {
// If out-of-bounds checking is turned off, skip the rest.
if (!Filter.CheckCStringOutOfBounds)
return state;
@@ -774,25 +762,25 @@ ProgramStateRef CStringChecker::checkAdditionOverflow(CheckerContext &C,
SVal maxMinusRight;
if (isa<nonloc::ConcreteInt>(right)) {
- maxMinusRight = svalBuilder.evalBinOpNN(state, BO_Sub, maxVal, right,
- sizeTy);
+ maxMinusRight =
+ svalBuilder.evalBinOpNN(state, BO_Sub, maxVal, right, sizeTy);
} else {
// Try switching the operands. (The order of these two assignments is
// important!)
- maxMinusRight = svalBuilder.evalBinOpNN(state, BO_Sub, maxVal, left,
- sizeTy);
+ maxMinusRight =
+ svalBuilder.evalBinOpNN(state, BO_Sub, maxVal, left, sizeTy);
left = right;
}
if (std::optional<NonLoc> maxMinusRightNL = maxMinusRight.getAs<NonLoc>()) {
QualType cmpTy = svalBuilder.getConditionType();
// If left > max - right, we have an overflow.
- SVal willOverflow = svalBuilder.evalBinOpNN(state, BO_GT, left,
- *maxMinusRightNL, cmpTy);
+ SVal willOverflow =
+ svalBuilder.evalBinOpNN(state, BO_GT, left, *maxMinusRightNL, cmpTy);
ProgramStateRef stateOverflow, stateOkay;
std::tie(stateOverflow, stateOkay) =
- state->assume(willOverflow.castAs<DefinedOrUnknownSVal>());
+ state->assume(willOverflow.castAs<DefinedOrUnknownSVal>());
if (stateOverflow && !stateOkay) {
// We have an overflow. Emit a bug report.
@@ -809,8 +797,8 @@ ProgramStateRef CStringChecker::checkAdditionOverflow(CheckerContext &C,
}
ProgramStateRef CStringChecker::setCStringLength(ProgramStateRef state,
- const MemRegion *MR,
- SVal strLength) {
+ const MemRegion *MR,
+ SVal strLength) {
assert(!strLength.isUndef() && "Attempt to set an undefined string length");
MR = MR->StripCasts();
@@ -864,10 +852,9 @@ SVal CStringChecker::getCStringLengthForRegion(CheckerContext &C,
// Otherwise, get a new symbol and update the state.
SValBuilder &svalBuilder = C.getSValBuilder();
QualType sizeTy = svalBuilder.getContext().getSizeType();
- SVal strLength = svalBuilder.getMetadataSymbolVal(CStringChecker::getTag(),
- MR, Ex, sizeTy,
- C.getLocationContext(),
- C.blockCount());
+ SVal strLength =
+ svalBuilder.getMetadataSymbolVal(CStringChecker::getTag(), MR, Ex, sizeTy,
+ C.getLocationContext(), C.blockCount());
if (!hypothetical) {
if (std::optional<NonLoc> strLn = strLength.getAs<NonLoc>()) {
@@ -875,8 +862,8 @@ SVal CStringChecker::getCStringLengthForRegion(CheckerContext &C,
BasicValueFactory &BVF = svalBuilder.getBasicValueFactory();
const llvm::APSInt &maxValInt = BVF.getMaxValue(sizeTy);
llvm::APSInt fourInt = APSIntType(maxValInt).getValue(4);
- const llvm::APSInt *maxLengthInt = BVF.evalAPSInt(BO_Div, maxValInt,
- fourInt);
+ const llvm::APSInt *maxLengthInt =
+ BVF.evalAPSInt(BO_Div, maxValInt, fourInt);
NonLoc maxLength = svalBuilder.makeIntVal(*maxLengthInt);
SVal evalLength = svalBuilder.evalBinOpNN(state, BO_LE, *strLn, maxLength,
svalBuilder.getConditionType());
@@ -978,7 +965,9 @@ SVal CStringChecker::getCStringLength(CheckerContext &C, ProgramStateRef &state,
}
const StringLiteral *CStringChecker::getCStringLiteral(CheckerContext &C,
- ProgramStateRef &state, const Expr *expr, SVal val) const {
+ ProgramStateRef &state,
+ const Expr *expr,
+ SVal val) const {
// Get the memory region pointed to by the val.
const MemRegion *bufRegion = val.getAsRegion();
@@ -989,7 +978,7 @@ const StringLiteral *CStringChecker::getCStringLiteral(CheckerContext &C,
bufRegion = bufRegion->StripCasts();
// Cast the memory region to a string region.
- const StringRegion *strRegion= dyn_cast<StringRegion>(bufRegion);
+ const StringRegion *strRegion = dyn_cast<StringRegion>(bufRegion);
if (!strRegion)
return nullptr;
@@ -1543,7 +1532,7 @@ void CStringChecker::evalstrLengthCommon(CheckerContext &C,
ProgramStateRef stateZeroSize, stateNonZeroSize;
std::tie(stateZeroSize, stateNonZeroSize) =
- assumeZero(C, state, maxlenVal, maxlenExpr->getType());
+ assumeZero(C, state, maxlenVal, maxlenExpr->getType());
// If the size can be zero, the result will be 0 in that case, and we don't
// have to check the string itself.
@@ -1619,15 +1608,19 @@ void CStringChecker::evalstrLengthCommon(CheckerContext &C,
NonLoc resultNL = result.castAs<NonLoc>();
if (strLengthNL) {
- state = state->assume(C.getSValBuilder().evalBinOpNN(
- state, BO_LE, resultNL, *strLengthNL, cmpTy)
- .castAs<DefinedOrUnknownSVal>(), true);
+ state = state->assume(
+ C.getSValBuilder()
+ .evalBinOpNN(state, BO_LE, resultNL, *strLengthNL, cmpTy)
+ .castAs<DefinedOrUnknownSVal>(),
+ true);
}
if (maxlenValNL) {
- state = state->assume(C.getSValBuilder().evalBinOpNN(
- state, BO_LE, resultNL, *maxlenValNL, cmpTy)
- .castAs<DefinedOrUnknownSVal>(), true);
+ state = state->assume(
+ C.getSValBuilder()
+ .evalBinOpNN(state, BO_LE, resultNL, *maxlenValNL, cmpTy)
+ .castAs<DefinedOrUnknownSVal>(),
+ true);
}
}
@@ -1903,8 +1896,8 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallEvent &Call,
LCtx, strLength);
} else {
// strlcat returns strlen(src) + strlen(dst)
- SVal retSize = svalBuilder.evalBinOp(
- state, BO_Add, strLength, dstStrLength, sizeTy);
+ SVal retSize = svalBuilder.evalBinOp(state, BO_Add, strLength,
+ dstStrLength, sizeTy);
StateZeroSize =
StateZeroSize->BindExpr(Call.getOriginExpr(), LCtx, retSize);
}
@@ -1995,10 +1988,8 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallEvent &Call,
if (dstStrLengthNL && appendK != ConcatFnKind::none) {
// we extend the dst string with the src
// finalStrLength >= dstStrLength
- SVal destInResult = svalBuilder.evalBinOpNN(state, BO_GE,
- *finalStrLengthNL,
- *dstStrLengthNL,
- cmpTy);
+ SVal destInResult = svalBuilder.evalBinOpNN(
+ state, BO_GE, *finalStrLengthNL, *dstStrLengthNL, cmpTy);
state =
state->assume(destInResult.castAs<DefinedOrUnknownSVal>(), true);
if (!state)
@@ -2021,7 +2012,7 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallEvent &Call,
Result = (ReturnEnd ? UnknownVal() : DstVal);
} else {
if (appendK == ConcatFnKind::strlcat || appendK == ConcatFnKind::none)
- //strlcpy, strlcat
+ // strlcpy, strlcat
Result = strlRetVal;
else
Result = finalStrLength;
@@ -2054,7 +2045,7 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallEvent &Call,
// Then, if the final length is known...
if (std::optional<NonLoc> knownStrLength = finalStrLength.getAs<NonLoc>()) {
SVal lastElement = svalBuilder.evalBinOpLN(state, BO_Add, *dstRegVal,
- *knownStrLength, ptrTy);
+ *knownStrLength, ptrTy);
// ...and we haven't checked the bound, we'll check the actual copy.
if (!boundWarning) {
@@ -2117,25 +2108,25 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallEvent &Call,
void CStringChecker::evalStrcmp(CheckerContext &C,
const CallEvent &Call) const {
- //int strcmp(const char *s1, const char *s2);
+ // int strcmp(const char *s1, const char *s2);
evalStrcmpCommon(C, Call, /* IsBounded = */ false, /* IgnoreCase = */ false);
}
void CStringChecker::evalStrncmp(CheckerContext &C,
const CallEvent &Call) const {
- //int strncmp(const char *s1, const char *s2, size_t n);
+ // int strncmp(const char *s1, const char *s2, size_t n);
evalStrcmpCommon(C, Call, /* IsBounded = */ true, /* IgnoreCase = */ false);
}
void CStringChecker::evalStrcasecmp(CheckerContext &C,
const CallEvent &Call) const {
- //int strcasecmp(const char *s1, const char *s2);
+ // int strcasecmp(const char *s1, const char *s2);
evalStrcmpCommon(C, Call, /* IsBounded = */ false, /* IgnoreCase = */ true);
}
void CStringChecker::evalStrncasecmp(CheckerContext &C,
const CallEvent &Call) const {
- //int strncasecmp(const char *s1, const char *s2, size_t n);
+ // int strncasecmp(const char *s1, const char *s2, size_t n);
evalStrcmpCommon(C, Call, /* IsBounded = */ true, /* IgnoreCase = */ true);
}
@@ -2248,15 +2239,13 @@ void CStringChecker::evalStrcmpCommon(CheckerContext &C, const CallEvent &Call,
// than zero, [c11, p7.24.4.2].
if (compareRes == 0) {
resultVal = svalBuilder.makeIntVal(compareRes, Call.getResultType());
- }
- else {
+ } else {
DefinedSVal zeroVal = svalBuilder.makeIntVal(0, Call.getResultType());
// Constrain strcmp's result range based on the result of StringRef's
// comparison methods.
BinaryOperatorKind op = (compareRes > 0) ? BO_GT : BO_LT;
- SVal compareWithZero =
- svalBuilder.evalBinOp(state, op, resultVal, zeroVal,
- svalBuilder.getConditionType());
+ SVal compareWithZero = svalBuilder.evalBinOp(
+ state, op, resultVal, zeroVal, svalBuilder.getConditionType());
DefinedSVal compareWithZeroVal = compareWithZero.castAs<DefinedSVal>();
state = state->assume(compareWithZeroVal, true);
}
@@ -2437,7 +2426,7 @@ void CStringChecker::evalBzero(CheckerContext &C, const CallEvent &Call) const {
ProgramStateRef StateZeroSize, StateNonZeroSize;
std::tie(StateZeroSize, StateNonZeroSize) =
- assumeZero(C, State, SizeVal, SizeTy);
+ assumeZero(C, State, SizeVal, SizeTy);
// If the size is zero, there won't be any actual memory access,
// In this case we just return.
@@ -2599,7 +2588,7 @@ void CStringChecker::checkPreStmt(const DeclStmt *DS, CheckerContext &C) const {
SVal StrVal = C.getSVal(Init);
assert(StrVal.isValid() && "Initializer string is unknown or undefined");
DefinedOrUnknownSVal strLength =
- getCStringLength(C, state, Init, StrVal).castAs<DefinedOrUnknownSVal>();
+ getCStringLength(C, state, Init, StrVal).castAs<DefinedOrUnknownSVal>();
state = state->set<CStringLength>(MR, strLength);
}
@@ -2607,12 +2596,10 @@ void CStringChecker::checkPreStmt(const DeclStmt *DS, CheckerContext &C) const {
C.addTransition(state);
}
-ProgramStateRef
-CStringChecker::checkRegionChanges(ProgramStateRef state,
- const InvalidatedSymbols *,
+ProgramStateRef CStringChecker::checkRegionChanges(
+ ProgramStateRef state, const InvalidatedSymbols *,
ArrayRef<const MemRegion *> ExplicitRegions,
- ArrayRef<const MemRegion *> Regions,
- const LocationContext *LCtx,
+ ArrayRef<const MemRegion *> Regions, const LocationContext *LCtx,
const CallEvent *Call) const {
CStringLengthTy Entries = state->get<CStringLength>();
if (Entries.isEmpty())
@@ -2657,7 +2644,7 @@ CStringChecker::checkRegionChanges(ProgramStateRef state,
}
void CStringChecker::checkLiveSymbols(ProgramStateRef state,
- SymbolReaper &SR) const {
+ SymbolReaper &SR) const {
// Mark all symbols in our string length map as valid.
CStringLengthTy Entries = state->get<CStringLength>();
@@ -2668,7 +2655,7 @@ void CStringChecker::checkLiveSymbols(ProgramStateRef state,
}
void CStringChecker::checkDeadSymbols(SymbolReaper &SR,
- CheckerContext &C) const {
+ CheckerContext &C) const {
ProgramStateRef state = C.getState();
CStringLengthTy Entries = state->get<CStringLength>();
if (Entries.isEmpty())
diff --git a/clang/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp
index 888724f7ea3b29..6b9ef889c76f77 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp
@@ -11,13 +11,13 @@
// of bytes to copy.
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/Expr.h"
#include "clang/AST/OperationKinds.h"
#include "clang/AST/StmtVisitor.h"
#include "clang/Analysis/AnalysisDeclContext.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Basic/TypeTraits.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
@@ -29,10 +29,10 @@ using namespace clang;
using namespace ento;
namespace {
-class WalkAST: public StmtVisitor<WalkAST> {
+class WalkAST : public StmtVisitor<WalkAST> {
const CheckerBase *Checker;
BugReporter &BR;
- AnalysisDeclContext* AC;
+ AnalysisDeclContext *AC;
/// Check if two expressions refer to the same declaration.
bool sameDecl(const Expr *A1, const Expr *A2) {
@@ -106,9 +106,7 @@ class WalkAST: public StmtVisitor<WalkAST> {
// Statement visitor methods.
void VisitChildren(Stmt *S);
- void VisitStmt(Stmt *S) {
- VisitChildren(S);
- }
+ void VisitStmt(Stmt *S) { VisitChildren(S); }
void VisitCallExpr(CallExpr *CE);
};
} // end anonymous namespace
@@ -178,7 +176,8 @@ bool WalkAST::containsBadStrlcpyStrlcatPattern(const CallExpr *CE) {
// - integral value
// We try to figure out if the last argument is possibly longer
// than the destination can possibly handle if its size can be defined.
- if (const auto *IL = dyn_cast<IntegerLiteral>(LenArg->IgnoreParenImpCasts())) {
+ if (const auto *IL =
+ dyn_cast<IntegerLiteral>(LenArg->IgnoreParenImpCasts())) {
uint64_t ILRawVal = IL->getValue().getZExtValue();
// Case when there is pointer arithmetic on the destination buffer
@@ -189,7 +188,8 @@ bool WalkAST::containsBadStrlcpyStrlcatPattern(const CallExpr *CE) {
dyn_cast<BinaryOperator>(DstArg->IgnoreParenImpCasts())) {
DstArgDRE = dyn_cast<DeclRefExpr>(BE->getLHS()->IgnoreParenImpCasts());
if (BE->getOpcode() == BO_Add) {
- if ((IL = dyn_cast<IntegerLiteral>(BE->getRHS()->IgnoreParenImpCasts()))) {
+ if ((IL = dyn_cast<IntegerLiteral>(
+ BE->getRHS()->IgnoreParenImpCasts()))) {
DstOff = IL->getValue().getZExtValue();
}
}
@@ -219,8 +219,8 @@ void WalkAST::VisitCallExpr(CallExpr *CE) {
if (containsBadStrncatPattern(CE)) {
const Expr *DstArg = CE->getArg(0);
const Expr *LenArg = CE->getArg(2);
- PathDiagnosticLocation Loc =
- PathDiagnosticLocation::createBegin(LenArg, BR.getSourceManager(), AC);
+ PathDiagnosticLocation Loc = PathDiagnosticLocation::createBegin(
+ LenArg, BR.getSourceManager(), AC);
StringRef DstName = getPrintableName(DstArg);
@@ -228,8 +228,10 @@ void WalkAST::VisitCallExpr(CallExpr *CE) {
llvm::raw_svector_ostream os(S);
os << "Potential buffer overflow. ";
if (!DstName.empty()) {
- os << "Replace with 'sizeof(" << DstName << ") "
- "- strlen(" << DstName <<") - 1'";
+ os << "Replace with 'sizeof(" << DstName
+ << ") "
+ "- strlen("
+ << DstName << ") - 1'";
os << " or u";
} else
os << "U";
@@ -244,24 +246,25 @@ void WalkAST::VisitCallExpr(CallExpr *CE) {
if (containsBadStrlcpyStrlcatPattern(CE)) {
const Expr *DstArg = CE->getArg(0);
const Expr *LenArg = CE->getArg(2);
- PathDiagnosticLocation Loc =
- PathDiagnosticLocation::createBegin(LenArg, BR.getSourceManager(), AC);
+ PathDiagnosticLocation Loc = PathDiagnosticLocation::createBegin(
+ LenArg, BR.getSourceManager(), AC);
StringRef DstName = getPrintableName(DstArg);
SmallString<256> S;
llvm::raw_svector_ostream os(S);
- os << "The third argument allows to potentially copy more bytes than it should. ";
+ os << "The third argument allows to potentially copy more bytes than it "
+ "should. ";
os << "Replace with the value ";
if (!DstName.empty())
- os << "sizeof(" << DstName << ")";
+ os << "sizeof(" << DstName << ")";
else
- os << "sizeof(<destination buffer>)";
+ os << "sizeof(<destination buffer>)";
os << " or lower";
BR.EmitBasicReport(FD, Checker, "Anti-pattern in the argument",
- "C String API", os.str(), Loc,
- LenArg->getSourceRange());
+ "C String API", os.str(), Loc,
+ LenArg->getSourceRange());
}
}
@@ -276,16 +279,15 @@ void WalkAST::VisitChildren(Stmt *S) {
}
namespace {
-class CStringSyntaxChecker: public Checker<check::ASTCodeBody> {
+class CStringSyntaxChecker : public Checker<check::ASTCodeBody> {
public:
-
- void checkASTCodeBody(const Decl *D, AnalysisManager& Mgr,
- BugReporter &BR) const {
+ void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
+ BugReporter &BR) const {
WalkAST walker(this, BR, Mgr.getAnalysisDeclContext(D));
walker.Visit(D->getBody());
}
};
-}
+} // namespace
void ento::registerCStringSyntaxChecker(CheckerManager &mgr) {
mgr.registerChecker<CStringSyntaxChecker>();
diff --git a/clang/lib/StaticAnalyzer/Checkers/CXXSelfAssignmentChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/CXXSelfAssignmentChecker.cpp
index 24776338ce10bc..85f90b009a6799 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CXXSelfAssignmentChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CXXSelfAssignmentChecker.cpp
@@ -31,7 +31,7 @@ class CXXSelfAssignmentChecker : public Checker<check::BeginFunction> {
CXXSelfAssignmentChecker();
void checkBeginFunction(CheckerContext &C) const;
};
-}
+} // namespace
CXXSelfAssignmentChecker::CXXSelfAssignmentChecker() {}
@@ -46,14 +46,13 @@ void CXXSelfAssignmentChecker::checkBeginFunction(CheckerContext &C) const {
return;
auto &State = C.getState();
auto &SVB = C.getSValBuilder();
- auto ThisVal =
- State->getSVal(SVB.getCXXThis(MD, LCtx->getStackFrame()));
+ auto ThisVal = State->getSVal(SVB.getCXXThis(MD, LCtx->getStackFrame()));
auto Param = SVB.makeLoc(State->getRegion(MD->getParamDecl(0), LCtx));
auto ParamVal = State->getSVal(Param);
ProgramStateRef SelfAssignState = State->bindLoc(Param, ThisVal, LCtx);
const NoteTag *SelfAssignTag =
- C.getNoteTag([MD](PathSensitiveBugReport &BR) -> std::string {
+ C.getNoteTag([MD](PathSensitiveBugReport &BR) -> std::string {
SmallString<256> Msg;
llvm::raw_svector_ostream Out(Msg);
Out << "Assuming " << MD->getParamDecl(0)->getName() << " == *this";
@@ -63,7 +62,7 @@ void CXXSelfAssignmentChecker::checkBeginFunction(CheckerContext &C) const {
ProgramStateRef NonSelfAssignState = State->bindLoc(Param, ParamVal, LCtx);
const NoteTag *NonSelfAssignTag =
- C.getNoteTag([MD](PathSensitiveBugReport &BR) -> std::string {
+ C.getNoteTag([MD](PathSensitiveBugReport &BR) -> std::string {
SmallString<256> Msg;
llvm::raw_svector_ostream Out(Msg);
Out << "Assuming " << MD->getParamDecl(0)->getName() << " != *this";
diff --git a/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp
index f2e1f69c32cfdc..2e09d5d287355d 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp
@@ -117,8 +117,7 @@ class CallAndMessageChecker
void emitNilReceiverBug(CheckerContext &C, const ObjCMethodCall &msg,
ExplodedNode *N) const;
- void HandleNilReceiver(CheckerContext &C,
- ProgramStateRef state,
+ void HandleNilReceiver(CheckerContext &C, ProgramStateRef state,
const ObjCMethodCall &msg) const;
void LazyInit_BT(const char *desc, std::unique_ptr<BugType> &BT) const {
@@ -138,7 +137,8 @@ void CallAndMessageChecker::emitBadCall(BugType *BT, CheckerContext &C,
if (!N)
return;
- auto R = std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
+ auto R =
+ std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
if (BadE) {
R->addRange(BadE->getSourceRange());
if (BadE->isGLValue())
@@ -194,7 +194,7 @@ bool CallAndMessageChecker::uninitRefOrPointer(
return false;
// No parameter declaration available, i.e. variadic function argument.
- if(!ParamDecl)
+ if (!ParamDecl)
return false;
// If parameter is declared as pointer to const in function declaration,
@@ -212,7 +212,7 @@ bool CallAndMessageChecker::uninitRefOrPointer(
} else
return false;
- if(!ParamDecl->getType()->getPointeeType().isConstQualified())
+ if (!ParamDecl->getType()->getPointeeType().isConstQualified())
return false;
if (const MemRegion *SValMemRegion = V.getAsRegion()) {
@@ -275,16 +275,10 @@ class FindUninitializedField {
};
} // namespace
-bool CallAndMessageChecker::PreVisitProcessArg(CheckerContext &C,
- SVal V,
- SourceRange ArgRange,
- const Expr *ArgEx,
- int ArgumentNumber,
- bool CheckUninitFields,
- const CallEvent &Call,
- std::unique_ptr<BugType> &BT,
- const ParmVarDecl *ParamDecl
- ) const {
+bool CallAndMessageChecker::PreVisitProcessArg(
+ CheckerContext &C, SVal V, SourceRange ArgRange, const Expr *ArgEx,
+ int ArgumentNumber, bool CheckUninitFields, const CallEvent &Call,
+ std::unique_ptr<BugType> &BT, const ParmVarDecl *ParamDecl) const {
const char *BD = "Uninitialized argument value";
if (uninitRefOrPointer(C, V, ArgRange, ArgEx, BT, ParamDecl, BD,
@@ -338,7 +332,9 @@ bool CallAndMessageChecker::PreVisitProcessArg(CheckerContext &C,
os << " (e.g., via the field chain: '";
bool first = true;
for (SmallVectorImpl<const FieldDecl *>::iterator
- DI = F.FieldChain.begin(), DE = F.FieldChain.end(); DI!=DE;++DI){
+ DI = F.FieldChain.begin(),
+ DE = F.FieldChain.end();
+ DI != DE; ++DI) {
if (first)
first = false;
else
@@ -606,7 +602,8 @@ void CallAndMessageChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
}
assert(BT && "Unknown message kind.");
- auto R = std::make_unique<PathSensitiveBugReport>(*BT, BT->getDescription(), N);
+ auto R = std::make_unique<PathSensitiveBugReport>(
+ *BT, BT->getDescription(), N);
const ObjCMessageExpr *ME = msg.getOriginExpr();
R->addRange(ME->getReceiverRange());
@@ -666,7 +663,7 @@ void CallAndMessageChecker::emitNilReceiverBug(CheckerContext &C,
static bool supportsNilWithFloatRet(const llvm::Triple &triple) {
return (triple.getVendor() == llvm::Triple::Apple &&
(triple.isiOS() || triple.isWatchOS() ||
- !triple.isMacOSXVersionLT(10,5)));
+ !triple.isMacOSXVersionLT(10, 5)));
}
void CallAndMessageChecker::HandleNilReceiver(CheckerContext &C,
@@ -689,19 +686,18 @@ void CallAndMessageChecker::HandleNilReceiver(CheckerContext &C,
}
// Other cases: check if sizeof(return type) > sizeof(void*)
- if (CanRetTy != Ctx.VoidTy && C.getLocationContext()->getParentMap()
- .isConsumedExpr(Msg.getOriginExpr())) {
+ if (CanRetTy != Ctx.VoidTy &&
+ C.getLocationContext()->getParentMap().isConsumedExpr(
+ Msg.getOriginExpr())) {
// Compute: sizeof(void *) and sizeof(return type)
const uint64_t voidPtrSize = Ctx.getTypeSize(Ctx.VoidPtrTy);
const uint64_t returnTypeSize = Ctx.getTypeSize(CanRetTy);
- if (CanRetTy.getTypePtr()->isReferenceType()||
+ if (CanRetTy.getTypePtr()->isReferenceType() ||
(voidPtrSize < returnTypeSize &&
!(supportsNilWithFloatRet(Ctx.getTargetInfo().getTriple()) &&
- (Ctx.FloatTy == CanRetTy ||
- Ctx.DoubleTy == CanRetTy ||
- Ctx.LongDoubleTy == CanRetTy ||
- Ctx.LongLongTy == CanRetTy ||
+ (Ctx.FloatTy == CanRetTy || Ctx.DoubleTy == CanRetTy ||
+ Ctx.LongDoubleTy == CanRetTy || Ctx.LongLongTy == CanRetTy ||
Ctx.UnsignedLongLongTy == CanRetTy)))) {
if (ExplodedNode *N = C.generateErrorNode(state, &Tag))
emitNilReceiverBug(C, Msg, N);
diff --git a/clang/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp
index a50772f881f7d0..c89d89e6736785 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp
@@ -23,13 +23,13 @@ using namespace clang;
using namespace ento;
namespace {
-class CastSizeChecker : public Checker< check::PreStmt<CastExpr> > {
+class CastSizeChecker : public Checker<check::PreStmt<CastExpr>> {
const BugType BT{this, "Cast region with wrong size."};
public:
void checkPreStmt(const CastExpr *CE, CheckerContext &C) const;
};
-}
+} // namespace
/// Check if we are casting to a struct with a flexible array at the end.
/// \code
@@ -64,7 +64,7 @@ static bool evenFlexibleArraySize(ASTContext &Ctx, CharUnits RegionSize,
const Type *ElemType = Last->getType()->getArrayElementTypeNoTypeQual();
CharUnits FlexSize;
if (const ConstantArrayType *ArrayTy =
- Ctx.getAsConstantArrayType(Last->getType())) {
+ Ctx.getAsConstantArrayType(Last->getType())) {
FlexSize = Ctx.getTypeSizeInChars(ElemType);
if (ArrayTy->getSize() == 1 && TypeSize > FlexSize)
TypeSize -= FlexSize;
@@ -86,7 +86,8 @@ static bool evenFlexibleArraySize(ASTContext &Ctx, CharUnits RegionSize,
return Left % FlexSize == 0;
}
-void CastSizeChecker::checkPreStmt(const CastExpr *CE,CheckerContext &C) const {
+void CastSizeChecker::checkPreStmt(const CastExpr *CE,
+ CheckerContext &C) const {
const Expr *E = CE->getSubExpr();
ASTContext &Ctx = C.getASTContext();
QualType ToTy = Ctx.getCanonicalType(CE->getType());
diff --git a/clang/lib/StaticAnalyzer/Checkers/CastToStructChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/CastToStructChecker.cpp
index e674ec43bcd9df..43922d3735e1a8 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CastToStructChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CastToStructChecker.cpp
@@ -12,8 +12,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/RecursiveASTVisitor.h"
+#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"
@@ -34,7 +34,7 @@ class CastToStructVisitor : public RecursiveASTVisitor<CastToStructVisitor> {
: BR(B), Checker(Checker), AC(A) {}
bool VisitCastExpr(const CastExpr *CE);
};
-}
+} // namespace
bool CastToStructVisitor::VisitCastExpr(const CastExpr *CE) {
const Expr *E = CE->getSubExpr();
@@ -62,12 +62,13 @@ bool CastToStructVisitor::VisitCastExpr(const CastExpr *CE) {
if (!OrigPointeeTy->isRecordType()) {
SourceRange Sr[1] = {CE->getSourceRange()};
PathDiagnosticLocation Loc(CE, BR.getSourceManager(), AC);
- BR.EmitBasicReport(
- AC->getDecl(), Checker, "Cast from non-struct type to struct type",
- categories::LogicError, "Casting a non-structure type to a structure "
- "type and accessing a field can lead to memory "
- "access errors or data corruption.",
- Loc, Sr);
+ BR.EmitBasicReport(AC->getDecl(), Checker,
+ "Cast from non-struct type to struct type",
+ categories::LogicError,
+ "Casting a non-structure type to a structure "
+ "type and accessing a field can lead to memory "
+ "access errors or data corruption.",
+ Loc, Sr);
} else {
// Don't warn when size of data is unknown.
const auto *U = dyn_cast<UnaryOperator>(E);
@@ -83,8 +84,7 @@ bool CastToStructVisitor::VisitCastExpr(const CastExpr *CE) {
if (!VD || VD->getType()->isReferenceType())
return true;
- if (ToPointeeTy->isIncompleteType() ||
- OrigPointeeTy->isIncompleteType())
+ if (ToPointeeTy->isIncompleteType() || OrigPointeeTy->isIncompleteType())
return true;
// Warn when there is widening cast.
diff --git a/clang/lib/StaticAnalyzer/Checkers/CastValueChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/CastValueChecker.cpp
index f02d20d45678b3..5389766d7ab3a2 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CastValueChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CastValueChecker.cpp
@@ -138,8 +138,7 @@ static const NoteTag *getNoteTag(CheckerContext &C,
static const NoteTag *getNoteTag(CheckerContext &C,
SmallVector<QualType, 4> CastToTyVec,
- const Expr *Object,
- bool IsKnownCast) {
+ const Expr *Object, bool IsKnownCast) {
Object = Object->IgnoreParenImpCasts();
return C.getNoteTag(
@@ -161,14 +160,15 @@ static const NoteTag *getNoteTag(CheckerContext &C,
Out << " is";
bool First = true;
- for (QualType CastToTy: CastToTyVec) {
+ for (QualType CastToTy : CastToTyVec) {
std::string CastToName =
CastToTy->getAsCXXRecordDecl()
? CastToTy->getAsCXXRecordDecl()->getNameAsString()
: CastToTy.getAsString();
- Out << ' ' << ((CastToTyVec.size() == 1) ? "not" :
- (First ? "neither" : "nor")) << " a '" << CastToName
- << '\'';
+ Out << ' '
+ << ((CastToTyVec.size() == 1) ? "not"
+ : (First ? "neither" : "nor"))
+ << " a '" << CastToName << '\'';
First = false;
}
@@ -266,7 +266,7 @@ static void addInstanceOfTransition(const CallEvent &Call,
for (unsigned idx = 0; idx < FD->getTemplateSpecializationArgs()->size() - 1;
++idx) {
TemplateArgument CastToTempArg =
- FD->getTemplateSpecializationArgs()->get(idx);
+ FD->getTemplateSpecializationArgs()->get(idx);
switch (CastToTempArg.getKind()) {
default:
return;
@@ -274,7 +274,7 @@ static void addInstanceOfTransition(const CallEvent &Call,
CastToTyVec.push_back(CastToTempArg.getAsType());
break;
case TemplateArgument::Pack:
- for (TemplateArgument ArgInPack: CastToTempArg.pack_elements())
+ for (TemplateArgument ArgInPack : CastToTempArg.pack_elements())
CastToTyVec.push_back(ArgInPack.getAsType());
break;
}
@@ -286,7 +286,7 @@ static void addInstanceOfTransition(const CallEvent &Call,
bool Success = false;
bool IsAnyKnown = false;
- for (QualType CastToTy: CastToTyVec) {
+ for (QualType CastToTy : CastToTyVec) {
if (CastFromTy->isPointerType())
CastToTy = C.getASTContext().getPointerType(CastToTy);
else if (CastFromTy->isReferenceType())
@@ -295,7 +295,7 @@ static void addInstanceOfTransition(const CallEvent &Call,
return;
const DynamicCastInfo *CastInfo =
- getDynamicCastInfo(State, MR, CastFromTy, CastToTy);
+ getDynamicCastInfo(State, MR, CastFromTy, CastToTy);
bool CastSucceeds;
if (CastInfo)
@@ -313,11 +313,11 @@ static void addInstanceOfTransition(const CallEvent &Call,
if (CastSucceeds) {
Success = true;
- C.addTransition(
- NewState->BindExpr(Call.getOriginExpr(), C.getLocationContext(),
- C.getSValBuilder().makeTruthVal(true)),
- getNoteTag(C, CastInfo, CastToTy, Call.getArgExpr(0), true,
- IsKnownCast));
+ C.addTransition(NewState->BindExpr(Call.getOriginExpr(),
+ C.getLocationContext(),
+ C.getSValBuilder().makeTruthVal(true)),
+ getNoteTag(C, CastInfo, CastToTy, Call.getArgExpr(0),
+ true, IsKnownCast));
if (IsKnownCast)
return;
} else if (CastInfo && CastInfo->succeeds()) {
@@ -327,10 +327,10 @@ static void addInstanceOfTransition(const CallEvent &Call,
}
if (!Success) {
- C.addTransition(
- State->BindExpr(Call.getOriginExpr(), C.getLocationContext(),
- C.getSValBuilder().makeTruthVal(false)),
- getNoteTag(C, CastToTyVec, Call.getArgExpr(0), IsAnyKnown));
+ C.addTransition(State->BindExpr(Call.getOriginExpr(),
+ C.getLocationContext(),
+ C.getSValBuilder().makeTruthVal(false)),
+ getNoteTag(C, CastToTyVec, Call.getArgExpr(0), IsAnyKnown));
}
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp b/clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp
index 978bc0bb082f80..eb3552c2c7abb6 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp
@@ -27,14 +27,14 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
-#include "clang/Analysis/PathDiagnostic.h"
#include "clang/AST/Attr.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprObjC.h"
+#include "clang/Analysis/PathDiagnostic.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/TargetInfo.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
@@ -93,10 +93,8 @@ namespace {
class ObjCDeallocChecker
: public Checker<check::ASTDecl<ObjCImplementationDecl>,
check::PreObjCMessage, check::PostObjCMessage,
- check::PreCall,
- check::BeginFunction, check::EndFunction,
- eval::Assume,
- check::PointerEscape,
+ check::PreCall, check::BeginFunction, check::EndFunction,
+ eval::Assume, check::PointerEscape,
check::PreStmt<ReturnStmt>> {
mutable const IdentifierInfo *NSObjectII = nullptr;
@@ -116,7 +114,7 @@ class ObjCDeallocChecker
categories::MemoryRefCount};
public:
- void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& Mgr,
+ void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager &Mgr,
BugReporter &BR) const;
void checkBeginFunction(CheckerContext &Ctx) const;
void checkPreObjCMessage(const ObjCMethodCall &M, CheckerContext &C) const;
@@ -149,7 +147,7 @@ class ObjCDeallocChecker
const ObjCIvarRegion *getIvarRegionForIvarSymbol(SymbolRef IvarSym) const;
SymbolRef getInstanceSymbolFromIvarSymbol(SymbolRef IvarSym) const;
- const ObjCPropertyImplDecl*
+ const ObjCPropertyImplDecl *
findPropertyOnDeallocatingInstance(SymbolRef IvarSym,
CheckerContext &C) const;
@@ -183,13 +181,11 @@ class ObjCDeallocChecker
};
} // End anonymous namespace.
-
/// Maps from the symbol for a class instance to the set of
/// symbols remaining that must be released in -dealloc.
REGISTER_SET_FACTORY_WITH_PROGRAMSTATE(SymbolSet, SymbolRef)
REGISTER_MAP_WITH_PROGRAMSTATE(UnreleasedIvarMap, SymbolRef, SymbolSet)
-
/// An AST check that diagnose when the class requires a -dealloc method and
/// is missing one.
void ObjCDeallocChecker::checkASTDecl(const ObjCImplementationDecl *D,
@@ -234,7 +230,7 @@ void ObjCDeallocChecker::checkASTDecl(const ObjCImplementationDecl *D,
}
if (!MD) { // No dealloc found.
- const char* Name = "Missing -dealloc";
+ const char *Name = "Missing -dealloc";
std::string Buf;
llvm::raw_string_ostream OS(Buf);
@@ -256,8 +252,7 @@ void ObjCDeallocChecker::checkASTDecl(const ObjCImplementationDecl *D,
/// If this is the beginning of -dealloc, mark the values initially stored in
/// instance variables that must be released by the end of -dealloc
/// as unreleased in the state.
-void ObjCDeallocChecker::checkBeginFunction(
- CheckerContext &C) const {
+void ObjCDeallocChecker::checkBeginFunction(CheckerContext &C) const {
initIdentifierInfoAndSelectors(C.getASTContext());
// Only do this if the current method is -dealloc.
@@ -333,8 +328,8 @@ ObjCDeallocChecker::getInstanceSymbolFromIvarSymbol(SymbolRef IvarSym) const {
/// If we are in -dealloc or -dealloc is on the stack, handle the call if it is
/// a release or a nilling-out property setter.
-void ObjCDeallocChecker::checkPreObjCMessage(
- const ObjCMethodCall &M, CheckerContext &C) const {
+void ObjCDeallocChecker::checkPreObjCMessage(const ObjCMethodCall &M,
+ CheckerContext &C) const {
// Only run if -dealloc is on the stack.
SVal DeallocedInstance;
if (!instanceDeallocIsOnStack(C, DeallocedInstance))
@@ -352,7 +347,7 @@ void ObjCDeallocChecker::checkPreObjCMessage(
if (ReleasedValue) {
// An instance variable symbol was released with -release:
// [_property release];
- if (diagnoseExtraRelease(ReleasedValue,M, C))
+ if (diagnoseExtraRelease(ReleasedValue, M, C))
return;
} else {
// An instance variable symbol was released nilling out its property:
@@ -385,8 +380,8 @@ void ObjCDeallocChecker::checkPreCall(const CallEvent &Call,
}
/// If the message was a call to '[super dealloc]', diagnose any missing
/// releases.
-void ObjCDeallocChecker::checkPostObjCMessage(
- const ObjCMethodCall &M, CheckerContext &C) const {
+void ObjCDeallocChecker::checkPostObjCMessage(const ObjCMethodCall &M,
+ CheckerContext &C) const {
// We perform this check post-message so that if the super -dealloc
// calls a helper method and that this class overrides, any ivars released in
// the helper method will be recorded before checking.
@@ -396,14 +391,14 @@ void ObjCDeallocChecker::checkPostObjCMessage(
/// Check for missing releases even when -dealloc does not call
/// '[super dealloc]'.
-void ObjCDeallocChecker::checkEndFunction(
- const ReturnStmt *RS, CheckerContext &C) const {
+void ObjCDeallocChecker::checkEndFunction(const ReturnStmt *RS,
+ CheckerContext &C) const {
diagnoseMissingReleases(C);
}
/// Check for missing releases on early return.
-void ObjCDeallocChecker::checkPreStmt(
- const ReturnStmt *RS, CheckerContext &C) const {
+void ObjCDeallocChecker::checkPreStmt(const ReturnStmt *RS,
+ CheckerContext &C) const {
diagnoseMissingReleases(C);
}
@@ -479,7 +474,6 @@ ProgramStateRef ObjCDeallocChecker::checkPointerEscape(
State = State->remove<UnreleasedIvarMap>(Sym);
}
-
SymbolRef InstanceSymbol = getInstanceSymbolFromIvarSymbol(Sym);
if (!InstanceSymbol)
continue;
@@ -573,8 +567,7 @@ void ObjCDeallocChecker::diagnoseMissingReleases(CheckerContext &C) const {
assert(PropDecl->getSetterKind() == ObjCPropertyDecl::Copy ||
PropDecl->getSetterKind() == ObjCPropertyDecl::Retain);
- OS << "The '" << *IvarDecl << "' ivar in '" << *ImplDecl
- << "' was ";
+ OS << "The '" << *IvarDecl << "' ivar in '" << *ImplDecl << "' was ";
if (PropDecl->getSetterKind() == ObjCPropertyDecl::Retain)
OS << "retained";
@@ -685,13 +678,11 @@ bool ObjCDeallocChecker::diagnoseExtraRelease(SymbolRef ReleasedValue,
assert(PropDecl->getSetterKind() == ObjCPropertyDecl::Weak ||
(PropDecl->getSetterKind() == ObjCPropertyDecl::Assign &&
!PropDecl->isReadOnly()) ||
- isReleasedByCIFilterDealloc(PropImpl)
- );
+ isReleasedByCIFilterDealloc(PropImpl));
const ObjCImplDecl *Container = getContainingObjCImpl(C.getLocationContext());
- OS << "The '" << *PropImpl->getPropertyIvarDecl()
- << "' ivar in '" << *Container;
-
+ OS << "The '" << *PropImpl->getPropertyIvarDecl() << "' ivar in '"
+ << *Container;
if (isReleasedByCIFilterDealloc(PropImpl)) {
OS << "' will be released by '-[CIFilter dealloc]' but also released here";
@@ -703,7 +694,7 @@ bool ObjCDeallocChecker::diagnoseExtraRelease(SymbolRef ReleasedValue,
else
OS << "an assign, readwrite";
- OS << " property but was released in 'dealloc'";
+ OS << " property but was released in 'dealloc'";
}
auto BR = std::make_unique<PathSensitiveBugReport>(ExtraReleaseBugType,
@@ -757,8 +748,7 @@ bool ObjCDeallocChecker::diagnoseMistakenDealloc(SymbolRef DeallocedValue,
return true;
}
-void ObjCDeallocChecker::initIdentifierInfoAndSelectors(
- ASTContext &Ctx) const {
+void ObjCDeallocChecker::initIdentifierInfoAndSelectors(ASTContext &Ctx) const {
if (NSObjectII)
return;
@@ -775,8 +765,7 @@ void ObjCDeallocChecker::initIdentifierInfoAndSelectors(
}
/// Returns true if M is a call to '[super dealloc]'.
-bool ObjCDeallocChecker::isSuperDeallocMessage(
- const ObjCMethodCall &M) const {
+bool ObjCDeallocChecker::isSuperDeallocMessage(const ObjCMethodCall &M) const {
if (M.getOriginExpr()->getReceiverKind() != ObjCMessageExpr::SuperInstance)
return false;
@@ -1001,7 +990,7 @@ bool ObjCDeallocChecker::instanceDeallocIsOnStack(const CheckerContext &C,
bool ObjCDeallocChecker::classHasSeparateTeardown(
const ObjCInterfaceDecl *ID) const {
// Suppress if the class is not a subclass of NSObject.
- for ( ; ID ; ID = ID->getSuperClass()) {
+ for (; ID; ID = ID->getSuperClass()) {
IdentifierInfo *II = ID->getIdentifier();
if (II == NSObjectII)
@@ -1040,7 +1029,7 @@ bool ObjCDeallocChecker::isReleasedByCIFilterDealloc(
const ObjCInterfaceDecl *ID =
PropImpl->getPropertyIvarDecl()->getContainingInterface();
- for ( ; ID ; ID = ID->getSuperClass()) {
+ for (; ID; ID = ID->getSuperClass()) {
IdentifierInfo *II = ID->getIdentifier();
if (II == CIFilterII)
return true;
diff --git a/clang/lib/StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp b/clang/lib/StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp
index c8fe5c2ccf384e..1bba08626525c1 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp
@@ -12,11 +12,11 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
-#include "clang/Analysis/PathDiagnostic.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/Type.h"
+#include "clang/Analysis/PathDiagnostic.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "llvm/ADT/DenseMap.h"
@@ -30,7 +30,7 @@ static bool AreTypesCompatible(QualType Derived, QualType Ancestor,
// Right now don't compare the compatibility of pointers. That involves
// looking at subtyping relationships. FIXME: Future patch.
- if (Derived->isAnyPointerType() && Ancestor->isAnyPointerType())
+ if (Derived->isAnyPointerType() && Ancestor->isAnyPointerType())
return true;
return C.typesAreCompatible(Derived, Ancestor);
@@ -49,8 +49,7 @@ static void CompareReturnTypes(const ObjCMethodDecl *MethDerived,
std::string sbuf;
llvm::raw_string_ostream os(sbuf);
- os << "The Objective-C class '"
- << *MethDerived->getClassInterface()
+ os << "The Objective-C class '" << *MethDerived->getClassInterface()
<< "', which is derived from class '"
<< *MethAncestor->getClassInterface()
<< "', defines the instance method '";
@@ -64,8 +63,7 @@ static void CompareReturnTypes(const ObjCMethodDecl *MethDerived,
"behavior for clients of these classes.";
PathDiagnosticLocation MethDLoc =
- PathDiagnosticLocation::createBegin(MethDerived,
- BR.getSourceManager());
+ PathDiagnosticLocation::createBegin(MethDerived, BR.getSourceManager());
BR.EmitBasicReport(
MethDerived, Checker, "Incompatible instance method return type",
@@ -86,7 +84,7 @@ static void CheckObjCInstMethSignature(const ObjCImplementationDecl *ID,
ASTContext &Ctx = BR.getContext();
// Build a DenseMap of the methods for quick querying.
- typedef llvm::DenseMap<Selector,ObjCMethodDecl*> MapTy;
+ typedef llvm::DenseMap<Selector, ObjCMethodDecl *> MapTy;
MapTy IMeths;
unsigned NumMethods = 0;
@@ -122,15 +120,15 @@ static void CheckObjCInstMethSignature(const ObjCImplementationDecl *ID,
//===----------------------------------------------------------------------===//
namespace {
-class ObjCMethSigsChecker : public Checker<
- check::ASTDecl<ObjCImplementationDecl> > {
+class ObjCMethSigsChecker
+ : public Checker<check::ASTDecl<ObjCImplementationDecl>> {
public:
- void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& mgr,
+ void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager &mgr,
BugReporter &BR) const {
CheckObjCInstMethSignature(D, BR, this);
}
};
-}
+} // namespace
void ento::registerObjCMethSigsChecker(CheckerManager &mgr) {
mgr.registerChecker<ObjCMethSigsChecker>();
diff --git a/clang/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp b/clang/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp
index 17af1aebd6d2a0..d0651ce2d48e7a 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp
@@ -10,10 +10,10 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/StmtVisitor.h"
#include "clang/Analysis/AnalysisDeclContext.h"
#include "clang/Basic/TargetInfo.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
@@ -26,11 +26,8 @@ using namespace ento;
static bool isArc4RandomAvailable(const ASTContext &Ctx) {
const llvm::Triple &T = Ctx.getTargetInfo().getTriple();
- return T.getVendor() == llvm::Triple::Apple ||
- T.isOSFreeBSD() ||
- T.isOSNetBSD() ||
- T.isOSOpenBSD() ||
- T.isOSDragonFly();
+ return T.getVendor() == llvm::Triple::Apple || T.isOSFreeBSD() ||
+ T.isOSNetBSD() || T.isOSOpenBSD() || T.isOSDragonFly();
}
namespace {
@@ -68,7 +65,7 @@ struct ChecksFilter {
class WalkAST : public StmtVisitor<WalkAST> {
BugReporter &BR;
- AnalysisDeclContext* AC;
+ AnalysisDeclContext *AC;
enum { num_setids = 6 };
IdentifierInfo *II_setid[num_setids];
@@ -76,17 +73,15 @@ class WalkAST : public StmtVisitor<WalkAST> {
const ChecksFilter &filter;
public:
- WalkAST(BugReporter &br, AnalysisDeclContext* ac,
- const ChecksFilter &f)
- : BR(br), AC(ac), II_setid(),
- CheckRand(isArc4RandomAvailable(BR.getContext())),
- filter(f) {}
+ WalkAST(BugReporter &br, AnalysisDeclContext *ac, const ChecksFilter &f)
+ : BR(br), AC(ac), II_setid(),
+ CheckRand(isArc4RandomAvailable(BR.getContext())), filter(f) {}
// Statement visitor methods.
void VisitCallExpr(CallExpr *CE);
void VisitObjCMessageExpr(ObjCMessageExpr *CE);
void VisitForStmt(ForStmt *S);
- void VisitCompoundStmt (CompoundStmt *S);
+ void VisitCompoundStmt(CompoundStmt *S);
void VisitStmt(Stmt *S) { VisitChildren(S); }
void VisitChildren(Stmt *S);
@@ -137,7 +132,7 @@ void WalkAST::VisitCallExpr(CallExpr *CE) {
// Get the name of the callee. If it's a builtin, strip off the prefix.
IdentifierInfo *II = FD->getIdentifier();
- if (!II) // if no identifier, not a simple C function
+ if (!II) // if no identifier, not a simple C function
return;
StringRef Name = II->getName();
Name.consume_front("__builtin_");
@@ -223,8 +218,8 @@ void WalkAST::VisitForStmt(ForStmt *FS) {
// Returns either 'x' or 'y', depending on which one of them is incremented
// in 'expr', or nullptr if none of them is incremented.
-static const DeclRefExpr*
-getIncrementedVar(const Expr *expr, const VarDecl *x, const VarDecl *y) {
+static const DeclRefExpr *getIncrementedVar(const Expr *expr, const VarDecl *x,
+ const VarDecl *y) {
expr = expr->IgnoreParenCasts();
if (const BinaryOperator *B = dyn_cast<BinaryOperator>(expr)) {
@@ -248,7 +243,8 @@ getIncrementedVar(const Expr *expr, const VarDecl *x, const VarDecl *y) {
if (const UnaryOperator *U = dyn_cast<UnaryOperator>(expr))
return U->isIncrementDecrementOp()
- ? getIncrementedVar(U->getSubExpr(), x, y) : nullptr;
+ ? getIncrementedVar(U->getSubExpr(), x, y)
+ : nullptr;
return nullptr;
}
@@ -289,9 +285,9 @@ void WalkAST::checkLoopConditionForFloat(const ForStmt *FS) {
// Are we comparing variables?
const DeclRefExpr *drLHS =
- dyn_cast<DeclRefExpr>(B->getLHS()->IgnoreParenLValueCasts());
+ dyn_cast<DeclRefExpr>(B->getLHS()->IgnoreParenLValueCasts());
const DeclRefExpr *drRHS =
- dyn_cast<DeclRefExpr>(B->getRHS()->IgnoreParenLValueCasts());
+ dyn_cast<DeclRefExpr>(B->getRHS()->IgnoreParenLValueCasts());
// Does at least one of the variables have a floating point type?
drLHS = drLHS && drLHS->getType()->isRealFloatingType() ? drLHS : nullptr;
@@ -332,10 +328,9 @@ void WalkAST::checkLoopConditionForFloat(const ForStmt *FS) {
const char *bugType = "Floating point variable used as loop counter";
PathDiagnosticLocation FSLoc =
- PathDiagnosticLocation::createBegin(FS, BR.getSourceManager(), AC);
- BR.EmitBasicReport(AC->getDecl(), filter.checkName_FloatLoopCounter,
- bugType, "Security", os.str(),
- FSLoc, ranges);
+ PathDiagnosticLocation::createBegin(FS, BR.getSourceManager(), AC);
+ BR.EmitBasicReport(AC->getDecl(), filter.checkName_FloatLoopCounter, bugType,
+ "Security", os.str(), FSLoc, ranges);
}
//===----------------------------------------------------------------------===//
@@ -372,12 +367,12 @@ void WalkAST::checkCall_bcmp(const CallExpr *CE, const FunctionDecl *FD) {
// Issue a warning.
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_bcmp,
"Use of deprecated function in call to 'bcmp()'",
"Security",
- "The bcmp() function is obsoleted by memcmp().",
- CELoc, CE->getCallee()->getSourceRange());
+ "The bcmp() function is obsoleted by memcmp().", CELoc,
+ CE->getCallee()->getSourceRange());
}
//===----------------------------------------------------------------------===//
@@ -414,7 +409,7 @@ void WalkAST::checkCall_bcopy(const CallExpr *CE, const FunctionDecl *FD) {
// Issue a warning.
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_bcopy,
"Use of deprecated function in call to 'bcopy()'",
"Security",
@@ -455,15 +450,14 @@ void WalkAST::checkCall_bzero(const CallExpr *CE, const FunctionDecl *FD) {
// Issue a warning.
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_bzero,
"Use of deprecated function in call to 'bzero()'",
"Security",
- "The bzero() function is obsoleted by memset().",
- CELoc, CE->getCallee()->getSourceRange());
+ "The bzero() function is obsoleted by memset().", CELoc,
+ CE->getCallee()->getSourceRange());
}
-
//===----------------------------------------------------------------------===//
// Check: Any use of 'gets' is insecure. Most man pages literally says this.
//
@@ -493,10 +487,9 @@ void WalkAST::checkCall_gets(const CallExpr *CE, const FunctionDecl *FD) {
// Issue a warning.
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_gets,
- "Potential buffer overflow in call to 'gets'",
- "Security",
+ "Potential buffer overflow in call to 'gets'", "Security",
"Call to function 'gets' is extremely insecure as it can "
"always result in a buffer overflow",
CELoc, CE->getCallee()->getSourceRange());
@@ -533,10 +526,9 @@ void WalkAST::checkCall_getpw(const CallExpr *CE, const FunctionDecl *FD) {
// Issue a warning.
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_getpw,
- "Potential buffer overflow in call to 'getpw'",
- "Security",
+ "Potential buffer overflow in call to 'getpw'", "Security",
"The getpw() function is dangerous as it may overflow the "
"provided buffer. It is obsoleted by getpwuid().",
CELoc, CE->getCallee()->getSourceRange());
@@ -556,7 +548,7 @@ void WalkAST::checkCall_mktemp(const CallExpr *CE, const FunctionDecl *FD) {
}
const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>();
- if(!FPT)
+ if (!FPT)
return;
// Verify that the function takes a single argument.
@@ -574,7 +566,7 @@ void WalkAST::checkCall_mktemp(const CallExpr *CE, const FunctionDecl *FD) {
// Issue a warning.
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_mktemp,
"Potential insecure temporary file in call 'mktemp'",
"Security",
@@ -594,23 +586,22 @@ void WalkAST::checkCall_mkstemp(const CallExpr *CE, const FunctionDecl *FD) {
StringRef Name = FD->getIdentifier()->getName();
std::pair<signed, signed> ArgSuffix =
- llvm::StringSwitch<std::pair<signed, signed> >(Name)
- .Case("mktemp", std::make_pair(0,-1))
- .Case("mkstemp", std::make_pair(0,-1))
- .Case("mkdtemp", std::make_pair(0,-1))
- .Case("mkstemps", std::make_pair(0,1))
- .Default(std::make_pair(-1, -1));
+ llvm::StringSwitch<std::pair<signed, signed>>(Name)
+ .Case("mktemp", std::make_pair(0, -1))
+ .Case("mkstemp", std::make_pair(0, -1))
+ .Case("mkdtemp", std::make_pair(0, -1))
+ .Case("mkstemps", std::make_pair(0, 1))
+ .Default(std::make_pair(-1, -1));
assert(ArgSuffix.first >= 0 && "Unsupported function");
// Check if the number of arguments is consistent with out expectations.
unsigned numArgs = CE->getNumArgs();
- if ((signed) numArgs <= ArgSuffix.first)
+ if ((signed)numArgs <= ArgSuffix.first)
return;
- const StringLiteral *strArg =
- dyn_cast<StringLiteral>(CE->getArg((unsigned)ArgSuffix.first)
- ->IgnoreParenImpCasts());
+ const StringLiteral *strArg = dyn_cast<StringLiteral>(
+ CE->getArg((unsigned)ArgSuffix.first)->IgnoreParenImpCasts());
// Currently we only handle string literals. It is possible to do better,
// either by looking at references to const variables, or by doing real
@@ -634,23 +625,26 @@ void WalkAST::checkCall_mkstemp(const CallExpr *CE, const FunctionDecl *FD) {
// FIXME: Issue a warning.
if (Result.isNegative())
return;
- suffix = (unsigned) Result.getZExtValue();
+ suffix = (unsigned)Result.getZExtValue();
n = (n > suffix) ? n - suffix : 0;
}
for (unsigned i = 0; i < n; ++i)
- if (str[i] == 'X') ++numX;
+ if (str[i] == 'X')
+ ++numX;
if (numX >= 6)
return;
// Issue a warning.
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
SmallString<512> buf;
llvm::raw_svector_ostream out(buf);
- out << "Call to '" << Name << "' should have at least 6 'X's in the"
- " format string to be secure (" << numX << " 'X'";
+ out << "Call to '" << Name
+ << "' should have at least 6 'X's in the"
+ " format string to be secure ("
+ << numX << " 'X'";
if (numX != 1)
out << 's';
out << " seen";
@@ -662,8 +656,8 @@ void WalkAST::checkCall_mkstemp(const CallExpr *CE, const FunctionDecl *FD) {
}
out << ')';
BR.EmitBasicReport(AC->getDecl(), filter.checkName_mkstemp,
- "Insecure temporary file creation", "Security",
- out.str(), CELoc, strArg->getSourceRange());
+ "Insecure temporary file creation", "Security", out.str(),
+ CELoc, strArg->getSourceRange());
}
//===----------------------------------------------------------------------===//
@@ -693,7 +687,7 @@ void WalkAST::checkCall_strcpy(const CallExpr *CE, const FunctionDecl *FD) {
// Issue a warning.
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_strcpy,
"Potential insecure memory buffer bounds restriction in "
"call 'strcpy'",
@@ -721,7 +715,7 @@ void WalkAST::checkCall_strcat(const CallExpr *CE, const FunctionDecl *FD) {
// Issue a warning.
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_strcpy,
"Potential insecure memory buffer bounds restriction in "
"call 'strcat'",
@@ -870,7 +864,7 @@ void WalkAST::checkCall_rand(const CallExpr *CE, const FunctionDecl *FD) {
if (!PT)
return;
- if (! PT->getPointeeType()->isIntegralOrUnscopedEnumerationType())
+ if (!PT->getPointeeType()->isIntegralOrUnscopedEnumerationType())
return;
} else if (FTP->getNumParams() != 0)
return;
@@ -887,7 +881,7 @@ void WalkAST::checkCall_rand(const CallExpr *CE, const FunctionDecl *FD) {
<< " Use 'arc4random' instead";
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_rand, os1.str(),
"Security", os2.str(), CELoc,
CE->getCallee()->getSourceRange());
@@ -908,13 +902,14 @@ void WalkAST::checkCall_random(const CallExpr *CE, const FunctionDecl *FD) {
// Issue a warning.
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_rand,
"'random' is not a secure random number generator",
"Security",
"The 'random' function produces a sequence of values that "
"an adversary may be able to predict. Use 'arc4random' "
- "instead", CELoc, CE->getCallee()->getSourceRange());
+ "instead",
+ CELoc, CE->getCallee()->getSourceRange());
}
//===----------------------------------------------------------------------===//
@@ -928,7 +923,7 @@ void WalkAST::checkCall_vfork(const CallExpr *CE, const FunctionDecl *FD) {
// All calls to vfork() are insecure, issue a warning.
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_vfork,
"Potential insecure implementation-specific behavior in "
"call 'vfork'",
@@ -1014,10 +1009,8 @@ void WalkAST::checkUncheckedReturnValue(CallExpr *CE) {
return;
if (II_setid[0] == nullptr) {
- static const char * const identifiers[num_setids] = {
- "setuid", "setgid", "seteuid", "setegid",
- "setreuid", "setregid"
- };
+ static const char *const identifiers[num_setids] = {
+ "setuid", "setgid", "seteuid", "setegid", "setreuid", "setregid"};
for (size_t i = 0; i < num_setids; i++)
II_setid[i] = &BR.getContext().Idents.get(identifiers[i]);
@@ -1059,7 +1052,7 @@ void WalkAST::checkUncheckedReturnValue(CallExpr *CE) {
<< "', the following code may execute with unexpected privileges";
PathDiagnosticLocation CELoc =
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), filter.checkName_UncheckedReturn, os1.str(),
"Security", os2.str(), CELoc,
CE->getCallee()->getSourceRange());
@@ -1074,13 +1067,13 @@ class SecuritySyntaxChecker : public Checker<check::ASTCodeBody> {
public:
ChecksFilter filter;
- void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) const {
WalkAST walker(BR, mgr.getAnalysisDeclContext(D), filter);
walker.Visit(D->getBody());
}
};
-}
+} // namespace
void ento::registerSecuritySyntaxChecker(CheckerManager &mgr) {
mgr.registerChecker<SecuritySyntaxChecker>();
diff --git a/clang/lib/StaticAnalyzer/Checkers/CheckSizeofPointer.cpp b/clang/lib/StaticAnalyzer/Checkers/CheckSizeofPointer.cpp
index 0d2551f11583ea..c0b82cb015be46 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CheckSizeofPointer.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CheckSizeofPointer.cpp
@@ -11,8 +11,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/StmtVisitor.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
@@ -24,7 +24,7 @@ namespace {
class WalkAST : public StmtVisitor<WalkAST> {
BugReporter &BR;
const CheckerBase *Checker;
- AnalysisDeclContext* AC;
+ AnalysisDeclContext *AC;
public:
WalkAST(BugReporter &br, const CheckerBase *checker, AnalysisDeclContext *ac)
@@ -33,7 +33,7 @@ class WalkAST : public StmtVisitor<WalkAST> {
void VisitStmt(Stmt *S) { VisitChildren(S); }
void VisitChildren(Stmt *S);
};
-}
+} // namespace
void WalkAST::VisitChildren(Stmt *S) {
for (Stmt *Child : S->children())
@@ -46,8 +46,8 @@ void WalkAST::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
if (E->getKind() != UETT_SizeOf)
return;
- // If an explicit type is used in the code, usually the coder knows what they are
- // doing.
+ // If an explicit type is used in the code, usually the coder knows what they
+ // are doing.
if (E->isArgumentType())
return;
@@ -62,7 +62,7 @@ void WalkAST::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
return;
PathDiagnosticLocation ELoc =
- PathDiagnosticLocation::createBegin(E, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(E, BR.getSourceManager(), AC);
BR.EmitBasicReport(AC->getDecl(), Checker,
"Potential unintended use of sizeof() on pointer type",
categories::LogicError,
@@ -79,13 +79,13 @@ void WalkAST::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
namespace {
class SizeofPointerChecker : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) const {
WalkAST walker(BR, this, mgr.getAnalysisDeclContext(D));
walker.Visit(D->getBody());
}
};
-}
+} // namespace
void ento::registerSizeofPointerChecker(CheckerManager &mgr) {
mgr.registerChecker<SizeofPointerChecker>();
diff --git a/clang/lib/StaticAnalyzer/Checkers/CheckerDocumentation.cpp b/clang/lib/StaticAnalyzer/Checkers/CheckerDocumentation.cpp
index 3e5e2b9139149d..690f8df8af99da 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CheckerDocumentation.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CheckerDocumentation.cpp
@@ -33,30 +33,17 @@ namespace ento {
/// checking.
///
/// \sa CheckerContext
-class CheckerDocumentation : public Checker< check::PreStmt<ReturnStmt>,
- check::PostStmt<DeclStmt>,
- check::PreObjCMessage,
- check::PostObjCMessage,
- check::ObjCMessageNil,
- check::PreCall,
- check::PostCall,
- check::BranchCondition,
- check::NewAllocator,
- check::Location,
- check::Bind,
- check::DeadSymbols,
- check::BeginFunction,
- check::EndFunction,
- check::EndAnalysis,
- check::EndOfTranslationUnit,
- eval::Call,
- eval::Assume,
- check::LiveSymbols,
- check::RegionChanges,
- check::PointerEscape,
- check::ConstPointerEscape,
- check::Event<ImplicitNullDerefEvent>,
- check::ASTDecl<FunctionDecl> > {
+class CheckerDocumentation
+ : public Checker<
+ check::PreStmt<ReturnStmt>, check::PostStmt<DeclStmt>,
+ check::PreObjCMessage, check::PostObjCMessage, check::ObjCMessageNil,
+ check::PreCall, check::PostCall, check::BranchCondition,
+ check::NewAllocator, check::Location, check::Bind, check::DeadSymbols,
+ check::BeginFunction, check::EndFunction, check::EndAnalysis,
+ check::EndOfTranslationUnit, eval::Call, eval::Assume,
+ check::LiveSymbols, check::RegionChanges, check::PointerEscape,
+ check::ConstPointerEscape, check::Event<ImplicitNullDerefEvent>,
+ check::ASTDecl<FunctionDecl>> {
public:
/// Pre-visit the Statement.
///
@@ -179,7 +166,6 @@ class CheckerDocumentation : public Checker< check::PreStmt<ReturnStmt>,
/// check::DeadSymbols
void checkDeadSymbols(SymbolReaper &SR, CheckerContext &C) const {}
-
/// Called when the analyzer core starts analyzing a function,
/// regardless of whether it is analyzed at the top level or is inlined.
///
@@ -202,16 +188,14 @@ class CheckerDocumentation : public Checker< check::PreStmt<ReturnStmt>,
/// See IdempotentOperationChecker for a usage example.
///
/// check::EndAnalysis
- void checkEndAnalysis(ExplodedGraph &G,
- BugReporter &BR,
+ void checkEndAnalysis(ExplodedGraph &G, BugReporter &BR,
ExprEngine &Eng) const {}
/// Called after analysis of a TranslationUnit is complete.
///
/// check::EndOfTranslationUnit
void checkEndOfTranslationUnit(const TranslationUnitDecl *TU,
- AnalysisManager &Mgr,
- BugReporter &BR) const {}
+ AnalysisManager &Mgr, BugReporter &BR) const {}
/// Evaluates function call.
///
@@ -236,9 +220,10 @@ class CheckerDocumentation : public Checker< check::PreStmt<ReturnStmt>,
/// performed on the symbols of interest and change the state accordingly.
///
/// eval::Assume
- ProgramStateRef evalAssume(ProgramStateRef State,
- SVal Cond,
- bool Assumption) const { return State; }
+ ProgramStateRef evalAssume(ProgramStateRef State, SVal Cond,
+ bool Assumption) const {
+ return State;
+ }
/// Allows modifying SymbolReaper object. For example, checkers can explicitly
/// register symbols of interest as live. These symbols will not be marked
@@ -270,12 +255,11 @@ class CheckerDocumentation : public Checker< check::PreStmt<ReturnStmt>,
///
/// check::RegionChanges
ProgramStateRef
- checkRegionChanges(ProgramStateRef State,
- const InvalidatedSymbols *Invalidated,
- ArrayRef<const MemRegion *> ExplicitRegions,
- ArrayRef<const MemRegion *> Regions,
- const LocationContext *LCtx,
- const CallEvent *Call) const {
+ checkRegionChanges(ProgramStateRef State,
+ const InvalidatedSymbols *Invalidated,
+ ArrayRef<const MemRegion *> ExplicitRegions,
+ ArrayRef<const MemRegion *> Regions,
+ const LocationContext *LCtx, const CallEvent *Call) const {
return State;
}
@@ -304,9 +288,9 @@ class CheckerDocumentation : public Checker< check::PreStmt<ReturnStmt>,
/// Note: in most cases checkPointerEscape callback is sufficient.
/// \sa checkPointerEscape
ProgramStateRef checkConstPointerEscape(ProgramStateRef State,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind) const {
+ const InvalidatedSymbols &Escaped,
+ const CallEvent *Call,
+ PointerEscapeKind Kind) const {
return State;
}
@@ -321,14 +305,12 @@ class CheckerDocumentation : public Checker< check::PreStmt<ReturnStmt>,
/// FunctionDecl.
///
/// check::ASTDecl<FunctionDecl>
- void checkASTDecl(const FunctionDecl *D,
- AnalysisManager &Mgr,
+ void checkASTDecl(const FunctionDecl *D, AnalysisManager &Mgr,
BugReporter &BR) const {}
};
void CheckerDocumentation::checkPostStmt(const DeclStmt *DS,
- CheckerContext &C) const {
-}
+ CheckerContext &C) const {}
} // end namespace ento
} // end namespace clang
diff --git a/clang/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp
index be7be15022d360..fa26821ee7ab68 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp
@@ -30,7 +30,7 @@ namespace {
enum Kind { NO_CHROOT, ROOT_CHANGED, JAIL_ENTERED };
bool isRootChanged(intptr_t k) { return k == ROOT_CHANGED; }
-//bool isJailEntered(intptr_t k) { return k == JAIL_ENTERED; }
+// bool isJailEntered(intptr_t k) { return k == JAIL_ENTERED; }
// This checker checks improper use of chroot.
// The state transition:
@@ -82,7 +82,7 @@ void ChrootChecker::evalChroot(const CallEvent &Call, CheckerContext &C) const {
// Once encouter a chroot(), set the enum value ROOT_CHANGED directly in
// the GDM.
- state = Mgr.addGDM(state, ChrootChecker::getTag(), (void*) ROOT_CHANGED);
+ state = Mgr.addGDM(state, ChrootChecker::getTag(), (void *)ROOT_CHANGED);
C.addTransition(state);
}
@@ -101,11 +101,11 @@ void ChrootChecker::evalChdir(const CallEvent &Call, CheckerContext &C) const {
if (const MemRegion *R = ArgVal.getAsRegion()) {
R = R->StripCasts();
- if (const StringRegion* StrRegion= dyn_cast<StringRegion>(R)) {
- const StringLiteral* Str = StrRegion->getStringLiteral();
+ if (const StringRegion *StrRegion = dyn_cast<StringRegion>(R)) {
+ const StringLiteral *Str = StrRegion->getStringLiteral();
if (Str->getString() == "/")
- state = Mgr.addGDM(state, ChrootChecker::getTag(),
- (void*) JAIL_ENTERED);
+ state =
+ Mgr.addGDM(state, ChrootChecker::getTag(), (void *)JAIL_ENTERED);
}
}
@@ -120,9 +120,9 @@ void ChrootChecker::checkPreCall(const CallEvent &Call,
return;
// If jail state is ROOT_CHANGED, generate BugReport.
- void *const* k = C.getState()->FindGDM(ChrootChecker::getTag());
+ void *const *k = C.getState()->FindGDM(ChrootChecker::getTag());
if (k)
- if (isRootChanged((intptr_t) *k))
+ if (isRootChanged((intptr_t)*k))
if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
constexpr llvm::StringLiteral Msg =
"No call of chdir(\"/\") immediately after chroot";
diff --git a/clang/lib/StaticAnalyzer/Checkers/CloneChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/CloneChecker.cpp
index 6692a45a09f776..781445cf5580cf 100644
--- a/clang/lib/StaticAnalyzer/Checkers/CloneChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/CloneChecker.cpp
@@ -12,9 +12,9 @@
///
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/Analysis/CloneDetection.h"
#include "clang/Basic/Diagnostic.h"
+#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"
@@ -191,14 +191,16 @@ void ento::registerCloneChecker(CheckerManager &Mgr) {
Checker, "MinimumCloneComplexity");
if (Checker->MinComplexity < 0)
- Mgr.reportInvalidCheckerOptionValue(
- Checker, "MinimumCloneComplexity", "a non-negative value");
+ Mgr.reportInvalidCheckerOptionValue(Checker, "MinimumCloneComplexity",
+ "a non-negative value");
- Checker->ReportNormalClones = Mgr.getAnalyzerOptions().getCheckerBooleanOption(
- Checker, "ReportNormalClones");
+ Checker->ReportNormalClones =
+ Mgr.getAnalyzerOptions().getCheckerBooleanOption(Checker,
+ "ReportNormalClones");
- Checker->IgnoredFilesPattern = Mgr.getAnalyzerOptions()
- .getCheckerStringOption(Checker, "IgnoredFilesPattern");
+ Checker->IgnoredFilesPattern =
+ Mgr.getAnalyzerOptions().getCheckerStringOption(Checker,
+ "IgnoredFilesPattern");
}
bool ento::shouldRegisterCloneChecker(const CheckerManager &mgr) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/ContainerModeling.cpp b/clang/lib/StaticAnalyzer/Checkers/ContainerModeling.cpp
index 65a2ec4076fdf6..cdba82cee3b452 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ContainerModeling.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ContainerModeling.cpp
@@ -31,7 +31,7 @@ using namespace iterator;
namespace {
class ContainerModeling
- : public Checker<check::PostCall, check::LiveSymbols, check::DeadSymbols> {
+ : public Checker<check::PostCall, check::LiveSymbols, check::DeadSymbols> {
void handleBegin(CheckerContext &C, const Expr *CE, SVal RetVal,
SVal Cont) const;
@@ -135,16 +135,16 @@ ProgramStateRef reassignAllIteratorPositionsUnless(ProgramStateRef State,
SymbolRef Offset,
BinaryOperator::Opcode Opc);
ProgramStateRef rebaseSymbolInIteratorPositionsIf(
- ProgramStateRef State, SValBuilder &SVB, SymbolRef OldSym,
- SymbolRef NewSym, SymbolRef CondSym, BinaryOperator::Opcode Opc);
+ ProgramStateRef State, SValBuilder &SVB, SymbolRef OldSym, SymbolRef NewSym,
+ SymbolRef CondSym, BinaryOperator::Opcode Opc);
SymbolRef rebaseSymbol(ProgramStateRef State, SValBuilder &SVB, SymbolRef Expr,
- SymbolRef OldSym, SymbolRef NewSym);
+ SymbolRef OldSym, SymbolRef NewSym);
bool hasLiveIterators(ProgramStateRef State, const MemRegion *Cont);
} // namespace
void ContainerModeling::checkPostCall(const CallEvent &Call,
- CheckerContext &C) const {
+ CheckerContext &C) const {
const auto *Func = dyn_cast_or_null<FunctionDecl>(Call.getDecl());
if (!Func)
return;
@@ -156,7 +156,7 @@ void ContainerModeling::checkPostCall(const CallEvent &Call,
const auto *InstCall = cast<CXXInstanceCall>(&Call);
if (cast<CXXMethodDecl>(Func)->isMoveAssignmentOperator()) {
handleAssignment(C, InstCall->getCXXThisVal(), Call.getOriginExpr(),
- Call.getArgSVal(0));
+ Call.getArgSVal(0));
return;
}
@@ -212,12 +212,12 @@ void ContainerModeling::checkLiveSymbols(ProgramStateRef State,
const auto CData = Cont.second;
if (CData.getBegin()) {
SR.markLive(CData.getBegin());
- if(const auto *SIE = dyn_cast<SymIntExpr>(CData.getBegin()))
+ if (const auto *SIE = dyn_cast<SymIntExpr>(CData.getBegin()))
SR.markLive(SIE->getLHS());
}
if (CData.getEnd()) {
SR.markLive(CData.getEnd());
- if(const auto *SIE = dyn_cast<SymIntExpr>(CData.getEnd()))
+ if (const auto *SIE = dyn_cast<SymIntExpr>(CData.getEnd()))
SR.markLive(SIE->getLHS());
}
}
@@ -243,7 +243,7 @@ void ContainerModeling::checkDeadSymbols(SymbolReaper &SR,
}
void ContainerModeling::handleBegin(CheckerContext &C, const Expr *CE,
- SVal RetVal, SVal Cont) const {
+ SVal RetVal, SVal Cont) const {
const auto *ContReg = Cont.getAsRegion();
if (!ContReg)
return;
@@ -265,7 +265,7 @@ void ContainerModeling::handleBegin(CheckerContext &C, const Expr *CE,
}
void ContainerModeling::handleEnd(CheckerContext &C, const Expr *CE,
- SVal RetVal, SVal Cont) const {
+ SVal RetVal, SVal Cont) const {
const auto *ContReg = Cont.getAsRegion();
if (!ContReg)
return;
@@ -399,8 +399,7 @@ void ContainerModeling::handleClear(CheckerContext &C, SVal Cont,
}
}
}
- const NoteTag *ChangeTag =
- getChangeTag(C, "became empty", ContReg, ContE);
+ const NoteTag *ChangeTag = getChangeTag(C, "became empty", ContReg, ContE);
State = invalidateAllIteratorPositions(State, ContReg);
C.addTransition(State, ChangeTag);
}
@@ -434,12 +433,12 @@ void ContainerModeling::handlePushBack(CheckerContext &C, SVal Cont,
auto &BVF = SymMgr.getBasicVals();
auto &SVB = C.getSValBuilder();
const auto newEndSym =
- SVB.evalBinOp(State, BO_Add,
- nonloc::SymbolVal(EndSym),
- nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
- SymMgr.getType(EndSym)).getAsSymbol();
+ SVB.evalBinOp(State, BO_Add, nonloc::SymbolVal(EndSym),
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
+ SymMgr.getType(EndSym))
+ .getAsSymbol();
const NoteTag *ChangeTag =
- getChangeTag(C, "extended to the back by 1 position", ContReg, ContE);
+ getChangeTag(C, "extended to the back by 1 position", ContReg, ContE);
State = setContainerData(State, ContReg, CData->newEnd(newEndSym));
C.addTransition(State, ChangeTag);
}
@@ -463,12 +462,12 @@ void ContainerModeling::handlePopBack(CheckerContext &C, SVal Cont,
auto &BVF = SymMgr.getBasicVals();
auto &SVB = C.getSValBuilder();
const auto BackSym =
- SVB.evalBinOp(State, BO_Sub,
- nonloc::SymbolVal(EndSym),
- nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
- SymMgr.getType(EndSym)).getAsSymbol();
+ SVB.evalBinOp(State, BO_Sub, nonloc::SymbolVal(EndSym),
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
+ SymMgr.getType(EndSym))
+ .getAsSymbol();
const NoteTag *ChangeTag =
- getChangeTag(C, "shrank from the back by 1 position", ContReg, ContE);
+ getChangeTag(C, "shrank from the back by 1 position", ContReg, ContE);
// For vector-like and deque-like containers invalidate the last and the
// past-end iterator positions. For list-like containers only invalidate
// the last position
@@ -508,12 +507,12 @@ void ContainerModeling::handlePushFront(CheckerContext &C, SVal Cont,
auto &BVF = SymMgr.getBasicVals();
auto &SVB = C.getSValBuilder();
const auto newBeginSym =
- SVB.evalBinOp(State, BO_Sub,
- nonloc::SymbolVal(BeginSym),
- nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
- SymMgr.getType(BeginSym)).getAsSymbol();
- const NoteTag *ChangeTag =
- getChangeTag(C, "extended to the front by 1 position", ContReg, ContE);
+ SVB.evalBinOp(State, BO_Sub, nonloc::SymbolVal(BeginSym),
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
+ SymMgr.getType(BeginSym))
+ .getAsSymbol();
+ const NoteTag *ChangeTag = getChangeTag(
+ C, "extended to the front by 1 position", ContReg, ContE);
State = setContainerData(State, ContReg, CData->newBegin(newBeginSym));
C.addTransition(State, ChangeTag);
}
@@ -545,12 +544,12 @@ void ContainerModeling::handlePopFront(CheckerContext &C, SVal Cont,
auto &BVF = SymMgr.getBasicVals();
auto &SVB = C.getSValBuilder();
const auto newBeginSym =
- SVB.evalBinOp(State, BO_Add,
- nonloc::SymbolVal(BeginSym),
- nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
- SymMgr.getType(BeginSym)).getAsSymbol();
+ SVB.evalBinOp(State, BO_Add, nonloc::SymbolVal(BeginSym),
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
+ SymMgr.getType(BeginSym))
+ .getAsSymbol();
const NoteTag *ChangeTag =
- getChangeTag(C, "shrank from the front by 1 position", ContReg, ContE);
+ getChangeTag(C, "shrank from the front by 1 position", ContReg, ContE);
State = setContainerData(State, ContReg, CData->newBegin(newBeginSym));
C.addTransition(State, ChangeTag);
}
@@ -658,7 +657,7 @@ void ContainerModeling::handleErase(CheckerContext &C, SVal Cont, SVal Iter1,
}
void ContainerModeling::handleEraseAfter(CheckerContext &C, SVal Cont,
- SVal Iter) const {
+ SVal Iter) const {
auto State = C.getState();
const auto *Pos = getIteratorPosition(State, Iter);
if (!Pos)
@@ -670,10 +669,10 @@ void ContainerModeling::handleEraseAfter(CheckerContext &C, SVal Cont,
auto &BVF = SymMgr.getBasicVals();
auto &SVB = C.getSValBuilder();
const auto NextSym =
- SVB.evalBinOp(State, BO_Add,
- nonloc::SymbolVal(Pos->getOffset()),
- nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
- SymMgr.getType(Pos->getOffset())).getAsSymbol();
+ SVB.evalBinOp(State, BO_Add, nonloc::SymbolVal(Pos->getOffset()),
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
+ SymMgr.getType(Pos->getOffset()))
+ .getAsSymbol();
State = invalidateIteratorPositions(State, NextSym, BO_EQ);
C.addTransition(State);
}
@@ -700,9 +699,9 @@ const NoteTag *ContainerModeling::getChangeTag(CheckerContext &C,
// First try to get the name of the variable from the region
if (const auto *DR = dyn_cast<DeclRegion>(ContReg)) {
Name = DR->getDecl()->getName();
- // If the region is not a `DeclRegion` then use the expression instead
+ // If the region is not a `DeclRegion` then use the expression instead
} else if (const auto *DRE =
- dyn_cast<DeclRefExpr>(ContE->IgnoreParenCasts())) {
+ dyn_cast<DeclRefExpr>(ContE->IgnoreParenCasts())) {
Name = DRE->getDecl()->getName();
}
@@ -713,14 +712,14 @@ const NoteTag *ContainerModeling::getChangeTag(CheckerContext &C,
SmallString<256> Msg;
llvm::raw_svector_ostream Out(Msg);
- Out << "Container " << (!Name.empty() ? ("'" + Name.str() + "' ") : "" )
+ Out << "Container " << (!Name.empty() ? ("'" + Name.str() + "' ") : "")
<< Text;
return std::string(Out.str());
});
}
void ContainerModeling::printState(raw_ostream &Out, ProgramStateRef State,
- const char *NL, const char *Sep) const {
+ const char *NL, const char *Sep) const {
auto ContMap = State->get<ContainerMap>();
if (!ContMap.isEmpty()) {
@@ -845,8 +844,8 @@ ProgramStateRef createContainerBegin(ProgramStateRef State,
return State;
auto &SymMgr = State->getSymbolManager();
- const SymbolConjured *Sym = SymMgr.conjureSymbol(E, LCtx, T, BlockCount,
- "begin");
+ const SymbolConjured *Sym =
+ SymMgr.conjureSymbol(E, LCtx, T, BlockCount, "begin");
State = assumeNoOverflow(State, Sym, 4);
if (CDataPtr) {
@@ -868,8 +867,8 @@ ProgramStateRef createContainerEnd(ProgramStateRef State, const MemRegion *Cont,
return State;
auto &SymMgr = State->getSymbolManager();
- const SymbolConjured *Sym = SymMgr.conjureSymbol(E, LCtx, T, BlockCount,
- "end");
+ const SymbolConjured *Sym =
+ SymMgr.conjureSymbol(E, LCtx, T, BlockCount, "end");
State = assumeNoOverflow(State, Sym, 4);
if (CDataPtr) {
@@ -989,7 +988,7 @@ ProgramStateRef reassignAllIteratorPositionsUnless(ProgramStateRef State,
BinaryOperator::Opcode Opc) {
auto MatchContAndCompare = [&](const IteratorPosition &Pos) {
return Pos.getContainer() == Cont &&
- !compare(State, Pos.getOffset(), Offset, Opc);
+ !compare(State, Pos.getOffset(), Offset, Opc);
};
auto ReAssign = [&](const IteratorPosition &Pos) {
return Pos.reAssign(NewCont);
@@ -1001,14 +1000,13 @@ ProgramStateRef reassignAllIteratorPositionsUnless(ProgramStateRef State,
// `OldSym - Int` to `NewSym - Int` and `OldSym` to `NewSym` in any iterator
// position offsets where `CondSym` is true.
ProgramStateRef rebaseSymbolInIteratorPositionsIf(
- ProgramStateRef State, SValBuilder &SVB, SymbolRef OldSym,
- SymbolRef NewSym, SymbolRef CondSym, BinaryOperator::Opcode Opc) {
+ ProgramStateRef State, SValBuilder &SVB, SymbolRef OldSym, SymbolRef NewSym,
+ SymbolRef CondSym, BinaryOperator::Opcode Opc) {
auto LessThanEnd = [&](const IteratorPosition &Pos) {
return compare(State, Pos.getOffset(), CondSym, Opc);
};
auto RebaseSymbol = [&](const IteratorPosition &Pos) {
- return Pos.setTo(rebaseSymbol(State, SVB, Pos.getOffset(), OldSym,
- NewSym));
+ return Pos.setTo(rebaseSymbol(State, SVB, Pos.getOffset(), OldSym, NewSym));
};
return processIteratorPositions(State, LessThanEnd, RebaseSymbol);
}
@@ -1020,16 +1018,18 @@ SymbolRef rebaseSymbol(ProgramStateRef State, SValBuilder &SVB,
SymbolRef OrigExpr, SymbolRef OldExpr,
SymbolRef NewSym) {
auto &SymMgr = SVB.getSymbolManager();
- auto Diff = SVB.evalBinOpNN(State, BO_Sub, nonloc::SymbolVal(OrigExpr),
- nonloc::SymbolVal(OldExpr),
- SymMgr.getType(OrigExpr));
+ auto Diff =
+ SVB.evalBinOpNN(State, BO_Sub, nonloc::SymbolVal(OrigExpr),
+ nonloc::SymbolVal(OldExpr), SymMgr.getType(OrigExpr));
const auto DiffInt = Diff.getAs<nonloc::ConcreteInt>();
if (!DiffInt)
return OrigExpr;
- return SVB.evalBinOpNN(State, BO_Add, *DiffInt, nonloc::SymbolVal(NewSym),
- SymMgr.getType(OrigExpr)).getAsSymbol();
+ return SVB
+ .evalBinOpNN(State, BO_Add, *DiffInt, nonloc::SymbolVal(NewSym),
+ SymMgr.getType(OrigExpr))
+ .getAsSymbol();
}
bool hasLiveIterators(ProgramStateRef State, const MemRegion *Cont) {
@@ -1061,7 +1061,7 @@ bool ento::shouldRegisterContainerModeling(const CheckerManager &mgr) {
if (!mgr.getAnalyzerOptions().ShouldAggressivelySimplifyBinaryOperation) {
mgr.getASTContext().getDiagnostics().Report(
diag::err_analyzer_checker_incompatible_analyzer_option)
- << "aggressive-binary-operation-simplification" << "false";
+ << "aggressive-binary-operation-simplification" << "false";
return false;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/ConversionChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ConversionChecker.cpp
index eca8d3cc072292..bb95746f3c3256 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ConversionChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ConversionChecker.cpp
@@ -23,8 +23,8 @@
// is an alternative to those checks.
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/ParentMap.h"
+#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"
@@ -52,7 +52,7 @@ class ConversionChecker : public Checker<check::PreStmt<ImplicitCastExpr>> {
void reportBug(ExplodedNode *N, const Expr *E, CheckerContext &C,
const char Msg[]) const;
};
-}
+} // namespace
void ConversionChecker::checkPreStmt(const ImplicitCastExpr *Cast,
CheckerContext &C) const {
diff --git a/clang/lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp
index 86f446fc411ca2..f9358b0780de15 100644
--- a/clang/lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp
@@ -59,8 +59,7 @@ class EHCodeVisitor : public RecursiveASTVisitor<EHCodeVisitor> {
return true;
}
- EHCodeVisitor(llvm::DenseSet<const VarDecl *> &S) :
- inEH(false), S(S) {}
+ EHCodeVisitor(llvm::DenseSet<const VarDecl *> &S) : inEH(false), S(S) {}
};
// FIXME: Eventually migrate into its own file, and have it managed by
@@ -68,9 +67,10 @@ class EHCodeVisitor : public RecursiveASTVisitor<EHCodeVisitor> {
class ReachableCode {
const CFG &cfg;
llvm::BitVector reachable;
+
public:
ReachableCode(const CFG &cfg)
- : cfg(cfg), reachable(cfg.getNumBlockIDs(), false) {}
+ : cfg(cfg), reachable(cfg.getNumBlockIDs(), false) {}
void computeReachableBlocks();
@@ -78,13 +78,13 @@ class ReachableCode {
return reachable[block->getBlockID()];
}
};
-}
+} // namespace
void ReachableCode::computeReachableBlocks() {
if (!cfg.getNumBlockIDs())
return;
- SmallVector<const CFGBlock*, 10> worklist;
+ SmallVector<const CFGBlock *, 10> worklist;
worklist.push_back(&cfg.getEntry());
while (!worklist.empty()) {
@@ -130,11 +130,11 @@ class DeadStoresChecker : public Checker<check::ASTCodeBody> {
class DeadStoreObs : public LiveVariables::Observer {
const CFG &cfg;
ASTContext &Ctx;
- BugReporter& BR;
+ BugReporter &BR;
const DeadStoresChecker *Checker;
- AnalysisDeclContext* AC;
- ParentMap& Parents;
- llvm::SmallPtrSet<const VarDecl*, 20> Escaped;
+ AnalysisDeclContext *AC;
+ ParentMap &Parents;
+ llvm::SmallPtrSet<const VarDecl *, 20> Escaped;
std::unique_ptr<ReachableCode> reachableCode;
const CFGBlock *currentBlock;
std::unique_ptr<llvm::DenseSet<const VarDecl *>> InEH;
@@ -189,8 +189,8 @@ class DeadStoreObs : public LiveVariables::Observer {
return false;
}
- void Report(const VarDecl *V, DeadStoreKind dsk,
- PathDiagnosticLocation L, SourceRange R) {
+ void Report(const VarDecl *V, DeadStoreKind dsk, PathDiagnosticLocation L,
+ SourceRange R) {
if (Escaped.count(V))
return;
@@ -214,48 +214,49 @@ class DeadStoreObs : public LiveVariables::Observer {
SmallVector<FixItHint, 1> Fixits;
switch (dsk) {
- case DeadInit: {
- BugType = "Dead initialization";
- os << "Value stored to '" << *V
- << "' during its initialization is never read";
-
- ASTContext &ACtx = V->getASTContext();
- if (Checker->ShowFixIts) {
- if (V->getInit()->HasSideEffects(ACtx,
- /*IncludePossibleEffects=*/true)) {
- break;
- }
- SourceManager &SM = ACtx.getSourceManager();
- const LangOptions &LO = ACtx.getLangOpts();
- SourceLocation L1 =
- Lexer::findNextToken(
- V->getTypeSourceInfo()->getTypeLoc().getEndLoc(),
- SM, LO)->getEndLoc();
- SourceLocation L2 =
- Lexer::getLocForEndOfToken(V->getInit()->getEndLoc(), 1, SM, LO);
- Fixits.push_back(FixItHint::CreateRemoval({L1, L2}));
+ case DeadInit: {
+ BugType = "Dead initialization";
+ os << "Value stored to '" << *V
+ << "' during its initialization is never read";
+
+ ASTContext &ACtx = V->getASTContext();
+ if (Checker->ShowFixIts) {
+ if (V->getInit()->HasSideEffects(ACtx,
+ /*IncludePossibleEffects=*/true)) {
+ break;
}
- break;
+ SourceManager &SM = ACtx.getSourceManager();
+ const LangOptions &LO = ACtx.getLangOpts();
+ SourceLocation L1 =
+ Lexer::findNextToken(
+ V->getTypeSourceInfo()->getTypeLoc().getEndLoc(), SM, LO)
+ ->getEndLoc();
+ SourceLocation L2 =
+ Lexer::getLocForEndOfToken(V->getInit()->getEndLoc(), 1, SM, LO);
+ Fixits.push_back(FixItHint::CreateRemoval({L1, L2}));
}
+ break;
+ }
+
+ case DeadIncrement:
+ BugType = "Dead increment";
+ [[fallthrough]];
+ case Standard:
+ if (!BugType)
+ BugType = "Dead assignment";
+ os << "Value stored to '" << *V << "' is never read";
+ break;
- case DeadIncrement:
- BugType = "Dead increment";
- [[fallthrough]];
- case Standard:
- if (!BugType) BugType = "Dead assignment";
- os << "Value stored to '" << *V << "' is never read";
- break;
-
- // eg.: f((x = foo()))
- case Enclosing:
- if (!Checker->WarnForDeadNestedAssignments)
- return;
- BugType = "Dead nested assignment";
- os << "Although the value stored to '" << *V
- << "' is used in the enclosing expression, the value is never "
- "actually read from '"
- << *V << "'";
- break;
+ // eg.: f((x = foo()))
+ case Enclosing:
+ if (!Checker->WarnForDeadNestedAssignments)
+ return;
+ BugType = "Dead nested assignment";
+ os << "Although the value stored to '" << *V
+ << "' is used in the enclosing expression, the value is never "
+ "actually read from '"
+ << *V << "'";
+ break;
}
BR.EmitBasicReport(AC->getDecl(), Checker, BugType, categories::UnusedCode,
@@ -278,23 +279,23 @@ class DeadStoreObs : public LiveVariables::Observer {
VD->hasAttr<ObjCPreciseLifetimeAttr>())) {
PathDiagnosticLocation ExLoc =
- PathDiagnosticLocation::createBegin(Ex, BR.getSourceManager(), AC);
+ PathDiagnosticLocation::createBegin(Ex, BR.getSourceManager(), AC);
Report(VD, dsk, ExLoc, Val->getSourceRange());
}
}
void CheckDeclRef(const DeclRefExpr *DR, const Expr *Val, DeadStoreKind dsk,
- const LiveVariables::LivenessValues& Live) {
+ const LiveVariables::LivenessValues &Live) {
if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl()))
CheckVarDecl(VD, DR, Val, dsk, Live);
}
- bool isIncrement(VarDecl *VD, const BinaryOperator* B) {
+ bool isIncrement(VarDecl *VD, const BinaryOperator *B) {
if (B->isCompoundAssignmentOp())
return true;
const Expr *RHS = B->getRHS()->IgnoreParenCasts();
- const BinaryOperator* BRHS = dyn_cast<BinaryOperator>(RHS);
+ const BinaryOperator *BRHS = dyn_cast<BinaryOperator>(RHS);
if (!BRHS)
return false;
@@ -323,8 +324,9 @@ class DeadStoreObs : public LiveVariables::Observer {
// Only cover dead stores from regular assignments. ++/-- dead stores
// have never flagged a real bug.
- if (const BinaryOperator* B = dyn_cast<BinaryOperator>(S)) {
- if (!B->isAssignmentOp()) return; // Skip non-assignments.
+ if (const BinaryOperator *B = dyn_cast<BinaryOperator>(S)) {
+ if (!B->isAssignmentOp())
+ return; // Skip non-assignments.
if (DeclRefExpr *DR = dyn_cast<DeclRefExpr>(B->getLHS()))
if (VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) {
@@ -348,14 +350,14 @@ class DeadStoreObs : public LiveVariables::Observer {
return;
// Otherwise, issue a warning.
- DeadStoreKind dsk = Parents.isConsumedExpr(B)
- ? Enclosing
- : (isIncrement(VD,B) ? DeadIncrement : Standard);
+ DeadStoreKind dsk =
+ Parents.isConsumedExpr(B)
+ ? Enclosing
+ : (isIncrement(VD, B) ? DeadIncrement : Standard);
CheckVarDecl(VD, DR, B->getRHS(), dsk, Live);
}
- }
- else if (const UnaryOperator* U = dyn_cast<UnaryOperator>(S)) {
+ } else if (const UnaryOperator *U = dyn_cast<UnaryOperator>(S)) {
if (!U->isIncrementOp() || U->isPrefix())
return;
@@ -367,8 +369,7 @@ class DeadStoreObs : public LiveVariables::Observer {
if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Ex))
CheckDeclRef(DR, U, DeadIncrement, Live);
- }
- else if (const DeclStmt *DS = dyn_cast<DeclStmt>(S))
+ } else if (const DeclStmt *DS = dyn_cast<DeclStmt>(S))
// Iterate through the decls. Warn if any initializers are complex
// expressions that are not live (never used).
for (const auto *DI : DS->decls()) {
@@ -399,8 +400,7 @@ class DeadStoreObs : public LiveVariables::Observer {
// A dead initialization is a variable that is dead after it
// is initialized. We don't flag warnings for those variables
// marked 'unused' or 'objc_precise_lifetime'.
- if (!isLive(Live, V) &&
- !V->hasAttr<UnusedAttr>() &&
+ if (!isLive(Live, V) && !V->hasAttr<UnusedAttr>() &&
!V->hasAttr<ObjCPreciseLifetimeAttr>()) {
// Special case: check for initializations with constants.
//
@@ -435,7 +435,7 @@ class DeadStoreObs : public LiveVariables::Observer {
}
PathDiagnosticLocation Loc =
- PathDiagnosticLocation::create(V, BR.getSourceManager());
+ PathDiagnosticLocation::create(V, BR.getSourceManager());
Report(V, DeadInit, Loc, V->getInit()->getSourceRange());
}
}
@@ -477,7 +477,7 @@ class DeadStoreObs : public LiveVariables::Observer {
namespace {
class FindEscaped {
public:
- llvm::SmallPtrSet<const VarDecl*, 20> Escaped;
+ llvm::SmallPtrSet<const VarDecl *, 20> Escaped;
void operator()(const Stmt *S) {
// Check for '&'. Any VarDecl whose address has been taken we treat as
@@ -501,7 +501,7 @@ class FindEscaped {
}
// Treat local variables captured by reference in C++ lambdas as escaped.
- void findLambdaReferenceCaptures(const LambdaExpr *LE) {
+ void findLambdaReferenceCaptures(const LambdaExpr *LE) {
const CXXRecordDecl *LambdaClass = LE->getLambdaClass();
llvm::DenseMap<const ValueDecl *, FieldDecl *> CaptureFields;
FieldDecl *ThisCaptureField;
@@ -524,7 +524,6 @@ class FindEscaped {
};
} // end anonymous namespace
-
//===----------------------------------------------------------------------===//
// DeadStoresChecker
//===----------------------------------------------------------------------===//
@@ -558,8 +557,7 @@ void ento::registerDeadStoresChecker(CheckerManager &Mgr) {
const AnalyzerOptions &AnOpts = Mgr.getAnalyzerOptions();
Chk->WarnForDeadNestedAssignments =
AnOpts.getCheckerBooleanOption(Chk, "WarnForDeadNestedAssignments");
- Chk->ShowFixIts =
- AnOpts.getCheckerBooleanOption(Chk, "ShowFixIts");
+ Chk->ShowFixIts = AnOpts.getCheckerBooleanOption(Chk, "ShowFixIts");
}
bool ento::shouldRegisterDeadStoresChecker(const CheckerManager &mgr) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp b/clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp
index 04bbe85473c0e0..c087ca6a1a29f9 100644
--- a/clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp
@@ -10,12 +10,12 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/Analysis/Analyses/Dominators.h"
#include "clang/Analysis/Analyses/LiveVariables.h"
#include "clang/Analysis/CallGraph.h"
-#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
@@ -32,7 +32,7 @@ using namespace ento;
namespace {
class DominatorsTreeDumper : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) const {
if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {
CFGDomTree Dom;
@@ -41,7 +41,7 @@ class DominatorsTreeDumper : public Checker<check::ASTCodeBody> {
}
}
};
-}
+} // namespace
void ento::registerDominatorsTreeDumper(CheckerManager &mgr) {
mgr.registerChecker<DominatorsTreeDumper>();
@@ -58,7 +58,7 @@ bool ento::shouldRegisterDominatorsTreeDumper(const CheckerManager &mgr) {
namespace {
class PostDominatorsTreeDumper : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) const {
if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {
CFGPostDomTree Dom;
@@ -67,7 +67,7 @@ class PostDominatorsTreeDumper : public Checker<check::ASTCodeBody> {
}
}
};
-}
+} // namespace
void ento::registerPostDominatorsTreeDumper(CheckerManager &mgr) {
mgr.registerChecker<PostDominatorsTreeDumper>();
@@ -84,7 +84,7 @@ bool ento::shouldRegisterPostDominatorsTreeDumper(const CheckerManager &mgr) {
namespace {
class ControlDependencyTreeDumper : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) const {
if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {
ControlDependencyCalculator Dom(AC->getCFG());
@@ -92,13 +92,14 @@ class ControlDependencyTreeDumper : public Checker<check::ASTCodeBody> {
}
}
};
-}
+} // namespace
void ento::registerControlDependencyTreeDumper(CheckerManager &mgr) {
mgr.registerChecker<ControlDependencyTreeDumper>();
}
-bool ento::shouldRegisterControlDependencyTreeDumper(const CheckerManager &mgr) {
+bool ento::shouldRegisterControlDependencyTreeDumper(
+ const CheckerManager &mgr) {
return true;
}
@@ -109,14 +110,14 @@ bool ento::shouldRegisterControlDependencyTreeDumper(const CheckerManager &mgr)
namespace {
class LiveVariablesDumper : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) const {
- if (LiveVariables* L = mgr.getAnalysis<LiveVariables>(D)) {
+ if (LiveVariables *L = mgr.getAnalysis<LiveVariables>(D)) {
L->dumpBlockLiveness(mgr.getSourceManager());
}
}
};
-}
+} // namespace
void ento::registerLiveVariablesDumper(CheckerManager &mgr) {
mgr.registerChecker<LiveVariablesDumper>();
@@ -133,13 +134,13 @@ bool ento::shouldRegisterLiveVariablesDumper(const CheckerManager &mgr) {
namespace {
class LiveExpressionsDumper : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D, AnalysisManager& Mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
BugReporter &BR) const {
if (LiveVariables *L = Mgr.getAnalysis<RelaxedLiveVariables>(D))
L->dumpExprLiveness(Mgr.getSourceManager());
}
};
-}
+} // namespace
void ento::registerLiveExpressionsDumper(CheckerManager &mgr) {
mgr.registerChecker<LiveExpressionsDumper>();
@@ -156,22 +157,20 @@ bool ento::shouldRegisterLiveExpressionsDumper(const CheckerManager &mgr) {
namespace {
class CFGViewer : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) const {
if (CFG *cfg = mgr.getCFG(D)) {
cfg->viewCFG(mgr.getLangOpts());
}
}
};
-}
+} // namespace
void ento::registerCFGViewer(CheckerManager &mgr) {
mgr.registerChecker<CFGViewer>();
}
-bool ento::shouldRegisterCFGViewer(const CheckerManager &mgr) {
- return true;
-}
+bool ento::shouldRegisterCFGViewer(const CheckerManager &mgr) { return true; }
//===----------------------------------------------------------------------===//
// CFGDumper
@@ -180,7 +179,7 @@ bool ento::shouldRegisterCFGViewer(const CheckerManager &mgr) {
namespace {
class CFGDumper : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) const {
PrintingPolicy Policy(mgr.getLangOpts());
Policy.TerseOutput = true;
@@ -188,36 +187,33 @@ class CFGDumper : public Checker<check::ASTCodeBody> {
D->print(llvm::errs(), Policy);
if (CFG *cfg = mgr.getCFG(D)) {
- cfg->dump(mgr.getLangOpts(),
- llvm::sys::Process::StandardErrHasColors());
+ cfg->dump(mgr.getLangOpts(), llvm::sys::Process::StandardErrHasColors());
}
}
};
-}
+} // namespace
void ento::registerCFGDumper(CheckerManager &mgr) {
mgr.registerChecker<CFGDumper>();
}
-bool ento::shouldRegisterCFGDumper(const CheckerManager &mgr) {
- return true;
-}
+bool ento::shouldRegisterCFGDumper(const CheckerManager &mgr) { return true; }
//===----------------------------------------------------------------------===//
// CallGraphViewer
//===----------------------------------------------------------------------===//
namespace {
-class CallGraphViewer : public Checker< check::ASTDecl<TranslationUnitDecl> > {
+class CallGraphViewer : public Checker<check::ASTDecl<TranslationUnitDecl>> {
public:
- void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager& mgr,
+ void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager &mgr,
BugReporter &BR) const {
CallGraph CG;
- CG.addToCallGraph(const_cast<TranslationUnitDecl*>(TU));
+ CG.addToCallGraph(const_cast<TranslationUnitDecl *>(TU));
CG.viewGraph();
}
};
-}
+} // namespace
void ento::registerCallGraphViewer(CheckerManager &mgr) {
mgr.registerChecker<CallGraphViewer>();
@@ -232,16 +228,16 @@ bool ento::shouldRegisterCallGraphViewer(const CheckerManager &mgr) {
//===----------------------------------------------------------------------===//
namespace {
-class CallGraphDumper : public Checker< check::ASTDecl<TranslationUnitDecl> > {
+class CallGraphDumper : public Checker<check::ASTDecl<TranslationUnitDecl>> {
public:
- void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager& mgr,
+ void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager &mgr,
BugReporter &BR) const {
CallGraph CG;
- CG.addToCallGraph(const_cast<TranslationUnitDecl*>(TU));
+ CG.addToCallGraph(const_cast<TranslationUnitDecl *>(TU));
CG.dump();
}
};
-}
+} // namespace
void ento::registerCallGraphDumper(CheckerManager &mgr) {
mgr.registerChecker<CallGraphDumper>();
@@ -256,7 +252,7 @@ bool ento::shouldRegisterCallGraphDumper(const CheckerManager &mgr) {
//===----------------------------------------------------------------------===//
namespace {
-class ConfigDumper : public Checker< check::EndOfTranslationUnit > {
+class ConfigDumper : public Checker<check::EndOfTranslationUnit> {
typedef AnalyzerOptions::ConfigTable Table;
static int compareEntry(const Table::MapEntryTy *const *LHS,
@@ -266,8 +262,7 @@ class ConfigDumper : public Checker< check::EndOfTranslationUnit > {
public:
void checkEndOfTranslationUnit(const TranslationUnitDecl *TU,
- AnalysisManager& mgr,
- BugReporter &BR) const {
+ AnalysisManager &mgr, BugReporter &BR) const {
const Table &Config = mgr.options.Config;
SmallVector<const Table::MapEntryTy *, 32> Keys;
@@ -282,7 +277,7 @@ class ConfigDumper : public Checker< check::EndOfTranslationUnit > {
<< '\n';
}
};
-}
+} // namespace
void ento::registerConfigDumper(CheckerManager &mgr) {
mgr.registerChecker<ConfigDumper>();
@@ -297,15 +292,16 @@ bool ento::shouldRegisterConfigDumper(const CheckerManager &mgr) {
//===----------------------------------------------------------------------===//
namespace {
-class ExplodedGraphViewer : public Checker< check::EndAnalysis > {
+class ExplodedGraphViewer : public Checker<check::EndAnalysis> {
public:
ExplodedGraphViewer() {}
- void checkEndAnalysis(ExplodedGraph &G, BugReporter &B,ExprEngine &Eng) const {
+ void checkEndAnalysis(ExplodedGraph &G, BugReporter &B,
+ ExprEngine &Eng) const {
Eng.ViewGraph(false);
}
};
-}
+} // namespace
void ento::registerExplodedGraphViewer(CheckerManager &mgr) {
mgr.registerChecker<ExplodedGraphViewer>();
@@ -343,6 +339,4 @@ void ento::registerReportStmts(CheckerManager &mgr) {
mgr.registerChecker<ReportStmts>();
}
-bool ento::shouldRegisterReportStmts(const CheckerManager &mgr) {
- return true;
-}
+bool ento::shouldRegisterReportStmts(const CheckerManager &mgr) { return true; }
diff --git a/clang/lib/StaticAnalyzer/Checkers/DebugContainerModeling.cpp b/clang/lib/StaticAnalyzer/Checkers/DebugContainerModeling.cpp
index 72186a99d94358..045c618936adca 100644
--- a/clang/lib/StaticAnalyzer/Checkers/DebugContainerModeling.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/DebugContainerModeling.cpp
@@ -25,8 +25,7 @@ using namespace iterator;
namespace {
-class DebugContainerModeling
- : public Checker<eval::Call> {
+class DebugContainerModeling : public Checker<eval::Call> {
const BugType DebugMsgBugType{this, "Checking analyzer assumptions", "debug",
/*SuppressOnSink=*/true};
@@ -39,7 +38,7 @@ class DebugContainerModeling
ExplodedNode *reportDebugMsg(llvm::StringRef Msg, CheckerContext &C) const;
typedef void (DebugContainerModeling::*FnCheck)(const CallExpr *,
- CheckerContext &) const;
+ CheckerContext &) const;
CallDescriptionMap<FnCheck> Callbacks = {
{{{"clang_analyzer_container_begin"}, 1},
@@ -90,14 +89,13 @@ void DebugContainerModeling::analyzerContainerDataField(const CallExpr *CE,
// Progpagate interestingness from the container's data (marked
// interesting by an `ExprInspection` debug call to the container
// itself.
- const NoteTag *InterestingTag =
- C.getNoteTag(
- [Cont, Field](PathSensitiveBugReport &BR) -> std::string {
- if (BR.isInteresting(Field)) {
- BR.markInteresting(Cont);
- }
- return "";
- });
+ const NoteTag *InterestingTag = C.getNoteTag(
+ [Cont, Field](PathSensitiveBugReport &BR) -> std::string {
+ if (BR.isInteresting(Field)) {
+ BR.markInteresting(Cont);
+ }
+ return "";
+ });
C.addTransition(State, InterestingTag);
return;
}
@@ -105,22 +103,21 @@ void DebugContainerModeling::analyzerContainerDataField(const CallExpr *CE,
}
auto &BVF = C.getSValBuilder().getBasicValueFactory();
- State = State->BindExpr(CE, C.getLocationContext(),
- nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(0))));
+ State =
+ State->BindExpr(CE, C.getLocationContext(),
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(0))));
}
void DebugContainerModeling::analyzerContainerBegin(const CallExpr *CE,
CheckerContext &C) const {
- analyzerContainerDataField(CE, C, [](const ContainerData *D) {
- return D->getBegin();
- });
+ analyzerContainerDataField(
+ CE, C, [](const ContainerData *D) { return D->getBegin(); });
}
void DebugContainerModeling::analyzerContainerEnd(const CallExpr *CE,
CheckerContext &C) const {
- analyzerContainerDataField(CE, C, [](const ContainerData *D) {
- return D->getEnd();
- });
+ analyzerContainerDataField(
+ CE, C, [](const ContainerData *D) { return D->getEnd(); });
}
ExplodedNode *DebugContainerModeling::reportDebugMsg(llvm::StringRef Msg,
diff --git a/clang/lib/StaticAnalyzer/Checkers/DebugIteratorModeling.cpp b/clang/lib/StaticAnalyzer/Checkers/DebugIteratorModeling.cpp
index 79ab71d7829db7..4bf48b80491bec 100644
--- a/clang/lib/StaticAnalyzer/Checkers/DebugIteratorModeling.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/DebugIteratorModeling.cpp
@@ -25,8 +25,7 @@ using namespace iterator;
namespace {
-class DebugIteratorModeling
- : public Checker<eval::Call> {
+class DebugIteratorModeling : public Checker<eval::Call> {
const BugType DebugMsgBugType{this, "Checking analyzer assumptions", "debug",
/*SuppressOnSink=*/true};
@@ -95,26 +94,35 @@ void DebugIteratorModeling::analyzerIteratorDataField(const CallExpr *CE,
void DebugIteratorModeling::analyzerIteratorPosition(const CallExpr *CE,
CheckerContext &C) const {
auto &BVF = C.getSValBuilder().getBasicValueFactory();
- analyzerIteratorDataField(CE, C, [](const IteratorPosition *P) {
- return nonloc::SymbolVal(P->getOffset());
- }, nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(0))));
+ analyzerIteratorDataField(
+ CE, C,
+ [](const IteratorPosition *P) {
+ return nonloc::SymbolVal(P->getOffset());
+ },
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(0))));
}
void DebugIteratorModeling::analyzerIteratorContainer(const CallExpr *CE,
CheckerContext &C) const {
auto &BVF = C.getSValBuilder().getBasicValueFactory();
- analyzerIteratorDataField(CE, C, [](const IteratorPosition *P) {
- return loc::MemRegionVal(P->getContainer());
- }, loc::ConcreteInt(BVF.getValue(llvm::APSInt::get(0))));
+ analyzerIteratorDataField(
+ CE, C,
+ [](const IteratorPosition *P) {
+ return loc::MemRegionVal(P->getContainer());
+ },
+ loc::ConcreteInt(BVF.getValue(llvm::APSInt::get(0))));
}
void DebugIteratorModeling::analyzerIteratorValidity(const CallExpr *CE,
CheckerContext &C) const {
auto &BVF = C.getSValBuilder().getBasicValueFactory();
- analyzerIteratorDataField(CE, C, [&BVF](const IteratorPosition *P) {
- return
- nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get((P->isValid()))));
- }, nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(0))));
+ analyzerIteratorDataField(
+ CE, C,
+ [&BVF](const IteratorPosition *P) {
+ return nonloc::ConcreteInt(
+ BVF.getValue(llvm::APSInt::get((P->isValid()))));
+ },
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(0))));
}
ExplodedNode *DebugIteratorModeling::reportDebugMsg(llvm::StringRef Msg,
diff --git a/clang/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp
index a678c3827e7f12..4667671cec89bd 100644
--- a/clang/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp
@@ -28,9 +28,8 @@ using namespace ento;
namespace {
class DereferenceChecker
- : public Checker< check::Location,
- check::Bind,
- EventDispatcher<ImplicitNullDerefEvent> > {
+ : public Checker<check::Location, check::Bind,
+ EventDispatcher<ImplicitNullDerefEvent>> {
enum DerefKind { NullPointer, UndefinedPointerValue };
BugType BT_Null{this, "Dereference of null pointer", categories::LogicError};
@@ -43,7 +42,7 @@ class DereferenceChecker
bool suppressReport(CheckerContext &C, const Expr *E) const;
public:
- void checkLocation(SVal location, bool isLoad, const Stmt* S,
+ void checkLocation(SVal location, bool isLoad, const Stmt *S,
CheckerContext &C) const;
void checkBind(SVal L, SVal V, const Stmt *S, CheckerContext &C) const;
@@ -57,46 +56,42 @@ class DereferenceChecker
};
} // end anonymous namespace
-void
-DereferenceChecker::AddDerefSource(raw_ostream &os,
- SmallVectorImpl<SourceRange> &Ranges,
- const Expr *Ex,
- const ProgramState *state,
- const LocationContext *LCtx,
- bool loadedFrom) {
+void DereferenceChecker::AddDerefSource(
+ raw_ostream &os, SmallVectorImpl<SourceRange> &Ranges, const Expr *Ex,
+ const ProgramState *state, const LocationContext *LCtx, bool loadedFrom) {
Ex = Ex->IgnoreParenLValueCasts();
switch (Ex->getStmtClass()) {
- default:
- break;
- case Stmt::DeclRefExprClass: {
- const DeclRefExpr *DR = cast<DeclRefExpr>(Ex);
- if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) {
- os << " (" << (loadedFrom ? "loaded from" : "from")
- << " variable '" << VD->getName() << "')";
- Ranges.push_back(DR->getSourceRange());
- }
- break;
- }
- case Stmt::MemberExprClass: {
- const MemberExpr *ME = cast<MemberExpr>(Ex);
- os << " (" << (loadedFrom ? "loaded from" : "via")
- << " field '" << ME->getMemberNameInfo() << "')";
- SourceLocation L = ME->getMemberLoc();
- Ranges.push_back(SourceRange(L, L));
- break;
- }
- case Stmt::ObjCIvarRefExprClass: {
- const ObjCIvarRefExpr *IV = cast<ObjCIvarRefExpr>(Ex);
- os << " (" << (loadedFrom ? "loaded from" : "via")
- << " ivar '" << IV->getDecl()->getName() << "')";
- SourceLocation L = IV->getLocation();
- Ranges.push_back(SourceRange(L, L));
- break;
+ default:
+ break;
+ case Stmt::DeclRefExprClass: {
+ const DeclRefExpr *DR = cast<DeclRefExpr>(Ex);
+ if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) {
+ os << " (" << (loadedFrom ? "loaded from" : "from") << " variable '"
+ << VD->getName() << "')";
+ Ranges.push_back(DR->getSourceRange());
}
+ break;
+ }
+ case Stmt::MemberExprClass: {
+ const MemberExpr *ME = cast<MemberExpr>(Ex);
+ os << " (" << (loadedFrom ? "loaded from" : "via") << " field '"
+ << ME->getMemberNameInfo() << "')";
+ SourceLocation L = ME->getMemberLoc();
+ Ranges.push_back(SourceRange(L, L));
+ break;
+ }
+ case Stmt::ObjCIvarRefExprClass: {
+ const ObjCIvarRefExpr *IV = cast<ObjCIvarRefExpr>(Ex);
+ os << " (" << (loadedFrom ? "loaded from" : "via") << " ivar '"
+ << IV->getDecl()->getName() << "')";
+ SourceLocation L = IV->getLocation();
+ Ranges.push_back(SourceRange(L, L));
+ break;
+ }
}
}
-static const Expr *getDereferenceExpr(const Stmt *S, bool IsBind=false){
+static const Expr *getDereferenceExpr(const Stmt *S, bool IsBind = false) {
const Expr *E = nullptr;
// Walk through lvalue casts to get the original expression
@@ -183,40 +178,40 @@ void DereferenceChecker::reportBug(DerefKind K, ProgramStateRef State,
case Stmt::ArraySubscriptExprClass: {
os << "Array access";
const ArraySubscriptExpr *AE = cast<ArraySubscriptExpr>(S);
- AddDerefSource(os, Ranges, AE->getBase()->IgnoreParenCasts(),
- State.get(), N->getLocationContext());
+ AddDerefSource(os, Ranges, AE->getBase()->IgnoreParenCasts(), State.get(),
+ N->getLocationContext());
os << DerefStr1;
break;
}
case Stmt::OMPArraySectionExprClass: {
os << "Array access";
const OMPArraySectionExpr *AE = cast<OMPArraySectionExpr>(S);
- AddDerefSource(os, Ranges, AE->getBase()->IgnoreParenCasts(),
- State.get(), N->getLocationContext());
+ AddDerefSource(os, Ranges, AE->getBase()->IgnoreParenCasts(), State.get(),
+ N->getLocationContext());
os << DerefStr1;
break;
}
case Stmt::UnaryOperatorClass: {
os << BT->getDescription();
const UnaryOperator *U = cast<UnaryOperator>(S);
- AddDerefSource(os, Ranges, U->getSubExpr()->IgnoreParens(),
- State.get(), N->getLocationContext(), true);
+ AddDerefSource(os, Ranges, U->getSubExpr()->IgnoreParens(), State.get(),
+ N->getLocationContext(), true);
break;
}
case Stmt::MemberExprClass: {
const MemberExpr *M = cast<MemberExpr>(S);
if (M->isArrow() || isDeclRefExprToReference(M->getBase())) {
os << "Access to field '" << M->getMemberNameInfo() << "'" << DerefStr2;
- AddDerefSource(os, Ranges, M->getBase()->IgnoreParenCasts(),
- State.get(), N->getLocationContext(), true);
+ AddDerefSource(os, Ranges, M->getBase()->IgnoreParenCasts(), State.get(),
+ N->getLocationContext(), true);
}
break;
}
case Stmt::ObjCIvarRefExprClass: {
const ObjCIvarRefExpr *IV = cast<ObjCIvarRefExpr>(S);
os << "Access to instance variable '" << *IV->getDecl() << "'" << DerefStr2;
- AddDerefSource(os, Ranges, IV->getBase()->IgnoreParenCasts(),
- State.get(), N->getLocationContext(), true);
+ AddDerefSource(os, Ranges, IV->getBase()->IgnoreParenCasts(), State.get(),
+ N->getLocationContext(), true);
break;
}
default:
@@ -228,14 +223,15 @@ void DereferenceChecker::reportBug(DerefKind K, ProgramStateRef State,
bugreporter::trackExpressionValue(N, bugreporter::getDerefExpr(S), *report);
- for (SmallVectorImpl<SourceRange>::iterator
- I = Ranges.begin(), E = Ranges.end(); I!=E; ++I)
+ for (SmallVectorImpl<SourceRange>::iterator I = Ranges.begin(),
+ E = Ranges.end();
+ I != E; ++I)
report->addRange(*I);
C.emitReport(std::move(report));
}
-void DereferenceChecker::checkLocation(SVal l, bool isLoad, const Stmt* S,
+void DereferenceChecker::checkLocation(SVal l, bool isLoad, const Stmt *S,
CheckerContext &C) const {
// Check for dereference of an undefined value.
if (l.isUndef()) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp b/clang/lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp
index 49486ea796c263..b07958814fad23 100644
--- a/clang/lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp
@@ -1,4 +1,5 @@
-//=- DirectIvarAssignment.cpp - Check rules on ObjC properties -*- C++ ----*-==//
+//=- DirectIvarAssignment.cpp - Check rules on ObjC properties -*- C++
+//----*-==//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -20,10 +21,10 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/Attr.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/StmtVisitor.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
@@ -48,11 +49,11 @@ static bool DefaultMethodFilter(const ObjCMethodDecl *M) {
M->getSelector().getNameForSlot(0).contains("Init");
}
-class DirectIvarAssignment :
- public Checker<check::ASTDecl<ObjCImplementationDecl> > {
+class DirectIvarAssignment
+ : public Checker<check::ASTDecl<ObjCImplementationDecl>> {
- typedef llvm::DenseMap<const ObjCIvarDecl*,
- const ObjCPropertyDecl*> IvarToPropertyMapTy;
+ typedef llvm::DenseMap<const ObjCIvarDecl *, const ObjCPropertyDecl *>
+ IvarToPropertyMapTy;
/// A helper class, which walks the AST and locates all assignments to ivars
/// in the given function.
@@ -87,19 +88,19 @@ class DirectIvarAssignment :
DirectIvarAssignment() : ShouldSkipMethod(&DefaultMethodFilter) {}
- void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& Mgr,
+ void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager &Mgr,
BugReporter &BR) const;
};
-static const ObjCIvarDecl *findPropertyBackingIvar(const ObjCPropertyDecl *PD,
- const ObjCInterfaceDecl *InterD,
- ASTContext &Ctx) {
+static const ObjCIvarDecl *
+findPropertyBackingIvar(const ObjCPropertyDecl *PD,
+ const ObjCInterfaceDecl *InterD, ASTContext &Ctx) {
// Check for synthesized ivars.
ObjCIvarDecl *ID = PD->getPropertyIvarDecl();
if (ID)
return ID;
- ObjCInterfaceDecl *NonConstInterD = const_cast<ObjCInterfaceDecl*>(InterD);
+ ObjCInterfaceDecl *NonConstInterD = const_cast<ObjCInterfaceDecl *>(InterD);
// Check for existing "_PropName".
ID = NonConstInterD->lookupInstanceVariable(PD->getDefaultSynthIvarName(Ctx));
@@ -114,18 +115,17 @@ static const ObjCIvarDecl *findPropertyBackingIvar(const ObjCPropertyDecl *PD,
}
void DirectIvarAssignment::checkASTDecl(const ObjCImplementationDecl *D,
- AnalysisManager& Mgr,
- BugReporter &BR) const {
+ AnalysisManager &Mgr,
+ BugReporter &BR) const {
const ObjCInterfaceDecl *InterD = D->getClassInterface();
-
IvarToPropertyMapTy IvarToPropMap;
// Find all properties for this class.
for (const auto *PD : InterD->instance_properties()) {
// Find the corresponding IVar.
- const ObjCIvarDecl *ID = findPropertyBackingIvar(PD, InterD,
- Mgr.getASTContext());
+ const ObjCIvarDecl *ID =
+ findPropertyBackingIvar(PD, InterD, Mgr.getASTContext());
if (!ID)
continue;
@@ -163,12 +163,12 @@ static bool isAnnotatedToAllowDirectAssignment(const Decl *D) {
}
void DirectIvarAssignment::MethodCrawler::VisitBinaryOperator(
- const BinaryOperator *BO) {
+ const BinaryOperator *BO) {
if (!BO->isAssignmentOp())
return;
const ObjCIvarRefExpr *IvarRef =
- dyn_cast<ObjCIvarRefExpr>(BO->getLHS()->IgnoreParenCasts());
+ dyn_cast<ObjCIvarRefExpr>(BO->getLHS()->IgnoreParenCasts());
if (!IvarRef)
return;
@@ -205,10 +205,11 @@ void DirectIvarAssignment::MethodCrawler::VisitBinaryOperator(
}
}
}
-}
+} // namespace
// Register the checker that checks for direct accesses in functions annotated
-// with __attribute__((annotate("objc_no_direct_instance_variable_assignment"))).
+// with
+// __attribute__((annotate("objc_no_direct_instance_variable_assignment"))).
static bool AttrFilter(const ObjCMethodDecl *M) {
for (const auto *Ann : M->specific_attrs<AnnotateAttr>())
if (Ann->getAnnotation() == "objc_no_direct_instance_variable_assignment")
diff --git a/clang/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp
index 5496f087447fbe..a05e3c49c04b9d 100644
--- a/clang/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp
@@ -25,7 +25,7 @@ using namespace ento;
using namespace taint;
namespace {
-class DivZeroChecker : public Checker< check::PreStmt<BinaryOperator> > {
+class DivZeroChecker : public Checker<check::PreStmt<BinaryOperator>> {
const BugType BT{this, "Division by zero"};
const BugType TaintBT{this, "Division by zero", categories::TaintedData};
void reportBug(StringRef Msg, ProgramStateRef StateZero,
@@ -70,10 +70,7 @@ void DivZeroChecker::reportTaintBug(
void DivZeroChecker::checkPreStmt(const BinaryOperator *B,
CheckerContext &C) const {
BinaryOperator::Opcode Op = B->getOpcode();
- if (Op != BO_Div &&
- Op != BO_Rem &&
- Op != BO_DivAssign &&
- Op != BO_RemAssign)
+ if (Op != BO_Div && Op != BO_Rem && Op != BO_DivAssign && Op != BO_RemAssign)
return;
if (!B->getRHS()->getType()->isScalarType())
diff --git a/clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp
index 0ad307d3ebd504..5da9f404e1ca37 100644
--- a/clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp
@@ -21,8 +21,8 @@
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/CheckerManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/DynamicType.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/DynamicType.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
using namespace clang;
@@ -58,7 +58,7 @@ class DynamicTypeChecker : public Checker<check::PostStmt<ImplicitCastExpr>> {
public:
void checkPostStmt(const ImplicitCastExpr *CE, CheckerContext &C) const;
};
-}
+} // namespace
void DynamicTypeChecker::reportTypeError(QualType DynamicType,
QualType StaticType,
diff --git a/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp b/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp
index 034774a252b118..d4549638c70caf 100644
--- a/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp
@@ -49,14 +49,10 @@ REGISTER_MAP_WITH_PROGRAMSTATE(MostSpecializedTypeArgsMap, SymbolRef,
const ObjCObjectPointerType *)
namespace {
-class DynamicTypePropagation:
- public Checker< check::PreCall,
- check::PostCall,
- check::DeadSymbols,
- check::PostStmt<CastExpr>,
- check::PostStmt<CXXNewExpr>,
- check::PreObjCMessage,
- check::PostObjCMessage > {
+class DynamicTypePropagation
+ : public Checker<check::PreCall, check::PostCall, check::DeadSymbols,
+ check::PostStmt<CastExpr>, check::PostStmt<CXXNewExpr>,
+ check::PreObjCMessage, check::PostObjCMessage> {
/// Return a better dynamic type if one can be derived from the cast.
const ObjCObjectPointerType *getBetterObjCType(const Expr *CastE,
@@ -445,8 +441,7 @@ DynamicTypePropagation::getBetterObjCType(const Expr *CastE,
if (OldDTy.isNull()) {
return NewTy;
}
- const ObjCObjectPointerType *OldTy =
- OldDTy->getAs<ObjCObjectPointerType>();
+ const ObjCObjectPointerType *OldTy = OldDTy->getAs<ObjCObjectPointerType>();
if (!OldTy)
return nullptr;
@@ -769,9 +764,10 @@ findMethodDecl(const ObjCMessageExpr *MessageExpr,
/// Get the returned ObjCObjectPointerType by a method based on the tracked type
/// information, or null pointer when the returned type is not an
/// ObjCObjectPointerType.
-static QualType getReturnTypeForMethod(
- const ObjCMethodDecl *Method, ArrayRef<QualType> TypeArgs,
- const ObjCObjectPointerType *SelfType, ASTContext &C) {
+static QualType getReturnTypeForMethod(const ObjCMethodDecl *Method,
+ ArrayRef<QualType> TypeArgs,
+ const ObjCObjectPointerType *SelfType,
+ ASTContext &C) {
QualType StaticResultType = Method->getReturnType();
// Is the return type declared as instance type?
diff --git a/clang/lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp
index 7aefcdc6d358aa..ce7e8c4def956a 100644
--- a/clang/lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp
@@ -22,14 +22,13 @@ using namespace clang;
using namespace ento;
namespace {
-class FixedAddressChecker
- : public Checker< check::PreStmt<BinaryOperator> > {
+class FixedAddressChecker : public Checker<check::PreStmt<BinaryOperator>> {
const BugType BT{this, "Use fixed address"};
public:
void checkPreStmt(const BinaryOperator *B, CheckerContext &C) const;
};
-}
+} // namespace
void FixedAddressChecker::checkPreStmt(const BinaryOperator *B,
CheckerContext &C) const {
diff --git a/clang/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp
index 5637941a58f026..e9f9af4ccb28a5 100644
--- a/clang/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp
@@ -28,8 +28,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
@@ -47,8 +47,7 @@ const char *WarnAtNode = "waitcall";
class GCDAntipatternChecker : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &AM,
BugReporter &BR) const;
};
@@ -62,8 +61,8 @@ decltype(auto) equalsBoundArgDecl(int ArgIdx, const char *DeclName) {
}
decltype(auto) bindAssignmentToDecl(const char *DeclName) {
- return hasLHS(ignoringParenImpCasts(
- declRefExpr(to(varDecl().bind(DeclName)))));
+ return hasLHS(
+ ignoringParenImpCasts(declRefExpr(to(varDecl().bind(DeclName)))));
}
/// The pattern is very common in tests, and it is OK to use it there.
@@ -71,7 +70,7 @@ decltype(auto) bindAssignmentToDecl(const char *DeclName) {
/// (used in XCTest), and a class name contains "mock" or "test" (used in
/// helpers which are not tests themselves, but used exclusively in tests).
static bool isTest(const Decl *D) {
- if (const auto* ND = dyn_cast<NamedDecl>(D)) {
+ if (const auto *ND = dyn_cast<NamedDecl>(D)) {
std::string DeclName = ND->getNameAsString();
if (StringRef(DeclName).starts_with("test"))
return true;
@@ -90,45 +89,36 @@ static bool isTest(const Decl *D) {
static auto findGCDAntiPatternWithSemaphore() -> decltype(compoundStmt()) {
const char *SemaphoreBinding = "semaphore_name";
- auto SemaphoreCreateM = callExpr(allOf(
- callsName("dispatch_semaphore_create"),
- hasArgument(0, ignoringParenCasts(integerLiteral(equals(0))))));
+ auto SemaphoreCreateM = callExpr(
+ allOf(callsName("dispatch_semaphore_create"),
+ hasArgument(0, ignoringParenCasts(integerLiteral(equals(0))))));
auto SemaphoreBindingM = anyOf(
forEachDescendant(
varDecl(hasDescendant(SemaphoreCreateM)).bind(SemaphoreBinding)),
forEachDescendant(binaryOperator(bindAssignmentToDecl(SemaphoreBinding),
- hasRHS(SemaphoreCreateM))));
+ hasRHS(SemaphoreCreateM))));
- auto HasBlockArgumentM = hasAnyArgument(hasType(
- hasCanonicalType(blockPointerType())
- ));
+ auto HasBlockArgumentM =
+ hasAnyArgument(hasType(hasCanonicalType(blockPointerType())));
- auto ArgCallsSignalM = hasAnyArgument(stmt(hasDescendant(callExpr(
- allOf(
- callsName("dispatch_semaphore_signal"),
- equalsBoundArgDecl(0, SemaphoreBinding)
- )))));
+ auto ArgCallsSignalM = hasAnyArgument(stmt(
+ hasDescendant(callExpr(allOf(callsName("dispatch_semaphore_signal"),
+ equalsBoundArgDecl(0, SemaphoreBinding))))));
auto HasBlockAndCallsSignalM = allOf(HasBlockArgumentM, ArgCallsSignalM);
auto HasBlockCallingSignalM =
- forEachDescendant(
- stmt(anyOf(
- callExpr(HasBlockAndCallsSignalM),
- objcMessageExpr(HasBlockAndCallsSignalM)
- )));
-
- auto SemaphoreWaitM = forEachDescendant(
- callExpr(
- allOf(
- callsName("dispatch_semaphore_wait"),
- equalsBoundArgDecl(0, SemaphoreBinding)
- )
- ).bind(WarnAtNode));
-
- return compoundStmt(
- SemaphoreBindingM, HasBlockCallingSignalM, SemaphoreWaitM);
+ forEachDescendant(stmt(anyOf(callExpr(HasBlockAndCallsSignalM),
+ objcMessageExpr(HasBlockAndCallsSignalM))));
+
+ auto SemaphoreWaitM =
+ forEachDescendant(callExpr(allOf(callsName("dispatch_semaphore_wait"),
+ equalsBoundArgDecl(0, SemaphoreBinding)))
+ .bind(WarnAtNode));
+
+ return compoundStmt(SemaphoreBindingM, HasBlockCallingSignalM,
+ SemaphoreWaitM);
}
static auto findGCDAntiPatternWithGroup() -> decltype(compoundStmt()) {
@@ -140,46 +130,35 @@ static auto findGCDAntiPatternWithGroup() -> decltype(compoundStmt()) {
forEachDescendant(
varDecl(hasDescendant(DispatchGroupCreateM)).bind(GroupBinding)),
forEachDescendant(binaryOperator(bindAssignmentToDecl(GroupBinding),
- hasRHS(DispatchGroupCreateM))));
+ hasRHS(DispatchGroupCreateM))));
auto GroupEnterM = forEachDescendant(
stmt(callExpr(allOf(callsName("dispatch_group_enter"),
equalsBoundArgDecl(0, GroupBinding)))));
- auto HasBlockArgumentM = hasAnyArgument(hasType(
- hasCanonicalType(blockPointerType())
- ));
+ auto HasBlockArgumentM =
+ hasAnyArgument(hasType(hasCanonicalType(blockPointerType())));
- auto ArgCallsSignalM = hasAnyArgument(stmt(hasDescendant(callExpr(
- allOf(
- callsName("dispatch_group_leave"),
- equalsBoundArgDecl(0, GroupBinding)
- )))));
+ auto ArgCallsSignalM = hasAnyArgument(stmt(
+ hasDescendant(callExpr(allOf(callsName("dispatch_group_leave"),
+ equalsBoundArgDecl(0, GroupBinding))))));
auto HasBlockAndCallsLeaveM = allOf(HasBlockArgumentM, ArgCallsSignalM);
auto AcceptsBlockM =
- forEachDescendant(
- stmt(anyOf(
- callExpr(HasBlockAndCallsLeaveM),
- objcMessageExpr(HasBlockAndCallsLeaveM)
- )));
-
- auto GroupWaitM = forEachDescendant(
- callExpr(
- allOf(
- callsName("dispatch_group_wait"),
- equalsBoundArgDecl(0, GroupBinding)
- )
- ).bind(WarnAtNode));
+ forEachDescendant(stmt(anyOf(callExpr(HasBlockAndCallsLeaveM),
+ objcMessageExpr(HasBlockAndCallsLeaveM))));
+
+ auto GroupWaitM =
+ forEachDescendant(callExpr(allOf(callsName("dispatch_group_wait"),
+ equalsBoundArgDecl(0, GroupBinding)))
+ .bind(WarnAtNode));
return compoundStmt(GroupBindingM, GroupEnterM, AcceptsBlockM, GroupWaitM);
}
-static void emitDiagnostics(const BoundNodes &Nodes,
- const char* Type,
- BugReporter &BR,
- AnalysisDeclContext *ADC,
+static void emitDiagnostics(const BoundNodes &Nodes, const char *Type,
+ BugReporter &BR, AnalysisDeclContext *ADC,
const GCDAntipatternChecker *Checker) {
const auto *SW = Nodes.getNodeAs<CallExpr>(WarnAtNode);
assert(SW);
@@ -191,17 +170,14 @@ static void emitDiagnostics(const BoundNodes &Nodes,
<< "using a synchronous API or changing the caller to be asynchronous";
BR.EmitBasicReport(
- ADC->getDecl(),
- Checker,
- /*Name=*/"GCD performance anti-pattern",
- /*BugCategory=*/"Performance",
- OS.str(),
- PathDiagnosticLocation::createBegin(SW, BR.getSourceManager(), ADC),
- SW->getSourceRange());
+ ADC->getDecl(), Checker,
+ /*Name=*/"GCD performance anti-pattern",
+ /*BugCategory=*/"Performance", OS.str(),
+ PathDiagnosticLocation::createBegin(SW, BR.getSourceManager(), ADC),
+ SW->getSourceRange());
}
-void GCDAntipatternChecker::checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
+void GCDAntipatternChecker::checkASTCodeBody(const Decl *D, AnalysisManager &AM,
BugReporter &BR) const {
if (isTest(D))
return;
diff --git a/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp
index 6c32a8dec844cb..f40c52640cdb75 100644
--- a/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp
@@ -12,9 +12,9 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/Expr.h"
#include "clang/Basic/LangOptions.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
@@ -224,7 +224,7 @@ void GTestChecker::checkPostCall(const CallEvent &Call,
modelAssertionResultBoolConstructor(CtorCall, /*IsRef=*/false, C);
return;
}
- if (ParamCount == 2){
+ if (ParamCount == 2) {
auto *RefTy = CtorDecl->getParamDecl(0)->getType()->getAs<ReferenceType>();
if (RefTy &&
RefTy->getPointeeType()->getCanonicalTypeUnqualified() == BoolTy) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp
index 4ceaf933d0bfc8..a5dc9480b6da31 100644
--- a/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp
@@ -977,30 +977,29 @@ void GenericTaintRule::process(const GenericTaintChecker &Checker,
/// Propagate taint where it is necessary.
auto &F = State->getStateManager().get_context<ArgIdxFactory>();
ImmutableSet<ArgIdxTy> Result = F.getEmptySet();
- ForEachCallArg(
- [&](ArgIdxTy I, const Expr *E, SVal V) {
- if (PropDstArgs.contains(I)) {
- LLVM_DEBUG(llvm::dbgs() << "PreCall<"; Call.dump(llvm::dbgs());
- llvm::dbgs()
- << "> prepares tainting arg index: " << I << '\n';);
- Result = F.add(Result, I);
- }
+ ForEachCallArg([&](ArgIdxTy I, const Expr *E, SVal V) {
+ if (PropDstArgs.contains(I)) {
+ LLVM_DEBUG(llvm::dbgs() << "PreCall<"; Call.dump(llvm::dbgs());
+ llvm::dbgs()
+ << "> prepares tainting arg index: " << I << '\n';);
+ Result = F.add(Result, I);
+ }
- // Taint property gets lost if the variable is passed as a
- // non-const pointer or reference to a function which is
- // not inlined. For matching rules we want to preserve the taintedness.
- // TODO: We should traverse all reachable memory regions via the
- // escaping parameter. Instead of doing that we simply mark only the
- // referred memory region as tainted.
- if (WouldEscape(V, E->getType()) && getTaintedPointeeOrPointer(State, V)) {
- LLVM_DEBUG(if (!Result.contains(I)) {
- llvm::dbgs() << "PreCall<";
- Call.dump(llvm::dbgs());
- llvm::dbgs() << "> prepares tainting arg index: " << I << '\n';
- });
- Result = F.add(Result, I);
- }
+ // Taint property gets lost if the variable is passed as a
+ // non-const pointer or reference to a function which is
+ // not inlined. For matching rules we want to preserve the taintedness.
+ // TODO: We should traverse all reachable memory regions via the
+ // escaping parameter. Instead of doing that we simply mark only the
+ // referred memory region as tainted.
+ if (WouldEscape(V, E->getType()) && getTaintedPointeeOrPointer(State, V)) {
+ LLVM_DEBUG(if (!Result.contains(I)) {
+ llvm::dbgs() << "PreCall<";
+ Call.dump(llvm::dbgs());
+ llvm::dbgs() << "> prepares tainting arg index: " << I << '\n';
});
+ Result = F.add(Result, I);
+ }
+ });
if (!Result.isEmpty())
State = State->set<TaintArgsOnPostVisit>(C.getStackFrame(), Result);
diff --git a/clang/lib/StaticAnalyzer/Checkers/IdenticalExprChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/IdenticalExprChecker.cpp
index 1cf81b54e77d32..5a2dbf42f4d96d 100644
--- a/clang/lib/StaticAnalyzer/Checkers/IdenticalExprChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/IdenticalExprChecker.cpp
@@ -15,8 +15,8 @@
///
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/RecursiveASTVisitor.h"
+#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"
@@ -37,9 +37,9 @@ class FindIdenticalExprVisitor
BugReporter &BR;
const CheckerBase *Checker;
AnalysisDeclContext *AC;
+
public:
- explicit FindIdenticalExprVisitor(BugReporter &B,
- const CheckerBase *Checker,
+ explicit FindIdenticalExprVisitor(BugReporter &B, const CheckerBase *Checker,
AnalysisDeclContext *A)
: BR(B), Checker(Checker), AC(A) {}
// FindIdenticalExprVisitor only visits nodes
@@ -68,10 +68,8 @@ void FindIdenticalExprVisitor::reportIdenticalExpr(const BinaryOperator *B,
PathDiagnosticLocation ELoc =
PathDiagnosticLocation::createOperatorLoc(B, BR.getSourceManager());
- BR.EmitBasicReport(AC->getDecl(), Checker,
- "Use of identical expressions",
- categories::LogicError,
- Message, ELoc, Sr);
+ BR.EmitBasicReport(AC->getDecl(), Checker, "Use of identical expressions",
+ categories::LogicError, Message, ELoc, Sr);
}
void FindIdenticalExprVisitor::checkBitwiseOrLogicalOp(const BinaryOperator *B,
@@ -115,12 +113,15 @@ bool FindIdenticalExprVisitor::VisitIfStmt(const IfStmt *I) {
if (const CompoundStmt *CS = dyn_cast<CompoundStmt>(Stmt1)) {
if (!CS->body_empty()) {
const IfStmt *InnerIf = dyn_cast<IfStmt>(*CS->body_begin());
- if (InnerIf && isIdenticalStmt(AC->getASTContext(), I->getCond(), InnerIf->getCond(), /*IgnoreSideEffects=*/ false)) {
- PathDiagnosticLocation ELoc(InnerIf->getCond(), BR.getSourceManager(), AC);
- BR.EmitBasicReport(AC->getDecl(), Checker, "Identical conditions",
- categories::LogicError,
- "conditions of the inner and outer statements are identical",
- ELoc);
+ if (InnerIf &&
+ isIdenticalStmt(AC->getASTContext(), I->getCond(), InnerIf->getCond(),
+ /*IgnoreSideEffects=*/false)) {
+ PathDiagnosticLocation ELoc(InnerIf->getCond(), BR.getSourceManager(),
+ AC);
+ BR.EmitBasicReport(
+ AC->getDecl(), Checker, "Identical conditions",
+ categories::LogicError,
+ "conditions of the inner and outer statements are identical", ELoc);
}
}
}
@@ -168,12 +169,11 @@ bool FindIdenticalExprVisitor::VisitIfStmt(const IfStmt *I) {
}
if (isIdenticalStmt(AC->getASTContext(), Stmt1, Stmt2, true)) {
- PathDiagnosticLocation ELoc =
- PathDiagnosticLocation::createBegin(I, BR.getSourceManager(), AC);
- BR.EmitBasicReport(AC->getDecl(), Checker,
- "Identical branches",
- categories::LogicError,
- "true and false branches are identical", ELoc);
+ PathDiagnosticLocation ELoc =
+ PathDiagnosticLocation::createBegin(I, BR.getSourceManager(), AC);
+ BR.EmitBasicReport(AC->getDecl(), Checker, "Identical branches",
+ categories::LogicError,
+ "true and false branches are identical", ELoc);
}
return true;
}
@@ -273,8 +273,8 @@ bool FindIdenticalExprVisitor::VisitConditionalOperator(
// Check if expressions in conditional expression are identical
// from a symbolic point of view.
- if (isIdenticalStmt(AC->getASTContext(), C->getTrueExpr(),
- C->getFalseExpr(), true)) {
+ if (isIdenticalStmt(AC->getASTContext(), C->getTrueExpr(), C->getFalseExpr(),
+ true)) {
PathDiagnosticLocation ELoc =
PathDiagnosticLocation::createConditionalColonLoc(
C, BR.getSourceManager());
@@ -360,8 +360,8 @@ static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1,
case Stmt::NullStmtClass:
return true;
case Stmt::CStyleCastExprClass: {
- const CStyleCastExpr* CastExpr1 = cast<CStyleCastExpr>(Stmt1);
- const CStyleCastExpr* CastExpr2 = cast<CStyleCastExpr>(Stmt2);
+ const CStyleCastExpr *CastExpr1 = cast<CStyleCastExpr>(Stmt1);
+ const CStyleCastExpr *CastExpr2 = cast<CStyleCastExpr>(Stmt2);
return CastExpr1->getTypeAsWritten() == CastExpr2->getTypeAsWritten();
}
@@ -471,7 +471,7 @@ static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1,
llvm::APInt I2 = IntLit2->getValue();
if (I1.getBitWidth() != I2.getBitWidth())
return false;
- return I1 == I2;
+ return I1 == I2;
}
case Stmt::FloatingLiteralClass: {
const FloatingLiteral *FloatLit1 = cast<FloatingLiteral>(Stmt1);
diff --git a/clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp
index b673b51c46232d..2afafcbb59a0ef 100644
--- a/clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp
@@ -29,7 +29,6 @@ using namespace ento;
REGISTER_SET_FACTORY_WITH_PROGRAMSTATE(PtrSet, SymbolRef)
REGISTER_MAP_WITH_PROGRAMSTATE(RawPtrMap, const MemRegion *, PtrSet)
-
namespace {
class InnerPointerChecker
@@ -101,8 +100,8 @@ class InnerPointerChecker
const MemRegion *ObjRegion,
CheckerContext &C) const;
- /// Standard library functions that take a non-const `basic_string` argument by
- /// reference may invalidate its inner pointers. Check for these cases and
+ /// Standard library functions that take a non-const `basic_string` argument
+ /// by reference may invalidate its inner pointers. Check for these cases and
/// mark the pointers released.
void checkFunctionArguments(const CallEvent &Call, ProgramStateRef State,
CheckerContext &C) const;
@@ -119,7 +118,7 @@ class InnerPointerChecker
} // end anonymous namespace
bool InnerPointerChecker::isInvalidatingMemberFunction(
- const CallEvent &Call) const {
+ const CallEvent &Call) const {
if (const auto *MemOpCall = dyn_cast<CXXMemberOperatorCall>(&Call)) {
OverloadedOperatorKind Opc = MemOpCall->getOriginExpr()->getOperator();
if (Opc == OO_Equal || Opc == OO_PlusEqual)
@@ -171,7 +170,7 @@ void InnerPointerChecker::checkFunctionArguments(const CallEvent &Call,
// In case of member operator calls, `this` is counted as an
// argument but not as a parameter.
bool isaMemberOpCall = isa<CXXMemberOperatorCall>(FC);
- unsigned ArgI = isaMemberOpCall ? I+1 : I;
+ unsigned ArgI = isaMemberOpCall ? I + 1 : I;
SVal Arg = FC->getArgSVal(ArgI);
const auto *ArgRegion =
diff --git a/clang/lib/StaticAnalyzer/Checkers/InvalidatedIteratorChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/InvalidatedIteratorChecker.cpp
index 2e21f619a133e7..093cfbc85b15ed 100644
--- a/clang/lib/StaticAnalyzer/Checkers/InvalidatedIteratorChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/InvalidatedIteratorChecker.cpp
@@ -16,7 +16,6 @@
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
-
#include "Iterator.h"
using namespace clang;
@@ -26,10 +25,10 @@ using namespace iterator;
namespace {
class InvalidatedIteratorChecker
- : public Checker<check::PreCall, check::PreStmt<UnaryOperator>,
- check::PreStmt<BinaryOperator>,
- check::PreStmt<ArraySubscriptExpr>,
- check::PreStmt<MemberExpr>> {
+ : public Checker<check::PreCall, check::PreStmt<UnaryOperator>,
+ check::PreStmt<BinaryOperator>,
+ check::PreStmt<ArraySubscriptExpr>,
+ check::PreStmt<MemberExpr>> {
const BugType InvalidatedBugType{this, "Iterator invalidated",
"Misuse of STL APIs"};
@@ -44,7 +43,6 @@ class InvalidatedIteratorChecker
void checkPreStmt(const BinaryOperator *BO, CheckerContext &C) const;
void checkPreStmt(const ArraySubscriptExpr *ASE, CheckerContext &C) const;
void checkPreStmt(const MemberExpr *ME, CheckerContext &C) const;
-
};
} // namespace
diff --git a/clang/lib/StaticAnalyzer/Checkers/Iterator.cpp b/clang/lib/StaticAnalyzer/Checkers/Iterator.cpp
index e8d35aac2efd9e..e1a18df640cfa3 100644
--- a/clang/lib/StaticAnalyzer/Checkers/Iterator.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/Iterator.cpp
@@ -142,13 +142,9 @@ bool isDereferenceOperator(OverloadedOperatorKind OK) {
OK == OO_Subscript;
}
-bool isDereferenceOperator(UnaryOperatorKind OK) {
- return OK == UO_Deref;
-}
+bool isDereferenceOperator(UnaryOperatorKind OK) { return OK == UO_Deref; }
-bool isDereferenceOperator(BinaryOperatorKind OK) {
- return OK == BO_PtrMemI;
-}
+bool isDereferenceOperator(BinaryOperatorKind OK) { return OK == BO_PtrMemI; }
bool isIncrementOperator(OverloadedOperatorKind OK) {
return OK == OO_PlusPlus;
@@ -172,8 +168,8 @@ bool isRandomIncrOrDecrOperator(OverloadedOperatorKind OK) {
}
bool isRandomIncrOrDecrOperator(BinaryOperatorKind OK) {
- return OK == BO_Add || OK == BO_AddAssign ||
- OK == BO_Sub || OK == BO_SubAssign;
+ return OK == BO_Add || OK == BO_AddAssign || OK == BO_Sub ||
+ OK == BO_SubAssign;
}
const ContainerData *getContainerData(ProgramStateRef State,
@@ -230,9 +226,9 @@ ProgramStateRef advancePosition(ProgramStateRef State, SVal Iter,
auto &SVB = State->getStateManager().getSValBuilder();
auto &BVF = State->getStateManager().getBasicVals();
- assert ((Op == OO_Plus || Op == OO_PlusEqual ||
- Op == OO_Minus || Op == OO_MinusEqual) &&
- "Advance operator must be one of +, -, += and -=.");
+ assert((Op == OO_Plus || Op == OO_PlusEqual || Op == OO_Minus ||
+ Op == OO_MinusEqual) &&
+ "Advance operator must be one of +, -, += and -=.");
auto BinOp = (Op == OO_Plus || Op == OO_PlusEqual) ? BO_Add : BO_Sub;
const auto IntDistOp = Distance.getAs<nonloc::ConcreteInt>();
if (!IntDistOp)
@@ -245,11 +241,10 @@ ProgramStateRef advancePosition(ProgramStateRef State, SVal Iter,
IntDist = nonloc::ConcreteInt(BVF.getValue(-IntDist.getValue()));
BinOp = (BinOp == BO_Add) ? BO_Sub : BO_Add;
}
- const auto NewPos =
- Pos->setTo(SVB.evalBinOp(State, BinOp,
- nonloc::SymbolVal(Pos->getOffset()),
- IntDist, SymMgr.getType(Pos->getOffset()))
- .getAsSymbol());
+ const auto NewPos = Pos->setTo(
+ SVB.evalBinOp(State, BinOp, nonloc::SymbolVal(Pos->getOffset()), IntDist,
+ SymMgr.getType(Pos->getOffset()))
+ .getAsSymbol());
return setIteratorPosition(State, Iter, NewPos);
}
@@ -304,7 +299,7 @@ bool compare(ProgramStateRef State, NonLoc NL1, NonLoc NL2,
auto &SVB = State->getStateManager().getSValBuilder();
const auto comparison =
- SVB.evalBinOp(State, Opc, NL1, NL2, SVB.getConditionType());
+ SVB.evalBinOp(State, Opc, NL1, NL2, SVB.getConditionType());
assert(isa<DefinedSVal>(comparison) &&
"Symbol comparison must be a `DefinedSVal`");
diff --git a/clang/lib/StaticAnalyzer/Checkers/Iterator.h b/clang/lib/StaticAnalyzer/Checkers/Iterator.h
index 46de8ea01d77b2..3ac15f94b38780 100644
--- a/clang/lib/StaticAnalyzer/Checkers/Iterator.h
+++ b/clang/lib/StaticAnalyzer/Checkers/Iterator.h
@@ -25,7 +25,6 @@ namespace iterator {
// of operators in a common way by using a symbolic position.
struct IteratorPosition {
private:
-
// Container the iterator belongs to
const MemRegion *Cont;
@@ -111,31 +110,40 @@ class IteratorSymbolMap {};
class IteratorRegionMap {};
class ContainerMap {};
-using IteratorSymbolMapTy =
- CLANG_ENTO_PROGRAMSTATE_MAP(SymbolRef, IteratorPosition);
-using IteratorRegionMapTy =
- CLANG_ENTO_PROGRAMSTATE_MAP(const MemRegion *, IteratorPosition);
-using ContainerMapTy =
- CLANG_ENTO_PROGRAMSTATE_MAP(const MemRegion *, ContainerData);
+using IteratorSymbolMapTy = CLANG_ENTO_PROGRAMSTATE_MAP(SymbolRef,
+ IteratorPosition);
+using IteratorRegionMapTy = CLANG_ENTO_PROGRAMSTATE_MAP(const MemRegion *,
+ IteratorPosition);
+using ContainerMapTy = CLANG_ENTO_PROGRAMSTATE_MAP(const MemRegion *,
+ ContainerData);
} // namespace iterator
-template<>
+template <>
struct ProgramStateTrait<iterator::IteratorSymbolMap>
- : public ProgramStatePartialTrait<iterator::IteratorSymbolMapTy> {
- static void *GDMIndex() { static int Index; return &Index; }
+ : public ProgramStatePartialTrait<iterator::IteratorSymbolMapTy> {
+ static void *GDMIndex() {
+ static int Index;
+ return &Index;
+ }
};
-template<>
+template <>
struct ProgramStateTrait<iterator::IteratorRegionMap>
- : public ProgramStatePartialTrait<iterator::IteratorRegionMapTy> {
- static void *GDMIndex() { static int Index; return &Index; }
+ : public ProgramStatePartialTrait<iterator::IteratorRegionMapTy> {
+ static void *GDMIndex() {
+ static int Index;
+ return &Index;
+ }
};
-template<>
+template <>
struct ProgramStateTrait<iterator::ContainerMap>
- : public ProgramStatePartialTrait<iterator::ContainerMapTy> {
- static void *GDMIndex() { static int Index; return &Index; }
+ : public ProgramStatePartialTrait<iterator::ContainerMapTy> {
+ static void *GDMIndex() {
+ static int Index;
+ return &Index;
+ }
};
namespace iterator {
diff --git a/clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp b/clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp
index a95e811c2a4181..76d96894536721 100644
--- a/clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp
@@ -87,8 +87,8 @@ namespace {
class IteratorModeling
: public Checker<check::PostCall, check::PostStmt<UnaryOperator>,
check::PostStmt<BinaryOperator>,
- check::PostStmt<MaterializeTemporaryExpr>,
- check::Bind, check::LiveSymbols, check::DeadSymbols> {
+ check::PostStmt<MaterializeTemporaryExpr>, check::Bind,
+ check::LiveSymbols, check::DeadSymbols> {
using AdvanceFn = void (IteratorModeling::*)(CheckerContext &, const Expr *,
SVal, SVal, SVal) const;
@@ -219,9 +219,13 @@ void IteratorModeling::checkPostCall(const CallEvent &Call,
// FIXME: Add a more conservative mode
for (unsigned i = 0; i < Call.getNumArgs(); ++i) {
if (isIteratorType(Call.getArgExpr(i)->getType()) &&
- Call.getArgExpr(i)->getType().getNonReferenceType().getDesugaredType(
- C.getASTContext()).getTypePtr() ==
- Call.getResultType().getDesugaredType(C.getASTContext()).getTypePtr()) {
+ Call.getArgExpr(i)
+ ->getType()
+ .getNonReferenceType()
+ .getDesugaredType(C.getASTContext())
+ .getTypePtr() == Call.getResultType()
+ .getDesugaredType(C.getASTContext())
+ .getTypePtr()) {
if (const auto *Pos = getIteratorPosition(State, Call.getArgSVal(i))) {
assignToContainer(C, OrigExpr, Call.getReturnValue(),
Pos->getContainer());
@@ -344,88 +348,84 @@ void IteratorModeling::checkDeadSymbols(SymbolReaper &SR,
C.addTransition(State);
}
-void
-IteratorModeling::handleOverloadedOperator(CheckerContext &C,
- const CallEvent &Call,
- OverloadedOperatorKind Op) const {
- if (isSimpleComparisonOperator(Op)) {
- const auto *OrigExpr = Call.getOriginExpr();
- if (!OrigExpr)
- return;
+void IteratorModeling::handleOverloadedOperator(
+ CheckerContext &C, const CallEvent &Call, OverloadedOperatorKind Op) const {
+ if (isSimpleComparisonOperator(Op)) {
+ const auto *OrigExpr = Call.getOriginExpr();
+ if (!OrigExpr)
+ return;
- if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
- handleComparison(C, OrigExpr, Call.getReturnValue(),
- InstCall->getCXXThisVal(), Call.getArgSVal(0), Op);
- return;
- }
+ if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
+ handleComparison(C, OrigExpr, Call.getReturnValue(),
+ InstCall->getCXXThisVal(), Call.getArgSVal(0), Op);
+ return;
+ }
- handleComparison(C, OrigExpr, Call.getReturnValue(), Call.getArgSVal(0),
- Call.getArgSVal(1), Op);
+ handleComparison(C, OrigExpr, Call.getReturnValue(), Call.getArgSVal(0),
+ Call.getArgSVal(1), Op);
+ return;
+ } else if (isRandomIncrOrDecrOperator(Op)) {
+ const auto *OrigExpr = Call.getOriginExpr();
+ if (!OrigExpr)
return;
- } else if (isRandomIncrOrDecrOperator(Op)) {
- const auto *OrigExpr = Call.getOriginExpr();
- if (!OrigExpr)
- return;
- if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
- if (Call.getNumArgs() >= 1 &&
- Call.getArgExpr(0)->getType()->isIntegralOrEnumerationType()) {
- handleRandomIncrOrDecr(C, OrigExpr, Op, Call.getReturnValue(),
- InstCall->getCXXThisVal(), Call.getArgSVal(0));
- return;
- }
- } else if (Call.getNumArgs() >= 2) {
- const Expr *FirstArg = Call.getArgExpr(0);
- const Expr *SecondArg = Call.getArgExpr(1);
- const QualType FirstType = FirstArg->getType();
- const QualType SecondType = SecondArg->getType();
-
- if (FirstType->isIntegralOrEnumerationType() ||
- SecondType->isIntegralOrEnumerationType()) {
- // In case of operator+ the iterator can be either on the LHS (eg.:
- // it + 1), or on the RHS (eg.: 1 + it). Both cases are modeled.
- const bool IsIterFirst = FirstType->isStructureOrClassType();
- const SVal FirstArg = Call.getArgSVal(0);
- const SVal SecondArg = Call.getArgSVal(1);
- SVal Iterator = IsIterFirst ? FirstArg : SecondArg;
- SVal Amount = IsIterFirst ? SecondArg : FirstArg;
-
- handleRandomIncrOrDecr(C, OrigExpr, Op, Call.getReturnValue(),
- Iterator, Amount);
- return;
- }
+ if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
+ if (Call.getNumArgs() >= 1 &&
+ Call.getArgExpr(0)->getType()->isIntegralOrEnumerationType()) {
+ handleRandomIncrOrDecr(C, OrigExpr, Op, Call.getReturnValue(),
+ InstCall->getCXXThisVal(), Call.getArgSVal(0));
+ return;
}
- } else if (isIncrementOperator(Op)) {
- if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
- handleIncrement(C, Call.getReturnValue(), InstCall->getCXXThisVal(),
- Call.getNumArgs());
+ } else if (Call.getNumArgs() >= 2) {
+ const Expr *FirstArg = Call.getArgExpr(0);
+ const Expr *SecondArg = Call.getArgExpr(1);
+ const QualType FirstType = FirstArg->getType();
+ const QualType SecondType = SecondArg->getType();
+
+ if (FirstType->isIntegralOrEnumerationType() ||
+ SecondType->isIntegralOrEnumerationType()) {
+ // In case of operator+ the iterator can be either on the LHS (eg.:
+ // it + 1), or on the RHS (eg.: 1 + it). Both cases are modeled.
+ const bool IsIterFirst = FirstType->isStructureOrClassType();
+ const SVal FirstArg = Call.getArgSVal(0);
+ const SVal SecondArg = Call.getArgSVal(1);
+ SVal Iterator = IsIterFirst ? FirstArg : SecondArg;
+ SVal Amount = IsIterFirst ? SecondArg : FirstArg;
+
+ handleRandomIncrOrDecr(C, OrigExpr, Op, Call.getReturnValue(), Iterator,
+ Amount);
return;
}
-
- handleIncrement(C, Call.getReturnValue(), Call.getArgSVal(0),
+ }
+ } else if (isIncrementOperator(Op)) {
+ if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
+ handleIncrement(C, Call.getReturnValue(), InstCall->getCXXThisVal(),
Call.getNumArgs());
return;
- } else if (isDecrementOperator(Op)) {
- if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
- handleDecrement(C, Call.getReturnValue(), InstCall->getCXXThisVal(),
- Call.getNumArgs());
- return;
- }
+ }
- handleDecrement(C, Call.getReturnValue(), Call.getArgSVal(0),
- Call.getNumArgs());
+ handleIncrement(C, Call.getReturnValue(), Call.getArgSVal(0),
+ Call.getNumArgs());
+ return;
+ } else if (isDecrementOperator(Op)) {
+ if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
+ handleDecrement(C, Call.getReturnValue(), InstCall->getCXXThisVal(),
+ Call.getNumArgs());
return;
}
+
+ handleDecrement(C, Call.getReturnValue(), Call.getArgSVal(0),
+ Call.getNumArgs());
+ return;
+ }
}
-void
-IteratorModeling::handleAdvanceLikeFunction(CheckerContext &C,
- const CallEvent &Call,
- const Expr *OrigExpr,
- const AdvanceFn *Handler) const {
+void IteratorModeling::handleAdvanceLikeFunction(
+ CheckerContext &C, const CallEvent &Call, const Expr *OrigExpr,
+ const AdvanceFn *Handler) const {
if (!C.wasInlined) {
- (this->**Handler)(C, OrigExpr, Call.getReturnValue(),
- Call.getArgSVal(0), Call.getArgSVal(1));
+ (this->**Handler)(C, OrigExpr, Call.getReturnValue(), Call.getArgSVal(0),
+ Call.getArgSVal(1));
return;
}
@@ -506,8 +506,8 @@ void IteratorModeling::processComparison(CheckerContext &C,
OverloadedOperatorKind Op) const {
if (const auto TruthVal = RetVal.getAs<nonloc::ConcreteInt>()) {
if ((State = relateSymbols(State, Sym1, Sym2,
- (Op == OO_EqualEqual) ==
- (TruthVal->getValue() != 0)))) {
+ (Op == OO_EqualEqual) ==
+ (TruthVal->getValue() != 0)))) {
C.addTransition(State);
} else {
C.generateSink(State, C.getPredecessor());
@@ -542,8 +542,8 @@ void IteratorModeling::handleIncrement(CheckerContext &C, SVal RetVal,
return;
auto NewState =
- advancePosition(State, Iter, OO_Plus,
- nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))));
+ advancePosition(State, Iter, OO_Plus,
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))));
assert(NewState &&
"Advancing position by concrete int should always be successful");
@@ -568,8 +568,8 @@ void IteratorModeling::handleDecrement(CheckerContext &C, SVal RetVal,
return;
auto NewState =
- advancePosition(State, Iter, OO_Minus,
- nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))));
+ advancePosition(State, Iter, OO_Minus,
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))));
assert(NewState &&
"Advancing position by concrete int should always be successful");
@@ -740,7 +740,7 @@ void IteratorModeling::printState(raw_ostream &Out, ProgramStateRef State,
const auto Pos = Sym.second;
Out << (Pos.isValid() ? "Valid" : "Invalid") << " ; Container == ";
Pos.getContainer()->dumpToStream(Out);
- Out<<" ; Offset == ";
+ Out << " ; Offset == ";
Pos.getOffset()->dumpToStream(Out);
}
@@ -753,7 +753,7 @@ void IteratorModeling::printState(raw_ostream &Out, ProgramStateRef State,
const auto Pos = Reg.second;
Out << (Pos.isValid() ? "Valid" : "Invalid") << " ; Container == ";
Pos.getContainer()->dumpToStream(Out);
- Out<<" ; Offset == ";
+ Out << " ; Offset == ";
Pos.getOffset()->dumpToStream(Out);
}
}
@@ -791,8 +791,8 @@ ProgramStateRef relateSymbols(ProgramStateRef State, SymbolRef Sym1,
// 3. Compare the result to 0.
// 4. Assume the result of the comparison.
const auto comparison =
- SVB.evalBinOp(State, BO_EQ, nonloc::SymbolVal(Sym1),
- nonloc::SymbolVal(Sym2), SVB.getConditionType());
+ SVB.evalBinOp(State, BO_EQ, nonloc::SymbolVal(Sym1),
+ nonloc::SymbolVal(Sym2), SVB.getConditionType());
assert(isa<DefinedSVal>(comparison) &&
"Symbol comparison must be a `DefinedSVal`");
diff --git a/clang/lib/StaticAnalyzer/Checkers/IteratorRangeChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/IteratorRangeChecker.cpp
index d2b61fb92483c3..b53118a5effc2d 100644
--- a/clang/lib/StaticAnalyzer/Checkers/IteratorRangeChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/IteratorRangeChecker.cpp
@@ -27,10 +27,10 @@ using namespace iterator;
namespace {
class IteratorRangeChecker
- : public Checker<check::PreCall, check::PreStmt<UnaryOperator>,
- check::PreStmt<BinaryOperator>,
- check::PreStmt<ArraySubscriptExpr>,
- check::PreStmt<MemberExpr>> {
+ : public Checker<check::PreCall, check::PreStmt<UnaryOperator>,
+ check::PreStmt<BinaryOperator>,
+ check::PreStmt<ArraySubscriptExpr>,
+ check::PreStmt<MemberExpr>> {
const BugType OutOfRangeBugType{this, "Iterator out of range",
"Misuse of STL APIs"};
@@ -102,8 +102,7 @@ void IteratorRangeChecker::checkPreCall(const CallEvent &Call,
if (Call.getNumArgs() >= 1 &&
Call.getArgExpr(0)->getType()->isIntegralOrEnumerationType()) {
verifyRandomIncrOrDecr(C, Func->getOverloadedOperator(),
- InstCall->getCXXThisVal(),
- Call.getArgSVal(0));
+ InstCall->getCXXThisVal(), Call.getArgSVal(0));
}
} else {
if (Call.getNumArgs() >= 2 &&
@@ -202,14 +201,16 @@ void IteratorRangeChecker::verifyDereference(CheckerContext &C,
void IteratorRangeChecker::verifyIncrement(CheckerContext &C, SVal Iter) const {
auto &BVF = C.getSValBuilder().getBasicValueFactory();
- verifyRandomIncrOrDecr(C, OO_Plus, Iter,
- nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))));
+ verifyRandomIncrOrDecr(
+ C, OO_Plus, Iter,
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))));
}
void IteratorRangeChecker::verifyDecrement(CheckerContext &C, SVal Iter) const {
auto &BVF = C.getSValBuilder().getBasicValueFactory();
- verifyRandomIncrOrDecr(C, OO_Minus, Iter,
- nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))));
+ verifyRandomIncrOrDecr(
+ C, OO_Minus, Iter,
+ nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))));
}
void IteratorRangeChecker::verifyRandomIncrOrDecr(CheckerContext &C,
@@ -242,15 +243,15 @@ void IteratorRangeChecker::verifyRandomIncrOrDecr(CheckerContext &C,
auto *N = C.generateErrorNode(State);
if (!N)
return;
- reportBug("Iterator decremented ahead of its valid range.", LHS,
- C, N);
+ reportBug("Iterator decremented ahead of its valid range.", LHS, C, N);
}
if (isBehindPastTheEnd(State, *PosAfter)) {
auto *N = C.generateErrorNode(State);
if (!N)
return;
reportBug("Iterator incremented behind the past-the-end "
- "iterator.", LHS, C, N);
+ "iterator.",
+ LHS, C, N);
}
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp
index f0276a57bdf98e..1808cce63b4bb1 100644
--- a/clang/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp
@@ -54,13 +54,13 @@ struct ChecksFilter {
};
class IvarInvalidationCheckerImpl {
- typedef llvm::SmallSetVector<const ObjCMethodDecl*, 2> MethodSet;
- typedef llvm::DenseMap<const ObjCMethodDecl*,
- const ObjCIvarDecl*> MethToIvarMapTy;
- typedef llvm::DenseMap<const ObjCPropertyDecl*,
- const ObjCIvarDecl*> PropToIvarMapTy;
- typedef llvm::DenseMap<const ObjCIvarDecl*,
- const ObjCPropertyDecl*> IvarToPropMapTy;
+ typedef llvm::SmallSetVector<const ObjCMethodDecl *, 2> MethodSet;
+ typedef llvm::DenseMap<const ObjCMethodDecl *, const ObjCIvarDecl *>
+ MethToIvarMapTy;
+ typedef llvm::DenseMap<const ObjCPropertyDecl *, const ObjCIvarDecl *>
+ PropToIvarMapTy;
+ typedef llvm::DenseMap<const ObjCIvarDecl *, const ObjCPropertyDecl *>
+ IvarToPropMapTy;
struct InvalidationInfo {
/// Has the ivar been invalidated?
@@ -74,9 +74,7 @@ class IvarInvalidationCheckerImpl {
InvalidationMethods.insert(MD);
}
- bool needsInvalidation() const {
- return !InvalidationMethods.empty();
- }
+ bool needsInvalidation() const { return !InvalidationMethods.empty(); }
bool hasMethod(const ObjCMethodDecl *MD) {
if (IsInvalidated)
@@ -91,7 +89,7 @@ class IvarInvalidationCheckerImpl {
}
};
- typedef llvm::DenseMap<const ObjCIvarDecl*, InvalidationInfo> IvarSet;
+ typedef llvm::DenseMap<const ObjCIvarDecl *, InvalidationInfo> IvarSet;
/// Statement visitor, which walks the method body and flags the ivars
/// referenced in it (either directly or via property).
@@ -142,19 +140,16 @@ class IvarInvalidationCheckerImpl {
void check(const Expr *E);
public:
- MethodCrawler(IvarSet &InIVars,
- bool &InCalledAnotherInvalidationMethod,
+ MethodCrawler(IvarSet &InIVars, bool &InCalledAnotherInvalidationMethod,
const MethToIvarMapTy &InPropertySetterToIvarMap,
const MethToIvarMapTy &InPropertyGetterToIvarMap,
- const PropToIvarMapTy &InPropertyToIvarMap,
- ASTContext &InCtx)
- : IVars(InIVars),
- CalledAnotherInvalidationMethod(InCalledAnotherInvalidationMethod),
- PropertySetterToIvarMap(InPropertySetterToIvarMap),
- PropertyGetterToIvarMap(InPropertyGetterToIvarMap),
- PropertyToIvarMap(InPropertyToIvarMap),
- InvalidationMethod(nullptr),
- Ctx(InCtx) {}
+ const PropToIvarMapTy &InPropertyToIvarMap, ASTContext &InCtx)
+ : IVars(InIVars),
+ CalledAnotherInvalidationMethod(InCalledAnotherInvalidationMethod),
+ PropertySetterToIvarMap(InPropertySetterToIvarMap),
+ PropertyGetterToIvarMap(InPropertyGetterToIvarMap),
+ PropertyToIvarMap(InPropertyToIvarMap), InvalidationMethod(nullptr),
+ Ctx(InCtx) {}
void VisitStmt(const Stmt *S) { VisitChildren(S); }
@@ -189,10 +184,8 @@ class IvarInvalidationCheckerImpl {
/// the ivar backing the property when possible. Returns '0' when no such
/// ivar could be found.
static const ObjCIvarDecl *findPropertyBackingIvar(
- const ObjCPropertyDecl *Prop,
- const ObjCInterfaceDecl *InterfaceD,
- IvarSet &TrackedIvars,
- const ObjCIvarDecl **FirstIvarDecl);
+ const ObjCPropertyDecl *Prop, const ObjCInterfaceDecl *InterfaceD,
+ IvarSet &TrackedIvars, const ObjCIvarDecl **FirstIvarDecl);
/// Print ivar name or the property if the given ivar backs a property.
static void printIvar(llvm::raw_svector_ostream &os,
@@ -209,16 +202,15 @@ class IvarInvalidationCheckerImpl {
const IvarToPropMapTy &IvarToPopertyMap,
const ObjCMethodDecl *MethodD) const;
- AnalysisManager& Mgr;
+ AnalysisManager &Mgr;
BugReporter &BR;
/// Filter on the checks performed.
const ChecksFilter &Filter;
public:
- IvarInvalidationCheckerImpl(AnalysisManager& InMgr,
- BugReporter &InBR,
- const ChecksFilter &InFilter) :
- Mgr (InMgr), BR(InBR), Filter(InFilter) {}
+ IvarInvalidationCheckerImpl(AnalysisManager &InMgr, BugReporter &InBR,
+ const ChecksFilter &InFilter)
+ : Mgr(InMgr), BR(InBR), Filter(InFilter) {}
void visit(const ObjCImplementationDecl *D) const;
};
@@ -275,9 +267,9 @@ void IvarInvalidationCheckerImpl::containsInvalidationMethod(
}
}
-bool IvarInvalidationCheckerImpl::trackIvar(const ObjCIvarDecl *Iv,
- IvarSet &TrackedIvars,
- const ObjCIvarDecl **FirstIvarDecl) {
+bool IvarInvalidationCheckerImpl::trackIvar(
+ const ObjCIvarDecl *Iv, IvarSet &TrackedIvars,
+ const ObjCIvarDecl **FirstIvarDecl) {
QualType IvQTy = Iv->getType();
const ObjCObjectPointerType *IvTy = IvQTy->getAs<ObjCObjectPointerType>();
if (!IvTy)
@@ -297,10 +289,8 @@ bool IvarInvalidationCheckerImpl::trackIvar(const ObjCIvarDecl *Iv,
}
const ObjCIvarDecl *IvarInvalidationCheckerImpl::findPropertyBackingIvar(
- const ObjCPropertyDecl *Prop,
- const ObjCInterfaceDecl *InterfaceD,
- IvarSet &TrackedIvars,
- const ObjCIvarDecl **FirstIvarDecl) {
+ const ObjCPropertyDecl *Prop, const ObjCInterfaceDecl *InterfaceD,
+ IvarSet &TrackedIvars, const ObjCIvarDecl **FirstIvarDecl) {
const ObjCIvarDecl *IvarD = nullptr;
// Lookup for the synthesized case.
@@ -339,22 +329,22 @@ const ObjCIvarDecl *IvarInvalidationCheckerImpl::findPropertyBackingIvar(
return nullptr;
}
-void IvarInvalidationCheckerImpl::printIvar(llvm::raw_svector_ostream &os,
- const ObjCIvarDecl *IvarDecl,
- const IvarToPropMapTy &IvarToPopertyMap) {
+void IvarInvalidationCheckerImpl::printIvar(
+ llvm::raw_svector_ostream &os, const ObjCIvarDecl *IvarDecl,
+ const IvarToPropMapTy &IvarToPopertyMap) {
if (IvarDecl->getSynthesize()) {
const ObjCPropertyDecl *PD = IvarToPopertyMap.lookup(IvarDecl);
- assert(PD &&"Do we synthesize ivars for something other than properties?");
- os << "Property "<< PD->getName() << " ";
+ assert(PD && "Do we synthesize ivars for something other than properties?");
+ os << "Property " << PD->getName() << " ";
} else {
- os << "Instance variable "<< IvarDecl->getName() << " ";
+ os << "Instance variable " << IvarDecl->getName() << " ";
}
}
// Check that the invalidatable interfaces with ivars/properties implement the
// invalidation methods.
-void IvarInvalidationCheckerImpl::
-visit(const ObjCImplementationDecl *ImplD) const {
+void IvarInvalidationCheckerImpl::visit(
+ const ObjCImplementationDecl *ImplD) const {
// Collect all ivars that need cleanup.
IvarSet Ivars;
// Record the first Ivar needing invalidation; used in reporting when only
@@ -366,7 +356,7 @@ visit(const ObjCImplementationDecl *ImplD) const {
// Collect ivars declared in this class, its extensions and its implementation
ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(InterfaceD);
for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
- Iv= Iv->getNextIvar())
+ Iv = Iv->getNextIvar())
trackIvar(Iv, Ivars, &FirstIvarDecl);
// Construct Property/Property Accessor to Ivar maps to assist checking if an
@@ -383,8 +373,8 @@ visit(const ObjCImplementationDecl *ImplD) const {
if (PD->isClassProperty())
continue;
- const ObjCIvarDecl *ID = findPropertyBackingIvar(PD, InterfaceD, Ivars,
- &FirstIvarDecl);
+ const ObjCIvarDecl *ID =
+ findPropertyBackingIvar(PD, InterfaceD, Ivars, &FirstIvarDecl);
if (!ID)
continue;
@@ -420,19 +410,16 @@ visit(const ObjCImplementationDecl *ImplD) const {
bool AtImplementationContainsAtLeastOnePartialInvalidationMethod = false;
for (const ObjCMethodDecl *InterfD : PartialInfo.InvalidationMethods) {
// Get the corresponding method in the @implementation.
- const ObjCMethodDecl *D = ImplD->getMethod(InterfD->getSelector(),
- InterfD->isInstanceMethod());
+ const ObjCMethodDecl *D =
+ ImplD->getMethod(InterfD->getSelector(), InterfD->isInstanceMethod());
if (D && D->hasBody()) {
AtImplementationContainsAtLeastOnePartialInvalidationMethod = true;
bool CalledAnotherInvalidationMethod = false;
// The MethodCrowler is going to remove the invalidated ivars.
- MethodCrawler(Ivars,
- CalledAnotherInvalidationMethod,
- PropSetterToIvarMap,
- PropGetterToIvarMap,
- PropertyToIvarMap,
- BR.getContext()).VisitStmt(D->getBody());
+ MethodCrawler(Ivars, CalledAnotherInvalidationMethod, PropSetterToIvarMap,
+ PropGetterToIvarMap, PropertyToIvarMap, BR.getContext())
+ .VisitStmt(D->getBody());
// If another invalidation method was called, trust that full invalidation
// has occurred.
if (CalledAnotherInvalidationMethod)
@@ -469,8 +456,8 @@ visit(const ObjCImplementationDecl *ImplD) const {
bool AtImplementationContainsAtLeastOneInvalidationMethod = false;
for (const ObjCMethodDecl *InterfD : Info.InvalidationMethods) {
// Get the corresponding method in the @implementation.
- const ObjCMethodDecl *D = ImplD->getMethod(InterfD->getSelector(),
- InterfD->isInstanceMethod());
+ const ObjCMethodDecl *D =
+ ImplD->getMethod(InterfD->getSelector(), InterfD->isInstanceMethod());
if (D && D->hasBody()) {
AtImplementationContainsAtLeastOneInvalidationMethod = true;
@@ -478,12 +465,10 @@ visit(const ObjCImplementationDecl *ImplD) const {
IvarSet IvarsI = Ivars;
bool CalledAnotherInvalidationMethod = false;
- MethodCrawler(IvarsI,
- CalledAnotherInvalidationMethod,
- PropSetterToIvarMap,
- PropGetterToIvarMap,
- PropertyToIvarMap,
- BR.getContext()).VisitStmt(D->getBody());
+ MethodCrawler(IvarsI, CalledAnotherInvalidationMethod,
+ PropSetterToIvarMap, PropGetterToIvarMap, PropertyToIvarMap,
+ BR.getContext())
+ .VisitStmt(D->getBody());
// If another invalidation method was called, trust that full invalidation
// has occurred.
if (CalledAnotherInvalidationMethod)
@@ -527,26 +512,25 @@ void IvarInvalidationCheckerImpl::reportNoInvalidationMethod(
os << InterfaceD->getName();
PathDiagnosticLocation IvarDecLocation =
- PathDiagnosticLocation::createBegin(FirstIvarDecl, BR.getSourceManager());
+ PathDiagnosticLocation::createBegin(FirstIvarDecl, BR.getSourceManager());
BR.EmitBasicReport(FirstIvarDecl, CheckName, "Incomplete invalidation",
categories::CoreFoundationObjectiveC, os.str(),
IvarDecLocation);
}
-void IvarInvalidationCheckerImpl::
-reportIvarNeedsInvalidation(const ObjCIvarDecl *IvarD,
- const IvarToPropMapTy &IvarToPopertyMap,
- const ObjCMethodDecl *MethodD) const {
+void IvarInvalidationCheckerImpl::reportIvarNeedsInvalidation(
+ const ObjCIvarDecl *IvarD, const IvarToPropMapTy &IvarToPopertyMap,
+ const ObjCMethodDecl *MethodD) const {
SmallString<128> sbuf;
llvm::raw_svector_ostream os(sbuf);
printIvar(os, IvarD, IvarToPopertyMap);
os << "needs to be invalidated or set to nil";
if (MethodD) {
PathDiagnosticLocation MethodDecLocation =
- PathDiagnosticLocation::createEnd(MethodD->getBody(),
- BR.getSourceManager(),
- Mgr.getAnalysisDeclContext(MethodD));
+ PathDiagnosticLocation::createEnd(MethodD->getBody(),
+ BR.getSourceManager(),
+ Mgr.getAnalysisDeclContext(MethodD));
BR.EmitBasicReport(MethodD, Filter.checkName_InstanceVariableInvalidation,
"Incomplete invalidation",
categories::CoreFoundationObjectiveC, os.str(),
@@ -572,7 +556,8 @@ void IvarInvalidationCheckerImpl::MethodCrawler::markInvalidated(
}
}
-const Expr *IvarInvalidationCheckerImpl::MethodCrawler::peel(const Expr *E) const {
+const Expr *
+IvarInvalidationCheckerImpl::MethodCrawler::peel(const Expr *E) const {
E = E->IgnoreParenCasts();
if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
E = POE->getSyntacticForm()->IgnoreParenCasts();
@@ -616,7 +601,7 @@ void IvarInvalidationCheckerImpl::MethodCrawler::checkObjCPropertyRefExpr(
const ObjCMethodDecl *MD = PA->getImplicitPropertySetter();
if (MD) {
MD = MD->getCanonicalDecl();
- MethToIvarMapTy::const_iterator IvI =PropertyGetterToIvarMap.find(MD);
+ MethToIvarMapTy::const_iterator IvI = PropertyGetterToIvarMap.find(MD);
if (IvI != PropertyGetterToIvarMap.end())
markInvalidated(IvI->second);
return;
@@ -627,8 +612,8 @@ void IvarInvalidationCheckerImpl::MethodCrawler::checkObjCPropertyRefExpr(
bool IvarInvalidationCheckerImpl::MethodCrawler::isZero(const Expr *E) const {
E = peel(E);
- return (E->isNullPointerConstant(Ctx, Expr::NPC_ValueDependentIsNotNull)
- != Expr::NPCK_NotNull);
+ return (E->isNullPointerConstant(Ctx, Expr::NPC_ValueDependentIsNotNull) !=
+ Expr::NPCK_NotNull);
}
void IvarInvalidationCheckerImpl::MethodCrawler::check(const Expr *E) {
@@ -657,14 +642,12 @@ void IvarInvalidationCheckerImpl::MethodCrawler::VisitBinaryOperator(
// Do we assign/compare against zero? If yes, check the variable we are
// assigning to.
BinaryOperatorKind Opcode = BO->getOpcode();
- if (Opcode != BO_Assign &&
- Opcode != BO_EQ &&
- Opcode != BO_NE)
+ if (Opcode != BO_Assign && Opcode != BO_EQ && Opcode != BO_NE)
return;
if (isZero(BO->getRHS())) {
- check(BO->getLHS());
- return;
+ check(BO->getLHS());
+ return;
}
if (Opcode != BO_Assign && isZero(BO->getLHS())) {
@@ -674,7 +657,7 @@ void IvarInvalidationCheckerImpl::MethodCrawler::VisitBinaryOperator(
}
void IvarInvalidationCheckerImpl::MethodCrawler::VisitObjCMessageExpr(
- const ObjCMessageExpr *ME) {
+ const ObjCMessageExpr *ME) {
const ObjCMethodDecl *MD = ME->getMethodDecl();
const Expr *Receiver = ME->getInstanceReceiver();
@@ -708,12 +691,13 @@ void IvarInvalidationCheckerImpl::MethodCrawler::VisitObjCMessageExpr(
// Register the checkers.
namespace {
-class IvarInvalidationChecker :
- public Checker<check::ASTDecl<ObjCImplementationDecl> > {
+class IvarInvalidationChecker
+ : public Checker<check::ASTDecl<ObjCImplementationDecl>> {
public:
ChecksFilter Filter;
+
public:
- void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& Mgr,
+ void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager &Mgr,
BugReporter &BR) const {
IvarInvalidationCheckerImpl Walker(Mgr, BR, Filter);
Walker.visit(D);
diff --git a/clang/lib/StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp
index fa51aa80216b45..ade57171526e51 100644
--- a/clang/lib/StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp
@@ -11,9 +11,9 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/StmtVisitor.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "llvm/ADT/SmallString.h"
@@ -128,6 +128,7 @@ class StringRefCheckerVisitor : public StmtVisitor<StringRefCheckerVisitor> {
}
void VisitStmt(Stmt *S) { VisitChildren(S); }
void VisitDeclStmt(DeclStmt *DS);
+
private:
void VisitVarDecl(VarDecl *VD);
};
@@ -179,7 +180,7 @@ void StringRefCheckerVisitor::VisitVarDecl(VarDecl *VD) {
const char *desc = "StringRef should not be bound to temporary "
"std::string that it outlives";
PathDiagnosticLocation VDLoc =
- PathDiagnosticLocation::createBegin(VD, BR.getSourceManager());
+ PathDiagnosticLocation::createBegin(VD, BR.getSourceManager());
BR.EmitBasicReport(DeclWithIssue, Checker, desc, "LLVM Conventions", desc,
VDLoc, Init->getSourceRange());
}
@@ -212,7 +213,7 @@ static bool IsPartOfAST(const CXXRecordDecl *R) {
namespace {
class ASTFieldVisitor {
- SmallVector<FieldDecl*, 10> FieldChain;
+ SmallVector<FieldDecl *, 10> FieldChain;
const CXXRecordDecl *Root;
BugReporter &BR;
const CheckerBase *Checker;
@@ -264,8 +265,9 @@ void ASTFieldVisitor::ReportError(QualType T) {
if (FieldChain.size() > 1) {
os << " via the following chain: ";
bool isFirst = true;
- for (SmallVectorImpl<FieldDecl*>::iterator I=FieldChain.begin(),
- E=FieldChain.end(); I!=E; ++I) {
+ for (SmallVectorImpl<FieldDecl *>::iterator I = FieldChain.begin(),
+ E = FieldChain.end();
+ I != E; ++I) {
if (!isFirst)
os << '.';
else
@@ -283,7 +285,7 @@ void ASTFieldVisitor::ReportError(QualType T) {
// class, as that heuristic doesn't always work (the complete definition of
// the class may be in the header file, for example).
PathDiagnosticLocation L = PathDiagnosticLocation::createBegin(
- FieldChain.front(), BR.getSourceManager());
+ FieldChain.front(), BR.getSourceManager());
BR.EmitBasicReport(Root, Checker, "AST node allocates heap memory",
"LLVM Conventions", os.str(), L);
}
@@ -293,22 +295,21 @@ void ASTFieldVisitor::ReportError(QualType T) {
//===----------------------------------------------------------------------===//
namespace {
-class LLVMConventionsChecker : public Checker<
- check::ASTDecl<CXXRecordDecl>,
- check::ASTCodeBody > {
+class LLVMConventionsChecker
+ : public Checker<check::ASTDecl<CXXRecordDecl>, check::ASTCodeBody> {
public:
- void checkASTDecl(const CXXRecordDecl *R, AnalysisManager& mgr,
+ void checkASTDecl(const CXXRecordDecl *R, AnalysisManager &mgr,
BugReporter &BR) const {
if (R->isCompleteDefinition())
CheckASTMemory(R, BR, this);
}
- void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) const {
CheckStringRefAssignedTemporary(D, BR, this);
}
};
-}
+} // namespace
void ento::registerLLVMConventionsChecker(CheckerManager &mgr) {
mgr.registerChecker<LLVMConventionsChecker>();
diff --git a/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp
index 812d787e2e37c4..d6146d013413fc 100644
--- a/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp
@@ -67,7 +67,8 @@ class NonLocalizedStringChecker
// Methods that require a localized string
mutable llvm::DenseMap<const IdentifierInfo *,
- llvm::DenseMap<Selector, uint8_t>> UIMethods;
+ llvm::DenseMap<Selector, uint8_t>>
+ UIMethods;
// Methods that return a localized string
mutable llvm::SmallSet<std::pair<const IdentifierInfo *, Selector>, 12> LSM;
// C Functions that return a localized string
@@ -131,8 +132,9 @@ class NonLocalizedStringBRVisitor final : public BugReporterVisitor {
#define NEW_RECEIVER(receiver) \
llvm::DenseMap<Selector, uint8_t> &receiver##M = \
- UIMethods.insert({&Ctx.Idents.get(#receiver), \
- llvm::DenseMap<Selector, uint8_t>()}) \
+ UIMethods \
+ .insert({&Ctx.Idents.get(#receiver), \
+ llvm::DenseMap<Selector, uint8_t>()}) \
.first->second;
#define ADD_NULLARY_METHOD(receiver, method, argument) \
receiver##M.insert( \
@@ -710,7 +712,6 @@ void NonLocalizedStringChecker::setNonLocalizedState(const SVal S,
}
}
-
static bool isDebuggingName(std::string name) {
return StringRef(name).contains_insensitive("debug");
}
@@ -739,7 +740,6 @@ static bool isDebuggingContext(CheckerContext &C) {
return false;
}
-
/// Reports a localization error for the passed in method call and SVal
void NonLocalizedStringChecker::reportLocalizationError(
SVal S, const CallEvent &M, CheckerContext &C, int argumentNumber) const {
@@ -751,7 +751,8 @@ void NonLocalizedStringChecker::reportLocalizationError(
static CheckerProgramPointTag Tag("NonLocalizedStringChecker",
"UnlocalizedString");
- ExplodedNode *ErrNode = C.addTransition(C.getState(), C.getPredecessor(), &Tag);
+ ExplodedNode *ErrNode =
+ C.addTransition(C.getState(), C.getPredecessor(), &Tag);
if (!ErrNode)
return;
@@ -883,7 +884,8 @@ void NonLocalizedStringChecker::checkPreCall(const CallEvent &Call,
auto formals = FD->parameters();
for (unsigned i = 0, ei = std::min(static_cast<unsigned>(formals.size()),
- Call.getNumArgs()); i != ei; ++i) {
+ Call.getNumArgs());
+ i != ei; ++i) {
if (isAnnotatedAsTakingLocalized(formals[i])) {
auto actual = Call.getArgSVal(i);
if (hasNonLocalizedState(actual, C)) {
@@ -1395,9 +1397,8 @@ void PluralMisuseChecker::MethodCrawler::reportPluralMisuseError(
void ento::registerNonLocalizedStringChecker(CheckerManager &mgr) {
NonLocalizedStringChecker *checker =
mgr.registerChecker<NonLocalizedStringChecker>();
- checker->IsAggressive =
- mgr.getAnalyzerOptions().getCheckerBooleanOption(
- checker, "AggressiveReport");
+ checker->IsAggressive = mgr.getAnalyzerOptions().getCheckerBooleanOption(
+ checker, "AggressiveReport");
}
bool ento::shouldRegisterNonLocalizedStringChecker(const CheckerManager &mgr) {
@@ -1409,7 +1410,7 @@ void ento::registerEmptyLocalizationContextChecker(CheckerManager &mgr) {
}
bool ento::shouldRegisterEmptyLocalizationContextChecker(
- const CheckerManager &mgr) {
+ const CheckerManager &mgr) {
return true;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp
index 153a0a51e98024..176b9a5b3bc6f7 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp
@@ -106,7 +106,6 @@ class MIGChecker : public Checker<check::PostCall, check::PreStmt<ReturnStmt>,
void checkEndFunction(const ReturnStmt *RS, CheckerContext &C) const {
checkReturnAux(RS, C);
}
-
};
} // end anonymous namespace
@@ -132,7 +131,7 @@ static const ParmVarDecl *getOriginParam(SVal V, CheckerContext &C,
while (const MemRegion *MR = Sym->getOriginRegion()) {
const auto *VR = dyn_cast<VarRegion>(MR);
if (VR && VR->hasStackParametersStorage() &&
- VR->getStackFrame()->inTopFrame())
+ VR->getStackFrame()->inTopFrame())
return cast<ParmVarDecl>(VR->getDecl());
const SymbolicRegion *SR = MR->getSymbolicBase();
@@ -165,7 +164,8 @@ static bool isInMIGCall(CheckerContext &C) {
// FIXME: AnyCall doesn't support blocks yet, so they remain unchecked
// for now.
if (!AC->getReturnType(C.getASTContext())
- .getCanonicalType()->isSignedIntegerType())
+ .getCanonicalType()
+ ->isSignedIntegerType())
return false;
}
@@ -174,7 +174,7 @@ static bool isInMIGCall(CheckerContext &C) {
// See if there's an annotated method in the superclass.
if (const auto *MD = dyn_cast<CXXMethodDecl>(D))
- for (const auto *OMD: MD->overridden_methods())
+ for (const auto *OMD : MD->overridden_methods())
if (OMD->hasAttr<MIGServerRoutineAttr>())
return true;
@@ -186,8 +186,8 @@ void MIGChecker::checkPostCall(const CallEvent &Call, CheckerContext &C) const {
// If the code is doing reference counting over the parameter,
// it opens up an opportunity for safely calling a destructor function.
// TODO: We should still check for over-releases.
- if (const ParmVarDecl *PVD =
- getOriginParam(Call.getArgSVal(0), C, /*IncludeBaseRegions=*/true)) {
+ if (const ParmVarDecl *PVD = getOriginParam(Call.getArgSVal(0), C,
+ /*IncludeBaseRegions=*/true)) {
// We never need to clean up the program state because these are
// top-level parameters anyway, so they're always live.
C.addTransition(C.getState()->add<RefCountedParameters>(PVD));
@@ -213,7 +213,7 @@ void MIGChecker::checkPostCall(const CallEvent &Call, CheckerContext &C) const {
return;
const NoteTag *T =
- C.getNoteTag([this, PVD](PathSensitiveBugReport &BR) -> std::string {
+ C.getNoteTag([this, PVD](PathSensitiveBugReport &BR) -> std::string {
if (&BR.getBugType() != &BT)
return "";
SmallString<64> Str;
@@ -296,6 +296,4 @@ void ento::registerMIGChecker(CheckerManager &Mgr) {
Mgr.registerChecker<MIGChecker>();
}
-bool ento::shouldRegisterMIGChecker(const CheckerManager &mgr) {
- return true;
-}
+bool ento::shouldRegisterMIGChecker(const CheckerManager &mgr) { return true; }
diff --git a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp
index 3e374e6c240e76..3f995ca73a62bd 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp
@@ -22,8 +22,7 @@ namespace mpi {
void MPIBugReporter::reportDoubleNonblocking(
const CallEvent &MPICallEvent, const ento::mpi::Request &Req,
- const MemRegion *const RequestRegion,
- const ExplodedNode *const ExplNode,
+ const MemRegion *const RequestRegion, const ExplodedNode *const ExplNode,
BugReporter &BReporter) const {
std::string ErrorText;
@@ -46,10 +45,10 @@ void MPIBugReporter::reportDoubleNonblocking(
BReporter.emitReport(std::move(Report));
}
-void MPIBugReporter::reportMissingWait(
- const ento::mpi::Request &Req, const MemRegion *const RequestRegion,
- const ExplodedNode *const ExplNode,
- BugReporter &BReporter) const {
+void MPIBugReporter::reportMissingWait(const ento::mpi::Request &Req,
+ const MemRegion *const RequestRegion,
+ const ExplodedNode *const ExplNode,
+ BugReporter &BReporter) const {
std::string ErrorText{"Request " + RequestRegion->getDescriptiveName() +
" has no matching wait. "};
@@ -68,8 +67,7 @@ void MPIBugReporter::reportMissingWait(
void MPIBugReporter::reportUnmatchedWait(
const CallEvent &CE, const clang::ento::MemRegion *const RequestRegion,
- const ExplodedNode *const ExplNode,
- BugReporter &BReporter) const {
+ const ExplodedNode *const ExplNode, BugReporter &BReporter) const {
std::string ErrorText{"Request " + RequestRegion->getDescriptiveName() +
" has no matching nonblocking call. "};
@@ -112,6 +110,6 @@ MPIBugReporter::RequestNodeVisitor::VisitNode(const ExplodedNode *N,
return nullptr;
}
-} // end of namespace: mpi
-} // end of namespace: ento
-} // end of namespace: clang
+} // namespace mpi
+} // namespace ento
+} // namespace clang
diff --git a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.h b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.h
index 0222a2120b34f3..dd84c8c898c199 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.h
+++ b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.h
@@ -42,7 +42,7 @@ class MPIBugReporter {
const Request &Req,
const MemRegion *const RequestRegion,
const ExplodedNode *const ExplNode,
- BugReporter &BReporter) const;
+ BugReporter &BReporter) const;
/// Report a missing wait for a nonblocking call.
///
@@ -97,8 +97,8 @@ class MPIBugReporter {
};
};
-} // end of namespace: mpi
-} // end of namespace: ento
-} // end of namespace: clang
+} // namespace mpi
+} // namespace ento
+} // namespace clang
#endif
diff --git a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp
index 4c0a8ba2c7c094..280403167b38ee 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp
@@ -181,9 +181,9 @@ void MPIChecker::allRegionsUsedByWait(
}
}
-} // end of namespace: mpi
-} // end of namespace: ento
-} // end of namespace: clang
+} // namespace mpi
+} // namespace ento
+} // namespace clang
// Registers the checker for static analysis.
void clang::ento::registerMPIChecker(CheckerManager &MGR) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.h b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.h
index ce9f1afac20902..23d0e7dd254300 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.h
+++ b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.h
@@ -97,8 +97,8 @@ class MPIChecker : public Checker<check::PreCall, check::DeadSymbols> {
MPIBugReporter BReporter;
};
-} // end of namespace: mpi
-} // end of namespace: ento
-} // end of namespace: clang
+} // namespace mpi
+} // namespace ento
+} // namespace clang
#endif
diff --git a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIFunctionClassifier.cpp b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIFunctionClassifier.cpp
index 277b3ed2e10568..57d16193e386a3 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIFunctionClassifier.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIFunctionClassifier.cpp
@@ -278,6 +278,6 @@ bool MPIFunctionClassifier::isWaitType(const IdentifierInfo *IdentInfo) const {
return IdentInfo == IdentInfo_MPI_Wait || IdentInfo == IdentInfo_MPI_Waitall;
}
-} // end of namespace: mpi
-} // end of namespace: ento
-} // end of namespace: clang
+} // namespace mpi
+} // namespace ento
+} // namespace clang
diff --git a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h
index fe0fb2a4d0e727..22767273c21b79 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h
+++ b/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPITypes.h
@@ -50,7 +50,7 @@ typedef llvm::ImmutableMap<const clang::ento::MemRegion *,
clang::ento::mpi::Request>
RequestMapImpl;
-} // end of namespace: mpi
+} // namespace mpi
template <>
struct ProgramStateTrait<mpi::RequestMap>
@@ -61,6 +61,6 @@ struct ProgramStateTrait<mpi::RequestMap>
}
};
-} // end of namespace: ento
-} // end of namespace: clang
+} // namespace ento
+} // namespace clang
#endif
diff --git a/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp
index 12bf12a0b23227..70d4bfb450d2ef 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp
@@ -28,11 +28,9 @@ using namespace clang;
using namespace ento;
namespace {
-class MacOSKeychainAPIChecker : public Checker<check::PreStmt<CallExpr>,
- check::PostStmt<CallExpr>,
- check::DeadSymbols,
- check::PointerEscape,
- eval::Assume> {
+class MacOSKeychainAPIChecker
+ : public Checker<check::PreStmt<CallExpr>, check::PostStmt<CallExpr>,
+ check::DeadSymbols, check::PointerEscape, eval::Assume> {
const BugType BT{this, "Improper use of SecKeychain API",
categories::AppleAPIMisuse};
@@ -44,13 +42,11 @@ class MacOSKeychainAPIChecker : public Checker<check::PreStmt<CallExpr>,
unsigned int AllocatorIdx;
SymbolRef Region;
- AllocationState(const Expr *E, unsigned int Idx, SymbolRef R) :
- AllocatorIdx(Idx),
- Region(R) {}
+ AllocationState(const Expr *E, unsigned int Idx, SymbolRef R)
+ : AllocatorIdx(Idx), Region(R) {}
bool operator==(const AllocationState &X) const {
- return (AllocatorIdx == X.AllocatorIdx &&
- Region == X.Region);
+ return (AllocatorIdx == X.AllocatorIdx && Region == X.Region);
}
void Profile(llvm::FoldingSetNodeID &ID) const {
@@ -68,11 +64,11 @@ class MacOSKeychainAPIChecker : public Checker<check::PreStmt<CallExpr>,
PointerEscapeKind Kind) const;
ProgramStateRef evalAssume(ProgramStateRef state, SVal Cond,
bool Assumption) const;
- void printState(raw_ostream &Out, ProgramStateRef State,
- const char *NL, const char *Sep) const override;
+ void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
+ const char *Sep) const override;
private:
- typedef std::pair<SymbolRef, const AllocationState*> AllocationPair;
+ typedef std::pair<SymbolRef, const AllocationState *> AllocationPair;
typedef SmallVector<AllocationPair, 2> AllocationPairVec;
enum APIKind {
@@ -87,7 +83,7 @@ class MacOSKeychainAPIChecker : public Checker<check::PreStmt<CallExpr>,
/// Stores the information about the allocator and deallocator functions -
/// these are the functions the checker is tracking.
struct ADFunctionInfo {
- const char* Name;
+ const char *Name;
unsigned int Param;
unsigned int DeallocatorIdx;
APIKind Kind;
@@ -144,13 +140,12 @@ class MacOSKeychainAPIChecker : public Checker<check::PreStmt<CallExpr>,
PathSensitiveBugReport &BR) override;
};
};
-}
+} // namespace
/// ProgramState traits to store the currently allocated (and not yet freed)
/// symbols. This is a map from the allocated content symbol to the
/// corresponding AllocationState.
-REGISTER_MAP_WITH_PROGRAMSTATE(AllocatedData,
- SymbolRef,
+REGISTER_MAP_WITH_PROGRAMSTATE(AllocatedData, SymbolRef,
MacOSKeychainAPIChecker::AllocationState)
static bool isEnclosingFunctionParam(const Expr *E) {
@@ -164,15 +159,15 @@ static bool isEnclosingFunctionParam(const Expr *E) {
}
const MacOSKeychainAPIChecker::ADFunctionInfo
- MacOSKeychainAPIChecker::FunctionsToTrack[FunctionsToTrackSize] = {
- {"SecKeychainItemCopyContent", 4, 3, ValidAPI}, // 0
- {"SecKeychainFindGenericPassword", 6, 3, ValidAPI}, // 1
- {"SecKeychainFindInternetPassword", 13, 3, ValidAPI}, // 2
- {"SecKeychainItemFreeContent", 1, InvalidIdx, ValidAPI}, // 3
- {"SecKeychainItemCopyAttributesAndData", 5, 5, ValidAPI}, // 4
- {"SecKeychainItemFreeAttributesAndData", 1, InvalidIdx, ValidAPI}, // 5
- {"free", 0, InvalidIdx, ErrorAPI}, // 6
- {"CFStringCreateWithBytesNoCopy", 1, InvalidIdx, PossibleAPI}, // 7
+ MacOSKeychainAPIChecker::FunctionsToTrack[FunctionsToTrackSize] = {
+ {"SecKeychainItemCopyContent", 4, 3, ValidAPI}, // 0
+ {"SecKeychainFindGenericPassword", 6, 3, ValidAPI}, // 1
+ {"SecKeychainFindInternetPassword", 13, 3, ValidAPI}, // 2
+ {"SecKeychainItemFreeContent", 1, InvalidIdx, ValidAPI}, // 3
+ {"SecKeychainItemCopyAttributesAndData", 5, 5, ValidAPI}, // 4
+ {"SecKeychainItemFreeAttributesAndData", 1, InvalidIdx, ValidAPI}, // 5
+ {"free", 0, InvalidIdx, ErrorAPI}, // 6
+ {"CFStringCreateWithBytesNoCopy", 1, InvalidIdx, PossibleAPI}, // 7
};
unsigned MacOSKeychainAPIChecker::getTrackedFunctionIndex(StringRef Name,
@@ -201,13 +196,12 @@ static bool isBadDeallocationArgument(const MemRegion *Arg) {
/// Given the address expression, retrieve the value it's pointing to. Assume
/// that value is itself an address, and return the corresponding symbol.
-static SymbolRef getAsPointeeSymbol(const Expr *Expr,
- CheckerContext &C) {
+static SymbolRef getAsPointeeSymbol(const Expr *Expr, CheckerContext &C) {
ProgramStateRef State = C.getState();
SVal ArgV = C.getSVal(Expr);
if (std::optional<loc::MemRegionVal> X = ArgV.getAs<loc::MemRegionVal>()) {
- StoreManager& SM = C.getStoreManager();
+ StoreManager &SM = C.getStoreManager();
SymbolRef sym = SM.getBinding(State->getStore(), *X).getAsLocSymbol();
if (sym)
return sym;
@@ -217,10 +211,8 @@ static SymbolRef getAsPointeeSymbol(const Expr *Expr,
// Report deallocator mismatch. Remove the region from tracking - reporting a
// missing free error after this one is redundant.
-void MacOSKeychainAPIChecker::
- generateDeallocatorMismatchReport(const AllocationPair &AP,
- const Expr *ArgExpr,
- CheckerContext &C) const {
+void MacOSKeychainAPIChecker::generateDeallocatorMismatchReport(
+ const AllocationPair &AP, const Expr *ArgExpr, CheckerContext &C) const {
ProgramStateRef State = C.getState();
State = State->remove<AllocatedData>(AP.first);
ExplodedNode *N = C.generateNonFatalErrorNode(State);
@@ -230,7 +222,7 @@ void MacOSKeychainAPIChecker::
SmallString<80> sbuf;
llvm::raw_svector_ostream os(sbuf);
unsigned int PDeallocIdx =
- FunctionsToTrack[AP.second->AllocatorIdx].DeallocatorIdx;
+ FunctionsToTrack[AP.second->AllocatorIdx].DeallocatorIdx;
os << "Deallocator doesn't match the allocator: '"
<< FunctionsToTrack[PDeallocIdx].Name << "' should be used.";
@@ -274,9 +266,8 @@ void MacOSKeychainAPIChecker::checkPreStmt(const CallExpr *CE,
llvm::raw_svector_ostream os(sbuf);
unsigned int DIdx = FunctionsToTrack[AS->AllocatorIdx].DeallocatorIdx;
os << "Allocated data should be released before another call to "
- << "the allocator: missing a call to '"
- << FunctionsToTrack[DIdx].Name
- << "'.";
+ << "the allocator: missing a call to '"
+ << FunctionsToTrack[DIdx].Name << "'.";
auto Report = std::make_unique<PathSensitiveBugReport>(BT, os.str(), N);
Report->addVisitor(std::make_unique<SecKeychainBugVisitor>(V));
Report->addRange(ArgExpr->getSourceRange());
@@ -345,8 +336,8 @@ void MacOSKeychainAPIChecker::checkPreStmt(const CallExpr *CE,
if (funName == "CFStringCreateWithBytesNoCopy") {
const Expr *DeallocatorExpr = CE->getArg(5)->IgnoreParenCasts();
// NULL ~ default deallocator, so warn.
- if (DeallocatorExpr->isNullPointerConstant(C.getASTContext(),
- Expr::NPC_ValueDependentIsNotNull)) {
+ if (DeallocatorExpr->isNullPointerConstant(
+ C.getASTContext(), Expr::NPC_ValueDependentIsNotNull)) {
const AllocationPair AP = std::make_pair(ArgSM, AS);
generateDeallocatorMismatchReport(AP, ArgExpr, C);
return;
@@ -429,8 +420,8 @@ void MacOSKeychainAPIChecker::checkPostStmt(const CallExpr *CE,
C.getSymbolManager().addSymbolDependency(V, RetStatusSymbol);
// Track the allocated value in the checker state.
- State = State->set<AllocatedData>(V, AllocationState(ArgExpr, idx,
- RetStatusSymbol));
+ State = State->set<AllocatedData>(
+ V, AllocationState(ArgExpr, idx, RetStatusSymbol));
assert(State);
C.addTransition(State);
}
@@ -438,8 +429,7 @@ void MacOSKeychainAPIChecker::checkPostStmt(const CallExpr *CE,
// TODO: This logic is the same as in Malloc checker.
const ExplodedNode *
-MacOSKeychainAPIChecker::getAllocationNode(const ExplodedNode *N,
- SymbolRef Sym,
+MacOSKeychainAPIChecker::getAllocationNode(const ExplodedNode *N, SymbolRef Sym,
CheckerContext &C) const {
const LocationContext *LeakContext = N->getLocationContext();
// Walk the ExplodedGraph backwards and find the first node that referred to
@@ -452,8 +442,7 @@ MacOSKeychainAPIChecker::getAllocationNode(const ExplodedNode *N,
// Allocation node, is the last node in the current or parent context in
// which the symbol was tracked.
const LocationContext *NContext = N->getLocationContext();
- if (NContext == LeakContext ||
- NContext->isParentOf(LeakContext))
+ if (NContext == LeakContext || NContext->isParentOf(LeakContext))
AllocNode = N;
N = N->pred_empty() ? nullptr : *(N->pred_begin());
}
@@ -468,7 +457,7 @@ MacOSKeychainAPIChecker::generateAllocatedDataNotReleasedReport(
SmallString<70> sbuf;
llvm::raw_svector_ostream os(sbuf);
os << "Allocated data is not released: missing a call to '"
- << FunctionsToTrack[FI.DeallocatorIdx].Name << "'.";
+ << FunctionsToTrack[FI.DeallocatorIdx].Name << "'.";
// Most bug reports are cached at the location where they occurred.
// With leaks, we want to unique them by the location where they were
@@ -478,9 +467,8 @@ MacOSKeychainAPIChecker::generateAllocatedDataNotReleasedReport(
const Stmt *AllocStmt = AllocNode->getStmtForDiagnostics();
if (AllocStmt)
- LocUsedForUniqueing = PathDiagnosticLocation::createBegin(AllocStmt,
- C.getSourceManager(),
- AllocNode->getLocationContext());
+ LocUsedForUniqueing = PathDiagnosticLocation::createBegin(
+ AllocStmt, C.getSourceManager(), AllocNode->getLocationContext());
auto Report = std::make_unique<PathSensitiveBugReport>(
BT, os.str(), N, LocUsedForUniqueing,
@@ -512,8 +500,8 @@ ProgramStateRef MacOSKeychainAPIChecker::evalAssume(ProgramStateRef State,
SymbolRef ReturnSymbol = nullptr;
if (auto *SIE = dyn_cast<SymIntExpr>(CondBSE)) {
const llvm::APInt &RHS = SIE->getRHS();
- bool ErrorIsReturned = (OpCode == BO_EQ && RHS != NoErr) ||
- (OpCode == BO_NE && RHS == NoErr);
+ bool ErrorIsReturned =
+ (OpCode == BO_EQ && RHS != NoErr) || (OpCode == BO_NE && RHS == NoErr);
if (!Assumption)
ErrorIsReturned = !ErrorIsReturned;
if (ErrorIsReturned)
@@ -639,8 +627,7 @@ MacOSKeychainAPIChecker::SecKeychainBugVisitor::VisitNode(
}
void MacOSKeychainAPIChecker::printState(raw_ostream &Out,
- ProgramStateRef State,
- const char *NL,
+ ProgramStateRef State, const char *NL,
const char *Sep) const {
AllocatedDataTy AMap = State->get<AllocatedData>();
@@ -653,7 +640,6 @@ void MacOSKeychainAPIChecker::printState(raw_ostream &Out,
}
}
-
void ento::registerMacOSKeychainAPIChecker(CheckerManager &mgr) {
mgr.registerChecker<MacOSKeychainAPIChecker>();
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp
index 754b167642961c..b6e33cc95e0a54 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp
@@ -31,7 +31,7 @@ using namespace clang;
using namespace ento;
namespace {
-class MacOSXAPIChecker : public Checker< check::PreStmt<CallExpr> > {
+class MacOSXAPIChecker : public Checker<check::PreStmt<CallExpr>> {
const BugType BT_dispatchOnce{this, "Improper use of 'dispatch_once'",
categories::AppleAPIMisuse};
@@ -47,7 +47,7 @@ class MacOSXAPIChecker : public Checker< check::PreStmt<CallExpr> > {
const CallExpr *,
StringRef FName) const;
};
-} //end anonymous namespace
+} // end anonymous namespace
//===----------------------------------------------------------------------===//
// dispatch_once and dispatch_once_f
@@ -155,12 +155,10 @@ void MacOSXAPIChecker::checkPreStmt(const CallExpr *CE,
return;
SubChecker SC =
- llvm::StringSwitch<SubChecker>(Name)
- .Cases("dispatch_once",
- "_dispatch_once",
- "dispatch_once_f",
- &MacOSXAPIChecker::CheckDispatchOnce)
- .Default(nullptr);
+ llvm::StringSwitch<SubChecker>(Name)
+ .Cases("dispatch_once", "_dispatch_once", "dispatch_once_f",
+ &MacOSXAPIChecker::CheckDispatchOnce)
+ .Default(nullptr);
if (SC)
(this->*SC)(C, CE, Name);
diff --git a/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp
index 79ab05f2c7866a..b19fcc71c07d67 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp
@@ -199,12 +199,15 @@ class RefState {
LLVM_DUMP_METHOD void dump(raw_ostream &OS) const {
switch (K) {
-#define CASE(ID) case ID: OS << #ID; break;
- CASE(Allocated)
- CASE(AllocatedOfSizeZero)
- CASE(Released)
- CASE(Relinquished)
- CASE(Escaped)
+#define CASE(ID) \
+ case ID: \
+ OS << #ID; \
+ break;
+ CASE(Allocated)
+ CASE(AllocatedOfSizeZero)
+ CASE(Released)
+ CASE(Relinquished)
+ CASE(Escaped)
}
}
@@ -272,8 +275,7 @@ struct ReallocPair {
ID.AddPointer(ReallocatedSym);
}
bool operator==(const ReallocPair &X) const {
- return ReallocatedSym == X.ReallocatedSym &&
- Kind == X.Kind;
+ return ReallocatedSym == X.ReallocatedSym && Kind == X.Kind;
}
};
@@ -333,27 +335,28 @@ class MallocChecker
void checkPreCall(const CallEvent &Call, CheckerContext &C) const;
void checkPostCall(const CallEvent &Call, CheckerContext &C) const;
void checkNewAllocator(const CXXAllocatorCall &Call, CheckerContext &C) const;
- void checkPostObjCMessage(const ObjCMethodCall &Call, CheckerContext &C) const;
+ void checkPostObjCMessage(const ObjCMethodCall &Call,
+ CheckerContext &C) const;
void checkPostStmt(const BlockExpr *BE, CheckerContext &C) const;
void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &C) const;
void checkPreStmt(const ReturnStmt *S, CheckerContext &C) const;
void checkEndFunction(const ReturnStmt *S, CheckerContext &C) const;
ProgramStateRef evalAssume(ProgramStateRef state, SVal Cond,
- bool Assumption) const;
+ bool Assumption) const;
void checkLocation(SVal l, bool isLoad, const Stmt *S,
CheckerContext &C) const;
ProgramStateRef checkPointerEscape(ProgramStateRef State,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind) const;
+ const InvalidatedSymbols &Escaped,
+ const CallEvent *Call,
+ PointerEscapeKind Kind) const;
ProgramStateRef checkConstPointerEscape(ProgramStateRef State,
const InvalidatedSymbols &Escaped,
const CallEvent *Call,
PointerEscapeKind Kind) const;
- void printState(raw_ostream &Out, ProgramStateRef State,
- const char *NL, const char *Sep) const override;
+ void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
+ const char *Sep) const override;
private:
mutable std::unique_ptr<BugType> BT_DoubleFree[CK_NumCheckKinds];
@@ -655,9 +658,10 @@ class MallocChecker
///
/// We assume that pointers do not escape through calls to system functions
/// not handled by this checker.
- bool mayFreeAnyEscapedMemoryOrIsModeledExplicitly(const CallEvent *Call,
- ProgramStateRef State,
- SymbolRef &EscapingSymbol) const;
+ bool
+ mayFreeAnyEscapedMemoryOrIsModeledExplicitly(const CallEvent *Call,
+ ProgramStateRef State,
+ SymbolRef &EscapingSymbol) const;
/// Implementation of the checkPointerEscape callbacks.
[[nodiscard]] ProgramStateRef
@@ -1183,9 +1187,8 @@ MallocChecker::performKernelMalloc(const CallEvent &Call, CheckerContext &C,
NonLoc ZeroFlag = C.getSValBuilder()
.makeIntVal(*KernelZeroFlagVal, FlagsEx->getType())
.castAs<NonLoc>();
- SVal MaskedFlagsUC = C.getSValBuilder().evalBinOpNN(State, BO_And,
- Flags, ZeroFlag,
- FlagsEx->getType());
+ SVal MaskedFlagsUC = C.getSValBuilder().evalBinOpNN(
+ State, BO_And, Flags, ZeroFlag, FlagsEx->getType());
if (MaskedFlagsUC.isUnknownOrUndef())
return std::nullopt;
DefinedSVal MaskedFlags = MaskedFlagsUC.castAs<DefinedSVal>();
@@ -1404,7 +1407,8 @@ void MallocChecker::checkGMallocN(const CallEvent &Call,
CheckerContext &C) const {
ProgramStateRef State = C.getState();
SVal Init = UndefinedVal();
- SVal TotalSize = evalMulForBufferSize(C, Call.getArgExpr(0), Call.getArgExpr(1));
+ SVal TotalSize =
+ evalMulForBufferSize(C, Call.getArgExpr(0), Call.getArgExpr(1));
State = MallocMemAux(C, Call, TotalSize, Init, State, AF_Malloc);
State = ProcessZeroAllocCheck(Call, 0, State);
State = ProcessZeroAllocCheck(Call, 1, State);
@@ -1416,7 +1420,8 @@ void MallocChecker::checkGMallocN0(const CallEvent &Call,
ProgramStateRef State = C.getState();
SValBuilder &SB = C.getSValBuilder();
SVal Init = SB.makeZeroVal(SB.getContext().CharTy);
- SVal TotalSize = evalMulForBufferSize(C, Call.getArgExpr(0), Call.getArgExpr(1));
+ SVal TotalSize =
+ evalMulForBufferSize(C, Call.getArgExpr(0), Call.getArgExpr(1));
State = MallocMemAux(C, Call, TotalSize, Init, State, AF_Malloc);
State = ProcessZeroAllocCheck(Call, 0, State);
State = ProcessZeroAllocCheck(Call, 1, State);
@@ -1543,8 +1548,8 @@ ProgramStateRef MallocChecker::ProcessZeroAllocCheck(
const RefState *RS = State->get<RegionState>(Sym);
if (RS) {
if (RS->isAllocated())
- return TrueState->set<RegionState>(Sym,
- RefState::getAllocatedOfSizeZero(RS));
+ return TrueState->set<RegionState>(
+ Sym, RefState::getAllocatedOfSizeZero(RS));
else
return State;
} else {
@@ -1818,8 +1823,8 @@ ProgramStateRef MallocChecker::FreeMemAux(CheckerContext &C,
/// Checks if the previous call to free on the given symbol failed - if free
/// failed, returns true. Also, returns the corresponding return value symbol.
-static bool didPreviousFreeFail(ProgramStateRef State,
- SymbolRef Sym, SymbolRef &RetStatusSymbol) {
+static bool didPreviousFreeFail(ProgramStateRef State, SymbolRef Sym,
+ SymbolRef &RetStatusSymbol) {
const SymbolRef *Ret = State->get<FreeReturnValue>(Sym);
if (Ret) {
assert(*Ret && "We should not store the null return symbol");
@@ -1872,26 +1877,48 @@ static bool printMemFnName(raw_ostream &os, CheckerContext &C, const Expr *E) {
static void printExpectedAllocName(raw_ostream &os, AllocationFamily Family) {
- switch(Family) {
- case AF_Malloc: os << "malloc()"; return;
- case AF_CXXNew: os << "'new'"; return;
- case AF_CXXNewArray: os << "'new[]'"; return;
- case AF_IfNameIndex: os << "'if_nameindex()'"; return;
- case AF_InnerBuffer: os << "container-specific allocator"; return;
- case AF_Alloca:
- case AF_None: llvm_unreachable("not a deallocation expression");
+ switch (Family) {
+ case AF_Malloc:
+ os << "malloc()";
+ return;
+ case AF_CXXNew:
+ os << "'new'";
+ return;
+ case AF_CXXNewArray:
+ os << "'new[]'";
+ return;
+ case AF_IfNameIndex:
+ os << "'if_nameindex()'";
+ return;
+ case AF_InnerBuffer:
+ os << "container-specific allocator";
+ return;
+ case AF_Alloca:
+ case AF_None:
+ llvm_unreachable("not a deallocation expression");
}
}
static void printExpectedDeallocName(raw_ostream &os, AllocationFamily Family) {
- switch(Family) {
- case AF_Malloc: os << "free()"; return;
- case AF_CXXNew: os << "'delete'"; return;
- case AF_CXXNewArray: os << "'delete[]'"; return;
- case AF_IfNameIndex: os << "'if_freenameindex()'"; return;
- case AF_InnerBuffer: os << "container-specific deallocator"; return;
- case AF_Alloca:
- case AF_None: llvm_unreachable("suspicious argument");
+ switch (Family) {
+ case AF_Malloc:
+ os << "free()";
+ return;
+ case AF_CXXNew:
+ os << "'delete'";
+ return;
+ case AF_CXXNewArray:
+ os << "'delete[]'";
+ return;
+ case AF_IfNameIndex:
+ os << "'if_freenameindex()'";
+ return;
+ case AF_InnerBuffer:
+ os << "container-specific deallocator";
+ return;
+ case AF_Alloca:
+ case AF_None:
+ llvm_unreachable("suspicious argument");
}
}
@@ -2005,8 +2032,8 @@ ProgramStateRef MallocChecker::FreeMemAux(
SymBase, PreviousRetStatusSymbol);
return nullptr;
- // If the pointer is allocated or escaped, but we are now trying to free it,
- // check that the call to free is proper.
+ // If the pointer is allocated or escaped, but we are now trying to free
+ // it, check that the call to free is proper.
} else if (RsBase->isAllocated() || RsBase->isAllocatedOfSizeZero() ||
RsBase->isEscaped()) {
@@ -2021,8 +2048,7 @@ ProgramStateRef MallocChecker::FreeMemAux(
// Check if the memory location being freed is the actual location
// allocated, or an offset.
RegionOffset Offset = R->getAsOffset();
- if (Offset.isValid() &&
- !Offset.hasSymbolicOffset() &&
+ if (Offset.isValid() && !Offset.hasSymbolicOffset() &&
Offset.getOffset() != 0) {
const Expr *AllocExpr = cast<Expr>(RsBase->getStmt());
HandleOffsetFree(C, ArgVal, ArgExpr->getSourceRange(), ParentExpr,
@@ -2060,9 +2086,8 @@ ProgramStateRef MallocChecker::FreeMemAux(
// Normal free.
if (Hold)
- return State->set<RegionState>(SymBase,
- RefState::getRelinquished(Family,
- ParentExpr));
+ return State->set<RegionState>(
+ SymBase, RefState::getRelinquished(Family, ParentExpr));
return State->set<RegionState>(SymBase,
RefState::getReleased(Family, ParentExpr));
@@ -2084,8 +2109,7 @@ MallocChecker::getCheckIfTracked(AllocationFamily Family,
if (IsALeakCheck) {
if (ChecksEnabled[CK_NewDeleteLeaksChecker])
return CK_NewDeleteLeaksChecker;
- }
- else {
+ } else {
if (ChecksEnabled[CK_NewDeleteChecker])
return CK_NewDeleteChecker;
}
@@ -2129,8 +2153,7 @@ bool MallocChecker::SummarizeValue(raw_ostream &os, SVal V) {
return true;
}
-bool MallocChecker::SummarizeRegion(raw_ostream &os,
- const MemRegion *MR) {
+bool MallocChecker::SummarizeRegion(raw_ostream &os, const MemRegion *MR) {
switch (MR->getKind()) {
case MemRegion::FunctionCodeRegionKind: {
const NamedDecl *FD = cast<FunctionCodeRegion>(MR)->getDecl();
@@ -2234,8 +2257,7 @@ void MallocChecker::HandleNonHeapDealloc(CheckerContext &C, SVal ArgVal,
os << "deallocator";
os << " is ";
- bool Summarized = MR ? SummarizeRegion(os, MR)
- : SummarizeValue(os, ArgVal);
+ bool Summarized = MR ? SummarizeRegion(os, MR) : SummarizeValue(os, ArgVal);
if (Summarized)
os << ", which is not memory allocated by ";
else
@@ -2321,10 +2343,10 @@ void MallocChecker::HandleMismatchedDealloc(CheckerContext &C,
os << " allocated by " << AllocOs.str();
os << " should be deallocated by ";
- printExpectedDeallocName(os, RS->getAllocationFamily());
+ printExpectedDeallocName(os, RS->getAllocationFamily());
- if (printMemFnName(DeallocOs, C, DeallocExpr))
- os << ", not " << DeallocOs.str();
+ if (printMemFnName(DeallocOs, C, DeallocExpr))
+ os << ", not " << DeallocOs.str();
}
auto R = std::make_unique<PathSensitiveBugReport>(*BT_MismatchedDealloc,
@@ -2367,8 +2389,7 @@ void MallocChecker::HandleOffsetFree(CheckerContext &C, SVal ArgVal,
assert(MR && "Only MemRegion based symbols can have offset free errors");
RegionOffset Offset = MR->getAsOffset();
- assert((Offset.isValid() &&
- !Offset.hasSymbolicOffset() &&
+ assert((Offset.isValid() && !Offset.hasSymbolicOffset() &&
Offset.getOffset() != 0) &&
"Only symbols with a valid offset can have offset free errors");
@@ -2377,11 +2398,8 @@ void MallocChecker::HandleOffsetFree(CheckerContext &C, SVal ArgVal,
os << "Argument to ";
if (!printMemFnName(os, C, DeallocExpr))
os << "deallocator";
- os << " is offset by "
- << offsetBytes
- << " "
- << ((abs(offsetBytes) > 1) ? "bytes" : "byte")
- << " from the start of ";
+ os << " is offset by " << offsetBytes << " "
+ << ((abs(offsetBytes) > 1) ? "bytes" : "byte") << " from the start of ";
if (AllocExpr && printMemFnName(AllocNameOs, C, AllocExpr))
os << "memory allocated by " << AllocNameOs.str();
else
@@ -2662,8 +2680,8 @@ MallocChecker::ReallocMemAux(CheckerContext &C, const CallEvent &Call,
// Record the info about the reallocated symbol so that we could properly
// process failed reallocation.
- stateRealloc = stateRealloc->set<ReallocPairs>(ToPtr,
- ReallocPair(FromPtr, Kind));
+ stateRealloc =
+ stateRealloc->set<ReallocPairs>(ToPtr, ReallocPair(FromPtr, Kind));
// The reallocated symbol should stay alive for as long as the new symbol.
C.getSymbolManager().addSymbolDependency(ToPtr, FromPtr);
return stateRealloc;
@@ -2720,8 +2738,7 @@ MallocChecker::LeakInfo MallocChecker::getAllocationSite(const ExplodedNode *N,
// Allocation node, is the last node in the current or parent context in
// which the symbol was tracked.
const LocationContext *NContext = N->getLocationContext();
- if (NContext == LeakContext ||
- NContext->isParentOf(LeakContext))
+ if (NContext == LeakContext || NContext->isParentOf(LeakContext))
AllocNode = N;
N = N->pred_empty() ? nullptr : *(N->pred_begin());
}
@@ -2771,9 +2788,8 @@ void MallocChecker::HandleLeak(SymbolRef Sym, ExplodedNode *N,
const Stmt *AllocationStmt = AllocNode->getStmtForDiagnostics();
if (AllocationStmt)
- LocUsedForUniqueing = PathDiagnosticLocation::createBegin(AllocationStmt,
- C.getSourceManager(),
- AllocNode->getLocationContext());
+ LocUsedForUniqueing = PathDiagnosticLocation::createBegin(
+ AllocationStmt, C.getSourceManager(), AllocNode->getLocationContext());
SmallString<200> buf;
llvm::raw_svector_ostream os(buf);
@@ -2795,8 +2811,7 @@ void MallocChecker::HandleLeak(SymbolRef Sym, ExplodedNode *N,
}
void MallocChecker::checkDeadSymbols(SymbolReaper &SymReaper,
- CheckerContext &C) const
-{
+ CheckerContext &C) const {
ProgramStateRef state = C.getState();
RegionStateTy OldRS = state->get<RegionState>();
RegionStateTy::Factory &F = state->get_context<RegionState>();
@@ -2814,8 +2829,7 @@ void MallocChecker::checkDeadSymbols(SymbolReaper &SymReaper,
if (RS == OldRS) {
// We shouldn't have touched other maps yet.
- assert(state->get<ReallocPairs>() ==
- C.getState()->get<ReallocPairs>());
+ assert(state->get<ReallocPairs>() == C.getState()->get<ReallocPairs>());
assert(state->get<FreeReturnValue>() ==
C.getState()->get<FreeReturnValue>());
return;
@@ -2911,8 +2925,7 @@ void MallocChecker::checkPreCall(const CallEvent &Call,
}
}
-void MallocChecker::checkPreStmt(const ReturnStmt *S,
- CheckerContext &C) const {
+void MallocChecker::checkPreStmt(const ReturnStmt *S, CheckerContext &C) const {
checkEscapeOnReturn(S, C);
}
@@ -2944,7 +2957,7 @@ void MallocChecker::checkEscapeOnReturn(const ReturnStmt *S,
if (const MemRegion *MR = RetVal.getAsRegion())
if (isa<FieldRegion, ElementRegion>(MR))
if (const SymbolicRegion *BMR =
- dyn_cast<SymbolicRegion>(MR->getBaseRegion()))
+ dyn_cast<SymbolicRegion>(MR->getBaseRegion()))
Sym = BMR->getSymbol();
// Check if we are returning freed memory.
@@ -2964,14 +2977,13 @@ void MallocChecker::checkPostStmt(const BlockExpr *BE,
return;
ProgramStateRef state = C.getState();
- const BlockDataRegion *R =
- cast<BlockDataRegion>(C.getSVal(BE).getAsRegion());
+ const BlockDataRegion *R = cast<BlockDataRegion>(C.getSVal(BE).getAsRegion());
auto ReferencedVars = R->referenced_vars();
if (ReferencedVars.empty())
return;
- SmallVector<const MemRegion*, 10> Regions;
+ SmallVector<const MemRegion *, 10> Regions;
const LocationContext *LC = C.getLocationContext();
MemRegionManager &MemMgr = C.getSValBuilder().getRegionManager();
@@ -2983,8 +2995,7 @@ void MallocChecker::checkPostStmt(const BlockExpr *BE,
Regions.push_back(VR);
}
- state =
- state->scanReachableSymbols<StopTrackingCallback>(Regions).getState();
+ state = state->scanReachableSymbols<StopTrackingCallback>(Regions).getState();
C.addTransition(state);
}
@@ -3041,8 +3052,7 @@ void MallocChecker::checkUseZeroAllocated(SymbolRef Sym, CheckerContext &C,
if (const RefState *RS = C.getState()->get<RegionState>(Sym)) {
if (RS->isAllocatedOfSizeZero())
HandleUseZeroAlloc(C, RS->getStmt()->getSourceRange(), Sym);
- }
- else if (C.getState()->contains<ReallocSizeZeroSymbols>(Sym)) {
+ } else if (C.getState()->contains<ReallocSizeZeroSymbols>(Sym)) {
HandleUseZeroAlloc(C, S->getSourceRange(), Sym);
}
}
@@ -3068,9 +3078,8 @@ void MallocChecker::checkLocation(SVal l, bool isLoad, const Stmt *S,
// If a symbolic region is assumed to NULL (or another constant), stop tracking
// it - assuming that allocation failed on this path.
-ProgramStateRef MallocChecker::evalAssume(ProgramStateRef state,
- SVal Cond,
- bool Assumption) const {
+ProgramStateRef MallocChecker::evalAssume(ProgramStateRef state, SVal Cond,
+ bool Assumption) const {
RegionStateTy RS = state->get<RegionState>();
for (SymbolRef Sym : llvm::make_first_range(RS)) {
// If the symbol is assumed to be NULL, remove it from consideration.
@@ -3095,7 +3104,8 @@ ProgramStateRef MallocChecker::evalAssume(ProgramStateRef state,
if (RS->isReleased()) {
switch (ReallocPair.Kind) {
case OAR_ToBeFreedAfterFailure:
- state = state->set<RegionState>(ReallocSym,
+ state = state->set<RegionState>(
+ ReallocSym,
RefState::getAllocated(RS->getAllocationFamily(), RS->getStmt()));
break;
case OAR_DoNotTrackAfterFailure:
@@ -3113,9 +3123,8 @@ ProgramStateRef MallocChecker::evalAssume(ProgramStateRef state,
}
bool MallocChecker::mayFreeAnyEscapedMemoryOrIsModeledExplicitly(
- const CallEvent *Call,
- ProgramStateRef State,
- SymbolRef &EscapingSymbol) const {
+ const CallEvent *Call, ProgramStateRef State,
+ SymbolRef &EscapingSymbol) const {
assert(Call);
EscapingSymbol = nullptr;
@@ -3225,8 +3234,8 @@ bool MallocChecker::mayFreeAnyEscapedMemoryOrIsModeledExplicitly(
// Do not warn on pointers passed to 'setbuf' when used with std streams,
// these leaks might be intentional when setting the buffer for stdio.
// http://stackoverflow.com/questions/2671151/who-frees-setvbuf-buffer
- if (FName == "setbuf" || FName =="setbuffer" ||
- FName == "setlinebuf" || FName == "setvbuf") {
+ if (FName == "setbuf" || FName == "setbuffer" || FName == "setlinebuf" ||
+ FName == "setvbuf") {
if (Call->getNumArgs() >= 1) {
const Expr *ArgE = Call->getArgExpr(0)->IgnoreParenCasts();
if (const DeclRefExpr *ArgDRE = dyn_cast<DeclRefExpr>(ArgE))
@@ -3276,18 +3285,16 @@ bool MallocChecker::mayFreeAnyEscapedMemoryOrIsModeledExplicitly(
return false;
}
-ProgramStateRef MallocChecker::checkPointerEscape(ProgramStateRef State,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind) const {
+ProgramStateRef MallocChecker::checkPointerEscape(
+ ProgramStateRef State, const InvalidatedSymbols &Escaped,
+ const CallEvent *Call, PointerEscapeKind Kind) const {
return checkPointerEscapeAux(State, Escaped, Call, Kind,
/*IsConstPointerEscape*/ false);
}
-ProgramStateRef MallocChecker::checkConstPointerEscape(ProgramStateRef State,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind) const {
+ProgramStateRef MallocChecker::checkConstPointerEscape(
+ ProgramStateRef State, const InvalidatedSymbols &Escaped,
+ const CallEvent *Call, PointerEscapeKind Kind) const {
// If a const pointer escapes, it may not be freed(), but it could be deleted.
return checkPointerEscapeAux(State, Escaped, Call, Kind,
/*IsConstPointerEscape*/ true);
@@ -3418,51 +3425,51 @@ PathDiagnosticPieceRef MallocBugVisitor::VisitNode(const ExplodedNode *N,
} else if (isReleased(RSCurr, RSPrev, S)) {
const auto Family = RSCurr->getAllocationFamily();
switch (Family) {
- case AF_Alloca:
- case AF_Malloc:
- case AF_CXXNew:
- case AF_CXXNewArray:
- case AF_IfNameIndex:
- Msg = "Memory is released";
+ case AF_Alloca:
+ case AF_Malloc:
+ case AF_CXXNew:
+ case AF_CXXNewArray:
+ case AF_IfNameIndex:
+ Msg = "Memory is released";
+ StackHint = std::make_unique<StackHintGeneratorForSymbol>(
+ Sym, "Returning; memory was released");
+ break;
+ case AF_InnerBuffer: {
+ const MemRegion *ObjRegion =
+ allocation_state::getContainerObjRegion(statePrev, Sym);
+ const auto *TypedRegion = cast<TypedValueRegion>(ObjRegion);
+ QualType ObjTy = TypedRegion->getValueType();
+ OS << "Inner buffer of '" << ObjTy << "' ";
+
+ if (N->getLocation().getKind() == ProgramPoint::PostImplicitCallKind) {
+ OS << "deallocated by call to destructor";
StackHint = std::make_unique<StackHintGeneratorForSymbol>(
- Sym, "Returning; memory was released");
- break;
- case AF_InnerBuffer: {
- const MemRegion *ObjRegion =
- allocation_state::getContainerObjRegion(statePrev, Sym);
- const auto *TypedRegion = cast<TypedValueRegion>(ObjRegion);
- QualType ObjTy = TypedRegion->getValueType();
- OS << "Inner buffer of '" << ObjTy << "' ";
-
- if (N->getLocation().getKind() == ProgramPoint::PostImplicitCallKind) {
- OS << "deallocated by call to destructor";
- StackHint = std::make_unique<StackHintGeneratorForSymbol>(
- Sym, "Returning; inner buffer was deallocated");
- } else {
- OS << "reallocated by call to '";
- const Stmt *S = RSCurr->getStmt();
- if (const auto *MemCallE = dyn_cast<CXXMemberCallExpr>(S)) {
- OS << MemCallE->getMethodDecl()->getDeclName();
- } else if (const auto *OpCallE = dyn_cast<CXXOperatorCallExpr>(S)) {
- OS << OpCallE->getDirectCallee()->getDeclName();
- } else if (const auto *CallE = dyn_cast<CallExpr>(S)) {
- auto &CEMgr = BRC.getStateManager().getCallEventManager();
- CallEventRef<> Call =
- CEMgr.getSimpleCall(CallE, state, CurrentLC, {nullptr, 0});
- if (const auto *D = dyn_cast_or_null<NamedDecl>(Call->getDecl()))
- OS << D->getDeclName();
- else
- OS << "unknown";
- }
- OS << "'";
- StackHint = std::make_unique<StackHintGeneratorForSymbol>(
- Sym, "Returning; inner buffer was reallocated");
+ Sym, "Returning; inner buffer was deallocated");
+ } else {
+ OS << "reallocated by call to '";
+ const Stmt *S = RSCurr->getStmt();
+ if (const auto *MemCallE = dyn_cast<CXXMemberCallExpr>(S)) {
+ OS << MemCallE->getMethodDecl()->getDeclName();
+ } else if (const auto *OpCallE = dyn_cast<CXXOperatorCallExpr>(S)) {
+ OS << OpCallE->getDirectCallee()->getDeclName();
+ } else if (const auto *CallE = dyn_cast<CallExpr>(S)) {
+ auto &CEMgr = BRC.getStateManager().getCallEventManager();
+ CallEventRef<> Call =
+ CEMgr.getSimpleCall(CallE, state, CurrentLC, {nullptr, 0});
+ if (const auto *D = dyn_cast_or_null<NamedDecl>(Call->getDecl()))
+ OS << D->getDeclName();
+ else
+ OS << "unknown";
}
- Msg = OS.str();
- break;
+ OS << "'";
+ StackHint = std::make_unique<StackHintGeneratorForSymbol>(
+ Sym, "Returning; inner buffer was reallocated");
}
- case AF_None:
- llvm_unreachable("Unhandled allocation family!");
+ Msg = OS.str();
+ break;
+ }
+ case AF_None:
+ llvm_unreachable("Unhandled allocation family!");
}
// See if we're releasing memory while inlining a destructor
@@ -3506,13 +3513,13 @@ PathDiagnosticPieceRef MallocBugVisitor::VisitNode(const ExplodedNode *N,
if (SymbolRef sym = findFailedReallocSymbol(state, statePrev)) {
// Is it possible to fail two reallocs WITHOUT testing in between?
assert((!FailedReallocSymbol || FailedReallocSymbol == sym) &&
- "We only support one failed realloc at a time.");
+ "We only support one failed realloc at a time.");
BR.markInteresting(sym);
FailedReallocSymbol = sym;
}
}
- // We are in a special mode if a reallocation failed later in the path.
+ // We are in a special mode if a reallocation failed later in the path.
} else if (Mode == ReallocationFailed) {
assert(FailedReallocSymbol && "No symbol to look for.");
@@ -3582,8 +3589,8 @@ namespace clang {
namespace ento {
namespace allocation_state {
-ProgramStateRef
-markReleased(ProgramStateRef State, SymbolRef Sym, const Expr *Origin) {
+ProgramStateRef markReleased(ProgramStateRef State, SymbolRef Sym,
+ const Expr *Origin) {
AllocationFamily Family = AF_InnerBuffer;
return State->set<RegionState>(Sym, RefState::getReleased(Family, Origin));
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp
index 3c8b38973c6b8c..fe3e6a74a468ca 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp
@@ -17,8 +17,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/EvaluatedExprVisitor.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
@@ -53,9 +53,8 @@ class MallocOverflowSecurityChecker : public Checker<check::ASTCodeBody> {
const CallExpr *TheCall, ASTContext &Context) const;
void OutputPossibleOverflows(
- SmallVectorImpl<MallocOverflowCheck> &PossibleMallocOverflows,
- const Decl *D, BugReporter &BR, AnalysisManager &mgr) const;
-
+ SmallVectorImpl<MallocOverflowCheck> &PossibleMallocOverflows,
+ const Decl *D, BugReporter &BR, AnalysisManager &mgr) const;
};
} // end anonymous namespace
@@ -74,7 +73,7 @@ void MallocOverflowSecurityChecker::CheckMallocArgument(
conditional expression, an operation that could reduce the range
of the result, or anything too complicated :-). */
const Expr *e = TheCall->getArg(0);
- const BinaryOperator * mulop = nullptr;
+ const BinaryOperator *mulop = nullptr;
APSInt maxVal;
for (;;) {
@@ -122,144 +121,136 @@ void MallocOverflowSecurityChecker::CheckMallocArgument(
namespace {
// A worker class for OutputPossibleOverflows.
-class CheckOverflowOps :
- public EvaluatedExprVisitor<CheckOverflowOps> {
+class CheckOverflowOps : public EvaluatedExprVisitor<CheckOverflowOps> {
public:
typedef SmallVectorImpl<MallocOverflowCheck> theVecType;
private:
- theVecType &toScanFor;
- ASTContext &Context;
-
- bool isIntZeroExpr(const Expr *E) const {
- if (!E->getType()->isIntegralOrEnumerationType())
- return false;
- Expr::EvalResult Result;
- if (E->EvaluateAsInt(Result, Context))
- return Result.Val.getInt() == 0;
+ theVecType &toScanFor;
+ ASTContext &Context;
+
+ bool isIntZeroExpr(const Expr *E) const {
+ if (!E->getType()->isIntegralOrEnumerationType())
return false;
- }
+ Expr::EvalResult Result;
+ if (E->EvaluateAsInt(Result, Context))
+ return Result.Val.getInt() == 0;
+ return false;
+ }
- static const Decl *getDecl(const DeclRefExpr *DR) { return DR->getDecl(); }
- static const Decl *getDecl(const MemberExpr *ME) {
- return ME->getMemberDecl();
- }
+ static const Decl *getDecl(const DeclRefExpr *DR) { return DR->getDecl(); }
+ static const Decl *getDecl(const MemberExpr *ME) {
+ return ME->getMemberDecl();
+ }
- template <typename T1>
- void Erase(const T1 *DR,
- llvm::function_ref<bool(const MallocOverflowCheck &)> Pred) {
- auto P = [DR, Pred](const MallocOverflowCheck &Check) {
- if (const auto *CheckDR = dyn_cast<T1>(Check.variable))
- return getDecl(CheckDR) == getDecl(DR) && Pred(Check);
- return false;
- };
- llvm::erase_if(toScanFor, P);
- }
+ template <typename T1>
+ void Erase(const T1 *DR,
+ llvm::function_ref<bool(const MallocOverflowCheck &)> Pred) {
+ auto P = [DR, Pred](const MallocOverflowCheck &Check) {
+ if (const auto *CheckDR = dyn_cast<T1>(Check.variable))
+ return getDecl(CheckDR) == getDecl(DR) && Pred(Check);
+ return false;
+ };
+ llvm::erase_if(toScanFor, P);
+ }
- void CheckExpr(const Expr *E_p) {
- const Expr *E = E_p->IgnoreParenImpCasts();
- const auto PrecedesMalloc = [E, this](const MallocOverflowCheck &c) {
- return Context.getSourceManager().isBeforeInTranslationUnit(
- E->getExprLoc(), c.call->getExprLoc());
- };
- if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E))
- Erase<DeclRefExpr>(DR, PrecedesMalloc);
- else if (const auto *ME = dyn_cast<MemberExpr>(E)) {
- Erase<MemberExpr>(ME, PrecedesMalloc);
- }
+ void CheckExpr(const Expr *E_p) {
+ const Expr *E = E_p->IgnoreParenImpCasts();
+ const auto PrecedesMalloc = [E, this](const MallocOverflowCheck &c) {
+ return Context.getSourceManager().isBeforeInTranslationUnit(
+ E->getExprLoc(), c.call->getExprLoc());
+ };
+ if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E))
+ Erase<DeclRefExpr>(DR, PrecedesMalloc);
+ else if (const auto *ME = dyn_cast<MemberExpr>(E)) {
+ Erase<MemberExpr>(ME, PrecedesMalloc);
}
+ }
- // Check if the argument to malloc is assigned a value
- // which cannot cause an overflow.
- // e.g., malloc (mul * x) and,
- // case 1: mul = <constant value>
- // case 2: mul = a/b, where b > x
- void CheckAssignmentExpr(BinaryOperator *AssignEx) {
- bool assignKnown = false;
- bool numeratorKnown = false, denomKnown = false;
- APSInt denomVal;
- denomVal = 0;
-
- // Erase if the multiplicand was assigned a constant value.
- const Expr *rhs = AssignEx->getRHS();
- if (rhs->isEvaluatable(Context))
- assignKnown = true;
-
- // Discard the report if the multiplicand was assigned a value,
- // that can never overflow after multiplication. e.g., the assignment
- // is a division operator and the denominator is > other multiplicand.
- const Expr *rhse = rhs->IgnoreParenImpCasts();
- if (const BinaryOperator *BOp = dyn_cast<BinaryOperator>(rhse)) {
- if (BOp->getOpcode() == BO_Div) {
- const Expr *denom = BOp->getRHS()->IgnoreParenImpCasts();
- Expr::EvalResult Result;
- if (denom->EvaluateAsInt(Result, Context)) {
- denomVal = Result.Val.getInt();
- denomKnown = true;
- }
- const Expr *numerator = BOp->getLHS()->IgnoreParenImpCasts();
- if (numerator->isEvaluatable(Context))
- numeratorKnown = true;
+ // Check if the argument to malloc is assigned a value
+ // which cannot cause an overflow.
+ // e.g., malloc (mul * x) and,
+ // case 1: mul = <constant value>
+ // case 2: mul = a/b, where b > x
+ void CheckAssignmentExpr(BinaryOperator *AssignEx) {
+ bool assignKnown = false;
+ bool numeratorKnown = false, denomKnown = false;
+ APSInt denomVal;
+ denomVal = 0;
+
+ // Erase if the multiplicand was assigned a constant value.
+ const Expr *rhs = AssignEx->getRHS();
+ if (rhs->isEvaluatable(Context))
+ assignKnown = true;
+
+ // Discard the report if the multiplicand was assigned a value,
+ // that can never overflow after multiplication. e.g., the assignment
+ // is a division operator and the denominator is > other multiplicand.
+ const Expr *rhse = rhs->IgnoreParenImpCasts();
+ if (const BinaryOperator *BOp = dyn_cast<BinaryOperator>(rhse)) {
+ if (BOp->getOpcode() == BO_Div) {
+ const Expr *denom = BOp->getRHS()->IgnoreParenImpCasts();
+ Expr::EvalResult Result;
+ if (denom->EvaluateAsInt(Result, Context)) {
+ denomVal = Result.Val.getInt();
+ denomKnown = true;
}
+ const Expr *numerator = BOp->getLHS()->IgnoreParenImpCasts();
+ if (numerator->isEvaluatable(Context))
+ numeratorKnown = true;
}
- if (!assignKnown && !denomKnown)
- return;
- auto denomExtVal = denomVal.getExtValue();
+ }
+ if (!assignKnown && !denomKnown)
+ return;
+ auto denomExtVal = denomVal.getExtValue();
- // Ignore negative denominator.
- if (denomExtVal < 0)
- return;
+ // Ignore negative denominator.
+ if (denomExtVal < 0)
+ return;
- const Expr *lhs = AssignEx->getLHS();
- const Expr *E = lhs->IgnoreParenImpCasts();
+ const Expr *lhs = AssignEx->getLHS();
+ const Expr *E = lhs->IgnoreParenImpCasts();
- auto pred = [assignKnown, numeratorKnown,
- denomExtVal](const MallocOverflowCheck &Check) {
- return assignKnown ||
- (numeratorKnown && (denomExtVal >= Check.maxVal.getExtValue()));
- };
+ auto pred = [assignKnown, numeratorKnown,
+ denomExtVal](const MallocOverflowCheck &Check) {
+ return assignKnown ||
+ (numeratorKnown && (denomExtVal >= Check.maxVal.getExtValue()));
+ };
- if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E))
- Erase<DeclRefExpr>(DR, pred);
- else if (const auto *ME = dyn_cast<MemberExpr>(E))
- Erase<MemberExpr>(ME, pred);
- }
+ if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E))
+ Erase<DeclRefExpr>(DR, pred);
+ else if (const auto *ME = dyn_cast<MemberExpr>(E))
+ Erase<MemberExpr>(ME, pred);
+ }
- public:
- void VisitBinaryOperator(BinaryOperator *E) {
- if (E->isComparisonOp()) {
- const Expr * lhs = E->getLHS();
- const Expr * rhs = E->getRHS();
- // Ignore comparisons against zero, since they generally don't
- // protect against an overflow.
- if (!isIntZeroExpr(lhs) && !isIntZeroExpr(rhs)) {
- CheckExpr(lhs);
- CheckExpr(rhs);
- }
+public:
+ void VisitBinaryOperator(BinaryOperator *E) {
+ if (E->isComparisonOp()) {
+ const Expr *lhs = E->getLHS();
+ const Expr *rhs = E->getRHS();
+ // Ignore comparisons against zero, since they generally don't
+ // protect against an overflow.
+ if (!isIntZeroExpr(lhs) && !isIntZeroExpr(rhs)) {
+ CheckExpr(lhs);
+ CheckExpr(rhs);
}
- if (E->isAssignmentOp())
- CheckAssignmentExpr(E);
- EvaluatedExprVisitor<CheckOverflowOps>::VisitBinaryOperator(E);
}
+ if (E->isAssignmentOp())
+ CheckAssignmentExpr(E);
+ EvaluatedExprVisitor<CheckOverflowOps>::VisitBinaryOperator(E);
+ }
- /* We specifically ignore loop conditions, because they're typically
- not error checks. */
- void VisitWhileStmt(WhileStmt *S) {
- return this->Visit(S->getBody());
- }
- void VisitForStmt(ForStmt *S) {
- return this->Visit(S->getBody());
- }
- void VisitDoStmt(DoStmt *S) {
- return this->Visit(S->getBody());
- }
+ /* We specifically ignore loop conditions, because they're typically
+ not error checks. */
+ void VisitWhileStmt(WhileStmt *S) { return this->Visit(S->getBody()); }
+ void VisitForStmt(ForStmt *S) { return this->Visit(S->getBody()); }
+ void VisitDoStmt(DoStmt *S) { return this->Visit(S->getBody()); }
- CheckOverflowOps(theVecType &v, ASTContext &ctx)
- : EvaluatedExprVisitor<CheckOverflowOps>(ctx),
- toScanFor(v), Context(ctx)
- { }
- };
-}
+ CheckOverflowOps(theVecType &v, ASTContext &ctx)
+ : EvaluatedExprVisitor<CheckOverflowOps>(ctx), toScanFor(v),
+ Context(ctx) {}
+};
+} // namespace
// OutputPossibleOverflows - We've found a possible overflow earlier,
// now check whether Body might contain a comparison which might be
@@ -269,8 +260,8 @@ class CheckOverflowOps :
// detect the most blatent cases of overflow and educate the
// programmer.
void MallocOverflowSecurityChecker::OutputPossibleOverflows(
- SmallVectorImpl<MallocOverflowCheck> &PossibleMallocOverflows,
- const Decl *D, BugReporter &BR, AnalysisManager &mgr) const {
+ SmallVectorImpl<MallocOverflowCheck> &PossibleMallocOverflows,
+ const Decl *D, BugReporter &BR, AnalysisManager &mgr) const {
// By far the most common case: nothing to check.
if (PossibleMallocOverflows.empty())
return;
@@ -291,8 +282,8 @@ void MallocOverflowSecurityChecker::OutputPossibleOverflows(
}
void MallocOverflowSecurityChecker::checkASTCodeBody(const Decl *D,
- AnalysisManager &mgr,
- BugReporter &BR) const {
+ AnalysisManager &mgr,
+ BugReporter &BR) const {
CFG *cfg = mgr.getCFG(D);
if (!cfg)
@@ -303,29 +294,29 @@ void MallocOverflowSecurityChecker::checkASTCodeBody(const Decl *D,
for (CFG::iterator it = cfg->begin(), ei = cfg->end(); it != ei; ++it) {
CFGBlock *block = *it;
- for (CFGBlock::iterator bi = block->begin(), be = block->end();
- bi != be; ++bi) {
- if (std::optional<CFGStmt> CS = bi->getAs<CFGStmt>()) {
- if (const CallExpr *TheCall = dyn_cast<CallExpr>(CS->getStmt())) {
- // Get the callee.
- const FunctionDecl *FD = TheCall->getDirectCallee();
-
- if (!FD)
- continue;
-
- // Get the name of the callee. If it's a builtin, strip off the
- // prefix.
- IdentifierInfo *FnInfo = FD->getIdentifier();
- if (!FnInfo)
- continue;
-
- if (FnInfo->isStr("malloc") || FnInfo->isStr("_MALLOC")) {
- if (TheCall->getNumArgs() == 1)
- CheckMallocArgument(PossibleMallocOverflows, TheCall,
- mgr.getASTContext());
- }
+ for (CFGBlock::iterator bi = block->begin(), be = block->end(); bi != be;
+ ++bi) {
+ if (std::optional<CFGStmt> CS = bi->getAs<CFGStmt>()) {
+ if (const CallExpr *TheCall = dyn_cast<CallExpr>(CS->getStmt())) {
+ // Get the callee.
+ const FunctionDecl *FD = TheCall->getDirectCallee();
+
+ if (!FD)
+ continue;
+
+ // Get the name of the callee. If it's a builtin, strip off the
+ // prefix.
+ IdentifierInfo *FnInfo = FD->getIdentifier();
+ if (!FnInfo)
+ continue;
+
+ if (FnInfo->isStr("malloc") || FnInfo->isStr("_MALLOC")) {
+ if (TheCall->getNumArgs() == 1)
+ CheckMallocArgument(PossibleMallocOverflows, TheCall,
+ mgr.getASTContext());
}
}
+ }
}
}
@@ -336,6 +327,7 @@ void ento::registerMallocOverflowSecurityChecker(CheckerManager &mgr) {
mgr.registerChecker<MallocOverflowSecurityChecker>();
}
-bool ento::shouldRegisterMallocOverflowSecurityChecker(const CheckerManager &mgr) {
+bool ento::shouldRegisterMallocOverflowSecurityChecker(
+ const CheckerManager &mgr) {
return true;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp
index 9e81a6bd19fc5b..f06ef3500c58ea 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp
@@ -32,7 +32,7 @@ typedef std::pair<const TypeSourceInfo *, const CallExpr *> TypeCallPair;
typedef llvm::PointerUnion<const Stmt *, const VarDecl *> ExprParent;
class CastedAllocFinder
- : public ConstStmtVisitor<CastedAllocFinder, TypeCallPair> {
+ : public ConstStmtVisitor<CastedAllocFinder, TypeCallPair> {
IdentifierInfo *II_malloc, *II_calloc, *II_realloc;
public:
@@ -45,23 +45,23 @@ class CastedAllocFinder
CallRecord(ExprParent CastedExprParent, const Expr *CastedExpr,
const TypeSourceInfo *ExplicitCastType,
const CallExpr *AllocCall)
- : CastedExprParent(CastedExprParent), CastedExpr(CastedExpr),
- ExplicitCastType(ExplicitCastType), AllocCall(AllocCall) {}
+ : CastedExprParent(CastedExprParent), CastedExpr(CastedExpr),
+ ExplicitCastType(ExplicitCastType), AllocCall(AllocCall) {}
};
typedef std::vector<CallRecord> CallVec;
CallVec Calls;
- CastedAllocFinder(ASTContext *Ctx) :
- II_malloc(&Ctx->Idents.get("malloc")),
- II_calloc(&Ctx->Idents.get("calloc")),
- II_realloc(&Ctx->Idents.get("realloc")) {}
+ CastedAllocFinder(ASTContext *Ctx)
+ : II_malloc(&Ctx->Idents.get("malloc")),
+ II_calloc(&Ctx->Idents.get("calloc")),
+ II_realloc(&Ctx->Idents.get("realloc")) {}
void VisitChild(ExprParent Parent, const Stmt *S) {
TypeCallPair AllocCall = Visit(S);
if (AllocCall.second && AllocCall.second != S)
- Calls.push_back(CallRecord(Parent, cast<Expr>(S), AllocCall.first,
- AllocCall.second));
+ Calls.push_back(
+ CallRecord(Parent, cast<Expr>(S), AllocCall.first, AllocCall.second));
}
void VisitChildren(const Stmt *S) {
@@ -121,9 +121,7 @@ class SizeofFinder : public ConstStmtVisitor<SizeofFinder> {
return Visit(E->getSubExpr());
}
- void VisitParenExpr(const ParenExpr *E) {
- return Visit(E->getSubExpr());
- }
+ void VisitParenExpr(const ParenExpr *E) { return Visit(E->getSubExpr()); }
void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E) {
if (E->getKind() != UETT_SizeOf)
@@ -178,7 +176,7 @@ static bool compatibleWithArrayType(ASTContext &C, QualType PT, QualType T) {
class MallocSizeofChecker : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) const {
AnalysisDeclContext *ADC = mgr.getAnalysisDeclContext(D);
CastedAllocFinder Finder(&BR.getContext());
@@ -228,8 +226,8 @@ class MallocSizeofChecker : public Checker<check::ASTCodeBody> {
else
OS << "call";
OS << " is converted to a pointer of type '" << PointeeType
- << "', which is incompatible with "
- << "sizeof operand type '" << SizeofType << "'";
+ << "', which is incompatible with " << "sizeof operand type '"
+ << SizeofType << "'";
SmallVector<SourceRange, 4> Ranges;
Ranges.push_back(CallRec.AllocCall->getCallee()->getSourceRange());
Ranges.push_back(SFinder.Sizeofs[0]->getSourceRange());
@@ -246,7 +244,7 @@ class MallocSizeofChecker : public Checker<check::ASTCodeBody> {
}
};
-}
+} // namespace
void ento::registerMallocSizeofChecker(CheckerManager &mgr) {
mgr.registerChecker<MallocSizeofChecker>();
diff --git a/clang/lib/StaticAnalyzer/Checkers/MismatchedIteratorChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MismatchedIteratorChecker.cpp
index 82a6228318179a..8dd8639ac0bd00 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MismatchedIteratorChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MismatchedIteratorChecker.cpp
@@ -18,7 +18,6 @@
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
-
#include "Iterator.h"
using namespace clang;
@@ -28,7 +27,7 @@ using namespace iterator;
namespace {
class MismatchedIteratorChecker
- : public Checker<check::PreCall, check::PreStmt<BinaryOperator>> {
+ : public Checker<check::PreCall, check::PreStmt<BinaryOperator>> {
const BugType MismatchedBugType{this, "Iterator(s) mismatched",
"Misuse of STL APIs",
@@ -44,7 +43,6 @@ class MismatchedIteratorChecker
public:
void checkPreCall(const CallEvent &Call, CheckerContext &C) const;
void checkPreStmt(const BinaryOperator *BO, CheckerContext &C) const;
-
};
} // namespace
@@ -223,8 +221,8 @@ void MismatchedIteratorChecker::verifyMatch(CheckerContext &C, SVal Iter,
if (!N) {
return;
}
- reportBug("Container accessed using foreign iterator argument.",
- Iter, Cont, C, N);
+ reportBug("Container accessed using foreign iterator argument.", Iter, Cont,
+ C, N);
}
}
@@ -262,7 +260,8 @@ void MismatchedIteratorChecker::verifyMatch(CheckerContext &C, SVal Iter1,
if (!N)
return;
reportBug("Iterators of different containers used where the "
- "same container is expected.", Iter1, Iter2, C, N);
+ "same container is expected.",
+ Iter1, Iter2, C, N);
}
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/MmapWriteExecChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MmapWriteExecChecker.cpp
index 2e31c16e457c2e..6304367c6c7f4a 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MmapWriteExecChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MmapWriteExecChecker.cpp
@@ -41,14 +41,14 @@ class MmapWriteExecChecker : public Checker<check::PreCall> {
int ProtExecOv;
int ProtReadOv;
};
-}
+} // namespace
int MmapWriteExecChecker::ProtWrite = 0x02;
-int MmapWriteExecChecker::ProtExec = 0x04;
-int MmapWriteExecChecker::ProtRead = 0x01;
+int MmapWriteExecChecker::ProtExec = 0x04;
+int MmapWriteExecChecker::ProtRead = 0x01;
void MmapWriteExecChecker::checkPreCall(const CallEvent &Call,
- CheckerContext &C) const {
+ CheckerContext &C) const {
if (matchesAny(Call, MmapFn, MprotectFn)) {
SVal ProtVal = Call.getArgSVal(2);
auto ProtLoc = ProtVal.getAs<nonloc::ConcreteInt>();
@@ -82,14 +82,11 @@ void MmapWriteExecChecker::checkPreCall(const CallEvent &Call,
}
void ento::registerMmapWriteExecChecker(CheckerManager &mgr) {
- MmapWriteExecChecker *Mwec =
- mgr.registerChecker<MmapWriteExecChecker>();
+ MmapWriteExecChecker *Mwec = mgr.registerChecker<MmapWriteExecChecker>();
Mwec->ProtExecOv =
- mgr.getAnalyzerOptions()
- .getCheckerIntegerOption(Mwec, "MmapProtExec");
+ mgr.getAnalyzerOptions().getCheckerIntegerOption(Mwec, "MmapProtExec");
Mwec->ProtReadOv =
- mgr.getAnalyzerOptions()
- .getCheckerIntegerOption(Mwec, "MmapProtRead");
+ mgr.getAnalyzerOptions().getCheckerIntegerOption(Mwec, "MmapProtRead");
}
bool ento::shouldRegisterMmapWriteExecChecker(const CheckerManager &mgr) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp
index 5240352a9bd2f9..636500c5dc4b3c 100644
--- a/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp
@@ -45,9 +45,8 @@ struct RegionState {
} // end of anonymous namespace
namespace {
-class MoveChecker
- : public Checker<check::PreCall, check::PostCall,
- check::DeadSymbols, check::RegionChanges> {
+class MoveChecker : public Checker<check::PreCall, check::PostCall,
+ check::DeadSymbols, check::RegionChanges> {
public:
void checkPreCall(const CallEvent &MC, CheckerContext &C) const;
void checkPostCall(const CallEvent &MC, CheckerContext &C) const;
@@ -58,8 +57,8 @@ class MoveChecker
ArrayRef<const MemRegion *> RequestedRegions,
ArrayRef<const MemRegion *> InvalidatedRegions,
const LocationContext *LCtx, const CallEvent *Call) const;
- void printState(raw_ostream &Out, ProgramStateRef State,
- const char *NL, const char *Sep) const override;
+ void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
+ const char *Sep) const override;
private:
enum MisuseKind { MK_FunCall, MK_Copy, MK_Move, MK_Dereference };
@@ -73,9 +72,7 @@ class MoveChecker
AK_NumKinds = AK_All
};
- static bool misuseCausesCrash(MisuseKind MK) {
- return MK == MK_Dereference;
- }
+ static bool misuseCausesCrash(MisuseKind MK) { return MK == MK_Dereference; }
struct ObjectKind {
// Is this a local variable or a local rvalue reference?
@@ -99,16 +96,9 @@ class MoveChecker
// TODO: We can still try to identify *unsafe* use after move,
// like we did with smart pointers.
const llvm::StringSet<> StdSafeClasses = {
- "basic_filebuf",
- "basic_ios",
- "future",
- "optional",
- "packaged_task",
- "promise",
- "shared_future",
- "shared_lock",
- "thread",
- "unique_lock",
+ "basic_filebuf", "basic_ios", "future", "optional",
+ "packaged_task", "promise", "shared_future", "shared_lock",
+ "thread", "unique_lock",
};
// Should we bother tracking the state of the object?
@@ -188,15 +178,15 @@ class MoveChecker
public:
void setAggressiveness(StringRef Str, CheckerManager &Mgr) {
- Aggressiveness =
- llvm::StringSwitch<AggressivenessKind>(Str)
- .Case("KnownsOnly", AK_KnownsOnly)
- .Case("KnownsAndLocals", AK_KnownsAndLocals)
- .Case("All", AK_All)
- .Default(AK_Invalid);
+ Aggressiveness = llvm::StringSwitch<AggressivenessKind>(Str)
+ .Case("KnownsOnly", AK_KnownsOnly)
+ .Case("KnownsAndLocals", AK_KnownsAndLocals)
+ .Case("All", AK_All)
+ .Default(AK_Invalid);
if (Aggressiveness == AK_Invalid)
- Mgr.reportInvalidCheckerOptionValue(this, "WarnOn",
+ Mgr.reportInvalidCheckerOptionValue(
+ this, "WarnOn",
"either \"KnownsOnly\", \"KnownsAndLocals\" or \"All\" string value");
};
@@ -300,28 +290,28 @@ MoveChecker::MovedBugVisitor::VisitNode(const ExplodedNode *N,
ObjectKind OK = Chk.classifyObject(Region, RD);
switch (OK.StdKind) {
- case SK_SmartPtr:
- if (MK == MK_Dereference) {
- OS << "Smart pointer";
- Chk.explainObject(OS, Region, RD, MK);
- OS << " is reset to null when moved from";
- break;
- }
-
- // If it's not a dereference, we don't care if it was reset to null
- // or that it is even a smart pointer.
- [[fallthrough]];
- case SK_NonStd:
- case SK_Safe:
- OS << "Object";
+ case SK_SmartPtr:
+ if (MK == MK_Dereference) {
+ OS << "Smart pointer";
Chk.explainObject(OS, Region, RD, MK);
- OS << " is moved";
- break;
- case SK_Unsafe:
- OS << "Object";
- Chk.explainObject(OS, Region, RD, MK);
- OS << " is left in a valid but unspecified state after move";
+ OS << " is reset to null when moved from";
break;
+ }
+
+ // If it's not a dereference, we don't care if it was reset to null
+ // or that it is even a smart pointer.
+ [[fallthrough]];
+ case SK_NonStd:
+ case SK_Safe:
+ OS << "Object";
+ Chk.explainObject(OS, Region, RD, MK);
+ OS << " is moved";
+ break;
+ case SK_Unsafe:
+ OS << "Object";
+ Chk.explainObject(OS, Region, RD, MK);
+ OS << " is left in a valid but unspecified state after move";
+ break;
}
// Generate the extra diagnostic.
@@ -359,8 +349,8 @@ void MoveChecker::modelUse(ProgramStateRef State, const MemRegion *Region,
if (MK == MK_Dereference && OK.StdKind != SK_SmartPtr)
MK = MK_FunCall;
- if (!RS || !shouldWarnAbout(OK, MK)
- || isInMoveSafeContext(C.getLocationContext())) {
+ if (!RS || !shouldWarnAbout(OK, MK) ||
+ isInMoveSafeContext(C.getLocationContext())) {
// Finalize changes made by the caller.
C.addTransition(State);
return;
@@ -405,25 +395,25 @@ ExplodedNode *MoveChecker::tryToReportBug(const MemRegion *Region,
// Creating the error message.
llvm::SmallString<128> Str;
llvm::raw_svector_ostream OS(Str);
- switch(MK) {
- case MK_FunCall:
- OS << "Method called on moved-from object";
- explainObject(OS, Region, RD, MK);
- break;
- case MK_Copy:
- OS << "Moved-from object";
- explainObject(OS, Region, RD, MK);
- OS << " is copied";
- break;
- case MK_Move:
- OS << "Moved-from object";
- explainObject(OS, Region, RD, MK);
- OS << " is moved";
- break;
- case MK_Dereference:
- OS << "Dereference of null smart pointer";
- explainObject(OS, Region, RD, MK);
- break;
+ switch (MK) {
+ case MK_FunCall:
+ OS << "Method called on moved-from object";
+ explainObject(OS, Region, RD, MK);
+ break;
+ case MK_Copy:
+ OS << "Moved-from object";
+ explainObject(OS, Region, RD, MK);
+ OS << " is copied";
+ break;
+ case MK_Move:
+ OS << "Moved-from object";
+ explainObject(OS, Region, RD, MK);
+ OS << " is moved";
+ break;
+ case MK_Dereference:
+ OS << "Dereference of null smart pointer";
+ explainObject(OS, Region, RD, MK);
+ break;
}
auto R = std::make_unique<PathSensitiveBugReport>(
@@ -503,15 +493,15 @@ bool MoveChecker::isMoveSafeMethod(const CXXMethodDecl *MethodDec) const {
}
// Function call `empty` can be skipped.
return (MethodDec && MethodDec->getDeclName().isIdentifier() &&
- (MethodDec->getName().lower() == "empty" ||
- MethodDec->getName().lower() == "isempty"));
+ (MethodDec->getName().lower() == "empty" ||
+ MethodDec->getName().lower() == "isempty"));
}
bool MoveChecker::isStateResetMethod(const CXXMethodDecl *MethodDec) const {
if (!MethodDec)
- return false;
+ return false;
if (MethodDec->hasAttr<ReinitializesAttr>())
- return true;
+ return true;
if (MethodDec->getDeclName().isIdentifier()) {
std::string MethodName = MethodDec->getName().lower();
// TODO: Some of these methods (eg., resize) are not always resetting
@@ -559,15 +549,15 @@ MoveChecker::classifyObject(const MemRegion *MR,
isa<StackSpaceRegion>(MR->getMemorySpace());
if (!RD || !RD->getDeclContext()->isStdNamespace())
- return { IsLocal, SK_NonStd };
+ return {IsLocal, SK_NonStd};
if (belongsTo(RD, StdSmartPtrClasses))
- return { IsLocal, SK_SmartPtr };
+ return {IsLocal, SK_SmartPtr};
if (belongsTo(RD, StdSafeClasses))
- return { IsLocal, SK_Safe };
+ return {IsLocal, SK_Safe};
- return { IsLocal, SK_Unsafe };
+ return {IsLocal, SK_Unsafe};
}
void MoveChecker::explainObject(llvm::raw_ostream &OS, const MemRegion *MR,
@@ -582,18 +572,18 @@ void MoveChecker::explainObject(llvm::raw_ostream &OS, const MemRegion *MR,
ObjectKind OK = classifyObject(MR, RD);
switch (OK.StdKind) {
- case SK_NonStd:
- case SK_Safe:
- break;
- case SK_SmartPtr:
- if (MK != MK_Dereference)
- break;
-
- // We only care about the type if it's a dereference.
- [[fallthrough]];
- case SK_Unsafe:
- OS << " of type '" << RD->getQualifiedNameAsString() << "'";
+ case SK_NonStd:
+ case SK_Safe:
+ break;
+ case SK_SmartPtr:
+ if (MK != MK_Dereference)
break;
+
+ // We only care about the type if it's a dereference.
+ [[fallthrough]];
+ case SK_Unsafe:
+ OS << " of type '" << RD->getQualifiedNameAsString() << "'";
+ break;
};
}
@@ -698,8 +688,8 @@ void MoveChecker::checkDeadSymbols(SymbolReaper &SymReaper,
ProgramStateRef MoveChecker::checkRegionChanges(
ProgramStateRef State, const InvalidatedSymbols *Invalidated,
ArrayRef<const MemRegion *> RequestedRegions,
- ArrayRef<const MemRegion *> InvalidatedRegions,
- const LocationContext *LCtx, const CallEvent *Call) const {
+ ArrayRef<const MemRegion *> InvalidatedRegions, const LocationContext *LCtx,
+ const CallEvent *Call) const {
if (Call) {
// Relax invalidation upon function calls: only invalidate parameters
// that are passed directly via non-const pointers or non-const references
@@ -735,7 +725,7 @@ void MoveChecker::printState(raw_ostream &Out, ProgramStateRef State,
if (!RS.isEmpty()) {
Out << Sep << "Moved-from objects :" << NL;
- for (auto I: RS) {
+ for (auto I : RS) {
I.first->dumpToStream(Out);
if (I.second.isMoved())
Out << ": moved";
@@ -751,6 +741,4 @@ void ento::registerMoveChecker(CheckerManager &mgr) {
mgr.getAnalyzerOptions().getCheckerStringOption(chk, "WarnOn"), mgr);
}
-bool ento::shouldRegisterMoveChecker(const CheckerManager &mgr) {
- return true;
-}
+bool ento::shouldRegisterMoveChecker(const CheckerManager &mgr) { return true; }
diff --git a/clang/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp
index 0648084a7d3999..cd66a28c587175 100644
--- a/clang/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp
@@ -14,9 +14,9 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclObjC.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
@@ -29,8 +29,7 @@ using namespace clang;
using namespace ento;
namespace {
-class NSAutoreleasePoolChecker
- : public Checker<check::PreObjCMessage> {
+class NSAutoreleasePoolChecker : public Checker<check::PreObjCMessage> {
const BugType BT{this, "Use -drain instead of -release",
"API Upgrade (Apple)"};
mutable Selector releaseS;
diff --git a/clang/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp
index 54870bcb4bb22b..f86278d6a20ed9 100644
--- a/clang/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp
@@ -14,9 +14,9 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclObjC.h"
+#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"
@@ -37,17 +37,16 @@ static bool IsCFError(QualType T, IdentifierInfo *II);
//===----------------------------------------------------------------------===//
namespace {
-class NSErrorMethodChecker
- : public Checker< check::ASTDecl<ObjCMethodDecl> > {
+class NSErrorMethodChecker : public Checker<check::ASTDecl<ObjCMethodDecl>> {
mutable IdentifierInfo *II = nullptr;
public:
NSErrorMethodChecker() = default;
- void checkASTDecl(const ObjCMethodDecl *D,
- AnalysisManager &mgr, BugReporter &BR) const;
+ void checkASTDecl(const ObjCMethodDecl *D, AnalysisManager &mgr,
+ BugReporter &BR) const;
};
-}
+} // namespace
void NSErrorMethodChecker::checkASTDecl(const ObjCMethodDecl *D,
AnalysisManager &mgr,
@@ -61,7 +60,7 @@ void NSErrorMethodChecker::checkASTDecl(const ObjCMethodDecl *D,
II = &D->getASTContext().Idents.get("NSError");
bool hasNSError = false;
- for (const auto *I : D->parameters()) {
+ for (const auto *I : D->parameters()) {
if (IsNSError(I->getType(), II)) {
hasNSError = true;
break;
@@ -69,11 +68,12 @@ void NSErrorMethodChecker::checkASTDecl(const ObjCMethodDecl *D,
}
if (hasNSError) {
- const char *err = "Method accepting NSError** "
+ const char *err =
+ "Method accepting NSError** "
"should have a non-void return value to indicate whether or not an "
"error occurred";
PathDiagnosticLocation L =
- PathDiagnosticLocation::create(D, BR.getSourceManager());
+ PathDiagnosticLocation::create(D, BR.getSourceManager());
BR.EmitBasicReport(D, this, "Bad return type when passing NSError**",
"Coding conventions (Apple)", err, L);
}
@@ -84,17 +84,16 @@ void NSErrorMethodChecker::checkASTDecl(const ObjCMethodDecl *D,
//===----------------------------------------------------------------------===//
namespace {
-class CFErrorFunctionChecker
- : public Checker< check::ASTDecl<FunctionDecl> > {
+class CFErrorFunctionChecker : public Checker<check::ASTDecl<FunctionDecl>> {
mutable IdentifierInfo *II;
public:
CFErrorFunctionChecker() : II(nullptr) {}
- void checkASTDecl(const FunctionDecl *D,
- AnalysisManager &mgr, BugReporter &BR) const;
+ void checkASTDecl(const FunctionDecl *D, AnalysisManager &mgr,
+ BugReporter &BR) const;
};
-}
+} // namespace
static bool hasReservedReturnType(const FunctionDecl *D) {
if (isa<CXXConstructorDecl>(D))
@@ -106,8 +105,8 @@ static bool hasReservedReturnType(const FunctionDecl *D) {
}
void CFErrorFunctionChecker::checkASTDecl(const FunctionDecl *D,
- AnalysisManager &mgr,
- BugReporter &BR) const {
+ AnalysisManager &mgr,
+ BugReporter &BR) const {
if (!D->doesThisDeclarationHaveABody())
return;
if (!D->getReturnType()->isVoidType())
@@ -119,7 +118,7 @@ void CFErrorFunctionChecker::checkASTDecl(const FunctionDecl *D,
II = &D->getASTContext().Idents.get("CFErrorRef");
bool hasCFError = false;
- for (auto *I : D->parameters()) {
+ for (auto *I : D->parameters()) {
if (IsCFError(I->getType(), II)) {
hasCFError = true;
break;
@@ -127,11 +126,12 @@ void CFErrorFunctionChecker::checkASTDecl(const FunctionDecl *D,
}
if (hasCFError) {
- const char *err = "Function accepting CFErrorRef* "
+ const char *err =
+ "Function accepting CFErrorRef* "
"should have a non-void return value to indicate whether or not an "
"error occurred";
PathDiagnosticLocation L =
- PathDiagnosticLocation::create(D, BR.getSourceManager());
+ PathDiagnosticLocation::create(D, BR.getSourceManager());
BR.EmitBasicReport(D, this, "Bad return type when passing CFErrorRef*",
"Coding conventions (Apple)", err, L);
}
@@ -157,15 +157,15 @@ class CFErrorDerefBug : public BugType {
"Coding conventions (Apple)") {}
};
-}
+} // namespace
namespace {
class NSOrCFErrorDerefChecker
- : public Checker< check::Location,
- check::Event<ImplicitNullDerefEvent> > {
+ : public Checker<check::Location, check::Event<ImplicitNullDerefEvent>> {
mutable IdentifierInfo *NSErrorII, *CFErrorII;
mutable std::unique_ptr<NSErrorDerefBug> NSBT;
mutable std::unique_ptr<CFErrorDerefBug> CFBT;
+
public:
bool ShouldCheckNSError = false, ShouldCheckCFError = false;
CheckerNameRef NSErrorName, CFErrorName;
@@ -175,14 +175,13 @@ class NSOrCFErrorDerefChecker
CheckerContext &C) const;
void checkEvent(ImplicitNullDerefEvent event) const;
};
-}
+} // namespace
typedef llvm::ImmutableMap<SymbolRef, unsigned> ErrorOutFlag;
REGISTER_TRAIT_WITH_PROGRAMSTATE(NSErrorOut, ErrorOutFlag)
REGISTER_TRAIT_WITH_PROGRAMSTATE(CFErrorOut, ErrorOutFlag)
-template <typename T>
-static bool hasFlag(SVal val, ProgramStateRef state) {
+template <typename T> static bool hasFlag(SVal val, ProgramStateRef state) {
if (SymbolRef sym = val.getAsSymbol())
if (const unsigned *attachedFlags = state->get<T>(sym))
return *attachedFlags;
@@ -197,12 +196,12 @@ static void setFlag(ProgramStateRef state, SVal val, CheckerContext &C) {
}
static QualType parameterTypeFromSVal(SVal val, CheckerContext &C) {
- const StackFrameContext * SFC = C.getStackFrame();
+ const StackFrameContext *SFC = C.getStackFrame();
if (std::optional<loc::MemRegionVal> X = val.getAs<loc::MemRegionVal>()) {
- const MemRegion* R = X->getRegion();
+ const MemRegion *R = X->getRegion();
if (const VarRegion *VR = R->getAs<VarRegion>())
- if (const StackArgumentsSpaceRegion *
- stackReg = dyn_cast<StackArgumentsSpaceRegion>(VR->getMemorySpace()))
+ if (const StackArgumentsSpaceRegion *stackReg =
+ dyn_cast<StackArgumentsSpaceRegion>(VR->getMemorySpace()))
if (stackReg->getStackFrame() == SFC)
return VR->getValueType();
}
@@ -268,19 +267,17 @@ void NSOrCFErrorDerefChecker::checkEvent(ImplicitNullDerefEvent event) const {
llvm::raw_svector_ostream os(Buf);
os << "Potential null dereference. According to coding standards ";
- os << (isNSError
- ? "in 'Creating and Returning NSError Objects' the parameter"
- : "documented in CoreFoundation/CFError.h the parameter");
+ os << (isNSError ? "in 'Creating and Returning NSError Objects' the parameter"
+ : "documented in CoreFoundation/CFError.h the parameter");
- os << " may be null";
+ os << " may be null";
BugType *bug = nullptr;
if (isNSError) {
if (!NSBT)
NSBT.reset(new NSErrorDerefBug(NSErrorName));
bug = NSBT.get();
- }
- else {
+ } else {
if (!CFBT)
CFBT.reset(new CFErrorDerefBug(CFErrorName));
bug = CFBT.get();
@@ -291,12 +288,12 @@ void NSOrCFErrorDerefChecker::checkEvent(ImplicitNullDerefEvent event) const {
static bool IsNSError(QualType T, IdentifierInfo *II) {
- const PointerType* PPT = T->getAs<PointerType>();
+ const PointerType *PPT = T->getAs<PointerType>();
if (!PPT)
return false;
- const ObjCObjectPointerType* PT =
- PPT->getPointeeType()->getAs<ObjCObjectPointerType>();
+ const ObjCObjectPointerType *PT =
+ PPT->getPointeeType()->getAs<ObjCObjectPointerType>();
if (!PT)
return false;
@@ -311,11 +308,13 @@ static bool IsNSError(QualType T, IdentifierInfo *II) {
}
static bool IsCFError(QualType T, IdentifierInfo *II) {
- const PointerType* PPT = T->getAs<PointerType>();
- if (!PPT) return false;
+ const PointerType *PPT = T->getAs<PointerType>();
+ if (!PPT)
+ return false;
- const TypedefType* TT = PPT->getPointeeType()->getAs<TypedefType>();
- if (!TT) return false;
+ const TypedefType *TT = PPT->getPointeeType()->getAs<TypedefType>();
+ if (!TT)
+ return false;
return TT->getDecl()->getIdentifier() == II;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/NoReturnFunctionChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/NoReturnFunctionChecker.cpp
index 17c3cb4e9e04c1..97fba082292b14 100644
--- a/clang/lib/StaticAnalyzer/Checkers/NoReturnFunctionChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/NoReturnFunctionChecker.cpp
@@ -11,9 +11,9 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/Attr.h"
#include "clang/Analysis/SelectorExtras.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/CheckerManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
@@ -26,16 +26,17 @@ using namespace ento;
namespace {
-class NoReturnFunctionChecker : public Checker< check::PostCall,
- check::PostObjCMessage > {
+class NoReturnFunctionChecker
+ : public Checker<check::PostCall, check::PostObjCMessage> {
mutable Selector HandleFailureInFunctionSel;
mutable Selector HandleFailureInMethodSel;
+
public:
void checkPostCall(const CallEvent &CE, CheckerContext &C) const;
void checkPostObjCMessage(const ObjCMethodCall &msg, CheckerContext &C) const;
};
-}
+} // namespace
void NoReturnFunctionChecker::checkPostCall(const CallEvent &CE,
CheckerContext &C) const {
@@ -55,30 +56,32 @@ void NoReturnFunctionChecker::checkPostCall(const CallEvent &CE,
// HACK: Some functions are not marked noreturn, and don't return.
// Here are a few hardwired ones. If this takes too long, we can
// potentially cache these results.
- BuildSinks
- = llvm::StringSwitch<bool>(StringRef(II->getName()))
- .Case("exit", true)
- .Case("panic", true)
- .Case("error", true)
- .Case("Assert", true)
- // FIXME: This is just a wrapper around throwing an exception.
- // Eventually inter-procedural analysis should handle this easily.
- .Case("ziperr", true)
- .Case("assfail", true)
- .Case("db_error", true)
- .Case("__assert", true)
- .Case("__assert2", true)
- // For the purpose of static analysis, we do not care that
- // this MSVC function will return if the user decides to continue.
- .Case("_wassert", true)
- .Case("__assert_rtn", true)
- .Case("__assert_fail", true)
- .Case("dtrace_assfail", true)
- .Case("yy_fatal_error", true)
- .Case("_XCAssertionFailureHandler", true)
- .Case("_DTAssertionFailureHandler", true)
- .Case("_TSAssertionFailureHandler", true)
- .Default(false);
+ BuildSinks =
+ llvm::StringSwitch<bool>(StringRef(II->getName()))
+ .Case("exit", true)
+ .Case("panic", true)
+ .Case("error", true)
+ .Case("Assert", true)
+ // FIXME: This is just a wrapper around throwing an exception.
+ // Eventually inter-procedural analysis should handle this
+ // easily.
+ .Case("ziperr", true)
+ .Case("assfail", true)
+ .Case("db_error", true)
+ .Case("__assert", true)
+ .Case("__assert2", true)
+ // For the purpose of static analysis, we do not care that
+ // this MSVC function will return if the user decides to
+ // continue.
+ .Case("_wassert", true)
+ .Case("__assert_rtn", true)
+ .Case("__assert_fail", true)
+ .Case("dtrace_assfail", true)
+ .Case("yy_fatal_error", true)
+ .Case("_XCAssertionFailureHandler", true)
+ .Case("_DTAssertionFailureHandler", true)
+ .Case("_TSAssertionFailureHandler", true)
+ .Default(false);
}
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp
index a9002ee7c9661a..707b8799345b3e 100644
--- a/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp
@@ -282,9 +282,8 @@ NonNullParamChecker::genReportNullAttrNonNull(const ExplodedNode *ErrorNode,
unsigned IdxOfArg) const {
llvm::SmallString<256> SBuf;
llvm::raw_svector_ostream OS(SBuf);
- OS << "Null pointer passed to "
- << IdxOfArg << llvm::getOrdinalSuffix(IdxOfArg)
- << " parameter expecting 'nonnull'";
+ OS << "Null pointer passed to " << IdxOfArg
+ << llvm::getOrdinalSuffix(IdxOfArg) << " parameter expecting 'nonnull'";
auto R =
std::make_unique<PathSensitiveBugReport>(BTAttrNonNull, SBuf, ErrorNode);
diff --git a/clang/lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp
index 72c6a869d2251f..cf603c6689d32a 100644
--- a/clang/lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp
@@ -68,8 +68,8 @@ void NonnullGlobalConstantsChecker::initIdentifierInfo(ASTContext &Ctx) const {
/// Add an assumption that const string-like globals are non-null.
void NonnullGlobalConstantsChecker::checkLocation(SVal location, bool isLoad,
- const Stmt *S,
- CheckerContext &C) const {
+ const Stmt *S,
+ CheckerContext &C) const {
initIdentifierInfo(C.getASTContext());
if (!isLoad || !location.isValid())
return;
@@ -140,9 +140,9 @@ bool NonnullGlobalConstantsChecker::isNonnullType(QualType Ty) const {
if (auto *T = dyn_cast<ObjCObjectPointerType>(Ty)) {
return T->getInterfaceDecl() &&
- T->getInterfaceDecl()->getIdentifier() == NSStringII;
+ T->getInterfaceDecl()->getIdentifier() == NSStringII;
} else if (auto *T = Ty->getAs<TypedefType>()) {
- IdentifierInfo* II = T->getDecl()->getIdentifier();
+ IdentifierInfo *II = T->getDecl()->getIdentifier();
return II == CFStringRefII || II == CFBooleanRefII || II == CFNullRefII;
}
return false;
@@ -152,6 +152,7 @@ void ento::registerNonnullGlobalConstantsChecker(CheckerManager &Mgr) {
Mgr.registerChecker<NonnullGlobalConstantsChecker>();
}
-bool ento::shouldRegisterNonnullGlobalConstantsChecker(const CheckerManager &mgr) {
+bool ento::shouldRegisterNonnullGlobalConstantsChecker(
+ const CheckerManager &mgr) {
return true;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp
index 06f1ad00eaf20d..5380e67f4f95c2 100644
--- a/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp
@@ -459,7 +459,7 @@ static bool checkInvariantViolation(ProgramStateRef State, ExplodedNode *N,
if (!D)
return false;
- ArrayRef<ParmVarDecl*> Params;
+ ArrayRef<ParmVarDecl *> Params;
if (const auto *BD = dyn_cast<BlockDecl>(D))
Params = BD->parameters();
else if (const auto *FD = dyn_cast<FunctionDecl>(D))
@@ -699,7 +699,7 @@ void NullabilityChecker::checkPreStmt(const ReturnStmt *S,
// function with a _Nonnull return type:
// return (NSString * _Nonnull)0;
Nullability RetExprTypeLevelNullability =
- getNullabilityAnnotation(lookThroughImplicitCasts(RetExpr)->getType());
+ getNullabilityAnnotation(lookThroughImplicitCasts(RetExpr)->getType());
bool NullReturnedFromNonNull = (RequiredNullability == Nullability::Nonnull &&
Nullness == NullConstraint::IsNull);
@@ -714,8 +714,8 @@ void NullabilityChecker::checkPreStmt(const ReturnStmt *S,
SmallString<256> SBuf;
llvm::raw_svector_ostream OS(SBuf);
OS << (RetExpr->getType()->isObjCObjectPointerType() ? "nil" : "Null");
- OS << " returned from a " << C.getDeclDescription(D) <<
- " that is expected to return a non-null value";
+ OS << " returned from a " << C.getDeclDescription(D)
+ << " that is expected to return a non-null value";
reportBugIfInvariantHolds(OS.str(), ErrorKind::NilReturnedToNonnull,
CK_NullReturnedFromNonnull, N, nullptr, C,
RetExpr);
@@ -747,8 +747,8 @@ void NullabilityChecker::checkPreStmt(const ReturnStmt *S,
SmallString<256> SBuf;
llvm::raw_svector_ostream OS(SBuf);
- OS << "Nullable pointer is returned from a " << C.getDeclDescription(D) <<
- " that is expected to return a non-null value";
+ OS << "Nullable pointer is returned from a " << C.getDeclDescription(D)
+ << " that is expected to return a non-null value";
reportBugIfInvariantHolds(OS.str(), ErrorKind::NullableReturnedToNonnull,
CK_NullableReturnedFromNonnull, N, Region, C);
@@ -756,9 +756,8 @@ void NullabilityChecker::checkPreStmt(const ReturnStmt *S,
return;
}
if (RequiredNullability == Nullability::Nullable) {
- State = State->set<NullabilityMap>(Region,
- NullabilityState(RequiredNullability,
- S));
+ State = State->set<NullabilityMap>(
+ Region, NullabilityState(RequiredNullability, S));
C.addTransition(State);
}
}
@@ -1009,9 +1008,8 @@ void NullabilityChecker::checkPostObjCMessage(const ObjCMethodCall &M,
}
// For similar reasons ignore some methods of Cocoa arrays.
StringRef FirstSelectorSlot = M.getSelector().getNameForSlot(0);
- if (Name.contains("Array") &&
- (FirstSelectorSlot == "firstObject" ||
- FirstSelectorSlot == "lastObject")) {
+ if (Name.contains("Array") && (FirstSelectorSlot == "firstObject" ||
+ FirstSelectorSlot == "lastObject")) {
State =
State->set<NullabilityMap>(ReturnRegion, Nullability::Contradicted);
C.addTransition(State);
@@ -1182,7 +1180,7 @@ void NullabilityChecker::checkPostStmt(const ExplicitCastExpr *CE,
/// For a given statement performing a bind, attempt to syntactically
/// match the expression resulting in the bound value.
-static const Expr * matchValueExprForBind(const Stmt *S) {
+static const Expr *matchValueExprForBind(const Stmt *S) {
// For `x = e` the value expression is the right-hand side.
if (auto *BinOp = dyn_cast<BinaryOperator>(S)) {
if (BinOp->getOpcode() == BO_Assign)
@@ -1190,7 +1188,7 @@ static const Expr * matchValueExprForBind(const Stmt *S) {
}
// For `int x = e` the value expression is the initializer.
- if (auto *DS = dyn_cast<DeclStmt>(S)) {
+ if (auto *DS = dyn_cast<DeclStmt>(S)) {
if (DS->isSingleDecl()) {
auto *VD = dyn_cast<VarDecl>(DS->getSingleDecl());
if (!VD)
@@ -1233,7 +1231,7 @@ static bool isARCNilInitializedLocal(CheckerContext &C, const Stmt *S) {
return false;
// Sema only zero-initializes locals with ObjCLifetimes.
- if(!VD->getType().getQualifiers().hasObjCLifetime())
+ if (!VD->getType().getQualifiers().hasObjCLifetime())
return false;
const Expr *Init = VD->getInit();
@@ -1280,8 +1278,8 @@ void NullabilityChecker::checkBind(SVal L, SVal V, const Stmt *S,
Nullability ValueExprTypeLevelNullability = Nullability::Unspecified;
const Expr *ValueExpr = matchValueExprForBind(S);
if (ValueExpr) {
- ValueExprTypeLevelNullability =
- getNullabilityAnnotation(lookThroughImplicitCasts(ValueExpr)->getType());
+ ValueExprTypeLevelNullability = getNullabilityAnnotation(
+ lookThroughImplicitCasts(ValueExpr)->getType());
}
bool NullAssignedToNonNull = (LocNullability == Nullability::Nonnull &&
@@ -1295,7 +1293,6 @@ void NullabilityChecker::checkBind(SVal L, SVal V, const Stmt *S,
if (!N)
return;
-
const Stmt *ValueStmt = S;
if (ValueExpr)
ValueStmt = ValueExpr;
diff --git a/clang/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp
index f217520d8f4a09..201e4af6caa40f 100644
--- a/clang/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp
@@ -25,13 +25,13 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
-#include "clang/Lex/Lexer.h"
#include "llvm/ADT/APSInt.h"
using namespace clang;
@@ -54,23 +54,21 @@ class Callback : public MatchFinder::MatchCallback {
AnalysisDeclContext *ADC;
public:
- Callback(const NumberObjectConversionChecker *C,
- BugReporter &BR, AnalysisDeclContext *ADC)
+ Callback(const NumberObjectConversionChecker *C, BugReporter &BR,
+ AnalysisDeclContext *ADC)
: C(C), BR(BR), ADC(ADC) {}
void run(const MatchFinder::MatchResult &Result) override;
};
} // end of anonymous namespace
void Callback::run(const MatchFinder::MatchResult &Result) {
- bool IsPedanticMatch =
- (Result.Nodes.getNodeAs<Stmt>("pedantic") != nullptr);
+ bool IsPedanticMatch = (Result.Nodes.getNodeAs<Stmt>("pedantic") != nullptr);
if (IsPedanticMatch && !C->Pedantic)
return;
ASTContext &ACtx = ADC->getASTContext();
- if (const Expr *CheckIfNull =
- Result.Nodes.getNodeAs<Expr>("check_if_null")) {
+ if (const Expr *CheckIfNull = Result.Nodes.getNodeAs<Expr>("check_if_null")) {
// Unless the macro indicates that the intended type is clearly not
// a pointer type, we should avoid warning on comparing pointers
// to zero literals in non-pedantic mode.
@@ -107,19 +105,16 @@ void Callback::run(const MatchFinder::MatchResult &Result) {
const Expr *ConvertedObjCObject = Result.Nodes.getNodeAs<Expr>("objc_object");
bool IsCpp = (ConvertedCppObject != nullptr);
bool IsObjC = (ConvertedObjCObject != nullptr);
- const Expr *Obj = IsObjC ? ConvertedObjCObject
- : IsCpp ? ConvertedCppObject
- : ConvertedCObject;
+ const Expr *Obj = IsObjC ? ConvertedObjCObject
+ : IsCpp ? ConvertedCppObject
+ : ConvertedCObject;
assert(Obj);
- bool IsComparison =
- (Result.Nodes.getNodeAs<Stmt>("comparison") != nullptr);
+ bool IsComparison = (Result.Nodes.getNodeAs<Stmt>("comparison") != nullptr);
- bool IsOSNumber =
- (Result.Nodes.getNodeAs<Decl>("osnumber") != nullptr);
+ bool IsOSNumber = (Result.Nodes.getNodeAs<Decl>("osnumber") != nullptr);
- bool IsInteger =
- (Result.Nodes.getNodeAs<QualType>("int_type") != nullptr);
+ bool IsInteger = (Result.Nodes.getNodeAs<QualType>("int_type") != nullptr);
bool IsObjCBool =
(Result.Nodes.getNodeAs<QualType>("objc_bool_type") != nullptr);
bool IsCppBool =
@@ -146,9 +141,9 @@ void Callback::run(const MatchFinder::MatchResult &Result) {
OS << "a pointer value of type '" << ObjT << "' to a ";
std::string EuphemismForPlain = "primitive";
- std::string SuggestedApi = IsObjC ? (IsInteger ? "" : "-boolValue")
- : IsCpp ? (IsOSNumber ? "" : "getValue()")
- : "CFNumberGetValue()";
+ std::string SuggestedApi = IsObjC ? (IsInteger ? "" : "-boolValue")
+ : IsCpp ? (IsOSNumber ? "" : "getValue()")
+ : "CFNumberGetValue()";
if (SuggestedApi.empty()) {
// A generic message if we're not sure what API should be called.
// FIXME: Pattern-match the integer type to make a better guess?
@@ -170,10 +165,12 @@ void Callback::run(const MatchFinder::MatchResult &Result) {
else // Branch condition?
OS << EuphemismForPlain << " boolean value";
-
if (IsPedanticMatch)
OS << "; instead, either compare the pointer to "
- << (IsObjC ? "nil" : IsCpp ? "nullptr" : "NULL") << " or ";
+ << (IsObjC ? "nil"
+ : IsCpp ? "nullptr"
+ : "NULL")
+ << " or ";
else
OS << "; did you mean to ";
@@ -203,38 +200,28 @@ void NumberObjectConversionChecker::checkASTCodeBody(const Decl *D,
.bind("c_object")));
// Currently this matches XNU kernel number-object pointers.
- auto CppSuspiciousNumberObjectExprM =
- expr(ignoringParenImpCasts(
- expr(hasType(hasCanonicalType(
- pointerType(pointee(hasCanonicalType(
- recordType(hasDeclaration(
- anyOf(
- cxxRecordDecl(hasName("OSBoolean")),
- cxxRecordDecl(hasName("OSNumber"))
- .bind("osnumber"))))))))))
+ auto CppSuspiciousNumberObjectExprM = expr(ignoringParenImpCasts(
+ expr(hasType(hasCanonicalType(pointerType(
+ pointee(hasCanonicalType(recordType(hasDeclaration(anyOf(
+ cxxRecordDecl(hasName("OSBoolean")),
+ cxxRecordDecl(hasName("OSNumber")).bind("osnumber"))))))))))
.bind("cpp_object")));
// Currently this matches NeXTSTEP number objects.
- auto ObjCSuspiciousNumberObjectExprM =
- expr(ignoringParenImpCasts(
- expr(hasType(hasCanonicalType(
- objcObjectPointerType(pointee(
- qualType(hasCanonicalType(
- qualType(hasDeclaration(
- objcInterfaceDecl(hasName("NSNumber")))))))))))
+ auto ObjCSuspiciousNumberObjectExprM = expr(ignoringParenImpCasts(
+ expr(hasType(hasCanonicalType(objcObjectPointerType(
+ pointee(qualType(hasCanonicalType(qualType(hasDeclaration(
+ objcInterfaceDecl(hasName("NSNumber")))))))))))
.bind("objc_object")));
- auto SuspiciousNumberObjectExprM = anyOf(
- CSuspiciousNumberObjectExprM,
- CppSuspiciousNumberObjectExprM,
- ObjCSuspiciousNumberObjectExprM);
+ auto SuspiciousNumberObjectExprM =
+ anyOf(CSuspiciousNumberObjectExprM, CppSuspiciousNumberObjectExprM,
+ ObjCSuspiciousNumberObjectExprM);
// Useful for predicates like "Unless we've seen the same object elsewhere".
auto AnotherSuspiciousNumberObjectExprM =
- expr(anyOf(
- equalsBoundNode("c_object"),
- equalsBoundNode("objc_object"),
- equalsBoundNode("cpp_object")));
+ expr(anyOf(equalsBoundNode("c_object"), equalsBoundNode("objc_object"),
+ equalsBoundNode("cpp_object")));
// The .bind here is in order to compose the error message more accurately.
auto ObjCSuspiciousScalarBooleanTypeM =
@@ -256,59 +243,54 @@ void NumberObjectConversionChecker::checkASTCodeBody(const Decl *D,
typedefDecl(matchesName("^::u?intptr_t$"))))))))
.bind("int_type");
- auto SuspiciousScalarTypeM =
- qualType(anyOf(SuspiciousScalarBooleanTypeM,
- SuspiciousScalarNumberTypeM));
+ auto SuspiciousScalarTypeM = qualType(
+ anyOf(SuspiciousScalarBooleanTypeM, SuspiciousScalarNumberTypeM));
auto SuspiciousScalarExprM =
expr(ignoringParenImpCasts(expr(hasType(SuspiciousScalarTypeM))));
auto ConversionThroughAssignmentM =
- binaryOperator(allOf(hasOperatorName("="),
- hasLHS(SuspiciousScalarExprM),
+ binaryOperator(allOf(hasOperatorName("="), hasLHS(SuspiciousScalarExprM),
hasRHS(SuspiciousNumberObjectExprM)));
auto ConversionThroughBranchingM =
- ifStmt(allOf(
- hasCondition(SuspiciousNumberObjectExprM),
- unless(hasConditionVariableStatement(declStmt())
- ))).bind("pedantic");
+ ifStmt(allOf(hasCondition(SuspiciousNumberObjectExprM),
+ unless(hasConditionVariableStatement(declStmt()))))
+ .bind("pedantic");
- auto ConversionThroughCallM =
- callExpr(hasAnyArgument(allOf(hasType(SuspiciousScalarTypeM),
- ignoringParenImpCasts(
- SuspiciousNumberObjectExprM))));
+ auto ConversionThroughCallM = callExpr(hasAnyArgument(
+ allOf(hasType(SuspiciousScalarTypeM),
+ ignoringParenImpCasts(SuspiciousNumberObjectExprM))));
// We bind "check_if_null" to modify the warning message
// in case it was intended to compare a pointer to 0 with a relatively-ok
// construct "x == 0" or "x != 0".
auto ConversionThroughEquivalenceM =
- binaryOperator(allOf(anyOf(hasOperatorName("=="), hasOperatorName("!=")),
- hasEitherOperand(SuspiciousNumberObjectExprM),
- hasEitherOperand(SuspiciousScalarExprM
- .bind("check_if_null"))))
- .bind("comparison");
+ binaryOperator(
+ allOf(anyOf(hasOperatorName("=="), hasOperatorName("!=")),
+ hasEitherOperand(SuspiciousNumberObjectExprM),
+ hasEitherOperand(SuspiciousScalarExprM.bind("check_if_null"))))
+ .bind("comparison");
auto ConversionThroughComparisonM =
binaryOperator(allOf(anyOf(hasOperatorName(">="), hasOperatorName(">"),
hasOperatorName("<="), hasOperatorName("<")),
hasEitherOperand(SuspiciousNumberObjectExprM),
hasEitherOperand(SuspiciousScalarExprM)))
- .bind("comparison");
+ .bind("comparison");
auto ConversionThroughConditionalOperatorM =
- conditionalOperator(allOf(
- hasCondition(SuspiciousNumberObjectExprM),
- unless(hasTrueExpression(
- hasDescendant(AnotherSuspiciousNumberObjectExprM))),
- unless(hasFalseExpression(
- hasDescendant(AnotherSuspiciousNumberObjectExprM)))))
- .bind("pedantic");
+ conditionalOperator(allOf(hasCondition(SuspiciousNumberObjectExprM),
+ unless(hasTrueExpression(hasDescendant(
+ AnotherSuspiciousNumberObjectExprM))),
+ unless(hasFalseExpression(hasDescendant(
+ AnotherSuspiciousNumberObjectExprM)))))
+ .bind("pedantic");
auto ConversionThroughExclamationMarkM =
- unaryOperator(allOf(hasOperatorName("!"),
- has(expr(SuspiciousNumberObjectExprM))))
- .bind("pedantic");
+ unaryOperator(
+ allOf(hasOperatorName("!"), has(expr(SuspiciousNumberObjectExprM))))
+ .bind("pedantic");
auto ConversionThroughExplicitBooleanCastM =
explicitCastExpr(allOf(hasType(SuspiciousScalarBooleanTypeM),
@@ -318,21 +300,20 @@ void NumberObjectConversionChecker::checkASTCodeBody(const Decl *D,
explicitCastExpr(allOf(hasType(SuspiciousScalarNumberTypeM),
has(expr(SuspiciousNumberObjectExprM))));
- auto ConversionThroughInitializerM =
- declStmt(hasSingleDecl(
- varDecl(hasType(SuspiciousScalarTypeM),
- hasInitializer(SuspiciousNumberObjectExprM))));
-
- auto FinalM = stmt(anyOf(ConversionThroughAssignmentM,
- ConversionThroughBranchingM,
- ConversionThroughCallM,
- ConversionThroughComparisonM,
- ConversionThroughConditionalOperatorM,
- ConversionThroughEquivalenceM,
- ConversionThroughExclamationMarkM,
- ConversionThroughExplicitBooleanCastM,
- ConversionThroughExplicitNumberCastM,
- ConversionThroughInitializerM)).bind("conv");
+ auto ConversionThroughInitializerM = declStmt(
+ hasSingleDecl(varDecl(hasType(SuspiciousScalarTypeM),
+ hasInitializer(SuspiciousNumberObjectExprM))));
+
+ auto FinalM =
+ stmt(anyOf(ConversionThroughAssignmentM, ConversionThroughBranchingM,
+ ConversionThroughCallM, ConversionThroughComparisonM,
+ ConversionThroughConditionalOperatorM,
+ ConversionThroughEquivalenceM,
+ ConversionThroughExclamationMarkM,
+ ConversionThroughExplicitBooleanCastM,
+ ConversionThroughExplicitNumberCastM,
+ ConversionThroughInitializerM))
+ .bind("conv");
MatchFinder F;
Callback CB(this, BR, AM.getAnalysisDeclContext(D));
@@ -348,6 +329,7 @@ void ento::registerNumberObjectConversionChecker(CheckerManager &Mgr) {
Mgr.getAnalyzerOptions().getCheckerBooleanOption(Chk, "Pedantic");
}
-bool ento::shouldRegisterNumberObjectConversionChecker(const CheckerManager &mgr) {
+bool ento::shouldRegisterNumberObjectConversionChecker(
+ const CheckerManager &mgr) {
return true;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/OSObjectCStyleCast.cpp b/clang/lib/StaticAnalyzer/Checkers/OSObjectCStyleCast.cpp
index 0a8379d9ab99d3..6efaea73afbe7a 100644
--- a/clang/lib/StaticAnalyzer/Checkers/OSObjectCStyleCast.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/OSObjectCStyleCast.cpp
@@ -11,8 +11,8 @@
// as an explicit static or dynamic cast should be used instead.
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
@@ -48,8 +48,7 @@ AST_MATCHER_P(StringLiteral, mentionsBoundType, std::string, BindingID) {
} // end namespace ast_matchers
} // end namespace clang
-static void emitDiagnostics(const BoundNodes &Nodes,
- BugReporter &BR,
+static void emitDiagnostics(const BoundNodes &Nodes, BugReporter &BR,
AnalysisDeclContext *ADC,
const OSObjectCStyleCastChecker *Checker) {
const auto *CE = Nodes.getNodeAs<CastExpr>(WarnAtNode);
@@ -63,14 +62,11 @@ static void emitDiagnostics(const BoundNodes &Nodes,
<< RD->getNameAsString() << "', or 'OSDynamicCast' followed by "
<< "a null check if unsure",
- BR.EmitBasicReport(
- ADC->getDecl(),
- Checker,
- /*Name=*/"OSObject C-Style Cast",
- categories::SecurityError,
- OS.str(),
- PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), ADC),
- CE->getSourceRange());
+ BR.EmitBasicReport(
+ ADC->getDecl(), Checker,
+ /*Name=*/"OSObject C-Style Cast", categories::SecurityError, OS.str(),
+ PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), ADC),
+ CE->getSourceRange());
}
static decltype(auto) hasTypePointingTo(DeclarationMatcher DeclM) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp
index 552c222a251a63..83b0a31dd1dd93 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp
@@ -11,8 +11,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/StmtObjC.h"
+#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"
@@ -24,7 +24,7 @@ using namespace ento;
namespace {
class ObjCAtSyncChecker
- : public Checker< check::PreStmt<ObjCAtSynchronizedStmt> > {
+ : public Checker<check::PreStmt<ObjCAtSynchronizedStmt>> {
const BugType BT_null{this, "Nil value used as mutex for @synchronized() "
"(no synchronization will occur)"};
const BugType BT_undef{this, "Uninitialized value used as mutex "
diff --git a/clang/lib/StaticAnalyzer/Checkers/ObjCAutoreleaseWriteChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ObjCAutoreleaseWriteChecker.cpp
index 514f53b4804f50..03e1068bc2119a 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ObjCAutoreleaseWriteChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ObjCAutoreleaseWriteChecker.cpp
@@ -1,4 +1,5 @@
-//===- ObjCAutoreleaseWriteChecker.cpp ----------------------------*- C++ -*-==//
+//===- ObjCAutoreleaseWriteChecker.cpp ----------------------------*- C++
+//-*-==//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -26,8 +27,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/BugReporter/CommonBugCategories.h"
@@ -49,54 +50,44 @@ const char *IsARPBind = "isautoreleasepoolbind";
class ObjCAutoreleaseWriteChecker : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &AM,
BugReporter &BR) const;
+
private:
std::vector<std::string> SelectorsWithAutoreleasingPool = {
// Common to NSArray, NSSet, NSOrderedSet
- "enumerateObjectsUsingBlock:",
- "enumerateObjectsWithOptions:usingBlock:",
+ "enumerateObjectsUsingBlock:", "enumerateObjectsWithOptions:usingBlock:",
// Common to NSArray and NSOrderedSet
"enumerateObjectsAtIndexes:options:usingBlock:",
"indexOfObjectAtIndexes:options:passingTest:",
"indexesOfObjectsAtIndexes:options:passingTest:",
- "indexOfObjectPassingTest:",
- "indexOfObjectWithOptions:passingTest:",
+ "indexOfObjectPassingTest:", "indexOfObjectWithOptions:passingTest:",
"indexesOfObjectsPassingTest:",
"indexesOfObjectsWithOptions:passingTest:",
// NSDictionary
"enumerateKeysAndObjectsUsingBlock:",
"enumerateKeysAndObjectsWithOptions:usingBlock:",
- "keysOfEntriesPassingTest:",
- "keysOfEntriesWithOptions:passingTest:",
+ "keysOfEntriesPassingTest:", "keysOfEntriesWithOptions:passingTest:",
// NSSet
- "objectsPassingTest:",
- "objectsWithOptions:passingTest:",
+ "objectsPassingTest:", "objectsWithOptions:passingTest:",
"enumerateIndexPathsWithOptions:usingBlock:",
// NSIndexSet
- "enumerateIndexesWithOptions:usingBlock:",
- "enumerateIndexesUsingBlock:",
+ "enumerateIndexesWithOptions:usingBlock:", "enumerateIndexesUsingBlock:",
"enumerateIndexesInRange:options:usingBlock:",
- "enumerateRangesUsingBlock:",
- "enumerateRangesWithOptions:usingBlock:",
- "enumerateRangesInRange:options:usingBlock:",
- "indexPassingTest:",
- "indexesPassingTest:",
- "indexWithOptions:passingTest:",
- "indexesWithOptions:passingTest:",
- "indexInRange:options:passingTest:",
- "indexesInRange:options:passingTest:"
- };
+ "enumerateRangesUsingBlock:", "enumerateRangesWithOptions:usingBlock:",
+ "enumerateRangesInRange:options:usingBlock:", "indexPassingTest:",
+ "indexesPassingTest:", "indexWithOptions:passingTest:",
+ "indexesWithOptions:passingTest:", "indexInRange:options:passingTest:",
+ "indexesInRange:options:passingTest:"};
std::vector<std::string> FunctionsWithAutoreleasingPool = {
"dispatch_async", "dispatch_group_async", "dispatch_barrier_async"};
};
-}
+} // namespace
static inline std::vector<llvm::StringRef>
toRefs(const std::vector<std::string> &V) {
@@ -168,8 +159,8 @@ static void emitDiagnostics(BoundNodes &Match, const Decl *D, BugReporter &BR,
}
void ObjCAutoreleaseWriteChecker::checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
- BugReporter &BR) const {
+ AnalysisManager &AM,
+ BugReporter &BR) const {
auto DoublePointerParamM =
parmVarDecl(hasType(hasCanonicalType(pointerType(
@@ -180,35 +171,29 @@ void ObjCAutoreleaseWriteChecker::checkASTCodeBody(const Decl *D,
declRefExpr(to(parmVarDecl(DoublePointerParamM))).bind(CapturedBind);
// Write into a binded object, e.g. *ParamBind = X.
- auto WritesIntoM = binaryOperator(
- hasLHS(unaryOperator(
- hasOperatorName("*"),
- hasUnaryOperand(
- ignoringParenImpCasts(ReferencedParamM))
- )),
- hasOperatorName("=")
- ).bind(ProblematicWriteBind);
-
- auto ArgumentCaptureM = hasAnyArgument(
- ignoringParenImpCasts(ReferencedParamM));
- auto CapturedInParamM = stmt(anyOf(
- callExpr(ArgumentCaptureM),
- objcMessageExpr(ArgumentCaptureM)));
+ auto WritesIntoM =
+ binaryOperator(hasLHS(unaryOperator(hasOperatorName("*"),
+ hasUnaryOperand(ignoringParenImpCasts(
+ ReferencedParamM)))),
+ hasOperatorName("="))
+ .bind(ProblematicWriteBind);
+
+ auto ArgumentCaptureM =
+ hasAnyArgument(ignoringParenImpCasts(ReferencedParamM));
+ auto CapturedInParamM = stmt(
+ anyOf(callExpr(ArgumentCaptureM), objcMessageExpr(ArgumentCaptureM)));
// WritesIntoM happens inside a block passed as an argument.
- auto WritesOrCapturesInBlockM = hasAnyArgument(allOf(
- hasType(hasCanonicalType(blockPointerType())),
- forEachDescendant(
- stmt(anyOf(WritesIntoM, CapturedInParamM))
- )));
-
- auto BlockPassedToMarkedFuncM = stmt(anyOf(
- callExpr(allOf(
- callsNames(FunctionsWithAutoreleasingPool), WritesOrCapturesInBlockM)),
- objcMessageExpr(allOf(
- hasAnySelector(toRefs(SelectorsWithAutoreleasingPool)),
- WritesOrCapturesInBlockM))
- ));
+ auto WritesOrCapturesInBlockM = hasAnyArgument(
+ allOf(hasType(hasCanonicalType(blockPointerType())),
+ forEachDescendant(stmt(anyOf(WritesIntoM, CapturedInParamM)))));
+
+ auto BlockPassedToMarkedFuncM =
+ stmt(anyOf(callExpr(allOf(callsNames(FunctionsWithAutoreleasingPool),
+ WritesOrCapturesInBlockM)),
+ objcMessageExpr(allOf(
+ hasAnySelector(toRefs(SelectorsWithAutoreleasingPool)),
+ WritesOrCapturesInBlockM))));
// WritesIntoM happens inside an explicit @autoreleasepool.
auto WritesOrCapturesInPoolM =
@@ -221,10 +206,10 @@ void ObjCAutoreleaseWriteChecker::checkASTCodeBody(const Decl *D,
anyOf(forEachDescendant(BlockPassedToMarkedFuncM),
forEachDescendant(WritesOrCapturesInPoolM)));
- auto MatcherM = decl(anyOf(
- objcMethodDecl(HasParamAndWritesInMarkedFuncM).bind(IsMethodBind),
- functionDecl(HasParamAndWritesInMarkedFuncM),
- blockDecl(HasParamAndWritesInMarkedFuncM)));
+ auto MatcherM = decl(
+ anyOf(objcMethodDecl(HasParamAndWritesInMarkedFuncM).bind(IsMethodBind),
+ functionDecl(HasParamAndWritesInMarkedFuncM),
+ blockDecl(HasParamAndWritesInMarkedFuncM)));
auto Matches = match(MatcherM, *D, AM.getASTContext());
for (BoundNodes Match : Matches)
diff --git a/clang/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp
index 2b008d1c775a25..c30a1c20bbc992 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp
@@ -10,10 +10,10 @@
// 'CFDictionary', 'CFSet' APIs.
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/StmtVisitor.h"
#include "clang/Analysis/AnalysisDeclContext.h"
#include "clang/Basic/TargetInfo.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
@@ -27,7 +27,7 @@ namespace {
class WalkAST : public StmtVisitor<WalkAST> {
BugReporter &BR;
const CheckerBase *Checker;
- AnalysisDeclContext* AC;
+ AnalysisDeclContext *AC;
ASTContext &ASTC;
uint64_t PtrWidth;
@@ -87,7 +87,7 @@ static StringRef getCalleeName(CallExpr *CE) {
return StringRef();
IdentifierInfo *II = FD->getIdentifier();
- if (!II) // if no identifier, not a simple C function
+ if (!II) // if no identifier, not a simple C function
return StringRef();
return II->getName();
@@ -107,7 +107,7 @@ void WalkAST::VisitCallExpr(CallExpr *CE) {
ArgNum = 1;
Arg = CE->getArg(ArgNum)->IgnoreParenCasts();
if (hasPointerToPointerSizedType(Arg))
- return;
+ return;
} else if (Name.equals("CFDictionaryCreate")) {
if (CE->getNumArgs() != 6)
return;
@@ -129,7 +129,7 @@ void WalkAST::VisitCallExpr(CallExpr *CE) {
SmallString<64> BufName;
llvm::raw_svector_ostream OsName(BufName);
- OsName << " Invalid use of '" << Name << "'" ;
+ OsName << " Invalid use of '" << Name << "'";
SmallString<256> Buf;
llvm::raw_svector_ostream Os(Buf);
@@ -159,14 +159,13 @@ void WalkAST::VisitChildren(Stmt *S) {
namespace {
class ObjCContainersASTChecker : public Checker<check::ASTCodeBody> {
public:
-
- void checkASTCodeBody(const Decl *D, AnalysisManager& Mgr,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
BugReporter &BR) const {
WalkAST walker(BR, this, Mgr.getAnalysisDeclContext(D));
walker.Visit(D->getBody());
}
};
-}
+} // namespace
void ento::registerObjCContainersASTChecker(CheckerManager &mgr) {
mgr.registerChecker<ObjCContainersASTChecker>();
diff --git a/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp
index 28e88245ca95a0..16595ade24c7f3 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp
@@ -15,8 +15,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/ParentMap.h"
+#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"
@@ -27,9 +27,9 @@ using namespace clang;
using namespace ento;
namespace {
-class ObjCContainersChecker : public Checker< check::PreStmt<CallExpr>,
- check::PostStmt<CallExpr>,
- check::PointerEscape> {
+class ObjCContainersChecker
+ : public Checker<check::PreStmt<CallExpr>, check::PostStmt<CallExpr>,
+ check::PointerEscape> {
const BugType BT{this, "CFArray API", categories::CoreFoundationObjectiveC};
inline SymbolRef getArraySym(const Expr *E, CheckerContext &C) const {
@@ -49,8 +49,8 @@ class ObjCContainersChecker : public Checker< check::PreStmt<CallExpr>,
const CallEvent *Call,
PointerEscapeKind Kind) const;
- void printState(raw_ostream &OS, ProgramStateRef State,
- const char *NL, const char *Sep) const override;
+ void printState(raw_ostream &OS, ProgramStateRef State, const char *NL,
+ const char *Sep) const override;
};
} // end anonymous namespace
@@ -148,11 +148,9 @@ void ObjCContainersChecker::checkPreStmt(const CallExpr *CE,
}
}
-ProgramStateRef
-ObjCContainersChecker::checkPointerEscape(ProgramStateRef State,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind) const {
+ProgramStateRef ObjCContainersChecker::checkPointerEscape(
+ ProgramStateRef State, const InvalidatedSymbols &Escaped,
+ const CallEvent *Call, PointerEscapeKind Kind) const {
for (const auto &Sym : Escaped) {
// When a symbol for a mutable array escapes, we can't reason precisely
// about its size any more -- so remove it from the map.
diff --git a/clang/lib/StaticAnalyzer/Checkers/ObjCMissingSuperCallChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ObjCMissingSuperCallChecker.cpp
index 598b368e74d47a..20c2aede0baf8a 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ObjCMissingSuperCallChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ObjCMissingSuperCallChecker.cpp
@@ -12,12 +12,12 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
-#include "clang/Analysis/PathDiagnostic.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprObjC.h"
#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Analysis/PathDiagnostic.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
@@ -61,13 +61,14 @@ class FindSuperCallVisitor : public RecursiveASTVisitor<FindSuperCallVisitor> {
// ObjCSuperCallChecker
//===----------------------------------------------------------------------===//
-class ObjCSuperCallChecker : public Checker<
- check::ASTDecl<ObjCImplementationDecl> > {
+class ObjCSuperCallChecker
+ : public Checker<check::ASTDecl<ObjCImplementationDecl>> {
public:
ObjCSuperCallChecker() = default;
void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager &Mgr,
BugReporter &BR) const;
+
private:
bool isCheckableClass(const ObjCImplementationDecl *D,
StringRef &SuperclassName) const;
@@ -78,7 +79,7 @@ class ObjCSuperCallChecker : public Checker<
mutable bool IsInitialized = false;
};
-}
+} // namespace
/// Determine whether the given class has a superclass that we want
/// to check. The name of the found superclass is stored in SuperclassName.
@@ -88,8 +89,7 @@ class ObjCSuperCallChecker : public Checker<
bool ObjCSuperCallChecker::isCheckableClass(const ObjCImplementationDecl *D,
StringRef &SuperclassName) const {
const ObjCInterfaceDecl *ID = D->getClassInterface()->getSuperClass();
- for ( ; ID ; ID = ID->getSuperClass())
- {
+ for (; ID; ID = ID->getSuperClass()) {
SuperclassName = ID->getIdentifier()->getName();
if (SelectorsForClass.count(SuperclassName))
return true;
@@ -118,42 +118,39 @@ void ObjCSuperCallChecker::initializeSelectors(ASTContext &Ctx) const {
{ // Initialize selectors for: UIViewController
const SelectorDescriptor Selectors[] = {
- { "addChildViewController", 1 },
- { "viewDidAppear", 1 },
- { "viewDidDisappear", 1 },
- { "viewWillAppear", 1 },
- { "viewWillDisappear", 1 },
- { "removeFromParentViewController", 0 },
- { "didReceiveMemoryWarning", 0 },
- { "viewDidUnload", 0 },
- { "viewDidLoad", 0 },
- { "viewWillUnload", 0 },
- { "updateViewConstraints", 0 },
- { "encodeRestorableStateWithCoder", 1 },
- { "restoreStateWithCoder", 1 }};
+ {"addChildViewController", 1},
+ {"viewDidAppear", 1},
+ {"viewDidDisappear", 1},
+ {"viewWillAppear", 1},
+ {"viewWillDisappear", 1},
+ {"removeFromParentViewController", 0},
+ {"didReceiveMemoryWarning", 0},
+ {"viewDidUnload", 0},
+ {"viewDidLoad", 0},
+ {"viewWillUnload", 0},
+ {"updateViewConstraints", 0},
+ {"encodeRestorableStateWithCoder", 1},
+ {"restoreStateWithCoder", 1}};
fillSelectors(Ctx, Selectors, "UIViewController");
}
{ // Initialize selectors for: UIResponder
- const SelectorDescriptor Selectors[] = {
- { "resignFirstResponder", 0 }};
+ const SelectorDescriptor Selectors[] = {{"resignFirstResponder", 0}};
fillSelectors(Ctx, Selectors, "UIResponder");
}
{ // Initialize selectors for: NSResponder
const SelectorDescriptor Selectors[] = {
- { "encodeRestorableStateWithCoder", 1 },
- { "restoreStateWithCoder", 1 }};
+ {"encodeRestorableStateWithCoder", 1}, {"restoreStateWithCoder", 1}};
fillSelectors(Ctx, Selectors, "NSResponder");
}
{ // Initialize selectors for: NSDocument
const SelectorDescriptor Selectors[] = {
- { "encodeRestorableStateWithCoder", 1 },
- { "restoreStateWithCoder", 1 }};
+ {"encodeRestorableStateWithCoder", 1}, {"restoreStateWithCoder", 1}};
fillSelectors(Ctx, Selectors, "NSDocument");
}
@@ -175,7 +172,6 @@ void ObjCSuperCallChecker::checkASTDecl(const ObjCImplementationDecl *D,
if (!isCheckableClass(D, SuperclassName))
return;
-
// Iterate over all instance methods.
for (auto *MD : D->instance_methods()) {
Selector S = MD->getSelector();
@@ -184,25 +180,23 @@ void ObjCSuperCallChecker::checkASTDecl(const ObjCImplementationDecl *D,
continue;
// Check if the method calls its superclass implementation.
- if (MD->getBody())
- {
+ if (MD->getBody()) {
FindSuperCallVisitor Visitor(S);
Visitor.TraverseDecl(MD);
// It doesn't call super, emit a diagnostic.
if (!Visitor.DoesCallSuper) {
- PathDiagnosticLocation DLoc =
- PathDiagnosticLocation::createEnd(MD->getBody(),
- BR.getSourceManager(),
- Mgr.getAnalysisDeclContext(D));
+ PathDiagnosticLocation DLoc = PathDiagnosticLocation::createEnd(
+ MD->getBody(), BR.getSourceManager(),
+ Mgr.getAnalysisDeclContext(D));
const char *Name = "Missing call to superclass";
SmallString<320> Buf;
llvm::raw_svector_ostream os(Buf);
- os << "The '" << S.getAsString()
- << "' instance method in " << SuperclassName.str() << " subclass '"
- << *D << "' is missing a [super " << S.getAsString() << "] call";
+ os << "The '" << S.getAsString() << "' instance method in "
+ << SuperclassName.str() << " subclass '" << *D
+ << "' is missing a [super " << S.getAsString() << "] call";
BR.EmitBasicReport(MD, this, Name, categories::CoreFoundationObjectiveC,
os.str(), DLoc);
@@ -211,7 +205,6 @@ void ObjCSuperCallChecker::checkASTDecl(const ObjCImplementationDecl *D,
}
}
-
//===----------------------------------------------------------------------===//
// Check registration.
//===----------------------------------------------------------------------===//
diff --git a/clang/lib/StaticAnalyzer/Checkers/ObjCPropertyChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ObjCPropertyChecker.cpp
index 08ad6877cbe6b6..f07b03ae95dae8 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ObjCPropertyChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ObjCPropertyChecker.cpp
@@ -22,8 +22,7 @@ using namespace clang;
using namespace ento;
namespace {
-class ObjCPropertyChecker
- : public Checker<check::ASTDecl<ObjCPropertyDecl>> {
+class ObjCPropertyChecker : public Checker<check::ASTDecl<ObjCPropertyDecl>> {
void checkCopyMutable(const ObjCPropertyDecl *D, BugReporter &BR) const;
public:
@@ -47,9 +46,10 @@ void ObjCPropertyChecker::checkCopyMutable(const ObjCPropertyDecl *D,
if (!T->isObjCObjectPointerType())
return;
- const std::string &PropTypeName(T->getPointeeType().getCanonicalType()
- .getUnqualifiedType()
- .getAsString());
+ const std::string &PropTypeName(T->getPointeeType()
+ .getCanonicalType()
+ .getUnqualifiedType()
+ .getAsString());
if (!StringRef(PropTypeName).starts_with("NSMutable"))
return;
diff --git a/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp
index 217c46451f80f7..9eaa3ceadc2577 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp
@@ -35,8 +35,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/ParentMap.h"
+#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"
@@ -54,13 +54,10 @@ static bool isInitMessage(const ObjCMethodCall &Msg);
static bool isSelfVar(SVal location, CheckerContext &C);
namespace {
-class ObjCSelfInitChecker : public Checker< check::PostObjCMessage,
- check::PostStmt<ObjCIvarRefExpr>,
- check::PreStmt<ReturnStmt>,
- check::PreCall,
- check::PostCall,
- check::Location,
- check::Bind > {
+class ObjCSelfInitChecker
+ : public Checker<check::PostObjCMessage, check::PostStmt<ObjCIvarRefExpr>,
+ check::PreStmt<ReturnStmt>, check::PreCall,
+ check::PostCall, check::Location, check::Bind> {
const BugType BT{this, "Missing \"self = [(super or self) init...]\"",
categories::CoreFoundationObjectiveC};
@@ -78,8 +75,8 @@ class ObjCSelfInitChecker : public Checker< check::PostObjCMessage,
void checkPreCall(const CallEvent &CE, CheckerContext &C) const;
void checkPostCall(const CallEvent &CE, CheckerContext &C) const;
- void printState(raw_ostream &Out, ProgramStateRef State,
- const char *NL, const char *Sep) const override;
+ void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
+ const char *Sep) const override;
};
} // end anonymous namespace
@@ -88,7 +85,7 @@ enum SelfFlagEnum {
/// No flag set.
SelfFlag_None = 0x0,
/// Value came from 'self'.
- SelfFlag_Self = 0x1,
+ SelfFlag_Self = 0x1,
/// Value came from the result of an initializer (e.g. [super init]).
SelfFlag_InitRes = 0x2
};
@@ -114,8 +111,8 @@ static SelfFlagEnum getSelfFlags(SVal val, CheckerContext &C) {
return getSelfFlags(val, C.getState());
}
-static void addSelfFlag(ProgramStateRef state, SVal val,
- SelfFlagEnum flag, CheckerContext &C) {
+static void addSelfFlag(ProgramStateRef state, SVal val, SelfFlagEnum flag,
+ CheckerContext &C) {
// We tag the symbol that the SVal wraps.
if (SymbolRef sym = val.getAsSymbol()) {
state = state->set<SelfFlag>(sym,
@@ -167,8 +164,8 @@ void ObjCSelfInitChecker::checkPostObjCMessage(const ObjCMethodCall &Msg,
// then it is properly initialized.
// FIXME: A callback should disable checkers at the start of functions.
- if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>(
- C.getCurrentAnalysisDeclContext()->getDecl())))
+ if (!shouldRunOnFunctionOrMethod(
+ dyn_cast<NamedDecl>(C.getCurrentAnalysisDeclContext()->getDecl())))
return;
if (isInitMessage(Msg)) {
@@ -194,8 +191,8 @@ void ObjCSelfInitChecker::checkPostObjCMessage(const ObjCMethodCall &Msg,
void ObjCSelfInitChecker::checkPostStmt(const ObjCIvarRefExpr *E,
CheckerContext &C) const {
// FIXME: A callback should disable checkers at the start of functions.
- if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>(
- C.getCurrentAnalysisDeclContext()->getDecl())))
+ if (!shouldRunOnFunctionOrMethod(
+ dyn_cast<NamedDecl>(C.getCurrentAnalysisDeclContext()->getDecl())))
return;
checkForInvalidSelf(
@@ -207,8 +204,8 @@ void ObjCSelfInitChecker::checkPostStmt(const ObjCIvarRefExpr *E,
void ObjCSelfInitChecker::checkPreStmt(const ReturnStmt *S,
CheckerContext &C) const {
// FIXME: A callback should disable checkers at the start of functions.
- if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>(
- C.getCurrentAnalysisDeclContext()->getDecl())))
+ if (!shouldRunOnFunctionOrMethod(
+ dyn_cast<NamedDecl>(C.getCurrentAnalysisDeclContext()->getDecl())))
return;
checkForInvalidSelf(S->getRetValue(), C,
@@ -235,8 +232,8 @@ void ObjCSelfInitChecker::checkPreStmt(const ReturnStmt *S,
void ObjCSelfInitChecker::checkPreCall(const CallEvent &CE,
CheckerContext &C) const {
// FIXME: A callback should disable checkers at the start of functions.
- if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>(
- C.getCurrentAnalysisDeclContext()->getDecl())))
+ if (!shouldRunOnFunctionOrMethod(
+ dyn_cast<NamedDecl>(C.getCurrentAnalysisDeclContext()->getDecl())))
return;
ProgramStateRef state = C.getState();
@@ -264,8 +261,8 @@ void ObjCSelfInitChecker::checkPreCall(const CallEvent &CE,
void ObjCSelfInitChecker::checkPostCall(const CallEvent &CE,
CheckerContext &C) const {
// FIXME: A callback should disable checkers at the start of functions.
- if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>(
- C.getCurrentAnalysisDeclContext()->getDecl())))
+ if (!shouldRunOnFunctionOrMethod(
+ dyn_cast<NamedDecl>(C.getCurrentAnalysisDeclContext()->getDecl())))
return;
ProgramStateRef state = C.getState();
@@ -299,8 +296,8 @@ void ObjCSelfInitChecker::checkPostCall(const CallEvent &CE,
void ObjCSelfInitChecker::checkLocation(SVal location, bool isLoad,
const Stmt *S,
CheckerContext &C) const {
- if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>(
- C.getCurrentAnalysisDeclContext()->getDecl())))
+ if (!shouldRunOnFunctionOrMethod(
+ dyn_cast<NamedDecl>(C.getCurrentAnalysisDeclContext()->getDecl())))
return;
// Tag the result of a load from 'self' so that we can easily know that the
@@ -311,7 +308,6 @@ void ObjCSelfInitChecker::checkLocation(SVal location, bool isLoad,
C);
}
-
void ObjCSelfInitChecker::checkBind(SVal loc, SVal val, const Stmt *S,
CheckerContext &C) const {
// Allow assignment of anything to self. Self is a local variable in the
@@ -319,10 +315,8 @@ void ObjCSelfInitChecker::checkBind(SVal loc, SVal val, const Stmt *S,
// static functions/method calls. After self is assigned something we cannot
// reason about, stop enforcing the rules.
// (Only continue checking if the assigned value should be treated as self.)
- if ((isSelfVar(loc, C)) &&
- !hasSelfFlag(val, SelfFlag_InitRes, C) &&
- !hasSelfFlag(val, SelfFlag_Self, C) &&
- !isSelfVar(val, C)) {
+ if ((isSelfVar(loc, C)) && !hasSelfFlag(val, SelfFlag_InitRes, C) &&
+ !hasSelfFlag(val, SelfFlag_Self, C) && !isSelfVar(val, C)) {
// Stop tracking the checker-specific state in the state.
ProgramStateRef State = C.getState();
@@ -378,7 +372,6 @@ void ObjCSelfInitChecker::printState(raw_ostream &Out, ProgramStateRef State,
}
}
-
// FIXME: A callback should disable checkers at the start of functions.
static bool shouldRunOnFunctionOrMethod(const NamedDecl *ND) {
if (!ND)
@@ -393,9 +386,9 @@ static bool shouldRunOnFunctionOrMethod(const NamedDecl *ND) {
// self = [super init] applies only to NSObject subclasses.
// For instance, NSProxy doesn't implement -init.
ASTContext &Ctx = MD->getASTContext();
- IdentifierInfo* NSObjectII = &Ctx.Idents.get("NSObject");
+ IdentifierInfo *NSObjectII = &Ctx.Idents.get("NSObject");
ObjCInterfaceDecl *ID = MD->getClassInterface()->getSuperClass();
- for ( ; ID ; ID = ID->getSuperClass()) {
+ for (; ID; ID = ID->getSuperClass()) {
IdentifierInfo *II = ID->getIdentifier();
if (II == NSObjectII)
diff --git a/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp
index eb40711812e16b..24e03d43fefc1e 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp
@@ -48,7 +48,6 @@ class ObjCSuperDeallocChecker
CheckerContext &C) const;
private:
-
void diagnoseCallArguments(const CallEvent &CE, CheckerContext &C) const;
void reportUseAfterDealloc(SymbolRef Sym, StringRef Desc, const Stmt *S,
@@ -129,7 +128,7 @@ void ObjCSuperDeallocChecker::checkPostObjCMessage(const ObjCMethodCall &M,
}
void ObjCSuperDeallocChecker::checkLocation(SVal L, bool IsLoad, const Stmt *S,
- CheckerContext &C) const {
+ CheckerContext &C) const {
SymbolRef BaseSym = L.getLocSymbolInBase();
if (!BaseSym)
return;
@@ -162,8 +161,8 @@ void ObjCSuperDeallocChecker::checkLocation(SVal L, bool IsLoad, const Stmt *S,
std::string Buf;
llvm::raw_string_ostream OS(Buf);
if (IvarRegion) {
- OS << "Use of instance variable '" << *IvarRegion->getDecl() <<
- "' after 'self' has been deallocated";
+ OS << "Use of instance variable '" << *IvarRegion->getDecl()
+ << "' after 'self' has been deallocated";
Desc = OS.str();
}
@@ -214,8 +213,8 @@ void ObjCSuperDeallocChecker::diagnoseCallArguments(const CallEvent &CE,
}
}
-void
-ObjCSuperDeallocChecker::initIdentifierInfoAndSelectors(ASTContext &Ctx) const {
+void ObjCSuperDeallocChecker::initIdentifierInfoAndSelectors(
+ ASTContext &Ctx) const {
if (IIdealloc)
return;
@@ -225,8 +224,8 @@ ObjCSuperDeallocChecker::initIdentifierInfoAndSelectors(ASTContext &Ctx) const {
SELdealloc = Ctx.Selectors.getSelector(0, &IIdealloc);
}
-bool
-ObjCSuperDeallocChecker::isSuperDeallocMessage(const ObjCMethodCall &M) const {
+bool ObjCSuperDeallocChecker::isSuperDeallocMessage(
+ const ObjCMethodCall &M) const {
if (M.getOriginExpr()->getReceiverKind() != ObjCMessageExpr::SuperInstance)
return false;
diff --git a/clang/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp
index 2f2df63468b4b1..ac86b09e8e6be1 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp
@@ -28,9 +28,9 @@ using namespace clang;
using namespace ento;
enum IVarState { Unused, Used };
-typedef llvm::DenseMap<const ObjCIvarDecl*,IVarState> IvarUsageMap;
+typedef llvm::DenseMap<const ObjCIvarDecl *, IVarState> IvarUsageMap;
-static void Scan(IvarUsageMap& M, const Stmt *S) {
+static void Scan(IvarUsageMap &M, const Stmt *S) {
if (!S)
return;
@@ -59,7 +59,7 @@ static void Scan(IvarUsageMap& M, const Stmt *S) {
Scan(M, SubStmt);
}
-static void Scan(IvarUsageMap& M, const ObjCPropertyImplDecl *D) {
+static void Scan(IvarUsageMap &M, const ObjCPropertyImplDecl *D) {
if (!D)
return;
@@ -73,7 +73,7 @@ static void Scan(IvarUsageMap& M, const ObjCPropertyImplDecl *D) {
I->second = Used;
}
-static void Scan(IvarUsageMap& M, const ObjCContainerDecl *D) {
+static void Scan(IvarUsageMap &M, const ObjCContainerDecl *D) {
// Scan the methods for accesses.
for (const auto *I : D->instance_methods())
Scan(M, I->getBody());
@@ -103,8 +103,7 @@ static void Scan(IvarUsageMap &M, const DeclContext *C, const FileID FID,
}
static void checkObjCUnusedIvar(const ObjCImplementationDecl *D,
- BugReporter &BR,
- const CheckerBase *Checker) {
+ BugReporter &BR, const CheckerBase *Checker) {
const ObjCInterfaceDecl *ID = D->getClassInterface();
IvarUsageMap M;
@@ -118,8 +117,7 @@ static void checkObjCUnusedIvar(const ObjCImplementationDecl *D,
// (d) are unnamed bitfields
if (Ivar->getAccessControl() != ObjCIvarDecl::Private ||
Ivar->hasAttr<UnusedAttr>() || Ivar->hasAttr<IBOutletAttr>() ||
- Ivar->hasAttr<IBOutletCollectionAttr>() ||
- Ivar->isUnnamedBitfield())
+ Ivar->hasAttr<IBOutletCollectionAttr>() || Ivar->isUnnamedBitfield())
continue;
M[Ivar] = Unused;
@@ -171,15 +169,15 @@ static void checkObjCUnusedIvar(const ObjCImplementationDecl *D,
//===----------------------------------------------------------------------===//
namespace {
-class ObjCUnusedIvarsChecker : public Checker<
- check::ASTDecl<ObjCImplementationDecl> > {
+class ObjCUnusedIvarsChecker
+ : public Checker<check::ASTDecl<ObjCImplementationDecl>> {
public:
- void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager& mgr,
+ void checkASTDecl(const ObjCImplementationDecl *D, AnalysisManager &mgr,
BugReporter &BR) const {
checkObjCUnusedIvar(D, BR, this);
}
};
-}
+} // namespace
void ento::registerObjCUnusedIvarsChecker(CheckerManager &mgr) {
mgr.registerChecker<ObjCUnusedIvarsChecker>();
diff --git a/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp
index eee9449f31805c..9f936d99d41a92 100644
--- a/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp
@@ -11,12 +11,12 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/CharUnits.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/RecordLayout.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
@@ -347,11 +347,11 @@ class PaddingChecker : public Checker<check::ASTDecl<TranslationUnitDecl>> {
void ento::registerPaddingChecker(CheckerManager &Mgr) {
auto *Checker = Mgr.registerChecker<PaddingChecker>();
- Checker->AllowedPad = Mgr.getAnalyzerOptions()
- .getCheckerIntegerOption(Checker, "AllowedPad");
+ Checker->AllowedPad =
+ Mgr.getAnalyzerOptions().getCheckerIntegerOption(Checker, "AllowedPad");
if (Checker->AllowedPad < 0)
- Mgr.reportInvalidCheckerOptionValue(
- Checker, "AllowedPad", "a non-negative value");
+ Mgr.reportInvalidCheckerOptionValue(Checker, "AllowedPad",
+ "a non-negative value");
}
bool ento::shouldRegisterPaddingChecker(const CheckerManager &mgr) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/PointerIterationChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/PointerIterationChecker.cpp
index 8aca6d009cdb02..4c65fde1c2867d 100644
--- a/clang/lib/StaticAnalyzer/Checkers/PointerIterationChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/PointerIterationChecker.cpp
@@ -27,8 +27,7 @@ constexpr llvm::StringLiteral WarnAtNode = "iter";
class PointerIterationChecker : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &AM,
BugReporter &BR) const;
};
@@ -41,9 +40,8 @@ static void emitDiagnostics(const BoundNodes &Match, const Decl *D,
assert(MarkedStmt);
auto Range = MarkedStmt->getSourceRange();
- auto Location = PathDiagnosticLocation::createBegin(MarkedStmt,
- BR.getSourceManager(),
- ADC);
+ auto Location = PathDiagnosticLocation::createBegin(
+ MarkedStmt, BR.getSourceManager(), ADC);
std::string Diagnostics;
llvm::raw_string_ostream OS(Diagnostics);
OS << "Iteration of pointer-like elements "
@@ -65,23 +63,21 @@ static void emitDiagnostics(const BoundNodes &Match, const Decl *D,
auto matchUnorderedIterWithPointers() -> decltype(decl()) {
- auto UnorderedContainerM = declRefExpr(to(varDecl(hasType(
- recordDecl(hasName("std::unordered_set")
- )))));
+ auto UnorderedContainerM = declRefExpr(
+ to(varDecl(hasType(recordDecl(hasName("std::unordered_set"))))));
auto PointerTypeM = varDecl(hasType(hasCanonicalType(pointerType())));
- auto PointerIterM = stmt(cxxForRangeStmt(
- hasLoopVariable(PointerTypeM),
- hasRangeInit(UnorderedContainerM)
- )).bind(WarnAtNode);
+ auto PointerIterM = stmt(cxxForRangeStmt(hasLoopVariable(PointerTypeM),
+ hasRangeInit(UnorderedContainerM)))
+ .bind(WarnAtNode);
return decl(forEachDescendant(PointerIterM));
}
void PointerIterationChecker::checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
- BugReporter &BR) const {
+ AnalysisManager &AM,
+ BugReporter &BR) const {
auto MatcherM = matchUnorderedIterWithPointers();
auto Matches = match(MatcherM, *D, AM.getASTContext());
diff --git a/clang/lib/StaticAnalyzer/Checkers/PointerSortingChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/PointerSortingChecker.cpp
index 25d87f4acfc910..3092baf3765e9f 100644
--- a/clang/lib/StaticAnalyzer/Checkers/PointerSortingChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/PointerSortingChecker.cpp
@@ -27,8 +27,7 @@ constexpr llvm::StringLiteral WarnAtNode = "sort";
class PointerSortingChecker : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &AM,
BugReporter &BR) const;
};
@@ -41,9 +40,8 @@ static void emitDiagnostics(const BoundNodes &Match, const Decl *D,
assert(MarkedStmt);
auto Range = MarkedStmt->getSourceRange();
- auto Location = PathDiagnosticLocation::createBegin(MarkedStmt,
- BR.getSourceManager(),
- ADC);
+ auto Location = PathDiagnosticLocation::createBegin(
+ MarkedStmt, BR.getSourceManager(), ADC);
std::string Diagnostics;
llvm::raw_string_ostream OS(Diagnostics);
OS << "Sorting pointer-like elements "
@@ -68,23 +66,16 @@ decltype(auto) callsName(const char *FunctionName) {
// sort-unique-erase and the sort call will emit a report.
auto matchSortWithPointers() -> decltype(decl()) {
// Match any of these function calls.
- auto SortFuncM = anyOf(
- callsName("std::is_sorted"),
- callsName("std::nth_element"),
- callsName("std::partial_sort"),
- callsName("std::partition"),
- callsName("std::sort"),
- callsName("std::stable_partition"),
- callsName("std::stable_sort")
- );
+ auto SortFuncM =
+ anyOf(callsName("std::is_sorted"), callsName("std::nth_element"),
+ callsName("std::partial_sort"), callsName("std::partition"),
+ callsName("std::sort"), callsName("std::stable_partition"),
+ callsName("std::stable_sort"));
// Match only if the container has pointer-type elements.
- auto IteratesPointerEltsM = hasArgument(0,
- hasType(cxxRecordDecl(has(
- fieldDecl(hasType(hasCanonicalType(
- pointsTo(hasCanonicalType(pointerType()))
- )))
- ))));
+ auto IteratesPointerEltsM = hasArgument(
+ 0, hasType(cxxRecordDecl(has(fieldDecl(hasType(
+ hasCanonicalType(pointsTo(hasCanonicalType(pointerType())))))))));
auto PointerSortM = traverse(
TK_AsIs,
@@ -93,8 +84,7 @@ auto matchSortWithPointers() -> decltype(decl()) {
return decl(forEachDescendant(PointerSortM));
}
-void PointerSortingChecker::checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
+void PointerSortingChecker::checkASTCodeBody(const Decl *D, AnalysisManager &AM,
BugReporter &BR) const {
auto MatcherM = matchSortWithPointers();
diff --git a/clang/lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp
index 2438cf30b39b59..26983362b8d421 100644
--- a/clang/lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp
@@ -23,14 +23,13 @@ using namespace clang;
using namespace ento;
namespace {
-class PointerSubChecker
- : public Checker< check::PreStmt<BinaryOperator> > {
+class PointerSubChecker : public Checker<check::PreStmt<BinaryOperator>> {
const BugType BT{this, "Pointer subtraction"};
public:
void checkPreStmt(const BinaryOperator *B, CheckerContext &C) const;
};
-}
+} // namespace
void PointerSubChecker::checkPreStmt(const BinaryOperator *B,
CheckerContext &C) const {
diff --git a/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp
index fa8572cf85edfe..2a324d7f403504 100644
--- a/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp
@@ -701,7 +701,9 @@ void ento::registerPthreadLockBase(CheckerManager &mgr) {
mgr.registerChecker<PthreadLockChecker>();
}
-bool ento::shouldRegisterPthreadLockBase(const CheckerManager &mgr) { return true; }
+bool ento::shouldRegisterPthreadLockBase(const CheckerManager &mgr) {
+ return true;
+}
#define REGISTER_CHECKER(name) \
void ento::register##name(CheckerManager &mgr) { \
diff --git a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp
index 7e74b418b33536..151aa1f978de14 100644
--- a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp
@@ -49,66 +49,71 @@ void RefVal::print(raw_ostream &Out) const {
Out << "Tracked " << T << " | ";
switch (getKind()) {
- default: llvm_unreachable("Invalid RefVal kind");
- case Owned: {
- Out << "Owned";
- unsigned cnt = getCount();
- if (cnt) Out << " (+ " << cnt << ")";
- break;
- }
+ default:
+ llvm_unreachable("Invalid RefVal kind");
+ case Owned: {
+ Out << "Owned";
+ unsigned cnt = getCount();
+ if (cnt)
+ Out << " (+ " << cnt << ")";
+ break;
+ }
- case NotOwned: {
- Out << "NotOwned";
- unsigned cnt = getCount();
- if (cnt) Out << " (+ " << cnt << ")";
- break;
- }
+ case NotOwned: {
+ Out << "NotOwned";
+ unsigned cnt = getCount();
+ if (cnt)
+ Out << " (+ " << cnt << ")";
+ break;
+ }
- case ReturnedOwned: {
- Out << "ReturnedOwned";
- unsigned cnt = getCount();
- if (cnt) Out << " (+ " << cnt << ")";
- break;
- }
+ case ReturnedOwned: {
+ Out << "ReturnedOwned";
+ unsigned cnt = getCount();
+ if (cnt)
+ Out << " (+ " << cnt << ")";
+ break;
+ }
- case ReturnedNotOwned: {
- Out << "ReturnedNotOwned";
- unsigned cnt = getCount();
- if (cnt) Out << " (+ " << cnt << ")";
- break;
- }
+ case ReturnedNotOwned: {
+ Out << "ReturnedNotOwned";
+ unsigned cnt = getCount();
+ if (cnt)
+ Out << " (+ " << cnt << ")";
+ break;
+ }
- case Released:
- Out << "Released";
- break;
+ case Released:
+ Out << "Released";
+ break;
- case ErrorDeallocNotOwned:
- Out << "-dealloc (not-owned)";
- break;
+ case ErrorDeallocNotOwned:
+ Out << "-dealloc (not-owned)";
+ break;
- case ErrorLeak:
- Out << "Leaked";
- break;
+ case ErrorLeak:
+ Out << "Leaked";
+ break;
- case ErrorLeakReturned:
- Out << "Leaked (Bad naming)";
- break;
+ case ErrorLeakReturned:
+ Out << "Leaked (Bad naming)";
+ break;
- case ErrorUseAfterRelease:
- Out << "Use-After-Release [ERROR]";
- break;
+ case ErrorUseAfterRelease:
+ Out << "Use-After-Release [ERROR]";
+ break;
- case ErrorReleaseNotOwned:
- Out << "Release of Not-Owned [ERROR]";
- break;
+ case ErrorReleaseNotOwned:
+ Out << "Release of Not-Owned [ERROR]";
+ break;
- case RefVal::ErrorOverAutorelease:
- Out << "Over-autoreleased";
- break;
+ case RefVal::ErrorOverAutorelease:
+ Out << "Over-autoreleased";
+ break;
- case RefVal::ErrorReturnedNotOwned:
- Out << "Non-owned object returned instead of owned";
- break;
+ case RefVal::ErrorReturnedNotOwned:
+ Out << "Non-owned object returned instead of owned";
+ break;
}
switch (getIvarAccessHistory()) {
@@ -129,6 +134,7 @@ void RefVal::print(raw_ostream &Out) const {
namespace {
class StopTrackingCallback final : public SymbolVisitor {
ProgramStateRef state;
+
public:
StopTrackingCallback(ProgramStateRef st) : state(std::move(st)) {}
ProgramStateRef getState() const { return state; }
@@ -162,7 +168,7 @@ void RetainCountChecker::checkPostStmt(const BlockExpr *BE,
// FIXME: For now we invalidate the tracking of all symbols passed to blocks
// via captured variables, even though captured variables result in a copy
// and in implicit increment/decrement of a retain count.
- SmallVector<const MemRegion*, 10> Regions;
+ SmallVector<const MemRegion *, 10> Regions;
const LocationContext *LC = C.getLocationContext();
MemRegionManager &MemMgr = C.getSValBuilder().getRegionManager();
@@ -195,26 +201,26 @@ void RetainCountChecker::checkPostStmt(const CastExpr *CE,
ArgEffect AE = ArgEffect(IncRef, K);
switch (BE->getBridgeKind()) {
- case OBC_Bridge:
- // Do nothing.
- return;
- case OBC_BridgeRetained:
- AE = AE.withKind(IncRef);
- break;
- case OBC_BridgeTransfer:
- AE = AE.withKind(DecRefBridgedTransferred);
- break;
+ case OBC_Bridge:
+ // Do nothing.
+ return;
+ case OBC_BridgeRetained:
+ AE = AE.withKind(IncRef);
+ break;
+ case OBC_BridgeTransfer:
+ AE = AE.withKind(DecRefBridgedTransferred);
+ break;
}
ProgramStateRef state = C.getState();
SymbolRef Sym = C.getSVal(CE).getAsLocSymbol();
if (!Sym)
return;
- const RefVal* T = getRefBinding(state, Sym);
+ const RefVal *T = getRefBinding(state, Sym);
if (!T)
return;
- RefVal::Kind hasErr = (RefVal::Kind) 0;
+ RefVal::Kind hasErr = (RefVal::Kind)0;
state = updateSymbol(state, Sym, *T, AE, hasErr, C);
if (hasErr) {
@@ -232,8 +238,8 @@ void RetainCountChecker::processObjCLiterals(CheckerContext &C,
for (const Stmt *Child : Ex->children()) {
SVal V = pred->getSVal(Child);
if (SymbolRef sym = V.getAsSymbol())
- if (const RefVal* T = getRefBinding(state, sym)) {
- RefVal::Kind hasErr = (RefVal::Kind) 0;
+ if (const RefVal *T = getRefBinding(state, sym)) {
+ RefVal::Kind hasErr = (RefVal::Kind)0;
state = updateSymbol(state, sym, *T,
ArgEffect(MayEscape, ObjKind::ObjC), hasErr, C);
if (hasErr) {
@@ -246,7 +252,7 @@ void RetainCountChecker::processObjCLiterals(CheckerContext &C,
// Return the object as autoreleased.
// RetEffect RE = RetEffect::MakeNotOwned(ObjKind::ObjC);
if (SymbolRef sym =
- state->getSVal(Ex, pred->getLocationContext()).getAsSymbol()) {
+ state->getSVal(Ex, pred->getLocationContext()).getAsSymbol()) {
QualType ResultTy = Ex->getType();
state = setRefBinding(state, sym,
RefVal::makeNotOwned(ObjKind::ObjC, ResultTy));
@@ -352,9 +358,8 @@ const static RetainSummary *getSummary(RetainSummaryManager &Summaries,
const CallEvent &Call,
QualType ReceiverType) {
const Expr *CE = Call.getOriginExpr();
- AnyCall C =
- CE ? *AnyCall::forExpr(CE)
- : AnyCall(cast<CXXDestructorDecl>(Call.getDecl()));
+ AnyCall C = CE ? *AnyCall::forExpr(CE)
+ : AnyCall(cast<CXXDestructorDecl>(Call.getDecl()));
return Summaries.getSummary(C, Call.hasNonZeroCallbackArg(),
isReceiverUnconsumedSelf(Call), ReceiverType);
}
@@ -404,8 +409,8 @@ static QualType GetReturnType(const Expr *RetE, ASTContext &Ctx) {
// is a call to a class method whose type we can resolve. In such
// cases, promote the return type to XXX* (where XXX is the class).
const ObjCInterfaceDecl *D = ME->getReceiverInterface();
- return !D ? RetTy :
- Ctx.getObjCObjectPointerType(Ctx.getObjCInterfaceType(D));
+ return !D ? RetTy
+ : Ctx.getObjCObjectPointerType(Ctx.getObjCInterfaceType(D));
}
return RetTy;
@@ -433,7 +438,7 @@ static bool isPointerToObject(QualType QT) {
/// Whether the tracked value should be escaped on a given call.
/// OSObjects are escaped when passed to void * / etc.
static bool shouldEscapeOSArgumentOnCall(const CallEvent &CE, unsigned ArgIdx,
- const RefVal *TrackedValue) {
+ const RefVal *TrackedValue) {
if (TrackedValue->getObjKind() != ObjKind::OS)
return false;
if (ArgIdx >= CE.parameters().size())
@@ -485,12 +490,11 @@ void RetainCountChecker::processSummaryOfInlined(const RetainSummary &Summ,
}
static bool isSmartPtrField(const MemRegion *MR) {
- const auto *TR = dyn_cast<TypedValueRegion>(
- cast<SubRegion>(MR)->getSuperRegion());
+ const auto *TR =
+ dyn_cast<TypedValueRegion>(cast<SubRegion>(MR)->getSuperRegion());
return TR && RetainSummaryManager::isKnownSmartPointer(TR->getValueType());
}
-
/// A value escapes in these possible cases:
///
/// - binding to something that is not a memory region.
@@ -607,7 +611,7 @@ void RetainCountChecker::checkSummary(const RetainSummary &Summ,
ProgramStateRef state = C.getState();
// Evaluate the effect of the arguments.
- RefVal::Kind hasErr = (RefVal::Kind) 0;
+ RefVal::Kind hasErr = (RefVal::Kind)0;
SourceRange ErrorRange;
SymbolRef ErrorSym = nullptr;
@@ -644,8 +648,8 @@ void RetainCountChecker::checkSummary(const RetainSummary &Summ,
if (SymbolRef Sym = MsgInvocation->getReceiverSVal().getAsLocSymbol()) {
if (const RefVal *T = getRefBinding(state, Sym)) {
ReceiverIsTracked = true;
- state = updateSymbol(state, Sym, *T,
- Summ.getReceiverEffect(), hasErr, C);
+ state =
+ updateSymbol(state, Sym, *T, Summ.getReceiverEffect(), hasErr, C);
if (hasErr) {
ErrorRange = MsgInvocation->getOriginExpr()->getReceiverRange();
ErrorSym = Sym;
@@ -657,8 +661,7 @@ void RetainCountChecker::checkSummary(const RetainSummary &Summ,
} else if (const auto *MCall = dyn_cast<CXXMemberCall>(&CallOrMsg)) {
if (SymbolRef Sym = MCall->getCXXThisVal().getAsLocSymbol()) {
if (const RefVal *T = getRefBinding(state, Sym)) {
- state = updateSymbol(state, Sym, *T, Summ.getThisEffect(),
- hasErr, C);
+ state = updateSymbol(state, Sym, *T, Summ.getThisEffect(), hasErr, C);
if (hasErr) {
ErrorRange = MCall->getOriginExpr()->getSourceRange();
ErrorSym = Sym;
@@ -737,103 +740,103 @@ ProgramStateRef RetainCountChecker::updateSymbol(ProgramStateRef state,
}
switch (AE.getKind()) {
- case UnretainedOutParameter:
- case RetainedOutParameter:
- case RetainedOutParameterOnZero:
- case RetainedOutParameterOnNonZero:
- llvm_unreachable("Applies to pointer-to-pointer parameters, which should "
- "not have ref state.");
-
- case Dealloc: // NB. we only need to add a note in a non-error case.
- switch (V.getKind()) {
- default:
- llvm_unreachable("Invalid RefVal state for an explicit dealloc.");
- case RefVal::Owned:
- // The object immediately transitions to the released state.
- V = V ^ RefVal::Released;
- V.clearCounts();
- return setRefBinding(state, sym, V);
- case RefVal::NotOwned:
- V = V ^ RefVal::ErrorDeallocNotOwned;
- hasErr = V.getKind();
- break;
- }
+ case UnretainedOutParameter:
+ case RetainedOutParameter:
+ case RetainedOutParameterOnZero:
+ case RetainedOutParameterOnNonZero:
+ llvm_unreachable("Applies to pointer-to-pointer parameters, which should "
+ "not have ref state.");
+
+ case Dealloc: // NB. we only need to add a note in a non-error case.
+ switch (V.getKind()) {
+ default:
+ llvm_unreachable("Invalid RefVal state for an explicit dealloc.");
+ case RefVal::Owned:
+ // The object immediately transitions to the released state.
+ V = V ^ RefVal::Released;
+ V.clearCounts();
+ return setRefBinding(state, sym, V);
+ case RefVal::NotOwned:
+ V = V ^ RefVal::ErrorDeallocNotOwned;
+ hasErr = V.getKind();
break;
+ }
+ break;
- case MayEscape:
- if (V.getKind() == RefVal::Owned) {
- V = V ^ RefVal::NotOwned;
- break;
- }
+ case MayEscape:
+ if (V.getKind() == RefVal::Owned) {
+ V = V ^ RefVal::NotOwned;
+ break;
+ }
- [[fallthrough]];
+ [[fallthrough]];
- case DoNothing:
- return state;
+ case DoNothing:
+ return state;
- case Autorelease:
- // Update the autorelease counts.
- V = V.autorelease();
- break;
+ case Autorelease:
+ // Update the autorelease counts.
+ V = V.autorelease();
+ break;
- case StopTracking:
- case StopTrackingHard:
- return removeRefBinding(state, sym);
+ case StopTracking:
+ case StopTrackingHard:
+ return removeRefBinding(state, sym);
- case IncRef:
- switch (V.getKind()) {
- default:
- llvm_unreachable("Invalid RefVal state for a retain.");
- case RefVal::Owned:
- case RefVal::NotOwned:
- V = V + 1;
- break;
- }
+ case IncRef:
+ switch (V.getKind()) {
+ default:
+ llvm_unreachable("Invalid RefVal state for a retain.");
+ case RefVal::Owned:
+ case RefVal::NotOwned:
+ V = V + 1;
break;
+ }
+ break;
- case DecRef:
- case DecRefBridgedTransferred:
- case DecRefAndStopTrackingHard:
- switch (V.getKind()) {
- default:
- // case 'RefVal::Released' handled above.
- llvm_unreachable("Invalid RefVal state for a release.");
-
- case RefVal::Owned:
- assert(V.getCount() > 0);
- if (V.getCount() == 1) {
- if (AE.getKind() == DecRefBridgedTransferred ||
- V.getIvarAccessHistory() ==
- RefVal::IvarAccessHistory::AccessedDirectly)
- V = V ^ RefVal::NotOwned;
- else
- V = V ^ RefVal::Released;
- } else if (AE.getKind() == DecRefAndStopTrackingHard) {
- return removeRefBinding(state, sym);
- }
+ case DecRef:
+ case DecRefBridgedTransferred:
+ case DecRefAndStopTrackingHard:
+ switch (V.getKind()) {
+ default:
+ // case 'RefVal::Released' handled above.
+ llvm_unreachable("Invalid RefVal state for a release.");
+
+ case RefVal::Owned:
+ assert(V.getCount() > 0);
+ if (V.getCount() == 1) {
+ if (AE.getKind() == DecRefBridgedTransferred ||
+ V.getIvarAccessHistory() ==
+ RefVal::IvarAccessHistory::AccessedDirectly)
+ V = V ^ RefVal::NotOwned;
+ else
+ V = V ^ RefVal::Released;
+ } else if (AE.getKind() == DecRefAndStopTrackingHard) {
+ return removeRefBinding(state, sym);
+ }
- V = V - 1;
- break;
+ V = V - 1;
+ break;
- case RefVal::NotOwned:
- if (V.getCount() > 0) {
- if (AE.getKind() == DecRefAndStopTrackingHard)
- return removeRefBinding(state, sym);
- V = V - 1;
- } else if (V.getIvarAccessHistory() ==
- RefVal::IvarAccessHistory::AccessedDirectly) {
- // Assume that the instance variable was holding on the object at
- // +1, and we just didn't know.
- if (AE.getKind() == DecRefAndStopTrackingHard)
- return removeRefBinding(state, sym);
- V = V.releaseViaIvar() ^ RefVal::Released;
- } else {
- V = V ^ RefVal::ErrorReleaseNotOwned;
- hasErr = V.getKind();
- }
- break;
+ case RefVal::NotOwned:
+ if (V.getCount() > 0) {
+ if (AE.getKind() == DecRefAndStopTrackingHard)
+ return removeRefBinding(state, sym);
+ V = V - 1;
+ } else if (V.getIvarAccessHistory() ==
+ RefVal::IvarAccessHistory::AccessedDirectly) {
+ // Assume that the instance variable was holding on the object at
+ // +1, and we just didn't know.
+ if (AE.getKind() == DecRefAndStopTrackingHard)
+ return removeRefBinding(state, sym);
+ V = V.releaseViaIvar() ^ RefVal::Released;
+ } else {
+ V = V ^ RefVal::ErrorReleaseNotOwned;
+ hasErr = V.getKind();
}
break;
+ }
+ break;
}
return setRefBinding(state, sym, V);
}
@@ -842,16 +845,16 @@ const RefCountBug &
RetainCountChecker::errorKindToBugKind(RefVal::Kind ErrorKind,
SymbolRef Sym) const {
switch (ErrorKind) {
- case RefVal::ErrorUseAfterRelease:
- return *UseAfterRelease;
- case RefVal::ErrorReleaseNotOwned:
- return *ReleaseNotOwned;
- case RefVal::ErrorDeallocNotOwned:
- if (Sym->getType()->getPointeeCXXRecordDecl())
- return *FreeNotOwned;
- return *DeallocNotOwned;
- default:
- llvm_unreachable("Unhandled error.");
+ case RefVal::ErrorUseAfterRelease:
+ return *UseAfterRelease;
+ case RefVal::ErrorReleaseNotOwned:
+ return *ReleaseNotOwned;
+ case RefVal::ErrorDeallocNotOwned:
+ if (Sym->getType()->getPointeeCXXRecordDecl())
+ return *FreeNotOwned;
+ return *DeallocNotOwned;
+ default:
+ llvm_unreachable("Unhandled error.");
}
}
@@ -874,9 +877,9 @@ void RetainCountChecker::processNonLeakError(ProgramStateRef St,
if (!N)
return;
- auto report = std::make_unique<RefCountReport>(
- errorKindToBugKind(ErrorKind, Sym),
- C.getASTContext().getLangOpts(), N, Sym);
+ auto report =
+ std::make_unique<RefCountReport>(errorKindToBugKind(ErrorKind, Sym),
+ C.getASTContext().getLangOpts(), N, Sym);
report->addRange(ErrorRange);
C.emitReport(std::move(report));
}
@@ -952,7 +955,6 @@ bool RetainCountChecker::evalCall(const CallEvent &Call,
// output are non-zero.
if (auto L = RetVal.getAs<DefinedOrUnknownSVal>())
state = state->assume(*L, /*assumption=*/true);
-
}
}
@@ -960,8 +962,8 @@ bool RetainCountChecker::evalCall(const CallEvent &Call,
return true;
}
-ExplodedNode * RetainCountChecker::processReturn(const ReturnStmt *S,
- CheckerContext &C) const {
+ExplodedNode *RetainCountChecker::processReturn(const ReturnStmt *S,
+ CheckerContext &C) const {
ExplodedNode *Pred = C.getPredecessor();
// Only adjust the reference count if this is the top-level call frame,
@@ -996,27 +998,27 @@ ExplodedNode * RetainCountChecker::processReturn(const ReturnStmt *S,
RefVal X = *T;
switch (X.getKind()) {
- case RefVal::Owned: {
- unsigned cnt = X.getCount();
- assert(cnt > 0);
+ case RefVal::Owned: {
+ unsigned cnt = X.getCount();
+ assert(cnt > 0);
+ X.setCount(cnt - 1);
+ X = X ^ RefVal::ReturnedOwned;
+ break;
+ }
+
+ case RefVal::NotOwned: {
+ unsigned cnt = X.getCount();
+ if (cnt) {
X.setCount(cnt - 1);
X = X ^ RefVal::ReturnedOwned;
- break;
- }
-
- case RefVal::NotOwned: {
- unsigned cnt = X.getCount();
- if (cnt) {
- X.setCount(cnt - 1);
- X = X ^ RefVal::ReturnedOwned;
- } else {
- X = X ^ RefVal::ReturnedNotOwned;
- }
- break;
+ } else {
+ X = X ^ RefVal::ReturnedNotOwned;
}
+ break;
+ }
- default:
- return Pred;
+ default:
+ return Pred;
}
// Update the binding.
@@ -1063,12 +1065,9 @@ ExplodedNode * RetainCountChecker::processReturn(const ReturnStmt *S,
return checkReturnWithRetEffect(S, C, Pred, RE, X, Sym, state);
}
-ExplodedNode * RetainCountChecker::checkReturnWithRetEffect(const ReturnStmt *S,
- CheckerContext &C,
- ExplodedNode *Pred,
- RetEffect RE, RefVal X,
- SymbolRef Sym,
- ProgramStateRef state) const {
+ExplodedNode *RetainCountChecker::checkReturnWithRetEffect(
+ const ReturnStmt *S, CheckerContext &C, ExplodedNode *Pred, RetEffect RE,
+ RefVal X, SymbolRef Sym, ProgramStateRef state) const {
// HACK: Ignore retain-count issues on values accessed through ivars,
// because of cases like this:
// [_contentView retain];
@@ -1104,7 +1103,7 @@ ExplodedNode * RetainCountChecker::checkReturnWithRetEffect(const ReturnStmt *S,
} else if (X.isReturnedNotOwned()) {
if (RE.isOwned()) {
if (X.getIvarAccessHistory() ==
- RefVal::IvarAccessHistory::AccessedDirectly) {
+ RefVal::IvarAccessHistory::AccessedDirectly) {
// Assume the method was trying to transfer a +1 reference from a
// strong ivar to the caller.
state = setRefBinding(state, Sym,
@@ -1114,8 +1113,8 @@ ExplodedNode * RetainCountChecker::checkReturnWithRetEffect(const ReturnStmt *S,
// owned object.
state = setRefBinding(state, Sym, X ^ RefVal::ErrorReturnedNotOwned);
- static CheckerProgramPointTag
- ReturnNotOwnedTag(this, "ReturnNotOwnedForOwned");
+ static CheckerProgramPointTag ReturnNotOwnedTag(
+ this, "ReturnNotOwnedForOwned");
ExplodedNode *N = C.addTransition(state, Pred, &ReturnNotOwnedTag);
if (N) {
@@ -1147,8 +1146,7 @@ void RetainCountChecker::checkBind(SVal loc, SVal val, const Stmt *S,
}
}
-ProgramStateRef RetainCountChecker::evalAssume(ProgramStateRef state,
- SVal Cond,
+ProgramStateRef RetainCountChecker::evalAssume(ProgramStateRef state, SVal Cond,
bool Assumption) const {
// FIXME: We may add to the interface of evalAssume the list of symbols
// whose assumptions have changed. For now we just iterate through the
@@ -1203,14 +1201,9 @@ ProgramStateRef RetainCountChecker::checkRegionChanges(
return state;
}
-ProgramStateRef
-RetainCountChecker::handleAutoreleaseCounts(ProgramStateRef state,
- ExplodedNode *Pred,
- const ProgramPointTag *Tag,
- CheckerContext &Ctx,
- SymbolRef Sym,
- RefVal V,
- const ReturnStmt *S) const {
+ProgramStateRef RetainCountChecker::handleAutoreleaseCounts(
+ ProgramStateRef state, ExplodedNode *Pred, const ProgramPointTag *Tag,
+ CheckerContext &Ctx, SymbolRef Sym, RefVal V, const ReturnStmt *S) const {
unsigned ACnt = V.getAutoreleaseCount();
// No autorelease counts? Nothing to be done.
@@ -1281,10 +1274,9 @@ RetainCountChecker::handleAutoreleaseCounts(ProgramStateRef state,
return nullptr;
}
-ProgramStateRef
-RetainCountChecker::handleSymbolDeath(ProgramStateRef state,
- SymbolRef sid, RefVal V,
- SmallVectorImpl<SymbolRef> &Leaked) const {
+ProgramStateRef RetainCountChecker::handleSymbolDeath(
+ ProgramStateRef state, SymbolRef sid, RefVal V,
+ SmallVectorImpl<SymbolRef> &Leaked) const {
bool hasLeak;
// HACK: Ignore retain-count issues on values accessed through ivars,
@@ -1309,11 +1301,9 @@ RetainCountChecker::handleSymbolDeath(ProgramStateRef state,
return setRefBinding(state, sid, V ^ RefVal::ErrorLeak);
}
-ExplodedNode *
-RetainCountChecker::processLeaks(ProgramStateRef state,
- SmallVectorImpl<SymbolRef> &Leaked,
- CheckerContext &Ctx,
- ExplodedNode *Pred) const {
+ExplodedNode *RetainCountChecker::processLeaks(
+ ProgramStateRef state, SmallVectorImpl<SymbolRef> &Leaked,
+ CheckerContext &Ctx, ExplodedNode *Pred) const {
// Generate an intermediate node representing the leak point.
ExplodedNode *N = Ctx.addTransition(state, Pred);
const LangOptions &LOpts = Ctx.getASTContext().getLangOpts();
@@ -1384,8 +1374,8 @@ void RetainCountChecker::checkEndFunction(const ReturnStmt *RS,
}
for (auto &I : B) {
- state = handleAutoreleaseCounts(state, Pred, /*Tag=*/nullptr, Ctx,
- I.first, I.second);
+ state = handleAutoreleaseCounts(state, Pred, /*Tag=*/nullptr, Ctx, I.first,
+ I.second);
if (!state)
return;
}
@@ -1414,7 +1404,7 @@ void RetainCountChecker::checkDeadSymbols(SymbolReaper &SymReaper,
SmallVector<SymbolRef, 10> Leaked;
// Update counts from autorelease pools
- for (const auto &I: state->get<RefBindings>()) {
+ for (const auto &I : state->get<RefBindings>()) {
SymbolRef Sym = I.first;
if (SymReaper.isDead(Sym)) {
static CheckerProgramPointTag Tag(this, "DeadSymbolAutorelease");
diff --git a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h
index d4d7c4c74c56bd..d9dd7e1f0f0247 100644
--- a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h
+++ b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h
@@ -14,7 +14,6 @@
#ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_RETAINCOUNTCHECKER_H
#define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_RETAINCOUNTCHECKER_H
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "RetainCountDiagnostics.h"
#include "clang/AST/Attr.h"
#include "clang/AST/DeclCXX.h"
@@ -23,9 +22,10 @@
#include "clang/Analysis/DomainSpecific/CocoaConventions.h"
#include "clang/Analysis/PathDiagnostic.h"
#include "clang/Analysis/RetainSummaryManager.h"
+#include "clang/Analysis/SelectorExtras.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/SourceManager.h"
-#include "clang/Analysis/SelectorExtras.h"
+#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"
@@ -50,17 +50,17 @@ namespace retaincountchecker {
class RefVal {
public:
enum Kind {
- Owned = 0, // Owning reference.
- NotOwned, // Reference is not owned by still valid (not freed).
- Released, // Object has been released.
- ReturnedOwned, // Returned object passes ownership to caller.
+ Owned = 0, // Owning reference.
+ NotOwned, // Reference is not owned by still valid (not freed).
+ Released, // Object has been released.
+ ReturnedOwned, // Returned object passes ownership to caller.
ReturnedNotOwned, // Return object does not pass ownership to caller.
ERROR_START,
ErrorDeallocNotOwned, // -dealloc called on non-owned object.
ErrorUseAfterRelease, // Object used after released.
ErrorReleaseNotOwned, // Release of an object that was not owned.
ERROR_LEAK_START,
- ErrorLeak, // A memory leak due to excessive reference counts.
+ ErrorLeak, // A memory leak due to excessive reference counts.
ErrorLeakReturned, // A memory leak due to the returning method not having
// the correct naming conventions.
ErrorOverAutorelease,
@@ -108,9 +108,9 @@ class RefVal {
RefVal(Kind k, ObjKind o, unsigned cnt, unsigned acnt, QualType t,
IvarAccessHistory IvarAccess)
- : Cnt(cnt), ACnt(acnt), T(t), RawKind(static_cast<unsigned>(k)),
- RawObjectKind(static_cast<unsigned>(o)),
- RawIvarAccessHistory(static_cast<unsigned>(IvarAccess)) {
+ : Cnt(cnt), ACnt(acnt), T(t), RawKind(static_cast<unsigned>(k)),
+ RawObjectKind(static_cast<unsigned>(o)),
+ RawIvarAccessHistory(static_cast<unsigned>(IvarAccess)) {
assert(getKind() == k && "not enough bits for the kind");
assert(getObjKind() == o && "not enough bits for the object kind");
assert(getIvarAccessHistory() == IvarAccess && "not enough bits");
@@ -119,9 +119,7 @@ class RefVal {
public:
Kind getKind() const { return static_cast<Kind>(RawKind); }
- ObjKind getObjKind() const {
- return static_cast<ObjKind>(RawObjectKind);
- }
+ ObjKind getObjKind() const { return static_cast<ObjKind>(RawObjectKind); }
unsigned getCount() const { return Cnt; }
unsigned getAutoreleaseCount() const { return ACnt; }
@@ -130,12 +128,8 @@ class RefVal {
Cnt = 0;
ACnt = 0;
}
- void setCount(unsigned i) {
- Cnt = i;
- }
- void setAutoreleaseCount(unsigned i) {
- ACnt = i;
- }
+ void setCount(unsigned i) { Cnt = i; }
+ void setAutoreleaseCount(unsigned i) { ACnt = i; }
QualType getType() const { return T; }
@@ -148,21 +142,13 @@ class RefVal {
return static_cast<IvarAccessHistory>(RawIvarAccessHistory);
}
- bool isOwned() const {
- return getKind() == Owned;
- }
+ bool isOwned() const { return getKind() == Owned; }
- bool isNotOwned() const {
- return getKind() == NotOwned;
- }
+ bool isNotOwned() const { return getKind() == NotOwned; }
- bool isReturnedOwned() const {
- return getKind() == ReturnedOwned;
- }
+ bool isReturnedOwned() const { return getKind() == ReturnedOwned; }
- bool isReturnedNotOwned() const {
- return getKind() == ReturnedNotOwned;
- }
+ bool isReturnedNotOwned() const { return getKind() == ReturnedNotOwned; }
/// Create a state for an object whose lifetime is the responsibility of the
/// current function, at least partially.
@@ -191,13 +177,13 @@ class RefVal {
}
RefVal operator^(Kind k) const {
- return RefVal(k, getObjKind(), getCount(), getAutoreleaseCount(),
- getType(), getIvarAccessHistory());
+ return RefVal(k, getObjKind(), getCount(), getAutoreleaseCount(), getType(),
+ getIvarAccessHistory());
}
RefVal autorelease() const {
- return RefVal(getKind(), getObjKind(), getCount(), getAutoreleaseCount()+1,
- getType(), getIvarAccessHistory());
+ return RefVal(getKind(), getObjKind(), getCount(),
+ getAutoreleaseCount() + 1, getType(), getIvarAccessHistory());
}
RefVal withIvarAccess() const {
@@ -218,11 +204,11 @@ class RefVal {
getIvarAccessHistory() == X.getIvarAccessHistory();
}
- bool operator==(const RefVal& X) const {
+ bool operator==(const RefVal &X) const {
return T == X.T && hasSameState(X) && getObjKind() == X.getObjKind();
}
- void Profile(llvm::FoldingSetNodeID& ID) const {
+ void Profile(llvm::FoldingSetNodeID &ID) const {
ID.Add(T);
ID.AddInteger(RawKind);
ID.AddInteger(Cnt);
@@ -235,20 +221,13 @@ class RefVal {
};
class RetainCountChecker
- : public Checker< check::Bind,
- check::DeadSymbols,
- check::BeginFunction,
- check::EndFunction,
- check::PostStmt<BlockExpr>,
- check::PostStmt<CastExpr>,
- check::PostStmt<ObjCArrayLiteral>,
- check::PostStmt<ObjCDictionaryLiteral>,
- check::PostStmt<ObjCBoxedExpr>,
- check::PostStmt<ObjCIvarRefExpr>,
- check::PostCall,
- check::RegionChanges,
- eval::Assume,
- eval::Call > {
+ : public Checker<
+ check::Bind, check::DeadSymbols, check::BeginFunction,
+ check::EndFunction, check::PostStmt<BlockExpr>,
+ check::PostStmt<CastExpr>, check::PostStmt<ObjCArrayLiteral>,
+ check::PostStmt<ObjCDictionaryLiteral>,
+ check::PostStmt<ObjCBoxedExpr>, check::PostStmt<ObjCIvarRefExpr>,
+ check::PostCall, check::RegionChanges, eval::Assume, eval::Call> {
public:
std::unique_ptr<RefCountBug> UseAfterRelease;
@@ -287,8 +266,8 @@ class RetainCountChecker
return getSummaryManager(C.getASTContext());
}
- void printState(raw_ostream &Out, ProgramStateRef State,
- const char *NL, const char *Sep) const override;
+ void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
+ const char *Sep) const override;
void checkBind(SVal loc, SVal val, const Stmt *S, CheckerContext &C) const;
void checkPostStmt(const BlockExpr *BE, CheckerContext &C) const;
@@ -305,33 +284,32 @@ class RetainCountChecker
void checkSummary(const RetainSummary &Summ, const CallEvent &Call,
CheckerContext &C) const;
- void processSummaryOfInlined(const RetainSummary &Summ,
- const CallEvent &Call,
+ void processSummaryOfInlined(const RetainSummary &Summ, const CallEvent &Call,
CheckerContext &C) const;
bool evalCall(const CallEvent &Call, CheckerContext &C) const;
ProgramStateRef evalAssume(ProgramStateRef state, SVal Cond,
- bool Assumption) const;
+ bool Assumption) const;
ProgramStateRef
checkRegionChanges(ProgramStateRef state,
const InvalidatedSymbols *invalidated,
ArrayRef<const MemRegion *> ExplicitRegions,
ArrayRef<const MemRegion *> Regions,
- const LocationContext* LCtx,
- const CallEvent *Call) const;
+ const LocationContext *LCtx, const CallEvent *Call) const;
- ExplodedNode* checkReturnWithRetEffect(const ReturnStmt *S, CheckerContext &C,
- ExplodedNode *Pred, RetEffect RE, RefVal X,
- SymbolRef Sym, ProgramStateRef state) const;
+ ExplodedNode *checkReturnWithRetEffect(const ReturnStmt *S, CheckerContext &C,
+ ExplodedNode *Pred, RetEffect RE,
+ RefVal X, SymbolRef Sym,
+ ProgramStateRef state) const;
void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &C) const;
void checkBeginFunction(CheckerContext &C) const;
void checkEndFunction(const ReturnStmt *RS, CheckerContext &C) const;
- ProgramStateRef updateSymbol(ProgramStateRef state, SymbolRef sym,
- RefVal V, ArgEffect E, RefVal::Kind &hasErr,
+ ProgramStateRef updateSymbol(ProgramStateRef state, SymbolRef sym, RefVal V,
+ ArgEffect E, RefVal::Kind &hasErr,
CheckerContext &C) const;
const RefCountBug &errorKindToBugKind(RefVal::Kind ErrorKind,
@@ -343,16 +321,16 @@ class RetainCountChecker
void processObjCLiterals(CheckerContext &C, const Expr *Ex) const;
- ProgramStateRef handleSymbolDeath(ProgramStateRef state,
- SymbolRef sid, RefVal V,
+ ProgramStateRef handleSymbolDeath(ProgramStateRef state, SymbolRef sid,
+ RefVal V,
SmallVectorImpl<SymbolRef> &Leaked) const;
- ProgramStateRef
- handleAutoreleaseCounts(ProgramStateRef state, ExplodedNode *Pred,
- const ProgramPointTag *Tag, CheckerContext &Ctx,
- SymbolRef Sym,
- RefVal V,
- const ReturnStmt *S=nullptr) const;
+ ProgramStateRef handleAutoreleaseCounts(ProgramStateRef state,
+ ExplodedNode *Pred,
+ const ProgramPointTag *Tag,
+ CheckerContext &Ctx, SymbolRef Sym,
+ RefVal V,
+ const ReturnStmt *S = nullptr) const;
ExplodedNode *processLeaks(ProgramStateRef state,
SmallVectorImpl<SymbolRef> &Leaked,
@@ -369,7 +347,7 @@ class RetainCountChecker
/// Perform the necessary checks and state adjustments at the end of the
/// function.
/// \p S Return statement, may be null.
- ExplodedNode * processReturn(const ReturnStmt *S, CheckerContext &C) const;
+ ExplodedNode *processReturn(const ReturnStmt *S, CheckerContext &C) const;
};
//===----------------------------------------------------------------------===//
diff --git a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp
index c3acb73ba7175b..26f2807a9afb49 100644
--- a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp
@@ -53,7 +53,7 @@ StringRef RefCountBug::getDescription() const {
case DeallocNotOwned:
return "-dealloc sent to object that may be referenced elsewhere";
case FreeNotOwned:
- return "'free' called on an object that may be referenced elsewhere";
+ return "'free' called on an object that may be referenced elsewhere";
case OverAutorelease:
return "Object autoreleased too many times";
case ReturnNotOwnedForOwned:
@@ -92,8 +92,7 @@ static std::string getPrettyTypeName(QualType QT) {
/// Write information about the type state change to @c os,
/// return whether the note should be generated.
static bool shouldGenerateNote(llvm::raw_string_ostream &os,
- const RefVal *PrevT,
- const RefVal &CurrV,
+ const RefVal *PrevT, const RefVal &CurrV,
bool DeallocSent) {
// Get the previous type state.
RefVal PrevV = *PrevT;
@@ -194,7 +193,6 @@ static std::optional<std::string> findMetaClassAlloc(const Expr *Callee) {
if (const auto *RD = dyn_cast<CXXRecordDecl>(VD->getDeclContext()))
return RD->getNameAsString();
-
}
}
return std::nullopt;
@@ -300,7 +298,6 @@ static void generateDiagnosticsForCallLike(ProgramStateRef CurrSt,
} else if (CurrSt->isNonNull(RV).isConstrainedTrue()) {
os << " (assuming the call returns non-zero)";
}
-
}
}
}
@@ -348,7 +345,6 @@ class RefLeakReportVisitor : public RefCountReportVisitor {
} // end namespace ento
} // end namespace clang
-
/// Find the first node with the parent stack frame.
static const ExplodedNode *getCalleeNode(const ExplodedNode *Pred) {
const StackFrameContext *SC = Pred->getStackFrame();
@@ -365,7 +361,6 @@ static const ExplodedNode *getCalleeNode(const ExplodedNode *Pred) {
return N;
}
-
/// Insert a diagnostic piece at function exit
/// if a function parameter is annotated as "os_consumed",
/// but it does not actually consume the reference.
@@ -384,7 +379,7 @@ annotateConsumedSummaryMismatch(const ExplodedNode *N,
std::string sbuf;
llvm::raw_string_ostream os(sbuf);
ArrayRef<const ParmVarDecl *> Parameters = Call->parameters();
- for (unsigned I=0; I < Call->getNumArgs() && I < Parameters.size(); ++I) {
+ for (unsigned I = 0; I < Call->getNumArgs() && I < Parameters.size(); ++I) {
const ParmVarDecl *PVD = Parameters[I];
if (!PVD->hasAttr<OSConsumedAttr>())
@@ -453,7 +448,7 @@ PathDiagnosticPieceRef
RefCountReportVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
PathSensitiveBugReport &BR) {
- const auto &BT = static_cast<const RefCountBug&>(BR.getBugType());
+ const auto &BT = static_cast<const RefCountBug &>(BR.getBugType());
bool IsFreeUnowned = BT.getBugType() == RefCountBug::FreeNotOwned ||
BT.getBugType() == RefCountBug::DeallocNotOwned;
@@ -478,7 +473,7 @@ RefCountReportVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
ProgramStateRef CurrSt = N->getState();
const LocationContext *LCtx = N->getLocationContext();
- const RefVal* CurrT = getRefBinding(CurrSt, Sym);
+ const RefVal *CurrT = getRefBinding(CurrSt, Sym);
if (!CurrT)
return nullptr;
@@ -558,7 +553,7 @@ RefCountReportVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
// was ever passed as an argument.
unsigned i = 0;
- for (auto AI=CE->arg_begin(), AE=CE->arg_end(); AI!=AE; ++AI, ++i) {
+ for (auto AI = CE->arg_begin(), AE = CE->arg_end(); AI != AE; ++AI, ++i) {
// Retrieve the value of the argument. Is it the symbol
// we are interested in?
@@ -570,8 +565,8 @@ RefCountReportVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
}
} else if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(S)) {
if (const Expr *receiver = ME->getInstanceReceiver()) {
- if (CurrSt->getSValAsScalarOrLoc(receiver, LCtx)
- .getAsLocSymbol() == Sym) {
+ if (CurrSt->getSValAsScalarOrLoc(receiver, LCtx).getAsLocSymbol() ==
+ Sym) {
// The symbol we are tracking is the receiver.
DeallocSent = true;
}
@@ -587,7 +582,7 @@ RefCountReportVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
const Stmt *S = N->getLocation().castAs<StmtPoint>().getStmt();
PathDiagnosticLocation Pos(S, BRC.getSourceManager(),
- N->getLocationContext());
+ N->getLocationContext());
auto P = std::make_shared<PathDiagnosticEventPiece>(Pos, os.str());
// Add the range by scanning the children of the statement for any bindings
@@ -654,13 +649,12 @@ namespace {
// the leak. The function can also return a location context, which should be
// treated as interesting.
struct AllocationInfo {
- const ExplodedNode* N;
+ const ExplodedNode *N;
const MemRegion *R;
const LocationContext *InterestingMethodContext;
- AllocationInfo(const ExplodedNode *InN,
- const MemRegion *InR,
- const LocationContext *InInterestingMethodContext) :
- N(InN), R(InR), InterestingMethodContext(InInterestingMethodContext) {}
+ AllocationInfo(const ExplodedNode *InN, const MemRegion *InR,
+ const LocationContext *InInterestingMethodContext)
+ : N(InN), R(InR), InterestingMethodContext(InInterestingMethodContext) {}
};
} // end anonymous namespace
@@ -700,10 +694,10 @@ static AllocationInfo GetAllocationSite(ProgramStateManager &StateMgr,
// AllocationNodeInCurrentContext, is the last node in the current or
// parent context in which the symbol was tracked.
//
- // Note that the allocation site might be in the parent context. For example,
- // the case where an allocation happens in a block that captures a reference
- // to it and that reference is overwritten/dropped by another call to
- // the block.
+ // Note that the allocation site might be in the parent context. For
+ // example, the case where an allocation happens in a block that captures a
+ // reference to it and that reference is overwritten/dropped by another call
+ // to the block.
if (NContext == LeakContext || NContext->isParentOf(LeakContext))
AllocationNodeInCurrentOrParentContext = N;
@@ -742,7 +736,7 @@ static AllocationInfo GetAllocationSite(ProgramStateManager &StateMgr,
if (AllocationNodeInCurrentOrParentContext &&
AllocationNodeInCurrentOrParentContext->getLocationContext() !=
- LeakContext)
+ LeakContext)
FirstBinding = nullptr;
return AllocationInfo(AllocationNodeInCurrentOrParentContext, FirstBinding,
diff --git a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h
index d05900895c6a65..25d32dc4f71a59 100644
--- a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h
+++ b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h
@@ -16,8 +16,8 @@
#include "clang/Analysis/PathDiagnostic.h"
#include "clang/Analysis/RetainSummaryManager.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
namespace clang {
@@ -53,12 +53,10 @@ class RefCountReport : public PathSensitiveBugReport {
public:
RefCountReport(const RefCountBug &D, const LangOptions &LOpts,
- ExplodedNode *n, SymbolRef sym,
- bool isLeak=false);
+ ExplodedNode *n, SymbolRef sym, bool isLeak = false);
RefCountReport(const RefCountBug &D, const LangOptions &LOpts,
- ExplodedNode *n, SymbolRef sym,
- StringRef endText);
+ ExplodedNode *n, SymbolRef sym, StringRef endText);
ArrayRef<SourceRange> getRanges() const override {
if (!isLeak)
diff --git a/clang/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp
index 09d82ebabd4c97..609a38f83ba554 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp
@@ -24,16 +24,15 @@ using namespace clang;
using namespace ento;
namespace {
-class ReturnPointerRangeChecker :
- public Checker< check::PreStmt<ReturnStmt> > {
+class ReturnPointerRangeChecker : public Checker<check::PreStmt<ReturnStmt>> {
// FIXME: This bug correspond to CWE-466. Eventually we should have bug
// types explicitly reference such exploit categories (when applicable).
const BugType BT{this, "Buffer overflow"};
public:
- void checkPreStmt(const ReturnStmt *RS, CheckerContext &C) const;
+ void checkPreStmt(const ReturnStmt *RS, CheckerContext &C) const;
};
-}
+} // namespace
void ReturnPointerRangeChecker::checkPreStmt(const ReturnStmt *RS,
CheckerContext &C) const {
diff --git a/clang/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp
index efffbf2ee7559b..35d2a26adf94cd 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp
@@ -23,17 +23,18 @@ using namespace clang;
using namespace ento;
namespace {
-class ReturnUndefChecker : public Checker< check::PreStmt<ReturnStmt> > {
+class ReturnUndefChecker : public Checker<check::PreStmt<ReturnStmt>> {
const BugType BT_Undef{this, "Garbage return value"};
const BugType BT_NullReference{this, "Returning null reference"};
void emitUndef(CheckerContext &C, const Expr *RetE) const;
void checkReference(CheckerContext &C, const Expr *RetE,
DefinedOrUnknownSVal RetVal) const;
+
public:
void checkPreStmt(const ReturnStmt *RS, CheckerContext &C) const;
};
-}
+} // namespace
void ReturnUndefChecker::checkPreStmt(const ReturnStmt *RS,
CheckerContext &C) const {
diff --git a/clang/lib/StaticAnalyzer/Checkers/RunLoopAutoreleaseLeakChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/RunLoopAutoreleaseLeakChecker.cpp
index 2cf6c6ff47f1d2..2f8c525bcf20ec 100644
--- a/clang/lib/StaticAnalyzer/Checkers/RunLoopAutoreleaseLeakChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/RunLoopAutoreleaseLeakChecker.cpp
@@ -22,10 +22,10 @@
//===----------------------------------------------------------------------===//
//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclObjC.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
@@ -40,19 +40,17 @@ using namespace ast_matchers;
namespace {
-const char * RunLoopBind = "NSRunLoopM";
-const char * RunLoopRunBind = "RunLoopRunM";
-const char * OtherMsgBind = "OtherMessageSentM";
-const char * AutoreleasePoolBind = "AutoreleasePoolM";
-const char * OtherStmtAutoreleasePoolBind = "OtherAutoreleasePoolM";
+const char *RunLoopBind = "NSRunLoopM";
+const char *RunLoopRunBind = "RunLoopRunM";
+const char *OtherMsgBind = "OtherMessageSentM";
+const char *AutoreleasePoolBind = "AutoreleasePoolM";
+const char *OtherStmtAutoreleasePoolBind = "OtherAutoreleasePoolM";
class RunLoopAutoreleaseLeakChecker : public Checker<check::ASTCodeBody> {
public:
- void checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
+ void checkASTCodeBody(const Decl *D, AnalysisManager &AM,
BugReporter &BR) const;
-
};
} // end anonymous namespace
@@ -64,7 +62,8 @@ class RunLoopAutoreleaseLeakChecker : public Checker<check::ASTCodeBody> {
/// but useful enough in this case.
static bool seenBefore(const Stmt *Parent, const Stmt *A, const Stmt *B) {
for (const Stmt *C : Parent->children()) {
- if (!C) continue;
+ if (!C)
+ continue;
if (C == A)
return true;
@@ -77,9 +76,7 @@ static bool seenBefore(const Stmt *Parent, const Stmt *A, const Stmt *B) {
return false;
}
-static void emitDiagnostics(BoundNodes &Match,
- const Decl *D,
- BugReporter &BR,
+static void emitDiagnostics(BoundNodes &Match, const Decl *D, BugReporter &BR,
AnalysisManager &AM,
const RunLoopAutoreleaseLeakChecker *Checker) {
@@ -109,42 +106,41 @@ static void emitDiagnostics(BoundNodes &Match,
if (HasAutoreleasePool && (OAP != AP))
return;
- PathDiagnosticLocation Location = PathDiagnosticLocation::createBegin(
- ME, BR.getSourceManager(), ADC);
+ PathDiagnosticLocation Location =
+ PathDiagnosticLocation::createBegin(ME, BR.getSourceManager(), ADC);
SourceRange Range = ME->getSourceRange();
- BR.EmitBasicReport(ADC->getDecl(), Checker,
- /*Name=*/"Memory leak inside autorelease pool",
- /*BugCategory=*/"Memory",
- /*Name=*/
- (Twine("Temporary objects allocated in the") +
- " autorelease pool " +
- (HasAutoreleasePool ? "" : "of last resort ") +
- "followed by the launch of " +
- (RL ? "main run loop " : "xpc_main ") +
- "may never get released; consider moving them to a "
- "separate autorelease pool")
- .str(),
- Location, Range);
+ BR.EmitBasicReport(
+ ADC->getDecl(), Checker,
+ /*Name=*/"Memory leak inside autorelease pool",
+ /*BugCategory=*/"Memory",
+ /*Name=*/
+ (Twine("Temporary objects allocated in the") + " autorelease pool " +
+ (HasAutoreleasePool ? "" : "of last resort ") +
+ "followed by the launch of " + (RL ? "main run loop " : "xpc_main ") +
+ "may never get released; consider moving them to a "
+ "separate autorelease pool")
+ .str(),
+ Location, Range);
}
static StatementMatcher getRunLoopRunM(StatementMatcher Extra = anything()) {
StatementMatcher MainRunLoopM =
objcMessageExpr(hasSelector("mainRunLoop"),
- hasReceiverType(asString("NSRunLoop")),
- Extra)
+ hasReceiverType(asString("NSRunLoop")), Extra)
.bind(RunLoopBind);
- StatementMatcher MainRunLoopRunM = objcMessageExpr(hasSelector("run"),
- hasReceiver(MainRunLoopM),
- Extra).bind(RunLoopRunBind);
+ StatementMatcher MainRunLoopRunM =
+ objcMessageExpr(hasSelector("run"), hasReceiver(MainRunLoopM), Extra)
+ .bind(RunLoopRunBind);
StatementMatcher XPCRunM =
callExpr(callee(functionDecl(hasName("xpc_main")))).bind(RunLoopRunBind);
return anyOf(MainRunLoopRunM, XPCRunM);
}
-static StatementMatcher getOtherMessageSentM(StatementMatcher Extra = anything()) {
+static StatementMatcher
+getOtherMessageSentM(StatementMatcher Extra = anything()) {
return objcMessageExpr(unless(anyOf(equalsBoundNode(RunLoopBind),
equalsBoundNode(RunLoopRunBind))),
Extra)
@@ -156,12 +152,12 @@ checkTempObjectsInSamePool(const Decl *D, AnalysisManager &AM, BugReporter &BR,
const RunLoopAutoreleaseLeakChecker *Chkr) {
StatementMatcher RunLoopRunM = getRunLoopRunM();
StatementMatcher OtherMessageSentM = getOtherMessageSentM(
- hasAncestor(autoreleasePoolStmt().bind(OtherStmtAutoreleasePoolBind)));
+ hasAncestor(autoreleasePoolStmt().bind(OtherStmtAutoreleasePoolBind)));
StatementMatcher RunLoopInAutorelease =
- autoreleasePoolStmt(
- hasDescendant(RunLoopRunM),
- hasDescendant(OtherMessageSentM)).bind(AutoreleasePoolBind);
+ autoreleasePoolStmt(hasDescendant(RunLoopRunM),
+ hasDescendant(OtherMessageSentM))
+ .bind(AutoreleasePoolBind);
DeclarationMatcher GroupM = decl(hasDescendant(RunLoopInAutorelease));
@@ -179,22 +175,18 @@ checkTempObjectsInNoPool(const Decl *D, AnalysisManager &AM, BugReporter &BR,
StatementMatcher RunLoopRunM = getRunLoopRunM(NoPoolM);
StatementMatcher OtherMessageSentM = getOtherMessageSentM(NoPoolM);
- DeclarationMatcher GroupM = functionDecl(
- isMain(),
- hasDescendant(RunLoopRunM),
- hasDescendant(OtherMessageSentM)
- );
+ DeclarationMatcher GroupM = functionDecl(isMain(), hasDescendant(RunLoopRunM),
+ hasDescendant(OtherMessageSentM));
auto Matches = match(GroupM, *D, AM.getASTContext());
for (BoundNodes Match : Matches)
emitDiagnostics(Match, D, BR, AM, Chkr);
-
}
void RunLoopAutoreleaseLeakChecker::checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
- BugReporter &BR) const {
+ AnalysisManager &AM,
+ BugReporter &BR) const {
checkTempObjectsInSamePool(D, AM, BR, this);
checkTempObjectsInNoPool(D, AM, BR, this);
}
@@ -203,6 +195,7 @@ void ento::registerRunLoopAutoreleaseLeakChecker(CheckerManager &mgr) {
mgr.registerChecker<RunLoopAutoreleaseLeakChecker>();
}
-bool ento::shouldRegisterRunLoopAutoreleaseLeakChecker(const CheckerManager &mgr) {
+bool ento::shouldRegisterRunLoopAutoreleaseLeakChecker(
+ const CheckerManager &mgr) {
return true;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/STLAlgorithmModeling.cpp b/clang/lib/StaticAnalyzer/Checkers/STLAlgorithmModeling.cpp
index 788f2875863c3e..a1fb8491a8b293 100644
--- a/clang/lib/StaticAnalyzer/Checkers/STLAlgorithmModeling.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/STLAlgorithmModeling.cpp
@@ -1,4 +1,5 @@
-//===-- STLAlgorithmModeling.cpp -----------------------------------*- C++ -*--//
+//===-- STLAlgorithmModeling.cpp -----------------------------------*- C++
+//-*--//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -30,32 +31,32 @@ class STLAlgorithmModeling : public Checker<eval::Call> {
void Find(CheckerContext &C, const CallExpr *CE, unsigned paramNum) const;
using FnCheck = bool (STLAlgorithmModeling::*)(CheckerContext &,
- const CallExpr *) const;
+ const CallExpr *) const;
const CallDescriptionMap<FnCheck> Callbacks = {
- {{{"std", "find"}, 3}, &STLAlgorithmModeling::evalFind},
- {{{"std", "find"}, 4}, &STLAlgorithmModeling::evalFind},
- {{{"std", "find_if"}, 3}, &STLAlgorithmModeling::evalFind},
- {{{"std", "find_if"}, 4}, &STLAlgorithmModeling::evalFind},
- {{{"std", "find_if_not"}, 3}, &STLAlgorithmModeling::evalFind},
- {{{"std", "find_if_not"}, 4}, &STLAlgorithmModeling::evalFind},
- {{{"std", "find_first_of"}, 4}, &STLAlgorithmModeling::evalFind},
- {{{"std", "find_first_of"}, 5}, &STLAlgorithmModeling::evalFind},
- {{{"std", "find_first_of"}, 6}, &STLAlgorithmModeling::evalFind},
- {{{"std", "find_end"}, 4}, &STLAlgorithmModeling::evalFind},
- {{{"std", "find_end"}, 5}, &STLAlgorithmModeling::evalFind},
- {{{"std", "find_end"}, 6}, &STLAlgorithmModeling::evalFind},
- {{{"std", "lower_bound"}, 3}, &STLAlgorithmModeling::evalFind},
- {{{"std", "lower_bound"}, 4}, &STLAlgorithmModeling::evalFind},
- {{{"std", "upper_bound"}, 3}, &STLAlgorithmModeling::evalFind},
- {{{"std", "upper_bound"}, 4}, &STLAlgorithmModeling::evalFind},
- {{{"std", "search"}, 3}, &STLAlgorithmModeling::evalFind},
- {{{"std", "search"}, 4}, &STLAlgorithmModeling::evalFind},
- {{{"std", "search"}, 5}, &STLAlgorithmModeling::evalFind},
- {{{"std", "search"}, 6}, &STLAlgorithmModeling::evalFind},
- {{{"std", "search_n"}, 4}, &STLAlgorithmModeling::evalFind},
- {{{"std", "search_n"}, 5}, &STLAlgorithmModeling::evalFind},
- {{{"std", "search_n"}, 6}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find"}, 3}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find"}, 4}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find_if"}, 3}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find_if"}, 4}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find_if_not"}, 3}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find_if_not"}, 4}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find_first_of"}, 4}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find_first_of"}, 5}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find_first_of"}, 6}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find_end"}, 4}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find_end"}, 5}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "find_end"}, 6}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "lower_bound"}, 3}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "lower_bound"}, 4}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "upper_bound"}, 3}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "upper_bound"}, 4}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "search"}, 3}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "search"}, 4}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "search"}, 5}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "search"}, 6}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "search_n"}, 4}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "search_n"}, 5}, &STLAlgorithmModeling::evalFind},
+ {{{"std", "search_n"}, 6}, &STLAlgorithmModeling::evalFind},
};
public:
@@ -127,10 +128,9 @@ void STLAlgorithmModeling::Find(CheckerContext &C, const CallExpr *CE,
const auto *NewPos = getIteratorPosition(StateFound, RetVal);
assert(NewPos && "Failed to create new iterator position.");
- SVal GreaterOrEqual = SVB.evalBinOp(StateFound, BO_GE,
- nonloc::SymbolVal(NewPos->getOffset()),
- nonloc::SymbolVal(Pos->getOffset()),
- SVB.getConditionType());
+ SVal GreaterOrEqual = SVB.evalBinOp(
+ StateFound, BO_GE, nonloc::SymbolVal(NewPos->getOffset()),
+ nonloc::SymbolVal(Pos->getOffset()), SVB.getConditionType());
assert(isa<DefinedSVal>(GreaterOrEqual) &&
"Symbol comparison must be a `DefinedSVal`");
StateFound = StateFound->assume(GreaterOrEqual.castAs<DefinedSVal>(), true);
@@ -149,10 +149,9 @@ void STLAlgorithmModeling::Find(CheckerContext &C, const CallExpr *CE,
const auto *NewPos = getIteratorPosition(StateFound, RetVal);
assert(NewPos && "Failed to create new iterator position.");
- SVal Less = SVB.evalBinOp(StateFound, BO_LT,
- nonloc::SymbolVal(NewPos->getOffset()),
- nonloc::SymbolVal(Pos->getOffset()),
- SVB.getConditionType());
+ SVal Less = SVB.evalBinOp(
+ StateFound, BO_LT, nonloc::SymbolVal(NewPos->getOffset()),
+ nonloc::SymbolVal(Pos->getOffset()), SVB.getConditionType());
assert(isa<DefinedSVal>(Less) &&
"Symbol comparison must be a `DefinedSVal`");
StateFound = StateFound->assume(Less.castAs<DefinedSVal>(), true);
@@ -171,11 +170,10 @@ void STLAlgorithmModeling::Find(CheckerContext &C, const CallExpr *CE,
void ento::registerSTLAlgorithmModeling(CheckerManager &Mgr) {
auto *Checker = Mgr.registerChecker<STLAlgorithmModeling>();
Checker->AggressiveStdFindModeling =
- Mgr.getAnalyzerOptions().getCheckerBooleanOption(Checker,
- "AggressiveStdFindModeling");
+ Mgr.getAnalyzerOptions().getCheckerBooleanOption(
+ Checker, "AggressiveStdFindModeling");
}
bool ento::shouldRegisterSTLAlgorithmModeling(const CheckerManager &mgr) {
return true;
}
-
diff --git a/clang/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp
index 7cbe271dfbf93a..a1d1e48004e980 100644
--- a/clang/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp
@@ -1,4 +1,5 @@
-//===-- SimpleStreamChecker.cpp -----------------------------------------*- C++ -*--//
+//===-- SimpleStreamChecker.cpp -----------------------------------------*- C++
+//-*--//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -31,7 +32,7 @@ typedef SmallVector<SymbolRef, 2> SymbolVector;
struct StreamState {
private:
enum Kind { Opened, Closed } K;
- StreamState(Kind InK) : K(InK) { }
+ StreamState(Kind InK) : K(InK) {}
public:
bool isOpened() const { return K == Opened; }
@@ -40,18 +41,13 @@ struct StreamState {
static StreamState getOpened() { return StreamState(Opened); }
static StreamState getClosed() { return StreamState(Closed); }
- bool operator==(const StreamState &X) const {
- return K == X.K;
- }
- void Profile(llvm::FoldingSetNodeID &ID) const {
- ID.AddInteger(K);
- }
+ bool operator==(const StreamState &X) const { return K == X.K; }
+ void Profile(llvm::FoldingSetNodeID &ID) const { ID.AddInteger(K); }
};
-class SimpleStreamChecker : public Checker<check::PostCall,
- check::PreCall,
- check::DeadSymbols,
- check::PointerEscape> {
+class SimpleStreamChecker
+ : public Checker<check::PostCall, check::PreCall, check::DeadSymbols,
+ check::PointerEscape> {
const CallDescription OpenFn{{"fopen"}, 2};
const CallDescription CloseFn{{"fclose"}, 1};
@@ -60,8 +56,7 @@ class SimpleStreamChecker : public Checker<check::PostCall,
const BugType LeakBugType{this, "Resource Leak", "Unix Stream API Error",
/*SuppressOnSink=*/true};
- void reportDoubleClose(SymbolRef FileDescSym,
- const CallEvent &Call,
+ void reportDoubleClose(SymbolRef FileDescSym, const CallEvent &Call,
CheckerContext &C) const;
void reportLeaks(ArrayRef<SymbolRef> LeakedStreams, CheckerContext &C,
@@ -79,9 +74,9 @@ class SimpleStreamChecker : public Checker<check::PostCall,
/// Stop tracking addresses which escape.
ProgramStateRef checkPointerEscape(ProgramStateRef State,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind) const;
+ const InvalidatedSymbols &Escaped,
+ const CallEvent *Call,
+ PointerEscapeKind Kind) const;
};
} // end anonymous namespace
@@ -135,8 +130,8 @@ void SimpleStreamChecker::checkPreCall(const CallEvent &Call,
C.addTransition(State);
}
-static bool isLeaked(SymbolRef Sym, const StreamState &SS,
- bool IsSymDead, ProgramStateRef State) {
+static bool isLeaked(SymbolRef Sym, const StreamState &SS, bool IsSymDead,
+ ProgramStateRef State) {
if (IsSymDead && SS.isOpened()) {
// If a symbol is NULL, assume that fopen failed on this path.
// A symbol should only be considered leaked if it is non-null.
@@ -201,7 +196,8 @@ void SimpleStreamChecker::reportLeaks(ArrayRef<SymbolRef> LeakedStreams,
}
}
-bool SimpleStreamChecker::guaranteedNotToCloseFile(const CallEvent &Call) const{
+bool SimpleStreamChecker::guaranteedNotToCloseFile(
+ const CallEvent &Call) const {
// If it's not in a system header, assume it might close a file.
if (!Call.isInSystemHeader())
return false;
@@ -218,11 +214,9 @@ bool SimpleStreamChecker::guaranteedNotToCloseFile(const CallEvent &Call) const{
// If the pointer we are tracking escaped, do not track the symbol as
// we cannot reason about it anymore.
-ProgramStateRef
-SimpleStreamChecker::checkPointerEscape(ProgramStateRef State,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind) const {
+ProgramStateRef SimpleStreamChecker::checkPointerEscape(
+ ProgramStateRef State, const InvalidatedSymbols &Escaped,
+ const CallEvent *Call, PointerEscapeKind Kind) const {
// If we know that the call cannot close a file, there is nothing to do.
if (Kind == PSK_DirectEscapeOnCall && guaranteedNotToCloseFile(*Call)) {
return State;
diff --git a/clang/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp
index ea09c43cc5ce90..6eae9eb3f5ee0c 100644
--- a/clang/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp
@@ -125,7 +125,8 @@ bool StackAddrEscapeChecker::isNotInCurrentFrame(const MemRegion *R,
bool StackAddrEscapeChecker::isSemaphoreCaptured(const BlockDecl &B) const {
if (!dispatch_semaphore_tII)
- dispatch_semaphore_tII = &B.getASTContext().Idents.get("dispatch_semaphore_t");
+ dispatch_semaphore_tII =
+ &B.getASTContext().Idents.get("dispatch_semaphore_t");
for (const auto &C : B.captures()) {
const auto *T = C.getVariable()->getType()->getAs<TypedefType>();
if (T && T->getDecl()->getIdentifier() == dispatch_semaphore_tII)
diff --git a/clang/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp
index acf4e833095b7f..8ee77ea941fee8 100644
--- a/clang/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp
@@ -28,10 +28,9 @@ class TaintTesterChecker : public Checker<check::PostStmt<Expr>> {
public:
void checkPostStmt(const Expr *E, CheckerContext &C) const;
};
-}
+} // namespace
-void TaintTesterChecker::checkPostStmt(const Expr *E,
- CheckerContext &C) const {
+void TaintTesterChecker::checkPostStmt(const Expr *E, CheckerContext &C) const {
ProgramStateRef State = C.getState();
if (!State)
return;
diff --git a/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp
index 667b19f8120eaa..5f04bf5eb9fbfd 100644
--- a/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp
@@ -172,7 +172,7 @@ void TestAfterDivZeroChecker::reportBug(SVal Val, CheckerContext &C) const {
N);
R->addVisitor(std::make_unique<DivisionBRVisitor>(Val.getAsSymbol(),
- C.getStackFrame()));
+ C.getStackFrame()));
C.emitReport(std::move(R));
}
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/TraversalChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/TraversalChecker.cpp
index 2f316bd3b20dbe..9b22ef61b9427d 100644
--- a/clang/lib/StaticAnalyzer/Checkers/TraversalChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/TraversalChecker.cpp
@@ -10,9 +10,9 @@
// as it builds the ExplodedGraph.
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/ParentMap.h"
#include "clang/AST/StmtObjC.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/CheckerManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
@@ -23,15 +23,15 @@ using namespace clang;
using namespace ento;
namespace {
-class TraversalDumper : public Checker< check::BranchCondition,
- check::BeginFunction,
- check::EndFunction > {
+class TraversalDumper
+ : public Checker<check::BranchCondition, check::BeginFunction,
+ check::EndFunction> {
public:
void checkBranchCondition(const Stmt *Condition, CheckerContext &C) const;
void checkBeginFunction(CheckerContext &C) const;
void checkEndFunction(const ReturnStmt *RS, CheckerContext &C) const;
};
-}
+} // namespace
void TraversalDumper::checkBranchCondition(const Stmt *Condition,
CheckerContext &C) const {
@@ -71,13 +71,12 @@ bool ento::shouldRegisterTraversalDumper(const CheckerManager &mgr) {
//------------------------------------------------------------------------------
namespace {
-class CallDumper : public Checker< check::PreCall,
- check::PostCall > {
+class CallDumper : public Checker<check::PreCall, check::PostCall> {
public:
void checkPreCall(const CallEvent &Call, CheckerContext &C) const;
void checkPostCall(const CallEvent &Call, CheckerContext &C) const;
};
-}
+} // namespace
void CallDumper::checkPreCall(const CallEvent &Call, CheckerContext &C) const {
unsigned Indentation = 0;
@@ -116,6 +115,4 @@ void ento::registerCallDumper(CheckerManager &mgr) {
mgr.registerChecker<CallDumper>();
}
-bool ento::shouldRegisterCallDumper(const CheckerManager &mgr) {
- return true;
-}
+bool ento::shouldRegisterCallDumper(const CheckerManager &mgr) { return true; }
diff --git a/clang/lib/StaticAnalyzer/Checkers/TrustNonnullChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/TrustNonnullChecker.cpp
index e2f8bd541c9670..932dc4f8f0d1ae 100644
--- a/clang/lib/StaticAnalyzer/Checkers/TrustNonnullChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/TrustNonnullChecker.cpp
@@ -18,13 +18,13 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/Analysis/SelectorExtras.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.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 "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
using namespace clang;
using namespace ento;
@@ -42,10 +42,9 @@ REGISTER_MAP_WITH_PROGRAMSTATE(NullImplicationMap, SymbolRef, SymbolRef)
namespace {
-class TrustNonnullChecker : public Checker<check::PostCall,
- check::PostObjCMessage,
- check::DeadSymbols,
- eval::Assume> {
+class TrustNonnullChecker
+ : public Checker<check::PostCall, check::PostObjCMessage,
+ check::DeadSymbols, eval::Assume> {
// Do not try to iterate over symbols with higher complexity.
static unsigned constexpr ComplexityThreshold = 10;
Selector ObjectForKeyedSubscriptSel;
@@ -62,8 +61,7 @@ class TrustNonnullChecker : public Checker<check::PostCall,
getKeywordSelector(Ctx, "setObject", "forKeyedSubscript")),
SetObjectForKeySel(getKeywordSelector(Ctx, "setObject", "forKey")) {}
- ProgramStateRef evalAssume(ProgramStateRef State,
- SVal Cond,
+ ProgramStateRef evalAssume(ProgramStateRef State, SVal Cond,
bool Assumption) const {
const SymbolRef CondS = Cond.getAsSymbol();
if (!CondS || CondS->computeComplexity() > ComplexityThreshold)
@@ -139,7 +137,6 @@ class TrustNonnullChecker : public Checker<check::PostCall,
}
private:
-
/// \returns State with GDM \p MapName where all dead symbols were
// removed.
template <typename MapName>
@@ -193,7 +190,7 @@ class TrustNonnullChecker : public Checker<check::PostCall,
/// \return Whether \p ID has a superclass by the name \p ClassName.
bool interfaceHasSuperclass(const ObjCInterfaceDecl *ID,
- StringRef ClassName) const {
+ StringRef ClassName) const {
if (ID->getIdentifier()->getName() == ClassName)
return true;
@@ -203,7 +200,6 @@ class TrustNonnullChecker : public Checker<check::PostCall,
return false;
}
-
/// \return a state with an optional implication added (if exists)
/// from a map of recorded implications.
/// If \p Negated is true, checks NullImplicationMap, and assumes
@@ -224,8 +220,8 @@ class TrustNonnullChecker : public Checker<check::PostCall,
SVal AntecedentV = SVB.makeSymbolVal(Antecedent);
ProgramStateRef State = InputState;
- if ((Negated && InputState->isNonNull(AntecedentV).isConstrainedTrue())
- || (!Negated && InputState->isNull(AntecedentV).isConstrainedTrue())) {
+ if ((Negated && InputState->isNonNull(AntecedentV).isConstrainedTrue()) ||
+ (!Negated && InputState->isNull(AntecedentV).isConstrainedTrue())) {
SVal ConsequentS = SVB.makeSymbolVal(*Consequent);
State = InputState->assume(ConsequentS.castAs<DefinedSVal>(), Negated);
if (!State)
@@ -245,7 +241,7 @@ class TrustNonnullChecker : public Checker<check::PostCall,
}
};
-} // end empty namespace
+} // namespace
void ento::registerTrustNonnullChecker(CheckerManager &Mgr) {
Mgr.registerChecker<TrustNonnullChecker>(Mgr.getASTContext());
diff --git a/clang/lib/StaticAnalyzer/Checkers/TrustReturnsNonnullChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/TrustReturnsNonnullChecker.cpp
index d80559c6a91522..8840799dffa7f7 100644
--- a/clang/lib/StaticAnalyzer/Checkers/TrustReturnsNonnullChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/TrustReturnsNonnullChecker.cpp
@@ -41,7 +41,7 @@ class TrustReturnsNonnullChecker : public Checker<check::PostCall> {
/// \returns Whether the method declaration has the attribute returns_nonnull.
bool isNonNullPtr(const CallEvent &Call) const {
QualType ExprRetType = Call.getResultType();
- const Decl *CallDeclaration = Call.getDecl();
+ const Decl *CallDeclaration = Call.getDecl();
if (!ExprRetType->isAnyPointerType() || !CallDeclaration)
return false;
diff --git a/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp
index 2839ef0b6d2e61..3b6024aee1f850 100644
--- a/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp
@@ -10,8 +10,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/Attr.h"
+#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"
@@ -26,7 +26,7 @@ using namespace ento;
namespace {
class UndefCapturedBlockVarChecker
- : public Checker< check::PostStmt<BlockExpr> > {
+ : public Checker<check::PostStmt<BlockExpr>> {
const BugType BT{this, "uninitialized variable captured by block"};
public:
@@ -48,9 +48,8 @@ static const DeclRefExpr *FindBlockDeclRefExpr(const Stmt *S,
return nullptr;
}
-void
-UndefCapturedBlockVarChecker::checkPostStmt(const BlockExpr *BE,
- CheckerContext &C) const {
+void UndefCapturedBlockVarChecker::checkPostStmt(const BlockExpr *BE,
+ CheckerContext &C) const {
if (!BE->getBlockDecl()->hasCaptures())
return;
@@ -95,6 +94,7 @@ void ento::registerUndefCapturedBlockVarChecker(CheckerManager &mgr) {
mgr.registerChecker<UndefCapturedBlockVarChecker>();
}
-bool ento::shouldRegisterUndefCapturedBlockVarChecker(const CheckerManager &mgr) {
+bool ento::shouldRegisterUndefCapturedBlockVarChecker(
+ const CheckerManager &mgr) {
return true;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp
index 4b845bb3ded23e..10fc173508318a 100644
--- a/clang/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp
@@ -25,8 +25,7 @@ using namespace clang;
using namespace ento;
namespace {
-class UndefResultChecker
- : public Checker< check::PostStmt<BinaryOperator> > {
+class UndefResultChecker : public Checker<check::PostStmt<BinaryOperator>> {
const BugType BT{this, "Result of operation is garbage or undefined"};
@@ -65,7 +64,7 @@ void UndefResultChecker::checkPostStmt(const BinaryOperator *B,
// Do not report assignments of uninitialized values inside swap functions.
// This should allow to swap partially uninitialized structs
if (const FunctionDecl *EnclosingFunctionDecl =
- dyn_cast<FunctionDecl>(C.getStackFrame()->getDecl()))
+ dyn_cast<FunctionDecl>(C.getStackFrame()->getDecl()))
if (C.getCalleeName(EnclosingFunctionDecl) == "swap")
return;
@@ -82,8 +81,7 @@ void UndefResultChecker::checkPostStmt(const BinaryOperator *B,
if (C.getSVal(B->getLHS()).isUndef()) {
Ex = B->getLHS()->IgnoreParenCasts();
isLeft = true;
- }
- else if (C.getSVal(B->getRHS()).isUndef()) {
+ } else if (C.getSVal(B->getRHS()).isUndef()) {
Ex = B->getRHS()->IgnoreParenCasts();
isLeft = false;
}
@@ -104,8 +102,7 @@ void UndefResultChecker::checkPostStmt(const BinaryOperator *B,
if (Ex) {
report->addRange(Ex->getSourceRange());
bugreporter::trackExpressionValue(N, Ex, *report);
- }
- else
+ } else
bugreporter::trackExpressionValue(N, B, *report);
C.emitReport(std::move(report));
diff --git a/clang/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp
index baa07fa66764e3..7f10b7325c7e07 100644
--- a/clang/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp
@@ -11,8 +11,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/DeclCXX.h"
+#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"
@@ -23,7 +23,7 @@ using namespace ento;
namespace {
class UndefinedArraySubscriptChecker
- : public Checker< check::PreStmt<ArraySubscriptExpr> > {
+ : public Checker<check::PreStmt<ArraySubscriptExpr>> {
const BugType BT{this, "Array subscript is undefined"};
public:
@@ -31,9 +31,8 @@ class UndefinedArraySubscriptChecker
};
} // end anonymous namespace
-void
-UndefinedArraySubscriptChecker::checkPreStmt(const ArraySubscriptExpr *A,
- CheckerContext &C) const {
+void UndefinedArraySubscriptChecker::checkPreStmt(const ArraySubscriptExpr *A,
+ CheckerContext &C) const {
const Expr *Index = A->getIdx();
if (!C.getSVal(Index).isUndef())
return;
@@ -59,6 +58,7 @@ void ento::registerUndefinedArraySubscriptChecker(CheckerManager &mgr) {
mgr.registerChecker<UndefinedArraySubscriptChecker>();
}
-bool ento::shouldRegisterUndefinedArraySubscriptChecker(const CheckerManager &mgr) {
+bool ento::shouldRegisterUndefinedArraySubscriptChecker(
+ const CheckerManager &mgr) {
return true;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp
index ddc6cc9e8202c7..ec471f4a1fbf7a 100644
--- a/clang/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp
@@ -21,15 +21,14 @@ using namespace clang;
using namespace ento;
namespace {
-class UndefinedAssignmentChecker
- : public Checker<check::Bind> {
+class UndefinedAssignmentChecker : public Checker<check::Bind> {
const BugType BT{this, "Assigned value is garbage or undefined"};
public:
void checkBind(SVal location, SVal val, const Stmt *S,
CheckerContext &C) const;
};
-}
+} // namespace
void UndefinedAssignmentChecker::checkBind(SVal location, SVal val,
const Stmt *StoreE,
@@ -40,7 +39,7 @@ void UndefinedAssignmentChecker::checkBind(SVal location, SVal val,
// Do not report assignments of uninitialized values inside swap functions.
// This should allow to swap partially uninitialized structs
if (const FunctionDecl *EnclosingFunctionDecl =
- dyn_cast<FunctionDecl>(C.getStackFrame()->getDecl()))
+ dyn_cast<FunctionDecl>(C.getStackFrame()->getDecl()))
if (C.getCalleeName(EnclosingFunctionDecl) == "swap")
return;
diff --git a/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObject.h b/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObject.h
index e35778e6480c5b..699d5236e4f91f 100644
--- a/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObject.h
+++ b/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObject.h
@@ -322,9 +322,8 @@ class FindUninitializedFields {
/// Returns true if T is a primitive type. An object of a primitive type only
/// needs to be analyzed as much as checking whether their value is undefined.
inline bool isPrimitiveType(const QualType &T) {
- return T->isBuiltinType() || T->isEnumeralType() ||
- T->isFunctionType() || T->isAtomicType() ||
- T->isVectorType() || T->isScalarType();
+ return T->isBuiltinType() || T->isEnumeralType() || T->isFunctionType() ||
+ T->isAtomicType() || T->isVectorType() || T->isScalarType();
}
inline bool isDereferencableType(const QualType &T) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp
index 6e1222fedad3ee..46983eed3337f3 100644
--- a/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp
@@ -17,10 +17,10 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "UninitializedObject.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
@@ -544,10 +544,9 @@ static bool hasUnguardedAccess(const FieldDecl *FD, ProgramStateRef State) {
auto NoReturnFuncM = callExpr(callee(functionDecl(isNoReturn())));
- auto GuardM =
- stmt(anyOf(ifStmt(), switchStmt(), conditionalOperator(), AssertLikeM,
- NoReturnFuncM))
- .bind("guard");
+ auto GuardM = stmt(anyOf(ifStmt(), switchStmt(), conditionalOperator(),
+ AssertLikeM, NoReturnFuncM))
+ .bind("guard");
for (const CXXMethodDecl *M : Parent->methods()) {
const Stmt *MethodBody = getMethodBody(M);
@@ -604,10 +603,10 @@ void ento::registerUninitializedObjectChecker(CheckerManager &Mgr) {
UninitObjCheckerOptions &ChOpts = Chk->Opts;
ChOpts.IsPedantic = AnOpts.getCheckerBooleanOption(Chk, "Pedantic");
- ChOpts.ShouldConvertNotesToWarnings = AnOpts.getCheckerBooleanOption(
- Chk, "NotesAsWarnings");
- ChOpts.CheckPointeeInitialization = AnOpts.getCheckerBooleanOption(
- Chk, "CheckPointeeInitialization");
+ ChOpts.ShouldConvertNotesToWarnings =
+ AnOpts.getCheckerBooleanOption(Chk, "NotesAsWarnings");
+ ChOpts.CheckPointeeInitialization =
+ AnOpts.getCheckerBooleanOption(Chk, "CheckPointeeInitialization");
ChOpts.IgnoredRecordsWithFieldPattern =
std::string(AnOpts.getCheckerStringOption(Chk, "IgnoreRecordsWithField"));
ChOpts.IgnoreGuardedFields =
@@ -615,9 +614,11 @@ void ento::registerUninitializedObjectChecker(CheckerManager &Mgr) {
std::string ErrorMsg;
if (!llvm::Regex(ChOpts.IgnoredRecordsWithFieldPattern).isValid(ErrorMsg))
- Mgr.reportInvalidCheckerOptionValue(Chk, "IgnoreRecordsWithField",
+ Mgr.reportInvalidCheckerOptionValue(
+ Chk, "IgnoreRecordsWithField",
"a valid regex, building failed with error message "
- "\"" + ErrorMsg + "\"");
+ "\"" +
+ ErrorMsg + "\"");
}
bool ento::shouldRegisterUninitializedObjectChecker(const CheckerManager &mgr) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp
index 19f1ca2dc824c9..69a15a5bba320d 100644
--- a/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp
@@ -58,14 +58,14 @@ class UnixAPIMisuseChecker
void CheckOpenAt(CheckerContext &C, const CallExpr *CE) const;
void CheckPthreadOnce(CheckerContext &C, const CallExpr *CE) const;
- void CheckOpenVariant(CheckerContext &C,
- const CallExpr *CE, OpenVariant Variant) const;
+ void CheckOpenVariant(CheckerContext &C, const CallExpr *CE,
+ OpenVariant Variant) const;
void ReportOpenBug(CheckerContext &C, ProgramStateRef State, const char *Msg,
SourceRange SR) const;
};
-class UnixAPIPortabilityChecker : public Checker< check::PreStmt<CallExpr> > {
+class UnixAPIPortabilityChecker : public Checker<check::PreStmt<CallExpr>> {
public:
void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
@@ -82,14 +82,10 @@ class UnixAPIPortabilityChecker : public Checker< check::PreStmt<CallExpr> > {
void CheckAllocaWithAlignZero(CheckerContext &C, const CallExpr *CE) const;
void CheckVallocZero(CheckerContext &C, const CallExpr *CE) const;
- bool ReportZeroByteAllocation(CheckerContext &C,
- ProgramStateRef falseState,
- const Expr *arg,
- const char *fn_name) const;
- void BasicAllocationCheck(CheckerContext &C,
- const CallExpr *CE,
- const unsigned numArgs,
- const unsigned sizeArg,
+ bool ReportZeroByteAllocation(CheckerContext &C, ProgramStateRef falseState,
+ const Expr *arg, const char *fn_name) const;
+ void BasicAllocationCheck(CheckerContext &C, const CallExpr *CE,
+ const unsigned numArgs, const unsigned sizeArg,
const char *fn) const;
};
@@ -139,8 +135,7 @@ void UnixAPIMisuseChecker::checkPreStmt(const CallExpr *CE,
CheckPthreadOnce(C, CE);
}
void UnixAPIMisuseChecker::ReportOpenBug(CheckerContext &C,
- ProgramStateRef State,
- const char *Msg,
+ ProgramStateRef State, const char *Msg,
SourceRange SR) const {
ExplodedNode *N = C.generateErrorNode(State);
if (!N)
@@ -201,12 +196,10 @@ void UnixAPIMisuseChecker::CheckOpenVariant(CheckerContext &C,
SmallString<256> SBuf;
llvm::raw_svector_ostream OS(SBuf);
OS << "The " << CreateModeArgIndex + 1
- << llvm::getOrdinalSuffix(CreateModeArgIndex + 1)
- << " argument to '" << VariantName << "' is not an integer";
+ << llvm::getOrdinalSuffix(CreateModeArgIndex + 1) << " argument to '"
+ << VariantName << "' is not an integer";
- ReportOpenBug(C, state,
- SBuf.c_str(),
- Arg->getSourceRange());
+ ReportOpenBug(C, state, SBuf.c_str(), Arg->getSourceRange());
return;
}
} else if (CE->getNumArgs() > MaxArgCount) {
@@ -215,8 +208,7 @@ void UnixAPIMisuseChecker::CheckOpenVariant(CheckerContext &C,
OS << "Call to '" << VariantName << "' with more than " << MaxArgCount
<< " arguments";
- ReportOpenBug(C, state,
- SBuf.c_str(),
+ ReportOpenBug(C, state, SBuf.c_str(),
CE->getArg(MaxArgCount)->getSourceRange());
return;
}
@@ -237,9 +229,8 @@ void UnixAPIMisuseChecker::CheckOpenVariant(CheckerContext &C,
NonLoc ocreateFlag = C.getSValBuilder()
.makeIntVal(*Val_O_CREAT, oflagsEx->getType())
.castAs<NonLoc>();
- SVal maskedFlagsUC = C.getSValBuilder().evalBinOpNN(state, BO_And,
- oflags, ocreateFlag,
- oflagsEx->getType());
+ SVal maskedFlagsUC = C.getSValBuilder().evalBinOpNN(
+ state, BO_And, oflags, ocreateFlag, oflagsEx->getType());
if (maskedFlagsUC.isUnknownOrUndef())
return;
DefinedSVal maskedFlags = maskedFlagsUC.castAs<DefinedSVal>();
@@ -260,9 +251,7 @@ void UnixAPIMisuseChecker::CheckOpenVariant(CheckerContext &C,
<< CreateModeArgIndex + 1
<< llvm::getOrdinalSuffix(CreateModeArgIndex + 1)
<< " argument when the 'O_CREAT' flag is set";
- ReportOpenBug(C, trueState,
- SBuf.c_str(),
- oflagsEx->getSourceRange());
+ ReportOpenBug(C, trueState, SBuf.c_str(), oflagsEx->getSourceRange());
}
}
@@ -271,7 +260,7 @@ void UnixAPIMisuseChecker::CheckOpenVariant(CheckerContext &C,
//===----------------------------------------------------------------------===//
void UnixAPIMisuseChecker::CheckPthreadOnce(CheckerContext &C,
- const CallExpr *CE) const {
+ const CallExpr *CE) const {
// This is similar to 'CheckDispatchOnce' in the MacOSXAPIChecker.
// They can possibly be refactored.
@@ -298,7 +287,7 @@ void UnixAPIMisuseChecker::CheckPthreadOnce(CheckerContext &C,
else
os << " stack allocated memory";
os << " for the \"control\" value. Using such transient memory for "
- "the control value is potentially dangerous.";
+ "the control value is potentially dangerous.";
if (isa<VarRegion>(R) && isa<StackLocalsSpaceRegion>(R->getMemorySpace()))
os << " Perhaps you intended to declare the variable as 'static'?";
@@ -313,17 +302,16 @@ void UnixAPIMisuseChecker::CheckPthreadOnce(CheckerContext &C,
// with allocation size 0
//===----------------------------------------------------------------------===//
-// FIXME: Eventually these should be rolled into the MallocChecker, but right now
-// they're more basic and valuable for widespread use.
+// FIXME: Eventually these should be rolled into the MallocChecker, but right
+// now they're more basic and valuable for widespread use.
// Returns true if we try to do a zero byte allocation, false otherwise.
// Fills in trueState and falseState.
-static bool IsZeroByteAllocation(ProgramStateRef state,
- const SVal argVal,
+static bool IsZeroByteAllocation(ProgramStateRef state, const SVal argVal,
ProgramStateRef *trueState,
ProgramStateRef *falseState) {
std::tie(*trueState, *falseState) =
- state->assume(argVal.castAs<DefinedSVal>());
+ state->assume(argVal.castAs<DefinedSVal>());
return (*falseState && !*trueState);
}
@@ -332,10 +320,8 @@ static bool IsZeroByteAllocation(ProgramStateRef state,
// will perform a zero byte allocation.
// Returns false if an error occurred, true otherwise.
bool UnixAPIPortabilityChecker::ReportZeroByteAllocation(
- CheckerContext &C,
- ProgramStateRef falseState,
- const Expr *arg,
- const char *fn_name) const {
+ CheckerContext &C, ProgramStateRef falseState, const Expr *arg,
+ const char *fn_name) const {
ExplodedNode *N = C.generateErrorNode(falseState);
if (!N)
return false;
@@ -375,7 +361,7 @@ void UnixAPIPortabilityChecker::BasicAllocationCheck(CheckerContext &C,
// Is the value perfectly constrained to zero?
if (IsZeroByteAllocation(state, argVal, &trueState, &falseState)) {
- (void) ReportZeroByteAllocation(C, falseState, arg, fn);
+ (void)ReportZeroByteAllocation(C, falseState, arg, fn);
return;
}
// Assume the value is non-zero going forward.
@@ -441,8 +427,7 @@ void UnixAPIPortabilityChecker::CheckAllocaZero(CheckerContext &C,
}
void UnixAPIPortabilityChecker::CheckAllocaWithAlignZero(
- CheckerContext &C,
- const CallExpr *CE) const {
+ CheckerContext &C, const CallExpr *CE) const {
BasicAllocationCheck(C, CE, 2, 0, "__builtin_alloca_with_align");
}
@@ -479,7 +464,7 @@ void UnixAPIPortabilityChecker::checkPreStmt(const CallExpr *CE,
else if (FName == "reallocf")
CheckReallocfZero(C, CE);
- else if (FName == "alloca" || FName == "__builtin_alloca")
+ else if (FName == "alloca" || FName == "__builtin_alloca")
CheckAllocaZero(C, CE);
else if (FName == "__builtin_alloca_with_align")
diff --git a/clang/lib/StaticAnalyzer/Checkers/UnreachableCodeChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/UnreachableCodeChecker.cpp
index d24a124f5ffee0..85ed19265ab2e4 100644
--- a/clang/lib/StaticAnalyzer/Checkers/UnreachableCodeChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/UnreachableCodeChecker.cpp
@@ -12,10 +12,10 @@
// A similar flow-sensitive only check exists in Analysis/ReachableCode.cpp
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/AST/ParentMap.h"
#include "clang/Basic/Builtins.h"
#include "clang/Basic/SourceManager.h"
+#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/CheckerManager.h"
@@ -34,6 +34,7 @@ class UnreachableCodeChecker : public Checker<check::EndAnalysis> {
public:
void checkEndAnalysis(ExplodedGraph &G, BugReporter &B,
ExprEngine &Eng) const;
+
private:
typedef llvm::SmallSet<unsigned, 32> CFGBlocksSet;
@@ -44,10 +45,9 @@ class UnreachableCodeChecker : public Checker<check::EndAnalysis> {
static bool isInvalidPath(const CFGBlock *CB, const ParentMap &PM);
static inline bool isEmptyCFGBlock(const CFGBlock *CB);
};
-}
+} // namespace
-void UnreachableCodeChecker::checkEndAnalysis(ExplodedGraph &G,
- BugReporter &B,
+void UnreachableCodeChecker::checkEndAnalysis(ExplodedGraph &G, BugReporter &B,
ExprEngine &Eng) const {
CFGBlocksSet reachable, visited;
@@ -126,8 +126,8 @@ void UnreachableCodeChecker::checkEndAnalysis(ExplodedGraph &G,
// such as llvm_unreachable.
if (!CB->empty()) {
bool foundUnreachable = false;
- for (CFGBlock::const_iterator ci = CB->begin(), ce = CB->end();
- ci != ce; ++ci) {
+ for (CFGBlock::const_iterator ci = CB->begin(), ce = CB->end(); ci != ce;
+ ++ci) {
if (std::optional<CFGStmt> S = (*ci).getAs<CFGStmt>())
if (const CallExpr *CE = dyn_cast<CallExpr>(S->getStmt())) {
if (CE->getBuiltinCallee() == Builtin::BI__builtin_unreachable ||
@@ -159,8 +159,7 @@ void UnreachableCodeChecker::checkEndAnalysis(ExplodedGraph &G,
SL = DL.asLocation();
if (SR.isInvalid() || !SL.isValid())
continue;
- }
- else
+ } else
continue;
// Check if the SourceLocation is in a system header
@@ -229,9 +228,9 @@ bool UnreachableCodeChecker::isInvalidPath(const CFGBlock *CB,
// Get the predecessor block's terminator condition
const Stmt *cond = pred->getTerminatorCondition();
- //assert(cond && "CFGBlock's predecessor has a terminator condition");
- // The previous assertion is invalid in some cases (eg do/while). Leaving
- // reporting of these situations on at the moment to help triage these cases.
+ // assert(cond && "CFGBlock's predecessor has a terminator condition");
+ // The previous assertion is invalid in some cases (eg do/while). Leaving
+ // reporting of these situations on at the moment to help triage these cases.
if (!cond)
return false;
@@ -243,9 +242,9 @@ bool UnreachableCodeChecker::isInvalidPath(const CFGBlock *CB,
// Returns true if the given CFGBlock is empty
bool UnreachableCodeChecker::isEmptyCFGBlock(const CFGBlock *CB) {
- return CB->getLabel() == nullptr // No labels
- && CB->size() == 0 // No statements
- && !CB->getTerminatorStmt(); // No terminator
+ return CB->getLabel() == nullptr // No labels
+ && CB->size() == 0 // No statements
+ && !CB->getTerminatorStmt(); // No terminator
}
void ento::registerUnreachableCodeChecker(CheckerManager &mgr) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp
index 2d1b873abf73f0..4e0af00b7554b8 100644
--- a/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp
@@ -404,9 +404,7 @@ void ento::registerValistBase(CheckerManager &mgr) {
mgr.registerChecker<ValistChecker>();
}
-bool ento::shouldRegisterValistBase(const CheckerManager &mgr) {
- return true;
-}
+bool ento::shouldRegisterValistBase(const CheckerManager &mgr) { return true; }
#define REGISTER_CHECKER(name) \
void ento::register##name##Checker(CheckerManager &mgr) { \
@@ -416,7 +414,7 @@ bool ento::shouldRegisterValistBase(const CheckerManager &mgr) {
mgr.getCurrentCheckerName(); \
} \
\
- bool ento::shouldRegister##name##Checker(const CheckerManager &mgr) { \
+ bool ento::shouldRegister##name##Checker(const CheckerManager &mgr) { \
return true; \
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp
index cb73ac68edd1ea..3a0a247a1464e7 100644
--- a/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp
@@ -24,17 +24,17 @@
//
//===----------------------------------------------------------------------===//
+#include "clang/AST/ParentMap.h"
#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 "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
-#include "clang/StaticAnalyzer/Core/Checker.h"
-#include "clang/StaticAnalyzer/Core/CheckerManager.h"
-#include "clang/AST/ParentMap.h"
#include <optional>
using namespace clang;
@@ -99,18 +99,8 @@ bool VforkChecker::isCallExplicitelyAllowed(const IdentifierInfo *II,
CheckerContext &C) const {
if (VforkAllowlist.empty()) {
// According to manpage.
- const char *ids[] = {
- "_Exit",
- "_exit",
- "execl",
- "execle",
- "execlp",
- "execv",
- "execve",
- "execvp",
- "execvpe",
- nullptr
- };
+ const char *ids[] = {"_Exit", "_exit", "execl", "execle", "execlp",
+ "execv", "execve", "execvp", "execvpe", nullptr};
ASTContext &AC = C.getASTContext();
for (const char **id = ids; *id; ++id)
@@ -165,9 +155,8 @@ void VforkChecker::checkPostCall(const CallEvent &Call,
// Get assigned memory region.
MemRegionManager &M = C.getStoreManager().getRegionManager();
const MemRegion *LhsDeclReg =
- LhsDecl
- ? M.getVarRegion(LhsDecl, C.getLocationContext())
- : (const MemRegion *)VFORK_RESULT_NONE;
+ LhsDecl ? M.getVarRegion(LhsDecl, C.getLocationContext())
+ : (const MemRegion *)VFORK_RESULT_NONE;
// Parent branch gets nonzero return value (according to manpage).
ProgramStateRef ParentState, ChildState;
@@ -195,7 +184,7 @@ void VforkChecker::checkBind(SVal L, SVal V, const Stmt *S,
return;
const MemRegion *VforkLhs =
- static_cast<const MemRegion *>(State->get<VforkResultRegion>());
+ static_cast<const MemRegion *>(State->get<VforkResultRegion>());
const MemRegion *MR = L.getAsRegion();
// Child is allowed to modify only vfork's lhs.
diff --git a/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp
index 33a9a07f9d32d1..7ac02c725ba880 100644
--- a/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp
@@ -174,8 +174,7 @@ void VirtualCallChecker::registerCtorDtorCallInState(bool IsBeginFunction,
// Enter a constructor, set the corresponding memregion be true.
if (isa<CXXConstructorDecl>(MD)) {
- auto ThiSVal =
- State->getSVal(SVB.getCXXThis(MD, LCtx->getStackFrame()));
+ auto ThiSVal = State->getSVal(SVB.getCXXThis(MD, LCtx->getStackFrame()));
const MemRegion *Reg = ThiSVal.getAsRegion();
if (IsBeginFunction)
State = State->set<CtorDtorMap>(Reg, ObjectState::CtorCalled);
@@ -188,8 +187,7 @@ void VirtualCallChecker::registerCtorDtorCallInState(bool IsBeginFunction,
// Enter a Destructor, set the corresponding memregion be true.
if (isa<CXXDestructorDecl>(MD)) {
- auto ThiSVal =
- State->getSVal(SVB.getCXXThis(MD, LCtx->getStackFrame()));
+ auto ThiSVal = State->getSVal(SVB.getCXXThis(MD, LCtx->getStackFrame()));
const MemRegion *Reg = ThiSVal.getAsRegion();
if (IsBeginFunction)
State = State->set<CtorDtorMap>(Reg, ObjectState::DtorCalled);
diff --git a/clang/lib/StaticAnalyzer/Checkers/WebKit/NoUncountedMembersChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/WebKit/NoUncountedMembersChecker.cpp
index c753ed84a700cd..71f61f6839a0c5 100644
--- a/clang/lib/StaticAnalyzer/Checkers/WebKit/NoUncountedMembersChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/WebKit/NoUncountedMembersChecker.cpp
@@ -77,9 +77,9 @@ class NoUncountedMemberChecker
if (auto *MemberCXXRD = MemberType->getPointeeCXXRecordDecl()) {
// If we don't see the definition we just don't know.
if (MemberCXXRD->hasDefinition()) {
- std::optional<bool> isRCAble = isRefCountable(MemberCXXRD);
- if (isRCAble && *isRCAble)
- reportBug(Member, MemberType, MemberCXXRD, RD);
+ std::optional<bool> isRCAble = isRefCountable(MemberCXXRD);
+ if (isRCAble && *isRCAble)
+ reportBug(Member, MemberType, MemberCXXRD, RD);
}
}
}
@@ -152,7 +152,6 @@ void ento::registerNoUncountedMemberChecker(CheckerManager &Mgr) {
Mgr.registerChecker<NoUncountedMemberChecker>();
}
-bool ento::shouldRegisterNoUncountedMemberChecker(
- const CheckerManager &Mgr) {
+bool ento::shouldRegisterNoUncountedMemberChecker(const CheckerManager &Mgr) {
return true;
}
diff --git a/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.cpp b/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.cpp
index defd83ec8e179c..43d6e099a56bb0 100644
--- a/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.cpp
@@ -53,8 +53,7 @@ hasPublicMethodInBase(const CXXBaseSpecifier *Base, const char *NameToMatch) {
return hasPublicMethodInBaseClass(R, NameToMatch) ? R : nullptr;
}
-std::optional<bool> isRefCountable(const CXXRecordDecl* R)
-{
+std::optional<bool> isRefCountable(const CXXRecordDecl *R) {
assert(R);
R = R->getDefinition();
@@ -143,8 +142,7 @@ bool isReturnValueRefCounted(const clang::FunctionDecl *F) {
return false;
}
-std::optional<bool> isUncounted(const CXXRecordDecl* Class)
-{
+std::optional<bool> isUncounted(const CXXRecordDecl *Class) {
// Keep isRefCounted first as it's cheaper.
if (isRefCounted(Class))
return false;
@@ -156,8 +154,7 @@ std::optional<bool> isUncounted(const CXXRecordDecl* Class)
return (*IsRefCountable);
}
-std::optional<bool> isUncountedPtr(const Type* T)
-{
+std::optional<bool> isUncountedPtr(const Type *T) {
assert(T);
if (T->isPointerType() || T->isReferenceType()) {
@@ -168,8 +165,7 @@ std::optional<bool> isUncountedPtr(const Type* T)
return false;
}
-std::optional<bool> isGetterOfRefCounted(const CXXMethodDecl* M)
-{
+std::optional<bool> isGetterOfRefCounted(const CXXMethodDecl *M) {
assert(M);
if (isa<CXXMethodDecl>(M)) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.h b/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.h
index e07cd31395747d..3e71a162d3f29e 100644
--- a/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.h
+++ b/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.h
@@ -35,18 +35,18 @@ hasPublicMethodInBase(const CXXBaseSpecifier *Base, const char *NameToMatch);
/// \returns true if \p Class is ref-countable, false if not, std::nullopt if
/// inconclusive.
-std::optional<bool> isRefCountable(const clang::CXXRecordDecl* Class);
+std::optional<bool> isRefCountable(const clang::CXXRecordDecl *Class);
/// \returns true if \p Class is ref-counted, false if not.
bool isRefCounted(const clang::CXXRecordDecl *Class);
/// \returns true if \p Class is ref-countable AND not ref-counted, false if
/// not, std::nullopt if inconclusive.
-std::optional<bool> isUncounted(const clang::CXXRecordDecl* Class);
+std::optional<bool> isUncounted(const clang::CXXRecordDecl *Class);
/// \returns true if \p T is either a raw pointer or reference to an uncounted
/// class, false if not, std::nullopt if inconclusive.
-std::optional<bool> isUncountedPtr(const clang::Type* T);
+std::optional<bool> isUncountedPtr(const clang::Type *T);
/// \returns true if \p F creates ref-countable object from uncounted parameter,
/// false if not.
@@ -56,7 +56,7 @@ bool isCtorOfRefCounted(const clang::FunctionDecl *F);
bool isReturnValueRefCounted(const clang::FunctionDecl *F);
/// \returns true if \p M is getter of a ref-counted class, false if not.
-std::optional<bool> isGetterOfRefCounted(const clang::CXXMethodDecl* Method);
+std::optional<bool> isGetterOfRefCounted(const clang::CXXMethodDecl *Method);
/// \returns true if \p F is a conversion between ref-countable or ref-counted
/// pointer types.
diff --git a/clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedCallArgsChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedCallArgsChecker.cpp
index 8b41a949fd6734..d9bc1cadf25fdd 100644
--- a/clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedCallArgsChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedCallArgsChecker.cpp
@@ -28,14 +28,13 @@ namespace {
class UncountedCallArgsChecker
: public Checker<check::ASTDecl<TranslationUnitDecl>> {
BugType Bug{this,
- "Uncounted call argument for a raw pointer/reference parameter",
- "WebKit coding guidelines"};
+ "Uncounted call argument for a raw pointer/reference parameter",
+ "WebKit coding guidelines"};
mutable BugReporter *BR;
TrivialFunctionAnalysis TFA;
public:
-
void checkASTDecl(const TranslationUnitDecl *TUD, AnalysisManager &MGR,
BugReporter &BRArg) const {
BR = &BRArg;
@@ -70,7 +69,8 @@ class UncountedCallArgsChecker
if (auto *F = CE->getDirectCallee()) {
// Skip the first argument for overloaded member operators (e. g. lambda
// or std::function call operator).
- unsigned ArgIdx = isa<CXXOperatorCallExpr>(CE) && isa_and_nonnull<CXXMethodDecl>(F);
+ unsigned ArgIdx =
+ isa<CXXOperatorCallExpr>(CE) && isa_and_nonnull<CXXMethodDecl>(F);
if (auto *MemberCallExpr = dyn_cast<CXXMemberCallExpr>(CE)) {
if (auto *MD = MemberCallExpr->getMethodDecl()) {
diff --git a/clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedLambdaCapturesChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedLambdaCapturesChecker.cpp
index a226a01ec0a579..54e3615618ea8f 100644
--- a/clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedLambdaCapturesChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedLambdaCapturesChecker.cpp
@@ -60,10 +60,10 @@ class UncountedLambdaCapturesChecker
if (C.capturesVariable()) {
ValueDecl *CapturedVar = C.getCapturedVar();
if (auto *CapturedVarType = CapturedVar->getType().getTypePtrOrNull()) {
- std::optional<bool> IsUncountedPtr = isUncountedPtr(CapturedVarType);
- if (IsUncountedPtr && *IsUncountedPtr) {
- reportBug(C, CapturedVar, CapturedVarType);
- }
+ std::optional<bool> IsUncountedPtr = isUncountedPtr(CapturedVarType);
+ if (IsUncountedPtr && *IsUncountedPtr) {
+ reportBug(C, CapturedVar, CapturedVarType);
+ }
}
}
}
diff --git a/clang/lib/StaticAnalyzer/Core/APSIntType.cpp b/clang/lib/StaticAnalyzer/Core/APSIntType.cpp
index 1185cdaa044a5f..02c57b7b1ec645 100644
--- a/clang/lib/StaticAnalyzer/Core/APSIntType.cpp
+++ b/clang/lib/StaticAnalyzer/Core/APSIntType.cpp
@@ -16,8 +16,8 @@ APSIntType::testInRange(const llvm::APSInt &Value,
bool AllowSignConversions) const {
// Negative numbers cannot be losslessly converted to unsigned type.
- if (IsUnsigned && !AllowSignConversions &&
- Value.isSigned() && Value.isNegative())
+ if (IsUnsigned && !AllowSignConversions && Value.isSigned() &&
+ Value.isNegative())
return RTR_Below;
unsigned MinBits;
diff --git a/clang/lib/StaticAnalyzer/Core/AnalysisManager.cpp b/clang/lib/StaticAnalyzer/Core/AnalysisManager.cpp
index f9750db7b50170..42aa80b08ece92 100644
--- a/clang/lib/StaticAnalyzer/Core/AnalysisManager.cpp
+++ b/clang/lib/StaticAnalyzer/Core/AnalysisManager.cpp
@@ -11,7 +11,7 @@
using namespace clang;
using namespace ento;
-void AnalysisManager::anchor() { }
+void AnalysisManager::anchor() {}
AnalysisManager::AnalysisManager(ASTContext &ASTCtx, Preprocessor &PP,
const PathDiagnosticConsumers &PDC,
@@ -23,25 +23,20 @@ AnalysisManager::AnalysisManager(ASTContext &ASTCtx, Preprocessor &PP,
: AnaCtxMgr(
ASTCtx, Options.UnoptimizedCFG,
Options.ShouldIncludeImplicitDtorsInCFG,
- /*addInitializers=*/true,
- Options.ShouldIncludeTemporaryDtorsInCFG,
+ /*addInitializers=*/true, Options.ShouldIncludeTemporaryDtorsInCFG,
Options.ShouldIncludeLifetimeInCFG,
// Adding LoopExit elements to the CFG is a requirement for loop
// unrolling.
- Options.ShouldIncludeLoopExitInCFG ||
- Options.ShouldUnrollLoops,
- Options.ShouldIncludeScopesInCFG,
- Options.ShouldSynthesizeBodies,
+ Options.ShouldIncludeLoopExitInCFG || Options.ShouldUnrollLoops,
+ Options.ShouldIncludeScopesInCFG, Options.ShouldSynthesizeBodies,
Options.ShouldConditionalizeStaticInitializers,
/*addCXXNewAllocator=*/true,
Options.ShouldIncludeRichConstructorsInCFG,
Options.ShouldElideConstructors,
- /*addVirtualBaseBranches=*/true,
- injector),
- Ctx(ASTCtx), PP(PP), LangOpts(ASTCtx.getLangOpts()),
- PathConsumers(PDC), CreateStoreMgr(storemgr),
- CreateConstraintMgr(constraintmgr), CheckerMgr(checkerMgr),
- options(Options) {
+ /*addVirtualBaseBranches=*/true, injector),
+ Ctx(ASTCtx), PP(PP), LangOpts(ASTCtx.getLangOpts()), PathConsumers(PDC),
+ CreateStoreMgr(storemgr), CreateConstraintMgr(constraintmgr),
+ CheckerMgr(checkerMgr), options(Options) {
AnaCtxMgr.getCFGBuildOptions().setAllAlwaysAdd();
AnaCtxMgr.getCFGBuildOptions().OmitImplicitValueInitializers = true;
AnaCtxMgr.getCFGBuildOptions().AddCXXDefaultInitExprInAggregates =
diff --git a/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp b/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp
index 86ef4a56866504..1c61a957234b71 100644
--- a/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp
+++ b/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp
@@ -14,8 +14,8 @@
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FileSystem.h"
@@ -32,8 +32,7 @@ using namespace ento;
using namespace llvm;
void AnalyzerOptions::printFormattedEntry(
- llvm::raw_ostream &Out,
- std::pair<StringRef, StringRef> EntryDescPair,
+ llvm::raw_ostream &Out, std::pair<StringRef, StringRef> EntryDescPair,
size_t InitialPad, size_t EntryWidth, size_t MinLineWidth) {
llvm::formatted_raw_ostream FOut(Out);
@@ -62,8 +61,7 @@ void AnalyzerOptions::printFormattedEntry(
}
}
-ExplorationStrategyKind
-AnalyzerOptions::getExplorationStrategy() const {
+ExplorationStrategyKind AnalyzerOptions::getExplorationStrategy() const {
auto K =
llvm::StringSwitch<std::optional<ExplorationStrategyKind>>(
ExplorationStrategy)
@@ -105,9 +103,8 @@ IPAKind AnalyzerOptions::getIPAMode() const {
return *K;
}
-bool
-AnalyzerOptions::mayInlineCXXMemberFunction(
- CXXInlineableMemberKind Param) const {
+bool AnalyzerOptions::mayInlineCXXMemberFunction(
+ CXXInlineableMemberKind Param) const {
if (getIPAMode() < IPAK_Inlining)
return false;
@@ -154,8 +151,8 @@ StringRef AnalyzerOptions::getCheckerStringOption(StringRef CheckerName,
StringRef AnalyzerOptions::getCheckerStringOption(const ento::CheckerBase *C,
StringRef OptionName,
bool SearchInParents) const {
- return getCheckerStringOption(
- C->getTagDescription(), OptionName, SearchInParents);
+ return getCheckerStringOption(C->getTagDescription(), OptionName,
+ SearchInParents);
}
bool AnalyzerOptions::getCheckerBooleanOption(StringRef CheckerName,
@@ -178,17 +175,17 @@ bool AnalyzerOptions::getCheckerBooleanOption(StringRef CheckerName,
bool AnalyzerOptions::getCheckerBooleanOption(const ento::CheckerBase *C,
StringRef OptionName,
bool SearchInParents) const {
- return getCheckerBooleanOption(
- C->getTagDescription(), OptionName, SearchInParents);
+ return getCheckerBooleanOption(C->getTagDescription(), OptionName,
+ SearchInParents);
}
int AnalyzerOptions::getCheckerIntegerOption(StringRef CheckerName,
StringRef OptionName,
bool SearchInParents) const {
int Ret = 0;
- bool HasFailed = getCheckerStringOption(CheckerName, OptionName,
- SearchInParents)
- .getAsInteger(0, Ret);
+ bool HasFailed =
+ getCheckerStringOption(CheckerName, OptionName, SearchInParents)
+ .getAsInteger(0, Ret);
assert(!HasFailed &&
"This option should be numeric, and should've been validated by "
"CheckerRegistry!");
@@ -199,6 +196,6 @@ int AnalyzerOptions::getCheckerIntegerOption(StringRef CheckerName,
int AnalyzerOptions::getCheckerIntegerOption(const ento::CheckerBase *C,
StringRef OptionName,
bool SearchInParents) const {
- return getCheckerIntegerOption(
- C->getTagDescription(), OptionName, SearchInParents);
+ return getCheckerIntegerOption(C->getTagDescription(), OptionName,
+ SearchInParents);
}
diff --git a/clang/lib/StaticAnalyzer/Core/BasicValueFactory.cpp b/clang/lib/StaticAnalyzer/Core/BasicValueFactory.cpp
index 5c10e757244d7f..17bd5cebd1eedf 100644
--- a/clang/lib/StaticAnalyzer/Core/BasicValueFactory.cpp
+++ b/clang/lib/StaticAnalyzer/Core/BasicValueFactory.cpp
@@ -29,13 +29,13 @@
using namespace clang;
using namespace ento;
-void CompoundValData::Profile(llvm::FoldingSetNodeID& ID, QualType T,
+void CompoundValData::Profile(llvm::FoldingSetNodeID &ID, QualType T,
llvm::ImmutableList<SVal> L) {
T.Profile(ID);
ID.AddPointer(L.getInternalPointer());
}
-void LazyCompoundValData::Profile(llvm::FoldingSetNodeID& ID,
+void LazyCompoundValData::Profile(llvm::FoldingSetNodeID &ID,
const StoreRef &store,
const TypedValueRegion *region) {
ID.AddPointer(store.getStore());
@@ -54,15 +54,15 @@ using SValPair = std::pair<SVal, SVal>;
namespace llvm {
-template<> struct FoldingSetTrait<SValData> {
- static inline void Profile(const SValData& X, llvm::FoldingSetNodeID& ID) {
+template <> struct FoldingSetTrait<SValData> {
+ static inline void Profile(const SValData &X, llvm::FoldingSetNodeID &ID) {
X.first.Profile(ID);
- ID.AddPointer( (void*) X.second);
+ ID.AddPointer((void *)X.second);
}
};
-template<> struct FoldingSetTrait<SValPair> {
- static inline void Profile(const SValPair& X, llvm::FoldingSetNodeID& ID) {
+template <> struct FoldingSetTrait<SValPair> {
+ static inline void Profile(const SValPair &X, llvm::FoldingSetNodeID &ID) {
X.first.Profile(ID);
X.second.Profile(ID);
}
@@ -83,18 +83,18 @@ BasicValueFactory::~BasicValueFactory() {
for (const auto &I : APSIntSet)
I.getValue().~APSInt();
- delete (PersistentSValsTy*) PersistentSVals;
- delete (PersistentSValPairsTy*) PersistentSValPairs;
+ delete (PersistentSValsTy *)PersistentSVals;
+ delete (PersistentSValPairsTy *)PersistentSValPairs;
}
-const llvm::APSInt& BasicValueFactory::getValue(const llvm::APSInt& X) {
+const llvm::APSInt &BasicValueFactory::getValue(const llvm::APSInt &X) {
llvm::FoldingSetNodeID ID;
void *InsertPos;
using FoldNodeTy = llvm::FoldingSetNodeWrapper<llvm::APSInt>;
X.Profile(ID);
- FoldNodeTy* P = APSIntSet.FindNodeOrInsertPos(ID, InsertPos);
+ FoldNodeTy *P = APSIntSet.FindNodeOrInsertPos(ID, InsertPos);
if (!P) {
P = new (BPAlloc) FoldNodeTy(X);
@@ -104,31 +104,31 @@ const llvm::APSInt& BasicValueFactory::getValue(const llvm::APSInt& X) {
return *P;
}
-const llvm::APSInt& BasicValueFactory::getValue(const llvm::APInt& X,
+const llvm::APSInt &BasicValueFactory::getValue(const llvm::APInt &X,
bool isUnsigned) {
llvm::APSInt V(X, isUnsigned);
return getValue(V);
}
-const llvm::APSInt& BasicValueFactory::getValue(uint64_t X, unsigned BitWidth,
- bool isUnsigned) {
+const llvm::APSInt &BasicValueFactory::getValue(uint64_t X, unsigned BitWidth,
+ bool isUnsigned) {
llvm::APSInt V(BitWidth, isUnsigned);
V = X;
return getValue(V);
}
-const llvm::APSInt& BasicValueFactory::getValue(uint64_t X, QualType T) {
+const llvm::APSInt &BasicValueFactory::getValue(uint64_t X, QualType T) {
return getValue(getAPSIntType(T).getValue(X));
}
-const CompoundValData*
+const CompoundValData *
BasicValueFactory::getCompoundValData(QualType T,
llvm::ImmutableList<SVal> Vals) {
llvm::FoldingSetNodeID ID;
CompoundValData::Profile(ID, T, Vals);
void *InsertPos;
- CompoundValData* D = CompoundValDataSet.FindNodeOrInsertPos(ID, InsertPos);
+ CompoundValData *D = CompoundValDataSet.FindNodeOrInsertPos(ID, InsertPos);
if (!D) {
D = new (BPAlloc) CompoundValData(T, Vals);
@@ -138,7 +138,7 @@ BasicValueFactory::getCompoundValData(QualType T,
return D;
}
-const LazyCompoundValData*
+const LazyCompoundValData *
BasicValueFactory::getLazyCompoundValData(const StoreRef &store,
const TypedValueRegion *region) {
llvm::FoldingSetNodeID ID;
@@ -146,7 +146,7 @@ BasicValueFactory::getLazyCompoundValData(const StoreRef &store,
void *InsertPos;
LazyCompoundValData *D =
- LazyCompoundValDataSet.FindNodeOrInsertPos(ID, InsertPos);
+ LazyCompoundValDataSet.FindNodeOrInsertPos(ID, InsertPos);
if (!D) {
D = new (BPAlloc) LazyCompoundValData(store, region);
@@ -242,108 +242,109 @@ const PointerToMemberData *BasicValueFactory::accumCXXBase(
return getPointerToMemberData(ND, BaseSpecList);
}
-const llvm::APSInt*
-BasicValueFactory::evalAPSInt(BinaryOperator::Opcode Op,
- const llvm::APSInt& V1, const llvm::APSInt& V2) {
+const llvm::APSInt *BasicValueFactory::evalAPSInt(BinaryOperator::Opcode Op,
+ const llvm::APSInt &V1,
+ const llvm::APSInt &V2) {
switch (Op) {
- default:
- llvm_unreachable("Invalid Opcode.");
+ default:
+ llvm_unreachable("Invalid Opcode.");
- case BO_Mul:
- return &getValue( V1 * V2 );
+ case BO_Mul:
+ return &getValue(V1 * V2);
- case BO_Div:
- if (V2 == 0) // Avoid division by zero
- return nullptr;
- return &getValue( V1 / V2 );
+ case BO_Div:
+ if (V2 == 0) // Avoid division by zero
+ return nullptr;
+ return &getValue(V1 / V2);
- case BO_Rem:
- if (V2 == 0) // Avoid division by zero
- return nullptr;
- return &getValue( V1 % V2 );
+ case BO_Rem:
+ if (V2 == 0) // Avoid division by zero
+ return nullptr;
+ return &getValue(V1 % V2);
- case BO_Add:
- return &getValue( V1 + V2 );
+ case BO_Add:
+ return &getValue(V1 + V2);
- case BO_Sub:
- return &getValue( V1 - V2 );
+ case BO_Sub:
+ return &getValue(V1 - V2);
- case BO_Shl: {
- // FIXME: This logic should probably go higher up, where we can
- // test these conditions symbolically.
+ case BO_Shl: {
+ // FIXME: This logic should probably go higher up, where we can
+ // test these conditions symbolically.
- if (V2.isNegative() || V2.getBitWidth() > 64)
- return nullptr;
+ if (V2.isNegative() || V2.getBitWidth() > 64)
+ return nullptr;
- uint64_t Amt = V2.getZExtValue();
+ uint64_t Amt = V2.getZExtValue();
- if (Amt >= V1.getBitWidth())
- return nullptr;
+ if (Amt >= V1.getBitWidth())
+ return nullptr;
- return &getValue( V1.operator<<( (unsigned) Amt ));
- }
+ return &getValue(V1.operator<<((unsigned)Amt));
+ }
- case BO_Shr: {
- // FIXME: This logic should probably go higher up, where we can
- // test these conditions symbolically.
+ case BO_Shr: {
+ // FIXME: This logic should probably go higher up, where we can
+ // test these conditions symbolically.
- if (V2.isNegative() || V2.getBitWidth() > 64)
- return nullptr;
+ if (V2.isNegative() || V2.getBitWidth() > 64)
+ return nullptr;
- uint64_t Amt = V2.getZExtValue();
+ uint64_t Amt = V2.getZExtValue();
- if (Amt >= V1.getBitWidth())
- return nullptr;
+ if (Amt >= V1.getBitWidth())
+ return nullptr;
- return &getValue( V1.operator>>( (unsigned) Amt ));
- }
+ return &getValue(V1.operator>>((unsigned)Amt));
+ }
- case BO_LT:
- return &getTruthValue( V1 < V2 );
+ case BO_LT:
+ return &getTruthValue(V1 < V2);
- case BO_GT:
- return &getTruthValue( V1 > V2 );
+ case BO_GT:
+ return &getTruthValue(V1 > V2);
- case BO_LE:
- return &getTruthValue( V1 <= V2 );
+ case BO_LE:
+ return &getTruthValue(V1 <= V2);
- case BO_GE:
- return &getTruthValue( V1 >= V2 );
+ case BO_GE:
+ return &getTruthValue(V1 >= V2);
- case BO_EQ:
- return &getTruthValue( V1 == V2 );
+ case BO_EQ:
+ return &getTruthValue(V1 == V2);
- case BO_NE:
- return &getTruthValue( V1 != V2 );
+ case BO_NE:
+ return &getTruthValue(V1 != V2);
- // Note: LAnd, LOr, Comma are handled specially by higher-level logic.
+ // Note: LAnd, LOr, Comma are handled specially by higher-level logic.
- case BO_And:
- return &getValue( V1 & V2 );
+ case BO_And:
+ return &getValue(V1 & V2);
- case BO_Or:
- return &getValue( V1 | V2 );
+ case BO_Or:
+ return &getValue(V1 | V2);
- case BO_Xor:
- return &getValue( V1 ^ V2 );
+ case BO_Xor:
+ return &getValue(V1 ^ V2);
}
}
-const std::pair<SVal, uintptr_t>&
-BasicValueFactory::getPersistentSValWithData(const SVal& V, uintptr_t Data) {
+const std::pair<SVal, uintptr_t> &
+BasicValueFactory::getPersistentSValWithData(const SVal &V, uintptr_t Data) {
// Lazily create the folding set.
- if (!PersistentSVals) PersistentSVals = new PersistentSValsTy();
+ if (!PersistentSVals)
+ PersistentSVals = new PersistentSValsTy();
llvm::FoldingSetNodeID ID;
void *InsertPos;
V.Profile(ID);
- ID.AddPointer((void*) Data);
+ ID.AddPointer((void *)Data);
- PersistentSValsTy& Map = *((PersistentSValsTy*) PersistentSVals);
+ PersistentSValsTy &Map = *((PersistentSValsTy *)PersistentSVals);
using FoldNodeTy = llvm::FoldingSetNodeWrapper<SValData>;
- FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos);
+ FoldNodeTy *P = Map.FindNodeOrInsertPos(ID, InsertPos);
if (!P) {
P = new (BPAlloc) FoldNodeTy(std::make_pair(V, Data));
@@ -353,21 +354,22 @@ BasicValueFactory::getPersistentSValWithData(const SVal& V, uintptr_t Data) {
return P->getValue();
}
-const std::pair<SVal, SVal>&
-BasicValueFactory::getPersistentSValPair(const SVal& V1, const SVal& V2) {
+const std::pair<SVal, SVal> &
+BasicValueFactory::getPersistentSValPair(const SVal &V1, const SVal &V2) {
// Lazily create the folding set.
- if (!PersistentSValPairs) PersistentSValPairs = new PersistentSValPairsTy();
+ if (!PersistentSValPairs)
+ PersistentSValPairs = new PersistentSValPairsTy();
llvm::FoldingSetNodeID ID;
void *InsertPos;
V1.Profile(ID);
V2.Profile(ID);
- PersistentSValPairsTy& Map = *((PersistentSValPairsTy*) PersistentSValPairs);
+ PersistentSValPairsTy &Map = *((PersistentSValPairsTy *)PersistentSValPairs);
using FoldNodeTy = llvm::FoldingSetNodeWrapper<SValPair>;
- FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos);
+ FoldNodeTy *P = Map.FindNodeOrInsertPos(ID, InsertPos);
if (!P) {
P = new (BPAlloc) FoldNodeTy(std::make_pair(V1, V2));
@@ -377,6 +379,6 @@ BasicValueFactory::getPersistentSValPair(const SVal& V1, const SVal& V2) {
return P->getValue();
}
-const SVal* BasicValueFactory::getPersistentSVal(SVal X) {
+const SVal *BasicValueFactory::getPersistentSVal(SVal X) {
return &getPersistentSValWithData(X, 0).first;
}
diff --git a/clang/lib/StaticAnalyzer/Core/BlockCounter.cpp b/clang/lib/StaticAnalyzer/Core/BlockCounter.cpp
index e7ac6f1cfa001f..04d6063104f6d5 100644
--- a/clang/lib/StaticAnalyzer/Core/BlockCounter.cpp
+++ b/clang/lib/StaticAnalyzer/Core/BlockCounter.cpp
@@ -26,7 +26,7 @@ class CountKey {
public:
CountKey(const StackFrameContext *CS, unsigned ID)
- : CallSite(CS), BlockID(ID) {}
+ : CallSite(CS), BlockID(ID) {}
bool operator==(const CountKey &RHS) const {
return (CallSite == RHS.CallSite) && (BlockID == RHS.BlockID);
@@ -42,43 +42,41 @@ class CountKey {
}
};
-}
+} // namespace
typedef llvm::ImmutableMap<CountKey, unsigned> CountMap;
static inline CountMap GetMap(void *D) {
- return CountMap(static_cast<CountMap::TreeTy*>(D));
+ return CountMap(static_cast<CountMap::TreeTy *>(D));
}
-static inline CountMap::Factory& GetFactory(void *F) {
- return *static_cast<CountMap::Factory*>(F);
+static inline CountMap::Factory &GetFactory(void *F) {
+ return *static_cast<CountMap::Factory *>(F);
}
unsigned BlockCounter::getNumVisited(const StackFrameContext *CallSite,
- unsigned BlockID) const {
+ unsigned BlockID) const {
CountMap M = GetMap(Data);
- CountMap::data_type* T = M.lookup(CountKey(CallSite, BlockID));
+ CountMap::data_type *T = M.lookup(CountKey(CallSite, BlockID));
return T ? *T : 0;
}
-BlockCounter::Factory::Factory(llvm::BumpPtrAllocator& Alloc) {
+BlockCounter::Factory::Factory(llvm::BumpPtrAllocator &Alloc) {
F = new CountMap::Factory(Alloc);
}
BlockCounter::Factory::~Factory() {
- delete static_cast<CountMap::Factory*>(F);
+ delete static_cast<CountMap::Factory *>(F);
}
-BlockCounter
-BlockCounter::Factory::IncrementCount(BlockCounter BC,
- const StackFrameContext *CallSite,
- unsigned BlockID) {
- return BlockCounter(GetFactory(F).add(GetMap(BC.Data),
- CountKey(CallSite, BlockID),
- BC.getNumVisited(CallSite, BlockID)+1).getRoot());
+BlockCounter BlockCounter::Factory::IncrementCount(
+ BlockCounter BC, const StackFrameContext *CallSite, unsigned BlockID) {
+ return BlockCounter(GetFactory(F)
+ .add(GetMap(BC.Data), CountKey(CallSite, BlockID),
+ BC.getNumVisited(CallSite, BlockID) + 1)
+ .getRoot());
}
-BlockCounter
-BlockCounter::Factory::GetEmptyCounter() {
+BlockCounter BlockCounter::Factory::GetEmptyCounter() {
return BlockCounter(GetFactory(F).getEmptyMap().getRoot());
}
diff --git a/clang/lib/StaticAnalyzer/Core/BugReporter.cpp b/clang/lib/StaticAnalyzer/Core/BugReporter.cpp
index 3617fdd778e3ca..5fe7d6f0dbc7c1 100644
--- a/clang/lib/StaticAnalyzer/Core/BugReporter.cpp
+++ b/clang/lib/StaticAnalyzer/Core/BugReporter.cpp
@@ -285,7 +285,7 @@ class PathDiagnosticBuilder : public BugReporterContext {
StackHintGenerator::~StackHintGenerator() = default;
-std::string StackHintGeneratorForSymbol::getMessage(const ExplodedNode *N){
+std::string StackHintGeneratorForSymbol::getMessage(const ExplodedNode *N) {
if (!N)
return getMessageForSymbolNotFound();
@@ -337,7 +337,8 @@ std::string StackHintGeneratorForSymbol::getMessageForArg(const Expr *ArgE,
++ArgIndex;
return (llvm::Twine(Msg) + " via " + std::to_string(ArgIndex) +
- llvm::getOrdinalSuffix(ArgIndex) + " parameter").str();
+ llvm::getOrdinalSuffix(ArgIndex) + " parameter")
+ .str();
}
//===----------------------------------------------------------------------===//
@@ -384,35 +385,34 @@ static void removeRedundantMsgs(PathPieces &path) {
path.pop_front();
switch (piece->getKind()) {
- case PathDiagnosticPiece::Call:
- removeRedundantMsgs(cast<PathDiagnosticCallPiece>(*piece).path);
- break;
- case PathDiagnosticPiece::Macro:
- removeRedundantMsgs(cast<PathDiagnosticMacroPiece>(*piece).subPieces);
+ case PathDiagnosticPiece::Call:
+ removeRedundantMsgs(cast<PathDiagnosticCallPiece>(*piece).path);
+ break;
+ case PathDiagnosticPiece::Macro:
+ removeRedundantMsgs(cast<PathDiagnosticMacroPiece>(*piece).subPieces);
+ break;
+ case PathDiagnosticPiece::Event: {
+ if (i == N - 1)
break;
- case PathDiagnosticPiece::Event: {
- if (i == N-1)
- break;
- if (auto *nextEvent =
- dyn_cast<PathDiagnosticEventPiece>(path.front().get())) {
- auto *event = cast<PathDiagnosticEventPiece>(piece.get());
- // Check to see if we should keep one of the two pieces. If we
- // come up with a preference, record which piece to keep, and consume
- // another piece from the path.
- if (auto *pieceToKeep =
- eventsDescribeSameCondition(event, nextEvent)) {
- piece = std::move(pieceToKeep == event ? piece : path.front());
- path.pop_front();
- ++i;
- }
+ if (auto *nextEvent =
+ dyn_cast<PathDiagnosticEventPiece>(path.front().get())) {
+ auto *event = cast<PathDiagnosticEventPiece>(piece.get());
+ // Check to see if we should keep one of the two pieces. If we
+ // come up with a preference, record which piece to keep, and consume
+ // another piece from the path.
+ if (auto *pieceToKeep = eventsDescribeSameCondition(event, nextEvent)) {
+ piece = std::move(pieceToKeep == event ? piece : path.front());
+ path.pop_front();
+ ++i;
}
- break;
}
- case PathDiagnosticPiece::ControlFlow:
- case PathDiagnosticPiece::Note:
- case PathDiagnosticPiece::PopUp:
- break;
+ break;
+ }
+ case PathDiagnosticPiece::ControlFlow:
+ case PathDiagnosticPiece::Note:
+ case PathDiagnosticPiece::PopUp:
+ break;
}
path.push_back(std::move(piece));
}
@@ -428,43 +428,43 @@ static bool removeUnneededCalls(const PathDiagnosticConstruct &C,
bool containsSomethingInteresting = IsInteresting;
const unsigned N = pieces.size();
- for (unsigned i = 0 ; i < N ; ++i) {
+ for (unsigned i = 0; i < N; ++i) {
// Remove the front piece from the path. If it is still something we
// want to keep once we are done, we will push it back on the end.
auto piece = std::move(pieces.front());
pieces.pop_front();
switch (piece->getKind()) {
- case PathDiagnosticPiece::Call: {
- auto &call = cast<PathDiagnosticCallPiece>(*piece);
- // Check if the location context is interesting.
- if (!removeUnneededCalls(
- C, call.path, R,
- R->isInteresting(C.getLocationContextFor(&call.path))))
- continue;
+ case PathDiagnosticPiece::Call: {
+ auto &call = cast<PathDiagnosticCallPiece>(*piece);
+ // Check if the location context is interesting.
+ if (!removeUnneededCalls(
+ C, call.path, R,
+ R->isInteresting(C.getLocationContextFor(&call.path))))
+ continue;
- containsSomethingInteresting = true;
- break;
- }
- case PathDiagnosticPiece::Macro: {
- auto ¯o = cast<PathDiagnosticMacroPiece>(*piece);
- if (!removeUnneededCalls(C, macro.subPieces, R, IsInteresting))
- continue;
- containsSomethingInteresting = true;
- break;
- }
- case PathDiagnosticPiece::Event: {
- auto &event = cast<PathDiagnosticEventPiece>(*piece);
+ containsSomethingInteresting = true;
+ break;
+ }
+ case PathDiagnosticPiece::Macro: {
+ auto ¯o = cast<PathDiagnosticMacroPiece>(*piece);
+ if (!removeUnneededCalls(C, macro.subPieces, R, IsInteresting))
+ continue;
+ containsSomethingInteresting = true;
+ break;
+ }
+ case PathDiagnosticPiece::Event: {
+ auto &event = cast<PathDiagnosticEventPiece>(*piece);
- // We never throw away an event, but we do throw it away wholesale
- // as part of a path if we throw the entire path away.
- containsSomethingInteresting |= !event.isPrunable();
- break;
- }
- case PathDiagnosticPiece::ControlFlow:
- case PathDiagnosticPiece::Note:
- case PathDiagnosticPiece::PopUp:
- break;
+ // We never throw away an event, but we do throw it away wholesale
+ // as part of a path if we throw the entire path away.
+ containsSomethingInteresting |= !event.isPrunable();
+ break;
+ }
+ case PathDiagnosticPiece::ControlFlow:
+ case PathDiagnosticPiece::Note:
+ case PathDiagnosticPiece::PopUp:
+ break;
}
pieces.push_back(std::move(piece));
@@ -597,8 +597,7 @@ PathDiagnosticLocation PathDiagnosticBuilder::ExecutionContinues(
if (Loc.asStmt())
os << "Execution continues on line "
- << getSourceManager().getExpansionLineNumber(Loc.asLocation())
- << '.';
+ << getSourceManager().getExpansionLineNumber(Loc.asLocation()) << '.';
else {
os << "Execution jumps to the end of the ";
const Decl *D = C.getCurrLocationContext()->getDecl();
@@ -648,55 +647,55 @@ getEnclosingStmtLocation(const Stmt *S, const LocationContext *LC,
while (const Stmt *Parent = getEnclosingParent(S, LC->getParentMap())) {
switch (Parent->getStmtClass()) {
- case Stmt::BinaryOperatorClass: {
- const auto *B = cast<BinaryOperator>(Parent);
- if (B->isLogicalOp())
- return PathDiagnosticLocation(allowNestedContexts ? B : S, SMgr, LC);
- break;
- }
- case Stmt::CompoundStmtClass:
- case Stmt::StmtExprClass:
+ case Stmt::BinaryOperatorClass: {
+ const auto *B = cast<BinaryOperator>(Parent);
+ if (B->isLogicalOp())
+ return PathDiagnosticLocation(allowNestedContexts ? B : S, SMgr, LC);
+ break;
+ }
+ case Stmt::CompoundStmtClass:
+ case Stmt::StmtExprClass:
+ return PathDiagnosticLocation(S, SMgr, LC);
+ case Stmt::ChooseExprClass:
+ // Similar to '?' if we are referring to condition, just have the edge
+ // point to the entire choose expression.
+ if (allowNestedContexts || cast<ChooseExpr>(Parent)->getCond() == S)
+ return PathDiagnosticLocation(Parent, SMgr, LC);
+ else
return PathDiagnosticLocation(S, SMgr, LC);
- case Stmt::ChooseExprClass:
- // Similar to '?' if we are referring to condition, just have the edge
- // point to the entire choose expression.
- if (allowNestedContexts || cast<ChooseExpr>(Parent)->getCond() == S)
- return PathDiagnosticLocation(Parent, SMgr, LC);
- else
- return PathDiagnosticLocation(S, SMgr, LC);
- case Stmt::BinaryConditionalOperatorClass:
- case Stmt::ConditionalOperatorClass:
- // For '?', if we are referring to condition, just have the edge point
- // to the entire '?' expression.
- if (allowNestedContexts ||
- cast<AbstractConditionalOperator>(Parent)->getCond() == S)
- return PathDiagnosticLocation(Parent, SMgr, LC);
- else
- return PathDiagnosticLocation(S, SMgr, LC);
- case Stmt::CXXForRangeStmtClass:
- if (cast<CXXForRangeStmt>(Parent)->getBody() == S)
- return PathDiagnosticLocation(S, SMgr, LC);
- break;
- case Stmt::DoStmtClass:
- return PathDiagnosticLocation(S, SMgr, LC);
- case Stmt::ForStmtClass:
- if (cast<ForStmt>(Parent)->getBody() == S)
- return PathDiagnosticLocation(S, SMgr, LC);
- break;
- case Stmt::IfStmtClass:
- if (cast<IfStmt>(Parent)->getCond() != S)
- return PathDiagnosticLocation(S, SMgr, LC);
- break;
- case Stmt::ObjCForCollectionStmtClass:
- if (cast<ObjCForCollectionStmt>(Parent)->getBody() == S)
- return PathDiagnosticLocation(S, SMgr, LC);
- break;
- case Stmt::WhileStmtClass:
- if (cast<WhileStmt>(Parent)->getCond() != S)
- return PathDiagnosticLocation(S, SMgr, LC);
- break;
- default:
- break;
+ case Stmt::BinaryConditionalOperatorClass:
+ case Stmt::ConditionalOperatorClass:
+ // For '?', if we are referring to condition, just have the edge point
+ // to the entire '?' expression.
+ if (allowNestedContexts ||
+ cast<AbstractConditionalOperator>(Parent)->getCond() == S)
+ return PathDiagnosticLocation(Parent, SMgr, LC);
+ else
+ return PathDiagnosticLocation(S, SMgr, LC);
+ case Stmt::CXXForRangeStmtClass:
+ if (cast<CXXForRangeStmt>(Parent)->getBody() == S)
+ return PathDiagnosticLocation(S, SMgr, LC);
+ break;
+ case Stmt::DoStmtClass:
+ return PathDiagnosticLocation(S, SMgr, LC);
+ case Stmt::ForStmtClass:
+ if (cast<ForStmt>(Parent)->getBody() == S)
+ return PathDiagnosticLocation(S, SMgr, LC);
+ break;
+ case Stmt::IfStmtClass:
+ if (cast<IfStmt>(Parent)->getCond() != S)
+ return PathDiagnosticLocation(S, SMgr, LC);
+ break;
+ case Stmt::ObjCForCollectionStmtClass:
+ if (cast<ObjCForCollectionStmt>(Parent)->getBody() == S)
+ return PathDiagnosticLocation(S, SMgr, LC);
+ break;
+ case Stmt::WhileStmtClass:
+ if (cast<WhileStmt>(Parent)->getCond() != S)
+ return PathDiagnosticLocation(S, SMgr, LC);
+ break;
+ default:
+ break;
}
S = Parent;
@@ -738,7 +737,7 @@ void PathDiagnosticBuilder::updateStackPiecesWithMessage(
}
static void CompactMacroExpandedPieces(PathPieces &path,
- const SourceManager& SM);
+ const SourceManager &SM);
PathDiagnosticPieceRef PathDiagnosticBuilder::generateDiagForSwitchOP(
const PathDiagnosticConstruct &C, const CFGBlock *Dst,
@@ -756,12 +755,12 @@ PathDiagnosticPieceRef PathDiagnosticBuilder::generateDiagForSwitchOP(
switch (S->getStmtClass()) {
default:
os << "No cases match in the switch statement. "
- "Control jumps to line "
- << End.asLocation().getExpansionLineNumber();
+ "Control jumps to line "
+ << End.asLocation().getExpansionLineNumber();
break;
case Stmt::DefaultStmtClass:
os << "Control jumps to the 'default' case at line "
- << End.asLocation().getExpansionLineNumber();
+ << End.asLocation().getExpansionLineNumber();
break;
case Stmt::CaseStmtClass: {
@@ -794,8 +793,7 @@ PathDiagnosticPieceRef PathDiagnosticBuilder::generateDiagForSwitchOP(
os << "'Default' branch taken. ";
End = ExecutionContinues(os, C);
}
- return std::make_shared<PathDiagnosticControlFlowPiece>(Start, End,
- os.str());
+ return std::make_shared<PathDiagnosticControlFlowPiece>(Start, End, os.str());
}
PathDiagnosticPieceRef PathDiagnosticBuilder::generateDiagForGotoOP(
@@ -822,14 +820,12 @@ PathDiagnosticPieceRef PathDiagnosticBuilder::generateDiagForBinaryOP(
PathDiagnosticLocation Start, End;
if (B->getOpcode() == BO_LAnd) {
- os << "&&"
- << "' is ";
+ os << "&&" << "' is ";
if (*(Src->succ_begin() + 1) == Dst) {
os << "false";
End = PathDiagnosticLocation(B->getLHS(), SM, C.getCurrLocationContext());
- Start =
- PathDiagnosticLocation::createOperatorLoc(B, SM);
+ Start = PathDiagnosticLocation::createOperatorLoc(B, SM);
} else {
os << "true";
Start =
@@ -838,8 +834,7 @@ PathDiagnosticPieceRef PathDiagnosticBuilder::generateDiagForBinaryOP(
}
} else {
assert(B->getOpcode() == BO_LOr);
- os << "||"
- << "' is ";
+ os << "||" << "' is ";
if (*(Src->succ_begin() + 1) == Dst) {
os << "false";
@@ -849,12 +844,10 @@ PathDiagnosticPieceRef PathDiagnosticBuilder::generateDiagForBinaryOP(
} else {
os << "true";
End = PathDiagnosticLocation(B->getLHS(), SM, C.getCurrLocationContext());
- Start =
- PathDiagnosticLocation::createOperatorLoc(B, SM);
+ Start = PathDiagnosticLocation::createOperatorLoc(B, SM);
}
}
- return std::make_shared<PathDiagnosticControlFlowPiece>(Start, End,
- os.str());
+ return std::make_shared<PathDiagnosticControlFlowPiece>(Start, End, os.str());
}
void PathDiagnosticBuilder::generateMinimalDiagForBlockEdge(
@@ -1003,21 +996,21 @@ void PathDiagnosticBuilder::generateMinimalDiagForBlockEdge(
static bool isLoop(const Stmt *Term) {
switch (Term->getStmtClass()) {
- case Stmt::ForStmtClass:
- case Stmt::WhileStmtClass:
- case Stmt::ObjCForCollectionStmtClass:
- case Stmt::CXXForRangeStmtClass:
- return true;
- default:
- // Note that we intentionally do not include do..while here.
- return false;
+ case Stmt::ForStmtClass:
+ case Stmt::WhileStmtClass:
+ case Stmt::ObjCForCollectionStmtClass:
+ case Stmt::CXXForRangeStmtClass:
+ return true;
+ default:
+ // Note that we intentionally do not include do..while here.
+ return false;
}
}
static bool isJumpToFalseBranch(const BlockEdge *BE) {
const CFGBlock *Src = BE->getSrc();
assert(Src->succ_size() == 2);
- return (*(Src->succ_begin()+1) == BE->getDst());
+ return (*(Src->succ_begin() + 1) == BE->getDst());
}
static bool isContainedByStmt(const ParentMap &PM, const Stmt *S,
@@ -1047,39 +1040,38 @@ static const Stmt *getStmtBeforeCond(const ParentMap &PM, const Stmt *Term,
static bool isInLoopBody(const ParentMap &PM, const Stmt *S, const Stmt *Term) {
const Stmt *LoopBody = nullptr;
switch (Term->getStmtClass()) {
- case Stmt::CXXForRangeStmtClass: {
- const auto *FR = cast<CXXForRangeStmt>(Term);
- if (isContainedByStmt(PM, FR->getInc(), S))
- return true;
- if (isContainedByStmt(PM, FR->getLoopVarStmt(), S))
- return true;
- LoopBody = FR->getBody();
- break;
- }
- case Stmt::ForStmtClass: {
- const auto *FS = cast<ForStmt>(Term);
- if (isContainedByStmt(PM, FS->getInc(), S))
- return true;
- LoopBody = FS->getBody();
- break;
- }
- case Stmt::ObjCForCollectionStmtClass: {
- const auto *FC = cast<ObjCForCollectionStmt>(Term);
- LoopBody = FC->getBody();
- break;
- }
- case Stmt::WhileStmtClass:
- LoopBody = cast<WhileStmt>(Term)->getBody();
- break;
- default:
- return false;
+ case Stmt::CXXForRangeStmtClass: {
+ const auto *FR = cast<CXXForRangeStmt>(Term);
+ if (isContainedByStmt(PM, FR->getInc(), S))
+ return true;
+ if (isContainedByStmt(PM, FR->getLoopVarStmt(), S))
+ return true;
+ LoopBody = FR->getBody();
+ break;
+ }
+ case Stmt::ForStmtClass: {
+ const auto *FS = cast<ForStmt>(Term);
+ if (isContainedByStmt(PM, FS->getInc(), S))
+ return true;
+ LoopBody = FS->getBody();
+ break;
+ }
+ case Stmt::ObjCForCollectionStmtClass: {
+ const auto *FC = cast<ObjCForCollectionStmt>(Term);
+ LoopBody = FC->getBody();
+ break;
+ }
+ case Stmt::WhileStmtClass:
+ LoopBody = cast<WhileStmt>(Term)->getBody();
+ break;
+ default:
+ return false;
}
return isContainedByStmt(PM, LoopBody, S);
}
/// Adds a sanitized control-flow diagnostic edge to a path.
-static void addEdgeToPath(PathPieces &path,
- PathDiagnosticLocation &PrevLoc,
+static void addEdgeToPath(PathPieces &path, PathDiagnosticLocation &PrevLoc,
PathDiagnosticLocation NewLoc) {
if (!NewLoc.isValid())
return;
@@ -1364,42 +1356,41 @@ static const Stmt *getStmtParent(const Stmt *S, const ParentMap &PM) {
static bool isConditionForTerminator(const Stmt *S, const Stmt *Cond) {
switch (S->getStmtClass()) {
- case Stmt::BinaryOperatorClass: {
- const auto *BO = cast<BinaryOperator>(S);
- if (!BO->isLogicalOp())
- return false;
- return BO->getLHS() == Cond || BO->getRHS() == Cond;
- }
- case Stmt::IfStmtClass:
- return cast<IfStmt>(S)->getCond() == Cond;
- case Stmt::ForStmtClass:
- return cast<ForStmt>(S)->getCond() == Cond;
- case Stmt::WhileStmtClass:
- return cast<WhileStmt>(S)->getCond() == Cond;
- case Stmt::DoStmtClass:
- return cast<DoStmt>(S)->getCond() == Cond;
- case Stmt::ChooseExprClass:
- return cast<ChooseExpr>(S)->getCond() == Cond;
- case Stmt::IndirectGotoStmtClass:
- return cast<IndirectGotoStmt>(S)->getTarget() == Cond;
- case Stmt::SwitchStmtClass:
- return cast<SwitchStmt>(S)->getCond() == Cond;
- case Stmt::BinaryConditionalOperatorClass:
- return cast<BinaryConditionalOperator>(S)->getCond() == Cond;
- case Stmt::ConditionalOperatorClass: {
- const auto *CO = cast<ConditionalOperator>(S);
- return CO->getCond() == Cond ||
- CO->getLHS() == Cond ||
- CO->getRHS() == Cond;
- }
- case Stmt::ObjCForCollectionStmtClass:
- return cast<ObjCForCollectionStmt>(S)->getElement() == Cond;
- case Stmt::CXXForRangeStmtClass: {
- const auto *FRS = cast<CXXForRangeStmt>(S);
- return FRS->getCond() == Cond || FRS->getRangeInit() == Cond;
- }
- default:
+ case Stmt::BinaryOperatorClass: {
+ const auto *BO = cast<BinaryOperator>(S);
+ if (!BO->isLogicalOp())
return false;
+ return BO->getLHS() == Cond || BO->getRHS() == Cond;
+ }
+ case Stmt::IfStmtClass:
+ return cast<IfStmt>(S)->getCond() == Cond;
+ case Stmt::ForStmtClass:
+ return cast<ForStmt>(S)->getCond() == Cond;
+ case Stmt::WhileStmtClass:
+ return cast<WhileStmt>(S)->getCond() == Cond;
+ case Stmt::DoStmtClass:
+ return cast<DoStmt>(S)->getCond() == Cond;
+ case Stmt::ChooseExprClass:
+ return cast<ChooseExpr>(S)->getCond() == Cond;
+ case Stmt::IndirectGotoStmtClass:
+ return cast<IndirectGotoStmt>(S)->getTarget() == Cond;
+ case Stmt::SwitchStmtClass:
+ return cast<SwitchStmt>(S)->getCond() == Cond;
+ case Stmt::BinaryConditionalOperatorClass:
+ return cast<BinaryConditionalOperator>(S)->getCond() == Cond;
+ case Stmt::ConditionalOperatorClass: {
+ const auto *CO = cast<ConditionalOperator>(S);
+ return CO->getCond() == Cond || CO->getLHS() == Cond ||
+ CO->getRHS() == Cond;
+ }
+ case Stmt::ObjCForCollectionStmtClass:
+ return cast<ObjCForCollectionStmt>(S)->getElement() == Cond;
+ case Stmt::CXXForRangeStmtClass: {
+ const auto *FRS = cast<CXXForRangeStmt>(S);
+ return FRS->getCond() == Cond || FRS->getRangeInit() == Cond;
+ }
+ default:
+ return false;
}
}
@@ -1508,12 +1499,13 @@ static void simplifySimpleBranches(PathPieces &pieces) {
continue;
const Stmt *s1Start = PieceI->getStartLocation().getStmtOrNull();
- const Stmt *s1End = PieceI->getEndLocation().getStmtOrNull();
+ const Stmt *s1End = PieceI->getEndLocation().getStmtOrNull();
if (!s1Start || !s1End)
continue;
- PathPieces::iterator NextI = I; ++NextI;
+ PathPieces::iterator NextI = I;
+ ++NextI;
if (NextI == E)
break;
@@ -1542,7 +1534,7 @@ static void simplifySimpleBranches(PathPieces &pieces) {
continue;
const Stmt *s2Start = PieceNextI->getStartLocation().getStmtOrNull();
- const Stmt *s2End = PieceNextI->getEndLocation().getStmtOrNull();
+ const Stmt *s2End = PieceNextI->getEndLocation().getStmtOrNull();
if (!s2Start || !s2End || s1End != s2Start)
continue;
@@ -1621,7 +1613,7 @@ static std::optional<size_t> getLengthOnSingleLine(const SourceManager &SM,
/// - if the whole statement is large enough that having subexpression arrows
/// might be helpful.
static void removeContextCycles(PathPieces &Path, const SourceManager &SM) {
- for (PathPieces::iterator I = Path.begin(), E = Path.end(); I != E; ) {
+ for (PathPieces::iterator I = Path.begin(), E = Path.end(); I != E;) {
// Pattern match the current piece and its successor.
const auto *PieceI = dyn_cast<PathDiagnosticControlFlowPiece>(I->get());
@@ -1631,9 +1623,10 @@ static void removeContextCycles(PathPieces &Path, const SourceManager &SM) {
}
const Stmt *s1Start = PieceI->getStartLocation().getStmtOrNull();
- const Stmt *s1End = PieceI->getEndLocation().getStmtOrNull();
+ const Stmt *s1End = PieceI->getEndLocation().getStmtOrNull();
- PathPieces::iterator NextI = I; ++NextI;
+ PathPieces::iterator NextI = I;
+ ++NextI;
if (NextI == E)
break;
@@ -1655,7 +1648,7 @@ static void removeContextCycles(PathPieces &Path, const SourceManager &SM) {
}
const Stmt *s2Start = PieceNextI->getStartLocation().getStmtOrNull();
- const Stmt *s2End = PieceNextI->getEndLocation().getStmtOrNull();
+ const Stmt *s2End = PieceNextI->getEndLocation().getStmtOrNull();
if (s1Start && s2Start && s1Start == s2End && s2Start == s1End) {
const size_t MAX_SHORT_LINE_LENGTH = 80;
@@ -1699,7 +1692,7 @@ static void removePunyEdges(PathPieces &path, const SourceManager &SM,
continue;
const Stmt *start = PieceI->getStartLocation().getStmtOrNull();
- const Stmt *end = PieceI->getEndLocation().getStmtOrNull();
+ const Stmt *end = PieceI->getEndLocation().getStmtOrNull();
if (!start || !end)
continue;
@@ -1745,7 +1738,8 @@ static void removeIdenticalEvents(PathPieces &path) {
if (!PieceI)
continue;
- PathPieces::iterator NextI = I; ++NextI;
+ PathPieces::iterator NextI = I;
+ ++NextI;
if (NextI == E)
return;
@@ -1769,7 +1763,7 @@ static bool optimizeEdges(const PathDiagnosticConstruct &C, PathPieces &path,
const ParentMap &PM = LC->getParentMap();
const SourceManager &SM = C.getSourceManager();
- for (PathPieces::iterator I = path.begin(), E = path.end(); I != E; ) {
+ for (PathPieces::iterator I = path.begin(), E = path.end(); I != E;) {
// Optimize subpaths.
if (auto *CallI = dyn_cast<PathDiagnosticCallPiece>(I->get())) {
// Record the fact that a call has been optimized so we only do the
@@ -1792,15 +1786,17 @@ static bool optimizeEdges(const PathDiagnosticConstruct &C, PathPieces &path,
}
const Stmt *s1Start = PieceI->getStartLocation().getStmtOrNull();
- const Stmt *s1End = PieceI->getEndLocation().getStmtOrNull();
+ const Stmt *s1End = PieceI->getEndLocation().getStmtOrNull();
const Stmt *level1 = getStmtParent(s1Start, PM);
const Stmt *level2 = getStmtParent(s1End, PM);
- PathPieces::iterator NextI = I; ++NextI;
+ PathPieces::iterator NextI = I;
+ ++NextI;
if (NextI == E)
break;
- const auto *PieceNextI = dyn_cast<PathDiagnosticControlFlowPiece>(NextI->get());
+ const auto *PieceNextI =
+ dyn_cast<PathDiagnosticControlFlowPiece>(NextI->get());
if (!PieceNextI) {
++I;
@@ -1808,7 +1804,7 @@ static bool optimizeEdges(const PathDiagnosticConstruct &C, PathPieces &path,
}
const Stmt *s2Start = PieceNextI->getStartLocation().getStmtOrNull();
- const Stmt *s2End = PieceNextI->getEndLocation().getStmtOrNull();
+ const Stmt *s2End = PieceNextI->getEndLocation().getStmtOrNull();
const Stmt *level3 = getStmtParent(s2Start, PM);
const Stmt *level4 = getStmtParent(s2End, PM);
@@ -1867,8 +1863,7 @@ static bool optimizeEdges(const PathDiagnosticConstruct &C, PathPieces &path,
//
// This can eliminate edges where we dive into a subexpression
// and then pop back out, etc.
- else if (s1Start && s2End &&
- lexicalContains(PM, s2Start, s2End) &&
+ else if (s1Start && s2End && lexicalContains(PM, s2Start, s2End) &&
!lexicalContains(PM, s1End, s1Start)) {
removeEdge = true;
}
@@ -1880,8 +1875,7 @@ static bool optimizeEdges(const PathDiagnosticConstruct &C, PathPieces &path,
// A.1 -> B
//
// These edges just look ugly and don't usually add anything.
- else if (s1Start && s2End &&
- lexicalContains(PM, s1Start, s1End)) {
+ else if (s1Start && s2End && lexicalContains(PM, s1Start, s1End)) {
SourceRange EdgeRange(PieceI->getEndLocation().asLocation(),
PieceI->getStartLocation().asLocation());
if (!getLengthOnSingleLine(SM, EdgeRange))
@@ -2051,7 +2045,6 @@ PathDiagnosticBuilder::generate(const PathDiagnosticConsumer *PDC) const {
PathDiagnosticLocation::createBegin(D, SM));
}
-
// Finally, prune the diagnostic path of uninteresting stuff.
if (!Construct.PD->path.empty()) {
if (R->shouldPrunePath() && Opts.ShouldPrunePaths) {
@@ -2168,9 +2161,7 @@ void PathSensitiveBugReport::addVisitor(
Callbacks.push_back(std::move(visitor));
}
-void PathSensitiveBugReport::clearVisitors() {
- Callbacks.clear();
-}
+void PathSensitiveBugReport::clearVisitors() { Callbacks.clear(); }
const Decl *PathSensitiveBugReport::getDeclWithIssue() const {
const ExplodedNode *N = getErrorNode();
@@ -2181,7 +2172,7 @@ const Decl *PathSensitiveBugReport::getDeclWithIssue() const {
return LC->getStackFrame()->getDecl();
}
-void BasicBugReport::Profile(llvm::FoldingSetNodeID& hash) const {
+void BasicBugReport::Profile(llvm::FoldingSetNodeID &hash) const {
hash.AddInteger(static_cast<int>(getKind()));
hash.AddPointer(&BT);
hash.AddString(Description);
@@ -2235,17 +2226,17 @@ static void insertToInterestingnessMap(
// and we wouldn't like to downplay their importance.
switch (TKind) {
- case bugreporter::TrackingKind::Thorough:
- Result.first->getSecond() = bugreporter::TrackingKind::Thorough;
- return;
- case bugreporter::TrackingKind::Condition:
- return;
- }
+ case bugreporter::TrackingKind::Thorough:
+ Result.first->getSecond() = bugreporter::TrackingKind::Thorough;
+ return;
+ case bugreporter::TrackingKind::Condition:
+ return;
+ }
- llvm_unreachable(
- "BugReport::markInteresting currently can only handle 2 different "
- "tracking kinds! Please define what tracking kind should this entitiy"
- "have, if it was already marked as interesting with a different kind!");
+ llvm_unreachable(
+ "BugReport::markInteresting currently can only handle 2 different "
+ "tracking kinds! Please define what tracking kind should this entitiy"
+ "have, if it was already marked as interesting with a different kind!");
}
void PathSensitiveBugReport::markInteresting(SymbolRef sym,
@@ -2319,11 +2310,11 @@ PathSensitiveBugReport::getInterestingnessKind(SVal V) const {
// If either is marked with throrough tracking, return that, we wouldn't like
// to downplay a note's importance by 'only' mentioning it as a condition.
- switch(*RKind) {
- case bugreporter::TrackingKind::Thorough:
- return RKind;
- case bugreporter::TrackingKind::Condition:
- return SKind;
+ switch (*RKind) {
+ case bugreporter::TrackingKind::Thorough:
+ return RKind;
+ case bugreporter::TrackingKind::Condition:
+ return SKind;
}
llvm_unreachable(
@@ -2372,7 +2363,7 @@ bool PathSensitiveBugReport::isInteresting(const MemRegion *R) const {
return getInterestingnessKind(R).has_value();
}
-bool PathSensitiveBugReport::isInteresting(const LocationContext *LC) const {
+bool PathSensitiveBugReport::isInteresting(const LocationContext *LC) const {
if (!LC)
return false;
return InterestingLocationContexts.count(LC);
@@ -2396,28 +2387,26 @@ const Stmt *PathSensitiveBugReport::getStmt() const {
return S;
}
-ArrayRef<SourceRange>
-PathSensitiveBugReport::getRanges() const {
+ArrayRef<SourceRange> PathSensitiveBugReport::getRanges() const {
// If no custom ranges, add the range of the statement corresponding to
// the error node.
if (Ranges.empty() && isa_and_nonnull<Expr>(getStmt()))
- return ErrorNodeRange;
+ return ErrorNodeRange;
return Ranges;
}
-PathDiagnosticLocation
-PathSensitiveBugReport::getLocation() const {
+PathDiagnosticLocation PathSensitiveBugReport::getLocation() const {
assert(ErrorNode && "Cannot create a location with a null node.");
const Stmt *S = ErrorNode->getStmtForDiagnostics();
- ProgramPoint P = ErrorNode->getLocation();
+ ProgramPoint P = ErrorNode->getLocation();
const LocationContext *LC = P.getLocationContext();
SourceManager &SM =
ErrorNode->getState()->getStateManager().getContext().getSourceManager();
if (!S) {
// If this is an implicit call, return the implicit call point location.
- if (std::optional<PreImplicitCall> PIE = P.getAs<PreImplicitCall>())
+ if (std::optional<PreImplicitCall> PIE = P.getAs<PreImplicitCall>())
return PathDiagnosticLocation(PIE->getLocation(), SM);
if (auto FE = P.getAs<FunctionExitPoint>()) {
if (const ReturnStmt *RS = FE->getStmt())
@@ -2518,8 +2507,9 @@ class BugPathGetter {
/// Assign each node with its distance from the root.
PriorityMapTy PriorityMap;
- /// Since the getErrorNode() or BugReport refers to the original ExplodedGraph,
- /// we need to pair it to the error node of the constructed trimmed graph.
+ /// Since the getErrorNode() or BugReport refers to the original
+ /// ExplodedGraph, we need to pair it to the error node of the constructed
+ /// trimmed graph.
using ReportNewNodePair =
std::pair<PathSensitiveBugReport *, const ExplodedNode *>;
SmallVector<ReportNewNodePair, 32> ReportNodes;
@@ -2527,8 +2517,7 @@ class BugPathGetter {
BugPathInfo CurrentBugPath;
/// A helper class for sorting ExplodedNodes by priority.
- template <bool Descending>
- class PriorityCompare {
+ template <bool Descending> class PriorityCompare {
const PriorityMapTy &PriorityMap;
public:
@@ -2544,8 +2533,7 @@ class BugPathGetter {
if (RI == E)
return !Descending;
- return Descending ? LI->second > RI->second
- : LI->second < RI->second;
+ return Descending ? LI->second > RI->second : LI->second < RI->second;
}
bool operator()(const ReportNewNodePair &LHS,
@@ -2645,9 +2633,9 @@ BugPathInfo *BugPathGetter::getNextBugPath() {
while (true) {
// Create the equivalent node in the new graph with the same state
// and location.
- ExplodedNode *NewN = GNew->createUncachedNode(
- OrigN->getLocation(), OrigN->getState(),
- OrigN->getID(), OrigN->isSink());
+ ExplodedNode *NewN =
+ GNew->createUncachedNode(OrigN->getLocation(), OrigN->getState(),
+ OrigN->getID(), OrigN->isSink());
// Link up the new node with the previous node.
if (Succ)
@@ -2677,7 +2665,7 @@ BugPathInfo *BugPathGetter::getNextBugPath() {
/// CompactMacroExpandedPieces - This function postprocesses a PathDiagnostic
/// object and collapses PathDiagosticPieces that are expanded by macros.
static void CompactMacroExpandedPieces(PathPieces &path,
- const SourceManager& SM) {
+ const SourceManager &SM) {
using MacroStackTy = std::vector<
std::pair<std::shared_ptr<PathDiagnosticMacroPiece>, SourceLocation>>;
@@ -2686,8 +2674,8 @@ static void CompactMacroExpandedPieces(PathPieces &path,
MacroStackTy MacroStack;
PiecesTy Pieces;
- for (PathPieces::const_iterator I = path.begin(), E = path.end();
- I != E; ++I) {
+ for (PathPieces::const_iterator I = path.begin(), E = path.end(); I != E;
+ ++I) {
const auto &piece = *I;
// Recursively compact calls.
@@ -2700,9 +2688,8 @@ static void CompactMacroExpandedPieces(PathPieces &path,
// Determine the instantiation location, which is the location we group
// related PathDiagnosticPieces.
- SourceLocation InstantiationLoc = Loc.isMacroID() ?
- SM.getExpansionLoc(Loc) :
- SourceLocation();
+ SourceLocation InstantiationLoc =
+ Loc.isMacroID() ? SM.getExpansionLoc(Loc) : SourceLocation();
if (Loc.isFileID()) {
MacroStack.clear();
@@ -2722,9 +2709,9 @@ static void CompactMacroExpandedPieces(PathPieces &path,
// or are part of an old one?
std::shared_ptr<PathDiagnosticMacroPiece> MacroGroup;
- SourceLocation ParentInstantiationLoc = InstantiationLoc.isMacroID() ?
- SM.getExpansionLoc(Loc) :
- SourceLocation();
+ SourceLocation ParentInstantiationLoc = InstantiationLoc.isMacroID()
+ ? SM.getExpansionLoc(Loc)
+ : SourceLocation();
// Walk the entire macro stack.
while (!MacroStack.empty()) {
@@ -2917,7 +2904,7 @@ void BugReporter::emitReport(std::unique_ptr<BugReport> R) {
// Lookup the equivance class. If there isn't one, create it.
void *InsertPos;
- BugReportEquivClass* EQ = EQClasses.FindNodeOrInsertPos(ID, InsertPos);
+ BugReportEquivClass *EQ = EQClasses.FindNodeOrInsertPos(ID, InsertPos);
if (!EQ) {
EQ = new BugReportEquivClass(std::move(R));
@@ -2971,7 +2958,7 @@ BugReport *PathSensitiveBugReporter::findReportInEquivalenceClass(
// post-dominated by a sink, simply add all the nodes in the equivalence class
// to 'Nodes'. Any of the reports will serve as a "representative" report.
assert(EQ.getReports().size() > 0);
- const BugType& BT = EQ.getReports()[0]->getBugType();
+ const BugType &BT = EQ.getReports()[0]->getBugType();
if (!BT.isSuppressOnSink()) {
BugReport *R = EQ.getReports()[0].get();
for (auto &J : EQ.getReports()) {
@@ -2991,7 +2978,7 @@ BugReport *PathSensitiveBugReporter::findReportInEquivalenceClass(
// stack for very long paths.
BugReport *exampleReport = nullptr;
- for (const auto &I: EQ.getReports()) {
+ for (const auto &I : EQ.getReports()) {
auto *R = dyn_cast<PathSensitiveBugReport>(I.get());
if (!R)
continue;
@@ -2999,7 +2986,7 @@ BugReport *PathSensitiveBugReporter::findReportInEquivalenceClass(
const ExplodedNode *errorNode = R->getErrorNode();
if (errorNode->isSink()) {
llvm_unreachable(
- "BugType::isSuppressSink() should not be 'true' for sink end nodes");
+ "BugType::isSuppressSink() should not be 'true' for sink end nodes");
}
// No successors? By definition this nodes isn't post-dominated by a sink.
if (errorNode->succ_empty()) {
@@ -3069,8 +3056,8 @@ BugReport *PathSensitiveBugReporter::findReportInEquivalenceClass(
return exampleReport;
}
-void BugReporter::FlushReport(BugReportEquivClass& EQ) {
- SmallVector<BugReport*, 10> bugReports;
+void BugReporter::FlushReport(BugReportEquivClass &EQ) {
+ SmallVector<BugReport *, 10> bugReports;
BugReport *report = findReportInEquivalenceClass(EQ, bugReports);
if (!report)
return;
@@ -3082,7 +3069,7 @@ void BugReporter::FlushReport(BugReportEquivClass& EQ) {
return;
}
- ArrayRef<PathDiagnosticConsumer*> Consumers = getPathDiagnosticConsumers();
+ ArrayRef<PathDiagnosticConsumer *> Consumers = getPathDiagnosticConsumers();
std::unique_ptr<DiagnosticForConsumerMapTy> Diagnostics =
generateDiagnosticForConsumerMap(report, Consumers, bugReports);
@@ -3095,7 +3082,7 @@ void BugReporter::FlushReport(BugReportEquivClass& EQ) {
if (PD->path.empty()) {
PathDiagnosticLocation L = report->getLocation();
auto piece = std::make_unique<PathDiagnosticEventPiece>(
- L, report->getDescription());
+ L, report->getDescription());
for (SourceRange Range : report->getRanges())
piece->addRange(Range);
PD->setEndOfPath(std::move(piece));
@@ -3108,8 +3095,8 @@ void BugReporter::FlushReport(BugReportEquivClass& EQ) {
for (const auto &I : llvm::reverse(report->getNotes())) {
PathDiagnosticNotePiece *Piece = I.get();
auto ConvertedPiece = std::make_shared<PathDiagnosticEventPiece>(
- Piece->getLocation(), Piece->getString());
- for (const auto &R: Piece->getRanges())
+ Piece->getLocation(), Piece->getString());
+ for (const auto &R : Piece->getRanges())
ConvertedPiece->addRange(R);
Pieces.push_front(std::move(ConvertedPiece));
@@ -3129,11 +3116,12 @@ void BugReporter::FlushReport(BugReportEquivClass& EQ) {
/// Insert all lines participating in the function signature \p Signature
/// into \p ExecutedLines.
-static void populateExecutedLinesWithFunctionSignature(
- const Decl *Signature, const SourceManager &SM,
- FilesToLineNumsMap &ExecutedLines) {
+static void
+populateExecutedLinesWithFunctionSignature(const Decl *Signature,
+ const SourceManager &SM,
+ FilesToLineNumsMap &ExecutedLines) {
SourceRange SignatureSourceRange;
- const Stmt* Body = Signature->getBody();
+ const Stmt *Body = Signature->getBody();
if (const auto FD = dyn_cast<FunctionDecl>(Signature)) {
SignatureSourceRange = FD->getSourceRange();
} else if (const auto OD = dyn_cast<ObjCMethodDecl>(Signature)) {
@@ -3142,8 +3130,8 @@ static void populateExecutedLinesWithFunctionSignature(
return;
}
SourceLocation Start = SignatureSourceRange.getBegin();
- SourceLocation End = Body ? Body->getSourceRange().getBegin()
- : SignatureSourceRange.getEnd();
+ SourceLocation End =
+ Body ? Body->getSourceRange().getBegin() : SignatureSourceRange.getEnd();
if (!Start.isValid() || !End.isValid())
return;
unsigned StartLine = SM.getExpansionLineNumber(Start);
@@ -3154,9 +3142,9 @@ static void populateExecutedLinesWithFunctionSignature(
ExecutedLines[FID].insert(Line);
}
-static void populateExecutedLinesWithStmt(
- const Stmt *S, const SourceManager &SM,
- FilesToLineNumsMap &ExecutedLines) {
+static void populateExecutedLinesWithStmt(const Stmt *S,
+ const SourceManager &SM,
+ FilesToLineNumsMap &ExecutedLines) {
SourceLocation Loc = S->getSourceRange().getBegin();
if (!Loc.isValid())
return;
@@ -3179,7 +3167,7 @@ findExecutedLines(const SourceManager &SM, const ExplodedNode *N) {
populateExecutedLinesWithFunctionSignature(D, SM, *ExecutedLines);
} else if (auto CE = N->getLocationAs<CallEnter>()) {
// Inlined function: show signature.
- const Decl* D = CE->getCalleeContext()->getDecl();
+ const Decl *D = CE->getCalleeContext()->getDecl();
populateExecutedLinesWithFunctionSignature(D, SM, *ExecutedLines);
} else if (const Stmt *S = N->getStmtForDiagnostics()) {
populateExecutedLinesWithStmt(S, SM, *ExecutedLines);
@@ -3258,7 +3246,7 @@ static void resetDiagnosticLocationToMainFile(PathDiagnostic &PD) {
CP = getFirstStackedCallToHeaderFile(CP, SMgr);
if (CP) {
// Mark the piece.
- CP->setAsLastInMainSourceFile();
+ CP->setAsLastInMainSourceFile();
// Update the path diagnostic message.
const auto *ND = dyn_cast<NamedDecl>(CP->getCallee());
@@ -3278,8 +3266,6 @@ static void resetDiagnosticLocationToMainFile(PathDiagnostic &PD) {
}
}
-
-
std::unique_ptr<DiagnosticForConsumerMapTy>
PathSensitiveBugReporter::generateDiagnosticForConsumerMap(
BugReport *exampleReport, ArrayRef<PathDiagnosticConsumer *> consumers,
@@ -3301,8 +3287,8 @@ PathSensitiveBugReporter::generateDiagnosticForConsumerMap(
ArrayRef<PathSensitiveBugReport *> convertedArrayOfReports(
reinterpret_cast<PathSensitiveBugReport *const *>(&*bugReports.begin()),
reinterpret_cast<PathSensitiveBugReport *const *>(&*bugReports.end()));
- std::unique_ptr<DiagnosticForConsumerMapTy> Out = generatePathDiagnostics(
- consumers, convertedArrayOfReports);
+ std::unique_ptr<DiagnosticForConsumerMapTy> Out =
+ generatePathDiagnostics(consumers, convertedArrayOfReports);
if (Out->empty())
return Out;
@@ -3330,9 +3316,9 @@ void BugReporter::EmitBasicReport(const Decl *DeclWithIssue,
}
void BugReporter::EmitBasicReport(const Decl *DeclWithIssue,
- CheckerNameRef CheckName,
- StringRef name, StringRef category,
- StringRef str, PathDiagnosticLocation Loc,
+ CheckerNameRef CheckName, StringRef name,
+ StringRef category, StringRef str,
+ PathDiagnosticLocation Loc,
ArrayRef<SourceRange> Ranges,
ArrayRef<FixItHint> Fixits) {
// 'BT' is owned by BugReporter.
@@ -3349,8 +3335,8 @@ void BugReporter::EmitBasicReport(const Decl *DeclWithIssue,
BugType *BugReporter::getBugTypeForName(CheckerNameRef CheckName,
StringRef name, StringRef category) {
SmallString<136> fullDesc;
- llvm::raw_svector_ostream(fullDesc) << CheckName.getName() << ":" << name
- << ":" << category;
+ llvm::raw_svector_ostream(fullDesc)
+ << CheckName.getName() << ":" << name << ":" << category;
std::unique_ptr<BugType> &BT = StrBugTypes[fullDesc];
if (!BT)
BT = std::make_unique<BugType>(CheckName, name, category);
diff --git a/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp b/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
index 2f9965036b9ef9..77a9e0fec28035 100644
--- a/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
+++ b/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
@@ -227,8 +227,8 @@ static bool hasVisibleUpdate(const ExplodedNode *LeftNode, SVal LeftVal,
return false;
return LLCV->getRegion() == RLCV->getRegion() &&
- LLCV->getStore() == LeftNode->getState()->getStore() &&
- RLCV->getStore() == RightNode->getState()->getStore();
+ LLCV->getStore() == LeftNode->getState()->getStore() &&
+ RLCV->getStore() == RightNode->getState()->getStore();
}
static std::optional<SVal> getSValForVar(const Expr *CondVarExpr,
@@ -289,18 +289,15 @@ static bool isInterestingExpr(const Expr *E, const ExplodedNode *N,
}
/// \return name of the macro inside the location \p Loc.
-static StringRef getMacroName(SourceLocation Loc,
- BugReporterContext &BRC) {
- return Lexer::getImmediateMacroName(
- Loc,
- BRC.getSourceManager(),
- BRC.getASTContext().getLangOpts());
+static StringRef getMacroName(SourceLocation Loc, BugReporterContext &BRC) {
+ return Lexer::getImmediateMacroName(Loc, BRC.getSourceManager(),
+ BRC.getASTContext().getLangOpts());
}
/// \return Whether given spelling location corresponds to an expansion
/// of a function-like macro.
static bool isFunctionMacroExpansion(SourceLocation Loc,
- const SourceManager &SM) {
+ const SourceManager &SM) {
if (!Loc.isMacroID())
return false;
while (SM.isMacroArgExpansion(Loc))
@@ -346,9 +343,9 @@ static bool wasRegionOfInterestModifiedAt(const SubRegion *RegionOfInterest,
// Implementation of BugReporterVisitor.
//===----------------------------------------------------------------------===//
-PathDiagnosticPieceRef BugReporterVisitor::getEndPath(BugReporterContext &,
- const ExplodedNode *,
- PathSensitiveBugReport &) {
+PathDiagnosticPieceRef
+BugReporterVisitor::getEndPath(BugReporterContext &, const ExplodedNode *,
+ PathSensitiveBugReport &) {
return nullptr;
}
@@ -931,10 +928,11 @@ class MacroNullReturnSuppressionVisitor final : public BugReporterVisitor {
return nullptr;
}
- static void addMacroVisitorIfNecessary(
- const ExplodedNode *N, const MemRegion *R,
- bool EnableNullFPSuppression, PathSensitiveBugReport &BR,
- const SVal V) {
+ static void addMacroVisitorIfNecessary(const ExplodedNode *N,
+ const MemRegion *R,
+ bool EnableNullFPSuppression,
+ PathSensitiveBugReport &BR,
+ const SVal V) {
AnalyzerOptions &Options = N->getState()->getAnalysisManager().options;
if (EnableNullFPSuppression && Options.ShouldSuppressNullReturnPaths &&
isa<Loc>(V))
@@ -942,7 +940,7 @@ class MacroNullReturnSuppressionVisitor final : public BugReporterVisitor {
V);
}
- void* getTag() const {
+ void *getTag() const {
static int Tag = 0;
return static_cast<void *>(&Tag);
}
@@ -991,15 +989,11 @@ namespace {
/// interesting value comes from an inlined function call.
class ReturnVisitor : public TrackingBugReporterVisitor {
const StackFrameContext *CalleeSFC;
- enum {
- Initial,
- MaybeUnsuppress,
- Satisfied
- } Mode = Initial;
+ enum { Initial, MaybeUnsuppress, Satisfied } Mode = Initial;
bool EnableNullFPSuppression;
bool ShouldInvalidate = true;
- AnalyzerOptions& Options;
+ AnalyzerOptions &Options;
bugreporter::TrackingKind TKind;
public:
@@ -1304,7 +1298,8 @@ static bool isObjCPointer(const ValueDecl *D) {
return D->getType()->isObjCObjectPointerType();
}
-/// Show diagnostics for initializing or declaring a region \p R with a bad value.
+/// Show diagnostics for initializing or declaring a region \p R with a bad
+/// value.
static void showBRDiagnostics(llvm::raw_svector_ostream &OS, StoreInfo SI) {
const bool HasPrefix = SI.Dest->canPrintPretty();
@@ -1658,14 +1653,15 @@ PathDiagnosticPieceRef StoreSiteFinder::VisitNode(const ExplodedNode *Succ,
ProgramStateManager &StateMgr = BRC.getStateManager();
CallEventManager &CallMgr = StateMgr.getCallEventManager();
- CallEventRef<> Call = CallMgr.getCaller(CE->getCalleeContext(),
- Succ->getState());
+ CallEventRef<> Call =
+ CallMgr.getCaller(CE->getCalleeContext(), Succ->getState());
InitE = Call->getArgExpr(Param->getFunctionScopeIndex());
} else {
// Handle Objective-C 'self'.
assert(isa<ImplicitParamDecl>(VR->getDecl()));
InitE = cast<ObjCMessageExpr>(CE->getCalleeContext()->getCallSite())
- ->getInstanceReceiver()->IgnoreParenCasts();
+ ->getInstanceReceiver()
+ ->IgnoreParenCasts();
}
IsParam = true;
}
@@ -1867,7 +1863,7 @@ PathDiagnosticPieceRef TrackConstraintBRVisitor::VisitNode(
return nullptr;
PathDiagnosticLocation L =
- PathDiagnosticLocation::create(P, BRC.getSourceManager());
+ PathDiagnosticLocation::create(P, BRC.getSourceManager());
if (!L.isValid())
return nullptr;
@@ -1883,8 +1879,8 @@ PathDiagnosticPieceRef TrackConstraintBRVisitor::VisitNode(
// Implementation of SuppressInlineDefensiveChecksVisitor.
//===----------------------------------------------------------------------===//
-SuppressInlineDefensiveChecksVisitor::
-SuppressInlineDefensiveChecksVisitor(DefinedSVal Value, const ExplodedNode *N)
+SuppressInlineDefensiveChecksVisitor::SuppressInlineDefensiveChecksVisitor(
+ DefinedSVal Value, const ExplodedNode *N)
: V(Value) {
// Check if the visitor is disabled.
AnalyzerOptions &Options = N->getState()->getAnalysisManager().options;
@@ -2014,8 +2010,7 @@ class TrackControlDependencyCondBRVisitor final
} // end of anonymous namespace
static std::shared_ptr<PathDiagnosticEventPiece>
-constructDebugPieceForTrackedCondition(const Expr *Cond,
- const ExplodedNode *N,
+constructDebugPieceForTrackedCondition(const Expr *Cond, const ExplodedNode *N,
BugReporterContext &BRC) {
if (BRC.getAnalyzerOptions().AnalysisDiagOpt == PD_NONE ||
@@ -2027,9 +2022,9 @@ constructDebugPieceForTrackedCondition(const Expr *Cond,
BRC.getSourceManager(), BRC.getASTContext().getLangOpts()));
return std::make_shared<PathDiagnosticEventPiece>(
- PathDiagnosticLocation::createBegin(
- Cond, BRC.getSourceManager(), N->getLocationContext()),
- (Twine() + "Tracking condition '" + ConditionText + "'").str());
+ PathDiagnosticLocation::createBegin(Cond, BRC.getSourceManager(),
+ N->getLocationContext()),
+ (Twine() + "Tracking condition '" + ConditionText + "'").str());
}
static bool isAssertlikeBlock(const CFGBlock *B, ASTContext &Context) {
@@ -2143,7 +2138,8 @@ static const Expr *peelOffOuterExpr(const Expr *Ex, const ExplodedNode *N) {
if (const auto *OVE = dyn_cast<OpaqueValueExpr>(Ex))
return peelOffOuterExpr(OVE->getSourceExpr(), N);
if (const auto *POE = dyn_cast<PseudoObjectExpr>(Ex)) {
- const auto *PropRef = dyn_cast<ObjCPropertyRefExpr>(POE->getSyntacticForm());
+ const auto *PropRef =
+ dyn_cast<ObjCPropertyRefExpr>(POE->getSyntacticForm());
if (PropRef && PropRef->isMessagingGetter()) {
const Expr *GetterMessageSend =
POE->getSemanticExpr(POE->getNumSemanticExprs() - 1);
@@ -2201,7 +2197,7 @@ static const Expr *peelOffOuterExpr(const Expr *Ex, const ExplodedNode *N) {
/// Find the ExplodedNode where the lvalue (the value of 'Ex')
/// was computed.
-static const ExplodedNode* findNodeForExpression(const ExplodedNode *N,
+static const ExplodedNode *findNodeForExpression(const ExplodedNode *N,
const Expr *Inner) {
while (N) {
if (N->getStmtForDiagnostics() == Inner)
@@ -2736,8 +2732,7 @@ NilReceiverBRVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
OS << "'";
ME->getSelector().print(OS);
OS << "' not called";
- }
- else {
+ } else {
OS << "No method is called";
}
OS << " because the receiver is nil";
@@ -2750,7 +2745,7 @@ NilReceiverBRVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
/*EnableNullFPSuppression*/ false});
// Issue a message saying that the method was skipped.
PathDiagnosticLocation L(Receiver, BRC.getSourceManager(),
- N->getLocationContext());
+ N->getLocationContext());
return std::make_shared<PathDiagnosticEventPiece>(L, OS.str());
}
@@ -2895,32 +2890,32 @@ ConditionBRVisitor::VisitTrueTest(const Expr *Cond, BugReporterContext &BRC,
while (true) {
CondTmp = CondTmp->IgnoreParenCasts();
switch (CondTmp->getStmtClass()) {
- default:
- break;
- case Stmt::BinaryOperatorClass:
- if (auto P = VisitTrueTest(Cond, cast<BinaryOperator>(CondTmp),
- BRC, R, N, TookTrueTmp, IsAssuming))
- return P;
- break;
- case Stmt::DeclRefExprClass:
- if (auto P = VisitTrueTest(Cond, cast<DeclRefExpr>(CondTmp),
- BRC, R, N, TookTrueTmp, IsAssuming))
- return P;
- break;
- case Stmt::MemberExprClass:
- if (auto P = VisitTrueTest(Cond, cast<MemberExpr>(CondTmp),
- BRC, R, N, TookTrueTmp, IsAssuming))
- return P;
- break;
- case Stmt::UnaryOperatorClass: {
- const auto *UO = cast<UnaryOperator>(CondTmp);
- if (UO->getOpcode() == UO_LNot) {
- TookTrueTmp = !TookTrueTmp;
- CondTmp = UO->getSubExpr();
- continue;
- }
- break;
+ default:
+ break;
+ case Stmt::BinaryOperatorClass:
+ if (auto P = VisitTrueTest(Cond, cast<BinaryOperator>(CondTmp), BRC, R, N,
+ TookTrueTmp, IsAssuming))
+ return P;
+ break;
+ case Stmt::DeclRefExprClass:
+ if (auto P = VisitTrueTest(Cond, cast<DeclRefExpr>(CondTmp), BRC, R, N,
+ TookTrueTmp, IsAssuming))
+ return P;
+ break;
+ case Stmt::MemberExprClass:
+ if (auto P = VisitTrueTest(Cond, cast<MemberExpr>(CondTmp), BRC, R, N,
+ TookTrueTmp, IsAssuming))
+ return P;
+ break;
+ case Stmt::UnaryOperatorClass: {
+ const auto *UO = cast<UnaryOperator>(CondTmp);
+ if (UO->getOpcode() == UO_LNot) {
+ TookTrueTmp = !TookTrueTmp;
+ CondTmp = UO->getSubExpr();
+ continue;
}
+ break;
+ }
}
break;
}
@@ -2973,8 +2968,9 @@ bool ConditionBRVisitor::patternMatch(const Expr *Ex, const Expr *ParentEx,
Out << '\'';
const LocationContext *LCtx = N->getLocationContext();
const ProgramState *state = N->getState().get();
- if (const MemRegion *R = state->getLValue(cast<VarDecl>(DR->getDecl()),
- LCtx).getAsRegion()) {
+ if (const MemRegion *R =
+ state->getLValue(cast<VarDecl>(DR->getDecl()), LCtx)
+ .getAsRegion()) {
if (report.isInteresting(R))
prunable = false;
else {
@@ -2998,8 +2994,7 @@ bool ConditionBRVisitor::patternMatch(const Expr *Ex, const Expr *ParentEx,
Out << "null";
return false;
}
- }
- else if (OriginalTy->isObjCObjectPointerType()) {
+ } else if (OriginalTy->isObjCObjectPointerType()) {
if (IL->getValue() == 0) {
Out << "nil";
return false;
@@ -3077,35 +3072,56 @@ PathDiagnosticPieceRef ConditionBRVisitor::VisitTrueTest(
// Do we need to invert the opcode?
if (shouldInvert)
switch (Op) {
- default: break;
- case BO_LT: Op = BO_GT; break;
- case BO_GT: Op = BO_LT; break;
- case BO_LE: Op = BO_GE; break;
- case BO_GE: Op = BO_LE; break;
+ default:
+ break;
+ case BO_LT:
+ Op = BO_GT;
+ break;
+ case BO_GT:
+ Op = BO_LT;
+ break;
+ case BO_LE:
+ Op = BO_GE;
+ break;
+ case BO_GE:
+ Op = BO_LE;
+ break;
}
if (!TookTrue)
switch (Op) {
- case BO_EQ: Op = BO_NE; break;
- case BO_NE: Op = BO_EQ; break;
- case BO_LT: Op = BO_GE; break;
- case BO_GT: Op = BO_LE; break;
- case BO_LE: Op = BO_GT; break;
- case BO_GE: Op = BO_LT; break;
- default:
- return nullptr;
- }
-
- switch (Op) {
case BO_EQ:
- Out << "equal to ";
+ Op = BO_NE;
break;
case BO_NE:
- Out << "not equal to ";
+ Op = BO_EQ;
break;
- default:
- Out << BinaryOperator::getOpcodeStr(Op) << ' ';
+ case BO_LT:
+ Op = BO_GE;
+ break;
+ case BO_GT:
+ Op = BO_LE;
+ break;
+ case BO_LE:
+ Op = BO_GT;
break;
+ case BO_GE:
+ Op = BO_LT;
+ break;
+ default:
+ return nullptr;
+ }
+
+ switch (Op) {
+ case BO_EQ:
+ Out << "equal to ";
+ break;
+ case BO_NE:
+ Out << "not equal to ";
+ break;
+ default:
+ Out << BinaryOperator::getOpcodeStr(Op) << ' ';
+ break;
}
Out << (shouldInvert ? LhsString : RhsString);
@@ -3405,7 +3421,7 @@ UndefOrNullArgVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
++Idx;
// Are we tracking the argument or its subregion?
- if ( !ArgReg || !R->isSubRegionOf(ArgReg->StripCasts()))
+ if (!ArgReg || !R->isSubRegionOf(ArgReg->StripCasts()))
continue;
// Check the function parameter type.
diff --git a/clang/lib/StaticAnalyzer/Core/CallEvent.cpp b/clang/lib/StaticAnalyzer/Core/CallEvent.cpp
index 0ac1d91b79beb5..2229c124741401 100644
--- a/clang/lib/StaticAnalyzer/Core/CallEvent.cpp
+++ b/clang/lib/StaticAnalyzer/Core/CallEvent.cpp
@@ -78,8 +78,7 @@ QualType CallEvent::getResultType() const {
static bool isCallback(QualType T) {
// If a parameter is a block or a callback, assume it can modify pointer.
- if (T->isBlockPointerType() ||
- T->isFunctionPointerType() ||
+ if (T->isBlockPointerType() || T->isFunctionPointerType() ||
T->isObjCSelType())
return true;
@@ -190,16 +189,16 @@ CallEvent::getCalleeStackFrame(unsigned BlockCount) const {
return ADC->getManager()->getStackFrame(ADC, LCtx, E, B, BlockCount, Idx);
}
-const ParamVarRegion
-*CallEvent::getParameterLocation(unsigned Index, unsigned BlockCount) const {
+const ParamVarRegion *
+CallEvent::getParameterLocation(unsigned Index, unsigned BlockCount) const {
const StackFrameContext *SFC = getCalleeStackFrame(BlockCount);
// We cannot construct a VarRegion without a stack frame.
if (!SFC)
return nullptr;
const ParamVarRegion *PVR =
- State->getStateManager().getRegionManager().getParamVarRegion(
- getOriginExpr(), Index, SFC);
+ State->getStateManager().getRegionManager().getParamVarRegion(
+ getOriginExpr(), Index, SFC);
return PVR;
}
@@ -254,9 +253,10 @@ ProgramStateRef CallEvent::invalidateRegions(unsigned BlockCount,
// below for efficiency.
if (PreserveArgs.count(Idx))
if (const MemRegion *MR = getArgSVal(Idx).getAsRegion())
- ETraits.setTrait(MR->getBaseRegion(),
- RegionAndSymbolInvalidationTraits::TK_PreserveContents);
- // TODO: Factor this out + handle the lower level const pointers.
+ ETraits.setTrait(
+ MR->getBaseRegion(),
+ RegionAndSymbolInvalidationTraits::TK_PreserveContents);
+ // TODO: Factor this out + handle the lower level const pointers.
ValuesToInvalidate.push_back(getArgSVal(Idx));
@@ -462,14 +462,15 @@ static void addParameterValuesToBindings(const StackFrameContext *CalleeCtx,
CallEvent::BindingsTy &Bindings,
SValBuilder &SVB,
const CallEvent &Call,
- ArrayRef<ParmVarDecl*> parameters) {
+ ArrayRef<ParmVarDecl *> parameters) {
MemRegionManager &MRMgr = SVB.getRegionManager();
// If the function has fewer parameters than the call has arguments, we simply
// do not bind any values to them.
unsigned NumArgs = Call.getNumArgs();
unsigned Idx = 0;
- ArrayRef<ParmVarDecl*>::iterator I = parameters.begin(), E = parameters.end();
+ ArrayRef<ParmVarDecl *>::iterator I = parameters.begin(),
+ E = parameters.end();
for (; I != E && Idx < NumArgs; ++I, ++Idx) {
assert(*I && "Formal parameter has no decl?");
@@ -550,7 +551,7 @@ std::optional<SVal> CallEvent::getReturnValueUnderConstruction() const {
return RetVal;
}
-ArrayRef<ParmVarDecl*> AnyFunctionCall::parameters() const {
+ArrayRef<ParmVarDecl *> AnyFunctionCall::parameters() const {
const FunctionDecl *D = getDecl();
if (!D)
return std::nullopt;
@@ -565,10 +566,10 @@ RuntimeDefinition AnyFunctionCall::getRuntimeDefinition() const {
// Note that the AnalysisDeclContext will have the FunctionDecl with
// the definition (if one exists).
AnalysisDeclContext *AD =
- getLocationContext()->getAnalysisDeclContext()->
- getManager()->getContext(FD);
+ getLocationContext()->getAnalysisDeclContext()->getManager()->getContext(
+ FD);
bool IsAutosynthesized;
- Stmt* Body = AD->getBody(IsAutosynthesized);
+ Stmt *Body = AD->getBody(IsAutosynthesized);
LLVM_DEBUG({
if (IsAutosynthesized)
llvm::dbgs() << "Using autosynthesized body for " << FD->getName()
@@ -582,7 +583,7 @@ RuntimeDefinition AnyFunctionCall::getRuntimeDefinition() const {
AnalyzerOptions &Opts = Engine.getAnalysisManager().options;
if (Body) {
- const Decl* Decl = AD->getDecl();
+ const Decl *Decl = AD->getDecl();
if (Opts.IsNaiveCTUEnabled && CTUCtx.isImportedAsNew(Decl)) {
// A newly created definition, but we had error(s) during the import.
if (CTUCtx.hasError(Decl))
@@ -612,8 +613,7 @@ RuntimeDefinition AnyFunctionCall::getRuntimeDefinition() const {
}
void AnyFunctionCall::getInitialStackFrameContents(
- const StackFrameContext *CalleeCtx,
- BindingsTy &Bindings) const {
+ const StackFrameContext *CalleeCtx, BindingsTy &Bindings) const {
const auto *D = cast<FunctionDecl>(CalleeCtx->getDecl());
SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
addParameterValuesToBindings(CalleeCtx, Bindings, SVB, *this,
@@ -670,11 +670,11 @@ bool AnyFunctionCall::argumentsMayEscape() const {
// - Many CF containers allow objects to escape through custom
// allocators/deallocators upon container construction. (PR12101)
if (FName.starts_with("CF") || FName.starts_with("CG")) {
- return StrInStrNoCase(FName, "InsertValue") != StringRef::npos ||
- StrInStrNoCase(FName, "AddValue") != StringRef::npos ||
- StrInStrNoCase(FName, "SetValue") != StringRef::npos ||
- StrInStrNoCase(FName, "WithData") != StringRef::npos ||
- StrInStrNoCase(FName, "AppendValue") != StringRef::npos ||
+ return StrInStrNoCase(FName, "InsertValue") != StringRef::npos ||
+ StrInStrNoCase(FName, "AddValue") != StringRef::npos ||
+ StrInStrNoCase(FName, "SetValue") != StringRef::npos ||
+ StrInStrNoCase(FName, "WithData") != StringRef::npos ||
+ StrInStrNoCase(FName, "AppendValue") != StringRef::npos ||
StrInStrNoCase(FName, "SetAttribute") != StringRef::npos;
}
@@ -813,8 +813,7 @@ RuntimeDefinition CXXInstanceCall::getRuntimeDefinition() const {
}
void CXXInstanceCall::getInitialStackFrameContents(
- const StackFrameContext *CalleeCtx,
- BindingsTy &Bindings) const {
+ const StackFrameContext *CalleeCtx, BindingsTy &Bindings) const {
AnyFunctionCall::getInitialStackFrameContents(CalleeCtx, Bindings);
// Handle the binding of 'this' in the new stack frame.
@@ -880,15 +879,15 @@ const BlockDataRegion *BlockCall::getBlockRegion() const {
return dyn_cast_or_null<BlockDataRegion>(DataReg);
}
-ArrayRef<ParmVarDecl*> BlockCall::parameters() const {
+ArrayRef<ParmVarDecl *> BlockCall::parameters() const {
const BlockDecl *D = getDecl();
if (!D)
return std::nullopt;
return D->parameters();
}
-void BlockCall::getExtraInvalidatedValues(ValueList &Values,
- RegionAndSymbolInvalidationTraits *ETraits) const {
+void BlockCall::getExtraInvalidatedValues(
+ ValueList &Values, RegionAndSymbolInvalidationTraits *ETraits) const {
// FIXME: This also needs to invalidate captured globals.
if (const MemRegion *R = getBlockRegion())
Values.push_back(loc::MemRegionVal(R));
@@ -897,7 +896,7 @@ void BlockCall::getExtraInvalidatedValues(ValueList &Values,
void BlockCall::getInitialStackFrameContents(const StackFrameContext *CalleeCtx,
BindingsTy &Bindings) const {
SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
- ArrayRef<ParmVarDecl*> Params;
+ ArrayRef<ParmVarDecl *> Params;
if (isConversionFromLambda()) {
auto *LambdaOperatorDecl = cast<CXXMethodDecl>(CalleeCtx->getDecl());
Params = LambdaOperatorDecl->parameters();
@@ -913,8 +912,7 @@ void BlockCall::getInitialStackFrameContents(const StackFrameContext *CalleeCtx,
Params = cast<BlockDecl>(CalleeCtx->getDecl())->parameters();
}
- addParameterValuesToBindings(CalleeCtx, Bindings, SVB, *this,
- Params);
+ addParameterValuesToBindings(CalleeCtx, Bindings, SVB, *this, Params);
}
SVal AnyCXXConstructorCall::getCXXThisVal() const {
@@ -923,8 +921,8 @@ SVal AnyCXXConstructorCall::getCXXThisVal() const {
return UnknownVal();
}
-void AnyCXXConstructorCall::getExtraInvalidatedValues(ValueList &Values,
- RegionAndSymbolInvalidationTraits *ETraits) const {
+void AnyCXXConstructorCall::getExtraInvalidatedValues(
+ ValueList &Values, RegionAndSymbolInvalidationTraits *ETraits) const {
SVal V = getCXXThisVal();
if (SymbolRef Sym = V.getAsSymbol(true))
ETraits->setTrait(Sym,
@@ -933,8 +931,7 @@ void AnyCXXConstructorCall::getExtraInvalidatedValues(ValueList &Values,
}
void AnyCXXConstructorCall::getInitialStackFrameContents(
- const StackFrameContext *CalleeCtx,
- BindingsTy &Bindings) const {
+ const StackFrameContext *CalleeCtx, BindingsTy &Bindings) const {
AnyFunctionCall::getInitialStackFrameContents(CalleeCtx, Bindings);
SVal ThisVal = getCXXThisVal();
@@ -969,7 +966,7 @@ RuntimeDefinition CXXDestructorCall::getRuntimeDefinition() const {
return CXXInstanceCall::getRuntimeDefinition();
}
-ArrayRef<ParmVarDecl*> ObjCMethodCall::parameters() const {
+ArrayRef<ParmVarDecl *> ObjCMethodCall::parameters() const {
const ObjCMethodDecl *D = getDecl();
if (!D)
return std::nullopt;
@@ -987,11 +984,10 @@ void ObjCMethodCall::getExtraInvalidatedValues(
SVal IvarLVal = getState()->getLValue(PropIvar, getReceiverSVal());
if (const MemRegion *IvarRegion = IvarLVal.getAsRegion()) {
ETraits->setTrait(
- IvarRegion,
- RegionAndSymbolInvalidationTraits::TK_DoNotInvalidateSuperRegion);
- ETraits->setTrait(
- IvarRegion,
- RegionAndSymbolInvalidationTraits::TK_SuppressEscape);
+ IvarRegion,
+ RegionAndSymbolInvalidationTraits::TK_DoNotInvalidateSuperRegion);
+ ETraits->setTrait(IvarRegion,
+ RegionAndSymbolInvalidationTraits::TK_SuppressEscape);
Values.push_back(IvarLVal);
}
return;
@@ -1020,7 +1016,7 @@ SVal ObjCMethodCall::getReceiverSVal() const {
bool ObjCMethodCall::isReceiverSelfOrSuper() const {
if (getOriginExpr()->getReceiverKind() == ObjCMessageExpr::SuperInstance ||
getOriginExpr()->getReceiverKind() == ObjCMessageExpr::SuperClass)
- return true;
+ return true;
if (!isInstanceMessage())
return false;
@@ -1087,15 +1083,15 @@ ObjCMessageKind ObjCMethodCall::getMessageKind() const {
}
if (K != OCM_Message) {
- const_cast<ObjCMethodCall *>(this)->Data
- = ObjCMessageDataTy(POE, K).getOpaqueValue();
+ const_cast<ObjCMethodCall *>(this)->Data =
+ ObjCMessageDataTy(POE, K).getOpaqueValue();
assert(getMessageKind() == K);
return K;
}
}
- const_cast<ObjCMethodCall *>(this)->Data
- = ObjCMessageDataTy(nullptr, 1).getOpaqueValue();
+ const_cast<ObjCMethodCall *>(this)->Data =
+ ObjCMessageDataTy(nullptr, 1).getOpaqueValue();
assert(getMessageKind() == OCM_Message);
return OCM_Message;
}
@@ -1129,7 +1125,7 @@ const ObjCPropertyDecl *ObjCMethodCall::getAccessedProperty() const {
}
bool ObjCMethodCall::canBeOverridenInSubclass(ObjCInterfaceDecl *IDecl,
- Selector Sel) const {
+ Selector Sel) const {
assert(IDecl);
AnalysisManager &AMgr =
getState()->getStateManager().getOwningEngine().getAnalysisManager();
@@ -1383,8 +1379,7 @@ bool ObjCMethodCall::argumentsMayEscape() const {
}
void ObjCMethodCall::getInitialStackFrameContents(
- const StackFrameContext *CalleeCtx,
- BindingsTy &Bindings) const {
+ const StackFrameContext *CalleeCtx, BindingsTy &Bindings) const {
const auto *D = cast<ObjCMethodDecl>(CalleeCtx->getDecl());
SValBuilder &SVB = getState()->getStateManager().getSValBuilder();
addParameterValuesToBindings(CalleeCtx, Bindings, SVB, *this,
@@ -1421,9 +1416,8 @@ CallEventManager::getSimpleCall(const CallExpr *CE, ProgramStateRef State,
return create<SimpleFunctionCall>(CE, State, LCtx, ElemRef);
}
-CallEventRef<>
-CallEventManager::getCaller(const StackFrameContext *CalleeCtx,
- ProgramStateRef State) {
+CallEventRef<> CallEventManager::getCaller(const StackFrameContext *CalleeCtx,
+ ProgramStateRef State) {
const LocationContext *ParentCtx = CalleeCtx->getParent();
const LocationContext *CallerCtx = ParentCtx->getStackFrame();
CFGBlock::ConstCFGElementRef ElemRef = {CalleeCtx->getCallSiteBlock(),
diff --git a/clang/lib/StaticAnalyzer/Core/Checker.cpp b/clang/lib/StaticAnalyzer/Core/Checker.cpp
index bc1c8964b3ee4a..f45f31cded6213 100644
--- a/clang/lib/StaticAnalyzer/Core/Checker.cpp
+++ b/clang/lib/StaticAnalyzer/Core/Checker.cpp
@@ -10,8 +10,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
using namespace clang;
using namespace ento;
@@ -26,13 +26,13 @@ CheckerNameRef CheckerBase::getCheckerName() const { return Name; }
CheckerProgramPointTag::CheckerProgramPointTag(StringRef CheckerName,
StringRef Msg)
- : SimpleProgramPointTag(CheckerName, Msg) {}
+ : SimpleProgramPointTag(CheckerName, Msg) {}
CheckerProgramPointTag::CheckerProgramPointTag(const CheckerBase *Checker,
StringRef Msg)
: SimpleProgramPointTag(Checker->getCheckerName().getName(), Msg) {}
-raw_ostream& clang::ento::operator<<(raw_ostream &Out,
+raw_ostream &clang::ento::operator<<(raw_ostream &Out,
const CheckerBase &Checker) {
Out << Checker.getCheckerName().getName();
return Out;
diff --git a/clang/lib/StaticAnalyzer/Core/CheckerContext.cpp b/clang/lib/StaticAnalyzer/Core/CheckerContext.cpp
index d6d4cec9dd3d4d..e4a904cde0484e 100644
--- a/clang/lib/StaticAnalyzer/Core/CheckerContext.cpp
+++ b/clang/lib/StaticAnalyzer/Core/CheckerContext.cpp
@@ -117,8 +117,7 @@ bool CheckerContext::isCLibraryFunction(const FunctionDecl *FD,
StringRef CheckerContext::getMacroNameOrSpelling(SourceLocation &Loc) {
if (Loc.isMacroID())
- return Lexer::getImmediateMacroName(Loc, getSourceManager(),
- getLangOpts());
+ return Lexer::getImmediateMacroName(Loc, getSourceManager(), getLangOpts());
SmallString<16> buf;
return Lexer::getSpelling(Loc, buf, getSourceManager(), getLangOpts());
}
diff --git a/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp b/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp
index 6fc16223ea8287..5812af5285bb4b 100644
--- a/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp
+++ b/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp
@@ -35,7 +35,7 @@ using namespace clang;
using namespace ento;
bool CheckerManager::hasPathSensitiveCheckers() const {
- const auto IfAnyAreNonEmpty = [](const auto &... Callbacks) -> bool {
+ const auto IfAnyAreNonEmpty = [](const auto &...Callbacks) -> bool {
return (!Callbacks.empty() || ...);
};
return IfAnyAreNonEmpty(
@@ -71,7 +71,7 @@ void CheckerManager::reportInvalidCheckerOptionValue(
// Functions for running checkers for AST traversing..
//===----------------------------------------------------------------------===//
-void CheckerManager::runCheckersOnASTDecl(const Decl *D, AnalysisManager& mgr,
+void CheckerManager::runCheckersOnASTDecl(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) {
assert(D);
@@ -93,7 +93,7 @@ void CheckerManager::runCheckersOnASTDecl(const Decl *D, AnalysisManager& mgr,
checker(D, mgr, BR);
}
-void CheckerManager::runCheckersOnASTBody(const Decl *D, AnalysisManager& mgr,
+void CheckerManager::runCheckersOnASTBody(const Decl *D, AnalysisManager &mgr,
BugReporter &BR) {
assert(D && D->hasBody());
@@ -106,15 +106,14 @@ void CheckerManager::runCheckersOnASTBody(const Decl *D, AnalysisManager& mgr,
//===----------------------------------------------------------------------===//
template <typename CHECK_CTX>
-static void expandGraphWithCheckers(CHECK_CTX checkCtx,
- ExplodedNodeSet &Dst,
+static void expandGraphWithCheckers(CHECK_CTX checkCtx, ExplodedNodeSet &Dst,
const ExplodedNodeSet &Src) {
const NodeBuilderContext &BldrCtx = checkCtx.Eng.getBuilderContext();
if (Src.empty())
return;
- typename CHECK_CTX::CheckersTy::const_iterator
- I = checkCtx.checkers_begin(), E = checkCtx.checkers_end();
+ typename CHECK_CTX::CheckersTy::const_iterator I = checkCtx.checkers_begin(),
+ E = checkCtx.checkers_end();
if (I == E) {
Dst.insert(Src);
return;
@@ -125,7 +124,7 @@ static void expandGraphWithCheckers(CHECK_CTX checkCtx,
for (; I != E; ++I) {
ExplodedNodeSet *CurrSet = nullptr;
- if (I+1 == E)
+ if (I + 1 == E)
CurrSet = &Dst;
else {
CurrSet = (PrevSet == &Tmp1) ? &Tmp2 : &Tmp1;
@@ -147,90 +146,87 @@ static void expandGraphWithCheckers(CHECK_CTX checkCtx,
namespace {
- struct CheckStmtContext {
- using CheckersTy = SmallVectorImpl<CheckerManager::CheckStmtFunc>;
+struct CheckStmtContext {
+ using CheckersTy = SmallVectorImpl<CheckerManager::CheckStmtFunc>;
- bool IsPreVisit;
- const CheckersTy &Checkers;
- const Stmt *S;
- ExprEngine &Eng;
- bool WasInlined;
-
- CheckStmtContext(bool isPreVisit, const CheckersTy &checkers,
- const Stmt *s, ExprEngine &eng, bool wasInlined = false)
- : IsPreVisit(isPreVisit), Checkers(checkers), S(s), Eng(eng),
- WasInlined(wasInlined) {}
-
- CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
- CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
-
- void runChecker(CheckerManager::CheckStmtFunc checkFn,
- NodeBuilder &Bldr, ExplodedNode *Pred) {
- // FIXME: Remove respondsToCallback from CheckerContext;
- ProgramPoint::Kind K = IsPreVisit ? ProgramPoint::PreStmtKind :
- ProgramPoint::PostStmtKind;
- const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
- Pred->getLocationContext(), checkFn.Checker);
- CheckerContext C(Bldr, Eng, Pred, L, WasInlined);
- checkFn(S, C);
- }
- };
+ bool IsPreVisit;
+ const CheckersTy &Checkers;
+ const Stmt *S;
+ ExprEngine &Eng;
+ bool WasInlined;
+
+ CheckStmtContext(bool isPreVisit, const CheckersTy &checkers, const Stmt *s,
+ ExprEngine &eng, bool wasInlined = false)
+ : IsPreVisit(isPreVisit), Checkers(checkers), S(s), Eng(eng),
+ WasInlined(wasInlined) {}
+
+ CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
+ CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
+
+ void runChecker(CheckerManager::CheckStmtFunc checkFn, NodeBuilder &Bldr,
+ ExplodedNode *Pred) {
+ // FIXME: Remove respondsToCallback from CheckerContext;
+ ProgramPoint::Kind K =
+ IsPreVisit ? ProgramPoint::PreStmtKind : ProgramPoint::PostStmtKind;
+ const ProgramPoint &L = ProgramPoint::getProgramPoint(
+ S, K, Pred->getLocationContext(), checkFn.Checker);
+ CheckerContext C(Bldr, Eng, Pred, L, WasInlined);
+ checkFn(S, C);
+ }
+};
} // namespace
/// Run checkers for visiting Stmts.
-void CheckerManager::runCheckersForStmt(bool isPreVisit,
- ExplodedNodeSet &Dst,
+void CheckerManager::runCheckersForStmt(bool isPreVisit, ExplodedNodeSet &Dst,
const ExplodedNodeSet &Src,
- const Stmt *S,
- ExprEngine &Eng,
+ const Stmt *S, ExprEngine &Eng,
bool WasInlined) {
- CheckStmtContext C(isPreVisit, getCachedStmtCheckersFor(S, isPreVisit),
- S, Eng, WasInlined);
+ CheckStmtContext C(isPreVisit, getCachedStmtCheckersFor(S, isPreVisit), S,
+ Eng, WasInlined);
expandGraphWithCheckers(C, Dst, Src);
}
namespace {
- struct CheckObjCMessageContext {
- using CheckersTy = std::vector<CheckerManager::CheckObjCMessageFunc>;
-
- ObjCMessageVisitKind Kind;
- bool WasInlined;
- const CheckersTy &Checkers;
- const ObjCMethodCall &Msg;
- ExprEngine &Eng;
-
- CheckObjCMessageContext(ObjCMessageVisitKind visitKind,
- const CheckersTy &checkers,
- const ObjCMethodCall &msg, ExprEngine &eng,
- bool wasInlined)
- : Kind(visitKind), WasInlined(wasInlined), Checkers(checkers), Msg(msg),
- Eng(eng) {}
-
- CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
- CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
-
- void runChecker(CheckerManager::CheckObjCMessageFunc checkFn,
- NodeBuilder &Bldr, ExplodedNode *Pred) {
- bool IsPreVisit;
-
- switch (Kind) {
- case ObjCMessageVisitKind::Pre:
- IsPreVisit = true;
- break;
- case ObjCMessageVisitKind::MessageNil:
- case ObjCMessageVisitKind::Post:
- IsPreVisit = false;
- break;
- }
+struct CheckObjCMessageContext {
+ using CheckersTy = std::vector<CheckerManager::CheckObjCMessageFunc>;
- const ProgramPoint &L = Msg.getProgramPoint(IsPreVisit,checkFn.Checker);
- CheckerContext C(Bldr, Eng, Pred, L, WasInlined);
+ ObjCMessageVisitKind Kind;
+ bool WasInlined;
+ const CheckersTy &Checkers;
+ const ObjCMethodCall &Msg;
+ ExprEngine &Eng;
- checkFn(*Msg.cloneWithState<ObjCMethodCall>(Pred->getState()), C);
+ CheckObjCMessageContext(ObjCMessageVisitKind visitKind,
+ const CheckersTy &checkers, const ObjCMethodCall &msg,
+ ExprEngine &eng, bool wasInlined)
+ : Kind(visitKind), WasInlined(wasInlined), Checkers(checkers), Msg(msg),
+ Eng(eng) {}
+
+ CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
+ CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
+
+ void runChecker(CheckerManager::CheckObjCMessageFunc checkFn,
+ NodeBuilder &Bldr, ExplodedNode *Pred) {
+ bool IsPreVisit;
+
+ switch (Kind) {
+ case ObjCMessageVisitKind::Pre:
+ IsPreVisit = true;
+ break;
+ case ObjCMessageVisitKind::MessageNil:
+ case ObjCMessageVisitKind::Post:
+ IsPreVisit = false;
+ break;
}
- };
+
+ const ProgramPoint &L = Msg.getProgramPoint(IsPreVisit, checkFn.Checker);
+ CheckerContext C(Bldr, Eng, Pred, L, WasInlined);
+
+ checkFn(*Msg.cloneWithState<ObjCMethodCall>(Pred->getState()), C);
+ }
+};
} // namespace
@@ -262,33 +258,32 @@ CheckerManager::getObjCMessageCheckers(ObjCMessageVisitKind Kind) const {
namespace {
- // FIXME: This has all the same signatures as CheckObjCMessageContext.
- // Is there a way we can merge the two?
- struct CheckCallContext {
- using CheckersTy = std::vector<CheckerManager::CheckCallFunc>;
+// FIXME: This has all the same signatures as CheckObjCMessageContext.
+// Is there a way we can merge the two?
+struct CheckCallContext {
+ using CheckersTy = std::vector<CheckerManager::CheckCallFunc>;
- bool IsPreVisit, WasInlined;
- const CheckersTy &Checkers;
- const CallEvent &Call;
- ExprEngine &Eng;
+ bool IsPreVisit, WasInlined;
+ const CheckersTy &Checkers;
+ const CallEvent &Call;
+ ExprEngine &Eng;
- CheckCallContext(bool isPreVisit, const CheckersTy &checkers,
- const CallEvent &call, ExprEngine &eng,
- bool wasInlined)
- : IsPreVisit(isPreVisit), WasInlined(wasInlined), Checkers(checkers),
- Call(call), Eng(eng) {}
+ CheckCallContext(bool isPreVisit, const CheckersTy &checkers,
+ const CallEvent &call, ExprEngine &eng, bool wasInlined)
+ : IsPreVisit(isPreVisit), WasInlined(wasInlined), Checkers(checkers),
+ Call(call), Eng(eng) {}
- CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
- CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
+ CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
+ CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
- void runChecker(CheckerManager::CheckCallFunc checkFn,
- NodeBuilder &Bldr, ExplodedNode *Pred) {
- const ProgramPoint &L = Call.getProgramPoint(IsPreVisit,checkFn.Checker);
- CheckerContext C(Bldr, Eng, Pred, L, WasInlined);
+ void runChecker(CheckerManager::CheckCallFunc checkFn, NodeBuilder &Bldr,
+ ExplodedNode *Pred) {
+ const ProgramPoint &L = Call.getProgramPoint(IsPreVisit, checkFn.Checker);
+ CheckerContext C(Bldr, Eng, Pred, L, WasInlined);
- checkFn(*Call.cloneWithState(Pred->getState()), C);
- }
- };
+ checkFn(*Call.cloneWithState(Pred->getState()), C);
+ }
+};
} // namespace
@@ -297,101 +292,91 @@ void CheckerManager::runCheckersForCallEvent(bool isPreVisit,
ExplodedNodeSet &Dst,
const ExplodedNodeSet &Src,
const CallEvent &Call,
- ExprEngine &Eng,
- bool WasInlined) {
+ ExprEngine &Eng, bool WasInlined) {
CheckCallContext C(isPreVisit,
- isPreVisit ? PreCallCheckers
- : PostCallCheckers,
- Call, Eng, WasInlined);
+ isPreVisit ? PreCallCheckers : PostCallCheckers, Call, Eng,
+ WasInlined);
expandGraphWithCheckers(C, Dst, Src);
}
namespace {
- struct CheckLocationContext {
- using CheckersTy = std::vector<CheckerManager::CheckLocationFunc>;
-
- const CheckersTy &Checkers;
- SVal Loc;
- bool IsLoad;
- const Stmt *NodeEx; /* Will become a CFGStmt */
- const Stmt *BoundEx;
- ExprEngine &Eng;
-
- CheckLocationContext(const CheckersTy &checkers,
- SVal loc, bool isLoad, const Stmt *NodeEx,
- const Stmt *BoundEx,
- ExprEngine &eng)
- : Checkers(checkers), Loc(loc), IsLoad(isLoad), NodeEx(NodeEx),
- BoundEx(BoundEx), Eng(eng) {}
-
- CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
- CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
-
- void runChecker(CheckerManager::CheckLocationFunc checkFn,
- NodeBuilder &Bldr, ExplodedNode *Pred) {
- ProgramPoint::Kind K = IsLoad ? ProgramPoint::PreLoadKind :
- ProgramPoint::PreStoreKind;
- const ProgramPoint &L =
- ProgramPoint::getProgramPoint(NodeEx, K,
- Pred->getLocationContext(),
- checkFn.Checker);
- CheckerContext C(Bldr, Eng, Pred, L);
- checkFn(Loc, IsLoad, BoundEx, C);
- }
- };
+struct CheckLocationContext {
+ using CheckersTy = std::vector<CheckerManager::CheckLocationFunc>;
+
+ const CheckersTy &Checkers;
+ SVal Loc;
+ bool IsLoad;
+ const Stmt *NodeEx; /* Will become a CFGStmt */
+ const Stmt *BoundEx;
+ ExprEngine &Eng;
+
+ CheckLocationContext(const CheckersTy &checkers, SVal loc, bool isLoad,
+ const Stmt *NodeEx, const Stmt *BoundEx, ExprEngine &eng)
+ : Checkers(checkers), Loc(loc), IsLoad(isLoad), NodeEx(NodeEx),
+ BoundEx(BoundEx), Eng(eng) {}
+
+ CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
+ CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
+
+ void runChecker(CheckerManager::CheckLocationFunc checkFn, NodeBuilder &Bldr,
+ ExplodedNode *Pred) {
+ ProgramPoint::Kind K =
+ IsLoad ? ProgramPoint::PreLoadKind : ProgramPoint::PreStoreKind;
+ const ProgramPoint &L = ProgramPoint::getProgramPoint(
+ NodeEx, K, Pred->getLocationContext(), checkFn.Checker);
+ CheckerContext C(Bldr, Eng, Pred, L);
+ checkFn(Loc, IsLoad, BoundEx, C);
+ }
+};
} // namespace
/// Run checkers for load/store of a location.
-void CheckerManager::runCheckersForLocation(ExplodedNodeSet &Dst,
- const ExplodedNodeSet &Src,
- SVal location, bool isLoad,
- const Stmt *NodeEx,
- const Stmt *BoundEx,
- ExprEngine &Eng) {
- CheckLocationContext C(LocationCheckers, location, isLoad, NodeEx,
- BoundEx, Eng);
+void CheckerManager::runCheckersForLocation(
+ ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, SVal location,
+ bool isLoad, const Stmt *NodeEx, const Stmt *BoundEx, ExprEngine &Eng) {
+ CheckLocationContext C(LocationCheckers, location, isLoad, NodeEx, BoundEx,
+ Eng);
expandGraphWithCheckers(C, Dst, Src);
}
namespace {
- struct CheckBindContext {
- using CheckersTy = std::vector<CheckerManager::CheckBindFunc>;
+struct CheckBindContext {
+ using CheckersTy = std::vector<CheckerManager::CheckBindFunc>;
- const CheckersTy &Checkers;
- SVal Loc;
- SVal Val;
- const Stmt *S;
- ExprEngine &Eng;
- const ProgramPoint &PP;
+ const CheckersTy &Checkers;
+ SVal Loc;
+ SVal Val;
+ const Stmt *S;
+ ExprEngine &Eng;
+ const ProgramPoint &PP;
- CheckBindContext(const CheckersTy &checkers,
- SVal loc, SVal val, const Stmt *s, ExprEngine &eng,
- const ProgramPoint &pp)
- : Checkers(checkers), Loc(loc), Val(val), S(s), Eng(eng), PP(pp) {}
+ CheckBindContext(const CheckersTy &checkers, SVal loc, SVal val,
+ const Stmt *s, ExprEngine &eng, const ProgramPoint &pp)
+ : Checkers(checkers), Loc(loc), Val(val), S(s), Eng(eng), PP(pp) {}
- CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
- CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
+ CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
+ CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
- void runChecker(CheckerManager::CheckBindFunc checkFn,
- NodeBuilder &Bldr, ExplodedNode *Pred) {
- const ProgramPoint &L = PP.withTag(checkFn.Checker);
- CheckerContext C(Bldr, Eng, Pred, L);
+ void runChecker(CheckerManager::CheckBindFunc checkFn, NodeBuilder &Bldr,
+ ExplodedNode *Pred) {
+ const ProgramPoint &L = PP.withTag(checkFn.Checker);
+ CheckerContext C(Bldr, Eng, Pred, L);
- checkFn(Loc, Val, S, C);
- }
- };
+ checkFn(Loc, Val, S, C);
+ }
+};
} // namespace
/// Run checkers for binding of a value to a location.
void CheckerManager::runCheckersForBind(ExplodedNodeSet &Dst,
const ExplodedNodeSet &Src,
- SVal location, SVal val,
- const Stmt *S, ExprEngine &Eng,
+ SVal location, SVal val, const Stmt *S,
+ ExprEngine &Eng,
const ProgramPoint &PP) {
CheckBindContext C(BindCheckers, location, val, S, Eng, PP);
expandGraphWithCheckers(C, Dst, Src);
@@ -463,28 +448,28 @@ void CheckerManager::runCheckersForEndFunction(NodeBuilderContext &BC,
namespace {
- struct CheckBranchConditionContext {
- using CheckersTy = std::vector<CheckerManager::CheckBranchConditionFunc>;
+struct CheckBranchConditionContext {
+ using CheckersTy = std::vector<CheckerManager::CheckBranchConditionFunc>;
- const CheckersTy &Checkers;
- const Stmt *Condition;
- ExprEngine &Eng;
+ const CheckersTy &Checkers;
+ const Stmt *Condition;
+ ExprEngine &Eng;
- CheckBranchConditionContext(const CheckersTy &checkers,
- const Stmt *Cond, ExprEngine &eng)
- : Checkers(checkers), Condition(Cond), Eng(eng) {}
+ CheckBranchConditionContext(const CheckersTy &checkers, const Stmt *Cond,
+ ExprEngine &eng)
+ : Checkers(checkers), Condition(Cond), Eng(eng) {}
- CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
- CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
+ CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
+ CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
- void runChecker(CheckerManager::CheckBranchConditionFunc checkFn,
- NodeBuilder &Bldr, ExplodedNode *Pred) {
- ProgramPoint L = PostCondition(Condition, Pred->getLocationContext(),
- checkFn.Checker);
- CheckerContext C(Bldr, Eng, Pred, L);
- checkFn(Condition, C);
- }
- };
+ void runChecker(CheckerManager::CheckBranchConditionFunc checkFn,
+ NodeBuilder &Bldr, ExplodedNode *Pred) {
+ ProgramPoint L =
+ PostCondition(Condition, Pred->getLocationContext(), checkFn.Checker);
+ CheckerContext C(Bldr, Eng, Pred, L);
+ checkFn(Condition, C);
+ }
+};
} // namespace
@@ -501,31 +486,30 @@ void CheckerManager::runCheckersForBranchCondition(const Stmt *Condition,
namespace {
- struct CheckNewAllocatorContext {
- using CheckersTy = std::vector<CheckerManager::CheckNewAllocatorFunc>;
-
- const CheckersTy &Checkers;
- const CXXAllocatorCall &Call;
- bool WasInlined;
- ExprEngine &Eng;
-
- CheckNewAllocatorContext(const CheckersTy &Checkers,
- const CXXAllocatorCall &Call, bool WasInlined,
- ExprEngine &Eng)
- : Checkers(Checkers), Call(Call), WasInlined(WasInlined), Eng(Eng) {}
-
- CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
- CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
-
- void runChecker(CheckerManager::CheckNewAllocatorFunc checkFn,
- NodeBuilder &Bldr, ExplodedNode *Pred) {
- ProgramPoint L =
- PostAllocatorCall(Call.getOriginExpr(), Pred->getLocationContext());
- CheckerContext C(Bldr, Eng, Pred, L, WasInlined);
- checkFn(cast<CXXAllocatorCall>(*Call.cloneWithState(Pred->getState())),
- C);
- }
- };
+struct CheckNewAllocatorContext {
+ using CheckersTy = std::vector<CheckerManager::CheckNewAllocatorFunc>;
+
+ const CheckersTy &Checkers;
+ const CXXAllocatorCall &Call;
+ bool WasInlined;
+ ExprEngine &Eng;
+
+ CheckNewAllocatorContext(const CheckersTy &Checkers,
+ const CXXAllocatorCall &Call, bool WasInlined,
+ ExprEngine &Eng)
+ : Checkers(Checkers), Call(Call), WasInlined(WasInlined), Eng(Eng) {}
+
+ CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
+ CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
+
+ void runChecker(CheckerManager::CheckNewAllocatorFunc checkFn,
+ NodeBuilder &Bldr, ExplodedNode *Pred) {
+ ProgramPoint L =
+ PostAllocatorCall(Call.getOriginExpr(), Pred->getLocationContext());
+ CheckerContext C(Bldr, Eng, Pred, L, WasInlined);
+ checkFn(cast<CXXAllocatorCall>(*Call.cloneWithState(Pred->getState())), C);
+ }
+};
} // namespace
@@ -549,35 +533,34 @@ void CheckerManager::runCheckersForLiveSymbols(ProgramStateRef state,
namespace {
- struct CheckDeadSymbolsContext {
- using CheckersTy = std::vector<CheckerManager::CheckDeadSymbolsFunc>;
-
- const CheckersTy &Checkers;
- SymbolReaper &SR;
- const Stmt *S;
- ExprEngine &Eng;
- ProgramPoint::Kind ProgarmPointKind;
-
- CheckDeadSymbolsContext(const CheckersTy &checkers, SymbolReaper &sr,
- const Stmt *s, ExprEngine &eng,
- ProgramPoint::Kind K)
- : Checkers(checkers), SR(sr), S(s), Eng(eng), ProgarmPointKind(K) {}
-
- CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
- CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
-
- void runChecker(CheckerManager::CheckDeadSymbolsFunc checkFn,
- NodeBuilder &Bldr, ExplodedNode *Pred) {
- const ProgramPoint &L = ProgramPoint::getProgramPoint(S, ProgarmPointKind,
- Pred->getLocationContext(), checkFn.Checker);
- CheckerContext C(Bldr, Eng, Pred, L);
-
- // Note, do not pass the statement to the checkers without letting them
- // differentiate if we ran remove dead bindings before or after the
- // statement.
- checkFn(SR, C);
- }
- };
+struct CheckDeadSymbolsContext {
+ using CheckersTy = std::vector<CheckerManager::CheckDeadSymbolsFunc>;
+
+ const CheckersTy &Checkers;
+ SymbolReaper &SR;
+ const Stmt *S;
+ ExprEngine &Eng;
+ ProgramPoint::Kind ProgarmPointKind;
+
+ CheckDeadSymbolsContext(const CheckersTy &checkers, SymbolReaper &sr,
+ const Stmt *s, ExprEngine &eng, ProgramPoint::Kind K)
+ : Checkers(checkers), SR(sr), S(s), Eng(eng), ProgarmPointKind(K) {}
+
+ CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
+ CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
+
+ void runChecker(CheckerManager::CheckDeadSymbolsFunc checkFn,
+ NodeBuilder &Bldr, ExplodedNode *Pred) {
+ const ProgramPoint &L = ProgramPoint::getProgramPoint(
+ S, ProgarmPointKind, Pred->getLocationContext(), checkFn.Checker);
+ CheckerContext C(Bldr, Eng, Pred, L);
+
+ // Note, do not pass the statement to the checkers without letting them
+ // differentiate if we ran remove dead bindings before or after the
+ // statement.
+ checkFn(SR, C);
+ }
+};
} // namespace
@@ -585,21 +568,18 @@ namespace {
void CheckerManager::runCheckersForDeadSymbols(ExplodedNodeSet &Dst,
const ExplodedNodeSet &Src,
SymbolReaper &SymReaper,
- const Stmt *S,
- ExprEngine &Eng,
+ const Stmt *S, ExprEngine &Eng,
ProgramPoint::Kind K) {
CheckDeadSymbolsContext C(DeadSymbolsCheckers, SymReaper, S, Eng, K);
expandGraphWithCheckers(C, Dst, Src);
}
/// Run checkers for region changes.
-ProgramStateRef
-CheckerManager::runCheckersForRegionChanges(ProgramStateRef state,
- const InvalidatedSymbols *invalidated,
- ArrayRef<const MemRegion *> ExplicitRegions,
- ArrayRef<const MemRegion *> Regions,
- const LocationContext *LCtx,
- const CallEvent *Call) {
+ProgramStateRef CheckerManager::runCheckersForRegionChanges(
+ ProgramStateRef state, const InvalidatedSymbols *invalidated,
+ ArrayRef<const MemRegion *> ExplicitRegions,
+ ArrayRef<const MemRegion *> Regions, const LocationContext *LCtx,
+ const CallEvent *Call) {
for (const auto &RegionChangesChecker : RegionChangesCheckers) {
// If any checker declares the state infeasible (or if it starts that way),
// bail out.
@@ -612,15 +592,12 @@ CheckerManager::runCheckersForRegionChanges(ProgramStateRef state,
}
/// Run checkers to process symbol escape event.
-ProgramStateRef
-CheckerManager::runCheckersForPointerEscape(ProgramStateRef State,
- const InvalidatedSymbols &Escaped,
- const CallEvent *Call,
- PointerEscapeKind Kind,
- RegionAndSymbolInvalidationTraits *ETraits) {
- assert((Call != nullptr ||
- (Kind != PSK_DirectEscapeOnCall &&
- Kind != PSK_IndirectEscapeOnCall)) &&
+ProgramStateRef CheckerManager::runCheckersForPointerEscape(
+ ProgramStateRef State, const InvalidatedSymbols &Escaped,
+ const CallEvent *Call, PointerEscapeKind Kind,
+ RegionAndSymbolInvalidationTraits *ETraits) {
+ assert((Call != nullptr || (Kind != PSK_DirectEscapeOnCall &&
+ Kind != PSK_IndirectEscapeOnCall)) &&
"Call must not be NULL when escaping on call");
for (const auto &PointerEscapeChecker : PointerEscapeCheckers) {
// If any checker declares the state infeasible (or if it starts that
@@ -633,9 +610,9 @@ CheckerManager::runCheckersForPointerEscape(ProgramStateRef State,
}
/// Run checkers for handling assumptions on symbolic values.
-ProgramStateRef
-CheckerManager::runCheckersForEvalAssume(ProgramStateRef state,
- SVal Cond, bool Assumption) {
+ProgramStateRef CheckerManager::runCheckersForEvalAssume(ProgramStateRef state,
+ SVal Cond,
+ bool Assumption) {
for (const auto &EvalAssumeChecker : EvalAssumeCheckers) {
// If any checker declares the state infeasible (or if it starts that way),
// bail out.
@@ -710,9 +687,7 @@ void CheckerManager::runCheckersForEvalCall(ExplodedNodeSet &Dst,
/// Run checkers for the entire Translation Unit.
void CheckerManager::runCheckersOnEndOfTranslationUnit(
- const TranslationUnitDecl *TU,
- AnalysisManager &mgr,
- BugReporter &BR) {
+ const TranslationUnitDecl *TU, AnalysisManager &mgr, BugReporter &BR) {
for (const auto &EndOfTranslationUnitChecker : EndOfTranslationUnitCheckers)
EndOfTranslationUnitChecker(TU, mgr, BR);
}
@@ -732,8 +707,8 @@ void CheckerManager::runCheckersForPrintStateJson(raw_ostream &Out,
// Create the new-line in JSON with enough space.
SmallString<128> NewLine;
llvm::raw_svector_ostream NLOut(NewLine);
- NLOut << "\", " << NL; // Inject the ending and a new line
- Indent(NLOut, InnerSpace, IsDot) << "\""; // then begin the next message.
+ NLOut << "\", " << NL; // Inject the ending and a new line
+ Indent(NLOut, InnerSpace, IsDot) << "\""; // then begin the next message.
++Space;
bool HasMessage = false;
@@ -792,7 +767,7 @@ void CheckerManager::runCheckersForPrintStateJson(raw_ostream &Out,
void CheckerManager::_registerForDecl(CheckDeclFunc checkfn,
HandlesDeclFunc isForDeclFn) {
- DeclCheckerInfo info = { checkfn, isForDeclFn };
+ DeclCheckerInfo info = {checkfn, isForDeclFn};
DeclCheckers.push_back(info);
}
@@ -806,13 +781,13 @@ void CheckerManager::_registerForBody(CheckDeclFunc checkfn) {
void CheckerManager::_registerForPreStmt(CheckStmtFunc checkfn,
HandlesStmtFunc isForStmtFn) {
- StmtCheckerInfo info = { checkfn, isForStmtFn, /*IsPreVisit*/true };
+ StmtCheckerInfo info = {checkfn, isForStmtFn, /*IsPreVisit*/ true};
StmtCheckers.push_back(info);
}
void CheckerManager::_registerForPostStmt(CheckStmtFunc checkfn,
HandlesStmtFunc isForStmtFn) {
- StmtCheckerInfo info = { checkfn, isForStmtFn, /*IsPreVisit*/false };
+ StmtCheckerInfo info = {checkfn, isForStmtFn, /*IsPreVisit*/ false};
StmtCheckers.push_back(info);
}
@@ -856,7 +831,7 @@ void CheckerManager::_registerForEndFunction(CheckEndFunctionFunc checkfn) {
}
void CheckerManager::_registerForBranchCondition(
- CheckBranchConditionFunc checkfn) {
+ CheckBranchConditionFunc checkfn) {
BranchConditionCheckers.push_back(checkfn);
}
@@ -876,12 +851,12 @@ void CheckerManager::_registerForRegionChanges(CheckRegionChangesFunc checkfn) {
RegionChangesCheckers.push_back(checkfn);
}
-void CheckerManager::_registerForPointerEscape(CheckPointerEscapeFunc checkfn){
+void CheckerManager::_registerForPointerEscape(CheckPointerEscapeFunc checkfn) {
PointerEscapeCheckers.push_back(checkfn);
}
void CheckerManager::_registerForConstPointerEscape(
- CheckPointerEscapeFunc checkfn) {
+ CheckPointerEscapeFunc checkfn) {
PointerEscapeCheckers.push_back(checkfn);
}
@@ -894,7 +869,7 @@ void CheckerManager::_registerForEvalCall(EvalCallFunc checkfn) {
}
void CheckerManager::_registerForEndOfTranslationUnit(
- CheckEndOfTranslationUnit checkfn) {
+ CheckEndOfTranslationUnit checkfn) {
EndOfTranslationUnitCheckers.push_back(checkfn);
}
diff --git a/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp b/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp
index d3499e7a917d34..8ca1d1fa7a9111 100644
--- a/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp
+++ b/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp
@@ -41,14 +41,12 @@ using namespace ento;
#define DEBUG_TYPE "CoreEngine"
-STATISTIC(NumSteps,
- "The # of steps executed.");
+STATISTIC(NumSteps, "The # of steps executed.");
STATISTIC(NumSTUSteps, "The # of STU steps executed.");
STATISTIC(NumCTUSteps, "The # of CTU steps executed.");
STATISTIC(NumReachedMaxSteps,
- "The # of times we reached the max number of steps.");
-STATISTIC(NumPathsExplored,
- "The # of paths explored by the analyzer.");
+ "The # of times we reached the max number of steps.");
+STATISTIC(NumPathsExplored, "The # of paths explored by the analyzer.");
//===----------------------------------------------------------------------===//
// Core analysis engine.
@@ -56,18 +54,18 @@ STATISTIC(NumPathsExplored,
static std::unique_ptr<WorkList> generateWorkList(AnalyzerOptions &Opts) {
switch (Opts.getExplorationStrategy()) {
- case ExplorationStrategyKind::DFS:
- return WorkList::makeDFS();
- case ExplorationStrategyKind::BFS:
- return WorkList::makeBFS();
- case ExplorationStrategyKind::BFSBlockDFSContents:
- return WorkList::makeBFSBlockDFSContents();
- case ExplorationStrategyKind::UnexploredFirst:
- return WorkList::makeUnexploredFirst();
- case ExplorationStrategyKind::UnexploredFirstQueue:
- return WorkList::makeUnexploredFirstPriorityQueue();
- case ExplorationStrategyKind::UnexploredFirstLocationQueue:
- return WorkList::makeUnexploredFirstPriorityLocationQueue();
+ case ExplorationStrategyKind::DFS:
+ return WorkList::makeDFS();
+ case ExplorationStrategyKind::BFS:
+ return WorkList::makeBFS();
+ case ExplorationStrategyKind::BFSBlockDFSContents:
+ return WorkList::makeBFSBlockDFSContents();
+ case ExplorationStrategyKind::UnexploredFirst:
+ return WorkList::makeUnexploredFirst();
+ case ExplorationStrategyKind::UnexploredFirstQueue:
+ return WorkList::makeUnexploredFirstPriorityQueue();
+ case ExplorationStrategyKind::UnexploredFirstLocationQueue:
+ return WorkList::makeUnexploredFirstPriorityLocationQueue();
}
llvm_unreachable("Unknown AnalyzerOptions::ExplorationStrategyKind");
}
@@ -97,8 +95,7 @@ bool CoreEngine::ExecuteWorkList(const LocationContext *L, unsigned MaxSteps,
assert(Entry->succ_size() == 1 && "Entry block must have 1 successor.");
// Mark the entry block as visited.
- FunctionSummaries->markVisitedBasicBlock(Entry->getBlockID(),
- L->getDecl(),
+ FunctionSummaries->markVisitedBasicBlock(Entry->getBlockID(), L->getDecl(),
L->getCFG()->getNumBlockIDs());
// Get the solitary successor.
@@ -132,7 +129,7 @@ bool CoreEngine::ExecuteWorkList(const LocationContext *L, unsigned MaxSteps,
// Cap our pre-reservation in the event that the user specifies
// a very large number of maximum steps.
const unsigned PreReservationCap = 4000000;
- if(!UnlimitedSteps)
+ if (!UnlimitedSteps)
G.reserve(std::min(MaxSteps, PreReservationCap));
auto ProcessWList = [this, UnlimitedSteps](unsigned MaxSteps) {
@@ -179,46 +176,43 @@ bool CoreEngine::ExecuteWorkList(const LocationContext *L, unsigned MaxSteps,
return WList->hasWork();
}
-void CoreEngine::dispatchWorkItem(ExplodedNode* Pred, ProgramPoint Loc,
- const WorkListUnit& WU) {
+void CoreEngine::dispatchWorkItem(ExplodedNode *Pred, ProgramPoint Loc,
+ const WorkListUnit &WU) {
// Dispatch on the location type.
switch (Loc.getKind()) {
- case ProgramPoint::BlockEdgeKind:
- HandleBlockEdge(Loc.castAs<BlockEdge>(), Pred);
- break;
-
- case ProgramPoint::BlockEntranceKind:
- HandleBlockEntrance(Loc.castAs<BlockEntrance>(), Pred);
- break;
-
- case ProgramPoint::BlockExitKind:
- assert(false && "BlockExit location never occur in forward analysis.");
- break;
-
- case ProgramPoint::CallEnterKind:
- HandleCallEnter(Loc.castAs<CallEnter>(), Pred);
- break;
-
- case ProgramPoint::CallExitBeginKind:
- ExprEng.processCallExit(Pred);
- break;
-
- case ProgramPoint::EpsilonKind: {
- assert(Pred->hasSinglePred() &&
- "Assume epsilon has exactly one predecessor by construction");
- ExplodedNode *PNode = Pred->getFirstPred();
- dispatchWorkItem(Pred, PNode->getLocation(), WU);
- break;
- }
- default:
- assert(Loc.getAs<PostStmt>() ||
- Loc.getAs<PostInitializer>() ||
- Loc.getAs<PostImplicitCall>() ||
- Loc.getAs<CallExitEnd>() ||
- Loc.getAs<LoopExit>() ||
- Loc.getAs<PostAllocatorCall>());
- HandlePostStmt(WU.getBlock(), WU.getIndex(), Pred);
- break;
+ case ProgramPoint::BlockEdgeKind:
+ HandleBlockEdge(Loc.castAs<BlockEdge>(), Pred);
+ break;
+
+ case ProgramPoint::BlockEntranceKind:
+ HandleBlockEntrance(Loc.castAs<BlockEntrance>(), Pred);
+ break;
+
+ case ProgramPoint::BlockExitKind:
+ assert(false && "BlockExit location never occur in forward analysis.");
+ break;
+
+ case ProgramPoint::CallEnterKind:
+ HandleCallEnter(Loc.castAs<CallEnter>(), Pred);
+ break;
+
+ case ProgramPoint::CallExitBeginKind:
+ ExprEng.processCallExit(Pred);
+ break;
+
+ case ProgramPoint::EpsilonKind: {
+ assert(Pred->hasSinglePred() &&
+ "Assume epsilon has exactly one predecessor by construction");
+ ExplodedNode *PNode = Pred->getFirstPred();
+ dispatchWorkItem(Pred, PNode->getLocation(), WU);
+ break;
+ }
+ default:
+ assert(Loc.getAs<PostStmt>() || Loc.getAs<PostInitializer>() ||
+ Loc.getAs<PostImplicitCall>() || Loc.getAs<CallExitEnd>() ||
+ Loc.getAs<LoopExit>() || Loc.getAs<PostAllocatorCall>());
+ HandlePostStmt(WU.getBlock(), WU.getIndex(), Pred);
+ break;
}
}
@@ -240,8 +234,7 @@ void CoreEngine::HandleBlockEdge(const BlockEdge &L, ExplodedNode *Pred) {
// Mark this block as visited.
const LocationContext *LC = Pred->getLocationContext();
- FunctionSummaries->markVisitedBasicBlock(Blk->getBlockID(),
- LC->getDecl(),
+ FunctionSummaries->markVisitedBasicBlock(Blk->getBlockID(), LC->getDecl(),
LC->getCFG()->getNumBlockIDs());
// Display a prunable path note to the user if it's a virtual bases branch
@@ -304,13 +297,13 @@ void CoreEngine::HandleBlockEdge(const BlockEdge &L, ExplodedNode *Pred) {
}
void CoreEngine::HandleBlockEntrance(const BlockEntrance &L,
- ExplodedNode *Pred) {
+ ExplodedNode *Pred) {
// Increment the block counter.
const LocationContext *LC = Pred->getLocationContext();
unsigned BlockId = L.getBlock()->getBlockID();
BlockCounter Counter = WList->getBlockCounter();
- Counter = BCounterFactory.IncrementCount(Counter, LC->getStackFrame(),
- BlockId);
+ Counter =
+ BCounterFactory.IncrementCount(Counter, LC->getStackFrame(), BlockId);
setBlockCounter(Counter);
// Process the entrance of the block.
@@ -321,115 +314,116 @@ void CoreEngine::HandleBlockEntrance(const BlockEntrance &L,
HandleBlockExit(L.getBlock(), Pred);
}
-void CoreEngine::HandleBlockExit(const CFGBlock * B, ExplodedNode *Pred) {
+void CoreEngine::HandleBlockExit(const CFGBlock *B, ExplodedNode *Pred) {
if (const Stmt *Term = B->getTerminatorStmt()) {
switch (Term->getStmtClass()) {
- default:
- llvm_unreachable("Analysis for this terminator not implemented.");
-
- case Stmt::CXXBindTemporaryExprClass:
- HandleCleanupTemporaryBranch(
- cast<CXXBindTemporaryExpr>(Term), B, Pred);
- return;
-
- // Model static initializers.
- case Stmt::DeclStmtClass:
- HandleStaticInit(cast<DeclStmt>(Term), B, Pred);
- return;
-
- case Stmt::BinaryOperatorClass: // '&&' and '||'
- HandleBranch(cast<BinaryOperator>(Term)->getLHS(), Term, B, Pred);
- return;
-
- case Stmt::BinaryConditionalOperatorClass:
- case Stmt::ConditionalOperatorClass:
- HandleBranch(cast<AbstractConditionalOperator>(Term)->getCond(),
- Term, B, Pred);
- return;
-
- // FIXME: Use constant-folding in CFG construction to simplify this
- // case.
-
- case Stmt::ChooseExprClass:
- HandleBranch(cast<ChooseExpr>(Term)->getCond(), Term, B, Pred);
- return;
-
- case Stmt::CXXTryStmtClass:
- // Generate a node for each of the successors.
- // Our logic for EH analysis can certainly be improved.
- for (CFGBlock::const_succ_iterator it = B->succ_begin(),
- et = B->succ_end(); it != et; ++it) {
- if (const CFGBlock *succ = *it) {
- generateNode(BlockEdge(B, succ, Pred->getLocationContext()),
- Pred->State, Pred);
- }
+ default:
+ llvm_unreachable("Analysis for this terminator not implemented.");
+
+ case Stmt::CXXBindTemporaryExprClass:
+ HandleCleanupTemporaryBranch(cast<CXXBindTemporaryExpr>(Term), B, Pred);
+ return;
+
+ // Model static initializers.
+ case Stmt::DeclStmtClass:
+ HandleStaticInit(cast<DeclStmt>(Term), B, Pred);
+ return;
+
+ case Stmt::BinaryOperatorClass: // '&&' and '||'
+ HandleBranch(cast<BinaryOperator>(Term)->getLHS(), Term, B, Pred);
+ return;
+
+ case Stmt::BinaryConditionalOperatorClass:
+ case Stmt::ConditionalOperatorClass:
+ HandleBranch(cast<AbstractConditionalOperator>(Term)->getCond(), Term, B,
+ Pred);
+ return;
+
+ // FIXME: Use constant-folding in CFG construction to simplify this
+ // case.
+
+ case Stmt::ChooseExprClass:
+ HandleBranch(cast<ChooseExpr>(Term)->getCond(), Term, B, Pred);
+ return;
+
+ case Stmt::CXXTryStmtClass:
+ // Generate a node for each of the successors.
+ // Our logic for EH analysis can certainly be improved.
+ for (CFGBlock::const_succ_iterator it = B->succ_begin(),
+ et = B->succ_end();
+ it != et; ++it) {
+ if (const CFGBlock *succ = *it) {
+ generateNode(BlockEdge(B, succ, Pred->getLocationContext()),
+ Pred->State, Pred);
}
- return;
+ }
+ return;
- case Stmt::DoStmtClass:
- HandleBranch(cast<DoStmt>(Term)->getCond(), Term, B, Pred);
- return;
+ case Stmt::DoStmtClass:
+ HandleBranch(cast<DoStmt>(Term)->getCond(), Term, B, Pred);
+ return;
- case Stmt::CXXForRangeStmtClass:
- HandleBranch(cast<CXXForRangeStmt>(Term)->getCond(), Term, B, Pred);
- return;
+ case Stmt::CXXForRangeStmtClass:
+ HandleBranch(cast<CXXForRangeStmt>(Term)->getCond(), Term, B, Pred);
+ return;
- case Stmt::ForStmtClass:
- HandleBranch(cast<ForStmt>(Term)->getCond(), Term, B, Pred);
- return;
+ case Stmt::ForStmtClass:
+ HandleBranch(cast<ForStmt>(Term)->getCond(), Term, B, Pred);
+ return;
- case Stmt::SEHLeaveStmtClass:
- case Stmt::ContinueStmtClass:
- case Stmt::BreakStmtClass:
- case Stmt::GotoStmtClass:
- break;
+ case Stmt::SEHLeaveStmtClass:
+ case Stmt::ContinueStmtClass:
+ case Stmt::BreakStmtClass:
+ case Stmt::GotoStmtClass:
+ break;
- case Stmt::IfStmtClass:
- HandleBranch(cast<IfStmt>(Term)->getCond(), Term, B, Pred);
- return;
+ case Stmt::IfStmtClass:
+ HandleBranch(cast<IfStmt>(Term)->getCond(), Term, B, Pred);
+ return;
- case Stmt::IndirectGotoStmtClass: {
- // Only 1 successor: the indirect goto dispatch block.
- assert(B->succ_size() == 1);
+ case Stmt::IndirectGotoStmtClass: {
+ // Only 1 successor: the indirect goto dispatch block.
+ assert(B->succ_size() == 1);
- IndirectGotoNodeBuilder
- builder(Pred, B, cast<IndirectGotoStmt>(Term)->getTarget(),
- *(B->succ_begin()), this);
+ IndirectGotoNodeBuilder builder(Pred, B,
+ cast<IndirectGotoStmt>(Term)->getTarget(),
+ *(B->succ_begin()), this);
- ExprEng.processIndirectGoto(builder);
- return;
- }
+ ExprEng.processIndirectGoto(builder);
+ return;
+ }
- case Stmt::ObjCForCollectionStmtClass:
- // In the case of ObjCForCollectionStmt, it appears twice in a CFG:
- //
- // (1) inside a basic block, which represents the binding of the
- // 'element' variable to a value.
- // (2) in a terminator, which represents the branch.
- //
- // For (1), ExprEngine will bind a value (i.e., 0 or 1) indicating
- // whether or not collection contains any more elements. We cannot
- // just test to see if the element is nil because a container can
- // contain nil elements.
- HandleBranch(Term, Term, B, Pred);
- return;
-
- case Stmt::SwitchStmtClass: {
- SwitchNodeBuilder builder(Pred, B, cast<SwitchStmt>(Term)->getCond(),
- this);
-
- ExprEng.processSwitch(builder);
- return;
- }
+ case Stmt::ObjCForCollectionStmtClass:
+ // In the case of ObjCForCollectionStmt, it appears twice in a CFG:
+ //
+ // (1) inside a basic block, which represents the binding of the
+ // 'element' variable to a value.
+ // (2) in a terminator, which represents the branch.
+ //
+ // For (1), ExprEngine will bind a value (i.e., 0 or 1) indicating
+ // whether or not collection contains any more elements. We cannot
+ // just test to see if the element is nil because a container can
+ // contain nil elements.
+ HandleBranch(Term, Term, B, Pred);
+ return;
- case Stmt::WhileStmtClass:
- HandleBranch(cast<WhileStmt>(Term)->getCond(), Term, B, Pred);
- return;
+ case Stmt::SwitchStmtClass: {
+ SwitchNodeBuilder builder(Pred, B, cast<SwitchStmt>(Term)->getCond(),
+ this);
- case Stmt::GCCAsmStmtClass:
- assert(cast<GCCAsmStmt>(Term)->isAsmGoto() && "Encountered GCCAsmStmt without labels");
- // TODO: Handle jumping to labels
- return;
+ ExprEng.processSwitch(builder);
+ return;
+ }
+
+ case Stmt::WhileStmtClass:
+ HandleBranch(cast<WhileStmt>(Term)->getCond(), Term, B, Pred);
+ return;
+
+ case Stmt::GCCAsmStmtClass:
+ assert(cast<GCCAsmStmt>(Term)->isAsmGoto() &&
+ "Encountered GCCAsmStmt without labels");
+ // TODO: Handle jumping to labels
+ return;
}
}
@@ -451,12 +445,12 @@ void CoreEngine::HandleCallEnter(const CallEnter &CE, ExplodedNode *Pred) {
}
void CoreEngine::HandleBranch(const Stmt *Cond, const Stmt *Term,
- const CFGBlock * B, ExplodedNode *Pred) {
+ const CFGBlock *B, ExplodedNode *Pred) {
assert(B->succ_size() == 2);
NodeBuilderContext Ctx(*this, B, Pred);
ExplodedNodeSet Dst;
ExprEng.processBranch(Cond, Ctx, Pred, Dst, *(B->succ_begin()),
- *(B->succ_begin() + 1));
+ *(B->succ_begin() + 1));
// Enqueue the new frontier onto the worklist.
enqueue(Dst);
}
@@ -468,7 +462,7 @@ void CoreEngine::HandleCleanupTemporaryBranch(const CXXBindTemporaryExpr *BTE,
NodeBuilderContext Ctx(*this, B, Pred);
ExplodedNodeSet Dst;
ExprEng.processCleanupTemporaryBranch(BTE, Ctx, Pred, Dst, *(B->succ_begin()),
- *(B->succ_begin() + 1));
+ *(B->succ_begin() + 1));
// Enqueue the new frontier onto the worklist.
enqueue(Dst);
}
@@ -478,8 +472,8 @@ void CoreEngine::HandleStaticInit(const DeclStmt *DS, const CFGBlock *B,
assert(B->succ_size() == 2);
NodeBuilderContext Ctx(*this, B, Pred);
ExplodedNodeSet Dst;
- ExprEng.processStaticInitializer(DS, Ctx, Pred, Dst,
- *(B->succ_begin()), *(B->succ_begin()+1));
+ ExprEng.processStaticInitializer(DS, Ctx, Pred, Dst, *(B->succ_begin()),
+ *(B->succ_begin() + 1));
// Enqueue the new frontier onto the worklist.
enqueue(Dst);
}
@@ -522,8 +516,7 @@ void CoreEngine::HandleVirtualBaseBranch(const CFGBlock *B,
/// generateNode - Utility method to generate nodes, hook up successors,
/// and add nodes to the worklist.
-void CoreEngine::generateNode(const ProgramPoint &Loc,
- ProgramStateRef State,
+void CoreEngine::generateNode(const ProgramPoint &Loc, ProgramStateRef State,
ExplodedNode *Pred) {
bool IsNew;
ExplodedNode *Node = G.getNode(Loc, State, false, &IsNew);
@@ -536,11 +529,12 @@ void CoreEngine::generateNode(const ProgramPoint &Loc,
}
// Only add 'Node' to the worklist if it was freshly generated.
- if (IsNew) WList->enqueue(Node);
+ if (IsNew)
+ WList->enqueue(Node);
}
-void CoreEngine::enqueueStmtNode(ExplodedNode *N,
- const CFGBlock *Block, unsigned Idx) {
+void CoreEngine::enqueueStmtNode(ExplodedNode *N, const CFGBlock *Block,
+ unsigned Idx) {
assert(Block);
assert(!N->isSink());
@@ -554,9 +548,9 @@ void CoreEngine::enqueueStmtNode(ExplodedNode *N,
// Do not create extra nodes. Move to the next CFG element.
if (N->getLocation().getAs<PostInitializer>() ||
- N->getLocation().getAs<PostImplicitCall>()||
+ N->getLocation().getAs<PostImplicitCall>() ||
N->getLocation().getAs<LoopExit>()) {
- WList->enqueue(N, Block, Idx+1);
+ WList->enqueue(N, Block, Idx + 1);
return;
}
@@ -566,7 +560,7 @@ void CoreEngine::enqueueStmtNode(ExplodedNode *N,
}
if ((*Block)[Idx].getKind() == CFGElement::NewAllocator) {
- WList->enqueue(N, Block, Idx+1);
+ WList->enqueue(N, Block, Idx + 1);
return;
}
@@ -577,7 +571,7 @@ void CoreEngine::enqueueStmtNode(ExplodedNode *N,
if (Loc == N->getLocation().withTag(nullptr)) {
// Note: 'N' should be a fresh node because otherwise it shouldn't be
// a member of Deferred.
- WList->enqueue(N, Block, Idx+1);
+ WList->enqueue(N, Block, Idx + 1);
return;
}
@@ -586,7 +580,7 @@ void CoreEngine::enqueueStmtNode(ExplodedNode *N,
Succ->addPredecessor(N, G);
if (IsNew)
- WList->enqueue(Succ, Block, Idx+1);
+ WList->enqueue(Succ, Block, Idx + 1);
}
ExplodedNode *CoreEngine::generateCallExitBeginNode(ExplodedNode *N,
@@ -608,13 +602,14 @@ void CoreEngine::enqueue(ExplodedNodeSet &Set) {
WList->enqueue(I);
}
-void CoreEngine::enqueue(ExplodedNodeSet &Set,
- const CFGBlock *Block, unsigned Idx) {
+void CoreEngine::enqueue(ExplodedNodeSet &Set, const CFGBlock *Block,
+ unsigned Idx) {
for (const auto I : Set)
enqueueStmtNode(I, Block, Idx);
}
-void CoreEngine::enqueueEndOfFunction(ExplodedNodeSet &Set, const ReturnStmt *RS) {
+void CoreEngine::enqueueEndOfFunction(ExplodedNodeSet &Set,
+ const ReturnStmt *RS) {
for (auto *I : Set) {
// If we are in an inlined call, generate CallExitBegin node.
if (I->getLocationContext()->getParent()) {
@@ -631,7 +626,7 @@ void CoreEngine::enqueueEndOfFunction(ExplodedNodeSet &Set, const ReturnStmt *RS
void NodeBuilder::anchor() {}
-ExplodedNode* NodeBuilder::generateNodeImpl(const ProgramPoint &Loc,
+ExplodedNode *NodeBuilder::generateNodeImpl(const ProgramPoint &Loc,
ProgramStateRef State,
ExplodedNode *FromN,
bool MarkAsSink) {
@@ -667,16 +662,15 @@ ExplodedNode *BranchNodeBuilder::generateNode(ProgramStateRef State,
if (!isFeasible(branch))
return nullptr;
- ProgramPoint Loc = BlockEdge(C.Block, branch ? DstT:DstF,
- NodePred->getLocationContext());
+ ProgramPoint Loc =
+ BlockEdge(C.Block, branch ? DstT : DstF, NodePred->getLocationContext());
ExplodedNode *Succ = generateNodeImpl(Loc, State, NodePred);
return Succ;
}
-ExplodedNode*
-IndirectGotoNodeBuilder::generateNode(const iterator &I,
- ProgramStateRef St,
- bool IsSink) {
+ExplodedNode *IndirectGotoNodeBuilder::generateNode(const iterator &I,
+ ProgramStateRef St,
+ bool IsSink) {
bool IsNew;
ExplodedNode *Succ =
Eng.G.getNode(BlockEdge(Src, I.getBlock(), Pred->getLocationContext()),
@@ -692,9 +686,8 @@ IndirectGotoNodeBuilder::generateNode(const iterator &I,
return Succ;
}
-ExplodedNode*
-SwitchNodeBuilder::generateCaseStmtNode(const iterator &I,
- ProgramStateRef St) {
+ExplodedNode *SwitchNodeBuilder::generateCaseStmtNode(const iterator &I,
+ ProgramStateRef St) {
bool IsNew;
ExplodedNode *Succ =
Eng.G.getNode(BlockEdge(Src, I.getBlock(), Pred->getLocationContext()),
@@ -707,9 +700,8 @@ SwitchNodeBuilder::generateCaseStmtNode(const iterator &I,
return Succ;
}
-ExplodedNode*
-SwitchNodeBuilder::generateDefaultCaseNode(ProgramStateRef St,
- bool IsSink) {
+ExplodedNode *SwitchNodeBuilder::generateDefaultCaseNode(ProgramStateRef St,
+ bool IsSink) {
// Get the block for the default case.
assert(Src->succ_rbegin() != Src->succ_rend());
CFGBlock *DefaultBlock = *Src->succ_rbegin();
diff --git a/clang/lib/StaticAnalyzer/Core/Environment.cpp b/clang/lib/StaticAnalyzer/Core/Environment.cpp
index 427f51109853bd..4b12f6ca72936d 100644
--- a/clang/lib/StaticAnalyzer/Core/Environment.cpp
+++ b/clang/lib/StaticAnalyzer/Core/Environment.cpp
@@ -72,13 +72,11 @@ static const Stmt *ignoreTransparentExprs(const Stmt *S) {
}
EnvironmentEntry::EnvironmentEntry(const Stmt *S, const LocationContext *L)
- : std::pair<const Stmt *,
- const StackFrameContext *>(ignoreTransparentExprs(S),
- L ? L->getStackFrame()
- : nullptr) {}
+ : std::pair<const Stmt *, const StackFrameContext *>(
+ ignoreTransparentExprs(S), L ? L->getStackFrame() : nullptr) {}
SVal Environment::lookupExpr(const EnvironmentEntry &E) const {
- const SVal* X = ExprBindings.lookup(E);
+ const SVal *X = ExprBindings.lookup(E);
if (X) {
SVal V = *X;
return V;
@@ -87,7 +85,7 @@ SVal Environment::lookupExpr(const EnvironmentEntry &E) const {
}
SVal Environment::getSVal(const EnvironmentEntry &Entry,
- SValBuilder& svalBuilder) const {
+ SValBuilder &svalBuilder) const {
const Stmt *S = Entry.getStmt();
assert(!isa<ObjCForCollectionStmt>(S) &&
"Use ExprEngine::hasMoreIteration()!");
@@ -136,8 +134,7 @@ SVal Environment::getSVal(const EnvironmentEntry &Entry,
}
Environment EnvironmentManager::bindExpr(Environment Env,
- const EnvironmentEntry &E,
- SVal V,
+ const EnvironmentEntry &E, SVal V,
bool Invalidate) {
if (V.isUnknown()) {
if (Invalidate)
@@ -176,10 +173,9 @@ class MarkLiveCallback final : public SymbolVisitor {
// - Mark their reachable symbols live in SymbolReaper,
// see ScanReachableSymbols.
// - Mark the region in DRoots if the binding is a loc::MemRegionVal.
-Environment
-EnvironmentManager::removeDeadBindings(Environment Env,
- SymbolReaper &SymReaper,
- ProgramStateRef ST) {
+Environment EnvironmentManager::removeDeadBindings(Environment Env,
+ SymbolReaper &SymReaper,
+ ProgramStateRef ST) {
// We construct a new Environment object entirely, as this is cheaper than
// individually removing all the subexpression bindings (which will greatly
// outnumber block-level expression bindings).
@@ -188,9 +184,8 @@ EnvironmentManager::removeDeadBindings(Environment Env,
MarkLiveCallback CB(SymReaper);
ScanReachableSymbols RSScaner(ST, CB);
- llvm::ImmutableMapRef<EnvironmentEntry, SVal>
- EBMapRef(NewEnv.ExprBindings.getRootWithoutRetain(),
- F.getTreeFactory());
+ llvm::ImmutableMapRef<EnvironmentEntry, SVal> EBMapRef(
+ NewEnv.ExprBindings.getRootWithoutRetain(), F.getTreeFactory());
// Iterate over the block-expr bindings.
for (Environment::iterator I = Env.begin(), End = Env.end(); I != End; ++I) {
diff --git a/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp b/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp
index f84da769d182f8..cf22c823b47a1b 100644
--- a/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp
+++ b/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp
@@ -210,7 +210,7 @@ void ExplodedNode::addPredecessor(ExplodedNode *V, ExplodedGraph &G) {
void ExplodedNode::NodeGroup::replaceNode(ExplodedNode *node) {
assert(!getFlag());
- GroupStorage &Storage = reinterpret_cast<GroupStorage&>(P);
+ GroupStorage &Storage = reinterpret_cast<GroupStorage &>(P);
assert(Storage.is<ExplodedNode *>());
Storage = node;
assert(Storage.is<ExplodedNode *>());
@@ -219,7 +219,7 @@ void ExplodedNode::NodeGroup::replaceNode(ExplodedNode *node) {
void ExplodedNode::NodeGroup::addNode(ExplodedNode *N, ExplodedGraph &G) {
assert(!getFlag());
- GroupStorage &Storage = reinterpret_cast<GroupStorage&>(P);
+ GroupStorage &Storage = reinterpret_cast<GroupStorage &>(P);
if (Storage.isNull()) {
Storage = N;
assert(Storage.is<ExplodedNode *>());
@@ -256,7 +256,7 @@ unsigned ExplodedNode::NodeGroup::size() const {
return 1;
}
-ExplodedNode * const *ExplodedNode::NodeGroup::begin() const {
+ExplodedNode *const *ExplodedNode::NodeGroup::begin() const {
if (getFlag())
return nullptr;
@@ -268,7 +268,7 @@ ExplodedNode * const *ExplodedNode::NodeGroup::begin() const {
return Storage.getAddrOfPtr1();
}
-ExplodedNode * const *ExplodedNode::NodeGroup::end() const {
+ExplodedNode *const *ExplodedNode::NodeGroup::end() const {
if (getFlag())
return nullptr;
@@ -353,18 +353,18 @@ const Stmt *ExplodedNode::getNextStmtForDiagnostics() const {
// Check if the statement is '?' or '&&'/'||'. These are "merges",
// not actual statement points.
switch (S->getStmtClass()) {
- case Stmt::ChooseExprClass:
- case Stmt::BinaryConditionalOperatorClass:
- case Stmt::ConditionalOperatorClass:
+ case Stmt::ChooseExprClass:
+ case Stmt::BinaryConditionalOperatorClass:
+ case Stmt::ConditionalOperatorClass:
+ continue;
+ case Stmt::BinaryOperatorClass: {
+ BinaryOperatorKind Op = cast<BinaryOperator>(S)->getOpcode();
+ if (Op == BO_LAnd || Op == BO_LOr)
continue;
- case Stmt::BinaryOperatorClass: {
- BinaryOperatorKind Op = cast<BinaryOperator>(S)->getOpcode();
- if (Op == BO_LAnd || Op == BO_LOr)
- continue;
- break;
- }
- default:
- break;
+ break;
+ }
+ default:
+ break;
}
// We found the statement, so return it.
return S;
@@ -390,22 +390,20 @@ const Stmt *ExplodedNode::getCurrentOrPreviousStmtForDiagnostics() const {
}
ExplodedNode *ExplodedGraph::getNode(const ProgramPoint &L,
- ProgramStateRef State,
- bool IsSink,
- bool* IsNew) {
+ ProgramStateRef State, bool IsSink,
+ bool *IsNew) {
// Profile 'State' to determine if we already have an existing node.
llvm::FoldingSetNodeID profile;
void *InsertPos = nullptr;
NodeTy::Profile(profile, L, State, IsSink);
- NodeTy* V = Nodes.FindNodeOrInsertPos(profile, InsertPos);
+ NodeTy *V = Nodes.FindNodeOrInsertPos(profile, InsertPos);
if (!V) {
if (!FreeNodes.empty()) {
V = FreeNodes.back();
FreeNodes.pop_back();
- }
- else {
+ } else {
// Allocate a new node.
V = getAllocator().Allocate<NodeTy>();
}
@@ -419,18 +417,17 @@ ExplodedNode *ExplodedGraph::getNode(const ProgramPoint &L,
// Insert the node into the node set and return it.
Nodes.InsertNode(V, InsertPos);
- if (IsNew) *IsNew = true;
- }
- else
- if (IsNew) *IsNew = false;
+ if (IsNew)
+ *IsNew = true;
+ } else if (IsNew)
+ *IsNew = false;
return V;
}
ExplodedNode *ExplodedGraph::createUncachedNode(const ProgramPoint &L,
ProgramStateRef State,
- int64_t Id,
- bool IsSink) {
+ int64_t Id, bool IsSink) {
NodeTy *V = getAllocator().Allocate<NodeTy>();
new (V) NodeTy(L, State, Id, IsSink);
return V;
@@ -450,7 +447,7 @@ ExplodedGraph::trim(ArrayRef<const NodeTy *> Sinks,
InterExplodedGraphMap Pass2Scratch;
Pass2Ty &Pass2 = ForwardMap ? *ForwardMap : Pass2Scratch;
- SmallVector<const ExplodedNode*, 10> WL1, WL2;
+ SmallVector<const ExplodedNode *, 10> WL1, WL2;
// ===- Pass 1 (reverse DFS) -===
for (const auto Sink : Sinks)
@@ -497,7 +494,8 @@ ExplodedGraph::trim(ArrayRef<const NodeTy *> Sinks,
Pass2[N] = NewN;
// Also record the reverse mapping from the new node to the old node.
- if (InverseMap) (*InverseMap)[NewN] = N;
+ if (InverseMap)
+ (*InverseMap)[NewN] = N;
// If this node is a root, designate it as such in the graph.
if (N->Preds.empty())
diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp
index 09c69f9612d96b..a655eb216a8ff5 100644
--- a/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp
+++ b/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp
@@ -89,16 +89,15 @@ using namespace ento;
#define DEBUG_TYPE "ExprEngine"
-STATISTIC(NumRemoveDeadBindings,
- "The # of times RemoveDeadBindings is called");
+STATISTIC(NumRemoveDeadBindings, "The # of times RemoveDeadBindings is called");
STATISTIC(NumMaxBlockCountReached,
- "The # of aborted paths due to reaching the maximum block count in "
- "a top level function");
+ "The # of aborted paths due to reaching the maximum block count in "
+ "a top level function");
STATISTIC(NumMaxBlockCountReachedInInlined,
- "The # of aborted paths due to reaching the maximum block count in "
- "an inlined function");
+ "The # of aborted paths due to reaching the maximum block count in "
+ "an inlined function");
STATISTIC(NumTimesRetriedWithoutInlining,
- "The # of times we re-evaluated a call without inlining");
+ "The # of times we re-evaluated a call without inlining");
//===----------------------------------------------------------------------===//
// Internal program state traits.
@@ -126,7 +125,7 @@ class ConstructedObjectKey {
public:
explicit ConstructedObjectKey(const ConstructionContextItem &Item,
- const LocationContext *LC)
+ const LocationContext *LC)
: Impl(Item, LC) {}
const ConstructionContextItem &getItem() const { return Impl.first; }
@@ -216,7 +215,7 @@ REGISTER_TRAIT_WITH_PROGRAMSTATE(PendingArrayDestruction,
// Engine construction and deletion.
//===----------------------------------------------------------------------===//
-static const char* TagProviderName = "ExprEngine";
+static const char *TagProviderName = "ExprEngine";
ExprEngine::ExprEngine(cross_tu::CrossTranslationUnitContext &CTU,
AnalysisManager &mgr, SetOfConstDecls *VisitedCalleesIn,
@@ -267,9 +266,9 @@ ProgramStateRef ExprEngine::getInitialState(const LocationContext *InitLoc) {
break;
SVal V = state->getSVal(loc::MemRegionVal(R));
- SVal Constraint_untested = evalBinOp(state, BO_GT, V,
- svalBuilder.makeZeroVal(T),
- svalBuilder.getConditionType());
+ SVal Constraint_untested =
+ evalBinOp(state, BO_GT, V, svalBuilder.makeZeroVal(T),
+ svalBuilder.getConditionType());
std::optional<DefinedOrUnknownSVal> Constraint =
Constraint_untested.getAs<DefinedOrUnknownSVal>();
@@ -281,8 +280,7 @@ ProgramStateRef ExprEngine::getInitialState(const LocationContext *InitLoc) {
state = newState;
}
break;
- }
- while (false);
+ } while (false);
if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
// Precondition: 'self' is always non-null upon entry to an Objective-C
@@ -657,28 +655,23 @@ bool ExprEngine::areAllObjectsFullyConstructed(ProgramStateRef State,
return true;
}
-
//===----------------------------------------------------------------------===//
// Top-level transfer function logic (Dispatcher).
//===----------------------------------------------------------------------===//
/// evalAssume - Called by ConstraintManager. Used to call checker-specific
/// logic for handling assumptions on symbolic values.
-ProgramStateRef ExprEngine::processAssume(ProgramStateRef state,
- SVal cond, bool assumption) {
+ProgramStateRef ExprEngine::processAssume(ProgramStateRef state, SVal cond,
+ bool assumption) {
return getCheckerManager().runCheckersForEvalAssume(state, cond, assumption);
}
-ProgramStateRef
-ExprEngine::processRegionChanges(ProgramStateRef state,
- const InvalidatedSymbols *invalidated,
- ArrayRef<const MemRegion *> Explicits,
- ArrayRef<const MemRegion *> Regions,
- const LocationContext *LCtx,
- const CallEvent *Call) {
- return getCheckerManager().runCheckersForRegionChanges(state, invalidated,
- Explicits, Regions,
- LCtx, Call);
+ProgramStateRef ExprEngine::processRegionChanges(
+ ProgramStateRef state, const InvalidatedSymbols *invalidated,
+ ArrayRef<const MemRegion *> Explicits, ArrayRef<const MemRegion *> Regions,
+ const LocationContext *LCtx, const CallEvent *Call) {
+ return getCheckerManager().runCheckersForRegionChanges(
+ state, invalidated, Explicits, Regions, LCtx, Call);
}
static void
@@ -970,38 +963,36 @@ void ExprEngine::processCFGElement(const CFGElement E, ExplodedNode *Pred,
currBldrCtx = Ctx;
switch (E.getKind()) {
- case CFGElement::Statement:
- case CFGElement::Constructor:
- case CFGElement::CXXRecordTypedCall:
- ProcessStmt(E.castAs<CFGStmt>().getStmt(), Pred);
- return;
- case CFGElement::Initializer:
- ProcessInitializer(E.castAs<CFGInitializer>(), Pred);
- return;
- case CFGElement::NewAllocator:
- ProcessNewAllocator(E.castAs<CFGNewAllocator>().getAllocatorExpr(),
- Pred);
- return;
- case CFGElement::AutomaticObjectDtor:
- case CFGElement::DeleteDtor:
- case CFGElement::BaseDtor:
- case CFGElement::MemberDtor:
- case CFGElement::TemporaryDtor:
- ProcessImplicitDtor(E.castAs<CFGImplicitDtor>(), Pred);
- return;
- case CFGElement::LoopExit:
- ProcessLoopExit(E.castAs<CFGLoopExit>().getLoopStmt(), Pred);
- return;
- case CFGElement::LifetimeEnds:
- case CFGElement::CleanupFunction:
- case CFGElement::ScopeBegin:
- case CFGElement::ScopeEnd:
- return;
+ case CFGElement::Statement:
+ case CFGElement::Constructor:
+ case CFGElement::CXXRecordTypedCall:
+ ProcessStmt(E.castAs<CFGStmt>().getStmt(), Pred);
+ return;
+ case CFGElement::Initializer:
+ ProcessInitializer(E.castAs<CFGInitializer>(), Pred);
+ return;
+ case CFGElement::NewAllocator:
+ ProcessNewAllocator(E.castAs<CFGNewAllocator>().getAllocatorExpr(), Pred);
+ return;
+ case CFGElement::AutomaticObjectDtor:
+ case CFGElement::DeleteDtor:
+ case CFGElement::BaseDtor:
+ case CFGElement::MemberDtor:
+ case CFGElement::TemporaryDtor:
+ ProcessImplicitDtor(E.castAs<CFGImplicitDtor>(), Pred);
+ return;
+ case CFGElement::LoopExit:
+ ProcessLoopExit(E.castAs<CFGLoopExit>().getLoopStmt(), Pred);
+ return;
+ case CFGElement::LifetimeEnds:
+ case CFGElement::CleanupFunction:
+ case CFGElement::ScopeBegin:
+ case CFGElement::ScopeEnd:
+ return;
}
}
-static bool shouldRemoveDeadBindings(AnalysisManager &AMgr,
- const Stmt *S,
+static bool shouldRemoveDeadBindings(AnalysisManager &AMgr, const Stmt *S,
const ExplodedNode *Pred,
const LocationContext *LC) {
// Are we never purging state values?
@@ -1029,11 +1020,10 @@ static bool shouldRemoveDeadBindings(AnalysisManager &AMgr,
void ExprEngine::removeDead(ExplodedNode *Pred, ExplodedNodeSet &Out,
const Stmt *ReferenceStmt,
const LocationContext *LC,
- const Stmt *DiagnosticStmt,
- ProgramPoint::Kind K) {
+ const Stmt *DiagnosticStmt, ProgramPoint::Kind K) {
assert((K == ProgramPoint::PreStmtPurgeDeadSymbolsKind ||
- ReferenceStmt == nullptr || isa<ReturnStmt>(ReferenceStmt))
- && "PostStmt is not generally supported by the SymbolReaper yet");
+ ReferenceStmt == nullptr || isa<ReturnStmt>(ReferenceStmt)) &&
+ "PostStmt is not generally supported by the SymbolReaper yet");
assert(LC && "Must pass the current (or expiring) LocationContext");
if (!DiagnosticStmt) {
@@ -1118,8 +1108,7 @@ void ExprEngine::ProcessStmt(const Stmt *currStmt, ExplodedNode *Pred) {
ExplodedNodeSet CleanedStates;
if (shouldRemoveDeadBindings(AMgr, currStmt, Pred,
Pred->getLocationContext())) {
- removeDead(Pred, CleanedStates, currStmt,
- Pred->getLocationContext());
+ removeDead(Pred, CleanedStates, currStmt, Pred->getLocationContext());
} else
CleanedStates.Add(Pred);
@@ -1136,7 +1125,7 @@ void ExprEngine::ProcessStmt(const Stmt *currStmt, ExplodedNode *Pred) {
Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
}
-void ExprEngine::ProcessLoopExit(const Stmt* S, ExplodedNode *Pred) {
+void ExprEngine::ProcessLoopExit(const Stmt *S, ExplodedNode *Pred) {
PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
S->getBeginLoc(),
"Error evaluating end of the loop");
@@ -1145,7 +1134,7 @@ void ExprEngine::ProcessLoopExit(const Stmt* S, ExplodedNode *Pred) {
NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
ProgramStateRef NewState = Pred->getState();
- if(AMgr.options.ShouldUnrollLoops)
+ if (AMgr.options.ShouldUnrollLoops)
NewState = processLoopEnd(S, NewState);
LoopExit PP(S, Pred->getLocationContext());
@@ -1211,9 +1200,9 @@ void ExprEngine::ProcessInitializer(const CFGInitializer CFGInit,
// If we fail to get the value for some reason, use a symbolic value.
if (InitVal.isUnknownOrUndef()) {
SValBuilder &SVB = getSValBuilder();
- InitVal = SVB.conjureSymbolVal(BMI->getInit(), stackFrame,
- Field->getType(),
- currBldrCtx->blockCount());
+ InitVal =
+ SVB.conjureSymbolVal(BMI->getInit(), stackFrame, Field->getType(),
+ currBldrCtx->blockCount());
}
} else {
InitVal = State->getSVal(BMI->getInit(), stackFrame);
@@ -1314,8 +1303,7 @@ void ExprEngine::ProcessImplicitDtor(const CFGImplicitDtor D,
Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
}
-void ExprEngine::ProcessNewAllocator(const CXXNewExpr *NE,
- ExplodedNode *Pred) {
+void ExprEngine::ProcessNewAllocator(const CXXNewExpr *NE, ExplodedNode *Pred) {
ExplodedNodeSet Dst;
AnalysisManager &AMgr = getAnalysisManager();
AnalyzerOptions &Opts = AMgr.options;
@@ -1406,8 +1394,7 @@ void ExprEngine::ProcessAutomaticObjDtor(const CFGAutomaticObjDtor Dtor,
/*IsBase=*/false, Pred, Dst, CallOpts);
}
-void ExprEngine::ProcessDeleteDtor(const CFGDeleteDtor Dtor,
- ExplodedNode *Pred,
+void ExprEngine::ProcessDeleteDtor(const CFGDeleteDtor Dtor, ExplodedNode *Pred,
ExplodedNodeSet &Dst) {
ProgramStateRef State = Pred->getState();
const LocationContext *LCtx = Pred->getLocationContext();
@@ -1482,28 +1469,27 @@ void ExprEngine::ProcessDeleteDtor(const CFGDeleteDtor Dtor,
VisitCXXDestructor(DTy, ArgR, DE, /*IsBase=*/false, Pred, Dst, CallOpts);
}
-void ExprEngine::ProcessBaseDtor(const CFGBaseDtor D,
- ExplodedNode *Pred, ExplodedNodeSet &Dst) {
+void ExprEngine::ProcessBaseDtor(const CFGBaseDtor D, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst) {
const LocationContext *LCtx = Pred->getLocationContext();
const auto *CurDtor = cast<CXXDestructorDecl>(LCtx->getDecl());
- Loc ThisPtr = getSValBuilder().getCXXThis(CurDtor,
- LCtx->getStackFrame());
+ Loc ThisPtr = getSValBuilder().getCXXThis(CurDtor, LCtx->getStackFrame());
SVal ThisVal = Pred->getState()->getSVal(ThisPtr);
// Create the base object region.
const CXXBaseSpecifier *Base = D.getBaseSpecifier();
QualType BaseTy = Base->getType();
- SVal BaseVal = getStoreManager().evalDerivedToBase(ThisVal, BaseTy,
- Base->isVirtual());
+ SVal BaseVal =
+ getStoreManager().evalDerivedToBase(ThisVal, BaseTy, Base->isVirtual());
EvalCallOptions CallOpts;
VisitCXXDestructor(BaseTy, BaseVal.getAsRegion(), CurDtor->getBody(),
/*IsBase=*/true, Pred, Dst, CallOpts);
}
-void ExprEngine::ProcessMemberDtor(const CFGMemberDtor D,
- ExplodedNode *Pred, ExplodedNodeSet &Dst) {
+void ExprEngine::ProcessMemberDtor(const CFGMemberDtor D, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst) {
const auto *DtorDecl = D.getDestructorDecl(getContext());
const FieldDecl *Member = D.getFieldDecl();
QualType T = Member->getType();
@@ -1683,8 +1669,7 @@ void ExprEngine::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *BTE,
}
ProgramStateRef ExprEngine::escapeValues(ProgramStateRef State,
- ArrayRef<SVal> Vs,
- PointerEscapeKind K,
+ ArrayRef<SVal> Vs, PointerEscapeKind K,
const CallEvent *Call) const {
class CollectReachableSymbolsCallback final : public SymbolVisitor {
InvalidatedSymbols &Symbols;
@@ -1719,708 +1704,701 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
assert(!isa<Expr>(S) || S == cast<Expr>(S)->IgnoreParens());
switch (S->getStmtClass()) {
- // C++, OpenMP and ARC stuff we don't support yet.
- case Stmt::CXXDependentScopeMemberExprClass:
- case Stmt::CXXTryStmtClass:
- case Stmt::CXXTypeidExprClass:
- case Stmt::CXXUuidofExprClass:
- case Stmt::CXXFoldExprClass:
- case Stmt::MSPropertyRefExprClass:
- case Stmt::MSPropertySubscriptExprClass:
- case Stmt::CXXUnresolvedConstructExprClass:
- case Stmt::DependentScopeDeclRefExprClass:
- case Stmt::ArrayTypeTraitExprClass:
- case Stmt::ExpressionTraitExprClass:
- case Stmt::UnresolvedLookupExprClass:
- case Stmt::UnresolvedMemberExprClass:
- case Stmt::TypoExprClass:
- case Stmt::RecoveryExprClass:
- case Stmt::CXXNoexceptExprClass:
- case Stmt::PackExpansionExprClass:
- case Stmt::PackIndexingExprClass:
- case Stmt::SubstNonTypeTemplateParmPackExprClass:
- case Stmt::FunctionParmPackExprClass:
- case Stmt::CoroutineBodyStmtClass:
- case Stmt::CoawaitExprClass:
- case Stmt::DependentCoawaitExprClass:
- case Stmt::CoreturnStmtClass:
- case Stmt::CoyieldExprClass:
- case Stmt::SEHTryStmtClass:
- case Stmt::SEHExceptStmtClass:
- case Stmt::SEHLeaveStmtClass:
- case Stmt::SEHFinallyStmtClass:
- case Stmt::OMPCanonicalLoopClass:
- case Stmt::OMPParallelDirectiveClass:
- case Stmt::OMPSimdDirectiveClass:
- case Stmt::OMPForDirectiveClass:
- case Stmt::OMPForSimdDirectiveClass:
- case Stmt::OMPSectionsDirectiveClass:
- case Stmt::OMPSectionDirectiveClass:
- case Stmt::OMPScopeDirectiveClass:
- case Stmt::OMPSingleDirectiveClass:
- case Stmt::OMPMasterDirectiveClass:
- case Stmt::OMPCriticalDirectiveClass:
- case Stmt::OMPParallelForDirectiveClass:
- case Stmt::OMPParallelForSimdDirectiveClass:
- case Stmt::OMPParallelSectionsDirectiveClass:
- case Stmt::OMPParallelMasterDirectiveClass:
- case Stmt::OMPParallelMaskedDirectiveClass:
- case Stmt::OMPTaskDirectiveClass:
- case Stmt::OMPTaskyieldDirectiveClass:
- case Stmt::OMPBarrierDirectiveClass:
- case Stmt::OMPTaskwaitDirectiveClass:
- case Stmt::OMPErrorDirectiveClass:
- case Stmt::OMPTaskgroupDirectiveClass:
- case Stmt::OMPFlushDirectiveClass:
- case Stmt::OMPDepobjDirectiveClass:
- case Stmt::OMPScanDirectiveClass:
- case Stmt::OMPOrderedDirectiveClass:
- case Stmt::OMPAtomicDirectiveClass:
- case Stmt::OMPTargetDirectiveClass:
- case Stmt::OMPTargetDataDirectiveClass:
- case Stmt::OMPTargetEnterDataDirectiveClass:
- case Stmt::OMPTargetExitDataDirectiveClass:
- case Stmt::OMPTargetParallelDirectiveClass:
- case Stmt::OMPTargetParallelForDirectiveClass:
- case Stmt::OMPTargetUpdateDirectiveClass:
- case Stmt::OMPTeamsDirectiveClass:
- case Stmt::OMPCancellationPointDirectiveClass:
- case Stmt::OMPCancelDirectiveClass:
- case Stmt::OMPTaskLoopDirectiveClass:
- case Stmt::OMPTaskLoopSimdDirectiveClass:
- case Stmt::OMPMasterTaskLoopDirectiveClass:
- case Stmt::OMPMaskedTaskLoopDirectiveClass:
- case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
- case Stmt::OMPMaskedTaskLoopSimdDirectiveClass:
- case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
- case Stmt::OMPParallelMaskedTaskLoopDirectiveClass:
- case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
- case Stmt::OMPParallelMaskedTaskLoopSimdDirectiveClass:
- case Stmt::OMPDistributeDirectiveClass:
- case Stmt::OMPDistributeParallelForDirectiveClass:
- case Stmt::OMPDistributeParallelForSimdDirectiveClass:
- case Stmt::OMPDistributeSimdDirectiveClass:
- case Stmt::OMPTargetParallelForSimdDirectiveClass:
- case Stmt::OMPTargetSimdDirectiveClass:
- case Stmt::OMPTeamsDistributeDirectiveClass:
- case Stmt::OMPTeamsDistributeSimdDirectiveClass:
- case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
- case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
- case Stmt::OMPTargetTeamsDirectiveClass:
- case Stmt::OMPTargetTeamsDistributeDirectiveClass:
- case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
- case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
- case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
- case Stmt::OMPTileDirectiveClass:
- case Stmt::OMPInteropDirectiveClass:
- case Stmt::OMPDispatchDirectiveClass:
- case Stmt::OMPMaskedDirectiveClass:
- case Stmt::OMPGenericLoopDirectiveClass:
- case Stmt::OMPTeamsGenericLoopDirectiveClass:
- case Stmt::OMPTargetTeamsGenericLoopDirectiveClass:
- case Stmt::OMPParallelGenericLoopDirectiveClass:
- case Stmt::OMPTargetParallelGenericLoopDirectiveClass:
- case Stmt::CapturedStmtClass:
- case Stmt::OpenACCComputeConstructClass:
- case Stmt::OMPUnrollDirectiveClass:
- case Stmt::OMPMetaDirectiveClass: {
- const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
- Engine.addAbortedBlock(node, currBldrCtx->getBlock());
- break;
- }
+ // C++, OpenMP and ARC stuff we don't support yet.
+ case Stmt::CXXDependentScopeMemberExprClass:
+ case Stmt::CXXTryStmtClass:
+ case Stmt::CXXTypeidExprClass:
+ case Stmt::CXXUuidofExprClass:
+ case Stmt::CXXFoldExprClass:
+ case Stmt::MSPropertyRefExprClass:
+ case Stmt::MSPropertySubscriptExprClass:
+ case Stmt::CXXUnresolvedConstructExprClass:
+ case Stmt::DependentScopeDeclRefExprClass:
+ case Stmt::ArrayTypeTraitExprClass:
+ case Stmt::ExpressionTraitExprClass:
+ case Stmt::UnresolvedLookupExprClass:
+ case Stmt::UnresolvedMemberExprClass:
+ case Stmt::TypoExprClass:
+ case Stmt::RecoveryExprClass:
+ case Stmt::CXXNoexceptExprClass:
+ case Stmt::PackExpansionExprClass:
+ case Stmt::PackIndexingExprClass:
+ case Stmt::SubstNonTypeTemplateParmPackExprClass:
+ case Stmt::FunctionParmPackExprClass:
+ case Stmt::CoroutineBodyStmtClass:
+ case Stmt::CoawaitExprClass:
+ case Stmt::DependentCoawaitExprClass:
+ case Stmt::CoreturnStmtClass:
+ case Stmt::CoyieldExprClass:
+ case Stmt::SEHTryStmtClass:
+ case Stmt::SEHExceptStmtClass:
+ case Stmt::SEHLeaveStmtClass:
+ case Stmt::SEHFinallyStmtClass:
+ case Stmt::OMPCanonicalLoopClass:
+ case Stmt::OMPParallelDirectiveClass:
+ case Stmt::OMPSimdDirectiveClass:
+ case Stmt::OMPForDirectiveClass:
+ case Stmt::OMPForSimdDirectiveClass:
+ case Stmt::OMPSectionsDirectiveClass:
+ case Stmt::OMPSectionDirectiveClass:
+ case Stmt::OMPScopeDirectiveClass:
+ case Stmt::OMPSingleDirectiveClass:
+ case Stmt::OMPMasterDirectiveClass:
+ case Stmt::OMPCriticalDirectiveClass:
+ case Stmt::OMPParallelForDirectiveClass:
+ case Stmt::OMPParallelForSimdDirectiveClass:
+ case Stmt::OMPParallelSectionsDirectiveClass:
+ case Stmt::OMPParallelMasterDirectiveClass:
+ case Stmt::OMPParallelMaskedDirectiveClass:
+ case Stmt::OMPTaskDirectiveClass:
+ case Stmt::OMPTaskyieldDirectiveClass:
+ case Stmt::OMPBarrierDirectiveClass:
+ case Stmt::OMPTaskwaitDirectiveClass:
+ case Stmt::OMPErrorDirectiveClass:
+ case Stmt::OMPTaskgroupDirectiveClass:
+ case Stmt::OMPFlushDirectiveClass:
+ case Stmt::OMPDepobjDirectiveClass:
+ case Stmt::OMPScanDirectiveClass:
+ case Stmt::OMPOrderedDirectiveClass:
+ case Stmt::OMPAtomicDirectiveClass:
+ case Stmt::OMPTargetDirectiveClass:
+ case Stmt::OMPTargetDataDirectiveClass:
+ case Stmt::OMPTargetEnterDataDirectiveClass:
+ case Stmt::OMPTargetExitDataDirectiveClass:
+ case Stmt::OMPTargetParallelDirectiveClass:
+ case Stmt::OMPTargetParallelForDirectiveClass:
+ case Stmt::OMPTargetUpdateDirectiveClass:
+ case Stmt::OMPTeamsDirectiveClass:
+ case Stmt::OMPCancellationPointDirectiveClass:
+ case Stmt::OMPCancelDirectiveClass:
+ case Stmt::OMPTaskLoopDirectiveClass:
+ case Stmt::OMPTaskLoopSimdDirectiveClass:
+ case Stmt::OMPMasterTaskLoopDirectiveClass:
+ case Stmt::OMPMaskedTaskLoopDirectiveClass:
+ case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
+ case Stmt::OMPMaskedTaskLoopSimdDirectiveClass:
+ case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
+ case Stmt::OMPParallelMaskedTaskLoopDirectiveClass:
+ case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
+ case Stmt::OMPParallelMaskedTaskLoopSimdDirectiveClass:
+ case Stmt::OMPDistributeDirectiveClass:
+ case Stmt::OMPDistributeParallelForDirectiveClass:
+ case Stmt::OMPDistributeParallelForSimdDirectiveClass:
+ case Stmt::OMPDistributeSimdDirectiveClass:
+ case Stmt::OMPTargetParallelForSimdDirectiveClass:
+ case Stmt::OMPTargetSimdDirectiveClass:
+ case Stmt::OMPTeamsDistributeDirectiveClass:
+ case Stmt::OMPTeamsDistributeSimdDirectiveClass:
+ case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
+ case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
+ case Stmt::OMPTargetTeamsDirectiveClass:
+ case Stmt::OMPTargetTeamsDistributeDirectiveClass:
+ case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
+ case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
+ case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
+ case Stmt::OMPTileDirectiveClass:
+ case Stmt::OMPInteropDirectiveClass:
+ case Stmt::OMPDispatchDirectiveClass:
+ case Stmt::OMPMaskedDirectiveClass:
+ case Stmt::OMPGenericLoopDirectiveClass:
+ case Stmt::OMPTeamsGenericLoopDirectiveClass:
+ case Stmt::OMPTargetTeamsGenericLoopDirectiveClass:
+ case Stmt::OMPParallelGenericLoopDirectiveClass:
+ case Stmt::OMPTargetParallelGenericLoopDirectiveClass:
+ case Stmt::CapturedStmtClass:
+ case Stmt::OpenACCComputeConstructClass:
+ case Stmt::OMPUnrollDirectiveClass:
+ case Stmt::OMPMetaDirectiveClass: {
+ const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
+ Engine.addAbortedBlock(node, currBldrCtx->getBlock());
+ break;
+ }
- case Stmt::ParenExprClass:
- llvm_unreachable("ParenExprs already handled.");
- case Stmt::GenericSelectionExprClass:
- llvm_unreachable("GenericSelectionExprs already handled.");
- // Cases that should never be evaluated simply because they shouldn't
- // appear in the CFG.
- case Stmt::BreakStmtClass:
- case Stmt::CaseStmtClass:
- case Stmt::CompoundStmtClass:
- case Stmt::ContinueStmtClass:
- case Stmt::CXXForRangeStmtClass:
- case Stmt::DefaultStmtClass:
- case Stmt::DoStmtClass:
- case Stmt::ForStmtClass:
- case Stmt::GotoStmtClass:
- case Stmt::IfStmtClass:
- case Stmt::IndirectGotoStmtClass:
- case Stmt::LabelStmtClass:
- case Stmt::NoStmtClass:
- case Stmt::NullStmtClass:
- case Stmt::SwitchStmtClass:
- case Stmt::WhileStmtClass:
- case Expr::MSDependentExistsStmtClass:
- llvm_unreachable("Stmt should not be in analyzer evaluation loop");
- case Stmt::ImplicitValueInitExprClass:
- // These nodes are shared in the CFG and would case caching out.
- // Moreover, no additional evaluation required for them, the
- // analyzer can reconstruct these values from the AST.
- llvm_unreachable("Should be pruned from CFG");
-
- case Stmt::ObjCSubscriptRefExprClass:
- case Stmt::ObjCPropertyRefExprClass:
- llvm_unreachable("These are handled by PseudoObjectExpr");
-
- case Stmt::GNUNullExprClass: {
- // GNU __null is a pointer-width integer, not an actual pointer.
- ProgramStateRef state = Pred->getState();
- state = state->BindExpr(
- S, Pred->getLocationContext(),
- svalBuilder.makeIntValWithWidth(getContext().VoidPtrTy, 0));
- Bldr.generateNode(S, Pred, state);
- break;
- }
+ case Stmt::ParenExprClass:
+ llvm_unreachable("ParenExprs already handled.");
+ case Stmt::GenericSelectionExprClass:
+ llvm_unreachable("GenericSelectionExprs already handled.");
+ // Cases that should never be evaluated simply because they shouldn't
+ // appear in the CFG.
+ case Stmt::BreakStmtClass:
+ case Stmt::CaseStmtClass:
+ case Stmt::CompoundStmtClass:
+ case Stmt::ContinueStmtClass:
+ case Stmt::CXXForRangeStmtClass:
+ case Stmt::DefaultStmtClass:
+ case Stmt::DoStmtClass:
+ case Stmt::ForStmtClass:
+ case Stmt::GotoStmtClass:
+ case Stmt::IfStmtClass:
+ case Stmt::IndirectGotoStmtClass:
+ case Stmt::LabelStmtClass:
+ case Stmt::NoStmtClass:
+ case Stmt::NullStmtClass:
+ case Stmt::SwitchStmtClass:
+ case Stmt::WhileStmtClass:
+ case Expr::MSDependentExistsStmtClass:
+ llvm_unreachable("Stmt should not be in analyzer evaluation loop");
+ case Stmt::ImplicitValueInitExprClass:
+ // These nodes are shared in the CFG and would case caching out.
+ // Moreover, no additional evaluation required for them, the
+ // analyzer can reconstruct these values from the AST.
+ llvm_unreachable("Should be pruned from CFG");
+
+ case Stmt::ObjCSubscriptRefExprClass:
+ case Stmt::ObjCPropertyRefExprClass:
+ llvm_unreachable("These are handled by PseudoObjectExpr");
+
+ case Stmt::GNUNullExprClass: {
+ // GNU __null is a pointer-width integer, not an actual pointer.
+ ProgramStateRef state = Pred->getState();
+ state = state->BindExpr(
+ S, Pred->getLocationContext(),
+ svalBuilder.makeIntValWithWidth(getContext().VoidPtrTy, 0));
+ Bldr.generateNode(S, Pred, state);
+ break;
+ }
- case Stmt::ObjCAtSynchronizedStmtClass:
- Bldr.takeNodes(Pred);
- VisitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ case Stmt::ObjCAtSynchronizedStmtClass:
+ Bldr.takeNodes(Pred);
+ VisitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Expr::ConstantExprClass:
- case Stmt::ExprWithCleanupsClass:
- // Handled due to fully linearised CFG.
- break;
+ case Expr::ConstantExprClass:
+ case Stmt::ExprWithCleanupsClass:
+ // Handled due to fully linearised CFG.
+ break;
- case Stmt::CXXBindTemporaryExprClass: {
- Bldr.takeNodes(Pred);
- ExplodedNodeSet PreVisit;
- getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
- ExplodedNodeSet Next;
- VisitCXXBindTemporaryExpr(cast<CXXBindTemporaryExpr>(S), PreVisit, Next);
- getCheckerManager().runCheckersForPostStmt(Dst, Next, S, *this);
- Bldr.addNodes(Dst);
- break;
- }
+ case Stmt::CXXBindTemporaryExprClass: {
+ Bldr.takeNodes(Pred);
+ ExplodedNodeSet PreVisit;
+ getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
+ ExplodedNodeSet Next;
+ VisitCXXBindTemporaryExpr(cast<CXXBindTemporaryExpr>(S), PreVisit, Next);
+ getCheckerManager().runCheckersForPostStmt(Dst, Next, S, *this);
+ Bldr.addNodes(Dst);
+ break;
+ }
- case Stmt::ArrayInitLoopExprClass:
- Bldr.takeNodes(Pred);
- VisitArrayInitLoopExpr(cast<ArrayInitLoopExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
- // Cases not handled yet; but will handle some day.
- case Stmt::DesignatedInitExprClass:
- case Stmt::DesignatedInitUpdateExprClass:
- case Stmt::ArrayInitIndexExprClass:
- case Stmt::ExtVectorElementExprClass:
- case Stmt::ImaginaryLiteralClass:
- case Stmt::ObjCAtCatchStmtClass:
- case Stmt::ObjCAtFinallyStmtClass:
- case Stmt::ObjCAtTryStmtClass:
- case Stmt::ObjCAutoreleasePoolStmtClass:
- case Stmt::ObjCEncodeExprClass:
- case Stmt::ObjCIsaExprClass:
- case Stmt::ObjCProtocolExprClass:
- case Stmt::ObjCSelectorExprClass:
- case Stmt::ParenListExprClass:
- case Stmt::ShuffleVectorExprClass:
- case Stmt::ConvertVectorExprClass:
- case Stmt::VAArgExprClass:
- case Stmt::CUDAKernelCallExprClass:
- case Stmt::OpaqueValueExprClass:
- case Stmt::AsTypeExprClass:
- case Stmt::ConceptSpecializationExprClass:
- case Stmt::CXXRewrittenBinaryOperatorClass:
- case Stmt::RequiresExprClass:
- case Expr::CXXParenListInitExprClass:
- // Fall through.
-
- // Cases we intentionally don't evaluate, since they don't need
- // to be explicitly evaluated.
- case Stmt::PredefinedExprClass:
- case Stmt::AddrLabelExprClass:
- case Stmt::AttributedStmtClass:
- case Stmt::IntegerLiteralClass:
- case Stmt::FixedPointLiteralClass:
- case Stmt::CharacterLiteralClass:
- case Stmt::CXXScalarValueInitExprClass:
- case Stmt::CXXBoolLiteralExprClass:
- case Stmt::ObjCBoolLiteralExprClass:
- case Stmt::ObjCAvailabilityCheckExprClass:
- case Stmt::FloatingLiteralClass:
- case Stmt::NoInitExprClass:
- case Stmt::SizeOfPackExprClass:
- case Stmt::StringLiteralClass:
- case Stmt::SourceLocExprClass:
- case Stmt::ObjCStringLiteralClass:
- case Stmt::CXXPseudoDestructorExprClass:
- case Stmt::SubstNonTypeTemplateParmExprClass:
- case Stmt::CXXNullPtrLiteralExprClass:
- case Stmt::OMPArraySectionExprClass:
- case Stmt::OMPArrayShapingExprClass:
- case Stmt::OMPIteratorExprClass:
- case Stmt::SYCLUniqueStableNameExprClass:
- case Stmt::TypeTraitExprClass: {
- Bldr.takeNodes(Pred);
- ExplodedNodeSet preVisit;
- getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
- getCheckerManager().runCheckersForPostStmt(Dst, preVisit, S, *this);
- Bldr.addNodes(Dst);
- break;
- }
+ case Stmt::ArrayInitLoopExprClass:
+ Bldr.takeNodes(Pred);
+ VisitArrayInitLoopExpr(cast<ArrayInitLoopExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
+ // Cases not handled yet; but will handle some day.
+ case Stmt::DesignatedInitExprClass:
+ case Stmt::DesignatedInitUpdateExprClass:
+ case Stmt::ArrayInitIndexExprClass:
+ case Stmt::ExtVectorElementExprClass:
+ case Stmt::ImaginaryLiteralClass:
+ case Stmt::ObjCAtCatchStmtClass:
+ case Stmt::ObjCAtFinallyStmtClass:
+ case Stmt::ObjCAtTryStmtClass:
+ case Stmt::ObjCAutoreleasePoolStmtClass:
+ case Stmt::ObjCEncodeExprClass:
+ case Stmt::ObjCIsaExprClass:
+ case Stmt::ObjCProtocolExprClass:
+ case Stmt::ObjCSelectorExprClass:
+ case Stmt::ParenListExprClass:
+ case Stmt::ShuffleVectorExprClass:
+ case Stmt::ConvertVectorExprClass:
+ case Stmt::VAArgExprClass:
+ case Stmt::CUDAKernelCallExprClass:
+ case Stmt::OpaqueValueExprClass:
+ case Stmt::AsTypeExprClass:
+ case Stmt::ConceptSpecializationExprClass:
+ case Stmt::CXXRewrittenBinaryOperatorClass:
+ case Stmt::RequiresExprClass:
+ case Expr::CXXParenListInitExprClass:
+ // Fall through.
+
+ // Cases we intentionally don't evaluate, since they don't need
+ // to be explicitly evaluated.
+ case Stmt::PredefinedExprClass:
+ case Stmt::AddrLabelExprClass:
+ case Stmt::AttributedStmtClass:
+ case Stmt::IntegerLiteralClass:
+ case Stmt::FixedPointLiteralClass:
+ case Stmt::CharacterLiteralClass:
+ case Stmt::CXXScalarValueInitExprClass:
+ case Stmt::CXXBoolLiteralExprClass:
+ case Stmt::ObjCBoolLiteralExprClass:
+ case Stmt::ObjCAvailabilityCheckExprClass:
+ case Stmt::FloatingLiteralClass:
+ case Stmt::NoInitExprClass:
+ case Stmt::SizeOfPackExprClass:
+ case Stmt::StringLiteralClass:
+ case Stmt::SourceLocExprClass:
+ case Stmt::ObjCStringLiteralClass:
+ case Stmt::CXXPseudoDestructorExprClass:
+ case Stmt::SubstNonTypeTemplateParmExprClass:
+ case Stmt::CXXNullPtrLiteralExprClass:
+ case Stmt::OMPArraySectionExprClass:
+ case Stmt::OMPArrayShapingExprClass:
+ case Stmt::OMPIteratorExprClass:
+ case Stmt::SYCLUniqueStableNameExprClass:
+ case Stmt::TypeTraitExprClass: {
+ Bldr.takeNodes(Pred);
+ ExplodedNodeSet preVisit;
+ getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
+ getCheckerManager().runCheckersForPostStmt(Dst, preVisit, S, *this);
+ Bldr.addNodes(Dst);
+ break;
+ }
- case Stmt::CXXDefaultArgExprClass:
- case Stmt::CXXDefaultInitExprClass: {
- Bldr.takeNodes(Pred);
- ExplodedNodeSet PreVisit;
- getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
+ case Stmt::CXXDefaultArgExprClass:
+ case Stmt::CXXDefaultInitExprClass: {
+ Bldr.takeNodes(Pred);
+ ExplodedNodeSet PreVisit;
+ getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
- ExplodedNodeSet Tmp;
- StmtNodeBuilder Bldr2(PreVisit, Tmp, *currBldrCtx);
+ ExplodedNodeSet Tmp;
+ StmtNodeBuilder Bldr2(PreVisit, Tmp, *currBldrCtx);
- const Expr *ArgE;
- if (const auto *DefE = dyn_cast<CXXDefaultArgExpr>(S))
- ArgE = DefE->getExpr();
- else if (const auto *DefE = dyn_cast<CXXDefaultInitExpr>(S))
- ArgE = DefE->getExpr();
- else
- llvm_unreachable("unknown constant wrapper kind");
+ const Expr *ArgE;
+ if (const auto *DefE = dyn_cast<CXXDefaultArgExpr>(S))
+ ArgE = DefE->getExpr();
+ else if (const auto *DefE = dyn_cast<CXXDefaultInitExpr>(S))
+ ArgE = DefE->getExpr();
+ else
+ llvm_unreachable("unknown constant wrapper kind");
- bool IsTemporary = false;
- if (const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(ArgE)) {
- ArgE = MTE->getSubExpr();
- IsTemporary = true;
- }
+ bool IsTemporary = false;
+ if (const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(ArgE)) {
+ ArgE = MTE->getSubExpr();
+ IsTemporary = true;
+ }
- std::optional<SVal> ConstantVal = svalBuilder.getConstantVal(ArgE);
- if (!ConstantVal)
- ConstantVal = UnknownVal();
-
- const LocationContext *LCtx = Pred->getLocationContext();
- for (const auto I : PreVisit) {
- ProgramStateRef State = I->getState();
- State = State->BindExpr(S, LCtx, *ConstantVal);
- if (IsTemporary)
- State = createTemporaryRegionIfNeeded(State, LCtx,
- cast<Expr>(S),
- cast<Expr>(S));
- Bldr2.generateNode(S, I, State);
- }
+ std::optional<SVal> ConstantVal = svalBuilder.getConstantVal(ArgE);
+ if (!ConstantVal)
+ ConstantVal = UnknownVal();
- getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
- Bldr.addNodes(Dst);
- break;
+ const LocationContext *LCtx = Pred->getLocationContext();
+ for (const auto I : PreVisit) {
+ ProgramStateRef State = I->getState();
+ State = State->BindExpr(S, LCtx, *ConstantVal);
+ if (IsTemporary)
+ State = createTemporaryRegionIfNeeded(State, LCtx, cast<Expr>(S),
+ cast<Expr>(S));
+ Bldr2.generateNode(S, I, State);
}
- // Cases we evaluate as opaque expressions, conjuring a symbol.
- case Stmt::CXXStdInitializerListExprClass:
- case Expr::ObjCArrayLiteralClass:
- case Expr::ObjCDictionaryLiteralClass:
- case Expr::ObjCBoxedExprClass: {
- Bldr.takeNodes(Pred);
+ getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
+ Bldr.addNodes(Dst);
+ break;
+ }
- ExplodedNodeSet preVisit;
- getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
+ // Cases we evaluate as opaque expressions, conjuring a symbol.
+ case Stmt::CXXStdInitializerListExprClass:
+ case Expr::ObjCArrayLiteralClass:
+ case Expr::ObjCDictionaryLiteralClass:
+ case Expr::ObjCBoxedExprClass: {
+ Bldr.takeNodes(Pred);
- ExplodedNodeSet Tmp;
- StmtNodeBuilder Bldr2(preVisit, Tmp, *currBldrCtx);
-
- const auto *Ex = cast<Expr>(S);
- QualType resultType = Ex->getType();
-
- for (const auto N : preVisit) {
- const LocationContext *LCtx = N->getLocationContext();
- SVal result = svalBuilder.conjureSymbolVal(nullptr, Ex, LCtx,
- resultType,
- currBldrCtx->blockCount());
- ProgramStateRef State = N->getState()->BindExpr(Ex, LCtx, result);
-
- // Escape pointers passed into the list, unless it's an ObjC boxed
- // expression which is not a boxable C structure.
- if (!(isa<ObjCBoxedExpr>(Ex) &&
- !cast<ObjCBoxedExpr>(Ex)->getSubExpr()
- ->getType()->isRecordType()))
- for (auto Child : Ex->children()) {
- assert(Child);
- SVal Val = State->getSVal(Child, LCtx);
- State = escapeValues(State, Val, PSK_EscapeOther);
- }
+ ExplodedNodeSet preVisit;
+ getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
- Bldr2.generateNode(S, N, State);
- }
+ ExplodedNodeSet Tmp;
+ StmtNodeBuilder Bldr2(preVisit, Tmp, *currBldrCtx);
+
+ const auto *Ex = cast<Expr>(S);
+ QualType resultType = Ex->getType();
+
+ for (const auto N : preVisit) {
+ const LocationContext *LCtx = N->getLocationContext();
+ SVal result = svalBuilder.conjureSymbolVal(nullptr, Ex, LCtx, resultType,
+ currBldrCtx->blockCount());
+ ProgramStateRef State = N->getState()->BindExpr(Ex, LCtx, result);
+
+ // Escape pointers passed into the list, unless it's an ObjC boxed
+ // expression which is not a boxable C structure.
+ if (!(isa<ObjCBoxedExpr>(Ex) &&
+ !cast<ObjCBoxedExpr>(Ex)->getSubExpr()->getType()->isRecordType()))
+ for (auto Child : Ex->children()) {
+ assert(Child);
+ SVal Val = State->getSVal(Child, LCtx);
+ State = escapeValues(State, Val, PSK_EscapeOther);
+ }
- getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
- Bldr.addNodes(Dst);
- break;
+ Bldr2.generateNode(S, N, State);
}
- case Stmt::ArraySubscriptExprClass:
- Bldr.takeNodes(Pred);
- VisitArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
+ Bldr.addNodes(Dst);
+ break;
+ }
- case Stmt::MatrixSubscriptExprClass:
- llvm_unreachable("Support for MatrixSubscriptExpr is not implemented.");
- break;
+ case Stmt::ArraySubscriptExprClass:
+ Bldr.takeNodes(Pred);
+ VisitArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Stmt::GCCAsmStmtClass:
- Bldr.takeNodes(Pred);
- VisitGCCAsmStmt(cast<GCCAsmStmt>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ case Stmt::MatrixSubscriptExprClass:
+ llvm_unreachable("Support for MatrixSubscriptExpr is not implemented.");
+ break;
- case Stmt::MSAsmStmtClass:
+ case Stmt::GCCAsmStmtClass:
+ Bldr.takeNodes(Pred);
+ VisitGCCAsmStmt(cast<GCCAsmStmt>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
+
+ case Stmt::MSAsmStmtClass:
+ Bldr.takeNodes(Pred);
+ VisitMSAsmStmt(cast<MSAsmStmt>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
+
+ case Stmt::BlockExprClass:
+ Bldr.takeNodes(Pred);
+ VisitBlockExpr(cast<BlockExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
+
+ case Stmt::LambdaExprClass:
+ if (AMgr.options.ShouldInlineLambdas) {
Bldr.takeNodes(Pred);
- VisitMSAsmStmt(cast<MSAsmStmt>(S), Pred, Dst);
+ VisitLambdaExpr(cast<LambdaExpr>(S), Pred, Dst);
Bldr.addNodes(Dst);
- break;
+ } else {
+ const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
+ Engine.addAbortedBlock(node, currBldrCtx->getBlock());
+ }
+ break;
- case Stmt::BlockExprClass:
+ case Stmt::BinaryOperatorClass: {
+ const auto *B = cast<BinaryOperator>(S);
+ if (B->isLogicalOp()) {
Bldr.takeNodes(Pred);
- VisitBlockExpr(cast<BlockExpr>(S), Pred, Dst);
+ VisitLogicalExpr(B, Pred, Dst);
Bldr.addNodes(Dst);
break;
-
- case Stmt::LambdaExprClass:
- if (AMgr.options.ShouldInlineLambdas) {
- Bldr.takeNodes(Pred);
- VisitLambdaExpr(cast<LambdaExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- } else {
- const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
- Engine.addAbortedBlock(node, currBldrCtx->getBlock());
- }
+ } else if (B->getOpcode() == BO_Comma) {
+ ProgramStateRef state = Pred->getState();
+ Bldr.generateNode(
+ B, Pred,
+ state->BindExpr(
+ B, Pred->getLocationContext(),
+ state->getSVal(B->getRHS(), Pred->getLocationContext())));
break;
+ }
- case Stmt::BinaryOperatorClass: {
- const auto *B = cast<BinaryOperator>(S);
- if (B->isLogicalOp()) {
- Bldr.takeNodes(Pred);
- VisitLogicalExpr(B, Pred, Dst);
- Bldr.addNodes(Dst);
- break;
- }
- else if (B->getOpcode() == BO_Comma) {
- ProgramStateRef state = Pred->getState();
- Bldr.generateNode(B, Pred,
- state->BindExpr(B, Pred->getLocationContext(),
- state->getSVal(B->getRHS(),
- Pred->getLocationContext())));
- break;
- }
+ Bldr.takeNodes(Pred);
- Bldr.takeNodes(Pred);
+ if (AMgr.options.ShouldEagerlyAssume &&
+ (B->isRelationalOp() || B->isEqualityOp())) {
+ ExplodedNodeSet Tmp;
+ VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Tmp);
+ evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, cast<Expr>(S));
+ } else
+ VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
- if (AMgr.options.ShouldEagerlyAssume &&
- (B->isRelationalOp() || B->isEqualityOp())) {
- ExplodedNodeSet Tmp;
- VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Tmp);
- evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, cast<Expr>(S));
- }
- else
- VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
+ }
- Bldr.addNodes(Dst);
- break;
- }
+ case Stmt::CXXOperatorCallExprClass: {
+ const auto *OCE = cast<CXXOperatorCallExpr>(S);
- case Stmt::CXXOperatorCallExprClass: {
- const auto *OCE = cast<CXXOperatorCallExpr>(S);
-
- // For instance method operators, make sure the 'this' argument has a
- // valid region.
- const Decl *Callee = OCE->getCalleeDecl();
- if (const auto *MD = dyn_cast_or_null<CXXMethodDecl>(Callee)) {
- if (MD->isImplicitObjectMemberFunction()) {
- ProgramStateRef State = Pred->getState();
- const LocationContext *LCtx = Pred->getLocationContext();
- ProgramStateRef NewState =
+ // For instance method operators, make sure the 'this' argument has a
+ // valid region.
+ const Decl *Callee = OCE->getCalleeDecl();
+ if (const auto *MD = dyn_cast_or_null<CXXMethodDecl>(Callee)) {
+ if (MD->isImplicitObjectMemberFunction()) {
+ ProgramStateRef State = Pred->getState();
+ const LocationContext *LCtx = Pred->getLocationContext();
+ ProgramStateRef NewState =
createTemporaryRegionIfNeeded(State, LCtx, OCE->getArg(0));
- if (NewState != State) {
- Pred = Bldr.generateNode(OCE, Pred, NewState, /*tag=*/nullptr,
- ProgramPoint::PreStmtKind);
- // Did we cache out?
- if (!Pred)
- break;
- }
+ if (NewState != State) {
+ Pred = Bldr.generateNode(OCE, Pred, NewState, /*tag=*/nullptr,
+ ProgramPoint::PreStmtKind);
+ // Did we cache out?
+ if (!Pred)
+ break;
}
}
- [[fallthrough]];
}
+ [[fallthrough]];
+ }
- case Stmt::CallExprClass:
- case Stmt::CXXMemberCallExprClass:
- case Stmt::UserDefinedLiteralClass:
- Bldr.takeNodes(Pred);
- VisitCallExpr(cast<CallExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
-
- case Stmt::CXXCatchStmtClass:
- Bldr.takeNodes(Pred);
- VisitCXXCatchStmt(cast<CXXCatchStmt>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
-
- case Stmt::CXXTemporaryObjectExprClass:
- case Stmt::CXXConstructExprClass:
- Bldr.takeNodes(Pred);
- VisitCXXConstructExpr(cast<CXXConstructExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
-
- case Stmt::CXXInheritedCtorInitExprClass:
- Bldr.takeNodes(Pred);
- VisitCXXInheritedCtorInitExpr(cast<CXXInheritedCtorInitExpr>(S), Pred,
- Dst);
- Bldr.addNodes(Dst);
- break;
+ case Stmt::CallExprClass:
+ case Stmt::CXXMemberCallExprClass:
+ case Stmt::UserDefinedLiteralClass:
+ Bldr.takeNodes(Pred);
+ VisitCallExpr(cast<CallExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Stmt::CXXNewExprClass: {
- Bldr.takeNodes(Pred);
+ case Stmt::CXXCatchStmtClass:
+ Bldr.takeNodes(Pred);
+ VisitCXXCatchStmt(cast<CXXCatchStmt>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- ExplodedNodeSet PreVisit;
- getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
+ case Stmt::CXXTemporaryObjectExprClass:
+ case Stmt::CXXConstructExprClass:
+ Bldr.takeNodes(Pred);
+ VisitCXXConstructExpr(cast<CXXConstructExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- ExplodedNodeSet PostVisit;
- for (const auto i : PreVisit)
- VisitCXXNewExpr(cast<CXXNewExpr>(S), i, PostVisit);
+ case Stmt::CXXInheritedCtorInitExprClass:
+ Bldr.takeNodes(Pred);
+ VisitCXXInheritedCtorInitExpr(cast<CXXInheritedCtorInitExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- getCheckerManager().runCheckersForPostStmt(Dst, PostVisit, S, *this);
- Bldr.addNodes(Dst);
- break;
- }
+ case Stmt::CXXNewExprClass: {
+ Bldr.takeNodes(Pred);
- case Stmt::CXXDeleteExprClass: {
- Bldr.takeNodes(Pred);
- ExplodedNodeSet PreVisit;
- const auto *CDE = cast<CXXDeleteExpr>(S);
- getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
- ExplodedNodeSet PostVisit;
- getCheckerManager().runCheckersForPostStmt(PostVisit, PreVisit, S, *this);
+ ExplodedNodeSet PreVisit;
+ getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
- for (const auto i : PostVisit)
- VisitCXXDeleteExpr(CDE, i, Dst);
+ ExplodedNodeSet PostVisit;
+ for (const auto i : PreVisit)
+ VisitCXXNewExpr(cast<CXXNewExpr>(S), i, PostVisit);
- Bldr.addNodes(Dst);
- break;
- }
- // FIXME: ChooseExpr is really a constant. We need to fix
- // the CFG do not model them as explicit control-flow.
+ getCheckerManager().runCheckersForPostStmt(Dst, PostVisit, S, *this);
+ Bldr.addNodes(Dst);
+ break;
+ }
- case Stmt::ChooseExprClass: { // __builtin_choose_expr
- Bldr.takeNodes(Pred);
- const auto *C = cast<ChooseExpr>(S);
- VisitGuardedExpr(C, C->getLHS(), C->getRHS(), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
- }
+ case Stmt::CXXDeleteExprClass: {
+ Bldr.takeNodes(Pred);
+ ExplodedNodeSet PreVisit;
+ const auto *CDE = cast<CXXDeleteExpr>(S);
+ getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
+ ExplodedNodeSet PostVisit;
+ getCheckerManager().runCheckersForPostStmt(PostVisit, PreVisit, S, *this);
- case Stmt::CompoundAssignOperatorClass:
- Bldr.takeNodes(Pred);
- VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ for (const auto i : PostVisit)
+ VisitCXXDeleteExpr(CDE, i, Dst);
- case Stmt::CompoundLiteralExprClass:
- Bldr.takeNodes(Pred);
- VisitCompoundLiteralExpr(cast<CompoundLiteralExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ Bldr.addNodes(Dst);
+ break;
+ }
+ // FIXME: ChooseExpr is really a constant. We need to fix
+ // the CFG do not model them as explicit control-flow.
- case Stmt::BinaryConditionalOperatorClass:
- case Stmt::ConditionalOperatorClass: { // '?' operator
- Bldr.takeNodes(Pred);
- const auto *C = cast<AbstractConditionalOperator>(S);
- VisitGuardedExpr(C, C->getTrueExpr(), C->getFalseExpr(), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
- }
+ case Stmt::ChooseExprClass: { // __builtin_choose_expr
+ Bldr.takeNodes(Pred);
+ const auto *C = cast<ChooseExpr>(S);
+ VisitGuardedExpr(C, C->getLHS(), C->getRHS(), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
+ }
- case Stmt::CXXThisExprClass:
- Bldr.takeNodes(Pred);
- VisitCXXThisExpr(cast<CXXThisExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ case Stmt::CompoundAssignOperatorClass:
+ Bldr.takeNodes(Pred);
+ VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Stmt::DeclRefExprClass: {
- Bldr.takeNodes(Pred);
- const auto *DE = cast<DeclRefExpr>(S);
- VisitCommonDeclRefExpr(DE, DE->getDecl(), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
- }
+ case Stmt::CompoundLiteralExprClass:
+ Bldr.takeNodes(Pred);
+ VisitCompoundLiteralExpr(cast<CompoundLiteralExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Stmt::DeclStmtClass:
- Bldr.takeNodes(Pred);
- VisitDeclStmt(cast<DeclStmt>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ case Stmt::BinaryConditionalOperatorClass:
+ case Stmt::ConditionalOperatorClass: { // '?' operator
+ Bldr.takeNodes(Pred);
+ const auto *C = cast<AbstractConditionalOperator>(S);
+ VisitGuardedExpr(C, C->getTrueExpr(), C->getFalseExpr(), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
+ }
- case Stmt::ImplicitCastExprClass:
- case Stmt::CStyleCastExprClass:
- case Stmt::CXXStaticCastExprClass:
- case Stmt::CXXDynamicCastExprClass:
- case Stmt::CXXReinterpretCastExprClass:
- case Stmt::CXXConstCastExprClass:
- case Stmt::CXXFunctionalCastExprClass:
- case Stmt::BuiltinBitCastExprClass:
- case Stmt::ObjCBridgedCastExprClass:
- case Stmt::CXXAddrspaceCastExprClass: {
- Bldr.takeNodes(Pred);
- const auto *C = cast<CastExpr>(S);
- ExplodedNodeSet dstExpr;
- VisitCast(C, C->getSubExpr(), Pred, dstExpr);
+ case Stmt::CXXThisExprClass:
+ Bldr.takeNodes(Pred);
+ VisitCXXThisExpr(cast<CXXThisExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- // Handle the postvisit checks.
- getCheckerManager().runCheckersForPostStmt(Dst, dstExpr, C, *this);
- Bldr.addNodes(Dst);
- break;
- }
+ case Stmt::DeclRefExprClass: {
+ Bldr.takeNodes(Pred);
+ const auto *DE = cast<DeclRefExpr>(S);
+ VisitCommonDeclRefExpr(DE, DE->getDecl(), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
+ }
- case Expr::MaterializeTemporaryExprClass: {
- Bldr.takeNodes(Pred);
- const auto *MTE = cast<MaterializeTemporaryExpr>(S);
- ExplodedNodeSet dstPrevisit;
- getCheckerManager().runCheckersForPreStmt(dstPrevisit, Pred, MTE, *this);
- ExplodedNodeSet dstExpr;
- for (const auto i : dstPrevisit)
- CreateCXXTemporaryObject(MTE, i, dstExpr);
- getCheckerManager().runCheckersForPostStmt(Dst, dstExpr, MTE, *this);
- Bldr.addNodes(Dst);
- break;
- }
+ case Stmt::DeclStmtClass:
+ Bldr.takeNodes(Pred);
+ VisitDeclStmt(cast<DeclStmt>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Stmt::InitListExprClass:
- Bldr.takeNodes(Pred);
- VisitInitListExpr(cast<InitListExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ case Stmt::ImplicitCastExprClass:
+ case Stmt::CStyleCastExprClass:
+ case Stmt::CXXStaticCastExprClass:
+ case Stmt::CXXDynamicCastExprClass:
+ case Stmt::CXXReinterpretCastExprClass:
+ case Stmt::CXXConstCastExprClass:
+ case Stmt::CXXFunctionalCastExprClass:
+ case Stmt::BuiltinBitCastExprClass:
+ case Stmt::ObjCBridgedCastExprClass:
+ case Stmt::CXXAddrspaceCastExprClass: {
+ Bldr.takeNodes(Pred);
+ const auto *C = cast<CastExpr>(S);
+ ExplodedNodeSet dstExpr;
+ VisitCast(C, C->getSubExpr(), Pred, dstExpr);
+
+ // Handle the postvisit checks.
+ getCheckerManager().runCheckersForPostStmt(Dst, dstExpr, C, *this);
+ Bldr.addNodes(Dst);
+ break;
+ }
- case Stmt::MemberExprClass:
- Bldr.takeNodes(Pred);
- VisitMemberExpr(cast<MemberExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ case Expr::MaterializeTemporaryExprClass: {
+ Bldr.takeNodes(Pred);
+ const auto *MTE = cast<MaterializeTemporaryExpr>(S);
+ ExplodedNodeSet dstPrevisit;
+ getCheckerManager().runCheckersForPreStmt(dstPrevisit, Pred, MTE, *this);
+ ExplodedNodeSet dstExpr;
+ for (const auto i : dstPrevisit)
+ CreateCXXTemporaryObject(MTE, i, dstExpr);
+ getCheckerManager().runCheckersForPostStmt(Dst, dstExpr, MTE, *this);
+ Bldr.addNodes(Dst);
+ break;
+ }
- case Stmt::AtomicExprClass:
- Bldr.takeNodes(Pred);
- VisitAtomicExpr(cast<AtomicExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ case Stmt::InitListExprClass:
+ Bldr.takeNodes(Pred);
+ VisitInitListExpr(cast<InitListExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Stmt::ObjCIvarRefExprClass:
- Bldr.takeNodes(Pred);
- VisitLvalObjCIvarRefExpr(cast<ObjCIvarRefExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ case Stmt::MemberExprClass:
+ Bldr.takeNodes(Pred);
+ VisitMemberExpr(cast<MemberExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Stmt::ObjCForCollectionStmtClass:
- Bldr.takeNodes(Pred);
- VisitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ case Stmt::AtomicExprClass:
+ Bldr.takeNodes(Pred);
+ VisitAtomicExpr(cast<AtomicExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Stmt::ObjCMessageExprClass:
- Bldr.takeNodes(Pred);
- VisitObjCMessage(cast<ObjCMessageExpr>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ case Stmt::ObjCIvarRefExprClass:
+ Bldr.takeNodes(Pred);
+ VisitLvalObjCIvarRefExpr(cast<ObjCIvarRefExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Stmt::ObjCAtThrowStmtClass:
- case Stmt::CXXThrowExprClass:
- // FIXME: This is not complete. We basically treat @throw as
- // an abort.
- Bldr.generateSink(S, Pred, Pred->getState());
- break;
+ case Stmt::ObjCForCollectionStmtClass:
+ Bldr.takeNodes(Pred);
+ VisitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Stmt::ReturnStmtClass:
- Bldr.takeNodes(Pred);
- VisitReturnStmt(cast<ReturnStmt>(S), Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ case Stmt::ObjCMessageExprClass:
+ Bldr.takeNodes(Pred);
+ VisitObjCMessage(cast<ObjCMessageExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- case Stmt::OffsetOfExprClass: {
- Bldr.takeNodes(Pred);
- ExplodedNodeSet PreVisit;
- getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
+ case Stmt::ObjCAtThrowStmtClass:
+ case Stmt::CXXThrowExprClass:
+ // FIXME: This is not complete. We basically treat @throw as
+ // an abort.
+ Bldr.generateSink(S, Pred, Pred->getState());
+ break;
- ExplodedNodeSet PostVisit;
- for (const auto Node : PreVisit)
- VisitOffsetOfExpr(cast<OffsetOfExpr>(S), Node, PostVisit);
+ case Stmt::ReturnStmtClass:
+ Bldr.takeNodes(Pred);
+ VisitReturnStmt(cast<ReturnStmt>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- getCheckerManager().runCheckersForPostStmt(Dst, PostVisit, S, *this);
- Bldr.addNodes(Dst);
- break;
- }
+ case Stmt::OffsetOfExprClass: {
+ Bldr.takeNodes(Pred);
+ ExplodedNodeSet PreVisit;
+ getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
- case Stmt::UnaryExprOrTypeTraitExprClass:
- Bldr.takeNodes(Pred);
- VisitUnaryExprOrTypeTraitExpr(cast<UnaryExprOrTypeTraitExpr>(S),
- Pred, Dst);
- Bldr.addNodes(Dst);
- break;
+ ExplodedNodeSet PostVisit;
+ for (const auto Node : PreVisit)
+ VisitOffsetOfExpr(cast<OffsetOfExpr>(S), Node, PostVisit);
- case Stmt::StmtExprClass: {
- const auto *SE = cast<StmtExpr>(S);
+ getCheckerManager().runCheckersForPostStmt(Dst, PostVisit, S, *this);
+ Bldr.addNodes(Dst);
+ break;
+ }
- if (SE->getSubStmt()->body_empty()) {
- // Empty statement expression.
- assert(SE->getType() == getContext().VoidTy
- && "Empty statement expression must have void type.");
- break;
- }
+ case Stmt::UnaryExprOrTypeTraitExprClass:
+ Bldr.takeNodes(Pred);
+ VisitUnaryExprOrTypeTraitExpr(cast<UnaryExprOrTypeTraitExpr>(S), Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
- if (const auto *LastExpr =
- dyn_cast<Expr>(*SE->getSubStmt()->body_rbegin())) {
- ProgramStateRef state = Pred->getState();
- Bldr.generateNode(SE, Pred,
- state->BindExpr(SE, Pred->getLocationContext(),
- state->getSVal(LastExpr,
- Pred->getLocationContext())));
- }
- break;
- }
+ case Stmt::StmtExprClass: {
+ const auto *SE = cast<StmtExpr>(S);
- case Stmt::UnaryOperatorClass: {
- Bldr.takeNodes(Pred);
- const auto *U = cast<UnaryOperator>(S);
- if (AMgr.options.ShouldEagerlyAssume && (U->getOpcode() == UO_LNot)) {
- ExplodedNodeSet Tmp;
- VisitUnaryOperator(U, Pred, Tmp);
- evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, U);
- }
- else
- VisitUnaryOperator(U, Pred, Dst);
- Bldr.addNodes(Dst);
+ if (SE->getSubStmt()->body_empty()) {
+ // Empty statement expression.
+ assert(SE->getType() == getContext().VoidTy &&
+ "Empty statement expression must have void type.");
break;
}
- case Stmt::PseudoObjectExprClass: {
- Bldr.takeNodes(Pred);
+ if (const auto *LastExpr =
+ dyn_cast<Expr>(*SE->getSubStmt()->body_rbegin())) {
ProgramStateRef state = Pred->getState();
- const auto *PE = cast<PseudoObjectExpr>(S);
- if (const Expr *Result = PE->getResultExpr()) {
- SVal V = state->getSVal(Result, Pred->getLocationContext());
- Bldr.generateNode(S, Pred,
- state->BindExpr(S, Pred->getLocationContext(), V));
- }
- else
- Bldr.generateNode(S, Pred,
- state->BindExpr(S, Pred->getLocationContext(),
- UnknownVal()));
-
- Bldr.addNodes(Dst);
- break;
+ Bldr.generateNode(
+ SE, Pred,
+ state->BindExpr(
+ SE, Pred->getLocationContext(),
+ state->getSVal(LastExpr, Pred->getLocationContext())));
}
+ break;
+ }
- case Expr::ObjCIndirectCopyRestoreExprClass: {
- // ObjCIndirectCopyRestoreExpr implies passing a temporary for
- // correctness of lifetime management. Due to limited analysis
- // of ARC, this is implemented as direct arg passing.
- Bldr.takeNodes(Pred);
- ProgramStateRef state = Pred->getState();
- const auto *OIE = cast<ObjCIndirectCopyRestoreExpr>(S);
- const Expr *E = OIE->getSubExpr();
- SVal V = state->getSVal(E, Pred->getLocationContext());
+ case Stmt::UnaryOperatorClass: {
+ Bldr.takeNodes(Pred);
+ const auto *U = cast<UnaryOperator>(S);
+ if (AMgr.options.ShouldEagerlyAssume && (U->getOpcode() == UO_LNot)) {
+ ExplodedNodeSet Tmp;
+ VisitUnaryOperator(U, Pred, Tmp);
+ evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, U);
+ } else
+ VisitUnaryOperator(U, Pred, Dst);
+ Bldr.addNodes(Dst);
+ break;
+ }
+
+ case Stmt::PseudoObjectExprClass: {
+ Bldr.takeNodes(Pred);
+ ProgramStateRef state = Pred->getState();
+ const auto *PE = cast<PseudoObjectExpr>(S);
+ if (const Expr *Result = PE->getResultExpr()) {
+ SVal V = state->getSVal(Result, Pred->getLocationContext());
Bldr.generateNode(S, Pred,
- state->BindExpr(S, Pred->getLocationContext(), V));
- Bldr.addNodes(Dst);
- break;
- }
+ state->BindExpr(S, Pred->getLocationContext(), V));
+ } else
+ Bldr.generateNode(
+ S, Pred,
+ state->BindExpr(S, Pred->getLocationContext(), UnknownVal()));
+
+ Bldr.addNodes(Dst);
+ break;
+ }
+
+ case Expr::ObjCIndirectCopyRestoreExprClass: {
+ // ObjCIndirectCopyRestoreExpr implies passing a temporary for
+ // correctness of lifetime management. Due to limited analysis
+ // of ARC, this is implemented as direct arg passing.
+ Bldr.takeNodes(Pred);
+ ProgramStateRef state = Pred->getState();
+ const auto *OIE = cast<ObjCIndirectCopyRestoreExpr>(S);
+ const Expr *E = OIE->getSubExpr();
+ SVal V = state->getSVal(E, Pred->getLocationContext());
+ Bldr.generateNode(S, Pred,
+ state->BindExpr(S, Pred->getLocationContext(), V));
+ Bldr.addNodes(Dst);
+ break;
+ }
}
}
@@ -2469,7 +2447,7 @@ bool ExprEngine::replayWithoutInlining(ExplodedNode *N,
// Note, changing the state ensures that we are not going to cache out.
ProgramStateRef NewNodeState = BeforeProcessingCall->getState();
NewNodeState =
- NewNodeState->set<ReplayWithoutInlining>(const_cast<Stmt *>(CE));
+ NewNodeState->set<ReplayWithoutInlining>(const_cast<Stmt *>(CE));
// Make the new node a successor of BeforeProcessingCall.
bool IsNew = false;
@@ -2483,7 +2461,7 @@ bool ExprEngine::replayWithoutInlining(ExplodedNode *N,
// Add the new node to the work list.
Engine.enqueueStmtNode(NewNode, CalleeSF->getCallSiteBlock(),
- CalleeSF->getIndex());
+ CalleeSF->getIndex());
NumTimesRetriedWithoutInlining++;
return true;
}
@@ -2495,7 +2473,7 @@ void ExprEngine::processCFGBlockEntrance(const BlockEdge &L,
PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
// If we reach a loop which has a known bound (and meets
// other constraints) then consider completely unrolling it.
- if(AMgr.options.ShouldUnrollLoops) {
+ if (AMgr.options.ShouldUnrollLoops) {
unsigned maxBlockVisitOnPath = AMgr.options.maxBlockVisitOnPath;
const Stmt *Term = nodeBuilder.getContext().getBlock()->getTerminatorStmt();
if (Term) {
@@ -2509,7 +2487,7 @@ void ExprEngine::processCFGBlockEntrance(const BlockEdge &L,
}
}
// Is we are inside an unrolled loop then no need the check the counters.
- if(isUnrolledState(Pred->getState()))
+ if (isUnrolledState(Pred->getState()))
return;
}
@@ -2533,14 +2511,14 @@ void ExprEngine::processCFGBlockEntrance(const BlockEdge &L,
if (BlockCount >= AMgr.options.maxBlockVisitOnPath) {
static SimpleProgramPointTag tag(TagProviderName, "Block count exceeded");
const ExplodedNode *Sink =
- nodeBuilder.generateSink(Pred->getState(), Pred, &tag);
+ nodeBuilder.generateSink(Pred->getState(), Pred, &tag);
// Check if we stopped at the top level function or not.
// Root node should have the location context of the top most function.
const LocationContext *CalleeLC = Pred->getLocation().getLocationContext();
const LocationContext *CalleeSF = CalleeLC->getStackFrame();
const LocationContext *RootLC =
- (*G.roots_begin())->getLocation().getLocationContext();
+ (*G.roots_begin())->getLocation().getLocationContext();
if (RootLC->getStackFrame() != CalleeSF) {
Engine.FunctionSummaries->markReachedMaxBlockCount(CalleeSF->getDecl());
@@ -2569,10 +2547,8 @@ void ExprEngine::processCFGBlockEntrance(const BlockEdge &L,
/// integers that promote their values (which are currently not tracked well).
/// This function returns the SVal bound to Condition->IgnoreCasts if all the
// cast(s) did was sign-extend the original value.
-static SVal RecoverCastedSymbol(ProgramStateRef state,
- const Stmt *Condition,
- const LocationContext *LCtx,
- ASTContext &Ctx) {
+static SVal RecoverCastedSymbol(ProgramStateRef state, const Stmt *Condition,
+ const LocationContext *LCtx, ASTContext &Ctx) {
const auto *Ex = dyn_cast<Expr>(Condition);
if (!Ex)
@@ -2633,8 +2609,7 @@ static const Stmt *getRightmostLeaf(const Stmt *Condition) {
// not evaluated, and is thus not in the SVal cache, we need to use that leaf
// expression to evaluate the truth value of the condition in the current state
// space.
-static const Stmt *ResolveCondition(const Stmt *Condition,
- const CFGBlock *B) {
+static const Stmt *ResolveCondition(const Stmt *Condition, const CFGBlock *B) {
if (const auto *Ex = dyn_cast<Expr>(Condition))
Condition = Ex->IgnoreParens();
@@ -2676,10 +2651,9 @@ ProgramStateRef ExprEngine::setWhetherHasMoreIteration(
return State->set<ObjCForHasMoreIterations>({O, LC}, HasMoreIteraton);
}
-ProgramStateRef
-ExprEngine::removeIterationState(ProgramStateRef State,
- const ObjCForCollectionStmt *O,
- const LocationContext *LC) {
+ProgramStateRef ExprEngine::removeIterationState(ProgramStateRef State,
+ const ObjCForCollectionStmt *O,
+ const LocationContext *LC) {
assert(State->contains<ObjCForHasMoreIterations>({O, LC}));
return State->remove<ObjCForHasMoreIterations>({O, LC});
}
@@ -2742,10 +2716,8 @@ assumeCondition(const Stmt *Condition, ExplodedNode *N) {
}
void ExprEngine::processBranch(const Stmt *Condition,
- NodeBuilderContext& BldCtx,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst,
- const CFGBlock *DstT,
+ NodeBuilderContext &BldCtx, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst, const CFGBlock *DstT,
const CFGBlock *DstF) {
assert((!Condition || !isa<CXXBindTemporaryExpr>(Condition)) &&
"CXXBindTemporaryExprs are handled by processBindTemporary.");
@@ -2819,12 +2791,9 @@ void ExprEngine::processBranch(const Stmt *Condition,
REGISTER_TRAIT_WITH_PROGRAMSTATE(InitializedGlobalsSet,
llvm::ImmutableSet<const VarDecl *>)
-void ExprEngine::processStaticInitializer(const DeclStmt *DS,
- NodeBuilderContext &BuilderCtx,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst,
- const CFGBlock *DstT,
- const CFGBlock *DstF) {
+void ExprEngine::processStaticInitializer(
+ const DeclStmt *DS, NodeBuilderContext &BuilderCtx, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst, const CFGBlock *DstT, const CFGBlock *DstF) {
PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
currBldrCtx = &BuilderCtx;
@@ -2873,7 +2842,7 @@ void ExprEngine::processIndirectGoto(IndirectGotoNodeBuilder &builder) {
if (isa<UndefinedVal, loc::ConcreteInt>(V)) {
// Dispatch to the first target and mark it as a sink.
- //ExplodedNode* N = builder.generateNode(builder.begin(), state, true);
+ // ExplodedNode* N = builder.generateNode(builder.begin(), state, true);
// FIXME: add checker visit.
// UndefBranches.insert(N);
return;
@@ -2896,7 +2865,7 @@ void ExprEngine::processBeginOfFunction(NodeBuilderContext &BC,
/// ProcessEndPath - Called by CoreEngine. Used to generate end-of-path
/// nodes when the control reaches the end of a function.
-void ExprEngine::processEndOfFunction(NodeBuilderContext& BC,
+void ExprEngine::processEndOfFunction(NodeBuilderContext &BC,
ExplodedNode *Pred,
const ReturnStmt *RS) {
ProgramStateRef State = Pred->getState();
@@ -2970,17 +2939,17 @@ void ExprEngine::processEndOfFunction(NodeBuilderContext& BC,
/// ProcessSwitch - Called by CoreEngine. Used to generate successor
/// nodes by processing the 'effects' of a switch statement.
-void ExprEngine::processSwitch(SwitchNodeBuilder& builder) {
+void ExprEngine::processSwitch(SwitchNodeBuilder &builder) {
using iterator = SwitchNodeBuilder::iterator;
ProgramStateRef state = builder.getState();
const Expr *CondE = builder.getCondition();
- SVal CondV_untested = state->getSVal(CondE, builder.getLocationContext());
+ SVal CondV_untested = state->getSVal(CondE, builder.getLocationContext());
if (CondV_untested.isUndef()) {
- //ExplodedNode* N = builder.generateDefaultCaseNode(state, true);
- // FIXME: add checker
- //UndefBranches.insert(N);
+ // ExplodedNode* N = builder.generateDefaultCaseNode(state, true);
+ // FIXME: add checker
+ // UndefBranches.insert(N);
return;
}
@@ -2991,7 +2960,7 @@ void ExprEngine::processSwitch(SwitchNodeBuilder& builder) {
iterator I = builder.begin(), EI = builder.end();
bool defaultIsFeasible = I == EI;
- for ( ; I != EI; ++I) {
+ for (; I != EI; ++I) {
// Successor may be pruned out during CFG construction.
if (!I.getBlock())
continue;
@@ -3083,8 +3052,7 @@ void ExprEngine::VisitCommonDeclRefExpr(const Expr *Ex, const NamedDecl *D,
// Sema follows a sequence of complex rules to determine whether the
// variable should be captured.
if (const FieldDecl *FD = LambdaCaptureFields[VD]) {
- Loc CXXThis =
- svalBuilder.getCXXThis(MD, LocCtxt->getStackFrame());
+ Loc CXXThis = svalBuilder.getCXXThis(MD, LocCtxt->getStackFrame());
SVal CXXThisVal = state->getSVal(CXXThis);
VInfo = std::make_pair(state->getLValue(FD, CXXThisVal), FD->getType());
}
@@ -3292,10 +3260,10 @@ void ExprEngine::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *Ex,
/// VisitArraySubscriptExpr - Transfer function for array accesses
void ExprEngine::VisitArraySubscriptExpr(const ArraySubscriptExpr *A,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst){
+ ExplodedNode *Pred,
+ ExplodedNodeSet &Dst) {
const Expr *Base = A->getBase()->IgnoreParens();
- const Expr *Idx = A->getIdx()->IgnoreParens();
+ const Expr *Idx = A->getIdx()->IgnoreParens();
ExplodedNodeSet CheckerPreStmt;
getCheckerManager().runCheckersForPreStmt(CheckerPreStmt, Pred, A, *this);
@@ -3308,8 +3276,9 @@ void ExprEngine::VisitArraySubscriptExpr(const ArraySubscriptExpr *A,
// The "like" case is for situations where C standard prohibits the type to
// be an lvalue, e.g. taking the address of a subscript of an expression of
// type "void *".
- bool IsGLValueLike = A->isGLValue() ||
- (A->getType().isCForbiddenLValueType() && !AMgr.getLangOpts().CPlusPlus);
+ bool IsGLValueLike =
+ A->isGLValue() ||
+ (A->getType().isCForbiddenLValueType() && !AMgr.getLangOpts().CPlusPlus);
for (auto *Node : CheckerPreStmt) {
const LocationContext *LCtx = Node->getLocationContext();
@@ -3324,11 +3293,10 @@ void ExprEngine::VisitArraySubscriptExpr(const ArraySubscriptExpr *A,
if (T->isVoidType())
T = getContext().CharTy;
- SVal V = state->getLValue(T,
- state->getSVal(Idx, LCtx),
+ SVal V = state->getLValue(T, state->getSVal(Idx, LCtx),
state->getSVal(Base, LCtx));
Bldr.generateNode(A, Node, state->BindExpr(A, LCtx, V), nullptr,
- ProgramPoint::PostLValueKind);
+ ProgramPoint::PostLValueKind);
} else if (IsVectorType) {
// FIXME: non-glvalue vector reads are not modelled.
Bldr.generateNode(A, Node, state, nullptr);
@@ -3403,8 +3371,8 @@ void ExprEngine::VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred,
// pointers as soon as they are used.
if (!M->isGLValue()) {
assert(M->getType()->isArrayType());
- const auto *PE =
- dyn_cast<ImplicitCastExpr>(I->getParentMap().getParentIgnoreParens(M));
+ const auto *PE = dyn_cast<ImplicitCastExpr>(
+ I->getParentMap().getParentIgnoreParens(M));
if (!PE || PE->getCastKind() != CK_ArrayToPointerDecay) {
llvm_unreachable("should always be wrapped in ArrayToPointerDecay");
}
@@ -3453,18 +3421,17 @@ void ExprEngine::VisitAtomicExpr(const AtomicExpr *AE, ExplodedNode *Pred,
}
State = State->invalidateRegions(ValuesToInvalidate, AE,
- currBldrCtx->blockCount(),
- LCtx,
- /*CausedByPointerEscape*/true,
- /*Symbols=*/nullptr);
+ currBldrCtx->blockCount(), LCtx,
+ /*CausedByPointerEscape*/ true,
+ /*Symbols=*/nullptr);
SVal ResultVal = UnknownVal();
State = State->BindExpr(AE, LCtx, ResultVal);
- Bldr.generateNode(AE, I, State, nullptr,
- ProgramPoint::PostStmtKind);
+ Bldr.generateNode(AE, I, State, nullptr, ProgramPoint::PostStmtKind);
}
- getCheckerManager().runCheckersForPostStmt(Dst, AfterInvalidateSet, AE, *this);
+ getCheckerManager().runCheckersForPostStmt(Dst, AfterInvalidateSet, AE,
+ *this);
}
// A value escapes in four possible cases:
@@ -3523,21 +3490,16 @@ ExprEngine::processPointerEscapedOnBind(ProgramStateRef State, SVal Loc,
nullptr);
}
-ProgramStateRef
-ExprEngine::notifyCheckersOfPointerEscape(ProgramStateRef State,
- const InvalidatedSymbols *Invalidated,
- ArrayRef<const MemRegion *> ExplicitRegions,
- const CallEvent *Call,
+ProgramStateRef ExprEngine::notifyCheckersOfPointerEscape(
+ ProgramStateRef State, const InvalidatedSymbols *Invalidated,
+ ArrayRef<const MemRegion *> ExplicitRegions, const CallEvent *Call,
RegionAndSymbolInvalidationTraits &ITraits) {
if (!Invalidated || Invalidated->empty())
return State;
if (!Call)
- return getCheckerManager().runCheckersForPointerEscape(State,
- *Invalidated,
- nullptr,
- PSK_EscapeOther,
- &ITraits);
+ return getCheckerManager().runCheckersForPointerEscape(
+ State, *Invalidated, nullptr, PSK_EscapeOther, &ITraits);
// If the symbols were invalidated by a call, we want to find out which ones
// were invalidated directly due to being arguments to the call.
@@ -3555,13 +3517,15 @@ ExprEngine::notifyCheckersOfPointerEscape(ProgramStateRef State,
}
if (!SymbolsDirectlyInvalidated.empty())
- State = getCheckerManager().runCheckersForPointerEscape(State,
- SymbolsDirectlyInvalidated, Call, PSK_DirectEscapeOnCall, &ITraits);
+ State = getCheckerManager().runCheckersForPointerEscape(
+ State, SymbolsDirectlyInvalidated, Call, PSK_DirectEscapeOnCall,
+ &ITraits);
// Notify about the symbols that get indirectly invalidated by the call.
if (!SymbolsIndirectlyInvalidated.empty())
- State = getCheckerManager().runCheckersForPointerEscape(State,
- SymbolsIndirectlyInvalidated, Call, PSK_IndirectEscapeOnCall, &ITraits);
+ State = getCheckerManager().runCheckersForPointerEscape(
+ State, SymbolsIndirectlyInvalidated, Call, PSK_IndirectEscapeOnCall,
+ &ITraits);
return State;
}
@@ -3569,8 +3533,7 @@ ExprEngine::notifyCheckersOfPointerEscape(ProgramStateRef State,
/// evalBind - Handle the semantics of binding a value to a specific location.
/// This method is used by evalStore and (soon) VisitDeclStmt, and others.
void ExprEngine::evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE,
- ExplodedNode *Pred,
- SVal location, SVal Val,
+ ExplodedNode *Pred, SVal location, SVal Val,
bool atDeclInit, const ProgramPoint *PP) {
const LocationContext *LC = Pred->getLocationContext();
PostStmt PS(StoreE, LC);
@@ -3587,8 +3550,8 @@ void ExprEngine::evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE,
// If the location is not a 'Loc', it will already be handled by
// the checkers. There is nothing left to do.
if (!isa<Loc>(location)) {
- const ProgramPoint L = PostStore(StoreE, LC, /*Loc*/nullptr,
- /*tag*/nullptr);
+ const ProgramPoint L = PostStore(StoreE, LC, /*Loc*/ nullptr,
+ /*tag*/ nullptr);
ProgramStateRef state = Pred->getState();
state = processPointerEscapedOnBind(state, location, Val, LC);
Bldr.generateNode(L, state, Pred);
@@ -3603,8 +3566,8 @@ void ExprEngine::evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE,
// When binding the value, pass on the hint that this is a initialization.
// For initializations, we do not need to inform clients of region
// changes.
- state = state->bindLoc(location.castAs<Loc>(),
- Val, LC, /* notifyChanges = */ !atDeclInit);
+ state = state->bindLoc(location.castAs<Loc>(), Val, LC,
+ /* notifyChanges = */ !atDeclInit);
const MemRegion *LocReg = nullptr;
if (std::optional<loc::MemRegionVal> LocRegVal =
@@ -3626,10 +3589,9 @@ void ExprEngine::evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE,
/// @param location The location to store the value
/// @param Val The value to be stored
void ExprEngine::evalStore(ExplodedNodeSet &Dst, const Expr *AssignE,
- const Expr *LocationE,
- ExplodedNode *Pred,
- ProgramStateRef state, SVal location, SVal Val,
- const ProgramPointTag *tag) {
+ const Expr *LocationE, ExplodedNode *Pred,
+ ProgramStateRef state, SVal location, SVal Val,
+ const ProgramPointTag *tag) {
// Proceed with the store. We use AssignE as the anchor for the PostStore
// ProgramPoint if it is non-NULL, and LocationE otherwise.
const Expr *StoreE = AssignE ? AssignE : LocationE;
@@ -3648,14 +3610,10 @@ void ExprEngine::evalStore(ExplodedNodeSet &Dst, const Expr *AssignE,
evalBind(Dst, StoreE, I, location, Val, false);
}
-void ExprEngine::evalLoad(ExplodedNodeSet &Dst,
- const Expr *NodeEx,
- const Expr *BoundEx,
- ExplodedNode *Pred,
- ProgramStateRef state,
- SVal location,
- const ProgramPointTag *tag,
- QualType LoadTy) {
+void ExprEngine::evalLoad(ExplodedNodeSet &Dst, const Expr *NodeEx,
+ const Expr *BoundEx, ExplodedNode *Pred,
+ ProgramStateRef state, SVal location,
+ const ProgramPointTag *tag, QualType LoadTy) {
assert(!isa<NonLoc>(location) && "location cannot be a NonLoc.");
assert(NodeEx);
assert(BoundEx);
@@ -3686,12 +3644,9 @@ void ExprEngine::evalLoad(ExplodedNodeSet &Dst,
}
}
-void ExprEngine::evalLocation(ExplodedNodeSet &Dst,
- const Stmt *NodeEx,
- const Stmt *BoundEx,
- ExplodedNode *Pred,
- ProgramStateRef state,
- SVal location,
+void ExprEngine::evalLocation(ExplodedNodeSet &Dst, const Stmt *NodeEx,
+ const Stmt *BoundEx, ExplodedNode *Pred,
+ ProgramStateRef state, SVal location,
bool isLoad) {
StmtNodeBuilder BldrTop(Pred, Dst, *currBldrCtx);
// Early checks for performance reason.
@@ -3716,18 +3671,17 @@ void ExprEngine::evalLocation(ExplodedNodeSet &Dst,
Bldr.generateNode(NodeEx, Pred, state, &tag);
}
ExplodedNodeSet Tmp;
- getCheckerManager().runCheckersForLocation(Tmp, Src, location, isLoad,
- NodeEx, BoundEx, *this);
+ getCheckerManager().runCheckersForLocation(Tmp, Src, location, isLoad, NodeEx,
+ BoundEx, *this);
BldrTop.addNodes(Tmp);
}
-std::pair<const ProgramPointTag *, const ProgramPointTag*>
+std::pair<const ProgramPointTag *, const ProgramPointTag *>
ExprEngine::geteagerlyAssumeBinOpBifurcationTags() {
- static SimpleProgramPointTag
- eagerlyAssumeBinOpBifurcationTrue(TagProviderName,
- "Eagerly Assume True"),
- eagerlyAssumeBinOpBifurcationFalse(TagProviderName,
- "Eagerly Assume False");
+ static SimpleProgramPointTag eagerlyAssumeBinOpBifurcationTrue(
+ TagProviderName, "Eagerly Assume True"),
+ eagerlyAssumeBinOpBifurcationFalse(TagProviderName,
+ "Eagerly Assume False");
return std::make_pair(&eagerlyAssumeBinOpBifurcationTrue,
&eagerlyAssumeBinOpBifurcationFalse);
}
@@ -3750,8 +3704,8 @@ void ExprEngine::evalEagerlyAssumeBinOpBifurcation(ExplodedNodeSet &Dst,
SVal V = state->getSVal(Ex, Pred->getLocationContext());
std::optional<nonloc::SymbolVal> SEV = V.getAs<nonloc::SymbolVal>();
if (SEV && SEV->isExpression()) {
- const std::pair<const ProgramPointTag *, const ProgramPointTag*> &tags =
- geteagerlyAssumeBinOpBifurcationTags();
+ const std::pair<const ProgramPointTag *, const ProgramPointTag *> &tags =
+ geteagerlyAssumeBinOpBifurcationTags();
ProgramStateRef StateTrue, StateFalse;
std::tie(StateTrue, StateFalse) = state->assume(*SEV);
@@ -3808,13 +3762,14 @@ void ExprEngine::VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred,
namespace llvm {
-template<>
-struct DOTGraphTraits<ExplodedGraph*> : public DefaultDOTGraphTraits {
- DOTGraphTraits (bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
+template <>
+struct DOTGraphTraits<ExplodedGraph *> : public DefaultDOTGraphTraits {
+ DOTGraphTraits(bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
static bool nodeHasBugReport(const ExplodedNode *N) {
BugReporter &BR = static_cast<ExprEngine &>(
- N->getState()->getStateManager().getOwningEngine()).getBugReporter();
+ N->getState()->getStateManager().getOwningEngine())
+ .getBugReporter();
for (const auto &Class : BR.equivalenceClasses()) {
for (const auto &Report : Class.getReports()) {
@@ -3857,7 +3812,7 @@ struct DOTGraphTraits<ExplodedGraph*> : public DefaultDOTGraphTraits {
return N->isTrivial();
}
- static std::string getNodeLabel(const ExplodedNode *N, ExplodedGraph *G){
+ static std::string getNodeLabel(const ExplodedNode *N, ExplodedGraph *G) {
std::string Buf;
llvm::raw_string_ostream Out(Buf);
@@ -3865,8 +3820,7 @@ struct DOTGraphTraits<ExplodedGraph*> : public DefaultDOTGraphTraits {
const unsigned int Space = 1;
ProgramStateRef State = N->getState();
- Out << "{ \"state_id\": " << State->getID()
- << ",\\l";
+ Out << "{ \"state_id\": " << State->getID() << ",\\l";
Indent(Out, Space, IsDot) << "\"program_points\": [\\l";
@@ -3881,9 +3835,9 @@ struct DOTGraphTraits<ExplodedGraph*> : public DefaultDOTGraphTraits {
Out << '\"' << Tag->getTagDescription() << '\"';
else
Out << "null";
- Out << ", \"node_id\": " << OtherNode->getID() <<
- ", \"is_sink\": " << OtherNode->isSink() <<
- ", \"has_report\": " << nodeHasBugReport(OtherNode) << " }";
+ Out << ", \"node_id\": " << OtherNode->getID()
+ << ", \"is_sink\": " << OtherNode->isSink()
+ << ", \"has_report\": " << nodeHasBugReport(OtherNode) << " }";
},
// Adds a comma and a new-line between each program point.
[&](const ExplodedNode *) { Out << ",\\l"; },
@@ -3952,4 +3906,4 @@ void *ProgramStateTrait<ReplayWithoutInlining>::GDMIndex() {
return &index;
}
-void ExprEngine::anchor() { }
+void ExprEngine::anchor() {}
diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp
index c3fc56ac30ee9f..6e49c43000d895 100644
--- a/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp
+++ b/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp
@@ -26,9 +26,11 @@ using llvm::APSInt;
/// (offset) if it is unknown so that memory arithmetic always
/// results in an ElementRegion.
/// \p Count The number of times the current basic block was visited.
-static SVal conjureOffsetSymbolOnLocation(
- SVal Symbol, SVal Other, Expr* Expression, SValBuilder &svalBuilder,
- unsigned Count, const LocationContext *LCtx) {
+static SVal conjureOffsetSymbolOnLocation(SVal Symbol, SVal Other,
+ Expr *Expression,
+ SValBuilder &svalBuilder,
+ unsigned Count,
+ const LocationContext *LCtx) {
QualType Ty = Expression->getType();
if (isa<Loc>(Other) && Ty->isIntegralOrEnumerationType() &&
Symbol.isUnknown()) {
@@ -37,9 +39,8 @@ static SVal conjureOffsetSymbolOnLocation(
return Symbol;
}
-void ExprEngine::VisitBinaryOperator(const BinaryOperator* B,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst) {
+void ExprEngine::VisitBinaryOperator(const BinaryOperator *B,
+ ExplodedNode *Pred, ExplodedNodeSet &Dst) {
Expr *LHS = B->getLHS()->IgnoreParens();
Expr *RHS = B->getRHS()->IgnoreParens();
@@ -50,8 +51,8 @@ void ExprEngine::VisitBinaryOperator(const BinaryOperator* B,
getCheckerManager().runCheckersForPreStmt(CheckedSet, Pred, B, *this);
// With both the LHS and RHS evaluated, process the operation itself.
- for (ExplodedNodeSet::iterator it=CheckedSet.begin(), ei=CheckedSet.end();
- it != ei; ++it) {
+ for (ExplodedNodeSet::iterator it = CheckedSet.begin(), ei = CheckedSet.end();
+ it != ei; ++it) {
ProgramStateRef state = (*it)->getState();
const LocationContext *LCtx = (*it)->getLocationContext();
@@ -65,14 +66,14 @@ void ExprEngine::VisitBinaryOperator(const BinaryOperator* B,
// FIXME: Handle structs.
if (RightV.isUnknown()) {
unsigned Count = currBldrCtx->blockCount();
- RightV = svalBuilder.conjureSymbolVal(nullptr, B->getRHS(), LCtx,
- Count);
+ RightV =
+ svalBuilder.conjureSymbolVal(nullptr, B->getRHS(), LCtx, Count);
}
// Simulate the effects of a "store": bind the value of the RHS
// to the L-Value represented by the LHS.
SVal ExprVal = B->isGLValue() ? LeftV : RightV;
- evalStore(Tmp2, B, LHS, *it, state->BindExpr(B, LCtx, ExprVal),
- LeftV, RightV);
+ evalStore(Tmp2, B, LHS, *it, state->BindExpr(B, LCtx, ExprVal), LeftV,
+ RightV);
continue;
}
@@ -83,10 +84,10 @@ void ExprEngine::VisitBinaryOperator(const BinaryOperator* B,
// TODO: This can be removed after we enable history tracking with
// SymSymExpr.
unsigned Count = currBldrCtx->blockCount();
- RightV = conjureOffsetSymbolOnLocation(
- RightV, LeftV, RHS, svalBuilder, Count, LCtx);
- LeftV = conjureOffsetSymbolOnLocation(
- LeftV, RightV, LHS, svalBuilder, Count, LCtx);
+ RightV = conjureOffsetSymbolOnLocation(RightV, LeftV, RHS, svalBuilder,
+ Count, LCtx);
+ LeftV = conjureOffsetSymbolOnLocation(LeftV, RightV, LHS, svalBuilder,
+ Count, LCtx);
}
// Although we don't yet model pointers-to-members, we do need to make
@@ -110,21 +111,41 @@ void ExprEngine::VisitBinaryOperator(const BinaryOperator* B,
continue;
}
- assert (B->isCompoundAssignmentOp());
+ assert(B->isCompoundAssignmentOp());
switch (Op) {
- default:
- llvm_unreachable("Invalid opcode for compound assignment.");
- case BO_MulAssign: Op = BO_Mul; break;
- case BO_DivAssign: Op = BO_Div; break;
- case BO_RemAssign: Op = BO_Rem; break;
- case BO_AddAssign: Op = BO_Add; break;
- case BO_SubAssign: Op = BO_Sub; break;
- case BO_ShlAssign: Op = BO_Shl; break;
- case BO_ShrAssign: Op = BO_Shr; break;
- case BO_AndAssign: Op = BO_And; break;
- case BO_XorAssign: Op = BO_Xor; break;
- case BO_OrAssign: Op = BO_Or; break;
+ default:
+ llvm_unreachable("Invalid opcode for compound assignment.");
+ case BO_MulAssign:
+ Op = BO_Mul;
+ break;
+ case BO_DivAssign:
+ Op = BO_Div;
+ break;
+ case BO_RemAssign:
+ Op = BO_Rem;
+ break;
+ case BO_AddAssign:
+ Op = BO_Add;
+ break;
+ case BO_SubAssign:
+ Op = BO_Sub;
+ break;
+ case BO_ShlAssign:
+ Op = BO_Shl;
+ break;
+ case BO_ShrAssign:
+ Op = BO_Shr;
+ break;
+ case BO_AndAssign:
+ Op = BO_And;
+ break;
+ case BO_XorAssign:
+ Op = BO_Xor;
+ break;
+ case BO_OrAssign:
+ Op = BO_Or;
+ break;
}
// Perform a load (the LHS). This performs the checks for
@@ -140,11 +161,11 @@ void ExprEngine::VisitBinaryOperator(const BinaryOperator* B,
// Get the computation type.
QualType CTy =
- cast<CompoundAssignOperator>(B)->getComputationResultType();
+ cast<CompoundAssignOperator>(B)->getComputationResultType();
CTy = getContext().getCanonicalType(CTy);
QualType CLHSTy =
- cast<CompoundAssignOperator>(B)->getComputationLHSType();
+ cast<CompoundAssignOperator>(B)->getComputationLHSType();
CLHSTy = getContext().getCanonicalType(CLHSTy);
QualType LTy = getContext().getCanonicalType(LHS->getType());
@@ -197,8 +218,7 @@ void ExprEngine::VisitBlockExpr(const BlockExpr *BE, ExplodedNode *Pred,
const BlockDecl *BD = BE->getBlockDecl();
// Get the value of the block itself.
- SVal V = svalBuilder.getBlockPointer(BD, T,
- Pred->getLocationContext(),
+ SVal V = svalBuilder.getBlockPointer(BD, T, Pred->getLocationContext(),
currBldrCtx->blockCount());
ProgramStateRef State = Pred->getState();
@@ -206,7 +226,7 @@ void ExprEngine::VisitBlockExpr(const BlockExpr *BE, ExplodedNode *Pred,
// If we created a new MemRegion for the block, we should explicitly bind
// the captured variables.
if (const BlockDataRegion *BDR =
- dyn_cast_or_null<BlockDataRegion>(V.getAsRegion())) {
+ dyn_cast_or_null<BlockDataRegion>(V.getAsRegion())) {
auto ReferencedVars = BDR->referenced_vars();
auto CI = BD->capture_begin();
@@ -218,9 +238,9 @@ void ExprEngine::VisitBlockExpr(const BlockExpr *BE, ExplodedNode *Pred,
// If the capture had a copy expression, use the result of evaluating
// that expression, otherwise use the original value.
// We rely on the invariant that the block declaration's capture variables
- // are a prefix of the BlockDataRegion's referenced vars (which may include
- // referenced globals, etc.) to enable fast lookup of the capture for a
- // given referenced var.
+ // are a prefix of the BlockDataRegion's referenced vars (which may
+ // include referenced globals, etc.) to enable fast lookup of the capture
+ // for a given referenced var.
const Expr *copyExpr = nullptr;
if (CI != CE) {
assert(CI->getVariable() == capturedR->getDecl());
@@ -244,17 +264,18 @@ void ExprEngine::VisitBlockExpr(const BlockExpr *BE, ExplodedNode *Pred,
ExplodedNodeSet Tmp;
StmtNodeBuilder Bldr(Pred, Tmp, *currBldrCtx);
Bldr.generateNode(BE, Pred,
- State->BindExpr(BE, Pred->getLocationContext(), V),
- nullptr, ProgramPoint::PostLValueKind);
+ State->BindExpr(BE, Pred->getLocationContext(), V), nullptr,
+ ProgramPoint::PostLValueKind);
// FIXME: Move all post/pre visits to ::Visit().
getCheckerManager().runCheckersForPostStmt(Dst, Tmp, BE, *this);
}
-ProgramStateRef ExprEngine::handleLValueBitCast(
- ProgramStateRef state, const Expr* Ex, const LocationContext* LCtx,
- QualType T, QualType ExTy, const CastExpr* CastE, StmtNodeBuilder& Bldr,
- ExplodedNode* Pred) {
+ProgramStateRef
+ExprEngine::handleLValueBitCast(ProgramStateRef state, const Expr *Ex,
+ const LocationContext *LCtx, QualType T,
+ QualType ExTy, const CastExpr *CastE,
+ StmtNodeBuilder &Bldr, ExplodedNode *Pred) {
if (T->isLValueReferenceType()) {
assert(!CastE->getType()->isLValueReferenceType());
ExTy = getContext().getLValueReferenceType(ExTy);
@@ -299,7 +320,8 @@ void ExprEngine::VisitCast(const CastExpr *CastE, const Expr *Ex,
QualType T = CastE->getType();
QualType ExTy = Ex->getType();
- if (const ExplicitCastExpr *ExCast=dyn_cast_or_null<ExplicitCastExpr>(CastE))
+ if (const ExplicitCastExpr *ExCast =
+ dyn_cast_or_null<ExplicitCastExpr>(CastE))
T = ExCast->getTypeAsWritten();
StmtNodeBuilder Bldr(dstPreStmt, Dst, *currBldrCtx);
@@ -308,230 +330,225 @@ void ExprEngine::VisitCast(const CastExpr *CastE, const Expr *Ex,
const LocationContext *LCtx = Pred->getLocationContext();
switch (CastE->getCastKind()) {
- case CK_LValueToRValue:
- case CK_LValueToRValueBitCast:
- llvm_unreachable("LValueToRValue casts handled earlier.");
- case CK_ToVoid:
- continue;
- // The analyzer doesn't do anything special with these casts,
- // since it understands retain/release semantics already.
- case CK_ARCProduceObject:
- case CK_ARCConsumeObject:
- case CK_ARCReclaimReturnedObject:
- case CK_ARCExtendBlockObject: // Fall-through.
- case CK_CopyAndAutoreleaseBlockObject:
- // The analyser can ignore atomic casts for now, although some future
- // checkers may want to make certain that you're not modifying the same
- // value through atomic and nonatomic pointers.
- case CK_AtomicToNonAtomic:
- case CK_NonAtomicToAtomic:
- // True no-ops.
- case CK_NoOp:
- case CK_ConstructorConversion:
- case CK_UserDefinedConversion:
- case CK_FunctionToPointerDecay:
- case CK_BuiltinFnToFnPtr: {
- // Copy the SVal of Ex to CastE.
- ProgramStateRef state = Pred->getState();
- const LocationContext *LCtx = Pred->getLocationContext();
- SVal V = state->getSVal(Ex, LCtx);
- state = state->BindExpr(CastE, LCtx, V);
- Bldr.generateNode(CastE, Pred, state);
- continue;
- }
- case CK_MemberPointerToBoolean:
- case CK_PointerToBoolean: {
- SVal V = state->getSVal(Ex, LCtx);
- auto PTMSV = V.getAs<nonloc::PointerToMember>();
- if (PTMSV)
- V = svalBuilder.makeTruthVal(!PTMSV->isNullMemberPointer(), ExTy);
- if (V.isUndef() || PTMSV) {
- state = state->BindExpr(CastE, LCtx, V);
- Bldr.generateNode(CastE, Pred, state);
- continue;
- }
- // Explicitly proceed with default handler for this case cascade.
- state =
- handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
- continue;
- }
- case CK_Dependent:
- case CK_ArrayToPointerDecay:
- case CK_BitCast:
- case CK_AddressSpaceConversion:
- case CK_BooleanToSignedIntegral:
- case CK_IntegralToPointer:
- case CK_PointerToIntegral: {
- SVal V = state->getSVal(Ex, LCtx);
- if (isa<nonloc::PointerToMember>(V)) {
- state = state->BindExpr(CastE, LCtx, UnknownVal());
- Bldr.generateNode(CastE, Pred, state);
- continue;
- }
- // Explicitly proceed with default handler for this case cascade.
- state =
- handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
- continue;
- }
- case CK_IntegralToBoolean:
- case CK_IntegralToFloating:
- case CK_FloatingToIntegral:
- case CK_FloatingToBoolean:
- case CK_FloatingCast:
- case CK_FloatingRealToComplex:
- case CK_FloatingComplexToReal:
- case CK_FloatingComplexToBoolean:
- case CK_FloatingComplexCast:
- case CK_FloatingComplexToIntegralComplex:
- case CK_IntegralRealToComplex:
- case CK_IntegralComplexToReal:
- case CK_IntegralComplexToBoolean:
- case CK_IntegralComplexCast:
- case CK_IntegralComplexToFloatingComplex:
- case CK_CPointerToObjCPointerCast:
- case CK_BlockPointerToObjCPointerCast:
- case CK_AnyPointerToBlockPointerCast:
- case CK_ObjCObjectLValueCast:
- case CK_ZeroToOCLOpaqueType:
- case CK_IntToOCLSampler:
- case CK_LValueBitCast:
- case CK_FloatingToFixedPoint:
- case CK_FixedPointToFloating:
- case CK_FixedPointCast:
- case CK_FixedPointToBoolean:
- case CK_FixedPointToIntegral:
- case CK_IntegralToFixedPoint: {
- state =
- handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
- continue;
- }
- case CK_IntegralCast: {
- // Delegate to SValBuilder to process.
- SVal V = state->getSVal(Ex, LCtx);
- if (AMgr.options.ShouldSupportSymbolicIntegerCasts)
- V = svalBuilder.evalCast(V, T, ExTy);
- else
- V = svalBuilder.evalIntegralCast(state, V, T, ExTy);
+ case CK_LValueToRValue:
+ case CK_LValueToRValueBitCast:
+ llvm_unreachable("LValueToRValue casts handled earlier.");
+ case CK_ToVoid:
+ continue;
+ // The analyzer doesn't do anything special with these casts,
+ // since it understands retain/release semantics already.
+ case CK_ARCProduceObject:
+ case CK_ARCConsumeObject:
+ case CK_ARCReclaimReturnedObject:
+ case CK_ARCExtendBlockObject: // Fall-through.
+ case CK_CopyAndAutoreleaseBlockObject:
+ // The analyser can ignore atomic casts for now, although some future
+ // checkers may want to make certain that you're not modifying the same
+ // value through atomic and nonatomic pointers.
+ case CK_AtomicToNonAtomic:
+ case CK_NonAtomicToAtomic:
+ // True no-ops.
+ case CK_NoOp:
+ case CK_ConstructorConversion:
+ case CK_UserDefinedConversion:
+ case CK_FunctionToPointerDecay:
+ case CK_BuiltinFnToFnPtr: {
+ // Copy the SVal of Ex to CastE.
+ ProgramStateRef state = Pred->getState();
+ const LocationContext *LCtx = Pred->getLocationContext();
+ SVal V = state->getSVal(Ex, LCtx);
+ state = state->BindExpr(CastE, LCtx, V);
+ Bldr.generateNode(CastE, Pred, state);
+ continue;
+ }
+ case CK_MemberPointerToBoolean:
+ case CK_PointerToBoolean: {
+ SVal V = state->getSVal(Ex, LCtx);
+ auto PTMSV = V.getAs<nonloc::PointerToMember>();
+ if (PTMSV)
+ V = svalBuilder.makeTruthVal(!PTMSV->isNullMemberPointer(), ExTy);
+ if (V.isUndef() || PTMSV) {
state = state->BindExpr(CastE, LCtx, V);
Bldr.generateNode(CastE, Pred, state);
continue;
}
- case CK_DerivedToBase:
- case CK_UncheckedDerivedToBase: {
- // For DerivedToBase cast, delegate to the store manager.
- SVal val = state->getSVal(Ex, LCtx);
- val = getStoreManager().evalDerivedToBase(val, CastE);
- state = state->BindExpr(CastE, LCtx, val);
+ // Explicitly proceed with default handler for this case cascade.
+ state = handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
+ continue;
+ }
+ case CK_Dependent:
+ case CK_ArrayToPointerDecay:
+ case CK_BitCast:
+ case CK_AddressSpaceConversion:
+ case CK_BooleanToSignedIntegral:
+ case CK_IntegralToPointer:
+ case CK_PointerToIntegral: {
+ SVal V = state->getSVal(Ex, LCtx);
+ if (isa<nonloc::PointerToMember>(V)) {
+ state = state->BindExpr(CastE, LCtx, UnknownVal());
Bldr.generateNode(CastE, Pred, state);
continue;
}
- // Handle C++ dyn_cast.
- case CK_Dynamic: {
- SVal val = state->getSVal(Ex, LCtx);
+ // Explicitly proceed with default handler for this case cascade.
+ state = handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
+ continue;
+ }
+ case CK_IntegralToBoolean:
+ case CK_IntegralToFloating:
+ case CK_FloatingToIntegral:
+ case CK_FloatingToBoolean:
+ case CK_FloatingCast:
+ case CK_FloatingRealToComplex:
+ case CK_FloatingComplexToReal:
+ case CK_FloatingComplexToBoolean:
+ case CK_FloatingComplexCast:
+ case CK_FloatingComplexToIntegralComplex:
+ case CK_IntegralRealToComplex:
+ case CK_IntegralComplexToReal:
+ case CK_IntegralComplexToBoolean:
+ case CK_IntegralComplexCast:
+ case CK_IntegralComplexToFloatingComplex:
+ case CK_CPointerToObjCPointerCast:
+ case CK_BlockPointerToObjCPointerCast:
+ case CK_AnyPointerToBlockPointerCast:
+ case CK_ObjCObjectLValueCast:
+ case CK_ZeroToOCLOpaqueType:
+ case CK_IntToOCLSampler:
+ case CK_LValueBitCast:
+ case CK_FloatingToFixedPoint:
+ case CK_FixedPointToFloating:
+ case CK_FixedPointCast:
+ case CK_FixedPointToBoolean:
+ case CK_FixedPointToIntegral:
+ case CK_IntegralToFixedPoint: {
+ state = handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
+ continue;
+ }
+ case CK_IntegralCast: {
+ // Delegate to SValBuilder to process.
+ SVal V = state->getSVal(Ex, LCtx);
+ if (AMgr.options.ShouldSupportSymbolicIntegerCasts)
+ V = svalBuilder.evalCast(V, T, ExTy);
+ else
+ V = svalBuilder.evalIntegralCast(state, V, T, ExTy);
+ state = state->BindExpr(CastE, LCtx, V);
+ Bldr.generateNode(CastE, Pred, state);
+ continue;
+ }
+ case CK_DerivedToBase:
+ case CK_UncheckedDerivedToBase: {
+ // For DerivedToBase cast, delegate to the store manager.
+ SVal val = state->getSVal(Ex, LCtx);
+ val = getStoreManager().evalDerivedToBase(val, CastE);
+ state = state->BindExpr(CastE, LCtx, val);
+ Bldr.generateNode(CastE, Pred, state);
+ continue;
+ }
+ // Handle C++ dyn_cast.
+ case CK_Dynamic: {
+ SVal val = state->getSVal(Ex, LCtx);
- // Compute the type of the result.
- QualType resultType = CastE->getType();
- if (CastE->isGLValue())
- resultType = getContext().getPointerType(resultType);
+ // Compute the type of the result.
+ QualType resultType = CastE->getType();
+ if (CastE->isGLValue())
+ resultType = getContext().getPointerType(resultType);
- bool Failed = true;
+ bool Failed = true;
- // Check if the value being cast does not evaluates to 0.
- if (!val.isZeroConstant())
- if (std::optional<SVal> V =
- StateMgr.getStoreManager().evalBaseToDerived(val, T)) {
+ // Check if the value being cast does not evaluates to 0.
+ if (!val.isZeroConstant())
+ if (std::optional<SVal> V =
+ StateMgr.getStoreManager().evalBaseToDerived(val, T)) {
val = *V;
Failed = false;
- }
+ }
- if (Failed) {
- if (T->isReferenceType()) {
- // A bad_cast exception is thrown if input value is a reference.
- // Currently, we model this, by generating a sink.
- Bldr.generateSink(CastE, Pred, state);
- continue;
- } else {
- // If the cast fails on a pointer, bind to 0.
- state = state->BindExpr(CastE, LCtx,
- svalBuilder.makeNullWithType(resultType));
- }
+ if (Failed) {
+ if (T->isReferenceType()) {
+ // A bad_cast exception is thrown if input value is a reference.
+ // Currently, we model this, by generating a sink.
+ Bldr.generateSink(CastE, Pred, state);
+ continue;
} else {
- // If we don't know if the cast succeeded, conjure a new symbol.
- if (val.isUnknown()) {
- DefinedOrUnknownSVal NewSym =
- svalBuilder.conjureSymbolVal(nullptr, CastE, LCtx, resultType,
- currBldrCtx->blockCount());
- state = state->BindExpr(CastE, LCtx, NewSym);
- } else
- // Else, bind to the derived region value.
- state = state->BindExpr(CastE, LCtx, val);
+ // If the cast fails on a pointer, bind to 0.
+ state = state->BindExpr(CastE, LCtx,
+ svalBuilder.makeNullWithType(resultType));
}
- Bldr.generateNode(CastE, Pred, state);
- continue;
- }
- case CK_BaseToDerived: {
- SVal val = state->getSVal(Ex, LCtx);
- QualType resultType = CastE->getType();
- if (CastE->isGLValue())
- resultType = getContext().getPointerType(resultType);
-
- if (!val.isConstant()) {
- std::optional<SVal> V = getStoreManager().evalBaseToDerived(val, T);
- val = V ? *V : UnknownVal();
- }
-
- // Failed to cast or the result is unknown, fall back to conservative.
+ } else {
+ // If we don't know if the cast succeeded, conjure a new symbol.
if (val.isUnknown()) {
- val =
- svalBuilder.conjureSymbolVal(nullptr, CastE, LCtx, resultType,
- currBldrCtx->blockCount());
- }
- state = state->BindExpr(CastE, LCtx, val);
- Bldr.generateNode(CastE, Pred, state);
- continue;
+ DefinedOrUnknownSVal NewSym = svalBuilder.conjureSymbolVal(
+ nullptr, CastE, LCtx, resultType, currBldrCtx->blockCount());
+ state = state->BindExpr(CastE, LCtx, NewSym);
+ } else
+ // Else, bind to the derived region value.
+ state = state->BindExpr(CastE, LCtx, val);
}
- case CK_NullToPointer: {
- SVal V = svalBuilder.makeNullWithType(CastE->getType());
- state = state->BindExpr(CastE, LCtx, V);
- Bldr.generateNode(CastE, Pred, state);
- continue;
- }
- case CK_NullToMemberPointer: {
- SVal V = svalBuilder.getMemberPointer(nullptr);
- state = state->BindExpr(CastE, LCtx, V);
- Bldr.generateNode(CastE, Pred, state);
- continue;
+ Bldr.generateNode(CastE, Pred, state);
+ continue;
+ }
+ case CK_BaseToDerived: {
+ SVal val = state->getSVal(Ex, LCtx);
+ QualType resultType = CastE->getType();
+ if (CastE->isGLValue())
+ resultType = getContext().getPointerType(resultType);
+
+ if (!val.isConstant()) {
+ std::optional<SVal> V = getStoreManager().evalBaseToDerived(val, T);
+ val = V ? *V : UnknownVal();
}
- case CK_DerivedToBaseMemberPointer:
- case CK_BaseToDerivedMemberPointer:
- case CK_ReinterpretMemberPointer: {
- SVal V = state->getSVal(Ex, LCtx);
- if (auto PTMSV = V.getAs<nonloc::PointerToMember>()) {
- SVal CastedPTMSV =
- svalBuilder.makePointerToMember(getBasicVals().accumCXXBase(
- CastE->path(), *PTMSV, CastE->getCastKind()));
- state = state->BindExpr(CastE, LCtx, CastedPTMSV);
- Bldr.generateNode(CastE, Pred, state);
- continue;
- }
- // Explicitly proceed with default handler for this case cascade.
+
+ // Failed to cast or the result is unknown, fall back to conservative.
+ if (val.isUnknown()) {
+ val = svalBuilder.conjureSymbolVal(nullptr, CastE, LCtx, resultType,
+ currBldrCtx->blockCount());
}
- [[fallthrough]];
- // Various C++ casts that are not handled yet.
- case CK_ToUnion:
- case CK_MatrixCast:
- case CK_VectorSplat:
- case CK_HLSLVectorTruncation: {
- QualType resultType = CastE->getType();
- if (CastE->isGLValue())
- resultType = getContext().getPointerType(resultType);
- SVal result = svalBuilder.conjureSymbolVal(
- /*symbolTag=*/nullptr, CastE, LCtx, resultType,
- currBldrCtx->blockCount());
- state = state->BindExpr(CastE, LCtx, result);
+ state = state->BindExpr(CastE, LCtx, val);
+ Bldr.generateNode(CastE, Pred, state);
+ continue;
+ }
+ case CK_NullToPointer: {
+ SVal V = svalBuilder.makeNullWithType(CastE->getType());
+ state = state->BindExpr(CastE, LCtx, V);
+ Bldr.generateNode(CastE, Pred, state);
+ continue;
+ }
+ case CK_NullToMemberPointer: {
+ SVal V = svalBuilder.getMemberPointer(nullptr);
+ state = state->BindExpr(CastE, LCtx, V);
+ Bldr.generateNode(CastE, Pred, state);
+ continue;
+ }
+ case CK_DerivedToBaseMemberPointer:
+ case CK_BaseToDerivedMemberPointer:
+ case CK_ReinterpretMemberPointer: {
+ SVal V = state->getSVal(Ex, LCtx);
+ if (auto PTMSV = V.getAs<nonloc::PointerToMember>()) {
+ SVal CastedPTMSV =
+ svalBuilder.makePointerToMember(getBasicVals().accumCXXBase(
+ CastE->path(), *PTMSV, CastE->getCastKind()));
+ state = state->BindExpr(CastE, LCtx, CastedPTMSV);
Bldr.generateNode(CastE, Pred, state);
continue;
}
+ // Explicitly proceed with default handler for this case cascade.
+ }
+ [[fallthrough]];
+ // Various C++ casts that are not handled yet.
+ case CK_ToUnion:
+ case CK_MatrixCast:
+ case CK_VectorSplat:
+ case CK_HLSLVectorTruncation: {
+ QualType resultType = CastE->getType();
+ if (CastE->isGLValue())
+ resultType = getContext().getPointerType(resultType);
+ SVal result = svalBuilder.conjureSymbolVal(
+ /*symbolTag=*/nullptr, CastE, LCtx, resultType,
+ currBldrCtx->blockCount());
+ state = state->BindExpr(CastE, LCtx, result);
+ Bldr.generateNode(CastE, Pred, state);
+ continue;
+ }
}
}
}
@@ -579,7 +596,7 @@ void ExprEngine::VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred,
const VarDecl *VD = dyn_cast_or_null<VarDecl>(*DS->decl_begin());
if (!VD) {
- //TODO:AZ: remove explicit insertion after refactoring is done.
+ // TODO:AZ: remove explicit insertion after refactoring is done.
Dst.insert(Pred);
return;
}
@@ -591,7 +608,7 @@ void ExprEngine::VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred,
ExplodedNodeSet dstEvaluated;
StmtNodeBuilder B(dstPreVisit, dstEvaluated, *currBldrCtx);
for (ExplodedNodeSet::iterator I = dstPreVisit.begin(), E = dstPreVisit.end();
- I!=E; ++I) {
+ I != E; ++I) {
ExplodedNode *N = *I;
ProgramStateRef state = N->getState();
const LocationContext *LC = N->getLocationContext();
@@ -622,14 +639,12 @@ void ExprEngine::VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred,
currBldrCtx->blockCount());
}
-
B.takeNodes(UpdatedN);
ExplodedNodeSet Dst2;
evalBind(Dst2, DS, UpdatedN, state->getLValue(VD, LC), InitVal, true);
B.addNodes(Dst2);
}
- }
- else {
+ } else {
B.generateNode(DS, N, state);
}
}
@@ -637,7 +652,7 @@ void ExprEngine::VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred,
getCheckerManager().runCheckersForPostStmt(Dst, B.getResults(), DS, *this);
}
-void ExprEngine::VisitLogicalExpr(const BinaryOperator* B, ExplodedNode *Pred,
+void ExprEngine::VisitLogicalExpr(const BinaryOperator *B, ExplodedNode *Pred,
ExplodedNodeSet &Dst) {
// This method acts upon CFG elements for logical operators && and ||
// and attaches the value (true or false) to them as expressions.
@@ -654,8 +669,7 @@ void ExprEngine::VisitLogicalExpr(const BinaryOperator* B, ExplodedNode *Pred,
// Due to this ambiguity, a more reliable solution would have been to
// track the short circuit operation history path-sensitively until
// we evaluate the respective logical operator.
- assert(B->getOpcode() == BO_LAnd ||
- B->getOpcode() == BO_LOr);
+ assert(B->getOpcode() == BO_LAnd || B->getOpcode() == BO_LOr);
StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
ProgramStateRef state = Pred->getState();
@@ -673,8 +687,8 @@ void ExprEngine::VisitLogicalExpr(const BinaryOperator* B, ExplodedNode *Pred,
ExplodedNode *N = Pred;
while (!N->getLocation().getAs<BlockEntrance>()) {
ProgramPoint P = N->getLocation();
- assert(P.getAs<PreStmt>()|| P.getAs<PreStmtPurgeDeadSymbols>());
- (void) P;
+ assert(P.getAs<PreStmt>() || P.getAs<PreStmtPurgeDeadSymbols>());
+ (void)P;
if (N->pred_size() != 1) {
// We failed to track back where we came from.
Bldr.generateNode(B, Pred, state);
@@ -700,14 +714,13 @@ void ExprEngine::VisitLogicalExpr(const BinaryOperator* B, ExplodedNode *Pred,
// The only terminator (if there is one) that makes sense is a logical op.
CFGTerminator T = SrcBlock->getTerminator();
if (const BinaryOperator *Term = cast_or_null<BinaryOperator>(T.getStmt())) {
- (void) Term;
+ (void)Term;
assert(Term->isLogicalOp());
assert(SrcBlock->succ_size() == 2);
// Did we take the true or false branch?
unsigned constant = (*SrcBlock->succ_begin() == BE.getDst()) ? 1 : 0;
X = svalBuilder.makeIntVal(constant, B->getType());
- }
- else {
+ } else {
// If there is no terminator, by construction the last statement
// in SrcBlock is the value of the enclosing expression.
// However, we still need to constrain that value to be 0 or 1.
@@ -731,8 +744,7 @@ void ExprEngine::VisitLogicalExpr(const BinaryOperator* B, ExplodedNode *Pred,
Bldr.generateNode(B, Pred, state->BindExpr(B, Pred->getLocationContext(), X));
}
-void ExprEngine::VisitInitListExpr(const InitListExpr *IE,
- ExplodedNode *Pred,
+void ExprEngine::VisitInitListExpr(const InitListExpr *IE, ExplodedNode *Pred,
ExplodedNodeSet &Dst) {
StmtNodeBuilder B(Pred, Dst, *currBldrCtx);
@@ -759,9 +771,9 @@ void ExprEngine::VisitInitListExpr(const InitListExpr *IE,
vals = getBasicVals().prependSVal(V, vals);
}
- B.generateNode(IE, Pred,
- state->BindExpr(IE, LCtx,
- svalBuilder.makeCompoundVal(T, vals)));
+ B.generateNode(
+ IE, Pred,
+ state->BindExpr(IE, LCtx, svalBuilder.makeCompoundVal(T, vals)));
return;
}
@@ -779,11 +791,8 @@ void ExprEngine::VisitInitListExpr(const InitListExpr *IE,
B.generateNode(IE, Pred, state->BindExpr(IE, LCtx, V));
}
-void ExprEngine::VisitGuardedExpr(const Expr *Ex,
- const Expr *L,
- const Expr *R,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst) {
+void ExprEngine::VisitGuardedExpr(const Expr *Ex, const Expr *L, const Expr *R,
+ ExplodedNode *Pred, ExplodedNodeSet &Dst) {
assert(L && R);
StmtNodeBuilder B(Pred, Dst, *currBldrCtx);
@@ -793,7 +802,7 @@ void ExprEngine::VisitGuardedExpr(const Expr *Ex,
// Find the predecessor block.
ProgramStateRef SrcState = state;
- for (const ExplodedNode *N = Pred ; N ; N = *N->pred_begin()) {
+ for (const ExplodedNode *N = Pred; N; N = *N->pred_begin()) {
ProgramPoint PP = N->getLocation();
if (PP.getAs<PreStmtPurgeDeadSymbols>() || PP.getAs<BlockEntrance>()) {
// If the state N has multiple predecessors P, it means that successors
@@ -843,9 +852,8 @@ void ExprEngine::VisitGuardedExpr(const Expr *Ex,
B.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V, true));
}
-void ExprEngine::
-VisitOffsetOfExpr(const OffsetOfExpr *OOE,
- ExplodedNode *Pred, ExplodedNodeSet &Dst) {
+void ExprEngine::VisitOffsetOfExpr(const OffsetOfExpr *OOE, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst) {
StmtNodeBuilder B(Pred, Dst, *currBldrCtx);
Expr::EvalResult Result;
if (OOE->EvaluateAsInt(Result, getContext())) {
@@ -854,18 +862,16 @@ VisitOffsetOfExpr(const OffsetOfExpr *OOE,
assert(OOE->getType()->castAs<BuiltinType>()->isInteger());
assert(IV.isSigned() == OOE->getType()->isSignedIntegerType());
SVal X = svalBuilder.makeIntVal(IV);
- B.generateNode(OOE, Pred,
- Pred->getState()->BindExpr(OOE, Pred->getLocationContext(),
- X));
+ B.generateNode(
+ OOE, Pred,
+ Pred->getState()->BindExpr(OOE, Pred->getLocationContext(), X));
}
// FIXME: Handle the case where __builtin_offsetof is not a constant.
}
-
-void ExprEngine::
-VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Ex,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst) {
+void ExprEngine::VisitUnaryExprOrTypeTraitExpr(
+ const UnaryExprOrTypeTraitExpr *Ex, ExplodedNode *Pred,
+ ExplodedNodeSet &Dst) {
// FIXME: Prechecks eventually go in ::Visit().
ExplodedNodeSet CheckedSet;
getCheckerManager().runCheckersForPreStmt(CheckedSet, Pred, Ex, *this);
@@ -919,7 +925,7 @@ void ExprEngine::handleUOExtension(ExplodedNode *N, const UnaryOperator *U,
Bldr.generateNode(U, N, state->BindExpr(U, LCtx, state->getSVal(Ex, LCtx)));
}
-void ExprEngine::VisitUnaryOperator(const UnaryOperator* U, ExplodedNode *Pred,
+void ExprEngine::VisitUnaryOperator(const UnaryOperator *U, ExplodedNode *Pred,
ExplodedNodeSet &Dst) {
// FIXME: Prechecks eventually go in ::Visit().
ExplodedNodeSet CheckedSet;
@@ -947,7 +953,7 @@ void ExprEngine::VisitUnaryOperator(const UnaryOperator* U, ExplodedNode *Pred,
}
// For all other types, UO_Real is an identity operation.
- assert (U->getType() == Ex->getType());
+ assert(U->getType() == Ex->getType());
ProgramStateRef state = N->getState();
const LocationContext *LCtx = N->getLocationContext();
Bldr.generateNode(U, N,
@@ -1000,7 +1006,7 @@ void ExprEngine::VisitUnaryOperator(const UnaryOperator* U, ExplodedNode *Pred,
case UO_LNot:
case UO_Minus:
case UO_Not: {
- assert (!U->isGLValue());
+ assert(!U->isGLValue());
const Expr *Ex = U->getSubExpr()->IgnoreParens();
ProgramStateRef state = N->getState();
const LocationContext *LCtx = N->getLocationContext();
@@ -1014,37 +1020,37 @@ void ExprEngine::VisitUnaryOperator(const UnaryOperator* U, ExplodedNode *Pred,
}
switch (U->getOpcode()) {
- default:
- llvm_unreachable("Invalid Opcode.");
- case UO_Not:
- // FIXME: Do we need to handle promotions?
- state = state->BindExpr(
- U, LCtx, svalBuilder.evalComplement(V.castAs<NonLoc>()));
- break;
- case UO_Minus:
- // FIXME: Do we need to handle promotions?
- state = state->BindExpr(U, LCtx,
- svalBuilder.evalMinus(V.castAs<NonLoc>()));
- break;
- case UO_LNot:
- // C99 6.5.3.3: "The expression !E is equivalent to (0==E)."
- //
- // Note: technically we do "E == 0", but this is the same in the
- // transfer functions as "0 == E".
- SVal Result;
- if (std::optional<Loc> LV = V.getAs<Loc>()) {
+ default:
+ llvm_unreachable("Invalid Opcode.");
+ case UO_Not:
+ // FIXME: Do we need to handle promotions?
+ state = state->BindExpr(U, LCtx,
+ svalBuilder.evalComplement(V.castAs<NonLoc>()));
+ break;
+ case UO_Minus:
+ // FIXME: Do we need to handle promotions?
+ state =
+ state->BindExpr(U, LCtx, svalBuilder.evalMinus(V.castAs<NonLoc>()));
+ break;
+ case UO_LNot:
+ // C99 6.5.3.3: "The expression !E is equivalent to (0==E)."
+ //
+ // Note: technically we do "E == 0", but this is the same in the
+ // transfer functions as "0 == E".
+ SVal Result;
+ if (std::optional<Loc> LV = V.getAs<Loc>()) {
Loc X = svalBuilder.makeNullWithType(Ex->getType());
Result = evalBinOp(state, BO_EQ, *LV, X, U->getType());
- } else if (Ex->getType()->isFloatingType()) {
+ } else if (Ex->getType()->isFloatingType()) {
// FIXME: handle floating point types.
Result = UnknownVal();
- } else {
+ } else {
nonloc::ConcreteInt X(getBasicVals().getValue(0, Ex->getType()));
Result = evalBinOp(state, BO_EQ, V.castAs<NonLoc>(), X, U->getType());
- }
+ }
- state = state->BindExpr(U, LCtx, Result);
- break;
+ state = state->BindExpr(U, LCtx, Result);
+ break;
}
Bldr.generateNode(U, N, state);
break;
@@ -1055,11 +1061,11 @@ void ExprEngine::VisitUnaryOperator(const UnaryOperator* U, ExplodedNode *Pred,
getCheckerManager().runCheckersForPostStmt(Dst, EvalSet, U, *this);
}
-void ExprEngine::VisitIncrementDecrementOperator(const UnaryOperator* U,
+void ExprEngine::VisitIncrementDecrementOperator(const UnaryOperator *U,
ExplodedNode *Pred,
ExplodedNodeSet &Dst) {
// Handle ++ and -- (both pre- and post-increment).
- assert (U->isIncrementDecrementOp());
+ assert(U->isIncrementDecrementOp());
const Expr *Ex = U->getSubExpr()->IgnoreParens();
const LocationContext *LCtx = Pred->getLocationContext();
@@ -1117,24 +1123,23 @@ void ExprEngine::VisitIncrementDecrementOperator(const UnaryOperator* U,
Result = evalBinOp(state, Op, V2, RHS, U->getType());
// Conjure a new symbol if necessary to recover precision.
- if (Result.isUnknown()){
- DefinedOrUnknownSVal SymVal =
- svalBuilder.conjureSymbolVal(nullptr, U, LCtx,
- currBldrCtx->blockCount());
+ if (Result.isUnknown()) {
+ DefinedOrUnknownSVal SymVal = svalBuilder.conjureSymbolVal(
+ nullptr, U, LCtx, currBldrCtx->blockCount());
Result = SymVal;
// If the value is a location, ++/-- should always preserve
// non-nullness. Check if the original value was non-null, and if so
// propagate that constraint.
if (Loc::isLocType(U->getType())) {
- DefinedOrUnknownSVal Constraint =
- svalBuilder.evalEQ(state, V2,svalBuilder.makeZeroVal(U->getType()));
+ DefinedOrUnknownSVal Constraint = svalBuilder.evalEQ(
+ state, V2, svalBuilder.makeZeroVal(U->getType()));
if (!state->assume(Constraint, true)) {
// It isn't feasible for the original value to be null.
// Propagate this constraint.
- Constraint = svalBuilder.evalEQ(state, SymVal,
- svalBuilder.makeZeroVal(U->getType()));
+ Constraint = svalBuilder.evalEQ(
+ state, SymVal, svalBuilder.makeZeroVal(U->getType()));
state = state->assume(Constraint, false);
assert(state);
diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp
index 504fd7f05e0f99..33a994813a0f2b 100644
--- a/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp
+++ b/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp
@@ -149,10 +149,9 @@ SVal ExprEngine::computeObjectUnderConstruction(
if (Init->isBaseInitializer()) {
const auto *ThisReg = cast<SubRegion>(ThisVal.getAsRegion());
const CXXRecordDecl *BaseClass =
- Init->getBaseClass()->getAsCXXRecordDecl();
- const auto *BaseReg =
- MRMgr.getCXXBaseObjectRegion(BaseClass, ThisReg,
- Init->isBaseVirtual());
+ Init->getBaseClass()->getAsCXXRecordDecl();
+ const auto *BaseReg = MRMgr.getCXXBaseObjectRegion(
+ BaseClass, ThisReg, Init->isBaseVirtual());
return SVB.makeLoc(BaseReg);
}
if (Init->isDelegatingInitializer())
@@ -191,7 +190,7 @@ SVal ExprEngine::computeObjectUnderConstruction(
return loc::MemRegionVal(R);
}
- return V;
+ return V;
}
// TODO: Detect when the allocator returns a null pointer.
// Constructor shall not be called in this case.
@@ -413,99 +412,99 @@ ProgramStateRef ExprEngine::updateObjectsUnderConstruction(
case ConstructionContext::SimpleVariableKind: {
const auto *DSCC = cast<VariableConstructionContext>(CC);
return addObjectUnderConstruction(State, DSCC->getDeclStmt(), LCtx, V);
- }
- case ConstructionContext::CXX17ElidedCopyConstructorInitializerKind:
- case ConstructionContext::SimpleConstructorInitializerKind: {
- const auto *ICC = cast<ConstructorInitializerConstructionContext>(CC);
- const auto *Init = ICC->getCXXCtorInitializer();
- // Base and delegating initializers handled above
- assert(Init->isAnyMemberInitializer() &&
- "Base and delegating initializers should have been handled by"
- "computeObjectUnderConstruction()");
- return addObjectUnderConstruction(State, Init, LCtx, V);
- }
- case ConstructionContext::NewAllocatedObjectKind: {
+ }
+ case ConstructionContext::CXX17ElidedCopyConstructorInitializerKind:
+ case ConstructionContext::SimpleConstructorInitializerKind: {
+ const auto *ICC = cast<ConstructorInitializerConstructionContext>(CC);
+ const auto *Init = ICC->getCXXCtorInitializer();
+ // Base and delegating initializers handled above
+ assert(Init->isAnyMemberInitializer() &&
+ "Base and delegating initializers should have been handled by"
+ "computeObjectUnderConstruction()");
+ return addObjectUnderConstruction(State, Init, LCtx, V);
+ }
+ case ConstructionContext::NewAllocatedObjectKind: {
+ return State;
+ }
+ case ConstructionContext::SimpleReturnedValueKind:
+ case ConstructionContext::CXX17ElidedCopyReturnedValueKind: {
+ const StackFrameContext *SFC = LCtx->getStackFrame();
+ const LocationContext *CallerLCtx = SFC->getParent();
+ if (!CallerLCtx) {
+ // No extra work is necessary in top frame.
return State;
}
- case ConstructionContext::SimpleReturnedValueKind:
- case ConstructionContext::CXX17ElidedCopyReturnedValueKind: {
- const StackFrameContext *SFC = LCtx->getStackFrame();
- const LocationContext *CallerLCtx = SFC->getParent();
- if (!CallerLCtx) {
- // No extra work is necessary in top frame.
- return State;
- }
-
- auto RTC = (*SFC->getCallSiteBlock())[SFC->getIndex()]
- .getAs<CFGCXXRecordTypedCall>();
- assert(RTC && "Could not have had a target region without it");
- if (isa<BlockInvocationContext>(CallerLCtx)) {
- // Unwrap block invocation contexts. They're mostly part of
- // the current stack frame.
- CallerLCtx = CallerLCtx->getParent();
- assert(!isa<BlockInvocationContext>(CallerLCtx));
- }
- return updateObjectsUnderConstruction(V,
- cast<Expr>(SFC->getCallSite()), State, CallerLCtx,
- RTC->getConstructionContext(), CallOpts);
+ auto RTC = (*SFC->getCallSiteBlock())[SFC->getIndex()]
+ .getAs<CFGCXXRecordTypedCall>();
+ assert(RTC && "Could not have had a target region without it");
+ if (isa<BlockInvocationContext>(CallerLCtx)) {
+ // Unwrap block invocation contexts. They're mostly part of
+ // the current stack frame.
+ CallerLCtx = CallerLCtx->getParent();
+ assert(!isa<BlockInvocationContext>(CallerLCtx));
}
- case ConstructionContext::ElidedTemporaryObjectKind: {
- assert(AMgr.getAnalyzerOptions().ShouldElideConstructors);
- if (!CallOpts.IsElidableCtorThatHasNotBeenElided) {
- const auto *TCC = cast<ElidedTemporaryObjectConstructionContext>(CC);
- State = updateObjectsUnderConstruction(
- V, TCC->getConstructorAfterElision(), State, LCtx,
- TCC->getConstructionContextAfterElision(), CallOpts);
-
- // Remember that we've elided the constructor.
- State = addObjectUnderConstruction(
- State, TCC->getConstructorAfterElision(), LCtx, V);
-
- // Remember that we've elided the destructor.
- if (const auto *BTE = TCC->getCXXBindTemporaryExpr())
- State = elideDestructor(State, BTE, LCtx);
-
- // Instead of materialization, shamelessly return
- // the final object destination.
- if (const auto *MTE = TCC->getMaterializedTemporaryExpr())
- State = addObjectUnderConstruction(State, MTE, LCtx, V);
-
- return State;
- }
- // If we decided not to elide the constructor, proceed as if
- // it's a simple temporary.
- [[fallthrough]];
- }
- case ConstructionContext::SimpleTemporaryObjectKind: {
- const auto *TCC = cast<TemporaryObjectConstructionContext>(CC);
+
+ return updateObjectsUnderConstruction(
+ V, cast<Expr>(SFC->getCallSite()), State, CallerLCtx,
+ RTC->getConstructionContext(), CallOpts);
+ }
+ case ConstructionContext::ElidedTemporaryObjectKind: {
+ assert(AMgr.getAnalyzerOptions().ShouldElideConstructors);
+ if (!CallOpts.IsElidableCtorThatHasNotBeenElided) {
+ const auto *TCC = cast<ElidedTemporaryObjectConstructionContext>(CC);
+ State = updateObjectsUnderConstruction(
+ V, TCC->getConstructorAfterElision(), State, LCtx,
+ TCC->getConstructionContextAfterElision(), CallOpts);
+
+ // Remember that we've elided the constructor.
+ State = addObjectUnderConstruction(
+ State, TCC->getConstructorAfterElision(), LCtx, V);
+
+ // Remember that we've elided the destructor.
if (const auto *BTE = TCC->getCXXBindTemporaryExpr())
- State = addObjectUnderConstruction(State, BTE, LCtx, V);
+ State = elideDestructor(State, BTE, LCtx);
+ // Instead of materialization, shamelessly return
+ // the final object destination.
if (const auto *MTE = TCC->getMaterializedTemporaryExpr())
State = addObjectUnderConstruction(State, MTE, LCtx, V);
return State;
}
- case ConstructionContext::LambdaCaptureKind: {
- const auto *LCC = cast<LambdaCaptureConstructionContext>(CC);
+ // If we decided not to elide the constructor, proceed as if
+ // it's a simple temporary.
+ [[fallthrough]];
+ }
+ case ConstructionContext::SimpleTemporaryObjectKind: {
+ const auto *TCC = cast<TemporaryObjectConstructionContext>(CC);
+ if (const auto *BTE = TCC->getCXXBindTemporaryExpr())
+ State = addObjectUnderConstruction(State, BTE, LCtx, V);
- // If we capture and array, we want to store the super region, not a
- // sub-region.
- if (const auto *EL = dyn_cast_or_null<ElementRegion>(V.getAsRegion()))
- V = loc::MemRegionVal(EL->getSuperRegion());
+ if (const auto *MTE = TCC->getMaterializedTemporaryExpr())
+ State = addObjectUnderConstruction(State, MTE, LCtx, V);
- return addObjectUnderConstruction(
- State, {LCC->getLambdaExpr(), LCC->getIndex()}, LCtx, V);
- }
- case ConstructionContext::ArgumentKind: {
- const auto *ACC = cast<ArgumentConstructionContext>(CC);
- if (const auto *BTE = ACC->getCXXBindTemporaryExpr())
- State = addObjectUnderConstruction(State, BTE, LCtx, V);
+ return State;
+ }
+ case ConstructionContext::LambdaCaptureKind: {
+ const auto *LCC = cast<LambdaCaptureConstructionContext>(CC);
- return addObjectUnderConstruction(
- State, {ACC->getCallLikeExpr(), ACC->getIndex()}, LCtx, V);
- }
+ // If we capture and array, we want to store the super region, not a
+ // sub-region.
+ if (const auto *EL = dyn_cast_or_null<ElementRegion>(V.getAsRegion()))
+ V = loc::MemRegionVal(EL->getSuperRegion());
+
+ return addObjectUnderConstruction(
+ State, {LCC->getLambdaExpr(), LCC->getIndex()}, LCtx, V);
+ }
+ case ConstructionContext::ArgumentKind: {
+ const auto *ACC = cast<ArgumentConstructionContext>(CC);
+ if (const auto *BTE = ACC->getCXXBindTemporaryExpr())
+ State = addObjectUnderConstruction(State, BTE, LCtx, V);
+
+ return addObjectUnderConstruction(
+ State, {ACC->getCallLikeExpr(), ACC->getIndex()}, LCtx, V);
+ }
}
llvm_unreachable("Unhandled construction context!");
}
@@ -579,8 +578,7 @@ bindRequiredArrayElementToEnvironment(ProgramStateRef State,
return State->BindExpr(CE->getArg(0), LCtx, NthElem);
}
-void ExprEngine::handleConstructor(const Expr *E,
- ExplodedNode *Pred,
+void ExprEngine::handleConstructor(const Expr *E, ExplodedNode *Pred,
ExplodedNodeSet &destNodes) {
const auto *CE = dyn_cast<CXXConstructExpr>(E);
const auto *CIE = dyn_cast<CXXInheritedCtorInitExpr>(E);
@@ -594,16 +592,16 @@ void ExprEngine::handleConstructor(const Expr *E,
if (CE) {
if (std::optional<SVal> ElidedTarget =
getObjectUnderConstruction(State, CE, LCtx)) {
- // We've previously modeled an elidable constructor by pretending that
- // it in fact constructs into the correct target. This constructor can
- // therefore be skipped.
- Target = *ElidedTarget;
- StmtNodeBuilder Bldr(Pred, destNodes, *currBldrCtx);
- State = finishObjectConstruction(State, CE, LCtx);
- if (auto L = Target.getAs<Loc>())
- State = State->BindExpr(CE, LCtx, State->getSVal(*L, CE->getType()));
- Bldr.generateNode(CE, Pred, State);
- return;
+ // We've previously modeled an elidable constructor by pretending that
+ // it in fact constructs into the correct target. This constructor can
+ // therefore be skipped.
+ Target = *ElidedTarget;
+ StmtNodeBuilder Bldr(Pred, destNodes, *currBldrCtx);
+ State = finishObjectConstruction(State, CE, LCtx);
+ if (auto L = Target.getAs<Loc>())
+ State = State->BindExpr(CE, LCtx, State->getSVal(*L, CE->getType()));
+ Bldr.generateNode(CE, Pred, State);
+ return;
}
}
@@ -701,8 +699,7 @@ void ExprEngine::handleConstructor(const Expr *E,
[[fallthrough]];
case CXXConstructionKind::Delegating: {
const CXXMethodDecl *CurCtor = cast<CXXMethodDecl>(LCtx->getDecl());
- Loc ThisPtr = getSValBuilder().getCXXThis(CurCtor,
- LCtx->getStackFrame());
+ Loc ThisPtr = getSValBuilder().getCXXThis(CurCtor, LCtx->getStackFrame());
SVal ThisVal = State->getSVal(ThisPtr);
if (CK == CXXConstructionKind::Delegating) {
@@ -771,8 +768,8 @@ void ExprEngine::handleConstructor(const Expr *E,
}
ExplodedNodeSet DstPreCall;
- getCheckerManager().runCheckersForPreCall(DstPreCall, PreInitialized,
- *Call, *this);
+ getCheckerManager().runCheckersForPreCall(DstPreCall, PreInitialized, *Call,
+ *this);
ExplodedNodeSet DstEvaluated;
@@ -835,9 +832,8 @@ void ExprEngine::handleConstructor(const Expr *E,
// If there were other constructors called for object-type arguments
// of this constructor, clean them up.
ExplodedNodeSet DstPostCall;
- getCheckerManager().runCheckersForPostCall(DstPostCall,
- DstPostArgumentCleanup,
- *Call, *this);
+ getCheckerManager().runCheckersForPostCall(
+ DstPostCall, DstPostArgumentCleanup, *Call, *this);
getCheckerManager().runCheckersForPostStmt(destNodes, DstPostCall, E, *this);
}
@@ -853,12 +849,9 @@ void ExprEngine::VisitCXXInheritedCtorInitExpr(
handleConstructor(CE, Pred, Dst);
}
-void ExprEngine::VisitCXXDestructor(QualType ObjectType,
- const MemRegion *Dest,
- const Stmt *S,
- bool IsBaseDtor,
- ExplodedNode *Pred,
- ExplodedNodeSet &Dst,
+void ExprEngine::VisitCXXDestructor(QualType ObjectType, const MemRegion *Dest,
+ const Stmt *S, bool IsBaseDtor,
+ ExplodedNode *Pred, ExplodedNodeSet &Dst,
EvalCallOptions &CallOpts) {
assert(S && "A destructor without a trigger!");
const LocationContext *LCtx = Pred->getLocationContext();
@@ -893,8 +886,8 @@ void ExprEngine::VisitCXXDestructor(QualType ObjectType,
} else {
static SimpleProgramPointTag T("ExprEngine", "SkipInvalidDestructor");
NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
- Bldr.generateSink(Pred->getLocation().withTag(&T),
- Pred->getState(), Pred);
+ Bldr.generateSink(Pred->getLocation().withTag(&T), Pred->getState(),
+ Pred);
return;
}
}
@@ -908,16 +901,14 @@ void ExprEngine::VisitCXXDestructor(QualType ObjectType,
"Error evaluating destructor");
ExplodedNodeSet DstPreCall;
- getCheckerManager().runCheckersForPreCall(DstPreCall, Pred,
- *Call, *this);
+ getCheckerManager().runCheckersForPreCall(DstPreCall, Pred, *Call, *this);
ExplodedNodeSet DstInvalidated;
StmtNodeBuilder Bldr(DstPreCall, DstInvalidated, *currBldrCtx);
for (ExplodedNode *N : DstPreCall)
defaultEvalCall(Bldr, N, *Call, CallOpts);
- getCheckerManager().runCheckersForPostCall(Dst, DstInvalidated,
- *Call, *this);
+ getCheckerManager().runCheckersForPostCall(Dst, DstInvalidated, *Call, *this);
}
void ExprEngine::VisitCXXNewAllocatorCall(const CXXNewExpr *CNE,
@@ -933,8 +924,7 @@ void ExprEngine::VisitCXXNewAllocatorCall(const CXXNewExpr *CNE,
CEMgr.getCXXAllocatorCall(CNE, State, LCtx, getCFGElementRef());
ExplodedNodeSet DstPreCall;
- getCheckerManager().runCheckersForPreCall(DstPreCall, Pred,
- *Call, *this);
+ getCheckerManager().runCheckersForPreCall(DstPreCall, Pred, *Call, *this);
ExplodedNodeSet DstPostCall;
StmtNodeBuilder CallBldr(DstPreCall, DstPostCall, *currBldrCtx);
@@ -993,7 +983,7 @@ void ExprEngine::VisitCXXNewAllocatorCall(const CXXNewExpr *CNE,
}
void ExprEngine::VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred,
- ExplodedNodeSet &Dst) {
+ ExplodedNodeSet &Dst) {
// FIXME: Much of this should eventually migrate to CXXAllocatorCall.
// Also, we need to decide how allocators actually work -- they're not
// really part of the CXXNewExpr because they happen BEFORE the
@@ -1165,15 +1155,13 @@ void ExprEngine::VisitCXXCatchStmt(const CXXCatchStmt *CS, ExplodedNode *Pred,
}
void ExprEngine::VisitCXXThisExpr(const CXXThisExpr *TE, ExplodedNode *Pred,
- ExplodedNodeSet &Dst) {
+ ExplodedNodeSet &Dst) {
StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
// Get the this object region from StoreManager.
const LocationContext *LCtx = Pred->getLocationContext();
- const MemRegion *R =
- svalBuilder.getRegionManager().getCXXThisRegion(
- getContext().getCanonicalType(TE->getType()),
- LCtx);
+ const MemRegion *R = svalBuilder.getRegionManager().getCXXThisRegion(
+ getContext().getCanonicalType(TE->getType()), LCtx);
ProgramStateRef state = Pred->getState();
SVal V = state->getSVal(loc::MemRegionVal(R));
@@ -1185,8 +1173,8 @@ void ExprEngine::VisitLambdaExpr(const LambdaExpr *LE, ExplodedNode *Pred,
const LocationContext *LocCtxt = Pred->getLocationContext();
// Get the region of the lambda itself.
- const MemRegion *R = svalBuilder.getRegionManager().getCXXTempObjectRegion(
- LE, LocCtxt);
+ const MemRegion *R =
+ svalBuilder.getRegionManager().getCXXTempObjectRegion(LE, LocCtxt);
SVal V = loc::MemRegionVal(R);
ProgramStateRef State = Pred->getState();
@@ -1246,9 +1234,8 @@ void ExprEngine::VisitLambdaExpr(const LambdaExpr *LE, ExplodedNode *Pred,
ExplodedNodeSet Tmp;
StmtNodeBuilder Bldr(Pred, Tmp, *currBldrCtx);
// FIXME: is this the right program point kind?
- Bldr.generateNode(LE, Pred,
- State->BindExpr(LE, LocCtxt, LambdaRVal),
- nullptr, ProgramPoint::PostLValueKind);
+ Bldr.generateNode(LE, Pred, State->BindExpr(LE, LocCtxt, LambdaRVal), nullptr,
+ ProgramPoint::PostLValueKind);
// FIXME: Move all post/pre visits to ::Visit().
getCheckerManager().runCheckersForPostStmt(Dst, Tmp, LE, *this);
diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp
index 4755b6bfa6dc0a..4c06d205981c54 100644
--- a/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp
+++ b/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp
@@ -32,16 +32,16 @@ using namespace ento;
#define DEBUG_TYPE "ExprEngine"
-STATISTIC(NumOfDynamicDispatchPathSplits,
- "The # of times we split the path due to imprecise dynamic dispatch info");
+STATISTIC(
+ NumOfDynamicDispatchPathSplits,
+ "The # of times we split the path due to imprecise dynamic dispatch info");
-STATISTIC(NumInlinedCalls,
- "The # of times we inlined a call");
+STATISTIC(NumInlinedCalls, "The # of times we inlined a call");
STATISTIC(NumReachedInlineCountMax,
- "The # of times we reached inline count maximum");
+ "The # of times we reached inline count maximum");
-void ExprEngine::processCallEnter(NodeBuilderContext& BC, CallEnter CE,
+void ExprEngine::processCallEnter(NodeBuilderContext &BC, CallEnter CE,
ExplodedNode *Pred) {
// Get the entry block in the CFG of the callee.
const StackFrameContext *calleeCtx = CE.getCalleeContext();
@@ -74,8 +74,8 @@ void ExprEngine::processCallEnter(NodeBuilderContext& BC, CallEnter CE,
// Find the last statement on the path to the exploded node and the
// corresponding Block.
-static std::pair<const Stmt*,
- const CFGBlock*> getLastStmt(const ExplodedNode *Node) {
+static std::pair<const Stmt *, const CFGBlock *>
+getLastStmt(const ExplodedNode *Node) {
const Stmt *S = nullptr;
const CFGBlock *Blk = nullptr;
const StackFrameContext *SF = Node->getStackFrame();
@@ -162,7 +162,7 @@ static SVal adjustReturnValue(SVal V, QualType ExpectedTy, QualType ActualTy,
return UnknownVal();
}
-void ExprEngine::removeDeadOnEndOfFunction(NodeBuilderContext& BC,
+void ExprEngine::removeDeadOnEndOfFunction(NodeBuilderContext &BC,
ExplodedNode *Pred,
ExplodedNodeSet &Dst) {
// Find the last statement in the function and the corresponding basic block.
@@ -186,8 +186,9 @@ void ExprEngine::removeDeadOnEndOfFunction(NodeBuilderContext& BC,
ProgramPoint::PostStmtPurgeDeadSymbolsKind);
}
-static bool wasDifferentDeclUsedForInlining(CallEventRef<> Call,
- const StackFrameContext *calleeCtx) {
+static bool
+wasDifferentDeclUsedForInlining(CallEventRef<> Call,
+ const StackFrameContext *calleeCtx) {
const Decl *RuntimeCallee = calleeCtx->getDecl();
const Decl *StaticDecl = Call->getDecl();
assert(RuntimeCallee);
@@ -258,8 +259,7 @@ void ExprEngine::processCallExit(ExplodedNode *CEBNode) {
// The parent context might not be a stack frame, so make sure we
// look up the first enclosing stack frame.
- const StackFrameContext *callerCtx =
- calleeCtx->getParent()->getStackFrame();
+ const StackFrameContext *callerCtx = calleeCtx->getParent()->getStackFrame();
const Stmt *CE = calleeCtx->getCallSite();
ProgramStateRef state = CEBNode->getState();
@@ -301,7 +301,7 @@ void ExprEngine::processCallExit(ExplodedNode *CEBNode) {
// Ensure that the return type matches the type of the returned Expr.
if (wasDifferentDeclUsedForInlining(Call, calleeCtx)) {
QualType ReturnedTy =
- CallEvent::getDeclaredResultType(calleeCtx->getDecl());
+ CallEvent::getDeclaredResultType(calleeCtx->getDecl());
if (!ReturnedTy.isNull()) {
if (const Expr *Ex = dyn_cast<Expr>(CE)) {
V = adjustReturnValue(V, Ex->getType(), ReturnedTy,
@@ -316,7 +316,7 @@ void ExprEngine::processCallExit(ExplodedNode *CEBNode) {
// Bind the constructed object value to CXXConstructExpr.
if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(CE)) {
loc::MemRegionVal This =
- svalBuilder.getCXXThis(CCE->getConstructor()->getParent(), calleeCtx);
+ svalBuilder.getCXXThis(CCE->getConstructor()->getParent(), calleeCtx);
SVal ThisV = state->getSVal(This);
ThisV = state->getSVal(ThisV.castAs<Loc>());
state = state->BindExpr(CCE, callerCtx, ThisV);
@@ -419,8 +419,8 @@ void ExprEngine::processCallExit(ExplodedNode *CEBNode) {
} else if (CE &&
!(isa<CXXNewExpr>(CE) && // Called when visiting CXXNewExpr.
AMgr.getAnalyzerOptions().MayInlineCXXAllocator)) {
- getCheckerManager().runCheckersForPostStmt(Dst, DstPostCall, CE,
- *this, /*wasInlined=*/true);
+ getCheckerManager().runCheckersForPostStmt(Dst, DstPostCall, CE, *this,
+ /*wasInlined=*/true);
} else {
Dst.insert(DstPostCall);
}
@@ -456,7 +456,7 @@ bool ExprEngine::isHuge(AnalysisDeclContext *ADC) const {
}
void ExprEngine::examineStackFrames(const Decl *D, const LocationContext *LCtx,
- bool &IsRecursive, unsigned &StackDepth) {
+ bool &IsRecursive, unsigned &StackDepth) {
IsRecursive = false;
StackDepth = 0;
@@ -489,14 +489,14 @@ void ExprEngine::examineStackFrames(const Decl *D, const LocationContext *LCtx,
// This is the map from the receiver region to a bool, specifying either we
// consider this region's information precise or not along the given path.
namespace {
- enum DynamicDispatchMode {
- DynamicDispatchModeInlined = 1,
- DynamicDispatchModeConservative
- };
+enum DynamicDispatchMode {
+ DynamicDispatchModeInlined = 1,
+ DynamicDispatchModeConservative
+};
} // end anonymous namespace
-REGISTER_MAP_WITH_PROGRAMSTATE(DynamicDispatchBifurcationMap,
- const MemRegion *, unsigned)
+REGISTER_MAP_WITH_PROGRAMSTATE(DynamicDispatchBifurcationMap, const MemRegion *,
+ unsigned)
REGISTER_TRAIT_WITH_PROGRAMSTATE(CTUDispatchBifurcation, bool)
void ExprEngine::ctuBifurcate(const CallEvent &Call, const Decl *D,
@@ -540,9 +540,8 @@ void ExprEngine::inlineCall(WorkList *WList, const CallEvent &Call,
const BlockDataRegion *BR = cast<BlockCall>(Call).getBlockRegion();
assert(BR && "If we have the block definition we should have its region");
AnalysisDeclContext *BlockCtx = AMgr.getAnalysisDeclContext(D);
- ParentOfCallee = BlockCtx->getBlockInvocationContext(CallerSFC,
- cast<BlockDecl>(D),
- BR);
+ ParentOfCallee =
+ BlockCtx->getBlockInvocationContext(CallerSFC, cast<BlockDecl>(D), BR);
}
// This may be NULL, but that's fine.
@@ -622,8 +621,7 @@ void ExprEngine::VisitCallExpr(const CallExpr *CE, ExplodedNode *Pred,
// the created nodes in 'Dst'.
// Note that if the call was inlined, dstCallEvaluated will be empty.
// The post-CallExpr check will occur in processCallExit.
- getCheckerManager().runCheckersForPostStmt(dst, dstCallEvaluated, CE,
- *this);
+ getCheckerManager().runCheckersForPostStmt(dst, dstCallEvaluated, CE, *this);
}
ProgramStateRef ExprEngine::finishArgumentConstruction(ProgramStateRef State,
@@ -641,7 +639,8 @@ ProgramStateRef ExprEngine::finishArgumentConstruction(ProgramStateRef State,
SVal VV = *V;
(void)VV;
assert(cast<VarRegion>(VV.castAs<loc::MemRegionVal>().getRegion())
- ->getStackFrame()->getParent()
+ ->getStackFrame()
+ ->getParent()
->getStackFrame() == LC->getStackFrame());
State = finishObjectConstruction(State, {E, I}, LC);
}
@@ -680,8 +679,7 @@ void ExprEngine::evalCall(ExplodedNodeSet &Dst, ExplodedNode *Pred,
// Run any pre-call checks using the generic call interface.
ExplodedNodeSet dstPreVisit;
- getCheckerManager().runCheckersForPreCall(dstPreVisit, Pred,
- Call, *this);
+ getCheckerManager().runCheckersForPreCall(dstPreVisit, Pred, Call, *this);
// Actually evaluate the function call. We try each of the checkers
// to see if the can evaluate the function call, and get a callback at
@@ -723,7 +721,8 @@ void ExprEngine::evalCall(ExplodedNodeSet &Dst, ExplodedNode *Pred,
if (Pointee.isConstQualified() || Pointee->isVoidType())
continue;
if (const MemRegion *MR = Call.getArgSVal(Arg).getAsRegion())
- Escaped.emplace_back(loc::MemRegionVal(MR), State->getSVal(MR, Pointee));
+ Escaped.emplace_back(loc::MemRegionVal(MR),
+ State->getSVal(MR, Pointee));
}
}
@@ -756,7 +755,8 @@ ProgramStateRef ExprEngine::bindReturnValue(const CallEvent &Call,
return State->BindExpr(E, LCtx, Msg->getReceiverSVal());
}
}
- } else if (const CXXConstructorCall *C = dyn_cast<CXXConstructorCall>(&Call)){
+ } else if (const CXXConstructorCall *C =
+ dyn_cast<CXXConstructorCall>(&Call)) {
SVal ThisV = C->getCXXThisVal();
ThisV = State->getSVal(ThisV.castAs<Loc>());
return State->BindExpr(E, LCtx, ThisV);
@@ -781,7 +781,8 @@ ProgramStateRef ExprEngine::bindReturnValue(const CallEvent &Call,
// the structure is a product of conservative evaluation
// and therefore contains nothing interesting at this point.
RegionAndSymbolInvalidationTraits ITraits;
- ITraits.setTrait(TargetR,
+ ITraits.setTrait(
+ TargetR,
RegionAndSymbolInvalidationTraits::TK_DoNotInvalidateSuperRegion);
State = State->invalidateRegions(TargetR, E, Count, LCtx,
/* CausesPointerEscape=*/false, nullptr,
@@ -829,7 +830,8 @@ ProgramStateRef ExprEngine::bindReturnValue(const CallEvent &Call,
// Conservatively evaluate call by invalidating regions and binding
// a conjured return value.
void ExprEngine::conservativeEvalCall(const CallEvent &Call, NodeBuilder &Bldr,
- ExplodedNode *Pred, ProgramStateRef State) {
+ ExplodedNode *Pred,
+ ProgramStateRef State) {
State = Call.invalidateRegions(currBldrCtx->blockCount(), State);
State = bindReturnValue(Call, Pred->getLocationContext(), State);
@@ -862,8 +864,8 @@ ExprEngine::mayInlineCallKind(const CallEvent &Call, const ExplodedNode *Pred,
const CXXConstructExpr *CtorExpr = Ctor.getOriginExpr();
auto CCE = getCurrentCFGElement().getAs<CFGConstructor>();
- const ConstructionContext *CC = CCE ? CCE->getConstructionContext()
- : nullptr;
+ const ConstructionContext *CC =
+ CCE ? CCE->getConstructionContext() : nullptr;
if (llvm::isa_and_nonnull<NewAllocatedObjectConstructionContext>(CC) &&
!Opts.MayInlineCXXAllocator)
@@ -931,8 +933,7 @@ ExprEngine::mayInlineCallKind(const CallEvent &Call, const ExplodedNode *Pred,
}
// Allow disabling temporary destructor inlining with a separate option.
- if (CallOpts.IsTemporaryCtorOrDtor &&
- !Opts.MayInlineCXXTemporaryDtors)
+ if (CallOpts.IsTemporaryCtorOrDtor && !Opts.MayInlineCXXTemporaryDtors)
return CIP_DisallowedOnce;
// If we did not find the correct this-region, it would be pointless
@@ -974,8 +975,7 @@ static bool hasMember(const ASTContext &Ctx, const CXXRecordDecl *RD,
/// Our heuristic for this is whether it contains a method named 'begin()' or a
/// nested type named 'iterator' or 'iterator_category'.
static bool isContainerClass(const ASTContext &Ctx, const CXXRecordDecl *RD) {
- return hasMember(Ctx, RD, "begin") ||
- hasMember(Ctx, RD, "iterator") ||
+ return hasMember(Ctx, RD, "begin") || hasMember(Ctx, RD, "iterator") ||
hasMember(Ctx, RD, "iterator_category");
}
@@ -984,8 +984,7 @@ static bool isContainerClass(const ASTContext &Ctx, const CXXRecordDecl *RD) {
///
/// We generally do a poor job modeling most containers right now, and might
/// prefer not to inline their methods.
-static bool isContainerMethod(const ASTContext &Ctx,
- const FunctionDecl *FD) {
+static bool isContainerMethod(const ASTContext &Ctx, const FunctionDecl *FD) {
if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
return isContainerClass(Ctx, MD->getParent());
return false;
@@ -1001,7 +1000,7 @@ static bool isCXXSharedPtrDtor(const FunctionDecl *FD) {
const CXXRecordDecl *RD = Dtor->getParent();
if (const IdentifierInfo *II = RD->getDeclName().getAsIdentifierInfo())
if (II->isStr("shared_ptr"))
- return true;
+ return true;
return false;
}
@@ -1266,17 +1265,16 @@ void ExprEngine::defaultEvalCall(NodeBuilder &Bldr, ExplodedNode *Pred,
conservativeEvalCall(*Call, Bldr, Pred, State);
}
-void ExprEngine::BifurcateCall(const MemRegion *BifurReg,
- const CallEvent &Call, const Decl *D,
- NodeBuilder &Bldr, ExplodedNode *Pred) {
+void ExprEngine::BifurcateCall(const MemRegion *BifurReg, const CallEvent &Call,
+ const Decl *D, NodeBuilder &Bldr,
+ ExplodedNode *Pred) {
assert(BifurReg);
BifurReg = BifurReg->StripCasts();
// Check if we've performed the split already - note, we only want
// to split the path once per memory region.
ProgramStateRef State = Pred->getState();
- const unsigned *BState =
- State->get<DynamicDispatchBifurcationMap>(BifurReg);
+ const unsigned *BState = State->get<DynamicDispatchBifurcationMap>(BifurReg);
if (BState) {
// If we are on "inline path", keep inlining if possible.
if (*BState == DynamicDispatchModeInlined)
@@ -1290,14 +1288,12 @@ void ExprEngine::BifurcateCall(const MemRegion *BifurReg,
// If we got here, this is the first time we process a message to this
// region, so split the path.
- ProgramStateRef IState =
- State->set<DynamicDispatchBifurcationMap>(BifurReg,
- DynamicDispatchModeInlined);
+ ProgramStateRef IState = State->set<DynamicDispatchBifurcationMap>(
+ BifurReg, DynamicDispatchModeInlined);
ctuBifurcate(Call, D, Bldr, Pred, IState);
- ProgramStateRef NoIState =
- State->set<DynamicDispatchBifurcationMap>(BifurReg,
- DynamicDispatchModeConservative);
+ ProgramStateRef NoIState = State->set<DynamicDispatchBifurcationMap>(
+ BifurReg, DynamicDispatchModeConservative);
conservativeEvalCall(Call, Bldr, Pred, NoIState);
NumOfDynamicDispatchPathSplits++;
@@ -1312,7 +1308,8 @@ void ExprEngine::VisitReturnStmt(const ReturnStmt *RS, ExplodedNode *Pred,
if (RS->getRetValue()) {
for (ExplodedNodeSet::iterator it = dstPreVisit.begin(),
- ei = dstPreVisit.end(); it != ei; ++it) {
+ ei = dstPreVisit.end();
+ it != ei; ++it) {
B.generateNode(RS, *it, (*it)->getState());
}
}
diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp
index f075df3ab5e4d6..b8280131bc4709 100644
--- a/clang/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp
+++ b/clang/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp
@@ -66,8 +66,8 @@ static void populateObjCForDestinationSet(
SVal V;
if (hasElements) {
- SymbolRef Sym = SymMgr.conjureSymbol(elem, LCtx, T,
- currBldrCtx->blockCount());
+ SymbolRef Sym =
+ SymMgr.conjureSymbol(elem, LCtx, T, currBldrCtx->blockCount());
V = svalBuilder.makeLoc(Sym);
} else {
V = svalBuilder.makeIntVal(0, T);
@@ -144,8 +144,7 @@ void ExprEngine::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S,
getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
}
-void ExprEngine::VisitObjCMessage(const ObjCMessageExpr *ME,
- ExplodedNode *Pred,
+void ExprEngine::VisitObjCMessage(const ObjCMessageExpr *ME, ExplodedNode *Pred,
ExplodedNodeSet &Dst) {
CallEventManager &CEMgr = getStateManager().getCallEventManager();
CallEventRef<ObjCMethodCall> Msg = CEMgr.getObjCMethodCall(
@@ -197,8 +196,7 @@ void ExprEngine::VisitObjCMessage(const ObjCMessageExpr *ME,
SVal recVal = Msg->getReceiverSVal();
if (!recVal.isUndef()) {
// Bifurcate the state into nil and non-nil ones.
- DefinedOrUnknownSVal receiverVal =
- recVal.castAs<DefinedOrUnknownSVal>();
+ DefinedOrUnknownSVal receiverVal = recVal.castAs<DefinedOrUnknownSVal>();
ProgramStateRef State = Pred->getState();
ProgramStateRef notNilState, nilState;
@@ -241,8 +239,8 @@ void ExprEngine::VisitObjCMessage(const ObjCMessageExpr *ME,
// Handle the previsits checks.
ExplodedNodeSet dstPrevisit;
- getCheckerManager().runCheckersForPreObjCMessage(dstPrevisit, Pred,
- *Msg, *this);
+ getCheckerManager().runCheckersForPreObjCMessage(dstPrevisit, Pred, *Msg,
+ *this);
ExplodedNodeSet dstGenericPrevisit;
getCheckerManager().runCheckersForPreCall(dstGenericPrevisit, dstPrevisit,
*Msg, *this);
@@ -252,7 +250,8 @@ void ExprEngine::VisitObjCMessage(const ObjCMessageExpr *ME,
StmtNodeBuilder Bldr(dstGenericPrevisit, dstEval, *currBldrCtx);
for (ExplodedNodeSet::iterator DI = dstGenericPrevisit.begin(),
- DE = dstGenericPrevisit.end(); DI != DE; ++DI) {
+ DE = dstGenericPrevisit.end();
+ DI != DE; ++DI) {
ExplodedNode *Pred = *DI;
ProgramStateRef State = Pred->getState();
CallEventRef<ObjCMethodCall> UpdatedMsg = Msg.cloneWithState(State);
@@ -287,11 +286,11 @@ void ExprEngine::VisitObjCMessage(const ObjCMessageExpr *ME,
finishArgumentConstruction(dstArgCleanup, I, *Msg);
ExplodedNodeSet dstPostvisit;
- getCheckerManager().runCheckersForPostCall(dstPostvisit, dstArgCleanup,
- *Msg, *this);
+ getCheckerManager().runCheckersForPostCall(dstPostvisit, dstArgCleanup, *Msg,
+ *this);
// Finally, perform the post-condition check of the ObjCMessageExpr and store
// the created nodes in 'Dst'.
- getCheckerManager().runCheckersForPostObjCMessage(Dst, dstPostvisit,
- *Msg, *this);
+ getCheckerManager().runCheckersForPostObjCMessage(Dst, dstPostvisit, *Msg,
+ *this);
}
diff --git a/clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp b/clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp
index fb5030d373c2f1..8f55bb3e0e9ec9 100644
--- a/clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp
+++ b/clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp
@@ -242,8 +242,7 @@ void ento::createSarifHTMLDiagnosticConsumer(
//===----------------------------------------------------------------------===//
void HTMLDiagnostics::FlushDiagnosticsImpl(
- std::vector<const PathDiagnostic *> &Diags,
- FilesMade *filesMade) {
+ std::vector<const PathDiagnostic *> &Diags, FilesMade *filesMade) {
for (const auto Diag : Diags)
ReportDiag(*Diag, filesMade);
}
@@ -260,14 +259,14 @@ static llvm::SmallString<32> getIssueHash(const PathDiagnostic &D,
D.getDeclWithIssue(), PP.getLangOpts());
}
-void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D,
+void HTMLDiagnostics::ReportDiag(const PathDiagnostic &D,
FilesMade *filesMade) {
// Create the HTML directory if it is missing.
if (!createdDir) {
createdDir = true;
if (std::error_code ec = llvm::sys::fs::create_directories(Directory)) {
- llvm::errs() << "warning: could not create directory '"
- << Directory << "': " << ec.message() << '\n';
+ llvm::errs() << "warning: could not create directory '" << Directory
+ << "': " << ec.message() << '\n';
noDir = true;
return;
}
@@ -284,24 +283,23 @@ void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D,
const SourceManager &SMgr = path.front()->getLocation().getManager();
// Create a new rewriter to generate HTML.
- Rewriter R(const_cast<SourceManager&>(SMgr), PP.getLangOpts());
+ Rewriter R(const_cast<SourceManager &>(SMgr), PP.getLangOpts());
// Get the function/method name
SmallString<128> declName("unknown");
int offsetDecl = 0;
if (const Decl *DeclWithIssue = D.getDeclWithIssue()) {
- if (const auto *ND = dyn_cast<NamedDecl>(DeclWithIssue))
- declName = ND->getDeclName().getAsString();
-
- if (const Stmt *Body = DeclWithIssue->getBody()) {
- // Retrieve the relative position of the declaration which will be used
- // for the file name
- FullSourceLoc L(
- SMgr.getExpansionLoc(path.back()->getLocation().asLocation()),
- SMgr);
- FullSourceLoc FunL(SMgr.getExpansionLoc(Body->getBeginLoc()), SMgr);
- offsetDecl = L.getExpansionLineNumber() - FunL.getExpansionLineNumber();
- }
+ if (const auto *ND = dyn_cast<NamedDecl>(DeclWithIssue))
+ declName = ND->getDeclName().getAsString();
+
+ if (const Stmt *Body = DeclWithIssue->getBody()) {
+ // Retrieve the relative position of the declaration which will be used
+ // for the file name
+ FullSourceLoc L(
+ SMgr.getExpansionLoc(path.back()->getLocation().asLocation()), SMgr);
+ FullSourceLoc FunL(SMgr.getExpansionLoc(Body->getBeginLoc()), SMgr);
+ offsetDecl = L.getExpansionLineNumber() - FunL.getExpansionLineNumber();
+ }
}
SmallString<32> IssueHash = getIssueHash(D, PP);
@@ -377,8 +375,10 @@ void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D,
os << report;
}
-std::string HTMLDiagnostics::GenerateHTML(const PathDiagnostic& D, Rewriter &R,
- const SourceManager& SMgr, const PathPieces& path, const char *declName) {
+std::string HTMLDiagnostics::GenerateHTML(const PathDiagnostic &D, Rewriter &R,
+ const SourceManager &SMgr,
+ const PathPieces &path,
+ const char *declName) {
// Rewrite source files as HTML for every new file the path crosses
std::vector<FileID> FileIDs;
for (auto I : path) {
@@ -450,16 +450,14 @@ std::string HTMLDiagnostics::GenerateHTML(const PathDiagnostic& D, Rewriter &R,
return file;
}
-void HTMLDiagnostics::dumpCoverageData(
- const PathDiagnostic &D,
- const PathPieces &path,
- llvm::raw_string_ostream &os) {
+void HTMLDiagnostics::dumpCoverageData(const PathDiagnostic &D,
+ const PathPieces &path,
+ llvm::raw_string_ostream &os) {
const FilesToLineNumsMap &ExecutedLines = D.getExecutedLines();
os << "var relevant_lines = {";
- for (auto I = ExecutedLines.begin(),
- E = ExecutedLines.end(); I != E; ++I) {
+ for (auto I = ExecutedLines.begin(), E = ExecutedLines.end(); I != E; ++I) {
if (I != ExecutedLines.begin())
os << ", ";
@@ -476,8 +474,9 @@ void HTMLDiagnostics::dumpCoverageData(
os << "};";
}
-std::string HTMLDiagnostics::showRelevantLinesJavascript(
- const PathDiagnostic &D, const PathPieces &path) {
+std::string
+HTMLDiagnostics::showRelevantLinesJavascript(const PathDiagnostic &D,
+ const PathPieces &path) {
std::string s;
llvm::raw_string_ostream os(s);
os << "<script type='text/javascript'>\n";
@@ -562,8 +561,10 @@ void HTMLDiagnostics::FinalizeHTML(const PathDiagnostic &D, Rewriter &R,
DirName += '/';
}
- int LineNumber = path.back()->getLocation().asLocation().getExpansionLineNumber();
- int ColumnNumber = path.back()->getLocation().asLocation().getExpansionColumnNumber();
+ int LineNumber =
+ path.back()->getLocation().asLocation().getExpansionLineNumber();
+ int ColumnNumber =
+ path.back()->getLocation().asLocation().getExpansionColumnNumber();
R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), showHelpJavascript());
@@ -585,29 +586,23 @@ void HTMLDiagnostics::FinalizeHTML(const PathDiagnostic &D, Rewriter &R,
os << "<!-- REPORTHEADER -->\n"
<< "<h3>Bug Summary</h3>\n<table class=\"simpletable\">\n"
"<tr><td class=\"rowname\">File:</td><td>"
- << html::EscapeText(DirName)
- << html::EscapeText(Entry.getName())
+ << html::EscapeText(DirName) << html::EscapeText(Entry.getName())
<< "</td></tr>\n<tr><td class=\"rowname\">Warning:</td><td>"
"<a href=\"#EndPath\">line "
- << LineNumber
- << ", column "
- << ColumnNumber
- << "</a><br />"
+ << LineNumber << ", column " << ColumnNumber << "</a><br />"
<< D.getVerboseDescription() << "</td></tr>\n";
// The navigation across the extra notes pieces.
unsigned NumExtraPieces = 0;
for (const auto &Piece : path) {
if (const auto *P = dyn_cast<PathDiagnosticNotePiece>(Piece.get())) {
- int LineNumber =
- P->getLocation().asLocation().getExpansionLineNumber();
+ int LineNumber = P->getLocation().asLocation().getExpansionLineNumber();
int ColumnNumber =
P->getLocation().asLocation().getExpansionColumnNumber();
++NumExtraPieces;
- os << "<tr><td class=\"rowname\">Note:</td><td>"
- << "<a href=\"#Note" << NumExtraPieces << "\">line "
- << LineNumber << ", column " << ColumnNumber << "</a><br />"
- << P->getString() << "</td></tr>";
+ os << "<tr><td class=\"rowname\">Note:</td><td>" << "<a href=\"#Note"
+ << NumExtraPieces << "\">line " << LineNumber << ", column "
+ << ColumnNumber << "</a><br />" << P->getString() << "</td></tr>";
}
}
@@ -669,20 +664,17 @@ void HTMLDiagnostics::FinalizeHTML(const PathDiagnostic &D, Rewriter &R,
os << "\n<!-- BUGFILE " << DirName << Entry.getName() << " -->\n";
- os << "\n<!-- FILENAME " << llvm::sys::path::filename(Entry.getName()) << " -->\n";
+ os << "\n<!-- FILENAME " << llvm::sys::path::filename(Entry.getName())
+ << " -->\n";
- os << "\n<!-- FUNCTIONNAME " << declName << " -->\n";
+ os << "\n<!-- FUNCTIONNAME " << declName << " -->\n";
os << "\n<!-- ISSUEHASHCONTENTOFLINEINCONTEXT " << getIssueHash(D, PP)
<< " -->\n";
- os << "\n<!-- BUGLINE "
- << LineNumber
- << " -->\n";
+ os << "\n<!-- BUGLINE " << LineNumber << " -->\n";
- os << "\n<!-- BUGCOLUMN "
- << ColumnNumber
- << " -->\n";
+ os << "\n<!-- BUGCOLUMN " << ColumnNumber << " -->\n";
os << "\n<!-- BUGPATHLENGTH " << getPathSizeWithoutArrows(path) << " -->\n";
@@ -908,8 +900,8 @@ void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
// Compute the column number. Rewind from the current position to the start
// of the line.
unsigned ColNo = SM.getColumnNumber(LPosInfo.first, LPosInfo.second);
- const char *TokInstantiationPtr =Pos.getExpansionLoc().getCharacterData();
- const char *LineStart = TokInstantiationPtr-ColNo;
+ const char *TokInstantiationPtr = Pos.getExpansionLoc().getCharacterData();
+ const char *LineStart = TokInstantiationPtr - ColNo;
// Compute LineEnd.
const char *LineEnd = TokInstantiationPtr;
@@ -919,7 +911,7 @@ void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
// Compute the margin offset by counting tabs and non-tabs.
unsigned PosNo = 0;
- for (const char* c = LineStart; c != TokInstantiationPtr; ++c)
+ for (const char *c = LineStart; c != TokInstantiationPtr; ++c)
PosNo += *c == '\t' ? 8 : 1;
// Create the html for the message.
@@ -928,10 +920,16 @@ void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
bool IsNote = false;
bool SuppressIndex = (max == 1);
switch (P.getKind()) {
- case PathDiagnosticPiece::Event: Kind = "Event"; break;
- case PathDiagnosticPiece::ControlFlow: Kind = "Control"; break;
+ case PathDiagnosticPiece::Event:
+ Kind = "Event";
+ break;
+ case PathDiagnosticPiece::ControlFlow:
+ Kind = "Control";
+ break;
// Setting Kind to "Control" is intentional.
- case PathDiagnosticPiece::Macro: Kind = "Control"; break;
+ case PathDiagnosticPiece::Macro:
+ Kind = "Control";
+ break;
case PathDiagnosticPiece::Note:
Kind = "Note";
IsNote = true;
@@ -975,7 +973,8 @@ void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
case ' ':
case '\t':
case '\n':
- if (cnt > max_token) max_token = cnt;
+ if (cnt > max_token)
+ max_token = cnt;
cnt = 0;
}
@@ -1003,10 +1002,9 @@ void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
em = characters / 2;
}
- if (em < max_line/2)
+ if (em < max_line / 2)
os << "; max-width:" << em << "em";
- }
- else
+ } else
os << "; max-width:100em";
os << "\">";
@@ -1014,14 +1012,13 @@ void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
if (!SuppressIndex) {
os << "<table class=\"msgT\"><tr><td valign=\"top\">";
os << "<div class=\"PathIndex";
- if (Kind) os << " PathIndex" << Kind;
+ if (Kind)
+ os << " PathIndex" << Kind;
os << "\">" << num << "</div>";
if (num > 1) {
- os << "</td><td><div class=\"PathNav\"><a href=\"#Path"
- << (num - 1)
- << "\" title=\"Previous event ("
- << (num - 1)
+ os << "</td><td><div class=\"PathNav\"><a href=\"#Path" << (num - 1)
+ << "\" title=\"Previous event (" << (num - 1)
<< ")\">←</a></div>";
}
@@ -1037,7 +1034,7 @@ void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
assert(L.isFileID());
StringRef BufferInfo = L.getBufferData();
std::pair<FileID, unsigned> LocInfo = L.getDecomposedLoc();
- const char* MacroName = LocInfo.second + BufferInfo.data();
+ const char *MacroName = LocInfo.second + BufferInfo.data();
Lexer rawLexer(SM.getLocForStartOfFile(LocInfo.first), PP.getLangOpts(),
BufferInfo.begin(), MacroName, BufferInfo.end());
@@ -1057,9 +1054,8 @@ void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
os << "EndPath";
else
os << "Path" << (num + 1);
- os << "\" title=\"Next event ("
- << (num + 1)
- << ")\">→</a></div></td>";
+ os << "\" title=\"Next event (" << (num + 1)
+ << ")\">→</a></div></td>";
}
os << "</tr></table>";
@@ -1067,8 +1063,7 @@ void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
// Within a macro piece. Write out each event.
ProcessMacroPiece(os, *MP, 0);
- }
- else {
+ } else {
os << html::EscapeText(P.getString());
if (!SuppressIndex) {
@@ -1079,8 +1074,7 @@ void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
os << "EndPath";
else
os << "Path" << (num + 1);
- os << "\" title=\"Next event ("
- << (num + 1)
+ os << "\" title=\"Next event (" << (num + 1)
<< ")\">→</a></div></td>";
}
@@ -1093,7 +1087,7 @@ void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
// Insert the new html.
unsigned DisplayPos = LineEnd - FileStart;
SourceLocation Loc =
- SM.getLocForStartOfFile(LPosInfo.first).getLocWithOffset(DisplayPos);
+ SM.getLocForStartOfFile(LPosInfo.first).getLocWithOffset(DisplayPos);
R.InsertTextBefore(Loc, os.str());
@@ -1119,7 +1113,7 @@ static void EmitAlphaCounter(raw_ostream &os, unsigned n) {
}
unsigned HTMLDiagnostics::ProcessMacroPiece(raw_ostream &os,
- const PathDiagnosticMacroPiece& P,
+ const PathDiagnosticMacroPiece &P,
unsigned num) {
for (const auto &subPiece : P.subPieces) {
if (const auto *MP = dyn_cast<PathDiagnosticMacroPiece>(subPiece.get())) {
@@ -1134,8 +1128,7 @@ unsigned HTMLDiagnostics::ProcessMacroPiece(raw_ostream &os,
"<td valign=\"top\"><div class=\"PathIndex PathIndexEvent\">";
EmitAlphaCounter(os, num++);
os << "</div></td><td valign=\"top\">"
- << html::EscapeText(EP->getString())
- << "</td></tr></table></div>\n";
+ << html::EscapeText(EP->getString()) << "</td></tr></table></div>\n";
}
}
@@ -1240,7 +1233,7 @@ unsigned HTMLDiagnostics::ProcessControlFlowPiece(
return Number;
}
-void HTMLDiagnostics::HighlightRange(Rewriter& R, FileID BugFileID,
+void HTMLDiagnostics::HighlightRange(Rewriter &R, FileID BugFileID,
SourceRange Range,
const char *HighlightStart,
const char *HighlightEnd) {
@@ -1266,14 +1259,13 @@ void HTMLDiagnostics::HighlightRange(Rewriter& R, FileID BugFileID,
if (EndColNo) {
// Add in the length of the token, so that we cover multi-char tokens.
- EndColNo += Lexer::MeasureTokenLength(Range.getEnd(), SM, LangOpts)-1;
+ EndColNo += Lexer::MeasureTokenLength(Range.getEnd(), SM, LangOpts) - 1;
}
// Highlight the range. Make the span tag the outermost tag for the
// selected range.
- SourceLocation E =
- InstantiationEnd.getLocWithOffset(EndColNo - OldEndColNo);
+ SourceLocation E = InstantiationEnd.getLocWithOffset(EndColNo - OldEndColNo);
html::HighlightRange(R, InstantiationStart, E, HighlightStart, HighlightEnd);
}
diff --git a/clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp b/clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp
index a80352816be613..81a59d2f5d5bfa 100644
--- a/clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp
+++ b/clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp
@@ -12,11 +12,11 @@
///
//===----------------------------------------------------------------------===//
-#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/LoopUnrolling.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/LoopUnrolling.h"
#include <optional>
using namespace clang;
@@ -343,5 +343,5 @@ bool isUnrolledState(ProgramStateRef State) {
return false;
return true;
}
-}
-}
+} // namespace ento
+} // namespace clang
diff --git a/clang/lib/StaticAnalyzer/Core/LoopWidening.cpp b/clang/lib/StaticAnalyzer/Core/LoopWidening.cpp
index 9e42801760622d..c923d75c558a1b 100644
--- a/clang/lib/StaticAnalyzer/Core/LoopWidening.cpp
+++ b/clang/lib/StaticAnalyzer/Core/LoopWidening.cpp
@@ -13,10 +13,10 @@
///
//===----------------------------------------------------------------------===//
+#include "clang/StaticAnalyzer/Core/PathSensitive/LoopWidening.h"
#include "clang/AST/AST.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/LoopWidening.h"
using namespace clang;
using namespace ento;
@@ -80,7 +80,6 @@ ProgramStateRef getWidenedLoopState(ProgramStateRef PrevState,
RegionAndSymbolInvalidationTraits::TK_PreserveContents);
}
-
// 'this' pointer is not an lvalue, we should not invalidate it. If the loop
// is located in a method, constructor or destructor, the value of 'this'
// pointer should remain unchanged. Ignore static methods, since they do not
diff --git a/clang/lib/StaticAnalyzer/Core/MemRegion.cpp b/clang/lib/StaticAnalyzer/Core/MemRegion.cpp
index 16db6b249dc92b..edbb3b4f22e124 100644
--- a/clang/lib/StaticAnalyzer/Core/MemRegion.cpp
+++ b/clang/lib/StaticAnalyzer/Core/MemRegion.cpp
@@ -66,7 +66,7 @@ using namespace ento;
//===----------------------------------------------------------------------===//
template <typename RegionTy, typename SuperTy, typename Arg1Ty>
-RegionTy* MemRegionManager::getSubRegion(const Arg1Ty arg1,
+RegionTy *MemRegionManager::getSubRegion(const Arg1Ty arg1,
const SuperTy *superRegion) {
llvm::FoldingSetNodeID ID;
RegionTy::ProfileRegion(ID, arg1, superRegion);
@@ -82,7 +82,7 @@ RegionTy* MemRegionManager::getSubRegion(const Arg1Ty arg1,
}
template <typename RegionTy, typename SuperTy, typename Arg1Ty, typename Arg2Ty>
-RegionTy* MemRegionManager::getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2,
+RegionTy *MemRegionManager::getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2,
const SuperTy *superRegion) {
llvm::FoldingSetNodeID ID;
RegionTy::ProfileRegion(ID, arg1, arg2, superRegion);
@@ -97,9 +97,9 @@ RegionTy* MemRegionManager::getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2,
return R;
}
-template <typename RegionTy, typename SuperTy,
- typename Arg1Ty, typename Arg2Ty, typename Arg3Ty>
-RegionTy* MemRegionManager::getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2,
+template <typename RegionTy, typename SuperTy, typename Arg1Ty, typename Arg2Ty,
+ typename Arg3Ty>
+RegionTy *MemRegionManager::getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2,
const Arg3Ty arg3,
const SuperTy *superRegion) {
llvm::FoldingSetNodeID ID;
@@ -129,8 +129,8 @@ MemRegionManager::~MemRegionManager() = default;
// Basic methods.
//===----------------------------------------------------------------------===//
-bool SubRegion::isSubRegionOf(const MemRegion* R) const {
- const MemRegion* r = this;
+bool SubRegion::isSubRegionOf(const MemRegion *R) const {
+ const MemRegion *r = this;
do {
if (r == R)
return true;
@@ -143,7 +143,7 @@ bool SubRegion::isSubRegionOf(const MemRegion* R) const {
}
MemRegionManager &SubRegion::getMemRegionManager() const {
- const SubRegion* r = this;
+ const SubRegion *r = this;
do {
const MemRegion *superRegion = r->getSuperRegion();
if (const auto *sr = dyn_cast<SubRegion>(superRegion)) {
@@ -178,9 +178,7 @@ ObjCIvarRegion::ObjCIvarRegion(const ObjCIvarDecl *ivd, const SubRegion *sReg)
const ObjCIvarDecl *ObjCIvarRegion::getDecl() const { return IVD; }
-QualType ObjCIvarRegion::getValueType() const {
- return getDecl()->getType();
-}
+QualType ObjCIvarRegion::getValueType() const { return getDecl()->getType(); }
QualType CXXBaseObjectRegion::getValueType() const {
return QualType(getDecl()->getTypeForDecl(), 0);
@@ -251,26 +249,25 @@ void ObjCStringRegion::ProfileRegion(llvm::FoldingSetNodeID &ID,
ID.AddPointer(superRegion);
}
-void AllocaRegion::ProfileRegion(llvm::FoldingSetNodeID& ID,
- const Expr *Ex, unsigned cnt,
- const MemRegion *superRegion) {
+void AllocaRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const Expr *Ex,
+ unsigned cnt, const MemRegion *superRegion) {
ID.AddInteger(static_cast<unsigned>(AllocaRegionKind));
ID.AddPointer(Ex);
ID.AddInteger(cnt);
ID.AddPointer(superRegion);
}
-void AllocaRegion::Profile(llvm::FoldingSetNodeID& ID) const {
+void AllocaRegion::Profile(llvm::FoldingSetNodeID &ID) const {
ProfileRegion(ID, Ex, Cnt, superRegion);
}
-void CompoundLiteralRegion::Profile(llvm::FoldingSetNodeID& ID) const {
+void CompoundLiteralRegion::Profile(llvm::FoldingSetNodeID &ID) const {
CompoundLiteralRegion::ProfileRegion(ID, CL, superRegion);
}
-void CompoundLiteralRegion::ProfileRegion(llvm::FoldingSetNodeID& ID,
+void CompoundLiteralRegion::ProfileRegion(llvm::FoldingSetNodeID &ID,
const CompoundLiteralExpr *CL,
- const MemRegion* superRegion) {
+ const MemRegion *superRegion) {
ID.AddInteger(static_cast<unsigned>(CompoundLiteralRegionKind));
ID.AddPointer(CL);
ID.AddPointer(superRegion);
@@ -292,9 +289,9 @@ void FieldRegion::Profile(llvm::FoldingSetNodeID &ID) const {
ProfileRegion(ID, getDecl(), superRegion);
}
-void ObjCIvarRegion::ProfileRegion(llvm::FoldingSetNodeID& ID,
+void ObjCIvarRegion::ProfileRegion(llvm::FoldingSetNodeID &ID,
const ObjCIvarDecl *ivd,
- const MemRegion* superRegion) {
+ const MemRegion *superRegion) {
ID.AddInteger(static_cast<unsigned>(ObjCIvarRegionKind));
ID.AddPointer(ivd);
ID.AddPointer(superRegion);
@@ -328,58 +325,56 @@ void ParamVarRegion::Profile(llvm::FoldingSetNodeID &ID) const {
ProfileRegion(ID, getOriginExpr(), getIndex(), superRegion);
}
-void SymbolicRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolRef sym,
+void SymbolicRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, SymbolRef sym,
const MemRegion *sreg) {
ID.AddInteger(static_cast<unsigned>(MemRegion::SymbolicRegionKind));
ID.Add(sym);
ID.AddPointer(sreg);
}
-void SymbolicRegion::Profile(llvm::FoldingSetNodeID& ID) const {
+void SymbolicRegion::Profile(llvm::FoldingSetNodeID &ID) const {
SymbolicRegion::ProfileRegion(ID, sym, getSuperRegion());
}
-void ElementRegion::ProfileRegion(llvm::FoldingSetNodeID& ID,
+void ElementRegion::ProfileRegion(llvm::FoldingSetNodeID &ID,
QualType ElementType, SVal Idx,
- const MemRegion* superRegion) {
+ const MemRegion *superRegion) {
ID.AddInteger(MemRegion::ElementRegionKind);
ID.Add(ElementType);
ID.AddPointer(superRegion);
Idx.Profile(ID);
}
-void ElementRegion::Profile(llvm::FoldingSetNodeID& ID) const {
+void ElementRegion::Profile(llvm::FoldingSetNodeID &ID) const {
ElementRegion::ProfileRegion(ID, ElementType, Index, superRegion);
}
-void FunctionCodeRegion::ProfileRegion(llvm::FoldingSetNodeID& ID,
- const NamedDecl *FD,
- const MemRegion*) {
+void FunctionCodeRegion::ProfileRegion(llvm::FoldingSetNodeID &ID,
+ const NamedDecl *FD, const MemRegion *) {
ID.AddInteger(MemRegion::FunctionCodeRegionKind);
ID.AddPointer(FD);
}
-void FunctionCodeRegion::Profile(llvm::FoldingSetNodeID& ID) const {
+void FunctionCodeRegion::Profile(llvm::FoldingSetNodeID &ID) const {
FunctionCodeRegion::ProfileRegion(ID, FD, superRegion);
}
-void BlockCodeRegion::ProfileRegion(llvm::FoldingSetNodeID& ID,
+void BlockCodeRegion::ProfileRegion(llvm::FoldingSetNodeID &ID,
const BlockDecl *BD, CanQualType,
const AnalysisDeclContext *AC,
- const MemRegion*) {
+ const MemRegion *) {
ID.AddInteger(MemRegion::BlockCodeRegionKind);
ID.AddPointer(BD);
}
-void BlockCodeRegion::Profile(llvm::FoldingSetNodeID& ID) const {
+void BlockCodeRegion::Profile(llvm::FoldingSetNodeID &ID) const {
BlockCodeRegion::ProfileRegion(ID, BD, locTy, AC, superRegion);
}
-void BlockDataRegion::ProfileRegion(llvm::FoldingSetNodeID& ID,
+void BlockDataRegion::ProfileRegion(llvm::FoldingSetNodeID &ID,
const BlockCodeRegion *BC,
const LocationContext *LC,
- unsigned BlkCount,
- const MemRegion *sReg) {
+ unsigned BlkCount, const MemRegion *sReg) {
ID.AddInteger(MemRegion::BlockDataRegionKind);
ID.AddPointer(BC);
ID.AddPointer(LC);
@@ -387,13 +382,12 @@ void BlockDataRegion::ProfileRegion(llvm::FoldingSetNodeID& ID,
ID.AddPointer(sReg);
}
-void BlockDataRegion::Profile(llvm::FoldingSetNodeID& ID) const {
+void BlockDataRegion::Profile(llvm::FoldingSetNodeID &ID) const {
BlockDataRegion::ProfileRegion(ID, BC, LC, BlockCount, getSuperRegion());
}
void CXXTempObjectRegion::ProfileRegion(llvm::FoldingSetNodeID &ID,
- Expr const *Ex,
- const MemRegion *sReg) {
+ Expr const *Ex, const MemRegion *sReg) {
ID.AddPointer(Ex);
ID.AddPointer(sReg);
}
@@ -417,8 +411,7 @@ void CXXLifetimeExtendedObjectRegion::Profile(
}
void CXXBaseObjectRegion::ProfileRegion(llvm::FoldingSetNodeID &ID,
- const CXXRecordDecl *RD,
- bool IsVirtual,
+ const CXXRecordDecl *RD, bool IsVirtual,
const MemRegion *SReg) {
ID.AddPointer(RD);
ID.AddBoolean(IsVirtual);
@@ -462,9 +455,7 @@ void SubRegion::anchor() {}
// Region pretty-printing.
//===----------------------------------------------------------------------===//
-LLVM_DUMP_METHOD void MemRegion::dump() const {
- dumpToStream(llvm::errs());
-}
+LLVM_DUMP_METHOD void MemRegion::dump() const { dumpToStream(llvm::errs()); }
std::string MemRegion::getString() const {
std::string s;
@@ -500,12 +491,12 @@ void BlockDataRegion::dumpToStream(raw_ostream &os) const {
void CompoundLiteralRegion::dumpToStream(raw_ostream &os) const {
// FIXME: More elaborate pretty-printing.
- os << "{ S" << CL->getID(getContext()) << " }";
+ os << "{ S" << CL->getID(getContext()) << " }";
}
void CXXTempObjectRegion::dumpToStream(raw_ostream &os) const {
- os << "temp_object{" << getValueType() << ", "
- << "S" << Ex->getID(getContext()) << '}';
+ os << "temp_object{" << getValueType() << ", " << "S"
+ << Ex->getID(getContext()) << '}';
}
void CXXLifetimeExtendedObjectRegion::dumpToStream(raw_ostream &os) const {
@@ -514,8 +505,7 @@ void CXXLifetimeExtendedObjectRegion::dumpToStream(raw_ostream &os) const {
os << ID->getName();
else
os << "D" << ExD->getID();
- os << ", "
- << "S" << Ex->getID(getContext()) << '}';
+ os << ", " << "S" << Ex->getID(getContext()) << '}';
}
void CXXBaseObjectRegion::dumpToStream(raw_ostream &os) const {
@@ -526,9 +516,7 @@ void CXXDerivedObjectRegion::dumpToStream(raw_ostream &os) const {
os << "Derived{" << superRegion << ',' << getDecl()->getName() << '}';
}
-void CXXThisRegion::dumpToStream(raw_ostream &os) const {
- os << "this";
-}
+void CXXThisRegion::dumpToStream(raw_ostream &os) const { os << "this"; }
void ElementRegion::dumpToStream(raw_ostream &os) const {
os << "Element{" << superRegion << ',' << Index << ',' << getElementType()
@@ -622,13 +610,9 @@ void ParamVarRegion::dumpToStream(raw_ostream &os) const {
}
}
-bool MemRegion::canPrintPretty() const {
- return canPrintPrettyAsExpr();
-}
+bool MemRegion::canPrintPretty() const { return canPrintPrettyAsExpr(); }
-bool MemRegion::canPrintPrettyAsExpr() const {
- return false;
-}
+bool MemRegion::canPrintPrettyAsExpr() const { return false; }
void MemRegion::printPretty(raw_ostream &os) const {
assert(canPrintPretty() && "This region cannot be printed pretty.");
@@ -656,17 +640,13 @@ void ParamVarRegion::printPrettyAsExpr(raw_ostream &os) const {
os << getDecl()->getName();
}
-bool ObjCIvarRegion::canPrintPrettyAsExpr() const {
- return true;
-}
+bool ObjCIvarRegion::canPrintPrettyAsExpr() const { return true; }
void ObjCIvarRegion::printPrettyAsExpr(raw_ostream &os) const {
os << getDecl()->getName();
}
-bool FieldRegion::canPrintPretty() const {
- return true;
-}
+bool FieldRegion::canPrintPretty() const { return true; }
bool FieldRegion::canPrintPrettyAsExpr() const {
return superRegion->canPrintPrettyAsExpr();
@@ -862,7 +842,7 @@ DefinedOrUnknownSVal MemRegionManager::getStaticSize(const MemRegion *MR,
}
template <typename REG>
-const REG *MemRegionManager::LazyAllocate(REG*& region) {
+const REG *MemRegionManager::LazyAllocate(REG *®ion) {
if (!region) {
region = new (A) REG(*this);
}
@@ -871,7 +851,7 @@ const REG *MemRegionManager::LazyAllocate(REG*& region) {
}
template <typename REG, typename ARG>
-const REG *MemRegionManager::LazyAllocate(REG*& region, ARG a) {
+const REG *MemRegionManager::LazyAllocate(REG *®ion, ARG a) {
if (!region) {
region = new (A) REG(this, a);
}
@@ -879,7 +859,7 @@ const REG *MemRegionManager::LazyAllocate(REG*& region, ARG a) {
return region;
}
-const StackLocalsSpaceRegion*
+const StackLocalsSpaceRegion *
MemRegionManager::getStackLocalsRegion(const StackFrameContext *STC) {
assert(STC);
StackLocalsSpaceRegion *&R = StackLocalsSpaceRegions[STC];
@@ -903,9 +883,9 @@ MemRegionManager::getStackArgumentsRegion(const StackFrameContext *STC) {
return R;
}
-const GlobalsSpaceRegion
-*MemRegionManager::getGlobalsRegion(MemRegion::Kind K,
- const CodeTextRegion *CR) {
+const GlobalsSpaceRegion *
+MemRegionManager::getGlobalsRegion(MemRegion::Kind K,
+ const CodeTextRegion *CR) {
if (!CR) {
if (K == MemRegion::GlobalSystemSpaceRegionKind)
return LazyAllocate(SystemGlobals);
@@ -940,13 +920,14 @@ const CodeSpaceRegion *MemRegionManager::getCodeRegion() {
// Constructing regions.
//===----------------------------------------------------------------------===//
-const StringRegion *MemRegionManager::getStringRegion(const StringLiteral *Str){
+const StringRegion *
+MemRegionManager::getStringRegion(const StringLiteral *Str) {
return getSubRegion<StringRegion>(
Str, cast<GlobalInternalSpaceRegion>(getGlobalsRegion()));
}
const ObjCStringRegion *
-MemRegionManager::getObjCStringRegion(const ObjCStringLiteral *Str){
+MemRegionManager::getObjCStringRegion(const ObjCStringLiteral *Str) {
return getSubRegion<ObjCStringRegion>(
Str, cast<GlobalInternalSpaceRegion>(getGlobalsRegion()));
}
@@ -1018,16 +999,16 @@ const VarRegion *MemRegionManager::getVarRegion(const VarDecl *D,
sReg = getGlobalsRegion(MemRegion::GlobalInternalSpaceRegionKind);
}
- // Finally handle static locals.
+ // Finally handle static locals.
} else {
// FIXME: Once we implement scope handling, we will need to properly lookup
// 'D' to the proper LocationContext.
const DeclContext *DC = D->getDeclContext();
llvm::PointerUnion<const StackFrameContext *, const VarRegion *> V =
- getStackOrCaptureRegionForDeclContext(LC, DC, D);
+ getStackOrCaptureRegionForDeclContext(LC, DC, D);
- if (V.is<const VarRegion*>())
- return V.get<const VarRegion*>();
+ if (V.is<const VarRegion *>())
+ return V.get<const VarRegion *>();
const auto *STC = V.get<const StackFrameContext *>();
@@ -1041,8 +1022,7 @@ const VarRegion *MemRegionManager::getVarRegion(const VarDecl *D,
isa<ParmVarDecl, ImplicitParamDecl>(D)
? static_cast<const MemRegion *>(getStackArgumentsRegion(STC))
: static_cast<const MemRegion *>(getStackLocalsRegion(STC));
- }
- else {
+ } else {
assert(D->isStaticLocal());
const Decl *STCD = STC->getDecl();
if (isa<FunctionDecl, ObjCMethodDecl>(STCD))
@@ -1064,13 +1044,10 @@ const VarRegion *MemRegionManager::getVarRegion(const VarDecl *D,
}
T = getContext().getBlockPointerType(T);
- const BlockCodeRegion *BTR =
- getBlockCodeRegion(BD, Ctx.getCanonicalType(T),
- STC->getAnalysisDeclContext());
- sReg = getGlobalsRegion(MemRegion::StaticGlobalSpaceRegionKind,
- BTR);
- }
- else {
+ const BlockCodeRegion *BTR = getBlockCodeRegion(
+ BD, Ctx.getCanonicalType(T), STC->getAnalysisDeclContext());
+ sReg = getGlobalsRegion(MemRegion::StaticGlobalSpaceRegionKind, BTR);
+ } else {
sReg = getGlobalsRegion();
}
}
@@ -1099,17 +1076,14 @@ MemRegionManager::getParamVarRegion(const Expr *OriginExpr, unsigned Index,
getStackArgumentsRegion(SFC));
}
-const BlockDataRegion *
-MemRegionManager::getBlockDataRegion(const BlockCodeRegion *BC,
- const LocationContext *LC,
- unsigned blockCount) {
+const BlockDataRegion *MemRegionManager::getBlockDataRegion(
+ const BlockCodeRegion *BC, const LocationContext *LC, unsigned blockCount) {
const MemSpaceRegion *sReg = nullptr;
const BlockDecl *BD = BC->getDecl();
if (!BD->hasCaptures()) {
// This handles 'static' blocks.
sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind);
- }
- else {
+ } else {
bool IsArcManagedBlock = Ctx.getLangOpts().ObjCAutoRefCount;
// ARC managed blocks can be initialized on stack or directly in heap
@@ -1131,7 +1105,7 @@ MemRegionManager::getBlockDataRegion(const BlockCodeRegion *BC,
return getSubRegion<BlockDataRegion>(BC, LC, blockCount, sReg);
}
-const CompoundLiteralRegion*
+const CompoundLiteralRegion *
MemRegionManager::getCompoundLiteralRegion(const CompoundLiteralExpr *CL,
const LocationContext *LC) {
const MemSpaceRegion *sReg = nullptr;
@@ -1147,17 +1121,17 @@ MemRegionManager::getCompoundLiteralRegion(const CompoundLiteralExpr *CL,
return getSubRegion<CompoundLiteralRegion>(CL, sReg);
}
-const ElementRegion*
+const ElementRegion *
MemRegionManager::getElementRegion(QualType elementType, NonLoc Idx,
- const SubRegion* superRegion,
- ASTContext &Ctx){
+ const SubRegion *superRegion,
+ ASTContext &Ctx) {
QualType T = Ctx.getCanonicalType(elementType).getUnqualifiedType();
llvm::FoldingSetNodeID ID;
ElementRegion::ProfileRegion(ID, T, Idx, superRegion);
void *InsertPos;
- MemRegion* data = Regions.FindNodeOrInsertPos(ID, InsertPos);
+ MemRegion *data = Regions.FindNodeOrInsertPos(ID, InsertPos);
auto *R = cast_or_null<ElementRegion>(data);
if (!R) {
@@ -1192,19 +1166,19 @@ const SymbolicRegion *MemRegionManager::getSymbolicHeapRegion(SymbolRef Sym) {
return getSubRegion<SymbolicRegion>(Sym, getHeapRegion());
}
-const FieldRegion*
+const FieldRegion *
MemRegionManager::getFieldRegion(const FieldDecl *d,
- const SubRegion* superRegion){
+ const SubRegion *superRegion) {
return getSubRegion<FieldRegion>(d, superRegion);
}
-const ObjCIvarRegion*
+const ObjCIvarRegion *
MemRegionManager::getObjCIvarRegion(const ObjCIvarDecl *d,
- const SubRegion* superRegion) {
+ const SubRegion *superRegion) {
return getSubRegion<ObjCIvarRegion>(d, superRegion);
}
-const CXXTempObjectRegion*
+const CXXTempObjectRegion *
MemRegionManager::getCXXTempObjectRegion(Expr const *E,
LocationContext const *LC) {
const StackFrameContext *SFC = LC->getStackFrame();
@@ -1232,8 +1206,7 @@ MemRegionManager::getCXXStaticLifetimeExtendedObjectRegion(
/// Checks whether \p BaseClass is a valid virtual or direct non-virtual base
/// class of the type of \p Super.
static bool isValidBaseClass(const CXXRecordDecl *BaseClass,
- const TypedValueRegion *Super,
- bool IsVirtual) {
+ const TypedValueRegion *Super, bool IsVirtual) {
BaseClass = BaseClass->getCanonicalDecl();
const CXXRecordDecl *Class = Super->getValueType()->getAsCXXRecordDecl();
@@ -1251,10 +1224,8 @@ static bool isValidBaseClass(const CXXRecordDecl *BaseClass,
return false;
}
-const CXXBaseObjectRegion *
-MemRegionManager::getCXXBaseObjectRegion(const CXXRecordDecl *RD,
- const SubRegion *Super,
- bool IsVirtual) {
+const CXXBaseObjectRegion *MemRegionManager::getCXXBaseObjectRegion(
+ const CXXRecordDecl *RD, const SubRegion *Super, bool IsVirtual) {
if (isa<TypedValueRegion>(Super)) {
assert(isValidBaseClass(RD, cast<TypedValueRegion>(Super), IsVirtual));
(void)&isValidBaseClass;
@@ -1277,7 +1248,7 @@ MemRegionManager::getCXXDerivedObjectRegion(const CXXRecordDecl *RD,
return getSubRegion<CXXDerivedObjectRegion>(RD, Super);
}
-const CXXThisRegion*
+const CXXThisRegion *
MemRegionManager::getCXXThisRegion(QualType thisPointerTy,
const LocationContext *LC) {
const auto *PT = thisPointerTy->getAs<PointerType>();
@@ -1298,7 +1269,7 @@ MemRegionManager::getCXXThisRegion(QualType thisPointerTy,
return getSubRegion<CXXThisRegion>(PT, getStackArgumentsRegion(STC));
}
-const AllocaRegion*
+const AllocaRegion *
MemRegionManager::getAllocaRegion(const Expr *E, unsigned cnt,
const LocationContext *LC) {
const StackFrameContext *STC = LC->getStackFrame();
@@ -1336,15 +1307,15 @@ const MemRegion *MemRegion::getBaseRegion() const {
const MemRegion *R = this;
while (true) {
switch (R->getKind()) {
- case MemRegion::ElementRegionKind:
- case MemRegion::FieldRegionKind:
- case MemRegion::ObjCIvarRegionKind:
- case MemRegion::CXXBaseObjectRegionKind:
- case MemRegion::CXXDerivedObjectRegionKind:
- R = cast<SubRegion>(R)->getSuperRegion();
- continue;
- default:
- break;
+ case MemRegion::ElementRegionKind:
+ case MemRegion::FieldRegionKind:
+ case MemRegion::ObjCIvarRegionKind:
+ case MemRegion::CXXBaseObjectRegionKind:
+ case MemRegion::CXXDerivedObjectRegionKind:
+ R = cast<SubRegion>(R)->getSuperRegion();
+ continue;
+ default:
+ break;
}
break;
}
@@ -1359,9 +1330,7 @@ const MemRegion *MemRegion::getMostDerivedObjectRegion() const {
return R;
}
-bool MemRegion::isSubRegionOf(const MemRegion *) const {
- return false;
-}
+bool MemRegion::isSubRegionOf(const MemRegion *) const { return false; }
//===----------------------------------------------------------------------===//
// View handling.
@@ -1622,7 +1591,8 @@ static RegionOffset calculateOffset(const MemRegion *R) {
// Get the field number.
unsigned idx = 0;
for (RecordDecl::field_iterator FI = RD->field_begin(),
- FE = RD->field_end(); FI != FE; ++FI, ++idx) {
+ FE = RD->field_end();
+ FI != FE; ++FI, ++idx) {
if (FR->getDecl() == *FI)
break;
}
@@ -1634,7 +1604,7 @@ static RegionOffset calculateOffset(const MemRegion *R) {
}
}
- Finish:
+Finish:
if (SymbolicOffsetBase)
return RegionOffset(SymbolicOffsetBase, RegionOffset::Symbolic);
return RegionOffset(R, Offset);
@@ -1659,13 +1629,11 @@ BlockDataRegion::getCaptureRegions(const VarDecl *VD) {
if (!VD->hasAttr<BlocksAttr>() && VD->hasLocalStorage()) {
VR = MemMgr.getNonParamVarRegion(VD, this);
OriginalVR = MemMgr.getVarRegion(VD, LC);
- }
- else {
+ } else {
if (LC) {
VR = MemMgr.getVarRegion(VD, LC);
OriginalVR = VR;
- }
- else {
+ } else {
VR = MemMgr.getNonParamVarRegion(VD, MemMgr.getUnknownRegion());
OriginalVR = MemMgr.getVarRegion(VD, LC);
}
@@ -1683,7 +1651,7 @@ void BlockDataRegion::LazyInitializeReferencedVars() {
std::distance(ReferencedBlockVars.begin(), ReferencedBlockVars.end());
if (NumBlockVars == 0) {
- ReferencedVars = (void*) 0x1;
+ ReferencedVars = (void *)0x1;
return;
}
@@ -1712,11 +1680,11 @@ void BlockDataRegion::LazyInitializeReferencedVars() {
BlockDataRegion::referenced_vars_iterator
BlockDataRegion::referenced_vars_begin() const {
- const_cast<BlockDataRegion*>(this)->LazyInitializeReferencedVars();
+ const_cast<BlockDataRegion *>(this)->LazyInitializeReferencedVars();
auto *Vec = static_cast<BumpVector<const MemRegion *> *>(ReferencedVars);
- if (Vec == (void*) 0x1)
+ if (Vec == (void *)0x1)
return BlockDataRegion::referenced_vars_iterator(nullptr, nullptr);
auto *VecOriginal =
@@ -1728,11 +1696,11 @@ BlockDataRegion::referenced_vars_begin() const {
BlockDataRegion::referenced_vars_iterator
BlockDataRegion::referenced_vars_end() const {
- const_cast<BlockDataRegion*>(this)->LazyInitializeReferencedVars();
+ const_cast<BlockDataRegion *>(this)->LazyInitializeReferencedVars();
auto *Vec = static_cast<BumpVector<const MemRegion *> *>(ReferencedVars);
- if (Vec == (void*) 0x1)
+ if (Vec == (void *)0x1)
return BlockDataRegion::referenced_vars_iterator(nullptr, nullptr);
auto *VecOriginal =
diff --git a/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp b/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp
index be19a1c118ea5a..2b28ca6c9dc347 100644
--- a/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp
+++ b/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp
@@ -40,48 +40,46 @@ using namespace markup;
//===----------------------------------------------------------------------===//
namespace {
- class PlistDiagnostics : public PathDiagnosticConsumer {
- PathDiagnosticConsumerOptions DiagOpts;
- const std::string OutputFile;
- const Preprocessor &PP;
- const cross_tu::CrossTranslationUnitContext &CTU;
- const MacroExpansionContext &MacroExpansions;
- const bool SupportsCrossFileDiagnostics;
-
- void printBugPath(llvm::raw_ostream &o, const FIDMap &FM,
- const PathPieces &Path);
-
- public:
- PlistDiagnostics(PathDiagnosticConsumerOptions DiagOpts,
- const std::string &OutputFile, const Preprocessor &PP,
- const cross_tu::CrossTranslationUnitContext &CTU,
- const MacroExpansionContext &MacroExpansions,
- bool supportsMultipleFiles);
-
- ~PlistDiagnostics() override {}
-
- void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
- FilesMade *filesMade) override;
-
- StringRef getName() const override {
- return "PlistDiagnostics";
- }
+class PlistDiagnostics : public PathDiagnosticConsumer {
+ PathDiagnosticConsumerOptions DiagOpts;
+ const std::string OutputFile;
+ const Preprocessor &PP;
+ const cross_tu::CrossTranslationUnitContext &CTU;
+ const MacroExpansionContext &MacroExpansions;
+ const bool SupportsCrossFileDiagnostics;
- PathGenerationScheme getGenerationScheme() const override {
- return Extensive;
- }
- bool supportsLogicalOpControlFlow() const override { return true; }
- bool supportsCrossFileDiagnostics() const override {
- return SupportsCrossFileDiagnostics;
- }
- };
+ void printBugPath(llvm::raw_ostream &o, const FIDMap &FM,
+ const PathPieces &Path);
+
+public:
+ PlistDiagnostics(PathDiagnosticConsumerOptions DiagOpts,
+ const std::string &OutputFile, const Preprocessor &PP,
+ const cross_tu::CrossTranslationUnitContext &CTU,
+ const MacroExpansionContext &MacroExpansions,
+ bool supportsMultipleFiles);
+
+ ~PlistDiagnostics() override {}
+
+ void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
+ FilesMade *filesMade) override;
+
+ StringRef getName() const override { return "PlistDiagnostics"; }
+
+ PathGenerationScheme getGenerationScheme() const override {
+ return Extensive;
+ }
+ bool supportsLogicalOpControlFlow() const override { return true; }
+ bool supportsCrossFileDiagnostics() const override {
+ return SupportsCrossFileDiagnostics;
+ }
+};
} // end anonymous namespace
namespace {
/// A helper class for emitting a single report.
class PlistPrinter {
- const FIDMap& FM;
+ const FIDMap &FM;
const Preprocessor &PP;
const cross_tu::CrossTranslationUnitContext &CTU;
const MacroExpansionContext &MacroExpansions;
@@ -93,7 +91,7 @@ class PlistPrinter {
const MacroExpansionContext &MacroExpansions)
: FM(FM), PP(PP), CTU(CTU), MacroExpansions(MacroExpansions) {}
- void ReportDiag(raw_ostream &o, const PathDiagnosticPiece& P) {
+ void ReportDiag(raw_ostream &o, const PathDiagnosticPiece &P) {
ReportPiece(o, P, /*indent*/ 4, /*depth*/ 0, /*includeControlFlow*/ true);
}
@@ -110,28 +108,26 @@ class PlistPrinter {
unsigned indent, unsigned depth, bool includeControlFlow,
bool isKeyEvent = false) {
switch (P.getKind()) {
- case PathDiagnosticPiece::ControlFlow:
- if (includeControlFlow)
- ReportControlFlow(o, cast<PathDiagnosticControlFlowPiece>(P), indent);
- break;
- case PathDiagnosticPiece::Call:
- ReportCall(o, cast<PathDiagnosticCallPiece>(P), indent,
- depth);
- break;
- case PathDiagnosticPiece::Event:
- ReportEvent(o, cast<PathDiagnosticEventPiece>(P), indent, depth,
- isKeyEvent);
- break;
- case PathDiagnosticPiece::Macro:
- ReportMacroSubPieces(o, cast<PathDiagnosticMacroPiece>(P), indent,
- depth);
- break;
- case PathDiagnosticPiece::Note:
- ReportNote(o, cast<PathDiagnosticNotePiece>(P), indent);
- break;
- case PathDiagnosticPiece::PopUp:
- ReportPopUp(o, cast<PathDiagnosticPopUpPiece>(P), indent);
- break;
+ case PathDiagnosticPiece::ControlFlow:
+ if (includeControlFlow)
+ ReportControlFlow(o, cast<PathDiagnosticControlFlowPiece>(P), indent);
+ break;
+ case PathDiagnosticPiece::Call:
+ ReportCall(o, cast<PathDiagnosticCallPiece>(P), indent, depth);
+ break;
+ case PathDiagnosticPiece::Event:
+ ReportEvent(o, cast<PathDiagnosticEventPiece>(P), indent, depth,
+ isKeyEvent);
+ break;
+ case PathDiagnosticPiece::Macro:
+ ReportMacroSubPieces(o, cast<PathDiagnosticMacroPiece>(P), indent, depth);
+ break;
+ case PathDiagnosticPiece::Note:
+ ReportNote(o, cast<PathDiagnosticNotePiece>(P), indent);
+ break;
+ case PathDiagnosticPiece::PopUp:
+ ReportPopUp(o, cast<PathDiagnosticPopUpPiece>(P), indent);
+ break;
}
}
@@ -141,15 +137,15 @@ class PlistPrinter {
void EmitFixits(raw_ostream &o, ArrayRef<FixItHint> fixits, unsigned indent);
void ReportControlFlow(raw_ostream &o,
- const PathDiagnosticControlFlowPiece& P,
+ const PathDiagnosticControlFlowPiece &P,
unsigned indent);
- void ReportEvent(raw_ostream &o, const PathDiagnosticEventPiece& P,
+ void ReportEvent(raw_ostream &o, const PathDiagnosticEventPiece &P,
unsigned indent, unsigned depth, bool isKeyEvent = false);
void ReportCall(raw_ostream &o, const PathDiagnosticCallPiece &P,
unsigned indent, unsigned depth);
- void ReportMacroSubPieces(raw_ostream &o, const PathDiagnosticMacroPiece& P,
+ void ReportMacroSubPieces(raw_ostream &o, const PathDiagnosticMacroPiece &P,
unsigned indent, unsigned depth);
- void ReportNote(raw_ostream &o, const PathDiagnosticNotePiece& P,
+ void ReportNote(raw_ostream &o, const PathDiagnosticNotePiece &P,
unsigned indent);
void ReportPopUp(raw_ostream &o, const PathDiagnosticPopUpPiece &P,
@@ -160,10 +156,8 @@ class PlistPrinter {
/// Print coverage information to output stream @c o.
/// May modify the used list of files @c Fids by inserting new ones.
-static void printCoverage(const PathDiagnostic *D,
- unsigned InputIndentLevel,
- SmallVectorImpl<FileID> &Fids,
- FIDMap &FM,
+static void printCoverage(const PathDiagnostic *D, unsigned InputIndentLevel,
+ SmallVectorImpl<FileID> &Fids, FIDMap &FM,
llvm::raw_fd_ostream &o);
static std::optional<StringRef> getExpandedMacro(
@@ -190,8 +184,8 @@ void PlistPrinter::EmitRanges(raw_ostream &o,
for (auto &R : Ranges)
EmitRange(o, SM,
- Lexer::getAsCharRange(SM.getExpansionRange(R), SM, LangOpts),
- FM, indent + 1);
+ Lexer::getAsCharRange(SM.getExpansionRange(R), SM, LangOpts), FM,
+ indent + 1);
--indent;
Indent(o, indent) << "</array>\n";
}
@@ -228,8 +222,8 @@ void PlistPrinter::EmitFixits(raw_ostream &o, ArrayRef<FixItHint> fixits,
assert(!fixit.BeforePreviousInsertions && "Not implemented yet!");
Indent(o, indent) << " <dict>\n";
Indent(o, indent) << " <key>remove_range</key>\n";
- EmitRange(o, SM, Lexer::getAsCharRange(fixit.RemoveRange, SM, LangOpts),
- FM, indent + 2);
+ EmitRange(o, SM, Lexer::getAsCharRange(fixit.RemoveRange, SM, LangOpts), FM,
+ indent + 2);
Indent(o, indent) << " <key>insert_string</key>";
EmitString(o, fixit.CodeToInsert);
o << "\n";
@@ -239,7 +233,7 @@ void PlistPrinter::EmitFixits(raw_ostream &o, ArrayRef<FixItHint> fixits,
}
void PlistPrinter::ReportControlFlow(raw_ostream &o,
- const PathDiagnosticControlFlowPiece& P,
+ const PathDiagnosticControlFlowPiece &P,
unsigned indent) {
const SourceManager &SM = PP.getSourceManager();
@@ -255,14 +249,15 @@ void PlistPrinter::ReportControlFlow(raw_ostream &o,
++indent;
Indent(o, indent) << "<array>\n";
++indent;
- for (PathDiagnosticControlFlowPiece::const_iterator I=P.begin(), E=P.end();
- I!=E; ++I) {
+ for (PathDiagnosticControlFlowPiece::const_iterator I = P.begin(),
+ E = P.end();
+ I != E; ++I) {
Indent(o, indent) << "<dict>\n";
++indent;
- // Make the ranges of the start and end point self-consistent with adjacent edges
- // by forcing to use only the beginning of the range. This simplifies the layout
- // logic for clients.
+ // Make the ranges of the start and end point self-consistent with adjacent
+ // edges by forcing to use only the beginning of the range. This simplifies
+ // the layout logic for clients.
Indent(o, indent) << "<key>start</key>\n";
SourceRange StartEdge(
SM.getExpansionLoc(I->getStart().asRange().getBegin()));
@@ -295,7 +290,8 @@ void PlistPrinter::ReportControlFlow(raw_ostream &o,
Indent(o, indent) << "</dict>\n";
}
-void PlistPrinter::ReportEvent(raw_ostream &o, const PathDiagnosticEventPiece& P,
+void PlistPrinter::ReportEvent(raw_ostream &o,
+ const PathDiagnosticEventPiece &P,
unsigned indent, unsigned depth,
bool isKeyEvent) {
@@ -332,25 +328,25 @@ void PlistPrinter::ReportEvent(raw_ostream &o, const PathDiagnosticEventPiece& P
// Finish up.
--indent;
- Indent(o, indent); o << "</dict>\n";
+ Indent(o, indent);
+ o << "</dict>\n";
}
void PlistPrinter::ReportCall(raw_ostream &o, const PathDiagnosticCallPiece &P,
- unsigned indent,
- unsigned depth) {
+ unsigned indent, unsigned depth) {
if (auto callEnter = P.getCallEnterEvent())
ReportPiece(o, *callEnter, indent, depth, /*includeControlFlow*/ true,
P.isLastInMainSourceFile());
-
++depth;
if (auto callEnterWithinCaller = P.getCallEnterWithinCallerEvent())
ReportPiece(o, *callEnterWithinCaller, indent, depth,
/*includeControlFlow*/ true);
- for (PathPieces::const_iterator I = P.path.begin(), E = P.path.end();I!=E;++I)
+ for (PathPieces::const_iterator I = P.path.begin(), E = P.path.end(); I != E;
+ ++I)
ReportPiece(o, **I, indent, depth, /*includeControlFlow*/ true);
--depth;
@@ -363,7 +359,7 @@ void PlistPrinter::ReportCall(raw_ostream &o, const PathDiagnosticCallPiece &P,
}
void PlistPrinter::ReportMacroSubPieces(raw_ostream &o,
- const PathDiagnosticMacroPiece& P,
+ const PathDiagnosticMacroPiece &P,
unsigned indent, unsigned depth) {
MacroPieces.push_back(&P);
@@ -419,7 +415,7 @@ void PlistPrinter::ReportMacroExpansions(raw_ostream &o, unsigned indent) {
}
}
-void PlistPrinter::ReportNote(raw_ostream &o, const PathDiagnosticNotePiece& P,
+void PlistPrinter::ReportNote(raw_ostream &o, const PathDiagnosticNotePiece &P,
unsigned indent) {
const SourceManager &SM = PP.getSourceManager();
@@ -445,7 +441,8 @@ void PlistPrinter::ReportNote(raw_ostream &o, const PathDiagnosticNotePiece& P,
// Finish up.
--indent;
- Indent(o, indent); o << "</dict>\n";
+ Indent(o, indent);
+ o << "</dict>\n";
}
void PlistPrinter::ReportPopUp(raw_ostream &o,
@@ -485,10 +482,8 @@ void PlistPrinter::ReportPopUp(raw_ostream &o,
/// Print coverage information to output stream @c o.
/// May modify the used list of files @c Fids by inserting new ones.
-static void printCoverage(const PathDiagnostic *D,
- unsigned InputIndentLevel,
- SmallVectorImpl<FileID> &Fids,
- FIDMap &FM,
+static void printCoverage(const PathDiagnostic *D, unsigned InputIndentLevel,
+ SmallVectorImpl<FileID> &Fids, FIDMap &FM,
llvm::raw_fd_ostream &o) {
unsigned IndentLevel = InputIndentLevel;
@@ -610,13 +605,12 @@ void PlistDiagnostics::printBugPath(llvm::raw_ostream &o, const FIDMap &FM,
}
void PlistDiagnostics::FlushDiagnosticsImpl(
- std::vector<const PathDiagnostic *> &Diags,
- FilesMade *filesMade) {
+ std::vector<const PathDiagnostic *> &Diags, FilesMade *filesMade) {
// Build up a set of FIDs that we use by scanning the locations and
// ranges of the diagnostics.
FIDMap FM;
SmallVector<FileID, 10> Fids;
- const SourceManager& SM = PP.getSourceManager();
+ const SourceManager &SM = PP.getSourceManager();
const LangOptions &LangOpts = PP.getLangOpts();
auto AddPieceFID = [&FM, &Fids, &SM](const PathDiagnosticPiece &Piece) {
@@ -671,14 +665,15 @@ void PlistDiagnostics::FlushDiagnosticsImpl(
// - "clang_version", the string representation of clang version
// - "files", an <array> mapping from FIDs to file names
// - "diagnostics", an <array> containing the path diagnostics
- o << "<dict>\n" <<
- " <key>clang_version</key>\n";
+ o << "<dict>\n"
+ << " <key>clang_version</key>\n";
EmitString(o, getClangFullVersion()) << '\n';
o << " <key>diagnostics</key>\n"
" <array>\n";
- for (std::vector<const PathDiagnostic*>::iterator DI=Diags.begin(),
- DE = Diags.end(); DI!=DE; ++DI) {
+ for (std::vector<const PathDiagnostic *>::iterator DI = Diags.begin(),
+ DE = Diags.end();
+ DI != DE; ++DI) {
o << " <dict>\n";
@@ -699,8 +694,8 @@ void PlistDiagnostics::FlushDiagnosticsImpl(
o << " <key>issue_hash_content_of_line_in_context</key>";
PathDiagnosticLocation UPDLoc = D->getUniqueingLoc();
FullSourceLoc L(SM.getExpansionLoc(UPDLoc.isValid()
- ? UPDLoc.asLocation()
- : D->getLocation().asLocation()),
+ ? UPDLoc.asLocation()
+ : D->getLocation().asLocation()),
SM);
const Decl *DeclWithIssue = D->getDeclWithIssue();
EmitString(o, getIssueHash(L, D->getCheckerName(), D->getBugType(),
@@ -714,20 +709,20 @@ void PlistDiagnostics::FlushDiagnosticsImpl(
if (const NamedDecl *ND = dyn_cast<NamedDecl>(DeclWithIssue)) {
StringRef declKind;
switch (ND->getKind()) {
- case Decl::CXXRecord:
- declKind = "C++ class";
- break;
- case Decl::CXXMethod:
- declKind = "C++ method";
- break;
- case Decl::ObjCMethod:
- declKind = "Objective-C method";
- break;
- case Decl::Function:
- declKind = "function";
- break;
- default:
- break;
+ case Decl::CXXRecord:
+ declKind = "C++ class";
+ break;
+ case Decl::CXXMethod:
+ declKind = "C++ method";
+ break;
+ case Decl::ObjCMethod:
+ declKind = "Objective-C method";
+ break;
+ case Decl::Function:
+ declKind = "function";
+ break;
+ default:
+ break;
}
if (!declKind.empty()) {
const std::string &declName = ND->getDeclName().getAsString();
@@ -755,14 +750,13 @@ void PlistDiagnostics::FlushDiagnosticsImpl(
<< L.getExpansionLineNumber() - UFunL.getExpansionLineNumber()
<< "</string>\n";
- // Otherwise, use the location on which the bug is reported.
+ // Otherwise, use the location on which the bug is reported.
} else {
FullSourceLoc FunL(SM.getExpansionLoc(Body->getBeginLoc()), SM);
o << " <key>issue_hash_function_offset</key><string>"
<< L.getExpansionLineNumber() - FunL.getExpansionLineNumber()
<< "</string>\n";
}
-
}
}
}
@@ -777,14 +771,15 @@ void PlistDiagnostics::FlushDiagnosticsImpl(
PDFileEntry::ConsumerFiles *files = filesMade->getFiles(*D);
if (files) {
for (PDFileEntry::ConsumerFiles::const_iterator CI = files->begin(),
- CE = files->end(); CI != CE; ++CI) {
+ CE = files->end();
+ CI != CE; ++CI) {
StringRef newName = CI->first;
if (newName != lastName) {
if (!lastName.empty()) {
o << " </array>\n";
}
lastName = newName;
- o << " <key>" << lastName << "_files</key>\n";
+ o << " <key>" << lastName << "_files</key>\n";
o << " <array>\n";
}
o << " <string>" << CI->second << "</string>\n";
diff --git a/clang/lib/StaticAnalyzer/Core/PrettyStackTraceLocationContext.h b/clang/lib/StaticAnalyzer/Core/PrettyStackTraceLocationContext.h
index c71ee3bd428614..21cebbcb595c34 100644
--- a/clang/lib/StaticAnalyzer/Core/PrettyStackTraceLocationContext.h
+++ b/clang/lib/StaticAnalyzer/Core/PrettyStackTraceLocationContext.h
@@ -27,6 +27,7 @@ namespace ento {
/// \endcode
class PrettyStackTraceLocationContext : public llvm::PrettyStackTraceEntry {
const LocationContext *LCtx;
+
public:
PrettyStackTraceLocationContext(const LocationContext *LC) : LCtx(LC) {
assert(LCtx);
@@ -38,7 +39,7 @@ class PrettyStackTraceLocationContext : public llvm::PrettyStackTraceEntry {
}
};
-} // end ento namespace
-} // end clang namespace
+} // namespace ento
+} // namespace clang
#endif
diff --git a/clang/lib/StaticAnalyzer/Core/ProgramState.cpp b/clang/lib/StaticAnalyzer/Core/ProgramState.cpp
index f12f1a5ac970dd..eece01586ff99f 100644
--- a/clang/lib/StaticAnalyzer/Core/ProgramState.cpp
+++ b/clang/lib/StaticAnalyzer/Core/ProgramState.cpp
@@ -24,17 +24,18 @@
using namespace clang;
using namespace ento;
-namespace clang { namespace ento {
+namespace clang {
+namespace ento {
/// Increments the number of times this state is referenced.
void ProgramStateRetain(const ProgramState *state) {
- ++const_cast<ProgramState*>(state)->refCount;
+ ++const_cast<ProgramState *>(state)->refCount;
}
/// Decrement the number of times this state is referenced.
void ProgramStateRelease(const ProgramState *state) {
assert(state->refCount > 0);
- ProgramState *s = const_cast<ProgramState*>(state);
+ ProgramState *s = const_cast<ProgramState *>(state);
if (--s->refCount == 0) {
ProgramStateManager &Mgr = s->getStateManager();
Mgr.StateSet.RemoveNode(s);
@@ -42,15 +43,12 @@ void ProgramStateRelease(const ProgramState *state) {
Mgr.freeStates.push_back(s);
}
}
-}}
+} // namespace ento
+} // namespace clang
-ProgramState::ProgramState(ProgramStateManager *mgr, const Environment& env,
- StoreRef st, GenericDataMap gdm)
- : stateMgr(mgr),
- Env(env),
- store(st.getStore()),
- GDM(gdm),
- refCount(0) {
+ProgramState::ProgramState(ProgramStateManager *mgr, const Environment &env,
+ StoreRef st, GenericDataMap gdm)
+ : stateMgr(mgr), Env(env), store(st.getStore()), GDM(gdm), refCount(0) {
stateMgr->getStoreManager().incrementReferenceCount(store);
}
@@ -74,17 +72,16 @@ ProgramStateManager::ProgramStateManager(ASTContext &Ctx,
ConstraintManagerCreator CreateCMgr,
llvm::BumpPtrAllocator &alloc,
ExprEngine *ExprEng)
- : Eng(ExprEng), EnvMgr(alloc), GDMFactory(alloc),
- svalBuilder(createSimpleSValBuilder(alloc, Ctx, *this)),
- CallEventMgr(new CallEventManager(alloc)), Alloc(alloc) {
+ : Eng(ExprEng), EnvMgr(alloc), GDMFactory(alloc),
+ svalBuilder(createSimpleSValBuilder(alloc, Ctx, *this)),
+ CallEventMgr(new CallEventManager(alloc)), Alloc(alloc) {
StoreMgr = (*CreateSMgr)(*this);
ConstraintMgr = (*CreateCMgr)(*this, ExprEng);
}
-
ProgramStateManager::~ProgramStateManager() {
- for (GDMContextsTy::iterator I=GDMContexts.begin(), E=GDMContexts.end();
- I!=E; ++I)
+ for (GDMContextsTy::iterator I = GDMContexts.begin(), E = GDMContexts.end();
+ I != E; ++I)
I->second.second(I->second.first);
}
@@ -103,21 +100,20 @@ ProgramStateRef ProgramStateManager::removeDeadBindingsFromEnvironmentAndStore(
NewState.Env = EnvMgr.removeDeadBindings(NewState.Env, SymReaper, state);
// Clean up the store.
- StoreRef newStore = StoreMgr->removeDeadBindings(NewState.getStore(), LCtx,
- SymReaper);
+ StoreRef newStore =
+ StoreMgr->removeDeadBindings(NewState.getStore(), LCtx, SymReaper);
NewState.setStore(newStore);
SymReaper.setReapedStore(newStore);
return getPersistentState(NewState);
}
-ProgramStateRef ProgramState::bindLoc(Loc LV,
- SVal V,
+ProgramStateRef ProgramState::bindLoc(Loc LV, SVal V,
const LocationContext *LCtx,
bool notifyChanges) const {
ProgramStateManager &Mgr = getStateManager();
- ProgramStateRef newState = makeWithStore(Mgr.StoreMgr->Bind(getStore(),
- LV, V));
+ ProgramStateRef newState =
+ makeWithStore(Mgr.StoreMgr->Bind(getStore(), LV, V));
const MemRegion *MR = LV.getAsRegion();
if (MR && notifyChanges)
return Mgr.getOwningEngine().processRegionChange(newState, MR, LCtx);
@@ -147,14 +143,11 @@ ProgramState::bindDefaultZero(SVal loc, const LocationContext *LCtx) const {
typedef ArrayRef<const MemRegion *> RegionList;
typedef ArrayRef<SVal> ValueList;
-ProgramStateRef
-ProgramState::invalidateRegions(RegionList Regions,
- const Expr *E, unsigned Count,
- const LocationContext *LCtx,
- bool CausedByPointerEscape,
- InvalidatedSymbols *IS,
- const CallEvent *Call,
- RegionAndSymbolInvalidationTraits *ITraits) const {
+ProgramStateRef ProgramState::invalidateRegions(
+ RegionList Regions, const Expr *E, unsigned Count,
+ const LocationContext *LCtx, bool CausedByPointerEscape,
+ InvalidatedSymbols *IS, const CallEvent *Call,
+ RegionAndSymbolInvalidationTraits *ITraits) const {
SmallVector<SVal, 8> Values;
for (const MemRegion *Reg : Regions)
Values.push_back(loc::MemRegionVal(Reg));
@@ -163,27 +156,21 @@ ProgramState::invalidateRegions(RegionList Regions,
IS, ITraits, Call);
}
-ProgramStateRef
-ProgramState::invalidateRegions(ValueList Values,
- const Expr *E, unsigned Count,
- const LocationContext *LCtx,
- bool CausedByPointerEscape,
- InvalidatedSymbols *IS,
- const CallEvent *Call,
- RegionAndSymbolInvalidationTraits *ITraits) const {
+ProgramStateRef ProgramState::invalidateRegions(
+ ValueList Values, const Expr *E, unsigned Count,
+ const LocationContext *LCtx, bool CausedByPointerEscape,
+ InvalidatedSymbols *IS, const CallEvent *Call,
+ RegionAndSymbolInvalidationTraits *ITraits) const {
return invalidateRegionsImpl(Values, E, Count, LCtx, CausedByPointerEscape,
IS, ITraits, Call);
}
-ProgramStateRef
-ProgramState::invalidateRegionsImpl(ValueList Values,
- const Expr *E, unsigned Count,
- const LocationContext *LCtx,
- bool CausedByPointerEscape,
- InvalidatedSymbols *IS,
- RegionAndSymbolInvalidationTraits *ITraits,
- const CallEvent *Call) const {
+ProgramStateRef ProgramState::invalidateRegionsImpl(
+ ValueList Values, const Expr *E, unsigned Count,
+ const LocationContext *LCtx, bool CausedByPointerEscape,
+ InvalidatedSymbols *IS, RegionAndSymbolInvalidationTraits *ITraits,
+ const CallEvent *Call) const {
ProgramStateManager &Mgr = getStateManager();
ExprEngine &Eng = Mgr.getOwningEngine();
@@ -197,18 +184,15 @@ ProgramState::invalidateRegionsImpl(ValueList Values,
StoreManager::InvalidatedRegions TopLevelInvalidated;
StoreManager::InvalidatedRegions Invalidated;
- const StoreRef &newStore
- = Mgr.StoreMgr->invalidateRegions(getStore(), Values, E, Count, LCtx, Call,
- *IS, *ITraits, &TopLevelInvalidated,
- &Invalidated);
+ const StoreRef &newStore = Mgr.StoreMgr->invalidateRegions(
+ getStore(), Values, E, Count, LCtx, Call, *IS, *ITraits,
+ &TopLevelInvalidated, &Invalidated);
ProgramStateRef newState = makeWithStore(newStore);
if (CausedByPointerEscape) {
- newState = Eng.notifyCheckersOfPointerEscape(newState, IS,
- TopLevelInvalidated,
- Call,
- *ITraits);
+ newState = Eng.notifyCheckersOfPointerEscape(
+ newState, IS, TopLevelInvalidated, Call, *ITraits);
}
return Eng.processRegionChanges(newState, IS, TopLevelInvalidated,
@@ -218,7 +202,7 @@ ProgramState::invalidateRegionsImpl(ValueList Values,
ProgramStateRef ProgramState::killBinding(Loc LV) const {
Store OldStore = getStore();
const StoreRef &newStore =
- getStateManager().StoreMgr->killBinding(OldStore, LV);
+ getStateManager().StoreMgr->killBinding(OldStore, LV);
if (newStore.getStore() == OldStore)
return this;
@@ -230,7 +214,7 @@ ProgramStateRef
ProgramState::enterStackFrame(const CallEvent &Call,
const StackFrameContext *CalleeCtx) const {
const StoreRef &NewStore =
- getStateManager().StoreMgr->enterStackFrame(getStore(), Call, CalleeCtx);
+ getStateManager().StoreMgr->enterStackFrame(getStore(), Call, CalleeCtx);
return makeWithStore(NewStore);
}
@@ -268,9 +252,8 @@ SVal ProgramState::getSVal(Loc location, QualType T) const {
// to the type of T, which is not always the case (e.g. for void).
if (!T.isNull() && (T->isIntegralOrEnumerationType() || Loc::isLocType(T))) {
if (SymbolRef sym = V.getAsSymbol()) {
- if (const llvm::APSInt *Int = getStateManager()
- .getConstraintManager()
- .getSymVal(this, sym)) {
+ if (const llvm::APSInt *Int =
+ getStateManager().getConstraintManager().getSymVal(this, sym)) {
// FIXME: Because we don't correctly model (yet) sign-extension
// and truncation of symbolic values, we need to convert
// the integer value to the correct signedness and bitwidth.
@@ -299,11 +282,10 @@ SVal ProgramState::getSVal(Loc location, QualType T) const {
}
ProgramStateRef ProgramState::BindExpr(const Stmt *S,
- const LocationContext *LCtx,
- SVal V, bool Invalidate) const{
- Environment NewEnv =
- getStateManager().EnvMgr.bindExpr(Env, EnvironmentEntry(S, LCtx), V,
- Invalidate);
+ const LocationContext *LCtx, SVal V,
+ bool Invalidate) const {
+ Environment NewEnv = getStateManager().EnvMgr.bindExpr(
+ Env, EnvironmentEntry(S, LCtx), V, Invalidate);
if (NewEnv == Env)
return this;
@@ -333,15 +315,14 @@ ProgramState::assumeInBoundDual(DefinedOrUnknownSVal Idx,
nonloc::ConcreteInt Min(BVF.getMinValue(indexTy));
// Adjust the index.
- SVal newIdx = svalBuilder.evalBinOpNN(this, BO_Add,
- Idx.castAs<NonLoc>(), Min, indexTy);
+ SVal newIdx =
+ svalBuilder.evalBinOpNN(this, BO_Add, Idx.castAs<NonLoc>(), Min, indexTy);
if (newIdx.isUnknownOrUndef())
return {this, this};
// Adjust the upper bound.
- SVal newBound =
- svalBuilder.evalBinOpNN(this, BO_Add, UpperBound.castAs<NonLoc>(),
- Min, indexTy);
+ SVal newBound = svalBuilder.evalBinOpNN(
+ this, BO_Add, UpperBound.castAs<NonLoc>(), Min, indexTy);
if (newBound.isUnknownOrUndef())
return {this, this};
@@ -391,18 +372,18 @@ ConditionTruthVal ProgramState::isNull(SVal V) const {
return getStateManager().ConstraintMgr->isNull(this, Sym);
}
-ProgramStateRef ProgramStateManager::getInitialState(const LocationContext *InitLoc) {
- ProgramState State(this,
- EnvMgr.getInitialEnvironment(),
- StoreMgr->getInitialStore(InitLoc),
- GDMFactory.getEmptyMap());
+ProgramStateRef
+ProgramStateManager::getInitialState(const LocationContext *InitLoc) {
+ ProgramState State(this, EnvMgr.getInitialEnvironment(),
+ StoreMgr->getInitialStore(InitLoc),
+ GDMFactory.getEmptyMap());
return getPersistentState(State);
}
-ProgramStateRef ProgramStateManager::getPersistentStateWithGDM(
- ProgramStateRef FromState,
- ProgramStateRef GDMState) {
+ProgramStateRef
+ProgramStateManager::getPersistentStateWithGDM(ProgramStateRef FromState,
+ ProgramStateRef GDMState) {
ProgramState NewState(*FromState);
NewState.GDM = GDMState->GDM;
return getPersistentState(NewState);
@@ -421,8 +402,7 @@ ProgramStateRef ProgramStateManager::getPersistentState(ProgramState &State) {
if (!freeStates.empty()) {
newState = freeStates.back();
freeStates.pop_back();
- }
- else {
+ } else {
newState = Alloc.Allocate<ProgramState>();
}
new (newState) ProgramState(State);
@@ -487,11 +467,9 @@ void ProgramState::printDOT(raw_ostream &Out, const LocationContext *LCtx,
printJson(Out, LCtx, /*NL=*/"\\l", Space, /*IsDot=*/true);
}
-LLVM_DUMP_METHOD void ProgramState::dump() const {
- printJson(llvm::errs());
-}
+LLVM_DUMP_METHOD void ProgramState::dump() const { printJson(llvm::errs()); }
-AnalysisManager& ProgramState::getAnalysisManager() const {
+AnalysisManager &ProgramState::getAnalysisManager() const {
return stateMgr->getOwningEngine().getAnalysisManager();
}
@@ -499,16 +477,13 @@ AnalysisManager& ProgramState::getAnalysisManager() const {
// Generic Data Map.
//===----------------------------------------------------------------------===//
-void *const* ProgramState::FindGDM(void *K) const {
- return GDM.lookup(K);
-}
+void *const *ProgramState::FindGDM(void *K) const { return GDM.lookup(K); }
-void*
-ProgramStateManager::FindGDMContext(void *K,
- void *(*CreateContext)(llvm::BumpPtrAllocator&),
- void (*DeleteContext)(void*)) {
+void *ProgramStateManager::FindGDMContext(
+ void *K, void *(*CreateContext)(llvm::BumpPtrAllocator &),
+ void (*DeleteContext)(void *)) {
- std::pair<void*, void (*)(void*)>& p = GDMContexts[K];
+ std::pair<void *, void (*)(void *)> &p = GDMContexts[K];
if (!p.first) {
p.first = CreateContext(Alloc);
p.second = DeleteContext;
@@ -517,7 +492,8 @@ ProgramStateManager::FindGDMContext(void *K,
return p.first;
}
-ProgramStateRef ProgramStateManager::addGDM(ProgramStateRef St, void *Key, void *Data){
+ProgramStateRef ProgramStateManager::addGDM(ProgramStateRef St, void *Key,
+ void *Data) {
ProgramState::GenericDataMap M1 = St->getGDM();
ProgramState::GenericDataMap M2 = GDMFactory.add(M1, Key, Data);
@@ -529,7 +505,8 @@ ProgramStateRef ProgramStateManager::addGDM(ProgramStateRef St, void *Key, void
return getPersistentState(NewSt);
}
-ProgramStateRef ProgramStateManager::removeGDM(ProgramStateRef state, void *Key) {
+ProgramStateRef ProgramStateManager::removeGDM(ProgramStateRef state,
+ void *Key) {
ProgramState::GenericDataMap OldM = state->getGDM();
ProgramState::GenericDataMap NewM = GDMFactory.remove(OldM, Key);
@@ -636,7 +613,8 @@ bool ScanReachableSymbols::scan(const MemRegion *R) {
return true;
}
-bool ProgramState::scanReachableSymbols(SVal val, SymbolVisitor& visitor) const {
+bool ProgramState::scanReachableSymbols(SVal val,
+ SymbolVisitor &visitor) const {
ScanReachableSymbols S(this, visitor);
return S.scan(val);
}
diff --git a/clang/lib/StaticAnalyzer/Core/RangedConstraintManager.cpp b/clang/lib/StaticAnalyzer/Core/RangedConstraintManager.cpp
index 4bbe933be2129e..e11d45532f2a2f 100644
--- a/clang/lib/StaticAnalyzer/Core/RangedConstraintManager.cpp
+++ b/clang/lib/StaticAnalyzer/Core/RangedConstraintManager.cpp
@@ -11,8 +11,8 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
namespace clang {
diff --git a/clang/lib/StaticAnalyzer/Core/RegionStore.cpp b/clang/lib/StaticAnalyzer/Core/RegionStore.cpp
index da9a1a1a4d1f69..510bc33c354fd0 100644
--- a/clang/lib/StaticAnalyzer/Core/RegionStore.cpp
+++ b/clang/lib/StaticAnalyzer/Core/RegionStore.cpp
@@ -44,6 +44,7 @@ namespace {
class BindingKey {
public:
enum Kind { Default = 0x0, Direct = 0x1 };
+
private:
enum { Symbolic = 0x2 };
@@ -53,22 +54,22 @@ class BindingKey {
/// Create a key for a binding to region \p r, which has a symbolic offset
/// from region \p Base.
explicit BindingKey(const SubRegion *r, const SubRegion *Base, Kind k)
- : P(r, k | Symbolic), Data(reinterpret_cast<uintptr_t>(Base)) {
+ : P(r, k | Symbolic), Data(reinterpret_cast<uintptr_t>(Base)) {
assert(r && Base && "Must have known regions.");
assert(getConcreteOffsetRegion() == Base && "Failed to store base region");
}
/// Create a key for a binding at \p offset from base region \p r.
explicit BindingKey(const MemRegion *r, uint64_t offset, Kind k)
- : P(r, k), Data(offset) {
+ : P(r, k), Data(offset) {
assert(r && "Must have known regions.");
assert(getOffset() == offset && "Failed to store offset");
assert((r == r->getBaseRegion() ||
isa<ObjCIvarRegion, CXXDerivedObjectRegion>(r)) &&
"Not a base");
}
-public:
+public:
bool isDirect() const { return P.getInt() & Direct; }
bool hasSymbolicOffset() const { return P.getInt() & Symbolic; }
@@ -89,7 +90,7 @@ class BindingKey {
return getRegion()->getBaseRegion();
}
- void Profile(llvm::FoldingSetNodeID& ID) const {
+ void Profile(llvm::FoldingSetNodeID &ID) const {
ID.AddPointer(P.getOpaqueValue());
ID.AddInteger(Data);
}
@@ -105,8 +106,7 @@ class BindingKey {
}
bool operator==(const BindingKey &X) const {
- return P.getOpaqueValue() == X.P.getOpaqueValue() &&
- Data == X.Data;
+ return P.getOpaqueValue() == X.P.getOpaqueValue() && Data == X.Data;
}
LLVM_DUMP_METHOD void dump() const;
@@ -144,16 +144,15 @@ void BindingKey::dump() const { llvm::errs() << *this; }
// Actual Store type.
//===----------------------------------------------------------------------===//
-typedef llvm::ImmutableMap<BindingKey, SVal> ClusterBindings;
+typedef llvm::ImmutableMap<BindingKey, SVal> ClusterBindings;
typedef llvm::ImmutableMapRef<BindingKey, SVal> ClusterBindingsRef;
typedef std::pair<BindingKey, SVal> BindingPair;
-typedef llvm::ImmutableMap<const MemRegion *, ClusterBindings>
- RegionBindings;
+typedef llvm::ImmutableMap<const MemRegion *, ClusterBindings> RegionBindings;
namespace {
-class RegionBindingsRef : public llvm::ImmutableMapRef<const MemRegion *,
- ClusterBindings> {
+class RegionBindingsRef
+ : public llvm::ImmutableMapRef<const MemRegion *, ClusterBindings> {
ClusterBindings::Factory *CBFactory;
// This flag indicates whether the current bindings are within the analysis
@@ -168,18 +167,15 @@ class RegionBindingsRef : public llvm::ImmutableMapRef<const MemRegion *,
bool IsMainAnalysis;
public:
- typedef llvm::ImmutableMapRef<const MemRegion *, ClusterBindings>
- ParentTy;
+ typedef llvm::ImmutableMapRef<const MemRegion *, ClusterBindings> ParentTy;
RegionBindingsRef(ClusterBindings::Factory &CBFactory,
const RegionBindings::TreeTy *T,
- RegionBindings::TreeTy::Factory *F,
- bool IsMainAnalysis)
+ RegionBindings::TreeTy::Factory *F, bool IsMainAnalysis)
: llvm::ImmutableMapRef<const MemRegion *, ClusterBindings>(T, F),
CBFactory(&CBFactory), IsMainAnalysis(IsMainAnalysis) {}
- RegionBindingsRef(const ParentTy &P,
- ClusterBindings::Factory &CBFactory,
+ RegionBindingsRef(const ParentTy &P, ClusterBindings::Factory &CBFactory,
bool IsMainAnalysis)
: llvm::ImmutableMapRef<const MemRegion *, ClusterBindings>(P),
CBFactory(&CBFactory), IsMainAnalysis(IsMainAnalysis) {}
@@ -196,8 +192,8 @@ class RegionBindingsRef : public llvm::ImmutableMapRef<const MemRegion *,
RegionBindingsRef addBinding(BindingKey K, SVal V) const;
- RegionBindingsRef addBinding(const MemRegion *R,
- BindingKey::Kind k, SVal V) const;
+ RegionBindingsRef addBinding(const MemRegion *R, BindingKey::Kind k,
+ SVal V) const;
const SVal *lookup(BindingKey K) const;
const SVal *lookup(const MemRegion *R, BindingKey::Kind k) const;
@@ -205,12 +201,11 @@ class RegionBindingsRef : public llvm::ImmutableMapRef<const MemRegion *,
RegionBindingsRef removeBinding(BindingKey K);
- RegionBindingsRef removeBinding(const MemRegion *R,
- BindingKey::Kind k);
+ RegionBindingsRef removeBinding(const MemRegion *R, BindingKey::Kind k);
RegionBindingsRef removeBinding(const MemRegion *R) {
- return removeBinding(R, BindingKey::Direct).
- removeBinding(R, BindingKey::Default);
+ return removeBinding(R, BindingKey::Direct)
+ .removeBinding(R, BindingKey::Default);
}
std::optional<SVal> getDirectBinding(const MemRegion *R) const;
@@ -226,9 +221,7 @@ class RegionBindingsRef : public llvm::ImmutableMapRef<const MemRegion *,
return reinterpret_cast<Store>(Ptr.getOpaqueValue());
}
- bool isMainAnalysis() const {
- return IsMainAnalysis;
- }
+ bool isMainAnalysis() const { return IsMainAnalysis; }
void printJson(raw_ostream &Out, const char *NL = "\n",
unsigned int Space = 0, bool IsDot = false) const {
@@ -262,7 +255,7 @@ class RegionBindingsRef : public llvm::ImmutableMapRef<const MemRegion *,
};
} // end anonymous namespace
-typedef const RegionBindingsRef& RegionBindingsConstRef;
+typedef const RegionBindingsRef &RegionBindingsConstRef;
std::optional<SVal>
RegionBindingsRef::getDirectBinding(const MemRegion *R) const {
@@ -287,7 +280,6 @@ RegionBindingsRef RegionBindingsRef::addBinding(BindingKey K, SVal V) const {
return add(Base, NewCluster);
}
-
RegionBindingsRef RegionBindingsRef::addBinding(const MemRegion *R,
BindingKey::Kind k,
SVal V) const {
@@ -319,7 +311,7 @@ RegionBindingsRef RegionBindingsRef::removeBinding(BindingKey K) {
}
RegionBindingsRef RegionBindingsRef::removeBinding(const MemRegion *R,
- BindingKey::Kind k){
+ BindingKey::Kind k) {
return removeBinding(BindingKey::Make(R, k));
}
@@ -336,9 +328,10 @@ class RegionStoreManager : public StoreManager {
mutable ClusterBindings::Factory CBFactory;
typedef std::vector<SVal> SValListTy;
+
private:
- typedef llvm::DenseMap<const LazyCompoundValData *,
- SValListTy> LazyBindingsMapTy;
+ typedef llvm::DenseMap<const LazyCompoundValData *, SValListTy>
+ LazyBindingsMapTy;
LazyBindingsMapTy LazyBindingsMap;
/// The largest number of fields a struct can have and still be
@@ -363,8 +356,7 @@ class RegionStoreManager : public StoreManager {
/// A helper used to populate the work list with the given set of
/// regions.
- void populateWorkList(InvalidateRegionsWorker &W,
- ArrayRef<SVal> Values,
+ void populateWorkList(InvalidateRegionsWorker &W, ArrayRef<SVal> Values,
InvalidatedRegions *TopLevelRegions);
public:
@@ -397,27 +389,25 @@ class RegionStoreManager : public StoreManager {
bool IsMainAnalysis = false;
if (const auto *FD = dyn_cast<FunctionDecl>(InitLoc->getDecl()))
IsMainAnalysis = FD->isMain() && !Ctx.getLangOpts().CPlusPlus;
- return StoreRef(RegionBindingsRef(
- RegionBindingsRef::ParentTy(RBFactory.getEmptyMap(), RBFactory),
- CBFactory, IsMainAnalysis).asStore(), *this);
+ return StoreRef(RegionBindingsRef(RegionBindingsRef::ParentTy(
+ RBFactory.getEmptyMap(), RBFactory),
+ CBFactory, IsMainAnalysis)
+ .asStore(),
+ *this);
}
//===-------------------------------------------------------------------===//
// Binding values to regions.
//===-------------------------------------------------------------------===//
- RegionBindingsRef invalidateGlobalRegion(MemRegion::Kind K,
- const Expr *Ex,
+ RegionBindingsRef invalidateGlobalRegion(MemRegion::Kind K, const Expr *Ex,
unsigned Count,
const LocationContext *LCtx,
RegionBindingsRef B,
InvalidatedRegions *Invalidated);
- StoreRef invalidateRegions(Store store,
- ArrayRef<SVal> Values,
- const Expr *E, unsigned Count,
- const LocationContext *LCtx,
- const CallEvent *Call,
- InvalidatedSymbols &IS,
+ StoreRef invalidateRegions(Store store, ArrayRef<SVal> Values, const Expr *E,
+ unsigned Count, const LocationContext *LCtx,
+ const CallEvent *Call, InvalidatedSymbols &IS,
RegionAndSymbolInvalidationTraits &ITraits,
InvalidatedRegions *Invalidated,
InvalidatedRegions *InvalidatedTopLevel) override;
@@ -438,7 +428,6 @@ class RegionStoreManager : public StoreManager {
QualType ElemT);
public: // Part of public interface to class.
-
StoreRef Bind(Store store, Loc LV, SVal V) override {
return StoreRef(bind(getRegionBindings(store), LV, V).asStore(), *this);
}
@@ -497,25 +486,23 @@ class RegionStoreManager : public StoreManager {
/// BindStruct - Bind a compound value to a structure.
RegionBindingsRef bindStruct(RegionBindingsConstRef B,
- const TypedValueRegion* R, SVal V);
+ const TypedValueRegion *R, SVal V);
/// BindVector - Bind a compound value to a vector.
RegionBindingsRef bindVector(RegionBindingsConstRef B,
- const TypedValueRegion* R, SVal V);
+ const TypedValueRegion *R, SVal V);
std::optional<RegionBindingsRef>
tryBindSmallArray(RegionBindingsConstRef B, const TypedValueRegion *R,
const ArrayType *AT, nonloc::LazyCompoundVal LCV);
RegionBindingsRef bindArray(RegionBindingsConstRef B,
- const TypedValueRegion* R,
- SVal V);
+ const TypedValueRegion *R, SVal V);
/// Clears out all bindings in the given region and assigns a new value
/// as a Default binding.
RegionBindingsRef bindAggregate(RegionBindingsConstRef B,
- const TypedRegion *R,
- SVal DefaultVal);
+ const TypedRegion *R, SVal DefaultVal);
/// Create a new store with the specified binding removed.
/// \param ST the original store, that is the basis for the new store.
@@ -625,7 +612,7 @@ class RegionStoreManager : public StoreManager {
/// removeDeadBindings - Scans the RegionStore of 'state' for dead values.
/// It returns a new Store with these values removed.
StoreRef removeDeadBindings(Store store, const StackFrameContext *LCtx,
- SymbolReaper& SymReaper) override;
+ SymbolReaper &SymReaper) override;
//===------------------------------------------------------------------===//
// Utility methods.
@@ -637,14 +624,13 @@ class RegionStoreManager : public StoreManager {
return RegionBindingsRef(
CBFactory,
static_cast<const RegionBindings::TreeTy *>(Ptr.getPointer()),
- RBFactory.getTreeFactory(),
- Ptr.getInt());
+ RBFactory.getTreeFactory(), Ptr.getInt());
}
void printJson(raw_ostream &Out, Store S, const char *NL = "\n",
unsigned int Space = 0, bool IsDot = false) const override;
- void iterBindings(Store store, BindingsHandler& f) override {
+ void iterBindings(Store store, BindingsHandler &f) override {
RegionBindingsRef B = getRegionBindings(store);
for (const auto &[Region, Cluster] : B) {
for (const auto &[Key, Value] : Cluster) {
@@ -687,11 +673,10 @@ enum GlobalsFilterKind {
GFK_All
};
-template <typename DERIVED>
-class ClusterAnalysis {
+template <typename DERIVED> class ClusterAnalysis {
protected:
typedef llvm::DenseMap<const MemRegion *, const ClusterBindings *> ClusterMap;
- typedef const MemRegion * WorkListElement;
+ typedef const MemRegion *WorkListElement;
typedef SmallVector<WorkListElement, 10> WorkList;
llvm::SmallPtrSet<const ClusterBindings *, 16> Visited;
@@ -704,18 +689,13 @@ class ClusterAnalysis {
RegionBindingsRef B;
-
protected:
- const ClusterBindings *getCluster(const MemRegion *R) {
- return B.lookup(R);
- }
+ const ClusterBindings *getCluster(const MemRegion *R) { return B.lookup(R); }
/// Returns true if all clusters in the given memspace should be initially
/// included in the cluster analysis. Subclasses may provide their
/// own implementation.
- bool includeEntireMemorySpace(const MemRegion *Base) {
- return false;
- }
+ bool includeEntireMemorySpace(const MemRegion *Base) { return false; }
public:
ClusterAnalysis(RegionStoreManager &rm, ProgramStateManager &StateMgr,
@@ -725,23 +705,21 @@ class ClusterAnalysis {
RegionBindingsRef getRegionBindings() const { return B; }
- bool isVisited(const MemRegion *R) {
- return Visited.count(getCluster(R));
- }
+ bool isVisited(const MemRegion *R) { return Visited.count(getCluster(R)); }
void GenerateClusters() {
// Scan the entire set of bindings and record the region clusters.
- for (RegionBindingsRef::iterator RI = B.begin(), RE = B.end();
- RI != RE; ++RI){
+ for (RegionBindingsRef::iterator RI = B.begin(), RE = B.end(); RI != RE;
+ ++RI) {
const MemRegion *Base = RI.getKey();
const ClusterBindings &Cluster = RI.getData();
assert(!Cluster.isEmpty() && "Empty clusters should be removed");
- static_cast<DERIVED*>(this)->VisitAddedToCluster(Base, Cluster);
+ static_cast<DERIVED *>(this)->VisitAddedToCluster(Base, Cluster);
// If the base's memspace should be entirely invalidated, add the cluster
// to the workspace up front.
- if (static_cast<DERIVED*>(this)->includeEntireMemorySpace(Base))
+ if (static_cast<DERIVED *>(this)->includeEntireMemorySpace(Base))
AddToWorkList(WorkListElement(Base), &Cluster);
}
}
@@ -754,7 +732,7 @@ class ClusterAnalysis {
}
bool AddToWorkList(const MemRegion *R) {
- return static_cast<DERIVED*>(this)->AddToWorkList(R);
+ return static_cast<DERIVED *>(this)->AddToWorkList(R);
}
void RunWorkList() {
@@ -762,7 +740,7 @@ class ClusterAnalysis {
WorkListElement E = WL.pop_back_val();
const MemRegion *BaseR = E;
- static_cast<DERIVED*>(this)->VisitCluster(BaseR, getCluster(BaseR));
+ static_cast<DERIVED *>(this)->VisitCluster(BaseR, getCluster(BaseR));
}
}
@@ -771,10 +749,10 @@ class ClusterAnalysis {
void VisitCluster(const MemRegion *BaseR, const ClusterBindings *C,
bool Flag) {
- static_cast<DERIVED*>(this)->VisitCluster(BaseR, C);
+ static_cast<DERIVED *>(this)->VisitCluster(BaseR, C);
}
};
-}
+} // namespace
//===----------------------------------------------------------------------===//
// Binding invalidation.
@@ -831,8 +809,7 @@ static bool isCompatibleWithFields(BindingKey K, const FieldVector &Fields) {
ptrdiff_t Delta = FieldsInBindingKey.size() - Fields.size();
if (Delta >= 0)
return std::equal(FieldsInBindingKey.begin() + Delta,
- FieldsInBindingKey.end(),
- Fields.begin());
+ FieldsInBindingKey.end(), Fields.begin());
else
return std::equal(FieldsInBindingKey.begin(), FieldsInBindingKey.end(),
Fields.begin() - Delta);
@@ -847,11 +824,11 @@ static bool isCompatibleWithFields(BindingKey K, const FieldVector &Fields) {
/// The \p IncludeAllDefaultBindings parameter specifies whether to include
/// default bindings that may extend beyond \p Top itself, e.g. if \p Top is
/// an aggregate within a larger aggregate with a default binding.
-static void
-collectSubRegionBindings(SmallVectorImpl<BindingPair> &Bindings,
- SValBuilder &SVB, const ClusterBindings &Cluster,
- const SubRegion *Top, BindingKey TopKey,
- bool IncludeAllDefaultBindings) {
+static void collectSubRegionBindings(SmallVectorImpl<BindingPair> &Bindings,
+ SValBuilder &SVB,
+ const ClusterBindings &Cluster,
+ const SubRegion *Top, BindingKey TopKey,
+ bool IncludeAllDefaultBindings) {
FieldVector FieldsInSymbolicSubregions;
if (TopKey.hasSymbolicOffset()) {
getSymbolicOffsetFields(TopKey, FieldsInSymbolicSubregions);
@@ -918,10 +895,11 @@ collectSubRegionBindings(SmallVectorImpl<BindingPair> &Bindings,
}
}
-static void
-collectSubRegionBindings(SmallVectorImpl<BindingPair> &Bindings,
- SValBuilder &SVB, const ClusterBindings &Cluster,
- const SubRegion *Top, bool IncludeAllDefaultBindings) {
+static void collectSubRegionBindings(SmallVectorImpl<BindingPair> &Bindings,
+ SValBuilder &SVB,
+ const ClusterBindings &Cluster,
+ const SubRegion *Top,
+ bool IncludeAllDefaultBindings) {
collectSubRegionBindings(Bindings, SVB, Cluster, Top,
BindingKey::Make(Top, BindingKey::Default),
IncludeAllDefaultBindings);
@@ -973,8 +951,8 @@ RegionStoreManager::removeSubRegionBindings(RegionBindingsConstRef B,
}
namespace {
-class InvalidateRegionsWorker : public ClusterAnalysis<InvalidateRegionsWorker>
-{
+class InvalidateRegionsWorker
+ : public ClusterAnalysis<InvalidateRegionsWorker> {
const Expr *Ex;
unsigned Count;
const LocationContext *LCtx;
@@ -982,19 +960,17 @@ class InvalidateRegionsWorker : public ClusterAnalysis<InvalidateRegionsWorker>
RegionAndSymbolInvalidationTraits &ITraits;
StoreManager::InvalidatedRegions *Regions;
GlobalsFilterKind GlobalsFilter;
+
public:
- InvalidateRegionsWorker(RegionStoreManager &rm,
- ProgramStateManager &stateMgr,
- RegionBindingsRef b,
- const Expr *ex, unsigned count,
- const LocationContext *lctx,
- InvalidatedSymbols &is,
+ InvalidateRegionsWorker(RegionStoreManager &rm, ProgramStateManager &stateMgr,
+ RegionBindingsRef b, const Expr *ex, unsigned count,
+ const LocationContext *lctx, InvalidatedSymbols &is,
RegionAndSymbolInvalidationTraits &ITraitsIn,
StoreManager::InvalidatedRegions *r,
GlobalsFilterKind GFK)
- : ClusterAnalysis<InvalidateRegionsWorker>(rm, stateMgr, b),
- Ex(ex), Count(count), LCtx(lctx), IS(is), ITraits(ITraitsIn), Regions(r),
- GlobalsFilter(GFK) {}
+ : ClusterAnalysis<InvalidateRegionsWorker>(rm, stateMgr, b), Ex(ex),
+ Count(count), LCtx(lctx), IS(is), ITraits(ITraitsIn), Regions(r),
+ GlobalsFilter(GFK) {}
void VisitCluster(const MemRegion *baseR, const ClusterBindings *C);
void VisitBinding(SVal V);
@@ -1011,7 +987,7 @@ class InvalidateRegionsWorker : public ClusterAnalysis<InvalidateRegionsWorker>
/// regions specially included at the start of invalidation.
bool isInitiallyIncludedGlobalRegion(const MemRegion *R);
};
-}
+} // namespace
bool InvalidateRegionsWorker::AddToWorkList(const MemRegion *R) {
bool doNotInvalidateSuperRegion = ITraits.hasTrait(
@@ -1047,9 +1023,8 @@ void InvalidateRegionsWorker::VisitBinding(SVal V) {
void InvalidateRegionsWorker::VisitCluster(const MemRegion *baseR,
const ClusterBindings *C) {
- bool PreserveRegionsContents =
- ITraits.hasTrait(baseR,
- RegionAndSymbolInvalidationTraits::TK_PreserveContents);
+ bool PreserveRegionsContents = ITraits.hasTrait(
+ baseR, RegionAndSymbolInvalidationTraits::TK_PreserveContents);
if (C) {
for (SVal Val : llvm::make_second_range(*C))
@@ -1071,7 +1046,7 @@ void InvalidateRegionsWorker::VisitCluster(const MemRegion *baseR,
const char *DeclBind = "DeclBind";
StatementMatcher RefToStatic = stmt(hasDescendant(declRefExpr(
- to(varDecl(hasStaticStorageDuration()).bind(DeclBind)))));
+ to(varDecl(hasStaticStorageDuration()).bind(DeclBind)))));
auto Matches =
match(RefToStatic, *RD->getLambdaCallOperator()->getBody(),
RD->getASTContext());
@@ -1094,8 +1069,7 @@ void InvalidateRegionsWorker::VisitCluster(const MemRegion *baseR,
const VarDecl *VD = VR->getDecl();
if (VD->hasAttr<BlocksAttr>() || !VD->hasLocalStorage()) {
AddToWorkList(VR);
- }
- else if (Loc::isLocType(VR->getValueType())) {
+ } else if (Loc::isLocType(VR->getValueType())) {
// Map the current bindings to a Store to retrieve the value
// of the binding. If that binding itself is a region, we should
// invalidate that region. This is because a block may capture
@@ -1127,7 +1101,7 @@ void InvalidateRegionsWorker::VisitCluster(const MemRegion *baseR,
// Invalidate the region by setting its default value to
// conjured symbol. The type of the symbol is irrelevant.
DefinedOrUnknownSVal V =
- svalBuilder.conjureSymbolVal(baseR, Ex, LCtx, Ctx.IntTy, Count);
+ svalBuilder.conjureSymbolVal(baseR, Ex, LCtx, Ctx.IntTy, Count);
B = B.addBinding(baseR, BindingKey::Default, V);
return;
}
@@ -1148,8 +1122,8 @@ void InvalidateRegionsWorker::VisitCluster(const MemRegion *baseR,
if (T->isRecordType()) {
// Invalidate the region by setting its default value to
// conjured symbol. The type of the symbol is irrelevant.
- DefinedOrUnknownSVal V = svalBuilder.conjureSymbolVal(baseR, Ex, LCtx,
- Ctx.IntTy, Count);
+ DefinedOrUnknownSVal V =
+ svalBuilder.conjureSymbolVal(baseR, Ex, LCtx, Ctx.IntTy, Count);
B = B.addBinding(baseR, BindingKey::Default, V);
return;
}
@@ -1215,16 +1189,15 @@ void InvalidateRegionsWorker::VisitCluster(const MemRegion *baseR,
}
}
conjure_default:
- // Set the default value of the array to conjured symbol.
- DefinedOrUnknownSVal V =
- svalBuilder.conjureSymbolVal(baseR, Ex, LCtx,
- AT->getElementType(), Count);
+ // Set the default value of the array to conjured symbol.
+ DefinedOrUnknownSVal V = svalBuilder.conjureSymbolVal(
+ baseR, Ex, LCtx, AT->getElementType(), Count);
B = B.addBinding(baseR, BindingKey::Default, V);
return;
}
- DefinedOrUnknownSVal V = svalBuilder.conjureSymbolVal(baseR, Ex, LCtx,
- T,Count);
+ DefinedOrUnknownSVal V =
+ svalBuilder.conjureSymbolVal(baseR, Ex, LCtx, T, Count);
assert(SymbolManager::canSymbolicate(T) || V.isUnknown());
B = B.addBinding(baseR, BindingKey::Direct, V);
}
@@ -1252,22 +1225,19 @@ bool InvalidateRegionsWorker::includeEntireMemorySpace(const MemRegion *Base) {
RegionAndSymbolInvalidationTraits::TK_EntireMemSpace);
}
-RegionBindingsRef
-RegionStoreManager::invalidateGlobalRegion(MemRegion::Kind K,
- const Expr *Ex,
- unsigned Count,
- const LocationContext *LCtx,
- RegionBindingsRef B,
- InvalidatedRegions *Invalidated) {
+RegionBindingsRef RegionStoreManager::invalidateGlobalRegion(
+ MemRegion::Kind K, const Expr *Ex, unsigned Count,
+ const LocationContext *LCtx, RegionBindingsRef B,
+ InvalidatedRegions *Invalidated) {
// Bind the globals memory space to a new symbol that we will use to derive
// the bindings for all globals.
const GlobalsSpaceRegion *GS = MRMgr.getGlobalsRegion(K);
- SVal V = svalBuilder.conjureSymbolVal(/* symbolTag = */ (const void*) GS, Ex, LCtx,
- /* type does not matter */ Ctx.IntTy,
- Count);
+ SVal V =
+ svalBuilder.conjureSymbolVal(/* symbolTag = */ (const void *)GS, Ex, LCtx,
+ /* type does not matter */ Ctx.IntTy, Count);
- B = B.removeBinding(GS)
- .addBinding(BindingKey::Make(GS, BindingKey::Default), V);
+ B = B.removeBinding(GS).addBinding(BindingKey::Make(GS, BindingKey::Default),
+ V);
// Even if there are no bindings in the global scope, we still need to
// record that we touched it.
@@ -1298,16 +1268,11 @@ void RegionStoreManager::populateWorkList(InvalidateRegionsWorker &W,
}
}
-StoreRef
-RegionStoreManager::invalidateRegions(Store store,
- ArrayRef<SVal> Values,
- const Expr *Ex, unsigned Count,
- const LocationContext *LCtx,
- const CallEvent *Call,
- InvalidatedSymbols &IS,
- RegionAndSymbolInvalidationTraits &ITraits,
- InvalidatedRegions *TopLevelRegions,
- InvalidatedRegions *Invalidated) {
+StoreRef RegionStoreManager::invalidateRegions(
+ Store store, ArrayRef<SVal> Values, const Expr *Ex, unsigned Count,
+ const LocationContext *LCtx, const CallEvent *Call, InvalidatedSymbols &IS,
+ RegionAndSymbolInvalidationTraits &ITraits,
+ InvalidatedRegions *TopLevelRegions, InvalidatedRegions *Invalidated) {
GlobalsFilterKind GlobalsFilter;
if (Call) {
if (Call->isInSystemHeader())
@@ -1339,12 +1304,12 @@ RegionStoreManager::invalidateRegions(Store store,
// TODO: This could possibly be more precise with modules.
switch (GlobalsFilter) {
case GFK_All:
- B = invalidateGlobalRegion(MemRegion::GlobalInternalSpaceRegionKind,
- Ex, Count, LCtx, B, Invalidated);
+ B = invalidateGlobalRegion(MemRegion::GlobalInternalSpaceRegionKind, Ex,
+ Count, LCtx, B, Invalidated);
[[fallthrough]];
case GFK_SystemOnly:
- B = invalidateGlobalRegion(MemRegion::GlobalSystemSpaceRegionKind,
- Ex, Count, LCtx, B, Invalidated);
+ B = invalidateGlobalRegion(MemRegion::GlobalSystemSpaceRegionKind, Ex,
+ Count, LCtx, B, Invalidated);
[[fallthrough]];
case GFK_None:
break;
@@ -1380,7 +1345,8 @@ SVal RegionStoreManager::ArrayToPointer(Loc Array, QualType T) {
// Loading values from regions.
//===----------------------------------------------------------------------===//
-SVal RegionStoreManager::getBinding(RegionBindingsConstRef B, Loc L, QualType T) {
+SVal RegionStoreManager::getBinding(RegionBindingsConstRef B, Loc L,
+ QualType T) {
assert(!isa<UnknownVal>(L) && "location unknown");
assert(!isa<UndefinedVal>(L) && "location undefined");
@@ -1454,10 +1420,10 @@ SVal RegionStoreManager::getBinding(RegionBindingsConstRef B, Loc L, QualType T)
if (RTy->isVectorType())
return UnknownVal();
- if (const FieldRegion* FR = dyn_cast<FieldRegion>(R))
+ if (const FieldRegion *FR = dyn_cast<FieldRegion>(R))
return svalBuilder.evalCast(getBindingForField(B, FR), T, QualType{});
- if (const ElementRegion* ER = dyn_cast<ElementRegion>(R)) {
+ if (const ElementRegion *ER = dyn_cast<ElementRegion>(R)) {
// FIXME: Here we actually perform an implicit conversion from the loaded
// value to the element type. Eventually we want to compose these values
// more intelligently. For example, an 'element' can encompass multiple
@@ -1540,8 +1506,7 @@ getExistingLazyBinding(SValBuilder &SVB, RegionBindingsConstRef B,
// If the LCV is for a subregion, the types might not match, and we shouldn't
// reuse the binding.
QualType RegionTy = getUnderlyingType(R);
- if (!RegionTy.isNull() &&
- !RegionTy->isVoidPointerType()) {
+ if (!RegionTy.isNull() && !RegionTy->isVoidPointerType()) {
QualType SourceRegionTy = LCV->getRegion()->getValueType();
if (!SVB.getContext().hasSameUnqualifiedType(RegionTy, SourceRegionTy))
return std::nullopt;
@@ -1562,8 +1527,8 @@ getExistingLazyBinding(SValBuilder &SVB, RegionBindingsConstRef B,
std::pair<Store, const SubRegion *>
RegionStoreManager::findLazyBinding(RegionBindingsConstRef B,
- const SubRegion *R,
- const SubRegion *originalRegion) {
+ const SubRegion *R,
+ const SubRegion *originalRegion) {
if (originalRegion != R) {
if (std::optional<nonloc::LazyCompoundVal> V =
getExistingLazyBinding(svalBuilder, B, R, true))
@@ -1582,21 +1547,21 @@ RegionStoreManager::findLazyBinding(RegionBindingsConstRef B,
} else if (const FieldRegion *FR = dyn_cast<FieldRegion>(R)) {
Result = findLazyBinding(B, cast<SubRegion>(FR->getSuperRegion()),
- originalRegion);
+ originalRegion);
if (Result.second)
Result.second = MRMgr.getFieldRegionWithSuper(FR, Result.second);
} else if (const CXXBaseObjectRegion *BaseReg =
- dyn_cast<CXXBaseObjectRegion>(R)) {
+ dyn_cast<CXXBaseObjectRegion>(R)) {
// C++ base object region is another kind of region that we should blast
// through to look for lazy compound value. It is like a field region.
Result = findLazyBinding(B, cast<SubRegion>(BaseReg->getSuperRegion()),
originalRegion);
if (Result.second)
- Result.second = MRMgr.getCXXBaseObjectRegionWithSuper(BaseReg,
- Result.second);
+ Result.second =
+ MRMgr.getCXXBaseObjectRegionWithSuper(BaseReg, Result.second);
}
return Result;
@@ -1906,12 +1871,12 @@ static std::optional<SVal> getDerivedSymbolForBinding(
}
SVal RegionStoreManager::getBindingForElement(RegionBindingsConstRef B,
- const ElementRegion* R) {
+ const ElementRegion *R) {
// Check if the region has a binding.
if (const std::optional<SVal> &V = B.getDirectBinding(R))
return *V;
- const MemRegion* superR = R->getSuperRegion();
+ const MemRegion *superR = R->getSuperRegion();
// Check if the region is an element region of a string literal.
if (const StringRegion *StrR = dyn_cast<StringRegion>(superR)) {
@@ -1957,7 +1922,7 @@ SVal RegionStoreManager::getBindingForElement(RegionBindingsConstRef B,
}
SVal RegionStoreManager::getBindingForField(RegionBindingsConstRef B,
- const FieldRegion* R) {
+ const FieldRegion *R) {
// Check if the region has a binding.
if (const std::optional<SVal> &V = B.getDirectBinding(R))
@@ -1966,7 +1931,7 @@ SVal RegionStoreManager::getBindingForField(RegionBindingsConstRef B,
// If the containing record was initialized, try to get its constant value.
const FieldDecl *FD = R->getDecl();
QualType Ty = FD->getType();
- const MemRegion* superR = R->getSuperRegion();
+ const MemRegion *superR = R->getSuperRegion();
if (const auto *VR = dyn_cast<VarRegion>(superR)) {
const VarDecl *VD = VR->getDecl();
QualType RecordVarTy = VD->getType();
@@ -2043,8 +2008,8 @@ SVal RegionStoreManager::getLazyBinding(const SubRegion *LazyBindingRegion,
if (const ElementRegion *ER = dyn_cast<ElementRegion>(LazyBindingRegion))
Result = getBindingForElement(LazyBinding, ER);
else
- Result = getBindingForField(LazyBinding,
- cast<FieldRegion>(LazyBindingRegion));
+ Result =
+ getBindingForField(LazyBinding, cast<FieldRegion>(LazyBindingRegion));
// FIXME: This is a hack to deal with RegionStore's inability to distinguish a
// default value for /part/ of an aggregate from a default value for the
@@ -2066,10 +2031,8 @@ SVal RegionStoreManager::getLazyBinding(const SubRegion *LazyBindingRegion,
return Result;
}
-SVal
-RegionStoreManager::getBindingForFieldOrElementCommon(RegionBindingsConstRef B,
- const TypedValueRegion *R,
- QualType Ty) {
+SVal RegionStoreManager::getBindingForFieldOrElementCommon(
+ RegionBindingsConstRef B, const TypedValueRegion *R, QualType Ty) {
// At this point we have already checked in either getBindingForElement or
// getBindingForField if 'R' has a direct binding.
@@ -2131,7 +2094,7 @@ RegionStoreManager::getBindingForFieldOrElementCommon(RegionBindingsConstRef B,
// Currently we don't reason specially about Clang-style vectors. Check
// if superR is a vector and if so return Unknown.
if (const TypedValueRegion *typedSuperR =
- dyn_cast<TypedValueRegion>(R->getSuperRegion())) {
+ dyn_cast<TypedValueRegion>(R->getSuperRegion())) {
if (typedSuperR->getValueType()->isVectorType())
return UnknownVal();
}
@@ -2159,7 +2122,7 @@ RegionStoreManager::getBindingForFieldOrElementCommon(RegionBindingsConstRef B,
}
SVal RegionStoreManager::getBindingForObjCIvar(RegionBindingsConstRef B,
- const ObjCIvarRegion* R) {
+ const ObjCIvarRegion *R) {
// Check if the region has a binding.
if (const std::optional<SVal> &V = B.getDirectBinding(R))
return *V;
@@ -2327,7 +2290,8 @@ bool RegionStoreManager::includedInBindings(Store store,
return true;
// Slow path: if the region is the VALUE of any binding, it is live.
- for (RegionBindingsRef::iterator RI = B.begin(), RE = B.end(); RI != RE; ++RI) {
+ for (RegionBindingsRef::iterator RI = B.begin(), RE = B.end(); RI != RE;
+ ++RI) {
const ClusterBindings &Cluster = RI.getData();
for (ClusterBindings::iterator CI = Cluster.begin(), CE = Cluster.end();
CI != CE; ++CI) {
@@ -2347,17 +2311,18 @@ bool RegionStoreManager::includedInBindings(Store store,
StoreRef RegionStoreManager::killBinding(Store ST, Loc L) {
if (std::optional<loc::MemRegionVal> LV = L.getAs<loc::MemRegionVal>())
- if (const MemRegion* R = LV->getRegion())
- return StoreRef(getRegionBindings(ST).removeBinding(R)
- .asImmutableMap()
- .getRootWithoutRetain(),
+ if (const MemRegion *R = LV->getRegion())
+ return StoreRef(getRegionBindings(ST)
+ .removeBinding(R)
+ .asImmutableMap()
+ .getRootWithoutRetain(),
*this);
return StoreRef(ST, *this);
}
-RegionBindingsRef
-RegionStoreManager::bind(RegionBindingsConstRef B, Loc L, SVal V) {
+RegionBindingsRef RegionStoreManager::bind(RegionBindingsConstRef B, Loc L,
+ SVal V) {
if (L.getAs<loc::ConcreteInt>())
return B;
@@ -2365,7 +2330,7 @@ RegionStoreManager::bind(RegionBindingsConstRef B, Loc L, SVal V) {
const MemRegion *R = L.castAs<loc::MemRegionVal>().getRegion();
// Check if the region is a struct region.
- if (const TypedValueRegion* TR = dyn_cast<TypedValueRegion>(R)) {
+ if (const TypedValueRegion *TR = dyn_cast<TypedValueRegion>(R)) {
QualType Ty = TR->getValueType();
if (Ty->isArrayType())
return bindArray(B, TR, V);
@@ -2396,8 +2361,7 @@ RegionStoreManager::bind(RegionBindingsConstRef B, Loc L, SVal V) {
RegionBindingsRef
RegionStoreManager::setImplicitDefaultValue(RegionBindingsConstRef B,
- const MemRegion *R,
- QualType T) {
+ const MemRegion *R, QualType T) {
SVal V;
if (Loc::isLocType(T))
@@ -2408,8 +2372,7 @@ RegionStoreManager::setImplicitDefaultValue(RegionBindingsConstRef B,
// Set the default value to a zero constant when it is a structure
// or array. The type doesn't really matter.
V = svalBuilder.makeZeroVal(Ctx.IntTy);
- }
- else {
+ } else {
// We can't represent values of this type, but we still need to set a value
// to record that the region has been initialized.
// If this assertion ever fires, a new case should be added above -- we
@@ -2455,16 +2418,16 @@ std::optional<RegionBindingsRef> RegionStoreManager::tryBindSmallArray(
return NewB;
}
-RegionBindingsRef
-RegionStoreManager::bindArray(RegionBindingsConstRef B,
- const TypedValueRegion* R,
- SVal Init) {
+RegionBindingsRef RegionStoreManager::bindArray(RegionBindingsConstRef B,
+ const TypedValueRegion *R,
+ SVal Init) {
- const ArrayType *AT =cast<ArrayType>(Ctx.getCanonicalType(R->getValueType()));
+ const ArrayType *AT =
+ cast<ArrayType>(Ctx.getCanonicalType(R->getValueType()));
QualType ElementTy = AT->getElementType();
std::optional<uint64_t> Size;
- if (const ConstantArrayType* CAT = dyn_cast<ConstantArrayType>(AT))
+ if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT))
Size = CAT->getSize().getZExtValue();
// Check if the init expr is a literal. If so, bind the rvalue instead.
@@ -2489,7 +2452,7 @@ RegionStoreManager::bindArray(RegionBindingsConstRef B,
return bindAggregate(B, R, UnknownVal());
// Remaining case: explicit compound values.
- const nonloc::CompoundVal& CV = Init.castAs<nonloc::CompoundVal>();
+ const nonloc::CompoundVal &CV = Init.castAs<nonloc::CompoundVal>();
nonloc::CompoundVal::iterator VI = CV.begin(), VE = CV.end();
uint64_t i = 0;
@@ -2521,7 +2484,7 @@ RegionStoreManager::bindArray(RegionBindingsConstRef B,
}
RegionBindingsRef RegionStoreManager::bindVector(RegionBindingsConstRef B,
- const TypedValueRegion* R,
+ const TypedValueRegion *R,
SVal V) {
QualType T = R->getValueType();
const VectorType *VT = T->castAs<VectorType>(); // Use castAs for typedefs.
@@ -2543,7 +2506,7 @@ RegionBindingsRef RegionStoreManager::bindVector(RegionBindingsConstRef B,
unsigned index = 0, numElements = VT->getNumElements();
RegionBindingsRef NewB(B);
- for ( ; index != numElements ; ++index) {
+ for (; index != numElements; ++index) {
if (VI == VE)
break;
@@ -2610,7 +2573,7 @@ RegionBindingsRef RegionStoreManager::bindStruct(RegionBindingsConstRef B,
QualType T = R->getValueType();
assert(T->isStructureOrClassType());
- const RecordType* RT = T->castAs<RecordType>();
+ const RecordType *RT = T->castAs<RecordType>();
const RecordDecl *RD = RT->getDecl();
if (!RD->isCompleteDefinition())
@@ -2649,7 +2612,7 @@ RegionBindingsRef RegionStoreManager::bindStruct(RegionBindingsConstRef B,
// the first field, second value binds to the second field, etc.
// It would have been much safer to organize non-lazy compound values as
// a mapping from fields/bases to values.
- const nonloc::CompoundVal& CV = V.castAs<nonloc::CompoundVal>();
+ const nonloc::CompoundVal &CV = V.castAs<nonloc::CompoundVal>();
nonloc::CompoundVal::iterator VI = CV.begin(), VE = CV.end();
RegionBindingsRef NewB(B);
@@ -2701,7 +2664,7 @@ RegionBindingsRef RegionStoreManager::bindStruct(RegionBindingsConstRef B,
continue;
QualType FTy = FI->getType();
- const FieldRegion* FR = MRMgr.getFieldRegion(*FI, R);
+ const FieldRegion *FR = MRMgr.getFieldRegion(*FI, R);
if (FTy->isArrayType())
NewB = bindArray(NewB, FR, *VI);
@@ -2721,10 +2684,9 @@ RegionBindingsRef RegionStoreManager::bindStruct(RegionBindingsConstRef B,
return NewB;
}
-RegionBindingsRef
-RegionStoreManager::bindAggregate(RegionBindingsConstRef B,
- const TypedRegion *R,
- SVal Val) {
+RegionBindingsRef RegionStoreManager::bindAggregate(RegionBindingsConstRef B,
+ const TypedRegion *R,
+ SVal Val) {
// Remove the old bindings, using 'R' as the root of all regions
// we will invalidate. Then add the new binding.
return removeSubRegionBindings(B, R).addBinding(R, BindingKey::Default, Val);
@@ -2743,11 +2705,11 @@ class RemoveDeadBindingsWorker
public:
RemoveDeadBindingsWorker(RegionStoreManager &rm,
- ProgramStateManager &stateMgr,
- RegionBindingsRef b, SymbolReaper &symReaper,
+ ProgramStateManager &stateMgr, RegionBindingsRef b,
+ SymbolReaper &symReaper,
const StackFrameContext *LCtx)
- : ClusterAnalysis<RemoveDeadBindingsWorker>(rm, stateMgr, b),
- SymReaper(symReaper), CurrentLCtx(LCtx) {}
+ : ClusterAnalysis<RemoveDeadBindingsWorker>(rm, stateMgr, b),
+ SymReaper(symReaper), CurrentLCtx(LCtx) {}
// Called by ClusterAnalysis.
void VisitAddedToCluster(const MemRegion *baseR, const ClusterBindings &C);
@@ -2761,7 +2723,7 @@ class RemoveDeadBindingsWorker
bool UpdatePostponed();
void VisitBinding(SVal V);
};
-}
+} // namespace
bool RemoveDeadBindingsWorker::AddToWorkList(const MemRegion *R) {
const MemRegion *BaseR = R->getBaseRegion();
@@ -2849,7 +2811,6 @@ void RemoveDeadBindingsWorker::VisitBinding(SVal V) {
}
}
-
// Update the set of live symbols.
for (SymbolRef Sym : V.symbols())
SymReaper.markLive(Sym);
@@ -2872,7 +2833,7 @@ bool RemoveDeadBindingsWorker::UpdatePostponed() {
StoreRef RegionStoreManager::removeDeadBindings(Store store,
const StackFrameContext *LCtx,
- SymbolReaper& SymReaper) {
+ SymbolReaper &SymReaper) {
RegionBindingsRef B = getRegionBindings(store);
RemoveDeadBindingsWorker W(*this, StateMgr, B, SymReaper, LCtx);
W.GenerateClusters();
@@ -2882,7 +2843,9 @@ StoreRef RegionStoreManager::removeDeadBindings(Store store,
W.AddToWorkList(Reg);
}
- do W.RunWorkList(); while (W.UpdatePostponed());
+ do
+ W.RunWorkList();
+ while (W.UpdatePostponed());
// We have now scanned the store, marking reachable regions and symbols
// as live. We now remove all the regions that are dead from the store
diff --git a/clang/lib/StaticAnalyzer/Core/SValBuilder.cpp b/clang/lib/StaticAnalyzer/Core/SValBuilder.cpp
index eb9cde5c8918fc..06c4f62d5e0818 100644
--- a/clang/lib/StaticAnalyzer/Core/SValBuilder.cpp
+++ b/clang/lib/StaticAnalyzer/Core/SValBuilder.cpp
@@ -125,7 +125,7 @@ SVal SValBuilder::convertToArrayIndex(SVal val) {
// Common case: we have an appropriately sized integer.
if (std::optional<nonloc::ConcreteInt> CI =
val.getAs<nonloc::ConcreteInt>()) {
- const llvm::APSInt& I = CI->getValue();
+ const llvm::APSInt &I = CI->getValue();
if (I.getBitWidth() == ArrayIndexWidth && I.isSigned())
return val;
}
@@ -133,7 +133,8 @@ SVal SValBuilder::convertToArrayIndex(SVal val) {
return evalCast(val, ArrayIndexTy, QualType{});
}
-nonloc::ConcreteInt SValBuilder::makeBoolVal(const CXXBoolLiteralExpr *boolean){
+nonloc::ConcreteInt
+SValBuilder::makeBoolVal(const CXXBoolLiteralExpr *boolean) {
return makeTruthVal(boolean->getValue());
}
@@ -210,10 +211,8 @@ DefinedOrUnknownSVal SValBuilder::conjureSymbolVal(const Stmt *stmt,
return nonloc::SymbolVal(sym);
}
-DefinedOrUnknownSVal
-SValBuilder::getConjuredHeapSymbolVal(const Expr *E,
- const LocationContext *LCtx,
- unsigned VisitCount) {
+DefinedOrUnknownSVal SValBuilder::getConjuredHeapSymbolVal(
+ const Expr *E, const LocationContext *LCtx, unsigned VisitCount) {
QualType T = E->getType();
return getConjuredHeapSymbolVal(E, LCtx, T, VisitCount);
}
@@ -257,7 +256,7 @@ DefinedSVal SValBuilder::getMetadataSymbolVal(const void *symbolTag,
DefinedOrUnknownSVal
SValBuilder::getDerivedRegionValueSymbolVal(SymbolRef parentSymbol,
- const TypedValueRegion *region) {
+ const TypedValueRegion *region) {
QualType T = region->getValueType();
if (T->isNullPtrType())
@@ -298,10 +297,10 @@ DefinedSVal SValBuilder::getBlockPointer(const BlockDecl *block,
CanQualType locTy,
const LocationContext *locContext,
unsigned blockCount) {
- const BlockCodeRegion *BC =
- MemMgr.getBlockCodeRegion(block, locTy, locContext->getAnalysisDeclContext());
- const BlockDataRegion *BD = MemMgr.getBlockDataRegion(BC, locContext,
- blockCount);
+ const BlockCodeRegion *BC = MemMgr.getBlockCodeRegion(
+ block, locTy, locContext->getAnalysisDeclContext());
+ const BlockDataRegion *BD =
+ MemMgr.getBlockDataRegion(BC, locContext, blockCount);
return loc::MemRegionVal(BD);
}
@@ -426,9 +425,8 @@ std::optional<SVal> SValBuilder::getConstantVal(const Expr *E) {
}
}
-SVal SValBuilder::makeSymExprValNN(BinaryOperator::Opcode Op,
- NonLoc LHS, NonLoc RHS,
- QualType ResultTy) {
+SVal SValBuilder::makeSymExprValNN(BinaryOperator::Opcode Op, NonLoc LHS,
+ NonLoc RHS, QualType ResultTy) {
SymbolRef symLHS = LHS.getAsSymbol();
SymbolRef symRHS = RHS.getAsSymbol();
@@ -437,7 +435,7 @@ SVal SValBuilder::makeSymExprValNN(BinaryOperator::Opcode Op,
const unsigned MaxComp = AnOpts.MaxSymbolComplexity;
if (symLHS && symRHS &&
- (symLHS->computeComplexity() + symRHS->computeComplexity()) < MaxComp)
+ (symLHS->computeComplexity() + symRHS->computeComplexity()) < MaxComp)
return makeNonLoc(symLHS, Op, symRHS, ResultTy);
if (symLHS && symLHS->computeComplexity() < MaxComp)
@@ -478,7 +476,7 @@ SVal SValBuilder::evalComplement(NonLoc X) {
}
SVal SValBuilder::evalUnaryOp(ProgramStateRef state, UnaryOperator::Opcode opc,
- SVal operand, QualType type) {
+ SVal operand, QualType type) {
auto OpN = operand.getAs<NonLoc>();
if (!OpN)
return UnknownVal();
@@ -560,7 +558,7 @@ DefinedOrUnknownSVal SValBuilder::evalEQ(ProgramStateRef state,
/// and restrict qualifiers. Also, assume that all types are similar to 'void'.
/// Assumes the input types are canonical.
static bool shouldBeModeledWithNoOp(ASTContext &Context, QualType ToTy,
- QualType FromTy) {
+ QualType FromTy) {
while (Context.UnwrapSimilarTypes(ToTy, FromTy)) {
Qualifiers Quals1, Quals2;
ToTy = Context.getUnqualifiedArrayType(ToTy, Quals1);
diff --git a/clang/lib/StaticAnalyzer/Core/SVals.cpp b/clang/lib/StaticAnalyzer/Core/SVals.cpp
index 0e1351215bb424..20a0562e52f2e4 100644
--- a/clang/lib/StaticAnalyzer/Core/SVals.cpp
+++ b/clang/lib/StaticAnalyzer/Core/SVals.cpp
@@ -45,7 +45,7 @@ using namespace ento;
const FunctionDecl *SVal::getAsFunctionDecl() const {
if (std::optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>()) {
- const MemRegion* R = X->getRegion();
+ const MemRegion *R = X->getRegion();
if (const FunctionCodeRegion *CTR = R->getAs<FunctionCodeRegion>())
if (const auto *FD = dyn_cast<FunctionDecl>(CTR->getDecl()))
return FD;
@@ -188,11 +188,11 @@ const MemRegion *loc::MemRegionVal::stripCasts(bool StripBaseCasts) const {
}
const void *nonloc::LazyCompoundVal::getStore() const {
- return static_cast<const LazyCompoundValData*>(Data)->getStore();
+ return static_cast<const LazyCompoundValData *>(Data)->getStore();
}
const TypedValueRegion *nonloc::LazyCompoundVal::getRegion() const {
- return static_cast<const LazyCompoundValData*>(Data)->getRegion();
+ return static_cast<const LazyCompoundValData *>(Data)->getRegion();
}
bool nonloc::PointerToMember::isNullMemberPointer() const {
@@ -255,9 +255,7 @@ bool SVal::isConstant(int I) const {
return false;
}
-bool SVal::isZeroConstant() const {
- return isConstant(0);
-}
+bool SVal::isZeroConstant() const { return isConstant(0); }
//===----------------------------------------------------------------------===//
// Pretty-Printing.
@@ -302,62 +300,60 @@ void NonLoc::dumpToStream(raw_ostream &os) const {
<< 'b';
break;
}
- case nonloc::SymbolValKind:
- os << castAs<nonloc::SymbolVal>().getSymbol();
- break;
-
- case nonloc::LocAsIntegerKind: {
- const nonloc::LocAsInteger& C = castAs<nonloc::LocAsInteger>();
- os << C.getLoc() << " [as " << C.getNumBits() << " bit integer]";
- break;
- }
- case nonloc::CompoundValKind: {
- const nonloc::CompoundVal& C = castAs<nonloc::CompoundVal>();
- os << "compoundVal{";
- bool first = true;
- for (const auto &I : C) {
- if (first) {
- os << ' '; first = false;
- }
- else
- os << ", ";
-
- I.dumpToStream(os);
- }
- os << "}";
- break;
- }
- case nonloc::LazyCompoundValKind: {
- const nonloc::LazyCompoundVal &C = castAs<nonloc::LazyCompoundVal>();
- os << "lazyCompoundVal{" << const_cast<void *>(C.getStore())
- << ',' << C.getRegion()
- << '}';
- break;
- }
- case nonloc::PointerToMemberKind: {
- os << "pointerToMember{";
- const nonloc::PointerToMember &CastRes =
- castAs<nonloc::PointerToMember>();
- if (CastRes.getDecl())
- os << "|" << CastRes.getDecl()->getQualifiedNameAsString() << "|";
- bool first = true;
- for (const auto &I : CastRes) {
- if (first) {
- os << ' '; first = false;
- }
- else
- os << ", ";
-
- os << I->getType();
- }
-
- os << '}';
- break;
+ case nonloc::SymbolValKind:
+ os << castAs<nonloc::SymbolVal>().getSymbol();
+ break;
+
+ case nonloc::LocAsIntegerKind: {
+ const nonloc::LocAsInteger &C = castAs<nonloc::LocAsInteger>();
+ os << C.getLoc() << " [as " << C.getNumBits() << " bit integer]";
+ break;
+ }
+ case nonloc::CompoundValKind: {
+ const nonloc::CompoundVal &C = castAs<nonloc::CompoundVal>();
+ os << "compoundVal{";
+ bool first = true;
+ for (const auto &I : C) {
+ if (first) {
+ os << ' ';
+ first = false;
+ } else
+ os << ", ";
+
+ I.dumpToStream(os);
}
- default:
- assert(false && "Pretty-printed not implemented for this NonLoc.");
- break;
+ os << "}";
+ break;
+ }
+ case nonloc::LazyCompoundValKind: {
+ const nonloc::LazyCompoundVal &C = castAs<nonloc::LazyCompoundVal>();
+ os << "lazyCompoundVal{" << const_cast<void *>(C.getStore()) << ','
+ << C.getRegion() << '}';
+ break;
+ }
+ case nonloc::PointerToMemberKind: {
+ os << "pointerToMember{";
+ const nonloc::PointerToMember &CastRes = castAs<nonloc::PointerToMember>();
+ if (CastRes.getDecl())
+ os << "|" << CastRes.getDecl()->getQualifiedNameAsString() << "|";
+ bool first = true;
+ for (const auto &I : CastRes) {
+ if (first) {
+ os << ' ';
+ first = false;
+ } else
+ os << ", ";
+
+ os << I->getType();
}
+
+ os << '}';
+ break;
+ }
+ default:
+ assert(false && "Pretty-printed not implemented for this NonLoc.");
+ break;
+ }
}
void Loc::dumpToStream(raw_ostream &os) const {
diff --git a/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp b/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp
index 45e48d435aca6a..857913a5ef2a1f 100644
--- a/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp
+++ b/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp
@@ -10,10 +10,10 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SValVisitor.h"
#include <optional>
@@ -68,12 +68,12 @@ class SimpleSValBuilder : public SValBuilder {
: SValBuilder(alloc, context, stateMgr) {}
~SimpleSValBuilder() override {}
- SVal evalBinOpNN(ProgramStateRef state, BinaryOperator::Opcode op,
- NonLoc lhs, NonLoc rhs, QualType resultTy) override;
- SVal evalBinOpLL(ProgramStateRef state, BinaryOperator::Opcode op,
- Loc lhs, Loc rhs, QualType resultTy) override;
- SVal evalBinOpLN(ProgramStateRef state, BinaryOperator::Opcode op,
- Loc lhs, NonLoc rhs, QualType resultTy) override;
+ SVal evalBinOpNN(ProgramStateRef state, BinaryOperator::Opcode op, NonLoc lhs,
+ NonLoc rhs, QualType resultTy) override;
+ SVal evalBinOpLL(ProgramStateRef state, BinaryOperator::Opcode op, Loc lhs,
+ Loc rhs, QualType resultTy) override;
+ SVal evalBinOpLN(ProgramStateRef state, BinaryOperator::Opcode op, Loc lhs,
+ NonLoc rhs, QualType resultTy) override;
/// Evaluates a given SVal by recursively evaluating and
/// simplifying the children SVals. If the SVal has only one possible
@@ -125,9 +125,9 @@ static bool isNegationValuePreserving(const llvm::APSInt &Value,
//===----------------------------------------------------------------------===//
SVal SimpleSValBuilder::MakeSymIntVal(const SymExpr *LHS,
- BinaryOperator::Opcode op,
- const llvm::APSInt &RHS,
- QualType resultTy) {
+ BinaryOperator::Opcode op,
+ const llvm::APSInt &RHS,
+ QualType resultTy) {
bool isIdempotent = false;
// Check for a few special cases with known reductions first.
@@ -266,8 +266,7 @@ static bool isWithinConstantOverflowBounds(SymbolRef Sym,
// Same for the concrete integers: see if I is within [min/4, max/4].
static bool isWithinConstantOverflowBounds(llvm::APSInt I) {
APSIntType AT(I);
- assert(!AT.isUnsigned() &&
- "This only works with signed integers!");
+ assert(!AT.isUnsigned() && "This only works with signed integers!");
llvm::APSInt Max = AT.getMaxValue() / AT.getValue(4), Min = -Max;
return (I <= Max) && (I >= -Max);
@@ -277,10 +276,9 @@ static std::pair<SymbolRef, llvm::APSInt>
decomposeSymbol(SymbolRef Sym, BasicValueFactory &BV) {
if (const auto *SymInt = dyn_cast<SymIntExpr>(Sym))
if (BinaryOperator::isAdditiveOp(SymInt->getOpcode()))
- return std::make_pair(SymInt->getLHS(),
- (SymInt->getOpcode() == BO_Add) ?
- (SymInt->getRHS()) :
- (-SymInt->getRHS()));
+ return std::make_pair(SymInt->getLHS(), (SymInt->getOpcode() == BO_Add)
+ ? (SymInt->getRHS())
+ : (-SymInt->getRHS()));
// Fail to decompose: "reduce" the problem to the "$x + 0" case.
return std::make_pair(Sym, BV.getValue(0, Sym->getType()));
@@ -290,16 +288,15 @@ decomposeSymbol(SymbolRef Sym, BasicValueFactory &BV) {
// same signed integral type and no overflows occur (which should be checked
// by the caller).
static NonLoc doRearrangeUnchecked(ProgramStateRef State,
- BinaryOperator::Opcode Op,
- SymbolRef LSym, llvm::APSInt LInt,
- SymbolRef RSym, llvm::APSInt RInt) {
+ BinaryOperator::Opcode Op, SymbolRef LSym,
+ llvm::APSInt LInt, SymbolRef RSym,
+ llvm::APSInt RInt) {
SValBuilder &SVB = State->getStateManager().getSValBuilder();
BasicValueFactory &BV = SVB.getBasicValueFactory();
SymbolManager &SymMgr = SVB.getSymbolManager();
QualType SymTy = LSym->getType();
- assert(SymTy == RSym->getType() &&
- "Symbols are not of the same type!");
+ assert(SymTy == RSym->getType() && "Symbols are not of the same type!");
assert(APSIntType(LInt) == BV.getAPSIntType(SymTy) &&
"Integers are not of the same type as symbols!");
assert(APSIntType(RInt) == BV.getAPSIntType(SymTy) &&
@@ -314,8 +311,9 @@ static NonLoc doRearrangeUnchecked(ProgramStateRef State,
llvm_unreachable("Operation not suitable for unchecked rearrangement!");
if (LSym == RSym)
- return SVB.evalBinOpNN(State, Op, nonloc::ConcreteInt(LInt),
- nonloc::ConcreteInt(RInt), ResultTy)
+ return SVB
+ .evalBinOpNN(State, Op, nonloc::ConcreteInt(LInt),
+ nonloc::ConcreteInt(RInt), ResultTy)
.castAs<NonLoc>();
SymbolRef ResultSym = nullptr;
@@ -357,10 +355,9 @@ static NonLoc doRearrangeUnchecked(ProgramStateRef State,
// overflow bounds.
static bool shouldRearrange(ProgramStateRef State, BinaryOperator::Opcode Op,
SymbolRef Sym, llvm::APSInt Int, QualType Ty) {
- return Sym->getType() == Ty &&
- (!BinaryOperator::isComparisonOp(Op) ||
- (isWithinConstantOverflowBounds(Sym, State) &&
- isWithinConstantOverflowBounds(Int)));
+ return Sym->getType() == Ty && (!BinaryOperator::isComparisonOp(Op) ||
+ (isWithinConstantOverflowBounds(Sym, State) &&
+ isWithinConstantOverflowBounds(Int)));
}
static std::optional<NonLoc> tryRearrange(ProgramStateRef State,
@@ -419,9 +416,8 @@ static std::optional<NonLoc> tryRearrange(ProgramStateRef State,
}
SVal SimpleSValBuilder::evalBinOpNN(ProgramStateRef state,
- BinaryOperator::Opcode op,
- NonLoc lhs, NonLoc rhs,
- QualType resultTy) {
+ BinaryOperator::Opcode op, NonLoc lhs,
+ NonLoc rhs, QualType resultTy) {
NonLoc InputLHS = lhs;
NonLoc InputRHS = rhs;
@@ -437,25 +433,25 @@ SVal SimpleSValBuilder::evalBinOpNN(ProgramStateRef state,
// Handle trivial case where left-side and right-side are the same.
if (lhs == rhs)
switch (op) {
- default:
- break;
- case BO_EQ:
- case BO_LE:
- case BO_GE:
- return makeTruthVal(true, resultTy);
- case BO_LT:
- case BO_GT:
- case BO_NE:
- return makeTruthVal(false, resultTy);
- case BO_Xor:
- case BO_Sub:
- if (resultTy->isIntegralOrEnumerationType())
- return makeIntVal(0, resultTy);
- return evalCast(makeIntVal(0, /*isUnsigned=*/false), resultTy,
- QualType{});
- case BO_Or:
- case BO_And:
- return evalCast(lhs, resultTy, QualType{});
+ default:
+ break;
+ case BO_EQ:
+ case BO_LE:
+ case BO_GE:
+ return makeTruthVal(true, resultTy);
+ case BO_LT:
+ case BO_GT:
+ case BO_NE:
+ return makeTruthVal(false, resultTy);
+ case BO_Xor:
+ case BO_Sub:
+ if (resultTy->isIntegralOrEnumerationType())
+ return makeIntVal(0, resultTy);
+ return evalCast(makeIntVal(0, /*isUnsigned=*/false), resultTy,
+ QualType{});
+ case BO_Or:
+ case BO_And:
+ return evalCast(lhs, resultTy, QualType{});
}
while (true) {
@@ -469,12 +465,12 @@ SVal SimpleSValBuilder::evalBinOpNN(ProgramStateRef state,
RPTM = rhs.castAs<nonloc::PointerToMember>();
auto LPTMD = LPTM.getPTMData(), RPTMD = RPTM.getPTMData();
switch (op) {
- case BO_EQ:
- return makeTruthVal(LPTMD == RPTMD, resultTy);
- case BO_NE:
- return makeTruthVal(LPTMD != RPTMD, resultTy);
- default:
- return UnknownVal();
+ case BO_EQ:
+ return makeTruthVal(LPTMD == RPTMD, resultTy);
+ case BO_NE:
+ return makeTruthVal(LPTMD != RPTMD, resultTy);
+ default:
+ return UnknownVal();
}
}
case nonloc::LocAsIntegerKind: {
@@ -509,17 +505,17 @@ SVal SimpleSValBuilder::evalBinOpNN(ProgramStateRef state,
BasicVals.getAPSIntType(Context.VoidPtrTy).apply(i);
return evalBinOpLL(state, op, lhsL, makeLoc(i), resultTy);
}
+ default:
+ switch (op) {
+ case BO_EQ:
+ return makeTruthVal(false, resultTy);
+ case BO_NE:
+ return makeTruthVal(true, resultTy);
default:
- switch (op) {
- case BO_EQ:
- return makeTruthVal(false, resultTy);
- case BO_NE:
- return makeTruthVal(true, resultTy);
- default:
- // This case also handles pointer arithmetic.
- return makeSymExprValNN(op, InputLHS, InputRHS, resultTy);
- }
+ // This case also handles pointer arithmetic.
+ return makeSymExprValNN(op, InputLHS, InputRHS, resultTy);
}
+ }
}
case nonloc::ConcreteIntKind: {
llvm::APSInt LHSValue = lhs.castAs<nonloc::ConcreteInt>().getValue();
@@ -531,8 +527,8 @@ SVal SimpleSValBuilder::evalBinOpNN(ProgramStateRef state,
// We're looking for a type big enough to compare the two values.
// FIXME: This is not correct. char + short will result in a promotion
// to int. Unfortunately we have lost types by this point.
- APSIntType CompareType = std::max(APSIntType(LHSValue),
- APSIntType(RHSValue));
+ APSIntType CompareType =
+ std::max(APSIntType(LHSValue), APSIntType(RHSValue));
CompareType.apply(LHSValue);
CompareType.apply(RHSValue);
} else if (!BinaryOperator::isShiftOp(op)) {
@@ -542,7 +538,7 @@ SVal SimpleSValBuilder::evalBinOpNN(ProgramStateRef state,
}
const llvm::APSInt *Result =
- BasicVals.evalAPSInt(op, LHSValue, RHSValue);
+ BasicVals.evalAPSInt(op, LHSValue, RHSValue);
if (!Result) {
if (op == BO_Shl || op == BO_Shr) {
// FIXME: At this point the constant folding claims that the result
@@ -645,15 +641,14 @@ SVal SimpleSValBuilder::evalBinOpNN(ProgramStateRef state,
case BO_GE:
case BO_EQ:
case BO_NE:
- assert(resultTy->isBooleanType() ||
- resultTy == getConditionType());
+ assert(resultTy->isBooleanType() || resultTy == getConditionType());
assert(symIntExpr->getType()->isBooleanType() ||
getContext().hasSameUnqualifiedType(symIntExpr->getType(),
getConditionType()));
// Negate the comparison and make a value.
opc = BinaryOperator::negateComparisonOp(opc);
- return makeNonLoc(symIntExpr->getLHS(), opc,
- symIntExpr->getRHS(), resultTy);
+ return makeNonLoc(symIntExpr->getLHS(), opc, symIntExpr->getRHS(),
+ resultTy);
}
}
@@ -787,9 +782,8 @@ static void assertEqualBitWidths(ProgramStateRef State, Loc RhsLoc,
// FIXME: all this logic will change if/when we have MemRegion::getLocation().
SVal SimpleSValBuilder::evalBinOpLL(ProgramStateRef state,
- BinaryOperator::Opcode op,
- Loc lhs, Loc rhs,
- QualType resultTy) {
+ BinaryOperator::Opcode op, Loc lhs, Loc rhs,
+ QualType resultTy) {
// Assert that bitwidth of lhs and rhs are the same.
// This can happen if two different address spaces are used,
@@ -977,7 +971,7 @@ SVal SimpleSValBuilder::evalBinOpLL(ProgramStateRef state,
// relying on us.
if (LeftBase != RightBase &&
((!isa<SymbolicRegion>(LeftBase) && !isa<SymbolicRegion>(RightBase)) ||
- (isa<HeapSpaceRegion>(LeftMS) || isa<HeapSpaceRegion>(RightMS))) ){
+ (isa<HeapSpaceRegion>(LeftMS) || isa<HeapSpaceRegion>(RightMS)))) {
switch (op) {
default:
return UnknownVal();
@@ -1029,8 +1023,8 @@ SVal SimpleSValBuilder::evalBinOpLL(ProgramStateRef state,
const FieldRegion *RightFR = dyn_cast<FieldRegion>(RightMR);
const FieldRegion *LeftFR = dyn_cast<FieldRegion>(LeftMR);
if (RightFR && LeftFR) {
- SVal R = evalBinOpFieldRegionFieldRegion(LeftFR, RightFR, op, resultTy,
- *this);
+ SVal R =
+ evalBinOpFieldRegionFieldRegion(LeftFR, RightFR, op, resultTy, *this);
if (!R.isUnknown())
return R;
}
@@ -1046,20 +1040,20 @@ SVal SimpleSValBuilder::evalBinOpLL(ProgramStateRef state,
int64_t right = RightOffset.getOffset();
switch (op) {
- default:
- return UnknownVal();
- case BO_LT:
- return makeTruthVal(left < right, resultTy);
- case BO_GT:
- return makeTruthVal(left > right, resultTy);
- case BO_LE:
- return makeTruthVal(left <= right, resultTy);
- case BO_GE:
- return makeTruthVal(left >= right, resultTy);
- case BO_EQ:
- return makeTruthVal(left == right, resultTy);
- case BO_NE:
- return makeTruthVal(left != right, resultTy);
+ default:
+ return UnknownVal();
+ case BO_LT:
+ return makeTruthVal(left < right, resultTy);
+ case BO_GT:
+ return makeTruthVal(left > right, resultTy);
+ case BO_LE:
+ return makeTruthVal(left <= right, resultTy);
+ case BO_GE:
+ return makeTruthVal(left >= right, resultTy);
+ case BO_EQ:
+ return makeTruthVal(left == right, resultTy);
+ case BO_NE:
+ return makeTruthVal(left != right, resultTy);
}
}
@@ -1139,14 +1133,14 @@ SVal SimpleSValBuilder::evalBinOpLN(ProgramStateRef state,
// Compute the adjusted pointer.
switch (op) {
- case BO_Add:
- rightI = leftI + rightI;
- break;
- case BO_Sub:
- rightI = leftI - rightI;
- break;
- default:
- llvm_unreachable("Invalid pointer arithmetic operation");
+ case BO_Add:
+ rightI = leftI + rightI;
+ break;
+ case BO_Sub:
+ rightI = leftI - rightI;
+ break;
+ default:
+ llvm_unreachable("Invalid pointer arithmetic operation");
}
return loc::ConcreteInt(getBasicValueFactory().getValue(rightI));
}
@@ -1163,12 +1157,11 @@ SVal SimpleSValBuilder::evalBinOpLN(ProgramStateRef state,
if (const ElementRegion *elemReg = dyn_cast<ElementRegion>(region)) {
assert(op == BO_Add || op == BO_Sub);
- index = evalBinOpNN(state, op, elemReg->getIndex(), rhs,
- getArrayIndexType());
+ index =
+ evalBinOpNN(state, op, elemReg->getIndex(), rhs, getArrayIndexType());
superR = cast<SubRegion>(elemReg->getSuperRegion());
elementType = elemReg->getElementType();
- }
- else if (isa<SubRegion>(region)) {
+ } else if (isa<SubRegion>(region)) {
assert(op == BO_Add || op == BO_Sub);
index = (op == BO_Add) ? rhs : evalMinus(rhs);
superR = cast<SubRegion>(region);
@@ -1187,8 +1180,8 @@ SVal SimpleSValBuilder::evalBinOpLN(ProgramStateRef state,
elementType = getContext().CharTy;
if (std::optional<NonLoc> indexV = index.getAs<NonLoc>()) {
- return loc::MemRegionVal(MemMgr.getElementRegion(elementType, *indexV,
- superR, getContext()));
+ return loc::MemRegionVal(
+ MemMgr.getElementRegion(elementType, *indexV, superR, getContext()));
}
}
return UnknownVal();
@@ -1283,9 +1276,7 @@ SVal SimpleSValBuilder::simplifySValOnce(ProgramStateRef State, SVal V) {
return V;
}
- SVal skip(SymbolRef Sym) {
- return cache(Sym, SVB.makeSymbolVal(Sym));
- }
+ SVal skip(SymbolRef Sym) { return cache(Sym, SVB.makeSymbolVal(Sym)); }
// Return the known const value for the Sym if available, or return Undef
// otherwise.
@@ -1407,8 +1398,7 @@ SVal SimpleSValBuilder::simplifySValOnce(ProgramStateRef State, SVal V) {
if (isUnchanged(S->getOperand(), Op))
return skip(S);
- return cache(
- S, SVB.evalUnaryOp(State, S->getOpcode(), Op, S->getType()));
+ return cache(S, SVB.evalUnaryOp(State, S->getOpcode(), Op, S->getType()));
}
SVal VisitSymExpr(SymbolRef S) { return nonloc::SymbolVal(S); }
diff --git a/clang/lib/StaticAnalyzer/Core/Store.cpp b/clang/lib/StaticAnalyzer/Core/Store.cpp
index 67ca61bb56ba28..12dac156cb44c2 100644
--- a/clang/lib/StaticAnalyzer/Core/Store.cpp
+++ b/clang/lib/StaticAnalyzer/Core/Store.cpp
@@ -43,8 +43,7 @@ StoreManager::StoreManager(ProgramStateManager &stateMgr)
: svalBuilder(stateMgr.getSValBuilder()), StateMgr(stateMgr),
MRMgr(svalBuilder.getRegionManager()), Ctx(stateMgr.getContext()) {}
-StoreRef StoreManager::enterStackFrame(Store OldStore,
- const CallEvent &Call,
+StoreRef StoreManager::enterStackFrame(Store OldStore, const CallEvent &Call,
const StackFrameContext *LCtx) {
StoreRef Store = StoreRef(OldStore, *this);
@@ -117,113 +116,113 @@ std::optional<const MemRegion *> StoreManager::castRegion(const MemRegion *R,
// Process region cast according to the kind of the region being cast.
switch (R->getKind()) {
- case MemRegion::CXXThisRegionKind:
- case MemRegion::CodeSpaceRegionKind:
- case MemRegion::StackLocalsSpaceRegionKind:
- case MemRegion::StackArgumentsSpaceRegionKind:
- case MemRegion::HeapSpaceRegionKind:
- case MemRegion::UnknownSpaceRegionKind:
- case MemRegion::StaticGlobalSpaceRegionKind:
- case MemRegion::GlobalInternalSpaceRegionKind:
- case MemRegion::GlobalSystemSpaceRegionKind:
- case MemRegion::GlobalImmutableSpaceRegionKind: {
- llvm_unreachable("Invalid region cast");
- }
+ case MemRegion::CXXThisRegionKind:
+ case MemRegion::CodeSpaceRegionKind:
+ case MemRegion::StackLocalsSpaceRegionKind:
+ case MemRegion::StackArgumentsSpaceRegionKind:
+ case MemRegion::HeapSpaceRegionKind:
+ case MemRegion::UnknownSpaceRegionKind:
+ case MemRegion::StaticGlobalSpaceRegionKind:
+ case MemRegion::GlobalInternalSpaceRegionKind:
+ case MemRegion::GlobalSystemSpaceRegionKind:
+ case MemRegion::GlobalImmutableSpaceRegionKind: {
+ llvm_unreachable("Invalid region cast");
+ }
- case MemRegion::FunctionCodeRegionKind:
- case MemRegion::BlockCodeRegionKind:
- case MemRegion::BlockDataRegionKind:
- case MemRegion::StringRegionKind:
- // FIXME: Need to handle arbitrary downcasts.
- case MemRegion::SymbolicRegionKind:
- case MemRegion::AllocaRegionKind:
- case MemRegion::CompoundLiteralRegionKind:
- case MemRegion::FieldRegionKind:
- case MemRegion::ObjCIvarRegionKind:
- case MemRegion::ObjCStringRegionKind:
- case MemRegion::NonParamVarRegionKind:
- case MemRegion::ParamVarRegionKind:
- case MemRegion::CXXTempObjectRegionKind:
- case MemRegion::CXXLifetimeExtendedObjectRegionKind:
- case MemRegion::CXXBaseObjectRegionKind:
- case MemRegion::CXXDerivedObjectRegionKind:
- return MakeElementRegion(cast<SubRegion>(R), PointeeTy);
-
- case MemRegion::ElementRegionKind: {
- // If we are casting from an ElementRegion to another type, the
- // algorithm is as follows:
- //
- // (1) Compute the "raw offset" of the ElementRegion from the
- // base region. This is done by calling 'getAsRawOffset()'.
- //
- // (2a) If we get a 'RegionRawOffset' after calling
- // 'getAsRawOffset()', determine if the absolute offset
- // can be exactly divided into chunks of the size of the
- // casted-pointee type. If so, create a new ElementRegion with
- // the pointee-cast type as the new ElementType and the index
- // being the offset divded by the chunk size. If not, create
- // a new ElementRegion at offset 0 off the raw offset region.
- //
- // (2b) If we don't a get a 'RegionRawOffset' after calling
- // 'getAsRawOffset()', it means that we are at offset 0.
- //
- // FIXME: Handle symbolic raw offsets.
-
- const ElementRegion *elementR = cast<ElementRegion>(R);
- const RegionRawOffset &rawOff = elementR->getAsArrayOffset();
- const MemRegion *baseR = rawOff.getRegion();
-
- // If we cannot compute a raw offset, throw up our hands and return
- // a NULL MemRegion*.
- if (!baseR)
- return std::nullopt;
-
- CharUnits off = rawOff.getOffset();
-
- if (off.isZero()) {
- // Edge case: we are at 0 bytes off the beginning of baseR. We check to
- // see if the type we are casting to is the same as the type of the base
- // region. If so, just return the base region.
- if (IsSameRegionType(baseR, CanonPointeeTy))
- return baseR;
- // Otherwise, create a new ElementRegion at offset 0.
- return MakeElementRegion(cast<SubRegion>(baseR), PointeeTy);
- }
+ case MemRegion::FunctionCodeRegionKind:
+ case MemRegion::BlockCodeRegionKind:
+ case MemRegion::BlockDataRegionKind:
+ case MemRegion::StringRegionKind:
+ // FIXME: Need to handle arbitrary downcasts.
+ case MemRegion::SymbolicRegionKind:
+ case MemRegion::AllocaRegionKind:
+ case MemRegion::CompoundLiteralRegionKind:
+ case MemRegion::FieldRegionKind:
+ case MemRegion::ObjCIvarRegionKind:
+ case MemRegion::ObjCStringRegionKind:
+ case MemRegion::NonParamVarRegionKind:
+ case MemRegion::ParamVarRegionKind:
+ case MemRegion::CXXTempObjectRegionKind:
+ case MemRegion::CXXLifetimeExtendedObjectRegionKind:
+ case MemRegion::CXXBaseObjectRegionKind:
+ case MemRegion::CXXDerivedObjectRegionKind:
+ return MakeElementRegion(cast<SubRegion>(R), PointeeTy);
+
+ case MemRegion::ElementRegionKind: {
+ // If we are casting from an ElementRegion to another type, the
+ // algorithm is as follows:
+ //
+ // (1) Compute the "raw offset" of the ElementRegion from the
+ // base region. This is done by calling 'getAsRawOffset()'.
+ //
+ // (2a) If we get a 'RegionRawOffset' after calling
+ // 'getAsRawOffset()', determine if the absolute offset
+ // can be exactly divided into chunks of the size of the
+ // casted-pointee type. If so, create a new ElementRegion with
+ // the pointee-cast type as the new ElementType and the index
+ // being the offset divded by the chunk size. If not, create
+ // a new ElementRegion at offset 0 off the raw offset region.
+ //
+ // (2b) If we don't a get a 'RegionRawOffset' after calling
+ // 'getAsRawOffset()', it means that we are at offset 0.
+ //
+ // FIXME: Handle symbolic raw offsets.
+
+ const ElementRegion *elementR = cast<ElementRegion>(R);
+ const RegionRawOffset &rawOff = elementR->getAsArrayOffset();
+ const MemRegion *baseR = rawOff.getRegion();
+
+ // If we cannot compute a raw offset, throw up our hands and return
+ // a NULL MemRegion*.
+ if (!baseR)
+ return std::nullopt;
+
+ CharUnits off = rawOff.getOffset();
+
+ if (off.isZero()) {
+ // Edge case: we are at 0 bytes off the beginning of baseR. We check to
+ // see if the type we are casting to is the same as the type of the base
+ // region. If so, just return the base region.
+ if (IsSameRegionType(baseR, CanonPointeeTy))
+ return baseR;
+ // Otherwise, create a new ElementRegion at offset 0.
+ return MakeElementRegion(cast<SubRegion>(baseR), PointeeTy);
+ }
- // We have a non-zero offset from the base region. We want to determine
- // if the offset can be evenly divided by sizeof(PointeeTy). If so,
- // we create an ElementRegion whose index is that value. Otherwise, we
- // create two ElementRegions, one that reflects a raw offset and the other
- // that reflects the cast.
-
- // Compute the index for the new ElementRegion.
- int64_t newIndex = 0;
- const MemRegion *newSuperR = nullptr;
-
- // We can only compute sizeof(PointeeTy) if it is a complete type.
- if (!PointeeTy->isIncompleteType()) {
- // Compute the size in **bytes**.
- CharUnits pointeeTySize = Ctx.getTypeSizeInChars(PointeeTy);
- if (!pointeeTySize.isZero()) {
- // Is the offset a multiple of the size? If so, we can layer the
- // ElementRegion (with elementType == PointeeTy) directly on top of
- // the base region.
- if (off % pointeeTySize == 0) {
- newIndex = off / pointeeTySize;
- newSuperR = baseR;
- }
+ // We have a non-zero offset from the base region. We want to determine
+ // if the offset can be evenly divided by sizeof(PointeeTy). If so,
+ // we create an ElementRegion whose index is that value. Otherwise, we
+ // create two ElementRegions, one that reflects a raw offset and the other
+ // that reflects the cast.
+
+ // Compute the index for the new ElementRegion.
+ int64_t newIndex = 0;
+ const MemRegion *newSuperR = nullptr;
+
+ // We can only compute sizeof(PointeeTy) if it is a complete type.
+ if (!PointeeTy->isIncompleteType()) {
+ // Compute the size in **bytes**.
+ CharUnits pointeeTySize = Ctx.getTypeSizeInChars(PointeeTy);
+ if (!pointeeTySize.isZero()) {
+ // Is the offset a multiple of the size? If so, we can layer the
+ // ElementRegion (with elementType == PointeeTy) directly on top of
+ // the base region.
+ if (off % pointeeTySize == 0) {
+ newIndex = off / pointeeTySize;
+ newSuperR = baseR;
}
}
+ }
- if (!newSuperR) {
- // Create an intermediate ElementRegion to represent the raw byte.
- // This will be the super region of the final ElementRegion.
- newSuperR = MakeElementRegion(cast<SubRegion>(baseR), Ctx.CharTy,
- off.getQuantity());
- }
-
- return MakeElementRegion(cast<SubRegion>(newSuperR), PointeeTy, newIndex);
+ if (!newSuperR) {
+ // Create an intermediate ElementRegion to represent the raw byte.
+ // This will be the super region of the final ElementRegion.
+ newSuperR = MakeElementRegion(cast<SubRegion>(baseR), Ctx.CharTy,
+ off.getQuantity());
}
+
+ return MakeElementRegion(cast<SubRegion>(newSuperR), PointeeTy, newIndex);
+ }
}
llvm_unreachable("unreachable");
@@ -267,8 +266,7 @@ SVal StoreManager::evalDerivedToBase(SVal Derived, const CXXBasePath &Path) {
// Walk through the path to create nested CXXBaseRegions.
SVal Result = Derived;
for (const auto &I : Path)
- Result = evalDerivedToBase(Result, I.Base->getType(),
- I.Base->isVirtual());
+ Result = evalDerivedToBase(Result, I.Base->getType(), I.Base->isVirtual());
return Result;
}
@@ -400,7 +398,7 @@ SVal StoreManager::getLValueFieldOrIvar(const Decl *D, SVal Base) {
return Base;
Loc BaseL = Base.castAs<Loc>();
- const SubRegion* BaseR = nullptr;
+ const SubRegion *BaseR = nullptr;
switch (BaseL.getKind()) {
case loc::MemRegionValKind:
@@ -482,8 +480,8 @@ SVal StoreManager::getLValueElement(QualType elementType, NonLoc Offset,
// p[1] = 8;
//
// Observe that 'p' binds to an AllocaRegion.
- return loc::MemRegionVal(MRMgr.getElementRegion(elementType, Offset,
- BaseRegion, Ctx));
+ return loc::MemRegionVal(
+ MRMgr.getElementRegion(elementType, Offset, BaseRegion, Ctx));
}
SVal BaseIdx = ElemR->getIndex();
@@ -505,24 +503,24 @@ SVal StoreManager::getLValueElement(QualType elementType, NonLoc Offset,
elementType, Offset, cast<SubRegion>(ElemR->getSuperRegion()), Ctx));
}
- const llvm::APSInt& OffI = Offset.castAs<nonloc::ConcreteInt>().getValue();
+ const llvm::APSInt &OffI = Offset.castAs<nonloc::ConcreteInt>().getValue();
assert(BaseIdxI.isSigned());
// Compute the new index.
- nonloc::ConcreteInt NewIdx(svalBuilder.getBasicValueFactory().getValue(BaseIdxI +
- OffI));
+ nonloc::ConcreteInt NewIdx(
+ svalBuilder.getBasicValueFactory().getValue(BaseIdxI + OffI));
// Construct the new ElementRegion.
const SubRegion *ArrayR = cast<SubRegion>(ElemR->getSuperRegion());
- return loc::MemRegionVal(MRMgr.getElementRegion(elementType, NewIdx, ArrayR,
- Ctx));
+ return loc::MemRegionVal(
+ MRMgr.getElementRegion(elementType, NewIdx, ArrayR, Ctx));
}
StoreManager::BindingsHandler::~BindingsHandler() = default;
-bool StoreManager::FindUniqueBinding::HandleBinding(StoreManager& SMgr,
+bool StoreManager::FindUniqueBinding::HandleBinding(StoreManager &SMgr,
Store store,
- const MemRegion* R,
+ const MemRegion *R,
SVal val) {
SymbolRef SymV = val.getAsLocSymbol();
if (!SymV || SymV != Sym)
@@ -531,8 +529,7 @@ bool StoreManager::FindUniqueBinding::HandleBinding(StoreManager& SMgr,
if (Binding) {
First = false;
return false;
- }
- else
+ } else
Binding = R;
return true;
diff --git a/clang/lib/StaticAnalyzer/Core/SymbolManager.cpp b/clang/lib/StaticAnalyzer/Core/SymbolManager.cpp
index 9025e11a3f51a3..dbb7a0acf0dcbd 100644
--- a/clang/lib/StaticAnalyzer/Core/SymbolManager.cpp
+++ b/clang/lib/StaticAnalyzer/Core/SymbolManager.cpp
@@ -135,36 +135,36 @@ void SymExpr::symbol_iterator::expand() {
const SymExpr *SE = itr.pop_back_val();
switch (SE->getKind()) {
- case SymExpr::SymbolRegionValueKind:
- case SymExpr::SymbolConjuredKind:
- case SymExpr::SymbolDerivedKind:
- case SymExpr::SymbolExtentKind:
- case SymExpr::SymbolMetadataKind:
- return;
- case SymExpr::SymbolCastKind:
- itr.push_back(cast<SymbolCast>(SE)->getOperand());
- return;
- case SymExpr::UnarySymExprKind:
- itr.push_back(cast<UnarySymExpr>(SE)->getOperand());
- return;
- case SymExpr::SymIntExprKind:
- itr.push_back(cast<SymIntExpr>(SE)->getLHS());
- return;
- case SymExpr::IntSymExprKind:
- itr.push_back(cast<IntSymExpr>(SE)->getRHS());
- return;
- case SymExpr::SymSymExprKind: {
- const auto *x = cast<SymSymExpr>(SE);
- itr.push_back(x->getLHS());
- itr.push_back(x->getRHS());
- return;
- }
+ case SymExpr::SymbolRegionValueKind:
+ case SymExpr::SymbolConjuredKind:
+ case SymExpr::SymbolDerivedKind:
+ case SymExpr::SymbolExtentKind:
+ case SymExpr::SymbolMetadataKind:
+ return;
+ case SymExpr::SymbolCastKind:
+ itr.push_back(cast<SymbolCast>(SE)->getOperand());
+ return;
+ case SymExpr::UnarySymExprKind:
+ itr.push_back(cast<UnarySymExpr>(SE)->getOperand());
+ return;
+ case SymExpr::SymIntExprKind:
+ itr.push_back(cast<SymIntExpr>(SE)->getLHS());
+ return;
+ case SymExpr::IntSymExprKind:
+ itr.push_back(cast<IntSymExpr>(SE)->getRHS());
+ return;
+ case SymExpr::SymSymExprKind: {
+ const auto *x = cast<SymSymExpr>(SE);
+ itr.push_back(x->getLHS());
+ itr.push_back(x->getRHS());
+ return;
+ }
}
llvm_unreachable("unhandled expansion case");
}
-const SymbolRegionValue*
-SymbolManager::getRegionValueSymbol(const TypedValueRegion* R) {
+const SymbolRegionValue *
+SymbolManager::getRegionValueSymbol(const TypedValueRegion *R) {
llvm::FoldingSetNodeID profile;
SymbolRegionValue::Profile(profile, R);
void *InsertPos;
@@ -178,17 +178,17 @@ SymbolManager::getRegionValueSymbol(const TypedValueRegion* R) {
return cast<SymbolRegionValue>(SD);
}
-const SymbolConjured* SymbolManager::conjureSymbol(const Stmt *E,
+const SymbolConjured *SymbolManager::conjureSymbol(const Stmt *E,
const LocationContext *LCtx,
- QualType T,
- unsigned Count,
+ QualType T, unsigned Count,
const void *SymbolTag) {
llvm::FoldingSetNodeID profile;
SymbolConjured::Profile(profile, E, T, Count, LCtx, SymbolTag);
void *InsertPos;
SymExpr *SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
if (!SD) {
- SD = new (BPAlloc) SymbolConjured(SymbolCounter, E, LCtx, T, Count, SymbolTag);
+ SD = new (BPAlloc)
+ SymbolConjured(SymbolCounter, E, LCtx, T, Count, SymbolTag);
DataSet.InsertNode(SD, InsertPos);
++SymbolCounter;
}
@@ -196,7 +196,7 @@ const SymbolConjured* SymbolManager::conjureSymbol(const Stmt *E,
return cast<SymbolConjured>(SD);
}
-const SymbolDerived*
+const SymbolDerived *
SymbolManager::getDerivedSymbol(SymbolRef parentSymbol,
const TypedValueRegion *R) {
llvm::FoldingSetNodeID profile;
@@ -212,8 +212,7 @@ SymbolManager::getDerivedSymbol(SymbolRef parentSymbol,
return cast<SymbolDerived>(SD);
}
-const SymbolExtent*
-SymbolManager::getExtentSymbol(const SubRegion *R) {
+const SymbolExtent *SymbolManager::getExtentSymbol(const SubRegion *R) {
llvm::FoldingSetNodeID profile;
SymbolExtent::Profile(profile, R);
void *InsertPos;
@@ -228,15 +227,16 @@ SymbolManager::getExtentSymbol(const SubRegion *R) {
}
const SymbolMetadata *
-SymbolManager::getMetadataSymbol(const MemRegion* R, const Stmt *S, QualType T,
- const LocationContext *LCtx,
- unsigned Count, const void *SymbolTag) {
+SymbolManager::getMetadataSymbol(const MemRegion *R, const Stmt *S, QualType T,
+ const LocationContext *LCtx, unsigned Count,
+ const void *SymbolTag) {
llvm::FoldingSetNodeID profile;
SymbolMetadata::Profile(profile, R, S, T, LCtx, Count, SymbolTag);
void *InsertPos;
SymExpr *SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
if (!SD) {
- SD = new (BPAlloc) SymbolMetadata(SymbolCounter, R, S, T, LCtx, Count, SymbolTag);
+ SD = new (BPAlloc)
+ SymbolMetadata(SymbolCounter, R, S, T, LCtx, Count, SymbolTag);
DataSet.InsertNode(SD, InsertPos);
++SymbolCounter;
}
@@ -244,9 +244,8 @@ SymbolManager::getMetadataSymbol(const MemRegion* R, const Stmt *S, QualType T,
return cast<SymbolMetadata>(SD);
}
-const SymbolCast*
-SymbolManager::getCastSymbol(const SymExpr *Op,
- QualType From, QualType To) {
+const SymbolCast *SymbolManager::getCastSymbol(const SymExpr *Op, QualType From,
+ QualType To) {
llvm::FoldingSetNodeID ID;
SymbolCast::Profile(ID, Op, From, To);
void *InsertPos;
@@ -261,7 +260,7 @@ SymbolManager::getCastSymbol(const SymExpr *Op,
const SymIntExpr *SymbolManager::getSymIntExpr(const SymExpr *lhs,
BinaryOperator::Opcode op,
- const llvm::APSInt& v,
+ const llvm::APSInt &v,
QualType t) {
llvm::FoldingSetNodeID ID;
SymIntExpr::Profile(ID, lhs, op, v, t);
@@ -276,10 +275,9 @@ const SymIntExpr *SymbolManager::getSymIntExpr(const SymExpr *lhs,
return cast<SymIntExpr>(data);
}
-const IntSymExpr *SymbolManager::getIntSymExpr(const llvm::APSInt& lhs,
+const IntSymExpr *SymbolManager::getIntSymExpr(const llvm::APSInt &lhs,
BinaryOperator::Opcode op,
- const SymExpr *rhs,
- QualType t) {
+ const SymExpr *rhs, QualType t) {
llvm::FoldingSetNodeID ID;
IntSymExpr::Profile(ID, lhs, op, rhs, t);
void *InsertPos;
@@ -295,8 +293,7 @@ const IntSymExpr *SymbolManager::getIntSymExpr(const llvm::APSInt& lhs,
const SymSymExpr *SymbolManager::getSymSymExpr(const SymExpr *lhs,
BinaryOperator::Opcode op,
- const SymExpr *rhs,
- QualType t) {
+ const SymExpr *rhs, QualType t) {
llvm::FoldingSetNodeID ID;
SymSymExpr::Profile(ID, lhs, op, rhs, t);
void *InsertPos;
@@ -325,26 +322,18 @@ const UnarySymExpr *SymbolManager::getUnarySymExpr(const SymExpr *Operand,
return cast<UnarySymExpr>(data);
}
-QualType SymbolConjured::getType() const {
- return T;
-}
+QualType SymbolConjured::getType() const { return T; }
-QualType SymbolDerived::getType() const {
- return R->getValueType();
-}
+QualType SymbolDerived::getType() const { return R->getValueType(); }
QualType SymbolExtent::getType() const {
ASTContext &Ctx = R->getMemRegionManager().getContext();
return Ctx.getSizeType();
}
-QualType SymbolMetadata::getType() const {
- return T;
-}
+QualType SymbolMetadata::getType() const { return T; }
-QualType SymbolRegionValue::getType() const {
- return R->getValueType();
-}
+QualType SymbolRegionValue::getType() const { return R->getValueType(); }
bool SymbolManager::canSymbolicate(QualType T) {
T = T.getCanonicalType();
@@ -370,8 +359,8 @@ void SymbolManager::addSymbolDependency(const SymbolRef Primary,
dependencies->push_back(Dependent);
}
-const SymbolRefSmallVectorTy *SymbolManager::getDependentSymbols(
- const SymbolRef Primary) {
+const SymbolRefSmallVectorTy *
+SymbolManager::getDependentSymbols(const SymbolRef Primary) {
SymbolDependTy::const_iterator I = SymbolDependencies.find(Primary);
if (I == SymbolDependencies.end())
return nullptr;
@@ -507,8 +496,8 @@ bool SymbolReaper::isLive(SymbolRef sym) {
return KnownLive;
}
-bool
-SymbolReaper::isLive(const Expr *ExprVal, const LocationContext *ELCtx) const {
+bool SymbolReaper::isLive(const Expr *ExprVal,
+ const LocationContext *ELCtx) const {
if (LCtx == nullptr)
return false;
@@ -528,7 +517,8 @@ SymbolReaper::isLive(const Expr *ExprVal, const LocationContext *ELCtx) const {
return LCtx->getAnalysis<RelaxedLiveVariables>()->isLive(Loc, ExprVal);
}
-bool SymbolReaper::isLive(const VarRegion *VR, bool includeStoreBindings) const{
+bool SymbolReaper::isLive(const VarRegion *VR,
+ bool includeStoreBindings) const {
const StackFrameContext *VarContext = VR->getStackFrame();
if (!VarContext)
@@ -555,7 +545,7 @@ bool SymbolReaper::isLive(const VarRegion *VR, bool includeStoreBindings) const{
return false;
unsigned &cachedQuery =
- const_cast<SymbolReaper *>(this)->includedRegionCache[VR];
+ const_cast<SymbolReaper *>(this)->includedRegionCache[VR];
if (cachedQuery) {
return cachedQuery == 1;
@@ -564,7 +554,7 @@ bool SymbolReaper::isLive(const VarRegion *VR, bool includeStoreBindings) const{
// Query the store to see if the region occurs in any live bindings.
if (Store store = reapedStore.getStore()) {
bool hasRegion =
- reapedStore.getStoreManager().includedInBindings(store, VR);
+ reapedStore.getStoreManager().includedInBindings(store, VR);
cachedQuery = hasRegion ? 1 : 2;
return hasRegion;
}
diff --git a/clang/lib/StaticAnalyzer/Core/TextDiagnostics.cpp b/clang/lib/StaticAnalyzer/Core/TextDiagnostics.cpp
index 71268af22e2424..c97b360eb6ee87 100644
--- a/clang/lib/StaticAnalyzer/Core/TextDiagnostics.cpp
+++ b/clang/lib/StaticAnalyzer/Core/TextDiagnostics.cpp
@@ -102,8 +102,7 @@ class TextDiagnostics : public PathDiagnosticConsumer {
continue;
reportPiece(NoteID, Piece->getLocation().asLocation(),
- Piece->getString(), Piece->getRanges(),
- Piece->getFixits());
+ Piece->getString(), Piece->getRanges(), Piece->getFixits());
}
if (!ShouldDisplayPathNotes)
@@ -116,8 +115,7 @@ class TextDiagnostics : public PathDiagnosticConsumer {
continue;
reportPiece(NoteID, Piece->getLocation().asLocation(),
- Piece->getString(), Piece->getRanges(),
- Piece->getFixits());
+ Piece->getString(), Piece->getRanges(), Piece->getFixits());
}
}
diff --git a/clang/lib/StaticAnalyzer/Core/WorkList.cpp b/clang/lib/StaticAnalyzer/Core/WorkList.cpp
index 7042a9020837a4..41dbee0287b550 100644
--- a/clang/lib/StaticAnalyzer/Core/WorkList.cpp
+++ b/clang/lib/StaticAnalyzer/Core/WorkList.cpp
@@ -11,9 +11,9 @@
//===----------------------------------------------------------------------===//
#include "clang/StaticAnalyzer/Core/PathSensitive/WorkList.h"
-#include "llvm/ADT/PriorityQueue.h"
-#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/PriorityQueue.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Statistic.h"
#include <deque>
@@ -37,17 +37,13 @@ class DFS : public WorkList {
SmallVector<WorkListUnit, 20> Stack;
public:
- bool hasWork() const override {
- return !Stack.empty();
- }
+ bool hasWork() const override { return !Stack.empty(); }
- void enqueue(const WorkListUnit& U) override {
- Stack.push_back(U);
- }
+ void enqueue(const WorkListUnit &U) override { Stack.push_back(U); }
WorkListUnit dequeue() override {
assert(!Stack.empty());
- const WorkListUnit& U = Stack.back();
+ const WorkListUnit &U = Stack.back();
Stack.pop_back(); // This technically "invalidates" U, but we are fine.
return U;
}
@@ -57,13 +53,9 @@ class BFS : public WorkList {
std::deque<WorkListUnit> Queue;
public:
- bool hasWork() const override {
- return !Queue.empty();
- }
+ bool hasWork() const override { return !Queue.empty(); }
- void enqueue(const WorkListUnit& U) override {
- Queue.push_back(U);
- }
+ void enqueue(const WorkListUnit &U) override { Queue.push_back(U); }
WorkListUnit dequeue() override {
WorkListUnit U = Queue.front();
@@ -88,38 +80,36 @@ std::unique_ptr<WorkList> WorkList::makeBFS() {
namespace {
- class BFSBlockDFSContents : public WorkList {
- std::deque<WorkListUnit> Queue;
- SmallVector<WorkListUnit, 20> Stack;
-
- public:
- bool hasWork() const override {
- return !Queue.empty() || !Stack.empty();
- }
+class BFSBlockDFSContents : public WorkList {
+ std::deque<WorkListUnit> Queue;
+ SmallVector<WorkListUnit, 20> Stack;
- void enqueue(const WorkListUnit& U) override {
- if (U.getNode()->getLocation().getAs<BlockEntrance>())
- Queue.push_front(U);
- else
- Stack.push_back(U);
- }
+public:
+ bool hasWork() const override { return !Queue.empty() || !Stack.empty(); }
- WorkListUnit dequeue() override {
- // Process all basic blocks to completion.
- if (!Stack.empty()) {
- const WorkListUnit& U = Stack.back();
- Stack.pop_back(); // This technically "invalidates" U, but we are fine.
- return U;
- }
+ void enqueue(const WorkListUnit &U) override {
+ if (U.getNode()->getLocation().getAs<BlockEntrance>())
+ Queue.push_front(U);
+ else
+ Stack.push_back(U);
+ }
- assert(!Queue.empty());
- // Don't use const reference. The subsequent pop_back() might make it
- // unsafe.
- WorkListUnit U = Queue.front();
- Queue.pop_front();
+ WorkListUnit dequeue() override {
+ // Process all basic blocks to completion.
+ if (!Stack.empty()) {
+ const WorkListUnit &U = Stack.back();
+ Stack.pop_back(); // This technically "invalidates" U, but we are fine.
return U;
}
- };
+
+ assert(!Queue.empty());
+ // Don't use const reference. The subsequent pop_back() might make it
+ // unsafe.
+ WorkListUnit U = Queue.front();
+ Queue.pop_front();
+ return U;
+ }
+};
} // namespace
@@ -155,9 +145,9 @@ class UnexploredFirstStack : public WorkList {
// correct.
StackUnexplored.push_back(U);
} else {
- LocIdentifier LocId = std::make_pair(
- BE->getBlock()->getBlockID(),
- N->getLocationContext()->getStackFrame());
+ LocIdentifier LocId =
+ std::make_pair(BE->getBlock()->getBlockID(),
+ N->getLocationContext()->getStackFrame());
auto InsertInfo = Reachable.insert(LocId);
if (InsertInfo.second) {
@@ -217,17 +207,15 @@ class UnexploredFirstPriorityQueue : public WorkList {
queue;
public:
- bool hasWork() const override {
- return !queue.empty();
- }
+ bool hasWork() const override { return !queue.empty(); }
void enqueue(const WorkListUnit &U) override {
const ExplodedNode *N = U.getNode();
unsigned NumVisited = 0;
if (auto BE = N->getLocation().getAs<BlockEntrance>()) {
- LocIdentifier LocId = std::make_pair(
- BE->getBlock()->getBlockID(),
- N->getLocationContext()->getStackFrame());
+ LocIdentifier LocId =
+ std::make_pair(BE->getBlock()->getBlockID(),
+ N->getLocationContext()->getStackFrame());
NumVisited = NumReached[LocId]++;
}
@@ -273,9 +261,7 @@ class UnexploredFirstPriorityLocationQueue : public WorkList {
queue;
public:
- bool hasWork() const override {
- return !queue.empty();
- }
+ bool hasWork() const override { return !queue.empty(); }
void enqueue(const WorkListUnit &U) override {
const ExplodedNode *N = U.getNode();
@@ -291,10 +277,9 @@ class UnexploredFirstPriorityLocationQueue : public WorkList {
queue.pop();
return U.first;
}
-
};
-}
+} // namespace
std::unique_ptr<WorkList> WorkList::makeUnexploredFirstPriorityLocationQueue() {
return std::make_unique<UnexploredFirstPriorityLocationQueue>();
diff --git a/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp b/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp
index b6ef40595e3c97..0da1a48b17bd5a 100644
--- a/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp
+++ b/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp
@@ -52,10 +52,10 @@ using namespace ento;
STATISTIC(NumFunctionTopLevel, "The # of functions at top level.");
STATISTIC(NumFunctionsAnalyzed,
- "The # of functions and blocks analyzed (as top level "
- "with inlining turned on).");
+ "The # of functions and blocks analyzed (as top level "
+ "with inlining turned on).");
STATISTIC(NumBlocksInAnalyzedFunctions,
- "The # of basic blocks in the analyzed functions.");
+ "The # of basic blocks in the analyzed functions.");
STATISTIC(NumVisitedBlocksInAnalyzedFunctions,
"The # of visited basic blocks in the analyzed functions.");
STATISTIC(PercentReachableBlocks, "The % of reachable basic blocks.");
@@ -69,11 +69,7 @@ namespace {
class AnalysisConsumer : public AnalysisASTConsumer,
public RecursiveASTVisitor<AnalysisConsumer> {
- enum {
- AM_None = 0,
- AM_Syntax = 0x1,
- AM_Path = 0x2
- };
+ enum { AM_None = 0, AM_Syntax = 0x1, AM_Path = 0x2 };
typedef unsigned AnalysisMode;
/// Mode of the analyzes while recursively visiting Decls.
@@ -124,14 +120,13 @@ class AnalysisConsumer : public AnalysisASTConsumer,
AnalyzerOptions &opts, ArrayRef<std::string> plugins,
CodeInjector *injector)
: RecVisitorMode(0), RecVisitorBR(nullptr), Ctx(nullptr),
- PP(CI.getPreprocessor()), OutDir(outdir), Opts(opts),
- Plugins(plugins), Injector(injector), CTU(CI),
- MacroExpansions(CI.getLangOpts()) {
+ PP(CI.getPreprocessor()), OutDir(outdir), Opts(opts), Plugins(plugins),
+ Injector(injector), CTU(CI), MacroExpansions(CI.getLangOpts()) {
DigestAnalyzerOptions();
if (Opts.AnalyzerDisplayProgress || Opts.PrintStats ||
Opts.ShouldSerializeStats) {
- AnalyzerTimers = std::make_unique<llvm::TimerGroup>(
- "analyzer", "Analyzer timers");
+ AnalyzerTimers =
+ std::make_unique<llvm::TimerGroup>("analyzer", "Analyzer timers");
SyntaxCheckTimer = std::make_unique<llvm::Timer>(
"syntaxchecks", "Syntax-based analysis time", *AnalyzerTimers);
ExprEngineTimer = std::make_unique<llvm::Timer>(
@@ -161,7 +156,7 @@ class AnalysisConsumer : public AnalysisASTConsumer,
break;
#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATEFN) \
case PD_##NAME: \
- CREATEFN(Opts.getDiagOpts(), PathConsumers, OutDir, PP, CTU, \
+ CREATEFN(Opts.getDiagOpts(), PathConsumers, OutDir, PP, CTU, \
MacroExpansions); \
break;
#include "clang/StaticAnalyzer/Core/Analyses.def"
@@ -175,8 +170,10 @@ class AnalysisConsumer : public AnalysisASTConsumer,
switch (Opts.AnalysisConstraintsOpt) {
default:
llvm_unreachable("Unknown constraint manager.");
-#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATEFN) \
- case NAME##Model: CreateConstraintMgr = CREATEFN; break;
+#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATEFN) \
+ case NAME##Model: \
+ CreateConstraintMgr = CREATEFN; \
+ break;
#include "clang/StaticAnalyzer/Core/Analyses.def"
}
}
@@ -241,7 +238,7 @@ class AnalysisConsumer : public AnalysisASTConsumer,
/// analyzed. This allows to redefine the default inlining policies when
/// analyzing a given function.
ExprEngine::InliningModes
- getInliningModeForFunction(const Decl *D, const SetOfConstDecls &Visited);
+ getInliningModeForFunction(const Decl *D, const SetOfConstDecls &Visited);
/// Build the call graph for all the top level decls of this TU and
/// use it to define the order in which the functions should be visited.
@@ -257,8 +254,7 @@ class AnalysisConsumer : public AnalysisASTConsumer,
ExprEngine::InliningModes IMode = ExprEngine::Inline_Minimal,
SetOfConstDecls *VisitedCallees = nullptr);
- void RunPathSensitiveChecks(Decl *D,
- ExprEngine::InliningModes IMode,
+ void RunPathSensitiveChecks(Decl *D, ExprEngine::InliningModes IMode,
SetOfConstDecls *VisitedCallees);
/// Visitors for the RecursiveASTVisitor.
@@ -292,9 +288,8 @@ class AnalysisConsumer : public AnalysisASTConsumer,
if (VD->getAnyInitializer())
return true;
- llvm::Expected<const VarDecl *> CTUDeclOrError =
- CTU.getCrossTUDefinition(VD, Opts.CTUDir, Opts.CTUIndexName,
- Opts.DisplayCTUProgress);
+ llvm::Expected<const VarDecl *> CTUDeclOrError = CTU.getCrossTUDefinition(
+ VD, Opts.CTUDir, Opts.CTUIndexName, Opts.DisplayCTUProgress);
if (!CTUDeclOrError) {
handleAllErrors(CTUDeclOrError.takeError(),
@@ -313,8 +308,7 @@ class AnalysisConsumer : public AnalysisASTConsumer,
// We skip function template definitions, as their semantics is
// only determined when they are instantiated.
- if (FD->isThisDeclarationADefinition() &&
- !FD->isDependentContext()) {
+ if (FD->isThisDeclarationADefinition() && !FD->isDependentContext()) {
assert(RecVisitorMode == AM_Syntax || Mgr->shouldInlineCall() == false);
HandleCode(FD, RecVisitorMode);
}
@@ -345,7 +339,8 @@ class AnalysisConsumer : public AnalysisASTConsumer,
PathConsumers.push_back(Consumer);
}
- void AddCheckerRegistrationFn(std::function<void(CheckerRegistry&)> Fn) override {
+ void
+ AddCheckerRegistrationFn(std::function<void(CheckerRegistry &)> Fn) override {
CheckerRegistrationFns.push_back(std::move(Fn));
}
@@ -361,7 +356,6 @@ class AnalysisConsumer : public AnalysisASTConsumer,
}; // namespace
} // end anonymous namespace
-
//===----------------------------------------------------------------------===//
// AnalysisConsumer implementation.
//===----------------------------------------------------------------------===//
@@ -386,8 +380,7 @@ void AnalysisConsumer::storeTopLevelDecls(DeclGroupRef DG) {
}
}
-static bool shouldSkipFunction(const Decl *D,
- const SetOfConstDecls &Visited,
+static bool shouldSkipFunction(const Decl *D, const SetOfConstDecls &Visited,
const SetOfConstDecls &VisitedAsTopLevel) {
if (VisitedAsTopLevel.count(D))
return true;
@@ -441,7 +434,7 @@ void AnalysisConsumer::HandleDeclsCallGraph(const unsigned LocalTUDeclsSize) {
// (though HandleInterestingDecl); triggering additions to LocalTUDecls.
// We rely on random access to add the initially processed Decls to CG.
CallGraph CG;
- for (unsigned i = 0 ; i < LocalTUDeclsSize ; ++i) {
+ for (unsigned i = 0; i < LocalTUDeclsSize; ++i) {
CG.addToCallGraph(LocalTUDecls[i]);
}
@@ -453,7 +446,7 @@ void AnalysisConsumer::HandleDeclsCallGraph(const unsigned LocalTUDeclsSize) {
// often.
SetOfConstDecls Visited;
SetOfConstDecls VisitedAsTopLevel;
- llvm::ReversePostOrderTraversal<clang::CallGraph*> RPOT(&CG);
+ llvm::ReversePostOrderTraversal<clang::CallGraph *> RPOT(&CG);
for (auto &N : RPOT) {
NumFunctionTopLevel++;
@@ -549,7 +542,7 @@ void AnalysisConsumer::runAnalysisOnTranslationUnit(ASTContext &C) {
// random access. By doing so, we automatically compensate for iterators
// possibly being invalidated, although this is a bit slower.
const unsigned LocalTUDeclsSize = LocalTUDecls.size();
- for (unsigned i = 0 ; i < LocalTUDeclsSize ; ++i) {
+ for (unsigned i = 0; i < LocalTUDeclsSize; ++i) {
TraverseDecl(LocalTUDecls[i]);
}
diff --git a/clang/lib/StaticAnalyzer/Frontend/AnalyzerHelpFlags.cpp b/clang/lib/StaticAnalyzer/Frontend/AnalyzerHelpFlags.cpp
index ea75c794f0b703..0508e91d034c4c 100644
--- a/clang/lib/StaticAnalyzer/Frontend/AnalyzerHelpFlags.cpp
+++ b/clang/lib/StaticAnalyzer/Frontend/AnalyzerHelpFlags.cpp
@@ -78,24 +78,18 @@ USAGE: -analyzer-config <OPTION1=VALUE,OPTION2=VALUE,...>
using OptionAndDescriptionTy = std::pair<StringRef, std::string>;
OptionAndDescriptionTy PrintableOptions[] = {
#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
- { \
- CMDFLAG, \
- llvm::Twine(llvm::Twine() + "(" + \
- (StringRef(#TYPE) == "StringRef" ? "string" : #TYPE ) + \
- ") " DESC \
- " (default: " #DEFAULT_VAL ")").str() \
- },
+ {CMDFLAG, llvm::Twine(llvm::Twine() + "(" + \
+ (StringRef(#TYPE) == "StringRef" ? "string" : #TYPE) + \
+ ") " DESC " (default: " #DEFAULT_VAL ")") \
+ .str()},
#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
SHALLOW_VAL, DEEP_VAL) \
- { \
- CMDFLAG, \
- llvm::Twine(llvm::Twine() + "(" + \
- (StringRef(#TYPE) == "StringRef" ? "string" : #TYPE ) + \
- ") " DESC \
- " (default: " #SHALLOW_VAL " in shallow mode, " #DEEP_VAL \
- " in deep mode)").str() \
- },
+ {CMDFLAG, llvm::Twine(llvm::Twine() + "(" + \
+ (StringRef(#TYPE) == "StringRef" ? "string" : #TYPE) + \
+ ") " DESC " (default: " #SHALLOW_VAL \
+ " in shallow mode, " #DEEP_VAL " in deep mode)") \
+ .str()},
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
#undef ANALYZER_OPTION
#undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
diff --git a/clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp b/clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp
index 317df90a7781e2..1372ca2223a0c8 100644
--- a/clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp
+++ b/clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp
@@ -419,13 +419,10 @@ void CheckerRegistry::addPackage(StringRef FullName) {
Data.Packages.emplace_back(PackageInfo(FullName));
}
-void CheckerRegistry::addPackageOption(StringRef OptionType,
- StringRef PackageFullName,
- StringRef OptionName,
- StringRef DefaultValStr,
- StringRef Description,
- StringRef DevelopmentStatus,
- bool IsHidden) {
+void CheckerRegistry::addPackageOption(
+ StringRef OptionType, StringRef PackageFullName, StringRef OptionName,
+ StringRef DefaultValStr, StringRef Description, StringRef DevelopmentStatus,
+ bool IsHidden) {
Data.PackageOptions.emplace_back(
PackageFullName, CmdLineOption{OptionType, OptionName, DefaultValStr,
Description, DevelopmentStatus, IsHidden});
@@ -446,13 +443,10 @@ void CheckerRegistry::addChecker(RegisterCheckerFn Rfn,
}
}
-void CheckerRegistry::addCheckerOption(StringRef OptionType,
- StringRef CheckerFullName,
- StringRef OptionName,
- StringRef DefaultValStr,
- StringRef Description,
- StringRef DevelopmentStatus,
- bool IsHidden) {
+void CheckerRegistry::addCheckerOption(
+ StringRef OptionType, StringRef CheckerFullName, StringRef OptionName,
+ StringRef DefaultValStr, StringRef Description, StringRef DevelopmentStatus,
+ bool IsHidden) {
Data.CheckerOptions.emplace_back(
CheckerFullName, CmdLineOption{OptionType, OptionName, DefaultValStr,
Description, DevelopmentStatus, IsHidden});
diff --git a/clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp b/clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp
index ae11fbbe32b762..1c8143ad72bbd6 100644
--- a/clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp
+++ b/clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp
@@ -8,10 +8,10 @@
#include "ModelInjector.h"
#include "clang/AST/Decl.h"
+#include "clang/AST/DeclObjC.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LangStandard.h"
#include "clang/Basic/Stack.h"
-#include "clang/AST/DeclObjC.h"
#include "clang/Frontend/ASTUnit.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendAction.h"
diff --git a/clang/lib/StaticAnalyzer/Frontend/ModelInjector.h b/clang/lib/StaticAnalyzer/Frontend/ModelInjector.h
index 4db26028362fb3..ace3126fc76a9b 100644
--- a/clang/lib/StaticAnalyzer/Frontend/ModelInjector.h
+++ b/clang/lib/StaticAnalyzer/Frontend/ModelInjector.h
@@ -11,10 +11,10 @@
/// clang::CodeInjector interface. This class is responsible for injecting
/// function definitions that were synthesized from model files.
///
-/// Model files allow definitions of functions to be lazily constituted for functions
-/// which lack bodies in the original source code. This allows the analyzer
-/// to more precisely analyze code that calls such functions, analyzing the
-/// artificial definitions (which typically approximate the semantics of the
+/// Model files allow definitions of functions to be lazily constituted for
+/// functions which lack bodies in the original source code. This allows the
+/// analyzer to more precisely analyze code that calls such functions, analyzing
+/// the artificial definitions (which typically approximate the semantics of the
/// called function) when called by client code. These definitions are
/// reconstituted lazily, on-demand, by the static analyzer engine.
///
@@ -60,7 +60,7 @@ class ModelInjector : public CodeInjector {
// BodyFarm.
llvm::StringMap<Stmt *> Bodies;
};
-}
-}
+} // namespace ento
+} // namespace clang
#endif
More information about the cfe-commits
mailing list