[build] Redeveloped and improved setting C/C++ standards in the build system (#1251)

* C/C++ standards support added to `qpl_set_common_target_properties()` CMake function:
  * C/C++ standard is set for a target in the following way:
    * If the required version of C/C++ standard is supported by CMake [`C_STANDARD`](https://cmake.org/cmake/help/latest/prop_tgt/C_STANDARD.html)/[`CXX_STANDARD`](https://cmake.org/cmake/help/latest/prop_tgt/CXX_STANDARD.html) properties, then these properties are set for the target (together with [`C_EXTENSIONS`](https://cmake.org/cmake/help/latest/prop_tgt/C_EXTENSIONS.html)/[`CXX_EXTENSIONS`](https://cmake.org/cmake/help/latest/prop_tgt/CXX_EXTENSIONS.html) set to `OFF` and [`C_STANDARD_REQUIRED`](https://cmake.org/cmake/help/latest/prop_tgt/C_STANDARD.html)/[`CXX_STANDARD_REQUIRED`](https://cmake.org/cmake/help/latest/prop_tgt/CXX_STANDARD_REQUIRED.html) set to `ON`). Otherwise, `-std=...` (Linux) and `/std:` (Windows) flags are set.
    * If the required version of C/C++ language feature ([`c_std_<version>`](https://cmake.org/cmake/help/latest/prop_gbl/CMAKE_C_KNOWN_FEATURES.html#high-level-meta-features-indicating-c-standard-support)/[`cxx_std_<version>`](https://cmake.org/cmake/help/latest/prop_gbl/CMAKE_CXX_KNOWN_FEATURES.html#high-level-meta-features-indicating-c-standard-support)) is supported by CMake, then it is activated for the target additionally.
  * C/C++ compiler flags have been fixed in all `CMakeLists.txt` files:
    * If C/C++ standard set for a component was C17 or C++17, then the corresponding setting has been removed (since C17 and C++17 are set by default in `qpl_set_common_target_properties()` now).
    * If some other version of the standards was set, then it is passed via arguments `C` or `CXX` to `qpl_set_common_target_properties()` function call now (if there were no function call of this function previosly for a particular target, it has been added).
    * A non-existent standard C18 was used for the build of some components using MSVC previously; all such occurrences have been replaced with C17.
* C/C++ standard conformance warnings are enabled:
  * Windows: [`/permissive-`](https://learn.microsoft.com/en-us/cpp/build/reference/permissive-standards-conformance), [`/volatile:iso`](https://learn.microsoft.com/en-us/cpp/build/reference/volatile-volatile-keyword-interpretation)
  * Linux: [`-pedantic`](https://clang.llvm.org/docs/ClangCommandLineReference.html#cmdoption-clang-pedantic) or `-pedantic-errors` (depending on the value of `QPL_TREAT_WARNINGS_AS_ERRORS` CMake option)
* Fixed mostly all standard conformance warnings for all supported compilers. The warnings remained unfixed are suppressed using `#pragma GCC diagnostic ignored` (for gcc and clang):
  * Fixed warnings:
    * Redundant semicolons have been removed, including:
      * `QPL_API` and `OWN_QPLC_API` macros don't have a trailing semicolon anymore; semicolons have been added after the usage of these macros where it was needed.
    * `OWN_CRC32` variadic macro was converted into an ordinary macro (receiving CRC calculation implementation as its last argument). `GZIP_REFL` is now passed to all existing occurrences of this macro (to preserve old behavior).
    * C function `hw_get_job_size()` which takes no arguments has been marked as receiving `void`.
    * `hw_configuration_driver.c` is conditionally included in build now using CMake rules, not `#if ... #endif` language constructs (to avoid empty translation units).
    * Pointers to functions in C are stored in variables of the type `void (*)(void)` now, not `void*`.
    * POSIX compliance level for Linux builds of ISA-L has been set to 200809L (to use `strnlen()` function on Linux).
  * Suppressed warnings:
    * Conversion of function pointers returned from `dlsym()` function (of the type `void*`) to variables storing pointers to functions.
    * Anonymous `struct`s and `union`s, including nested ones.

Author: tizmajlo

Doxyfile

@@ -2150,14 +2150,14 @@ INCLUDE_FILE_PATTERNS  =
 # recursively expanded use the := operator instead of the = operator.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-PREDEFINED             = "QPL_API(type,name,arg)=type name arg;" \
+PREDEFINED             = "QPL_API(type,name,arg)=type name arg" \
                          "OWN_FUN(type,name,arg)=type name arg" \
                          "QPL_FUN(type,name,arg)=type name arg" \
                          "HW_PATH_GENERAL_API(type,name,arg)=type hw_##name arg" \
                          "HW_PATH_IAA_API(type,name,arg)=type hw_iaa_##name arg" \
                          "HW_PATH_IAA_AECS_API(type,name,arg)=type hw_iaa_aecs_##name arg" \
                          "HW_PATH_BYTE_PACKED_STRUCTURE_BEGIN=typedef struct" \
-                         "OWN_QPLC_API(type,name,arg)=type name arg;" \
+                         "OWN_QPLC_API(type,name,arg)=type name arg" \
                          "OWN_QPLC_FUN(type,name,arg)=type name arg" \
                          "QPL_DEPRECATED(msg)=" \
                          "QPL_PROCESSING_ERROR_BASE=0U" \

cmake/target_settings.cmake

@@ -4,14 +4,140 @@
 # SPDX-License-Identifier: MIT
 # ==========================================================================
 
+# Intel® Query Processing Library (Intel® QPL)
+
+# Build system
+
 include_guard(GLOBAL)
 
+set(QPL_LANGUAGES C CXX)
+set(QPL_DEFAULT_C_STANDARD 17)
+set(QPL_DEFAULT_CXX_STANDARD 17)
+
+# Sets the language standard of the given language ${language} for the given target ${target_name} to the given version ${version}.
+function (qpl_set_language_standard target_name language version)
+    if (NOT language IN_LIST QPL_LANGUAGES)
+        message(
+            FATAL_ERROR
+                "Intel(R) QPL: Unsupported language '${language}' specified for target '${target_name}'. Supported languages are: ${QPL_LANGUAGES}.")
+    endif ()
+    if (language STREQUAL "C")
+        set(language_prefix "c")
+    elseif (language STREQUAL "CXX")
+        set(language_prefix "c++")
+    endif ()
+    set(language_standard "${language_prefix}${version}")
+    # Set the language standard using `<LANG>_STANDARD` target property if it is supported by CMake (otherwise, use the compile option
+    # `-std=<standard>`)
+    set(language_version_is_supported_by_cmake FALSE)
+    if (language STREQUAL "C")
+        # https://cmake.org/cmake/help/latest/prop_tgt/C_STANDARD.html
+        if (((version GREATER_EQUAL 90 OR version VERSION_LESS 17) AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.1")
+            OR (version VERSION_LESS_EQUAL 23 AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.21"))
+            set(language_version_is_supported_by_cmake TRUE)
+        endif ()
+        if (version VERSION_GREATER 23 AND version VERSION_LESS 90)
+            message(
+                FATAL_ERROR
+                    "Intel(R) QPL: C standard version '${version}' is not supported by Intel(R) QPL build system. Please, fix this CMake file to add support for this version."
+            )
+        endif ()
+    elseif (language STREQUAL "CXX")
+        # https://cmake.org/cmake/help/latest/prop_tgt/CXX_STANDARD.html
+        if (((version GREATER_EQUAL 98 OR version VERSION_LESS 17) AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.1")
+            OR (version VERSION_EQUAL 17 AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.8")
+            OR (version VERSION_EQUAL 20 AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.12")
+            OR (version VERSION_EQUAL 23 AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
+            OR (version VERSION_EQUAL 26 AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.25"))
+            set(language_version_is_supported_by_cmake TRUE)
+        endif ()
+        if (version VERSION_GREATER 26 AND version VERSION_LESS 98)
+            message(
+                FATAL_ERROR
+                    "Intel(R) QPL: C++ standard version '${version}' is not supported by Intel(R) QPL build system. Please, fix this CMake file to add support for this version."
+            )
+        endif ()
+    endif ()
+    if (language_version_is_supported_by_cmake)
+        set_target_properties(
+            ${target_name}
+            PROPERTIES ${language}_STANDARD ${version}
+                       ${language}_EXTENSIONS OFF
+                       ${language}_STANDARD_REQUIRED ON)
+    else ()
+        target_compile_options(
+            ${target_name} PRIVATE $<$<AND:$<COMPILE_LANGUAGE:${language}>,$<${language}_COMPILER_ID:GNU,Clang>>:-std=${language_standard}>
+                                   $<$<AND:$<COMPILE_LANGUAGE:${language}>,$<${language}_COMPILER_ID:MSVC>>:/std:${language_standard}>)
+    endif ()
+    # Additionally, set the language standard using `<lang>_std_<version>` compile feature if it is supported by CMake
+    set(language_feature_is_supported_by_cmake FALSE)
+    if (language STREQUAL "C")
+        # https://cmake.org/cmake/help/latest/prop_gbl/CMAKE_C_KNOWN_FEATURES.html
+        if (((version GREATER_EQUAL 90 OR version VERSION_LESS 17) AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.8")
+            OR (version VERSION_LESS_EQUAL 23 AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.21"))
+            set(language_feature_is_supported_by_cmake TRUE)
+        endif ()
+        if (version VERSION_GREATER 23 AND version VERSION_LESS 90)
+            message(FATAL_ERROR "Intel(R) QPL: C standard version feature 'c_std_${version}' is not supported by Intel(R) QPL build system. \
+Please, fix this CMake file to add support for this version.")
+        endif ()
+    elseif (language STREQUAL "CXX")
+        # https://cmake.org/cmake/help/latest/prop_gbl/CMAKE_CXX_KNOWN_FEATURES.html
+        if (((version GREATER_EQUAL 98 OR version VERSION_LESS 20) AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.8")
+            OR (version VERSION_EQUAL 20 AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.12")
+            OR (version VERSION_EQUAL 23 AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
+            OR (version VERSION_EQUAL 26 AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.30"))
+            set(language_feature_is_supported_by_cmake TRUE)
+        endif ()
+        if (version VERSION_GREATER 26 AND version VERSION_LESS 98)
+            message(FATAL_ERROR "Intel(R) QPL: C++ standard version feature 'cxx_std_${version}' is not supported by Intel(R) QPL build system. \
+Please, fix this CMake file to add support for this version.")
+        endif ()
+    endif ()
+    if (language_feature_is_supported_by_cmake)
+        set(language_feature "${language}_std_${version}")
+        string(TOLOWER "${language_feature}" language_feature)
+        target_compile_features(${target_name} PRIVATE ${language_feature})
+    endif ()
+endfunction ()
+
+# Sets C and C++ language standards for the given target ${target_name}.
+#
+# Defaults are C17 and C++17.
+function (qpl_set_language_standards target_name)
+    cmake_parse_arguments(
+        "ARGUMENT" # prefix
+        "" # options
+        "${QPL_LANGUAGES}" # one-value arguments
+        "" # multi-value arguments
+        ${ARGN})
+    foreach (language IN LISTS QPL_LANGUAGES)
+        if (NOT DEFINED ARGUMENT_${language})
+            set(ARGUMENT_${language} ${QPL_DEFAULT_${language}_STANDARD})
+        endif ()
+        qpl_set_language_standard(${target_name} ${language} ${ARGUMENT_${language}})
+    endforeach ()
+endfunction ()
+
 option(QPL_TREAT_WARNINGS_AS_ERRORS "Treat all compiler warnings as errors" ON)
 
 # Enables all reasonable warnings for a target with the given name ${target_name}.
 #
 # Treats them as errors if $CACHE{QPL_TREAT_WARNINGS_AS_ERRORS} option is set to ON.
 function (qpl_enable_warnings target_name)
+    # TODO: enable warnings here, and not in CMakeLists.txt files
+
+    # Enable C/C++ standard conformance warnings
+    if (MSVC)
+        target_compile_options(${target_name} PRIVATE /permissive- /volatile:iso)
+    else ()
+        if ($CACHE{QPL_TREAT_WARNINGS_AS_ERRORS})
+            target_compile_options(${target_name} PRIVATE -pedantic-errors)
+        else ()
+            target_compile_options(${target_name} PRIVATE -pedantic)
+        endif ()
+    endif ()
+    # Treat warnings as errors
     if ($CACHE{QPL_TREAT_WARNINGS_AS_ERRORS})
         if (MSVC)
             target_compile_options(${target_name} PRIVATE /WX)
@@ -23,5 +149,6 @@ endfunction ()
 
 # Sets common target settings for the target with the given name ${target_name}.
 function (qpl_set_common_target_settings target_name)
+    qpl_set_language_standards(${target_name} ${ARGN})
     qpl_enable_warnings(${target_name})
 endfunction ()

examples/low-level-api/CMakeLists.txt

@@ -49,7 +49,6 @@ foreach(source_file ${cpp_files})
         target_link_libraries(${example_name} PRIVATE accel-config)
         target_compile_definitions(${example_name} PRIVATE "QPL_EXAMPLES_USE_LIBACCEL_CONFIG")
     endif()
-    set_target_properties(${example_name} PROPERTIES CXX_STANDARD 17)
 
     if(WIN32)
         target_compile_options(${example_name} PRIVATE "$<$<CONFIG:Release>:-O2>")

include/qpl/c_api/defs.h

@@ -32,7 +32,7 @@ extern "C" {
  * @brief Macro to manipulate public API prototypes
  */
 #if !defined(QPL_API)
-#define QPL_API(type, name, arg) type name arg;
+#define QPL_API(type, name, arg) type name arg
 #endif
 
 #if !defined(UNREFERENCED_PARAMETER)

include/qpl/c_api/index_table.h

@@ -65,7 +65,7 @@ typedef struct {
  *     - @ref QPL_STS_NULL_PTR_ERR.
  */
 QPL_API(qpl_status, qpl_get_index_table_size,
-        (uint32_t mini_block_count, uint32_t mini_blocks_per_block, size_t* size_ptr))
+        (uint32_t mini_block_count, uint32_t mini_blocks_per_block, size_t* size_ptr));
 
 /**
  * @brief Sets source pointer to required position for further mini-block decompression
@@ -83,7 +83,7 @@ QPL_API(qpl_status, qpl_get_index_table_size,
  */
 QPL_API(qpl_status, qpl_set_mini_block_location,
         (uint32_t start_bit, uint32_t last_bit, uint8_t** source_pptr, uint32_t* first_bit_offset_ptr,
-         uint32_t* last_bit_offset_ptr, uint32_t* compressed_size_ptr))
+         uint32_t* last_bit_offset_ptr, uint32_t* compressed_size_ptr));
 
 /**
  * @brief Sets appropriate deflate block index
@@ -97,7 +97,7 @@ QPL_API(qpl_status, qpl_set_mini_block_location,
  *     - @ref QPL_STS_NULL_PTR_ERR.
  */
 QPL_API(qpl_status, qpl_find_header_block_index,
-        (qpl_index_table * table_ptr, uint32_t mini_block_number, uint32_t* block_index_ptr))
+        (qpl_index_table * table_ptr, uint32_t mini_block_number, uint32_t* block_index_ptr));
 
 /**
  * @brief Sets appropriate mini-block index
@@ -111,7 +111,7 @@ QPL_API(qpl_status, qpl_find_header_block_index,
  *     - @ref QPL_STS_NULL_PTR_ERR.
  */
 QPL_API(qpl_status, qpl_find_mini_block_index,
-        (qpl_index_table * table_ptr, uint32_t mini_block_number, uint32_t* block_index_ptr))
+        (qpl_index_table * table_ptr, uint32_t mini_block_number, uint32_t* block_index_ptr));
 
 /** @} */
 

include/qpl/c_api/job.h

@@ -158,7 +158,7 @@ typedef struct {
  *     - @ref QPL_STS_OK;
  *     - @ref QPL_STS_PATH_ERR.
  */
-QPL_API(qpl_status, qpl_get_job_size, (qpl_path_t qpl_path, uint32_t* job_size_ptr))
+QPL_API(qpl_status, qpl_get_job_size, (qpl_path_t qpl_path, uint32_t* job_size_ptr));
 
 /**
  * @brief Initializes the qpl_job structure and ensures proper alignment of internal structures.
@@ -179,7 +179,7 @@ QPL_API(qpl_status, qpl_get_job_size, (qpl_path_t qpl_path, uint32_t* job_size_p
  *     - @ref QPL_STS_PATH_ERR;
  *     - @ref QPL_STS_NULL_PTR_ERR.
  */
-QPL_API(qpl_status, qpl_init_job, (qpl_path_t qpl_path, qpl_job* qpl_job_ptr))
+QPL_API(qpl_status, qpl_init_job, (qpl_path_t qpl_path, qpl_job* qpl_job_ptr));
 
 /**
  * @brief Parses the qpl_job structure and forms the corresponding processing functions pipeline.
@@ -188,7 +188,7 @@ QPL_API(qpl_status, qpl_init_job, (qpl_path_t qpl_path, qpl_job* qpl_job_ptr))
  *
  * @return One of statuses presented in the @ref qpl_status
  */
-QPL_API(qpl_status, qpl_execute_job, (qpl_job * qpl_job_ptr))
+QPL_API(qpl_status, qpl_execute_job, (qpl_job * qpl_job_ptr));
 
 /**
  * @brief Parses the qpl_job structure and forms the corresponding processing functions pipeline.
@@ -199,7 +199,7 @@ QPL_API(qpl_status, qpl_execute_job, (qpl_job * qpl_job_ptr))
  * @return One of statuses presented in the @ref qpl_status
  *
  */
-QPL_API(qpl_status, qpl_submit_job, (qpl_job * qpl_job_ptr))
+QPL_API(qpl_status, qpl_submit_job, (qpl_job * qpl_job_ptr));
 
 /**
  * @brief Waits for the end of @ref qpl_job processing. (waits until the job is completed)
@@ -209,7 +209,7 @@ QPL_API(qpl_status, qpl_submit_job, (qpl_job * qpl_job_ptr))
  * @return One of statuses presented in the @ref qpl_status
  *
  */
-QPL_API(qpl_status, qpl_wait_job, (qpl_job * qpl_job_ptr))
+QPL_API(qpl_status, qpl_wait_job, (qpl_job * qpl_job_ptr));
 
 /**
  * @brief Checks the status of @ref qpl_job processing. (can be queried periodically to check the status
@@ -219,7 +219,7 @@ QPL_API(qpl_status, qpl_wait_job, (qpl_job * qpl_job_ptr))
  *
  * @return One of statuses presented in the @ref qpl_status
  */
-QPL_API(qpl_status, qpl_check_job, (qpl_job * qpl_job_ptr))
+QPL_API(qpl_status, qpl_check_job, (qpl_job * qpl_job_ptr));
 
 /**
  * @brief Completes @ref qpl_job lifecycle: disconnects from the internal library context, frees internal resources.
@@ -228,7 +228,7 @@ QPL_API(qpl_status, qpl_check_job, (qpl_job * qpl_job_ptr))
  *
  * @return ne of statuses presented in the @ref qpl_status
  */
-QPL_API(qpl_status, qpl_fini_job, (qpl_job * qpl_job_ptr))
+QPL_API(qpl_status, qpl_fini_job, (qpl_job * qpl_job_ptr));
 
 /** @} */
 

include/qpl/c_api/statistics.h

@@ -74,7 +74,7 @@ typedef struct {
  */
 QPL_API(qpl_status, qpl_gather_deflate_statistics,
         (uint8_t * source_ptr, const uint32_t source_length, qpl_histogram* histogram_ptr,
-         const qpl_compression_levels level, const qpl_path_t path))
+         const qpl_compression_levels level, const qpl_path_t path));
 
 /** @} */
 

include/qpl/c_api/utility.h

@@ -40,7 +40,7 @@ extern "C" {
  *
  * @return uint32_t
  */
-QPL_API(uint32_t, qpl_get_safe_deflate_compression_buffer_size, (uint32_t source_size))
+QPL_API(uint32_t, qpl_get_safe_deflate_compression_buffer_size, (uint32_t source_size));
 
 /** @} */
 

sources/c_api/CMakeLists.txt

@@ -39,9 +39,6 @@ target_include_directories(qpl_c_api
         PRIVATE $<TARGET_PROPERTY:middle_layer_lib,INTERFACE_INCLUDE_DIRECTORIES>)
 
 set_target_properties(qpl_c_api PROPERTIES
-        $<$<C_COMPILER_ID:MSVC>:C_STANDARD 18>
-        $<$<C_COMPILER_ID:GNU,Clang>:C_STANDARD 17>
-        CXX_STANDARD 17
         C_VISIBILITY_PRESET hidden
         CXX_VISIBILITY_PRESET hidden)
 

sources/c_api/compression_operations/own_deflate_job.c

@@ -20,9 +20,6 @@
 #include "deflate_histogram.h"
 #include "qplc_compression_consts.h"
 
-#define OWN_CRC32(buf, len, init_crc, ...) \
-    ((0, ##__VA_ARGS__) ? qpl_crc32_iscsi(buf, len, init_crc) : qpl_crc32_gzip_refl(init_crc, buf, len))
-
 /* ------ Own functions implementation ------ */
 
 void own_deflate_job_switch_to_next(own_deflate_job* const job_ptr, const uint32_t range) {
@@ -34,8 +31,9 @@ static inline void own_deflate_job_update_missed_literals(own_deflate_job* const
                                                           const uint8_t*         upper_bound_ptr) {
     while (job_ptr->current_ptr < upper_bound_ptr) {
         // Variables
-        const uint32_t hash_value = OWN_CRC32(job_ptr->current_ptr, QPLC_DEFLATE_BYTES_FOR_HASH_CALCULATION, 0U) &
-                                    job_ptr->histogram_ptr->table.hash_mask;
+        const uint32_t hash_value =
+                OWN_CRC32(job_ptr->current_ptr, QPLC_DEFLATE_BYTES_FOR_HASH_CALCULATION, 0U, GZIP_REFL) &
+                job_ptr->histogram_ptr->table.hash_mask;
 
         // Updating hash table
         own_deflate_hash_table_update(&job_ptr->histogram_ptr->table,
@@ -95,8 +93,8 @@ void own_deflate_job_process_literals_no_instructions(own_deflate_job* const job
             const uint32_t bytes_for_hash = QPL_MIN(QPLC_DEFLATE_BYTES_FOR_HASH_CALCULATION,
                                                     (uint32_t)(upper_bound_ptr - job_ptr->current_ptr));
 
-            const uint32_t hash_value =
-                    OWN_CRC32(job_ptr->current_ptr, bytes_for_hash, 0U) & job_ptr->histogram_ptr->table.hash_mask;
+            const uint32_t hash_value = OWN_CRC32(job_ptr->current_ptr, bytes_for_hash, 0U, GZIP_REFL) &
+                                        job_ptr->histogram_ptr->table.hash_mask;
 
             // Updating histogram
             job_ptr->histogram_ptr->literals_matches[*job_ptr->current_ptr]++;
@@ -111,8 +109,9 @@ void own_deflate_job_process_literals_no_instructions(own_deflate_job* const job
     } else {
         while (job_ptr->current_ptr < upper_bound_ptr) {
             // Variables
-            const uint32_t hash_value = OWN_CRC32(job_ptr->current_ptr, QPLC_DEFLATE_BYTES_FOR_HASH_CALCULATION, 0U) &
-                                        job_ptr->histogram_ptr->table.hash_mask;
+            const uint32_t hash_value =
+                    OWN_CRC32(job_ptr->current_ptr, QPLC_DEFLATE_BYTES_FOR_HASH_CALCULATION, 0U, GZIP_REFL) &
+                    job_ptr->histogram_ptr->table.hash_mask;
 
             // Updating histogram
             job_ptr->histogram_ptr->literals_matches[*job_ptr->current_ptr]++;