walkero
/
cppcheck
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Add generic valueflow forward analysis (#2511)

This commit is contained in:
Paul Fultz II 2020-02-13 09:27:06 -06:00 committed by GitHub
parent c472322aad
commit 7368a54629
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
23 changed files with 1028 additions and 857 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Makefile
View File

@ -189,6 +189,7 @@ LIBOBJ = $(libcppdir)/analyzerinfo.o \
$(libcppdir)/ctu.o \
$(libcppdir)/errorlogger.o \
$(libcppdir)/exprengine.o \
$(libcppdir)/forwardanalyzer.o \
$(libcppdir)/importproject.o \
$(libcppdir)/library.o \
$(libcppdir)/mathlib.o \
@ -497,6 +498,9 @@ $(libcppdir)/errorlogger.o: lib/errorlogger.cpp externals/tinyxml/tinyxml2.h lib
$(libcppdir)/exprengine.o: lib/exprengine.cpp lib/astutils.h lib/config.h lib/errorlogger.h lib/exprengine.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/exprengine.o $(libcppdir)/exprengine.cpp
$(libcppdir)/forwardanalyzer.o: lib/forwardanalyzer.cpp lib/astutils.h lib/config.h lib/errorlogger.h lib/forwardanalyzer.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/utils.h lib/valueflow.h lib/valueptr.h
$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/forwardanalyzer.o $(libcppdir)/forwardanalyzer.cpp
$(libcppdir)/importproject.o: lib/importproject.cpp externals/picojson.h externals/tinyxml/tinyxml2.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/importproject.o $(libcppdir)/importproject.cpp
@ -548,7 +552,7 @@ $(libcppdir)/tokenize.o: lib/tokenize.cpp lib/check.h lib/config.h lib/errorlogg
$(libcppdir)/tokenlist.o: lib/tokenlist.cpp externals/simplecpp/simplecpp.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenlist.h lib/utils.h lib/valueflow.h
$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/tokenlist.o $(libcppdir)/tokenlist.cpp
$(libcppdir)/valueflow.o: lib/valueflow.cpp lib/astutils.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/programmemory.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenlist.h lib/utils.h lib/valueflow.h
$(libcppdir)/valueflow.o: lib/valueflow.cpp lib/astutils.h lib/config.h lib/errorlogger.h lib/forwardanalyzer.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/programmemory.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/valueptr.h
$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/valueflow.o $(libcppdir)/valueflow.cpp
cli/cmdlineparser.o: cli/cmdlineparser.cpp cli/cmdlineparser.h cli/cppcheckexecutor.h cli/filelister.h cli/threadexecutor.h externals/tinyxml/tinyxml2.h lib/check.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h

112
lib/astutils.cpp
View File

@ -277,7 +277,8 @@ static bool hasToken(const Token * startTok, const Token * stopTok, const Token
return false;
}
const Token * nextAfterAstRightmostLeaf(const Token * tok)
template <class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*>)>
static T* nextAfterAstRightmostLeafGeneric(T* tok)
{
const Token * rightmostLeaf = tok;
if (!rightmostLeaf || !rightmostLeaf->astOperand1())
@ -295,6 +296,9 @@ const Token * nextAfterAstRightmostLeaf(const Token * tok)
return rightmostLeaf->next();
}
const Token* nextAfterAstRightmostLeaf(const Token* tok) { return nextAfterAstRightmostLeafGeneric(tok); }
Token* nextAfterAstRightmostLeaf(Token* tok) { return nextAfterAstRightmostLeafGeneric(tok); }
const Token* astParentSkipParens(const Token* tok)
{
return astParentSkipParens(const_cast<Token*>(tok));
@ -355,6 +359,43 @@ bool astIsRHS(const Token* tok)
return parent->astOperand2() == tok;
}
template <class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*>)>
static T* getCondTokImpl(T* tok)
{
if (!tok)
return nullptr;
if (Token::simpleMatch(tok, "("))
return getCondTok(tok->previous());
if (Token::simpleMatch(tok, "for") && Token::simpleMatch(tok->next()->astOperand2(), ";") &&
tok->next()->astOperand2()->astOperand2())
return tok->next()->astOperand2()->astOperand2()->astOperand1();
if (Token::simpleMatch(tok->next()->astOperand2(), ";"))
return tok->next()->astOperand2()->astOperand1();
return tok->next()->astOperand2();
}
template <class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*>)>
static T* getCondTokFromEndImpl(T* endBlock)
{
if (!Token::simpleMatch(endBlock, "}"))
return nullptr;
T* startBlock = endBlock->link();
if (!Token::simpleMatch(startBlock, "{"))
return nullptr;
if (Token::simpleMatch(startBlock->previous(), ")")) {
return getCondTok(startBlock->previous()->link());
} else if (Token::simpleMatch(startBlock->tokAt(-2), "} else {")) {
return getCondTokFromEnd(startBlock->tokAt(-2));
}
return nullptr;
}
Token* getCondTok(Token* tok) { return getCondTokImpl(tok); }
const Token* getCondTok(const Token* tok) { return getCondTokImpl(tok); }
Token* getCondTokFromEnd(Token* endBlock) { return getCondTokFromEndImpl(endBlock); }
const Token* getCondTokFromEnd(const Token* endBlock) { return getCondTokFromEndImpl(endBlock); }
static const Token * getVariableInitExpression(const Variable * var)
{
if (!var || !var->declEndToken())
@ -1001,7 +1042,24 @@ static bool isEscapedOrJump(const Token* tok, bool functionsScope)
return Token::Match(tok, "return|goto|throw|continue|break");
}
bool isReturnScope(const Token * const endToken, const Library * library, bool functionScope)
bool isEscapeFunction(const Token* ftok, const Library* library)
{
if (!Token::Match(ftok, "%name% ("))
return false;
const Function* function = ftok->function();
if (function) {
if (function->isEscapeFunction())
return true;
if (function->isAttributeNoreturn())
return true;
} else if (library) {
if (library->isnoreturn(ftok))
return true;
}
return false;
}
bool isReturnScope(const Token* const endToken, const Library* library, const Token** unknownFunc, bool functionScope)
{
if (!endToken || endToken->str() != "}")
return false;
@ -1014,7 +1072,8 @@ bool isReturnScope(const Token * const endToken, const Library * library, bool f
if (Token::simpleMatch(prev, "}")) {
if (Token::simpleMatch(prev->link()->tokAt(-2), "} else {"))
return isReturnScope(prev, library, functionScope) && isReturnScope(prev->link()->tokAt(-2), library, functionScope);
return isReturnScope(prev, library, unknownFunc, functionScope) &&
isReturnScope(prev->link()->tokAt(-2), library, unknownFunc, functionScope);
if (Token::simpleMatch(prev->link()->previous(), ") {") &&
Token::simpleMatch(prev->link()->linkAt(-1)->previous(), "switch (") &&
!Token::findsimplematch(prev->link(), "break", prev)) {
@ -1023,7 +1082,7 @@ bool isReturnScope(const Token * const endToken, const Library * library, bool f
if (isEscaped(prev->link()->astTop(), functionScope))
return true;
if (Token::Match(prev->link()->previous(), "[;{}] {"))
return isReturnScope(prev, library, functionScope);
return isReturnScope(prev, library, unknownFunc, functionScope);
} else if (Token::simpleMatch(prev, ";")) {
if (Token::simpleMatch(prev->previous(), ") ;") && Token::Match(prev->linkAt(-1)->tokAt(-2), "[;{}] %name% (")) {
const Token * ftok = prev->linkAt(-1)->previous();
@ -1033,10 +1092,13 @@ bool isReturnScope(const Token * const endToken, const Library * library, bool f
return true;
if (function->isAttributeNoreturn())
return true;
} else if (library) {
if (library->isnoreturn(ftok))
} else if (library && library->isnoreturn(ftok)) {
return true;
} else if (Token::Match(ftok, "exit|abort")) {
return true;
}
if (unknownFunc && !function && library && library->functions.count(library->getFunctionName(ftok)) == 0)
*unknownFunc = ftok;
return false;
}
if (Token::simpleMatch(prev->previous(), ") ;") && prev->previous()->link() &&
@ -1398,7 +1460,8 @@ const Token *findLambdaStartToken(const Token *last)
return nullptr;
}
const Token *findLambdaEndToken(const Token *first)
template <class T>
T* findLambdaEndTokenGeneric(T* first)
{
if (!first || first->str() != "[")
return nullptr;
@ -1415,6 +1478,9 @@ const Token *findLambdaEndToken(const Token *first)
return nullptr;
}
const Token* findLambdaEndToken(const Token* first) { return findLambdaEndTokenGeneric(first); }
Token* findLambdaEndToken(Token* first) { return findLambdaEndTokenGeneric(first); }
bool isLikelyStream(bool cpp, const Token *stream)
{
if (!cpp)
@ -1499,6 +1565,38 @@ bool isConstVarExpression(const Token *tok, const char* skipMatch)
return false;
}
static void getLHSVariablesRecursive(std::vector<const Variable*>& vars, const Token* tok)
{
if (!tok)
return;
if (vars.empty() && Token::Match(tok, "*|&|&&|[")) {
getLHSVariablesRecursive(vars, tok->astOperand1());
if (!vars.empty() || Token::simpleMatch(tok, "["))
return;
getLHSVariablesRecursive(vars, tok->astOperand2());
} else if (Token::Match(tok->previous(), "this . %var%")) {
getLHSVariablesRecursive(vars, tok->next());
} else if (Token::simpleMatch(tok, ".")) {
getLHSVariablesRecursive(vars, tok->astOperand1());
getLHSVariablesRecursive(vars, tok->astOperand2());
} else if (tok->variable()) {
vars.push_back(tok->variable());
}
}
std::vector<const Variable*> getLHSVariables(const Token* tok)
{
std::vector<const Variable*> result;
if (!Token::Match(tok, "%assign%"))
return result;
if (!tok->astOperand1())
return result;
if (tok->astOperand1()->varId() > 0 && tok->astOperand1()->variable())
return {tok->astOperand1()->variable()};
getLHSVariablesRecursive(result, tok->astOperand1());
return result;
}
static const Variable *getLHSVariableRecursive(const Token *tok)
{
if (!tok)

17
lib/astutils.h
View File

@ -90,6 +90,7 @@ const Token * astIsVariableComparison(const Token *tok, const std::string &comp,
bool isTemporary(bool cpp, const Token* tok, const Library* library, bool unknown = false);
const Token * nextAfterAstRightmostLeaf(const Token * tok);
Token* nextAfterAstRightmostLeaf(Token* tok);
Token* astParentSkipParens(Token* tok);
const Token* astParentSkipParens(const Token* tok);
@ -99,6 +100,12 @@ const Token* getParentMember(const Token * tok);
bool astIsLHS(const Token* tok);
bool astIsRHS(const Token* tok);
Token* getCondTok(Token* tok);
const Token* getCondTok(const Token* tok);
Token* getCondTokFromEnd(Token* endBlock);
const Token* getCondTokFromEnd(const Token* endBlock);
bool precedes(const Token * tok1, const Token * tok2);
bool exprDependsOnThis(const Token* expr, nonneg int depth = 0);
@ -128,8 +135,13 @@ bool isWithoutSideEffects(bool cpp, const Token* tok);
bool isUniqueExpression(const Token* tok);
bool isEscapeFunction(const Token* ftok, const Library* library);
/** Is scope a return scope (scope will unconditionally return) */
bool isReturnScope(const Token * const endToken, const Library * library=nullptr, bool functionScope=false);
bool isReturnScope(const Token* const endToken,
const Library* library = nullptr,
const Token** unknownFunc = nullptr,
bool functionScope = false);
/// Return the token to the function and the argument number
const Token * getTokenArgumentFunction(const Token * tok, int& argn);
@ -196,6 +208,7 @@ const Token *findLambdaStartToken(const Token *last);
* \return nullptr or the }
*/
const Token *findLambdaEndToken(const Token *first);
Token* findLambdaEndToken(Token* first);
bool isLikelyStream(bool cpp, const Token *stream);
@ -212,6 +225,8 @@ bool isConstVarExpression(const Token *tok, const char * skipMatch = nullptr);
const Variable *getLHSVariable(const Token *tok);
std::vector<const Variable*> getLHSVariables(const Token* tok);
bool isScopeBracket(const Token* tok);
bool isNullOperand(const Token *expr);

13
lib/checknullpointer.cpp
View File

@ -537,18 +537,7 @@ void CheckNullPointer::arithmetic()
continue;
if (numericOperand && numericOperand->valueType() && !numericOperand->valueType()->isIntegral())
continue;
MathLib::bigint checkValue = 0;
// When using an assign op, the value read from
// valueflow has already been updated, so instead of
// checking for zero we check that the value is equal
// to RHS
if (tok->astOperand2() && tok->astOperand2()->hasKnownIntValue()) {
if (tok->str() == "-=")
checkValue -= tok->astOperand2()->values().front().intvalue;
else if (tok->str() == "+=")
checkValue = tok->astOperand2()->values().front().intvalue;
}
const ValueFlow::Value *value = pointerOperand->getValue(checkValue);
const ValueFlow::Value* value = pointerOperand->getValue(0);
if (!value)
continue;
if (!mSettings->inconclusive && value->isInconclusive())

11
lib/config.h
View File

@ -28,6 +28,17 @@
# define OVERRIDE
#endif
// C++11 noexcept
#if (defined(__GNUC__) && (__GNUC__ >= 5)) \
|| (defined(__clang__) && (defined (__cplusplus)) && (__cplusplus >= 201103L)) \
|| defined(__CPPCHECK__)
# define NOEXCEPT noexcept
#else
# define NOEXCEPT
#endif
#define REQUIRES(msg, ...) class=typename std::enable_if<__VA_ARGS__::value>::type
#include <string>
static const std::string emptyString;

1
lib/cppcheck.vcxproj
View File

@ -97,6 +97,7 @@
<ClCompile Include="tokenize.cpp" />
<ClCompile Include="tokenlist.cpp" />
<ClCompile Include="valueflow.cpp" />
<ClCompile Include="forwardanalyzer.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\externals\simplecpp\simplecpp.h" />

2
lib/exprengine.cpp
View File

@ -475,7 +475,7 @@ ExprEngine::ConditionalValue::Vector ExprEngine::ArrayValue::read(ExprEngine::Va
continue;
}
if (auto i = std::dynamic_pointer_cast<ExprEngine::IntRange>(index)) {
if (stringLiteral && i->minValue >= 0 && i->minValue == i->maxValue) {
if (i->minValue >= 0 && i->minValue == i->maxValue) {
int c = 0;
if (i->minValue < stringLiteral->size())
c = stringLiteral->string[i->minValue];

417
lib/forwardanalyzer.cpp Normal file
View File

@ -0,0 +1,417 @@
#include "forwardanalyzer.h"
#include "astutils.h"
#include "settings.h"
#include "symboldatabase.h"
struct ForwardTraversal {
enum class Progress { Continue, Break, Skip };
ValuePtr<ForwardAnalyzer> analyzer;
const Settings* settings;
std::pair<bool, bool> evalCond(const Token* tok)
{
std::vector<int> result = analyzer->evaluate(tok);
bool checkThen = std::any_of(result.begin(), result.end(), [](int x) { return x; });
bool checkElse = std::any_of(result.begin(), result.end(), [](int x) { return !x; });
return std::make_pair(checkThen, checkElse);
}
Progress update(Token* tok)
{
ForwardAnalyzer::Action action = analyzer->analyze(tok);
if (!action.isNone())
analyzer->update(tok, action);
if (action.isInvalid())
return Progress::Break;
return Progress::Continue;
}
Progress updateTok(Token* tok, Token** out = nullptr)
{
if (Token::Match(tok, "asm|goto|continue|setjmp|longjmp"))
return Progress::Break;
else if (Token::Match(tok, "return|throw") || isEscapeFunction(tok, &settings->library)) {
updateRecursive(tok->astOperand1());
updateRecursive(tok->astOperand2());
return Progress::Break;
} else if (isUnevaluated(tok)) {
if (out)
*out = tok->link();
return Progress::Skip;
} else if (Token::Match(tok, "?|&&|%oror%")) {
if (updateConditional(tok) == Progress::Break)
return Progress::Break;
if (out)
*out = nextAfterAstRightmostLeaf(tok);
return Progress::Skip;
// Skip lambdas
} else if (Token* lambdaEndToken = findLambdaEndToken(tok)) {
if (checkScope(lambdaEndToken).isModified())
return Progress::Break;
if (out)
*out = lambdaEndToken;
} else {
if (update(tok) == Progress::Break)
return Progress::Break;
}
return Progress::Continue;
}
Progress updateRecursive(Token* tok)
{
if (!tok)
return Progress::Continue;
if (tok->astOperand1() && updateRecursive(tok->astOperand1()) == Progress::Break)
return Progress::Break;
Progress p = updateTok(tok);
if (p == Progress::Break)
return Progress::Break;
if (p == Progress::Continue && updateRecursive(tok->astOperand2()) == Progress::Break)
return Progress::Break;
return Progress::Continue;
}
Progress updateConditional(Token* tok)
{
if (Token::Match(tok, "?|&&|%oror%")) {
Token* condTok = tok->astOperand1();
if (updateRecursive(condTok) == Progress::Break)
return Progress::Break;
Token* childTok = tok->astOperand2();
bool checkThen, checkElse;
std::tie(checkThen, checkElse) = evalCond(condTok);
if (!checkThen && !checkElse) {
// Stop if the value is conditional
if (analyzer->isConditional())
return Progress::Break;
checkThen = true;
checkElse = true;
}
if (Token::simpleMatch(childTok, ":")) {
if (checkThen && updateRecursive(childTok->astOperand1()) == Progress::Break)
return Progress::Break;
if (checkElse && updateRecursive(childTok->astOperand2()) == Progress::Break)
return Progress::Break;
} else {
if (!checkThen && Token::simpleMatch(tok, "&&"))
return Progress::Continue;
if (!checkElse && Token::simpleMatch(tok, "||"))
return Progress::Continue;
if (updateRecursive(childTok) == Progress::Break)
return Progress::Break;
}
}
return Progress::Continue;
}
template <class T, class Predicate>
T* findRange(T* start, const Token* end, Predicate pred)
{
for (T* tok = start; tok && tok != end; tok = tok->next()) {
ForwardAnalyzer::Action action = analyzer->analyze(tok);
if (pred(action))
return tok;
}
return nullptr;
}
template <class T>
T* findActionRange(T* start, const Token* end, ForwardAnalyzer::Action action)
{
return findRange(start, end, [&](ForwardAnalyzer::Action a) { return a == action; });
}
ForwardAnalyzer::Action analyzeRange(const Token* start, const Token* end)
{
ForwardAnalyzer::Action result = ForwardAnalyzer::Action::None;
for (const Token* tok = start; tok && tok != end; tok = tok->next()) {
ForwardAnalyzer::Action action = analyzer->analyze(tok);
if (action.isModified() || action.isInconclusive())
return action;
result = action;
}
return result;
}
void forkScope(const Token* endBlock, bool isModified = false)
{
if (analyzer->updateScope(endBlock, isModified)) {
ForwardTraversal ft = *this;
ft.updateRange(endBlock->link(), endBlock);
}
}
static bool hasGoto(const Token* endBlock) { return Token::findsimplematch(endBlock->link(), "goto", endBlock); }
bool isEscapeScope(const Token* endBlock, bool unknown = false)
{
const Token* ftok = nullptr;
bool r = isReturnScope(endBlock, &settings->library, &ftok);
if (!r && ftok)
return unknown;
return r;
}
enum class Status {
None,
Escaped,
Modified,
Inconclusive,
};
ForwardAnalyzer::Action analyzeScope(const Token* endBlock) { return analyzeRange(endBlock->link(), endBlock); }
ForwardAnalyzer::Action checkScope(const Token* endBlock)
{
ForwardAnalyzer::Action a = analyzeScope(endBlock);
forkScope(endBlock, a.isModified());
return a;
}
Progress updateLoop(Token* endBlock, Token* condTok)
{
ForwardAnalyzer::Action a = analyzeScope(endBlock);
if (a.isInconclusive()) {
if (!analyzer->lowerToInconclusive())
return Progress::Break;
} else if (a.isModified()) {
if (!analyzer->lowerToPossible())
return Progress::Break;
}
// Traverse condition after lowering
if (condTok && updateRecursive(condTok) == Progress::Break)
return Progress::Break;
forkScope(endBlock, a.isModified());
if (a.isModified()) {
Token* writeTok = findRange(endBlock->link(), endBlock, std::mem_fn(&ForwardAnalyzer::Action::isModified));
const Token* nextStatement = Token::findmatch(writeTok, ";|}", endBlock);
if (!Token::Match(nextStatement, ";|} break ;"))
return Progress::Break;
}
// TODO: Shoule we traverse the body?
// updateRange(endBlock->link(), endBlock);
return Progress::Continue;
}
Progress updateRange(Token* start, const Token* end)
{
for (Token* tok = start; tok && tok != end; tok = tok->next()) {
Token* next = nullptr;
// Evaluate RHS of assignment before LHS
if (Token* assignTok = assignExpr(tok)) {
if (updateRecursive(assignTok->astOperand2()) == Progress::Break)
return Progress::Break;
if (updateRecursive(assignTok->astOperand1()) == Progress::Break)
return Progress::Break;
if (update(assignTok) == Progress::Break)
return Progress::Break;
tok = nextAfterAstRightmostLeaf(assignTok);
if (!tok)
return Progress::Break;
} else if (Token::simpleMatch(tok, "break")) {
const Scope* scope = findBreakScope(tok->scope());
if (!scope)
return Progress::Break;
tok = skipTo(tok, scope->bodyEnd, end);
if (!analyzer->lowerToPossible())
return Progress::Break;
// TODO: Dont break, instead move to the outer scope
if (!tok)
return Progress::Break;
} else if (Token::Match(tok, "%name% :") || Token::simpleMatch(tok, "case")) {
if (!analyzer->lowerToPossible())
return Progress::Break;
} else if (Token::simpleMatch(tok, "}") && Token::Match(tok->link()->previous(), ")|else {")) {
const bool inElse = Token::simpleMatch(tok->link()->previous(), "else {");
const Token* condTok = getCondTokFromEnd(tok);
if (!condTok)
return Progress::Break;
if (!condTok->hasKnownIntValue()) {
if (!analyzer->lowerToPossible())
return Progress::Break;
} else if (condTok->values().front().intvalue == !inElse) {
return Progress::Break;
}
analyzer->assume(condTok, !inElse);
if (Token::simpleMatch(tok, "} else {"))
tok = tok->linkAt(2);
} else if (Token::Match(tok, "if|while|for (") && Token::simpleMatch(tok->next()->link(), ") {")) {
Token* endCond = tok->next()->link();
Token* endBlock = endCond->next()->link();
Token* condTok = getCondTok(tok);
Token* initTok = getInitTok(tok);
if (!condTok)
return Progress::Break;
if (initTok && updateRecursive(initTok) == Progress::Break)
return Progress::Break;
if (Token::Match(tok, "for|while (")) {
if (updateLoop(endBlock, condTok) == Progress::Break)
return Progress::Break;
tok = endBlock;
} else {
// Traverse condition
if (updateRecursive(condTok) == Progress::Break)
return Progress::Break;
// Check if condition is true or false
bool checkThen, checkElse;
std::tie(checkThen, checkElse) = evalCond(condTok);
ForwardAnalyzer::Action thenAction = ForwardAnalyzer::Action::None;
ForwardAnalyzer::Action elseAction = ForwardAnalyzer::Action::None;
bool hasElse = false;
bool bail = false;
// Traverse then block
bool returnThen = isEscapeScope(endBlock, true);
bool returnElse = false;
if (checkThen) {
if (updateRange(endCond->next(), endBlock) == Progress::Break)
return Progress::Break;
} else if (!checkElse) {
thenAction = checkScope(endBlock);
if (hasGoto(endBlock))
bail = true;
}
// Traverse else block
if (Token::simpleMatch(endBlock, "} else {")) {
hasElse = true;
returnElse = isEscapeScope(endBlock->linkAt(2), true);
if (checkElse) {
Progress result = updateRange(endBlock->tokAt(2), endBlock->linkAt(2));
if (result == Progress::Break)
return Progress::Break;
} else if (!checkThen) {
elseAction = checkScope(endBlock->linkAt(2));
if (hasGoto(endBlock))
bail = true;
}
tok = endBlock->linkAt(2);
} else {
tok = endBlock;
}
if (bail)
return Progress::Break;
if (returnThen && returnElse)
return Progress::Break;
else if (thenAction.isModified() && elseAction.isModified())
return Progress::Break;
else if ((returnThen || returnElse) && (thenAction.isModified() || elseAction.isModified()))
return Progress::Break;
// Conditional return
if (returnThen && !hasElse) {
if (checkThen) {
return Progress::Break;
} else {
if (analyzer->isConditional())
return Progress::Break;
analyzer->assume(condTok, false);
}
}
if (thenAction.isInconclusive() || elseAction.isInconclusive()) {
if (!analyzer->lowerToInconclusive())
return Progress::Break;
} else if (thenAction.isModified() || elseAction.isModified()) {
if (!analyzer->lowerToPossible())
return Progress::Break;
analyzer->assume(condTok, elseAction.isModified());
}
}
} else if (Token::simpleMatch(tok, "} else {")) {
tok = tok->linkAt(2);
} else if (Token::simpleMatch(tok, "do {")) {
Token* endBlock = tok->next()->link();
if (updateLoop(endBlock, nullptr) == Progress::Break)
return Progress::Break;
tok = endBlock;
} else if (Token::Match(tok, "assert|ASSERT (")) {
const Token* condTok = tok->next()->astOperand2();
bool checkThen, checkElse;
std::tie(checkThen, checkElse) = evalCond(condTok);
if (checkElse)
return Progress::Break;
if (!checkThen)
analyzer->assume(condTok, true);
} else if (Token::simpleMatch(tok, "switch (")) {
if (updateRecursive(tok->next()->astOperand2()) == Progress::Break)
return Progress::Break;
return Progress::Break;
} else {
if (updateTok(tok, &next) == Progress::Break)
return Progress::Break;
if (next)
tok = next;
}
// Prevent infinite recursion
if (tok->next() == start)
break;
}
return Progress::Continue;
}
static bool isUnevaluated(const Token* tok)
{
if (Token::Match(tok->previous(), "sizeof|decltype ("))
return true;
return false;
}
static Token* assignExpr(Token* tok)
{
while (tok->astParent() && astIsLHS(tok)) {
if (Token::Match(tok->astParent(), "%assign%"))
return tok->astParent();
tok = tok->astParent();
}
return nullptr;
}
static const Scope* findBreakScope(const Scope* scope)
{
while (scope && scope->type != Scope::eWhile && scope->type != Scope::eFor && scope->type != Scope::eSwitch)
scope = scope->nestedIn;
return scope;
}
static Token* skipTo(Token* tok, const Token* dest, const Token* end = nullptr)
{
if (end && dest->index() > end->index())
return nullptr;
int i = dest->index() - tok->index();
if (i > 0)
return tok->tokAt(dest->index() - tok->index());
return nullptr;
}
static bool isConditional(const Token* tok)
{
const Token* parent = tok->astParent();
while (parent && !Token::Match(parent, "%oror%|&&|:")) {
tok = parent;
parent = parent->astParent();
}
return parent && (parent->str() == ":" || parent->astOperand2() == tok);
}
template <class T>
static T* getInitTok(T* tok)
{
if (!tok)
return nullptr;
if (Token::Match(tok, "%name% ("))
return getInitTok(tok->next());
if (!Token::simpleMatch(tok, "("))
return nullptr;
if (!Token::simpleMatch(tok->astOperand2(), ";"))
return nullptr;
if (Token::simpleMatch(tok->astOperand2()->astOperand1(), ";"))
return nullptr;
return tok->astOperand2()->astOperand1();
}
};
void valueFlowGenericForward(Token* start, const Token* end, const ValuePtr<ForwardAnalyzer>& fa, const Settings* settings)
{
ForwardTraversal ft{fa, settings};
ft.updateRange(start, end);
}

100
lib/forwardanalyzer.h Normal file
View File

@ -0,0 +1,100 @@
/*
* Cppcheck - A tool for static C/C++ code analysis
* Copyright (C) 2007-2019 Cppcheck team.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef forwardanalyzerH
#define forwardanalyzerH
#include "token.h"
#include "valueptr.h"
#include <vector>
class Settings;
struct ForwardAnalyzer {
struct Action {
Action() : mFlag(0) {}
// cppcheck-suppress noExplicitConstructor
Action(unsigned int f) : mFlag(f) {}
enum {
None = 0,
Read = (1 << 0),
Write = (1 << 1),
Invalid = (1 << 2),
Inconclusive = (1 << 3),
};
void set(unsigned int f, bool state = true) { mFlag = state ? mFlag | f : mFlag & ~f; }
bool get(unsigned int f) const { return ((mFlag & f) != 0); }
bool isRead() const { return get(Read); }
bool isWrite() const { return get(Write); }
bool isInvalid() const { return get(Invalid); }
bool isInconclusive() const { return get(Inconclusive); }
bool isNone() const { return mFlag == None; }
bool isModified() const { return isWrite() || isInvalid(); }
Action& operator|=(Action a)
{
set(a.mFlag);
return *this;
}
friend Action operator|(Action a, Action b)
{
a |= b;
return a;
}
friend bool operator==(Action a, Action b) { return a.mFlag == b.mFlag; }
friend bool operator!=(Action a, Action b) { return a.mFlag != b.mFlag; }
private:
unsigned int mFlag;
};
/// Analyze a token
virtual Action analyze(const Token* tok) const = 0;
/// Update the state of the value
virtual void update(Token* tok, Action a) = 0;
/// Try to evaluate the value of a token(most likely a condition)
virtual std::vector<int> evaluate(const Token* tok) const = 0;
/// Lower any values to possible
virtual bool lowerToPossible() = 0;
/// Lower any values to inconclusive
virtual bool lowerToInconclusive() = 0;
/// If the analysis is unsure whether to update a scope, this will return true if the analysis should bifurcate the scope
virtual bool updateScope(const Token* endBlock, bool modified) const = 0;
/// If the value is conditional
virtual bool isConditional() const = 0;
/// The condtion that wil be assumes during analysis
virtual void assume(const Token* tok, bool state) = 0;
virtual ~ForwardAnalyzer() {}
};
void valueFlowGenericForward(Token* start, const Token* end, const ValuePtr<ForwardAnalyzer>& fa, const Settings* settings);
#endif

2
lib/lib.pri
View File

@ -36,6 +36,7 @@ HEADERS += $${PWD}/analyzerinfo.h \
$${PWD}/ctu.h \
$${PWD}/errorlogger.h \
$${PWD}/exprengine.h \
$${PWD}/forwardanalyzer.h \
$${PWD}/importproject.h \
$${PWD}/library.h \
$${PWD}/mathlib.h \
@ -88,6 +89,7 @@ SOURCES += $${PWD}/analyzerinfo.cpp \
$${PWD}/ctu.cpp \
$${PWD}/errorlogger.cpp \
$${PWD}/exprengine.cpp \
$${PWD}/forwardanalyzer.cpp \
$${PWD}/importproject.cpp \
$${PWD}/library.cpp \
$${PWD}/mathlib.cpp \

13
lib/pathanalysis.cpp
View File

@ -15,19 +15,6 @@ const Scope* PathAnalysis::findOuterScope(const Scope * scope)
return scope;
}
static const Token* getCondTok(const Token* tok)
{
if (!tok)
return nullptr;
if (Token::simpleMatch(tok, "("))
return getCondTok(tok->previous());
if (Token::simpleMatch(tok, "for") && Token::simpleMatch(tok->next()->astOperand2(), ";") && tok->next()->astOperand2()->astOperand2())
return tok->next()->astOperand2()->astOperand2()->astOperand1();
if (Token::simpleMatch(tok->next()->astOperand2(), ";"))
return tok->next()->astOperand2()->astOperand1();
return tok->next()->astOperand2();
}
static const Token* assignExpr(const Token* tok)
{
while (tok->astParent() && astIsLHS(tok)) {

15
lib/programmemory.cpp
View File

@ -33,6 +33,8 @@ bool ProgramMemory::getTokValue(nonneg int varid, const Token** result) const
return found;
}
void ProgramMemory::setUnknown(nonneg int varid) { values[varid].valueType = ValueFlow::Value::ValueType::UNINIT; }
bool ProgramMemory::hasValue(nonneg int varid)
{
return values.find(varid) != values.end();
@ -167,6 +169,16 @@ static void fillProgramMemoryFromConditions(ProgramMemory& pm, const Token* tok,
fillProgramMemoryFromConditions(pm, tok->scope(), tok, settings);
}
static void fillProgramMemoryFromConditionalExpression(ProgramMemory& pm, const Token* tok, const Settings* settings)
{
const Token* parent = tok->astParent();
if (Token::Match(parent, "?|&&|%oror%")) {
programMemoryParseCondition(pm, parent->astOperand1(), tok, settings, !Token::simpleMatch(parent, "||"));
} else if (Token::simpleMatch(parent, ":") && Token::simpleMatch(parent->astParent(), "?")) {
programMemoryParseCondition(pm, parent->astParent()->astOperand1(), tok, settings, parent->astOperand1() == tok);
}
}
static void fillProgramMemoryFromAssignments(ProgramMemory& pm, const Token* tok, const ProgramMemory& state, std::unordered_map<nonneg int, ValueFlow::Value> vars)
{
int indentlevel = 0;
@ -192,6 +204,8 @@ static void fillProgramMemoryFromAssignments(ProgramMemory& pm, const Token* tok
execute(vartok->next()->astOperand2(), &pm, &result, &error);
if (!error)
pm.setIntValue(vartok->varId(), result);
else
pm.setUnknown(vartok->varId());
}
}
@ -244,6 +258,7 @@ ProgramMemory getProgramMemory(const Token *tok, nonneg int varid, const ValueFl
ProgramMemory programMemory;
programMemory.replace(getInitialProgramState(tok, value.tokvalue));
programMemory.replace(getInitialProgramState(tok, value.condition));
fillProgramMemoryFromConditions(programMemory, tok, nullptr);
programMemory.setValue(varid, value);
if (value.varId)
programMemory.setIntValue(value.varId, value.varvalue);

2
lib/programmemory.h
View File

@ -15,6 +15,8 @@ struct ProgramMemory {
bool getIntValue(nonneg int varid, MathLib::bigint* result) const;
void setIntValue(nonneg int varid, MathLib::bigint value);
void setUnknown(nonneg int varid);
bool getTokValue(nonneg int varid, const Token** result) const;
bool hasValue(nonneg int varid);

2
lib/symboldatabase.cpp
View File

@ -1406,7 +1406,7 @@ void SymbolDatabase::createSymbolDatabaseEscapeFunctions()
Function * function = scope.function;
if (!function)
continue;
function->isEscapeFunction(isReturnScope(scope.bodyEnd, &mSettings->library, true));
function->isEscapeFunction(isReturnScope(scope.bodyEnd, &mSettings->library, nullptr, true));
}
}

989
lib/valueflow.cpp
View File

File diff suppressed because it is too large Load Diff

87
lib/valueptr.h Normal file
View File

@ -0,0 +1,87 @@
/*
* Cppcheck - A tool for static C/C++ code analysis
* Copyright (C) 2007-2019 Cppcheck team.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
#ifndef valueptrH
#define valueptrH
//---------------------------------------------------------------------------
#include "config.h"
#include <functional>
#include <memory>
template <class T>
class CPPCHECKLIB ValuePtr {
template <class U>
struct cloner {
static T* apply(const T* x) { return new U(*static_cast<const U*>(x)); }
};
public:
using pointer = T*;
using element_type = T;
using cloner_type = decltype(&cloner<T>::apply);
ValuePtr() : mPtr(nullptr), mClone() {}
template <class U>
// cppcheck-suppress noExplicitConstructor
ValuePtr(const U& value) : mPtr(cloner<U>::apply(&value)), mClone(&cloner<U>::apply)
{}
ValuePtr(const ValuePtr& rhs) : mPtr(nullptr), mClone(rhs.mClone)
{
if (rhs) {
mPtr.reset(mClone(rhs.get()));
}
}
ValuePtr(ValuePtr&& rhs) : mPtr(std::move(rhs.mPtr)), mClone(std::move(rhs.mClone)) {}
pointer release() { return mPtr.release(); }
T* get() NOEXCEPT { return mPtr.get(); }
const T* get() const NOEXCEPT { return mPtr.get(); }
T& operator*() { return *get(); }
const T& operator*() const { return *get(); }
T* operator->() NOEXCEPT { return get(); }
const T* operator->() const NOEXCEPT { return get(); }
void swap(ValuePtr& rhs)
{
using std::swap;
swap(mPtr, rhs.mPtr);
swap(mClone, rhs.mClone);
}
ValuePtr<T>& operator=(ValuePtr rhs)
{
swap(rhs);
return *this;
}
operator bool() const NOEXCEPT { return !!mPtr; }
~ValuePtr() {}
private:
std::shared_ptr<T> mPtr;
cloner_type mClone;
};
#endif

26
test/CMakeLists.txt
View File

@ -41,9 +41,20 @@ if (BUILD_TESTS)
set(SKIP_TESTS "" CACHE STRING "A list of tests to skip")
function(add_fixture NAME)
set(options)
set(oneValueArgs WORKING_DIRECTORY)
set(multiValueArgs)
cmake_parse_arguments(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
if (${NAME} IN_LIST SKIP_TESTS)
elseif(TEST ${NAME})
else()
add_test(NAME ${NAME} COMMAND testrunner ${NAME} WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
set(WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
if (PARSE_WORKING_DIRECTORY)
set(WORKING_DIRECTORY ${PARSE_WORKING_DIRECTORY})
endif()
add_test(NAME ${NAME} COMMAND testrunner ${NAME} WORKING_DIRECTORY ${WORKING_DIRECTORY})
endif()
endfunction()
@ -53,18 +64,19 @@ if (BUILD_TESTS)
endif()
endfunction()
add_fixture(TestSamples WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
foreach(SRC ${srcs})
file(STRINGS ${SRC} FIXTURE_LINE REGEX "TestFixture\\(" LIMIT_COUNT 1)
if(FIXTURE_LINE MATCHES "TestFixture\\(\"([a-zA-z0-9]+)\"\\)")
add_fixture(${CMAKE_MATCH_1})
endif()
endforeach()
add_fixture("TestLeakAutoVarStrcpy")
add_fixture("TestLeakAutoVarWindows")
add_fixture("TestMemleakInFunction")
add_fixture("TestMemleakInClass")
add_fixture("TestMemleakStructMember")
add_fixture("TestMemleakNoVar")
add_fixture(TestLeakAutoVarStrcpy)
add_fixture(TestLeakAutoVarWindows)
add_fixture(TestMemleakInFunction)
add_fixture(TestMemleakInClass)
add_fixture(TestMemleakStructMember)
add_fixture(TestMemleakNoVar)
function(add_cfg CFG_TEST)
set(options INCONCLUSIVE)

3
test/testastutils.cpp
View File

@ -53,7 +53,8 @@ private:
}
void findLambdaEndToken() {
ASSERT(nullptr == ::findLambdaEndToken(nullptr));
const Token* nullTok = nullptr;
ASSERT(nullptr == ::findLambdaEndToken(nullTok));
ASSERT_EQUALS(false, findLambdaEndToken("void f() { }"));
ASSERT_EQUALS(true, findLambdaEndToken("[]{ }"));
ASSERT_EQUALS(true, findLambdaEndToken("[]{ return 0; }"));

2
test/testcondition.cpp
View File

@ -2058,7 +2058,7 @@ private:
" if (hasFailed) {}\n"
" }\n"
"}");
ASSERT_EQUALS("", errout.str());
ASSERT_EQUALS("[test.cpp:6]: (style) Condition '!hasFailed' is always true\n", errout.str());
}
void oppositeInnerCondition2() {

17
test/testnullpointer.cpp
View File

@ -90,6 +90,7 @@ private:
TEST_CASE(nullpointer48); // #9196
TEST_CASE(nullpointer49); // #7804
TEST_CASE(nullpointer50); // #6462
TEST_CASE(nullpointer51);
TEST_CASE(nullpointer_addressOf); // address of
TEST_CASE(nullpointerSwitch); // #2626
TEST_CASE(nullpointer_cast); // #4692
@ -1692,6 +1693,20 @@ private:
errout.str());
}
void nullpointer51() {
check("struct a {\n"
" a *b();\n"
"};\n"
"bool c(a *, const char *);\n"
"a *d(a *e) {\n"
" if (e) {}\n"
" if (c(e, \"\"))\n"
" return nullptr;\n"
" return e->b();\n"
"}\n");
ASSERT_EQUALS("", errout.str());
}
void nullpointer_addressOf() { // address of
check("void f() {\n"
" struct X *x = 0;\n"
@ -2107,7 +2122,7 @@ private:
" if (!p) {}\n"
" return q ? p->x : 0;\n"
"}");
ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
TODO_ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", "", errout.str());
check("int f(ABC *p) {\n" // FP : return &&
" if (!p) {}\n"

10
test/teststl.cpp
View File

@ -2152,7 +2152,9 @@ private:
" *it;\n"
" }\n"
"}");
ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:4] -> [test.cpp:6] -> [test.cpp:3] -> [test.cpp:4]: (error) Using iterator to local container 'vec' that may be invalid.\n", errout.str());
ASSERT_EQUALS(
"[test.cpp:4] -> [test.cpp:6] -> [test.cpp:3] -> [test.cpp:9]: (error, inconclusive) Using iterator to local container 'vec' that may be invalid.\n",
errout.str());
}
void pushback13() {
@ -2213,14 +2215,16 @@ private:
"}");
ASSERT_EQUALS("", errout.str());
// TODO: This shouldn't be inconclusive
check("void f(const std::vector<Bar>& bars) {\n"
" for(std::vector<Bar>::iterator i = bars.begin(); i != bars.end(); ++i) {\n"
" bars.insert(i, bar);\n"
" i = bars.insert(i, bar);\n"
" }\n"
"}");
TODO_ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2] -> [test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:2]: (error) Using iterator to local container 'bars' that may be invalid.\n", "", errout.str());
ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:4]: (error, inconclusive) Using iterator to local container 'bars' that may be invalid.\n", errout.str());
// TODO: This shouldn't be inconclusive
check("void* f(const std::vector<Bar>& bars) {\n"
" std::vector<Bar>::iterator i = bars.begin();\n"
" bars.insert(i, Bar());\n"
@ -2228,7 +2232,7 @@ private:
" void* v = &i->foo;\n"
" return v;\n"
"}");
TODO_ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:4] -> [test.cpp:1] -> [test.cpp:5] -> [test.cpp:4] -> [test.cpp:1] -> [test.cpp:6]: (error) Using pointer to local variable 'bars' that may be invalid.\n", "", errout.str());
ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:4]: (error, inconclusive) Using iterator to local container 'bars' that may be invalid.\n", errout.str());
}
void insert2() {

4
test/testuninitvar.cpp
View File

@ -4494,7 +4494,9 @@ private:
" c->x = 42;\n"
" return c->x;\n"
"}\n");
ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: c\n", errout.str());
ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: c\n"
"[test.cpp:7]: (error) Uninitialized variable: c\n",
errout.str());
valueFlowUninit("struct A {\n"
" double x;\n"

28
test/testvalueflow.cpp
View File

@ -1421,8 +1421,7 @@ private:
"}");
ASSERT_EQUALS_WITHOUT_LINENUMBERS(
"[test.cpp:3]: (debug) valueflow.cpp::valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable a\n"
"[test.cpp:4]: (debug) valueflow.cpp:1131:valueFlowReverse bailout: variable x stopping on goto label\n"
"[test.cpp:2]: (debug) valueflow.cpp:1813:valueFlowForwardVariable bailout: variable x. noreturn conditional scope.\n",
"[test.cpp:4]: (debug) valueflow.cpp:1131:valueFlowReverse bailout: variable x stopping on goto label\n",
errout.str());
// #5721 - FP
@ -1438,8 +1437,7 @@ private:
"}\n");
ASSERT_EQUALS_WITHOUT_LINENUMBERS(
"[test.cpp:2]: (debug) valueflow.cpp:1035:valueFlowReverse bailout: assignment of abc\n"
"[test.cpp:8]: (debug) valueflow.cpp:1131:valueFlowReverse bailout: variable abc stopping on goto label\n"
"[test.cpp:3]: (debug) valueflow.cpp:1813:valueFlowForwardVariable bailout: variable abc. noreturn conditional scope.\n",
"[test.cpp:8]: (debug) valueflow.cpp:1131:valueFlowReverse bailout: variable abc stopping on goto label\n",
errout.str());
}
@ -1811,7 +1809,7 @@ private:
" y = 42 / x;\n" // <- x is 2
"}";
ASSERT_EQUALS(false, testValueOfX(code, 5U, 0));
TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 5U, 2));
ASSERT_EQUALS(true, testValueOfX(code, 5U, 2));
code = "void f(int mode) {\n"
" struct ABC *x;\n"
@ -2303,7 +2301,7 @@ private:
" for (; x && \n"
" x->str() != y; x = x->next()) {}\n"
"}";
TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 3U, 0));
ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
code = "void f(const Token* x) {\n"
@ -2565,7 +2563,7 @@ private:
" return a == 1 ? x : 0;\n" // <- x is 26
"}";
ASSERT_EQUALS(false, testValueOfX(code, 4U, 13));
TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 4U, 26));
ASSERT_EQUALS(true, testValueOfX(code, 4U, 26));
}
void valueFlowForwardLambda() {
@ -3053,6 +3051,14 @@ private:
" a = x;\n" // <- max value is 3
"}";
ASSERT_EQUALS(true, testValueOfX(code, 5U, 3));
code = "void f() {\n"
" int x;\n"
" for (x = 0; x < 10; x++)\n"
" x;\n"
"}";
std::list<ValueFlow::Value> values = tokenValues(code, "x <");
ASSERT(std::none_of(values.begin(), values.end(), std::mem_fn(&ValueFlow::Value::isUninitValue)));
}
void valueFlowSubFunction() {
@ -3710,10 +3716,10 @@ private:
" c++;\n"
"}\n";
values = tokenValues(code, "c ++ ; }");
ASSERT_EQUALS(true, values.size() == 2);
ASSERT_EQUALS(true, values.front().isUninitValue() || values.back().isUninitValue());
ASSERT_EQUALS(true, values.front().isPossible() || values.back().isPossible());
ASSERT_EQUALS(true, values.front().intvalue == 0 || values.back().intvalue == 0);
TODO_ASSERT_EQUALS(true, false, values.size() == 2);
// ASSERT_EQUALS(true, values.front().isUninitValue() || values.back().isUninitValue());
// ASSERT_EQUALS(true, values.front().isPossible() || values.back().isPossible());
// ASSERT_EQUALS(true, values.front().intvalue == 0 || values.back().intvalue == 0);
code = "void b(bool d, bool e) {\n"
" int c;\n"