removed the need for Check object in CTU::getUnsafeUsage() callback / some CheckUninitVar cleanups (#5610)

firewave · web-flow · commit 989d276dde17 · 2023-11-03T18:27:11.000+01:00
The `Check` objects were just created for that purpose so they basically
just were wrappers for the pointers passed into them and were
unnecessary.
diff --git a/lib/checkbufferoverrun.cpp b/lib/checkbufferoverrun.cpp
@@ -906,14 +906,11 @@ namespace {
     };
 }
 
-bool CheckBufferOverrun::isCtuUnsafeBufferUsage(const Check *check, const Token *argtok, MathLib::bigint *offset, int type)
+bool CheckBufferOverrun::isCtuUnsafeBufferUsage(const Settings *settings, const Token *argtok, MathLib::bigint *offset, int type)
 {
     if (!offset)
         return false;
-    const CheckBufferOverrun *c = dynamic_cast<const CheckBufferOverrun *>(check);
-    if (!c)
-        return false;
-    if (!argtok->valueType() || argtok->valueType()->typeSize(c->mSettings->platform) == 0)
+    if (!argtok->valueType() || argtok->valueType()->typeSize(settings->platform) == 0)
         return false;
     const Token *indexTok = nullptr;
     if (type == 1 && Token::Match(argtok, "%name% [") && argtok->astParent() == argtok->next() && !Token::simpleMatch(argtok->linkAt(1), "] ["))
@@ -926,27 +923,26 @@ bool CheckBufferOverrun::isCtuUnsafeBufferUsage(const Check *check, const Token
         return false;
     if (!indexTok->hasKnownIntValue())
         return false;
-    *offset = indexTok->getKnownIntValue() * argtok->valueType()->typeSize(c->mSettings->platform);
+    *offset = indexTok->getKnownIntValue() * argtok->valueType()->typeSize(settings->platform);
     return true;
 }
 
-bool CheckBufferOverrun::isCtuUnsafeArrayIndex(const Check *check, const Token *argtok, MathLib::bigint *offset)
+bool CheckBufferOverrun::isCtuUnsafeArrayIndex(const Settings *settings, const Token *argtok, MathLib::bigint *offset)
 {
-    return CheckBufferOverrun::isCtuUnsafeBufferUsage(check, argtok, offset, 1);
+    return isCtuUnsafeBufferUsage(settings, argtok, offset, 1);
 }
 
-bool CheckBufferOverrun::isCtuUnsafePointerArith(const Check *check, const Token *argtok, MathLib::bigint *offset)
+bool CheckBufferOverrun::isCtuUnsafePointerArith(const Settings *settings, const Token *argtok, MathLib::bigint *offset)
 {
-    return CheckBufferOverrun::isCtuUnsafeBufferUsage(check, argtok, offset, 2);
+    return isCtuUnsafeBufferUsage(settings, argtok, offset, 2);
 }
 
 /** @brief Parse current TU and extract file info */
 Check::FileInfo *CheckBufferOverrun::getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const
 {
-    CheckBufferOverrun checkBufferOverrun(tokenizer, settings, nullptr);
     MyFileInfo *fileInfo = new MyFileInfo;
-    fileInfo->unsafeArrayIndex = CTU::getUnsafeUsage(tokenizer, settings, &checkBufferOverrun, isCtuUnsafeArrayIndex);
-    fileInfo->unsafePointerArith = CTU::getUnsafeUsage(tokenizer, settings, &checkBufferOverrun, isCtuUnsafePointerArith);
+    fileInfo->unsafeArrayIndex = CTU::getUnsafeUsage(tokenizer, settings, isCtuUnsafeArrayIndex);
+    fileInfo->unsafePointerArith = CTU::getUnsafeUsage(tokenizer, settings, isCtuUnsafePointerArith);
     if (fileInfo->unsafeArrayIndex.empty() && fileInfo->unsafePointerArith.empty()) {
         delete fileInfo;
         return nullptr;
diff --git a/lib/checkbufferoverrun.h b/lib/checkbufferoverrun.h
@@ -130,9 +130,9 @@ class CPPCHECKLIB CheckBufferOverrun : public Check {
     ValueFlow::Value getBufferSize(const Token *bufTok) const;
 
     // CTU
-    static bool isCtuUnsafeBufferUsage(const Check *check, const Token *argtok, MathLib::bigint *offset, int type);
-    static bool isCtuUnsafeArrayIndex(const Check *check, const Token *argtok, MathLib::bigint *offset);
-    static bool isCtuUnsafePointerArith(const Check *check, const Token *argtok, MathLib::bigint *offset);
+    static bool isCtuUnsafeBufferUsage(const Settings *settings, const Token *argtok, MathLib::bigint *offset, int type);
+    static bool isCtuUnsafeArrayIndex(const Settings *settings, const Token *argtok, MathLib::bigint *offset);
+    static bool isCtuUnsafePointerArith(const Settings *settings, const Token *argtok, MathLib::bigint *offset);
 
     Check::FileInfo * loadFileInfoFromXml(const tinyxml2::XMLElement *xmlElement) const override;
     static bool analyseWholeProgram1(const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap, const CTU::FileInfo::UnsafeUsage &unsafeUsage, int type, ErrorLogger &errorLogger);
diff --git a/lib/checknullpointer.cpp b/lib/checknullpointer.cpp
@@ -549,12 +549,11 @@ void CheckNullPointer::redundantConditionWarning(const Token* tok, const ValueFl
 }
 
 // NOLINTNEXTLINE(readability-non-const-parameter) - used as callback so we need to preserve the signature
-static bool isUnsafeUsage(const Check *check, const Token *vartok, MathLib::bigint *value)
+static bool isUnsafeUsage(const Settings *settings, const Token *vartok, MathLib::bigint *value)
 {
     (void)value;
-    const CheckNullPointer *checkNullPointer = dynamic_cast<const CheckNullPointer *>(check);
     bool unknown = false;
-    return checkNullPointer && checkNullPointer->isPointerDeRef(vartok, unknown);
+    return CheckNullPointer::isPointerDeRef(vartok, unknown, settings);
 }
 
 namespace {
@@ -575,8 +574,7 @@ namespace {
 
 Check::FileInfo *CheckNullPointer::getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const
 {
-    CheckNullPointer check(tokenizer, settings, nullptr);
-    const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(tokenizer, settings, &check, ::isUnsafeUsage);
+    const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(tokenizer, settings, isUnsafeUsage);
     if (unsafeUsage.empty())
         return nullptr;
 
diff --git a/lib/checkuninitvar.cpp b/lib/checkuninitvar.cpp
@@ -1129,8 +1129,9 @@ static bool isVoidCast(const Token *tok)
     return Token::simpleMatch(tok, "(") && tok->isCast() && tok->valueType() && tok->valueType()->type == ValueType::Type::VOID && tok->valueType()->pointer == 0;
 }
 
-const Token* CheckUninitVar::isVariableUsage(bool cpp, const Token *vartok, const Library& library, bool pointer, Alloc alloc, int indirect)
+const Token* CheckUninitVar::isVariableUsage(const Token *vartok, const Library& library, bool pointer, Alloc alloc, int indirect)
 {
+    const bool cpp = vartok->isCpp();
     const Token *valueExpr = vartok;   // non-dereferenced , no address of value as variable
     while (Token::Match(valueExpr->astParent(), ".|::") && astIsRhs(valueExpr))
         valueExpr = valueExpr->astParent();
@@ -1334,7 +1335,7 @@ const Token* CheckUninitVar::isVariableUsage(bool cpp, const Token *vartok, cons
 
 const Token* CheckUninitVar::isVariableUsage(const Token *vartok, bool pointer, Alloc alloc, int indirect) const
 {
-    return CheckUninitVar::isVariableUsage(mTokenizer->isCPP(), vartok, mSettings->library, pointer, alloc, indirect);
+    return isVariableUsage(vartok, mSettings->library, pointer, alloc, indirect);
 }
 
 /***
@@ -1681,18 +1682,11 @@ void CheckUninitVar::valueFlowUninit()
     }
 }
 
-Check::FileInfo *CheckUninitVar::getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const
-{
-    const CheckUninitVar checker(tokenizer, settings, nullptr);
-    return checker.getFileInfo();
-}
-
 // NOLINTNEXTLINE(readability-non-const-parameter) - used as callback so we need to preserve the signature
-static bool isVariableUsage(const Check *check, const Token *vartok, MathLib::bigint *value)
+static bool isVariableUsage(const Settings *settings, const Token *vartok, MathLib::bigint *value)
 {
     (void)value;
-    const CheckUninitVar *c = dynamic_cast<const CheckUninitVar *>(check);
-    return c && c->isVariableUsage(vartok, true, CheckUninitVar::Alloc::ARRAY);
+    return CheckUninitVar::isVariableUsage(vartok, settings->library, true, CheckUninitVar::Alloc::ARRAY);
 }
 
 namespace {
@@ -1710,9 +1704,9 @@ namespace {
     };
 }
 
-Check::FileInfo *CheckUninitVar::getFileInfo() const
+Check::FileInfo *CheckUninitVar::getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const
 {
-    const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(mTokenizer, mSettings, this, ::isVariableUsage);
+    const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(tokenizer, settings, ::isVariableUsage);
     if (unsafeUsage.empty())
         return nullptr;
 
diff --git a/lib/checkuninitvar.h b/lib/checkuninitvar.h
@@ -71,7 +71,7 @@ class CPPCHECKLIB CheckUninitVar : public Check {
 
     enum Alloc { NO_ALLOC, NO_CTOR_CALL, CTOR_CALL, ARRAY };
 
-    static const Token *isVariableUsage(bool cpp, const Token *vartok, const Library &library, bool pointer, Alloc alloc, int indirect = 0);
+    static const Token *isVariableUsage(const Token *vartok, const Library &library, bool pointer, Alloc alloc, int indirect = 0);
     const Token *isVariableUsage(const Token *vartok, bool pointer, Alloc alloc, int indirect = 0) const;
 
 private:
@@ -129,7 +129,6 @@ class CPPCHECKLIB CheckUninitVar : public Check {
     void uninitStructMemberError(const Token *tok, const std::string &membername);
 
     std::set<const Token*> mUninitDiags;
-    Check::FileInfo* getFileInfo() const;
 
     void getErrorMessages(ErrorLogger* errorLogger, const Settings* settings) const override
     {
diff --git a/lib/ctu.cpp b/lib/ctu.cpp
@@ -436,7 +436,7 @@ CTU::FileInfo *CTU::getFileInfo(const Tokenizer *tokenizer)
     return fileInfo;
 }
 
-static std::list<std::pair<const Token *, MathLib::bigint>> getUnsafeFunction(const Tokenizer *tokenizer, const Settings *settings, const Scope *scope, int argnr, const Check *check, bool (*isUnsafeUsage)(const Check *check, const Token *argtok, MathLib::bigint *value))
+static std::list<std::pair<const Token *, MathLib::bigint>> getUnsafeFunction(const Tokenizer *tokenizer, const Settings *settings, const Scope *scope, int argnr, bool (*isUnsafeUsage)(const Settings *settings, const Token *argtok, MathLib::bigint *value))
 {
     std::list<std::pair<const Token *, MathLib::bigint>> ret;
     const Variable * const argvar = scope->function->getArgumentVar(argnr);
@@ -460,15 +460,15 @@ static std::list<std::pair<const Token *, MathLib::bigint>> getUnsafeFunction(co
         if (tok2->variable() != argvar)
             continue;
         MathLib::bigint value = 0;
-        if (!isUnsafeUsage(check, tok2, &value))
+        if (!isUnsafeUsage(settings, tok2, &value))
             return ret; // TODO: Is this a read? then continue..
         ret.emplace_back(tok2, value);
         return ret;
     }
     return ret;
 }
 
-std::list<CTU::FileInfo::UnsafeUsage> CTU::getUnsafeUsage(const Tokenizer *tokenizer, const Settings *settings, const Check *check, bool (*isUnsafeUsage)(const Check *check, const Token *argtok, MathLib::bigint *value))
+std::list<CTU::FileInfo::UnsafeUsage> CTU::getUnsafeUsage(const Tokenizer *tokenizer, const Settings *settings, bool (*isUnsafeUsage)(const Settings *settings, const Token *argtok, MathLib::bigint *value))
 {
     std::list<CTU::FileInfo::UnsafeUsage> unsafeUsage;
 
@@ -482,7 +482,7 @@ std::list<CTU::FileInfo::UnsafeUsage> CTU::getUnsafeUsage(const Tokenizer *token
 
         // "Unsafe" functions unconditionally reads data before it is written..
         for (int argnr = 0; argnr < function->argCount(); ++argnr) {
-            for (const std::pair<const Token *, MathLib::bigint> &v : getUnsafeFunction(tokenizer, settings, &scope, argnr, check, isUnsafeUsage)) {
+            for (const std::pair<const Token *, MathLib::bigint> &v : getUnsafeFunction(tokenizer, settings, &scope, argnr, isUnsafeUsage)) {
                 const Token *tok = v.first;
                 const MathLib::bigint val = v.second;
                 unsafeUsage.emplace_back(CTU::getFunctionId(tokenizer, function), argnr+1, tok->str(), CTU::FileInfo::Location(tokenizer,tok), val);
diff --git a/lib/ctu.h b/lib/ctu.h
@@ -146,7 +146,7 @@ namespace CTU {
     /** @brief Parse current TU and extract file info */
     CPPCHECKLIB FileInfo *getFileInfo(const Tokenizer *tokenizer);
 
-    CPPCHECKLIB std::list<FileInfo::UnsafeUsage> getUnsafeUsage(const Tokenizer *tokenizer, const Settings *settings, const Check *check, bool (*isUnsafeUsage)(const Check *check, const Token *argtok, MathLib::bigint *value));
+    CPPCHECKLIB std::list<FileInfo::UnsafeUsage> getUnsafeUsage(const Tokenizer *tokenizer, const Settings *settings, bool (*isUnsafeUsage)(const Settings *settings, const Token *argtok, MathLib::bigint *value));
 
     CPPCHECKLIB std::list<FileInfo::UnsafeUsage> loadUnsafeUsageListFromXml(const tinyxml2::XMLElement *xmlElement);
 }
diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
@@ -7658,7 +7658,7 @@ static void valueFlowSubFunction(TokenList& tokenlist, SymbolDatabase& symboldat
                 });
                 // Remove uninit values if argument is passed by value
                 if (argtok->variable() && !argtok->variable()->isPointer() && argvalues.size() == 1 && argvalues.front().isUninitValue()) {
-                    if (CheckUninitVar::isVariableUsage(tokenlist.isCPP(), argtok, settings.library, false, CheckUninitVar::Alloc::NO_ALLOC, 0))
+                    if (CheckUninitVar::isVariableUsage(argtok, settings.library, false, CheckUninitVar::Alloc::NO_ALLOC, 0))
                         continue;
                 }
 

Original file line number	Diff line number	Diff line change
`@@ -549,12 +549,11 @@ void CheckNullPointer::redundantConditionWarning(const Token* tok, const ValueFl`
`549`	`549`	`}`
`550`	`550`
`551`	`551`	`// NOLINTNEXTLINE(readability-non-const-parameter) - used as callback so we need to preserve the signature`
`552`		`-static bool isUnsafeUsage(const Check check, const Token vartok, MathLib::bigint *value)`
	`552`	`+static bool isUnsafeUsage(const Settings settings, const Token vartok, MathLib::bigint *value)`
`553`	`553`	`{`
`554`	`554`	`(void)value;`
`555`		`- const CheckNullPointer checkNullPointer = dynamic_cast<const CheckNullPointer >(check);`
`556`	`555`	`bool unknown = false;`
`557`		`- return checkNullPointer && checkNullPointer->isPointerDeRef(vartok, unknown);`
	`556`	`+ return CheckNullPointer::isPointerDeRef(vartok, unknown, settings);`
`558`	`557`	`}`
`559`	`558`
`560`	`559`	`namespace {`
`@@ -575,8 +574,7 @@ namespace {`
`575`	`574`
`576`	`575`	`Check::FileInfo CheckNullPointer::getFileInfo(const Tokenizer tokenizer, const Settings *settings) const`
`577`	`576`	`{`
`578`		`- CheckNullPointer check(tokenizer, settings, nullptr);`
`579`		`- const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(tokenizer, settings, &check, ::isUnsafeUsage);`
	`577`	`+ const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(tokenizer, settings, isUnsafeUsage);`
`580`	`578`	`if (unsafeUsage.empty())`
`581`	`579`	`return nullptr;`
`582`	`580`
Original file line number	Diff line number	Diff line change
`@@ -1129,8 +1129,9 @@ static bool isVoidCast(const Token *tok)`
`1129`	`1129`	`return Token::simpleMatch(tok, "(") && tok->isCast() && tok->valueType() && tok->valueType()->type == ValueType::Type::VOID && tok->valueType()->pointer == 0;`
`1130`	`1130`	`}`
`1131`	`1131`
`1132`		`-const Token* CheckUninitVar::isVariableUsage(bool cpp, const Token *vartok, const Library& library, bool pointer, Alloc alloc, int indirect)`
	`1132`	`+const Token* CheckUninitVar::isVariableUsage(const Token *vartok, const Library& library, bool pointer, Alloc alloc, int indirect)`
`1133`	`1133`	`{`
	`1134`	`+ const bool cpp = vartok->isCpp();`
`1134`	`1135`	`const Token *valueExpr = vartok; // non-dereferenced , no address of value as variable`
`1135`	`1136`	`while (Token::Match(valueExpr->astParent(), ".\|::") && astIsRhs(valueExpr))`
`1136`	`1137`	`valueExpr = valueExpr->astParent();`
`@@ -1334,7 +1335,7 @@ const Token* CheckUninitVar::isVariableUsage(bool cpp, const Token *vartok, cons`
`1334`	`1335`
`1335`	`1336`	`const Token* CheckUninitVar::isVariableUsage(const Token *vartok, bool pointer, Alloc alloc, int indirect) const`
`1336`	`1337`	`{`
`1337`		`- return CheckUninitVar::isVariableUsage(mTokenizer->isCPP(), vartok, mSettings->library, pointer, alloc, indirect);`
	`1338`	`+ return isVariableUsage(vartok, mSettings->library, pointer, alloc, indirect);`
`1338`	`1339`	`}`
`1339`	`1340`
`1340`	`1341`	`/***`
`@@ -1681,18 +1682,11 @@ void CheckUninitVar::valueFlowUninit()`
`1681`	`1682`	`}`
`1682`	`1683`	`}`
`1683`	`1684`
`1684`		`-Check::FileInfo CheckUninitVar::getFileInfo(const Tokenizer tokenizer, const Settings *settings) const`
`1685`		`-{`
`1686`		`- const CheckUninitVar checker(tokenizer, settings, nullptr);`
`1687`		`- return checker.getFileInfo();`
`1688`		`-}`
`1689`		`-`
`1690`	`1685`	`// NOLINTNEXTLINE(readability-non-const-parameter) - used as callback so we need to preserve the signature`
`1691`		`-static bool isVariableUsage(const Check check, const Token vartok, MathLib::bigint *value)`
	`1686`	`+static bool isVariableUsage(const Settings settings, const Token vartok, MathLib::bigint *value)`
`1692`	`1687`	`{`
`1693`	`1688`	`(void)value;`
`1694`		`- const CheckUninitVar c = dynamic_cast<const CheckUninitVar >(check);`
`1695`		`- return c && c->isVariableUsage(vartok, true, CheckUninitVar::Alloc::ARRAY);`
	`1689`	`+ return CheckUninitVar::isVariableUsage(vartok, settings->library, true, CheckUninitVar::Alloc::ARRAY);`
`1696`	`1690`	`}`
`1697`	`1691`
`1698`	`1692`	`namespace {`
`@@ -1710,9 +1704,9 @@ namespace {`
`1710`	`1704`	`};`
`1711`	`1705`	`}`
`1712`	`1706`
`1713`		`-Check::FileInfo *CheckUninitVar::getFileInfo() const`
	`1707`	`+Check::FileInfo CheckUninitVar::getFileInfo(const Tokenizer tokenizer, const Settings *settings) const`
`1714`	`1708`	`{`
`1715`		`- const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(mTokenizer, mSettings, this, ::isVariableUsage);`
	`1709`	`+ const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(tokenizer, settings, ::isVariableUsage);`
`1716`	`1710`	`if (unsafeUsage.empty())`
`1717`	`1711`	`return nullptr;`
`1718`	`1712`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ namespace CTU {`
`146`	`146`	`/** @brief Parse current TU and extract file info */`
`147`	`147`	`CPPCHECKLIB FileInfo getFileInfo(const Tokenizer tokenizer);`
`148`	`148`
`149`		`- CPPCHECKLIB std::list<FileInfo::UnsafeUsage> getUnsafeUsage(const Tokenizer tokenizer, const Settings settings, const Check check, bool (isUnsafeUsage)(const Check check, const Token argtok, MathLib::bigint *value));`
	`149`	`+ CPPCHECKLIB std::list<FileInfo::UnsafeUsage> getUnsafeUsage(const Tokenizer tokenizer, const Settings settings, bool (isUnsafeUsage)(const Settings settings, const Token argtok, MathLib::bigint value));`
`150`	`150`
`151`	`151`	`CPPCHECKLIB std::list<FileInfo::UnsafeUsage> loadUnsafeUsageListFromXml(const tinyxml2::XMLElement *xmlElement);`
`152`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7658,7 +7658,7 @@ static void valueFlowSubFunction(TokenList& tokenlist, SymbolDatabase& symboldat`
`7658`	`7658`	`});`
`7659`	`7659`	`// Remove uninit values if argument is passed by value`
`7660`	`7660`	`if (argtok->variable() && !argtok->variable()->isPointer() && argvalues.size() == 1 && argvalues.front().isUninitValue()) {`
`7661`		`- if (CheckUninitVar::isVariableUsage(tokenlist.isCPP(), argtok, settings.library, false, CheckUninitVar::Alloc::NO_ALLOC, 0))`
	`7661`	`+ if (CheckUninitVar::isVariableUsage(argtok, settings.library, false, CheckUninitVar::Alloc::NO_ALLOC, 0))`
`7662`	`7662`	`continue;`
`7663`	`7663`	`}`
`7664`	`7664`