Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions lib/checkers.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -131,6 +131,7 @@ namespace checkers {
{"CheckOther::checkInvalidFree",""},
{"CheckOther::checkKnownArgument","style"},
{"CheckOther::checkKnownPointerToBool","style"},
{"CheckOther::checkMissingForLoopIncrement","warning"},
{"CheckOther::checkMisusedScopedObject","style,c++"},
{"CheckOther::checkModuloOfOne","style"},
{"CheckOther::checkNanInArithmeticExpression","style"},
Expand Down
128 changes: 128 additions & 0 deletions lib/checkother.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -68,6 +68,7 @@ static const CWE CWE704(704U); // Incorrect Type Conversion or Cast
static const CWE CWE758(758U); // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
static const CWE CWE768(768U); // Incorrect Short Circuit Evaluation
static const CWE CWE783(783U); // Operator Precedence Logic Error
static const CWE CWE835(835U); // Loop with Unreachable Exit Condition ('Infinite Loop')

//----------------------------------------------------------------------------------
// The return value of fgetc(), getc(), ungetc(), getchar() etc. is an integer value.
Expand Down Expand Up @@ -4905,6 +4906,131 @@ void CheckOtherImpl::overlappingWriteFunction(const Token *tok, const std::strin
reportError(tok, Severity::error, "overlappingWriteFunction", "Overlapping read/write in " + funcname + "() is undefined behavior");
}

//---------------------------------------------------------------------------
// Detect for-loops that never update their control variable (#5459)
//---------------------------------------------------------------------------

static bool stepUpdatesVar(const Token* stepTok, nonneg int varId)
{
if (!stepTok || varId == 0)
return false;
if (stepTok->isIncDecOp() && stepTok->astOperand1() && stepTok->astOperand1()->varId() == varId)
return true;
if (stepTok->isAssignmentOp() && stepTok->astOperand1() && stepTok->astOperand1()->varId() == varId)
return true;
// Recurse so nested updates are found, e.g. "delete *it++" or "a = b++"
return stepUpdatesVar(stepTok->astOperand1(), varId) || stepUpdatesVar(stepTok->astOperand2(), varId);
}

static bool hasForLoopExit(const Scope& scope)
{
for (const Token* tok = scope.bodyStart; tok != scope.bodyEnd; tok = tok->next()) {
const Scope* escapeScope = tok->scope();
if (!escapeScope || !escapeScope->isExecutable()) {
if (escapeScope)
tok = escapeScope->bodyEnd;
continue;
}
if (const Token* lambdaEnd = findLambdaEndToken(tok)) {
tok = lambdaEnd;
continue;
}
if (!tok->isName() || !tok->isKeyword())
continue;
if (Token::Match(tok, "goto|return|throw"))
return true;
if (tok->str() != "break")
continue;
// break only exits this loop if it is not nested in an inner loop/switch
while (escapeScope && escapeScope != &scope) {
if (escapeScope->isLoopScope() || escapeScope->type == ScopeType::eSwitch)
break;
escapeScope = escapeScope->nestedIn;
}
if (escapeScope == &scope)
return true;
}
return false;
}

static const Token* findForLoopControlVar(const Token* initTok, const Token* condTok)
{
if (!initTok || !condTok || !condTok->isComparisonOp())
return nullptr;

const Token* initLhs = Token::simpleMatch(initTok, "=") ? initTok->astOperand1() : nullptr;
if (!Token::Match(initLhs, "%var%") || initLhs->varId() == 0) //TODO: WILL THIS BE NULLPTR DEFERENCE IF initLhs IS SET TO NULLPTR ON LINE 4962??
return nullptr;

const Variable* var = initLhs->variable();
if (!var || !var->isLocal() || var->isStatic() || var->isReference() || var->isRValueReference())
return nullptr;

auto isAcceptableLoopVar = [](const Token* tok) -> bool {
if (!Token::Match(tok, "%var%") || tok->varId() == 0)
return false;
if (!tok->valueType())
return true; // incomplete type info; still allow for C / missing VT
return tok->valueType()->isIntegral() || tok->valueType()->type == ValueType::Type::ITERATOR;
};

const Token* op1 = condTok->astOperand1();
const Token* op2 = condTok->astOperand2();
if (isAcceptableLoopVar(op1) && op1->varId() == initLhs->varId())
return op1;
if (isAcceptableLoopVar(op2) && op2->varId() == initLhs->varId())
return op2;
return nullptr;
}

void CheckOtherImpl::checkMissingForLoopIncrement()
{
if (!mSettings.severity.isEnabled(Severity::warning))
return;

logChecker("CheckOther::checkMissingForLoopIncrement"); // warning

const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
for (const Scope& scope : symbolDatabase->scopeList) {
if (scope.type != ScopeType::eFor || !scope.classDef)
continue;

const Token* forTok = scope.classDef;
const Token* initTok = getInitTok(forTok);
const Token* condTok = getCondTok(forTok);
const Token* stepTok = getStepTok(forTok);
if (!initTok || !condTok)
continue;

const Token* loopVarTok = findForLoopControlVar(initTok, condTok);
if (!loopVarTok)
continue;

const nonneg int varId = loopVarTok->varId();
if (stepUpdatesVar(stepTok, varId))
continue;

if (!astHasVar(condTok, varId))
continue;

if (hasForLoopExit(scope))
continue;

if (findExpressionChanged(loopVarTok, scope.bodyStart, scope.bodyEnd, mSettings))
continue;

missingForLoopIncrementError(forTok, loopVarTok->str());
}
}

void CheckOtherImpl::missingForLoopIncrementError(const Token *tok, const std::string &varname)
{
reportError(tok, Severity::warning, "missingForLoopIncrement",
"$symbol:" + varname + "\n"
"The loop variable '$symbol' is not updated in this for-loop, so the loop might never terminate.",
CWE835, Certainty::normal);
}

void CheckOther::runChecks(const Tokenizer &tokenizer, ErrorLogger& errorLogger)
{
CheckOtherImpl checkOther(&tokenizer, tokenizer.getSettings(), errorLogger);
Expand Down Expand Up @@ -4956,6 +5082,7 @@ void CheckOther::runChecks(const Tokenizer &tokenizer, ErrorLogger& errorLogger)
checkOther.checkModuloOfOne();
checkOther.checkOverlappingWrite();
checkOther.checkUnionZeroInit();
checkOther.checkMissingForLoopIncrement();
}

void CheckOther::getErrorMessages(ErrorLogger& errorLogger, const Settings &settings) const
Expand Down Expand Up @@ -5041,4 +5168,5 @@ void CheckOther::getErrorMessages(ErrorLogger& errorLogger, const Settings &sett
c.funcArgOrderDifferent("function", nullptr, nullptr, nullvec, nullvec);
c.checkModuloOfOneError(nullptr);
c.unionZeroInitError(nullptr, UnionMember());
c.missingForLoopIncrementError(nullptr, "i");
}
5 changes: 5 additions & 0 deletions lib/checkother.h
Original file line number Diff line number Diff line change
Expand Up @@ -77,6 +77,7 @@ class CPPCHECKLIB CheckOther : public Check {
// warning
"- either division by zero or useless condition\n"
"- access of moved or forwarded variable.\n"
"- for-loop that never updates its control variable\n"

// performance
"- redundant data copying for const variable\n"
Expand Down Expand Up @@ -267,6 +268,9 @@ class CPPCHECKLIB CheckOtherImpl : public CheckImpl {
void overlappingWriteUnion(const Token *tok);
void overlappingWriteFunction(const Token *tok, const std::string& funcname);

/** @brief %Check for for-loops that never update their control variable (#5459) */
void checkMissingForLoopIncrement();

// Error messages..
void checkComparisonFunctionIsAlwaysTrueOrFalseError(const Token* tok, const std::string &functionName, const std::string &varName, bool result);
void checkCastIntToCharAndBackError(const Token *tok, const std::string &strFunctionName);
Expand Down Expand Up @@ -328,6 +332,7 @@ class CPPCHECKLIB CheckOtherImpl : public CheckImpl {
void comparePointersError(const Token *tok, const ValueFlow::Value *v1, const ValueFlow::Value *v2, bool subtract);
void checkModuloOfOneError(const Token *tok);
void unionZeroInitError(const Token *tok, const UnionMember& largestMember);
void missingForLoopIncrementError(const Token *tok, const std::string &varname);

bool diag(const Token* tok) {
return !mRedundantAssignmentDiag.emplace(tok).second;
Expand Down
39 changes: 39 additions & 0 deletions man/checkers/missingForLoopIncrement.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,39 @@
# missingForLoopIncrement

**Message**: The loop variable 'varname' is not updated in this for-loop, so the loop might never terminate.<br/>
**Category**: Correctness<br/>
**Severity**: Warning<br/>
**Language**: C, C++

## Description

A classic `for` loop's control variable is never advanced in the step clause or the loop body, so the
loop condition may never become false.

## Motivation

Forgetting to increment an iterator or index is a common bug that leads to an infinite loop. Compilers
often do not warn about an empty for-loop step when the programmer intended to update the variable in
the body but never did.

## How to fix

Before:
```cpp
#include <map>
void f(std::map<int, int> &theMap) {
for (auto it = theMap.begin(); it != theMap.end();) {
(void)*it; // <- missingForLoopIncrement: 'it' is never updated
}
}
```

After: increment in the for-header or in the body.
```cpp
#include <map>
void f(std::map<int, int> &theMap) {
for (auto it = theMap.begin(); it != theMap.end(); ++it) {
(void)*it;
}
}
```
122 changes: 120 additions & 2 deletions test/testother.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -345,6 +345,8 @@ class TestOther : public TestFixture {
TEST_CASE(unionZeroInitStructMember);
TEST_CASE(unionZeroInitUnknownType);
TEST_CASE(unionZeroInitBitfields);

TEST_CASE(missingForLoopIncrement); // #5459
}

struct CheckOptions
Expand Down Expand Up @@ -6680,7 +6682,8 @@ class TestOther : public TestFixture {
" c ++;\n"
" }\n"
"}\n");
ASSERT_EQUALS("[test.cpp:2:31]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
ASSERT_EQUALS("[test.cpp:2:31]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n"
"[test.cpp:2:5]: (warning) The loop variable 'i' is not updated in this for-loop, so the loop might never terminate. [missingForLoopIncrement]\n", errout_str());

check("void foo(int c) {\n"
" for (; running == 1;) {\n"
Expand Down Expand Up @@ -8639,7 +8642,8 @@ class TestOther : public TestFixture {
" if( i != 0 ) {}\n"
" }\n"
"}\n");
ASSERT_EQUALS("[test.cpp:2:17] -> [test.cpp:3:15]: (style) The comparison 'i != 0' is always false. [knownConditionTrueFalse]\n", errout_str());
ASSERT_EQUALS("[test.cpp:2:17] -> [test.cpp:3:15]: (style) The comparison 'i != 0' is always false. [knownConditionTrueFalse]\n"
"[test.cpp:2:5]: (warning) The loop variable 'i' is not updated in this for-loop, so the loop might never terminate. [missingForLoopIncrement]\n", errout_str());

check("void f() {\n"
" for(int i = 0; i < 10;) {\n"
Expand Down Expand Up @@ -14594,6 +14598,120 @@ class TestOther : public TestFixture {
"}\n");
ASSERT_EQUALS("", errout_str());
}

void missingForLoopIncrement() { // #5459
// Ticket example: empty step, iterator never updated
check("void f(const std::map<int,int>& theMap) {\n"
" for (auto it = theMap.begin(); it != theMap.end();) {\n"
" (void)*it;\n"
" }\n"
"}\n");
ASSERT_EQUALS("[test.cpp:2:3]: (warning) The loop variable 'it' is not updated in this for-loop, so the loop might never terminate. [missingForLoopIncrement]\n", errout_str());

// Index variable with empty step
check("void use(int);\n"
"void f(int n) {\n"
" for (int i = 0; i < n;) {\n"
" use(i);\n"
" }\n"
"}\n");
ASSERT_EQUALS("[test.cpp:3:3]: (warning) The loop variable 'i' is not updated in this for-loop, so the loop might never terminate. [missingForLoopIncrement]\n", errout_str());

// Empty body
check("void f(int n) {\n"
" for (int i = 0; i < n;) {\n"
" }\n"
"}\n");
ASSERT_EQUALS("[test.cpp:2:3]: (warning) The loop variable 'i' is not updated in this for-loop, so the loop might never terminate. [missingForLoopIncrement]\n", errout_str());

// Step in header — OK
check("void f(const std::map<int,int>& theMap) {\n"
" for (auto it = theMap.begin(); it != theMap.end(); ++it) {\n"
" (void)*it;\n"
" }\n"
"}\n");
ASSERT_EQUALS("", errout_str());

// Increment in body — OK
check("void f(const std::map<int,int>& theMap) {\n"
" for (auto it = theMap.begin(); it != theMap.end();) {\n"
" ++it;\n"
" }\n"
"}\n");
ASSERT_EQUALS("", errout_str());

// Assignment via erase in body — OK
check("void f(std::map<int,int>& theMap) {\n"
" for (auto it = theMap.begin(); it != theMap.end();) {\n"
" it = theMap.erase(it);\n"
" }\n"
"}\n");
ASSERT_EQUALS("", errout_str());

// += in body — OK
check("void f(int n) {\n"
" for (int i = 0; i < n;) {\n"
" i += 1;\n"
" }\n"
"}\n");
ASSERT_EQUALS("", errout_str());

// break in body — bail out
check("void f(int n) {\n"
" for (int i = 0; i < n;) {\n"
" if (n == 1)\n"
" break;\n"
" }\n"
"}\n");
ASSERT_EQUALS("", errout_str());

// return in body — bail out
check("void f(int n) {\n"
" for (int i = 0; i < n;) {\n"
" return;\n"
" }\n"
"}\n");
ASSERT_EQUALS("", errout_str());

// Infinite for(;;) — no identifiable control var
check("void f() {\n"
" for (;;) {\n"
" }\n"
"}\n");
ASSERT_EQUALS("", errout_str());

// Range-for — OK
check("void f(const std::vector<int>& v) {\n"
" for (auto x : v) {\n"
" (void)x;\n"
" }\n"
"}\n");
ASSERT_EQUALS("", errout_str());

// Opaque call that may modify the variable — bail out
check("void g(int& i);\n"
"void f(int n) {\n"
" for (int i = 0; i < n;) {\n"
" g(i);\n"
" }\n"
"}\n");
ASSERT_EQUALS("", errout_str());

// Nested update in step — OK
check("void f(const std::vector<int*>& v) {\n"
" for (auto it = v.begin(); it != v.end(); delete *it++);\n"
"}\n");
ASSERT_EQUALS("", errout_str());

// Loop var updated on RHS of step assignment — OK
check("void dostuff(int);\n"
"void foo(int num) {\n"
" int a = num;\n"
" for (int b = 0; b < num; a = b++)\n"
" dostuff(a);\n"
"}\n");
ASSERT_EQUALS("", errout_str());
}
};

REGISTER_TEST(TestOther)
Loading