got rid of global CTU::maxCtuDepth (#6892)

danmar · Oct 16, 2024 · 56b7b6a · 56b7b6a
1 parent 89465bc
commit 56b7b6a
Show file tree

Hide file tree

Showing 10 changed files with 46 additions and 26 deletions.
diff --git a/cli/cmdlineparser.cpp b/cli/cmdlineparser.cpp
@@ -903,8 +903,14 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
 
             // max ctu depth
             else if (std::strncmp(argv[i], "--max-ctu-depth=", 16) == 0) {
-                if (!parseNumberArg(argv[i], 16, mSettings.maxCtuDepth))
+                int temp = 0;
+                if (!parseNumberArg(argv[i], 16, temp))
                     return Result::Fail;
+                if (temp > 10) {
+                    mLogger.printMessage("--max-ctu-depth is being capped at 10. This limitation will be removed in a future Cppcheck version.");
+                    temp = 10;
+                }
+                mSettings.maxCtuDepth = temp;
             }
 
             else if (std::strcmp(argv[i], "--no-cpp-header-probe") == 0) {

diff --git a/lib/checkbufferoverrun.cpp b/lib/checkbufferoverrun.cpp
@@ -987,7 +987,6 @@ bool CheckBufferOverrun::analyseWholeProgram(const CTU::FileInfo *ctu, const std
     if (!ctu)
         return false;
     bool foundErrors = false;
-    (void)settings; // This argument is unused
 
     CheckBufferOverrun dummy(nullptr, &settings, &errorLogger);
     dummy.
@@ -1000,14 +999,14 @@ bool CheckBufferOverrun::analyseWholeProgram(const CTU::FileInfo *ctu, const std
         if (!fi)
             continue;
         for (const CTU::FileInfo::UnsafeUsage &unsafeUsage : fi->unsafeArrayIndex)
-            foundErrors |= analyseWholeProgram1(callsMap, unsafeUsage, 1, errorLogger);
+            foundErrors |= analyseWholeProgram1(callsMap, unsafeUsage, 1, errorLogger, settings.maxCtuDepth);
         for (const CTU::FileInfo::UnsafeUsage &unsafeUsage : fi->unsafePointerArith)
-            foundErrors |= analyseWholeProgram1(callsMap, unsafeUsage, 2, errorLogger);
+            foundErrors |= analyseWholeProgram1(callsMap, unsafeUsage, 2, errorLogger, settings.maxCtuDepth);
     }
     return foundErrors;
 }
 
-bool CheckBufferOverrun::analyseWholeProgram1(const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap, const CTU::FileInfo::UnsafeUsage &unsafeUsage, int type, ErrorLogger &errorLogger)
+bool CheckBufferOverrun::analyseWholeProgram1(const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap, const CTU::FileInfo::UnsafeUsage &unsafeUsage, int type, ErrorLogger &errorLogger, int maxCtuDepth)
 {
     const CTU::FileInfo::FunctionCall *functionCall = nullptr;
 
@@ -1017,7 +1016,8 @@ bool CheckBufferOverrun::analyseWholeProgram1(const std::map<std::string, std::l
                                     callsMap,
                                     "Using argument ARG",
                                     &functionCall,
-                                    false);
+                                    false,
+                                    maxCtuDepth);
     if (locationList.empty())
         return false;
 

diff --git a/lib/checkbufferoverrun.h b/lib/checkbufferoverrun.h
@@ -135,7 +135,7 @@ class CPPCHECKLIB CheckBufferOverrun : public Check {
     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);
+    static bool analyseWholeProgram1(const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap, const CTU::FileInfo::UnsafeUsage &unsafeUsage, int type, ErrorLogger &errorLogger, int maxCtuDepth);
 
 
     static std::string myName() {

diff --git a/lib/checknullpointer.cpp b/lib/checknullpointer.cpp
@@ -637,7 +637,8 @@ bool CheckNullPointer::analyseWholeProgram(const CTU::FileInfo *ctu, const std::
                                                 callsMap,
                                                 "Dereferencing argument ARG that is null",
                                                 nullptr,
-                                                warning);
+                                                warning,
+                                                settings.maxCtuDepth);
                 if (locationList.empty())
                     continue;
 

diff --git a/lib/checkuninitvar.cpp b/lib/checkuninitvar.cpp
@@ -1747,7 +1747,8 @@ bool CheckUninitVar::analyseWholeProgram(const CTU::FileInfo *ctu, const std::li
                                             callsMap,
                                             "Using argument ARG",
                                             &functionCall,
-                                            false);
+                                            false,
+                                            settings.maxCtuDepth);
             if (locationList.empty())
                 continue;
 

diff --git a/lib/cppcheck.cpp b/lib/cppcheck.cpp
@@ -1807,8 +1807,6 @@ void CppCheck::analyseClangTidy(const FileSettings &fileSettings)
 bool CppCheck::analyseWholeProgram()
 {
     bool errors = false;
-    // Init CTU
-    CTU::maxCtuDepth = mSettings.maxCtuDepth;
     // Analyse the tokens
     CTU::FileInfo ctu;
     if (mSettings.useSingleJob() || !mSettings.buildDir.empty())
@@ -1881,9 +1879,6 @@ unsigned int CppCheck::analyseWholeProgram(const std::string &buildDir, const st
         }
     }
 
-    // Set CTU max depth
-    CTU::maxCtuDepth = mSettings.maxCtuDepth;
-
     // Analyse the tokens
     // cppcheck-suppress shadowFunction - TODO: fix this
     for (Check *check : Check::instances())

diff --git a/lib/ctu.cpp b/lib/ctu.cpp
@@ -55,8 +55,6 @@ static constexpr char ATTR_MY_ARGNR[] = "my-argnr";
 static constexpr char ATTR_MY_ARGNAME[] = "my-argname";
 static constexpr char ATTR_VALUE[] = "value";
 
-int CTU::maxCtuDepth = 2;
-
 std::string CTU::getFunctionId(const Tokenizer &tokenizer, const Function *function)
 {
     return tokenizer.list.file(function->tokenDef) + ':' + std::to_string(function->tokenDef->linenr()) + ':' + std::to_string(function->tokenDef->column());
@@ -502,10 +500,11 @@ static bool findPath(const std::string &callId,
                      const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap,
                      const CTU::FileInfo::CallBase *path[10],
                      int index,
-                     bool warning)
+                     bool warning,
+                     int maxCtuDepth)
 {
-    if (index >= CTU::maxCtuDepth || index >= 10)
-        return false;
+    if (index >= maxCtuDepth)
+        return false; // TODO: add bailout message?
 
     const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>>::const_iterator it = callsMap.find(callId);
     if (it == callsMap.end())
@@ -543,7 +542,7 @@ static bool findPath(const std::string &callId,
         if (!nestedCall)
             continue;
 
-        if (findPath(nestedCall->myId, nestedCall->myArgNr, unsafeValue, invalidValue, callsMap, path, index + 1, warning)) {
+        if (findPath(nestedCall->myId, nestedCall->myArgNr, unsafeValue, invalidValue, callsMap, path, index + 1, warning, maxCtuDepth)) {
             path[index] = nestedCall;
             return true;
         }
@@ -557,13 +556,14 @@ std::list<ErrorMessage::FileLocation> CTU::FileInfo::getErrorPath(InvalidValueTy
                                                                   const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap,
                                                                   const char info[],
                                                                   const FunctionCall ** const functionCallPtr,
-                                                                  bool warning)
+                                                                  bool warning,
+                                                                  int maxCtuDepth)
 {
     std::list<ErrorMessage::FileLocation> locationList;
 
     const CTU::FileInfo::CallBase *path[10] = {nullptr};
 
-    if (!findPath(unsafeUsage.myId, unsafeUsage.myArgNr, unsafeUsage.value, invalidValue, callsMap, path, 0, warning))
+    if (!findPath(unsafeUsage.myId, unsafeUsage.myArgNr, unsafeUsage.value, invalidValue, callsMap, path, 0, warning, maxCtuDepth))
         return locationList;
 
     const std::string value1 = (invalidValue == InvalidValueType::null) ? "null" : "uninitialized";

diff --git a/lib/ctu.h b/lib/ctu.h
@@ -135,11 +135,10 @@ namespace CTU {
                                                                   const std::map<std::string, std::list<const CallBase *>> &callsMap,
                                                                   const char info[],
                                                                   const FunctionCall ** functionCallPtr,
-                                                                  bool warning);
+                                                                  bool warning,
+                                                                  int maxCtuDepth);
     };
 
-    extern int maxCtuDepth;
-
     CPPCHECKLIB std::string toString(const std::list<FileInfo::UnsafeUsage> &unsafeUsage);
 
     CPPCHECKLIB std::string getFunctionId(const Tokenizer &tokenizer, const Function *function);

diff --git a/releasenotes.txt b/releasenotes.txt
@@ -16,6 +16,7 @@ Changed interface:
 
 Deprecations:
 - The previously deprecated support for Python 2.7 has been removed. please use Python 3 instead.
+- The maximum value for --max-ctu-depth is currently capped at 10. This limitation will be removed in a future release.
 -
 
 Other:

diff --git a/test/testcmdlineparser.cpp b/test/testcmdlineparser.cpp
@@ -323,6 +323,8 @@ class TestCmdlineParser : public TestFixture {
         TEST_CASE(loadAverageNotSupported);
 #endif
         TEST_CASE(maxCtuDepth);
+        TEST_CASE(maxCtuDepth2);
+        TEST_CASE(maxCtuDepthLimit);
         TEST_CASE(maxCtuDepthInvalid);
         TEST_CASE(performanceValueflowMaxTime);
         TEST_CASE(performanceValueflowMaxTimeInvalid);
@@ -2110,10 +2112,25 @@ class TestCmdlineParser : public TestFixture {
 #endif
 
     void maxCtuDepth() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--max-ctu-depth=5", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS(5, settings->maxCtuDepth);
+    }
+
+    void maxCtuDepth2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--max-ctu-depth=10", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS(10, settings->maxCtuDepth);
+    }
+
+    void maxCtuDepthLimit() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-ctu-depth=12", "file.cpp"};
         ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
-        ASSERT_EQUALS(12, settings->maxCtuDepth);
+        ASSERT_EQUALS(10, settings->maxCtuDepth);
+        ASSERT_EQUALS("cppcheck: --max-ctu-depth is being capped at 10. This limitation will be removed in a future Cppcheck version.\n", logger->str());
     }
 
     void maxCtuDepthInvalid() {