This revision was landed with ongoing or failed builds. This revision was automatically updated to reflect the committed changes. Closed by commit rG96fba640cf58: [analyzer][NFC] Factor out the copy-paste code repetition of assumeDual and… (authored by martong).
Repository: rG LLVM Github Monorepo CHANGES SINCE LAST ACTION https://reviews.llvm.org/D125954/new/ https://reviews.llvm.org/D125954 Files: clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h clang/lib/StaticAnalyzer/Core/ConstraintManager.cpp Index: clang/lib/StaticAnalyzer/Core/ConstraintManager.cpp =================================================================== --- clang/lib/StaticAnalyzer/Core/ConstraintManager.cpp +++ clang/lib/StaticAnalyzer/Core/ConstraintManager.cpp @@ -42,12 +42,14 @@ return {}; } +template <typename AssumeFunction> ConstraintManager::ProgramStatePair -ConstraintManager::assumeDual(ProgramStateRef State, DefinedSVal Cond) { - ProgramStateRef StTrue = assumeInternal(State, Cond, true); +ConstraintManager::assumeDualImpl(ProgramStateRef &State, + AssumeFunction &Assume) { + ProgramStateRef StTrue = Assume(true); if (!StTrue) { - ProgramStateRef StFalse = assumeInternal(State, Cond, false); + ProgramStateRef StFalse = Assume(false); if (LLVM_UNLIKELY(!StFalse)) { // both infeasible ProgramStateRef StInfeasible = State->cloneAsPosteriorlyOverconstrained(); assert(StInfeasible->isPosteriorlyOverconstrained()); @@ -63,7 +65,7 @@ return ProgramStatePair(nullptr, StFalse); } - ProgramStateRef StFalse = assumeInternal(State, Cond, false); + ProgramStateRef StFalse = Assume(false); if (!StFalse) { return ProgramStatePair(StTrue, nullptr); } @@ -71,36 +73,22 @@ return ProgramStatePair(StTrue, StFalse); } +ConstraintManager::ProgramStatePair +ConstraintManager::assumeDual(ProgramStateRef State, DefinedSVal Cond) { + auto AssumeFun = [&](bool Assumption) { + return assumeInternal(State, Cond, Assumption); + }; + return assumeDualImpl(State, AssumeFun); +} + ConstraintManager::ProgramStatePair ConstraintManager::assumeInclusiveRangeDual(ProgramStateRef State, NonLoc Value, const llvm::APSInt &From, const llvm::APSInt &To) { - ProgramStateRef StInRange = - assumeInclusiveRangeInternal(State, Value, From, To, true); - if (!StInRange) { - ProgramStateRef StOutOfRange = - assumeInclusiveRangeInternal(State, Value, From, To, false); - if (LLVM_UNLIKELY(!StOutOfRange)) { // both infeasible - ProgramStateRef StInfeasible = State->cloneAsPosteriorlyOverconstrained(); - assert(StInfeasible->isPosteriorlyOverconstrained()); - // Checkers might rely on the API contract that both returned states - // cannot be null. Thus, we return StInfeasible for both branches because - // it might happen that a Checker uncoditionally uses one of them if the - // other is a nullptr. This may also happen with the non-dual and - // adjacent `assume(true)` and `assume(false)` calls. By implementing - // assume in therms of assumeDual, we can keep our API contract there as - // well. - return ProgramStatePair(StInfeasible, StInfeasible); - } - } - - ProgramStateRef StOutOfRange = - assumeInclusiveRangeInternal(State, Value, From, To, false); - if (!StOutOfRange) { - return ProgramStatePair(StInRange, nullptr); - } - - return ProgramStatePair(StInRange, StOutOfRange); + auto AssumeFun = [&](bool Assumption) { + return assumeInclusiveRangeInternal(State, Value, From, To, Assumption); + }; + return assumeDualImpl(State, AssumeFun); } ProgramStateRef ConstraintManager::assume(ProgramStateRef State, Index: clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h =================================================================== --- clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h +++ clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h @@ -162,6 +162,10 @@ /// Returns whether or not a symbol is known to be null ("true"), known to be /// non-null ("false"), or may be either ("underconstrained"). virtual ConditionTruthVal checkNull(ProgramStateRef State, SymbolRef Sym); + + template <typename AssumeFunction> + ProgramStatePair assumeDualImpl(ProgramStateRef &State, + AssumeFunction &Assume); }; std::unique_ptr<ConstraintManager>
Index: clang/lib/StaticAnalyzer/Core/ConstraintManager.cpp =================================================================== --- clang/lib/StaticAnalyzer/Core/ConstraintManager.cpp +++ clang/lib/StaticAnalyzer/Core/ConstraintManager.cpp @@ -42,12 +42,14 @@ return {}; } +template <typename AssumeFunction> ConstraintManager::ProgramStatePair -ConstraintManager::assumeDual(ProgramStateRef State, DefinedSVal Cond) { - ProgramStateRef StTrue = assumeInternal(State, Cond, true); +ConstraintManager::assumeDualImpl(ProgramStateRef &State, + AssumeFunction &Assume) { + ProgramStateRef StTrue = Assume(true); if (!StTrue) { - ProgramStateRef StFalse = assumeInternal(State, Cond, false); + ProgramStateRef StFalse = Assume(false); if (LLVM_UNLIKELY(!StFalse)) { // both infeasible ProgramStateRef StInfeasible = State->cloneAsPosteriorlyOverconstrained(); assert(StInfeasible->isPosteriorlyOverconstrained()); @@ -63,7 +65,7 @@ return ProgramStatePair(nullptr, StFalse); } - ProgramStateRef StFalse = assumeInternal(State, Cond, false); + ProgramStateRef StFalse = Assume(false); if (!StFalse) { return ProgramStatePair(StTrue, nullptr); } @@ -71,36 +73,22 @@ return ProgramStatePair(StTrue, StFalse); } +ConstraintManager::ProgramStatePair +ConstraintManager::assumeDual(ProgramStateRef State, DefinedSVal Cond) { + auto AssumeFun = [&](bool Assumption) { + return assumeInternal(State, Cond, Assumption); + }; + return assumeDualImpl(State, AssumeFun); +} + ConstraintManager::ProgramStatePair ConstraintManager::assumeInclusiveRangeDual(ProgramStateRef State, NonLoc Value, const llvm::APSInt &From, const llvm::APSInt &To) { - ProgramStateRef StInRange = - assumeInclusiveRangeInternal(State, Value, From, To, true); - if (!StInRange) { - ProgramStateRef StOutOfRange = - assumeInclusiveRangeInternal(State, Value, From, To, false); - if (LLVM_UNLIKELY(!StOutOfRange)) { // both infeasible - ProgramStateRef StInfeasible = State->cloneAsPosteriorlyOverconstrained(); - assert(StInfeasible->isPosteriorlyOverconstrained()); - // Checkers might rely on the API contract that both returned states - // cannot be null. Thus, we return StInfeasible for both branches because - // it might happen that a Checker uncoditionally uses one of them if the - // other is a nullptr. This may also happen with the non-dual and - // adjacent `assume(true)` and `assume(false)` calls. By implementing - // assume in therms of assumeDual, we can keep our API contract there as - // well. - return ProgramStatePair(StInfeasible, StInfeasible); - } - } - - ProgramStateRef StOutOfRange = - assumeInclusiveRangeInternal(State, Value, From, To, false); - if (!StOutOfRange) { - return ProgramStatePair(StInRange, nullptr); - } - - return ProgramStatePair(StInRange, StOutOfRange); + auto AssumeFun = [&](bool Assumption) { + return assumeInclusiveRangeInternal(State, Value, From, To, Assumption); + }; + return assumeDualImpl(State, AssumeFun); } ProgramStateRef ConstraintManager::assume(ProgramStateRef State, Index: clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h =================================================================== --- clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h +++ clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h @@ -162,6 +162,10 @@ /// Returns whether or not a symbol is known to be null ("true"), known to be /// non-null ("false"), or may be either ("underconstrained"). virtual ConditionTruthVal checkNull(ProgramStateRef State, SymbolRef Sym); + + template <typename AssumeFunction> + ProgramStatePair assumeDualImpl(ProgramStateRef &State, + AssumeFunction &Assume); }; std::unique_ptr<ConstraintManager>
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits