fixed #12465 - added command-line option --executor to specify the used executor implementation

Author: firewave

cli/cmdlineparser.cpp

@@ -374,6 +374,7 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
 
     ImportProject project;
 
+    bool executorAuto = true;
     int8_t logMissingInclude{0};
 
     for (int i = 1; i < argc; i++) {
@@ -614,6 +615,36 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
 #endif
             }
 
+            else if (std::strncmp(argv[i], "--executor=", 11) == 0) {
+                const std::string type = 11 + argv[i];
+                if (type == "auto") {
+                    executorAuto = true;
+                    mSettings.executor = Settings::defaultExecutor();
+                }
+                else if (type == "thread") {
+#if defined(HAS_THREADING_MODEL_THREAD)
+                    executorAuto = false;
+                    mSettings.executor = Settings::ExecutorType::Thread;
+#else
+                    mLogger.printError("executor type 'thread' cannot be used as Cppcheck has not been built with a respective threading model.");
+                    return Result::Fail;
+#endif
+                }
+                else if (type == "process") {
+#if defined(HAS_THREADING_MODEL_FORK)
+                    executorAuto = false;
+                    mSettings.executor = Settings::ExecutorType::Process;
+#else
+                    mLogger.printError("executor type 'process' cannot be used as Cppcheck has not been built with a respective threading model.");
+                    return Result::Fail;
+#endif
+                }
+                else {
+                    mLogger.printError("unknown executor: '" + type + "'.");
+                    return Result::Fail;
+                }
+            }
+
             // Filter errors
             else if (std::strncmp(argv[i], "--exitcode-suppressions=", 24) == 0) {
                 // exitcode-suppressions=filename.txt
@@ -1274,6 +1305,10 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
     if (!loadCppcheckCfg())
         return Result::Fail;
 
+    // TODO: bail out?
+    if (!executorAuto && mSettings.useSingleJob())
+        mLogger.printMessage("'--executor' has no effect as only a single job will be used.");
+
     // Default template format..
     if (mSettings.templateFormat.empty()) {
         mSettings.templateFormat = "{bold}{file}:{line}:{column}: {red}{inconclusive:{magenta}}{severity}:{inconclusive: inconclusive:}{default} {message} [{id}]{reset}\\n{code}";
@@ -1430,6 +1465,8 @@ void CmdLineParser::printHelp() const
         "                         provided. Note that your operating system can modify\n"
         "                         this value, e.g. '256' can become '0'.\n"
         "    --errorlist          Print a list of all the error messages in XML format.\n"
+        "    --executor=<type>\n"
+        "                         Specifies the executor to use. Possible values: auto, thread, processor.\n"
         "    --exitcode-suppressions=<file>\n"
         "                         Used when certain messages should be displayed but\n"
         "                         should not cause a non-zero exitcode.\n"

cli/cppcheckexecutor.cpp

@@ -266,18 +266,24 @@ int CppCheckExecutor::check_internal(const Settings& settings) const
     cppcheck.settings() = settings; // this is a copy
     auto& suppressions = cppcheck.settings().supprs.nomsg;
 
-    unsigned int returnValue;
+    unsigned int returnValue = 0;
     if (settings.useSingleJob()) {
         // Single process
         SingleExecutor executor(cppcheck, mFiles, mFileSettings, settings, suppressions, stdLogger);
         returnValue = executor.check();
     } else {
 #if defined(THREADING_MODEL_THREAD)
-        ThreadExecutor executor(mFiles, mFileSettings, settings, suppressions, stdLogger, CppCheckExecutor::executeCommand);
-#elif defined(THREADING_MODEL_FORK)
-        ProcessExecutor executor(mFiles, mFileSettings, settings, suppressions, stdLogger, CppCheckExecutor::executeCommand);
+        if (settings.executor == Settings::ExecutorType::Thread) {
+            ThreadExecutor executor(mFiles, mFileSettings, settings, suppressions, stdLogger, CppCheckExecutor::executeCommand);
+            returnValue = executor.check();
+        }
+#endif
+#if defined(THREADING_MODEL_FORK)
+        if (settings.executor == Settings::ExecutorType::Process) {
+            ProcessExecutor executor(mFiles, mFileSettings, settings, suppressions, stdLogger, CppCheckExecutor::executeCommand);
+            returnValue = executor.check();
+        }
 #endif
-        returnValue = executor.check();
     }
 
     cppcheck.analyseWholeProgram(settings.buildDir, mFiles, mFileSettings);

cmake/compilerDefinitions.cmake

@@ -41,8 +41,8 @@ if (ENABLE_CHECK_INTERNAL)
     add_definitions(-DCHECK_INTERNAL)
 endif()
 
-if (USE_THREADS)
-    add_definitions(-DUSE_THREADS)
+if (ALLOW_THREAD_EXECUTOR)
+    add_definitions(-DALLOW_THREAD_EXECUTOR)
 endif()
 
 if (MSVC AND DISABLE_CRTDBG_MAP_ALLOC)

cmake/options.cmake

@@ -58,10 +58,14 @@ if (BUILD_CORE_DLL)
     set(USE_BUNDLED_TINYXML2 ON)
 endif()
 option(CPPCHK_GLIBCXX_DEBUG "Usage of STL debug checks in Debug build"                      ON)
-option(USE_THREADS          "Usage of threads instead of fork() for -j"                     OFF)
+option(ALLOW_THREAD_EXECUTOR "Allow usage of ThreadExecutor for -j"                         ON)
 option(USE_BOOST            "Usage of Boost"                                                OFF)
 option(USE_LIBCXX           "Use libc++ instead of libstdc++"                               OFF)
 
+if (NOT ALLOW_THREAD_EXECUTOR AND WIN32)
+    message(FATAL_ERROR "Cannot disable usage of ThreadExecutor on Windows as no other executor implementation is currently available")
+endif()
+
 option(DISABLE_CRTDBG_MAP_ALLOC "Disable usage of Visual Studio C++ memory leak detection in Debug build" OFF)
 option(NO_UNIX_SIGNAL_HANDLING "Disable usage of Unix Signal Handling"                      OFF)
 option(NO_UNIX_BACKTRACE_SUPPORT "Disable usage of Unix Backtrace support"                  OFF)

cmake/printInfo.cmake

@@ -71,7 +71,7 @@ if (HAVE_RULES)
     message( STATUS "PCRE_LIBRARY =          ${PCRE_LIBRARY}" )
 endif()
 message( STATUS )
-message( STATUS "USE_THREADS =           ${USE_THREADS}" )
+message( STATUS "ALLOW_THREAD_EXECUTOR =  ${ALLOW_THREAD_EXECUTOR}" )
 message( STATUS "CMAKE_THREAD_LIBS_INIT = ${CMAKE_THREAD_LIBS_INIT}" )
 message( STATUS )
 message( STATUS "USE_BUNDLED_TINYXML2 =  ${USE_BUNDLED_TINYXML2}" )

lib/config.h

@@ -153,11 +153,11 @@ static const std::string emptyString;
 #if defined(_WIN32)
 #define THREADING_MODEL_THREAD
 #define STDCALL __stdcall
-#elif defined(USE_THREADS)
-#define THREADING_MODEL_THREAD
-#define STDCALL
 #elif ((defined(__GNUC__) || defined(__sun)) && !defined(__MINGW32__)) || defined(__CPPCHECK__)
-#define THREADING_MODEL_FORK
+#define HAS_THREADING_MODEL_FORK
+#if defined(ALLOW_THREAD_EXECUTOR)
+#define HAS_THREADING_MODEL_THREAD
+#endif
 #define STDCALL
 #else
 #error "No threading model defined"

lib/settings.cpp

@@ -36,9 +36,11 @@ const char Settings::SafeChecks::XmlExternalVariables[] = "external-variables";
 
 Settings::Settings()
 {
+    // TODO: set default executor
     severity.setEnabled(Severity::error, true);
     certainty.setEnabled(Certainty::normal, true);
     setCheckLevelNormal();
+    executor = defaultExecutor();
 }
 
 std::string Settings::loadCppcheckCfg()
@@ -589,3 +591,14 @@ std::string Settings::getMisraRuleText(const std::string& id, const std::string&
     const auto it = mMisraRuleTexts.find(id.substr(id.rfind('-') + 1));
     return it != mMisraRuleTexts.end() ? it->second : text;
 }
+
+Settings::ExecutorType Settings::defaultExecutor()
+{
+    static constexpr ExecutorType defaultExecutor =
+#if defined(HAS_THREADING_MODEL_FORK)
+        ExecutorType::Process;
+#elif defined(HAS_THREADING_MODEL_THREAD)
+        ExecutorType::Thread;
+#endif
+    return defaultExecutor;
+}

lib/settings.h

@@ -192,6 +192,18 @@ class CPPCHECKLIB WARN_UNUSED Settings {
     bool exceptionHandling{};
 #endif
 
+    enum class ExecutorType
+    {
+#ifdef HAS_THREADING_MODEL_THREAD
+        Thread,
+#endif
+#ifdef HAS_THREADING_MODEL_FORK
+        Process
+#endif
+    };
+
+    ExecutorType executor;
+
     // argv[0]
     std::string exename;
 
@@ -462,6 +474,8 @@ class CPPCHECKLIB WARN_UNUSED Settings {
     void setMisraRuleTexts(const std::string& data);
     std::string getMisraRuleText(const std::string& id, const std::string& text) const;
 
+    static ExecutorType defaultExecutor();
+
 private:
     static std::string parseEnabled(const std::string &str, std::tuple<SimpleEnableGroup<Severity>, SimpleEnableGroup<Checks>> &groups);
     std::string applyEnabled(const std::string &str, bool enable);

man/cppcheck.1.xml

@@ -117,6 +117,9 @@ man(1), man(7), http://www.tldp.org/HOWTO/Man-Page/
       <arg choice="opt">
         <option>--errorlist</option>
       </arg>
+      <arg choice="opt">
+        <option>--executor=&lt;type&gt;</option>
+      </arg>
       <arg choice="opt">
         <option>--exitcode-suppressions=&lt;file&gt;</option>
       </arg>
@@ -328,6 +331,15 @@ Example: '-UDEBUG'</para>
           <para>Print a list of all possible error messages in XML format.</para>
         </listitem>
       </varlistentry>
+      <varlistentry>
+        <term>
+          <option>--executor=&lt;type&gt;</option>
+        </term>
+        <listitem>
+          <para>Specifies the executor to use. Possible values:</para>
+          <glosslist><glossentry><glossterm>auto</glossterm><glossdef><para>Automatically select (default)</para></glossdef></glossentry><glossentry><glossterm>thread</glossterm><glossdef><para>Perform analysis within a thread in the main process</para></glossdef></glossentry><glossentry><glossterm>proicess</glossterm><glossdef><para>Perform analysis of each file in a separate child process</para></glossdef></glossentry></glosslist>
+        </listitem>
+      </varlistentry>
       <varlistentry>
         <term>
           <option>--exitcode-suppressions=&lt;file&gt;</option>

releasenotes.txt

@@ -23,3 +23,6 @@ Other:
 - Added '--template=simple'. It is expands to '{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]' without any additional location details.
 - Removed deprecated platform type 'Unspecified'. Please use 'unspecified' instead.
 - Removed deprecated 'Makefile' option 'SRCDIR'.
+- Added CMake option 'ALLOW_THREAD_EXECUTOR' to control the inclusion of the executor which performs the analysis within a thread of the main process.
+- Removed CMake option 'USE_THREADS' in favor of 'ALLOW_THREAD_EXECUTOR'.
+- Added command-line option `--executor=` to specify the executor. Available options are 'auto', 'process' and 'thread'. 'auto' will prefer 'process' if it is available. Note: Windows has no implementation of 'process' as of now so it will always chose 'thread' for now.

test/testcmdlineparser.cpp

@@ -338,6 +338,21 @@ class TestCmdlineParser : public TestFixture {
         TEST_CASE(signedCharUnsignedChar);
         TEST_CASE(library);
         TEST_CASE(libraryMissing);
+        TEST_CASE(executorDefault);
+        TEST_CASE(executorAuto);
+        TEST_CASE(executorAutoNoJobs);
+#if defined(HAS_THREADING_MODEL_THREAD)
+        TEST_CASE(executorThread);
+        TEST_CASE(executorThreadNoJobs);
+#else
+        TEST_CASE(executorThreadNotSupported);
+#endif
+#if defined(HAS_THREADING_MODEL_FORK)
+        TEST_CASE(executorProcess);
+        TEST_CASE(executorProcessNoJobs);
+#else
+        TEST_CASE(executorProcessNotSupported);
+#endif
 
         TEST_CASE(ignorepaths1);
         TEST_CASE(ignorepaths2);
@@ -2282,6 +2297,87 @@ class TestCmdlineParser : public TestFixture {
         ASSERT_EQUALS("cppcheck: Failed to load library configuration file 'posix2'. File not found\n", logger->str());
     }
 
+    void executorDefault() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(2, argv));
+#if defined(HAS_THREADING_MODEL_FORK)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
+#elif defined(HAS_THREADING_MODEL_THREAD)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
+#endif
+    }
+
+    void executorAuto() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j2", "--executor=auto", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+#if defined(HAS_THREADING_MODEL_FORK)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
+#elif defined(HAS_THREADING_MODEL_THREAD)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
+#endif
+    }
+
+    void executorAutoNoJobs() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--executor=auto", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+#if defined(HAS_THREADING_MODEL_FORK)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
+#elif defined(HAS_THREADING_MODEL_THREAD)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
+#endif
+    }
+
+#if defined(HAS_THREADING_MODEL_THREAD)
+    void executorThread() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j2", "--executor=thread", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
+    }
+
+    void executorThreadNoJobs() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--executor=thread", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
+        ASSERT_EQUALS("cppcheck: '--executor' has no effect as only a single job will be used.\n", logger->str());
+    }
+#else
+    void executorThreadNotSupported() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j2", "--executor=thread", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS("cppcheck: error: executor type 'thread' cannot be used as Cppcheck has not been built with a respective threading model.\n", logger->str());
+    }
+#endif
+
+#if defined(HAS_THREADING_MODEL_FORK)
+    void executorProcess() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j2", "--executor=process", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
+    }
+
+    void executorProcessNoJobs() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--executor=process", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
+        ASSERT_EQUALS("cppcheck: '--executor' has no effect as only a single job will be used.\n", logger->str());
+    }
+#else
+    void executorProcessNotSupported() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j2", "--executor=process", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS("cppcheck: error: executor type 'process' cannot be used as Cppcheck has not been built with a respective threading model.\n", logger->str());
+    }
+#endif
+
     void ignorepaths1() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-isrc", "file.cpp"};