Intel compiler support (#24217)

### Details: - Initial version of Intel compiler support - Only Linux is covered - Current PR is a prerequisite for https://github.com/openvinotoolkit/openvino/pull/23534
2024-04-27 18:03:28 +04:00 · 2024-04-27 18:03:28 +04:00 · c121e896da
parent 3b0d2013b8
commit c121e896da
62 changed files with 170 additions and 113 deletions
--- a/.github/workflows/code_snippets.yml
+++ b/.github/workflows/code_snippets.yml
@ -36,6 +36,10 @@ jobs:
          packages: ocl-icd-opencl-dev opencl-headers
          version: 3.0

+      - name: Install scons
+        if: runner.os == 'macOS'
+        run: brew install scons
+
      - name: CMake configure
        run: cmake -DCMAKE_BUILD_TYPE=Release -DTHREADING=SEQ -B build

--- a/cmake/dependencies.cmake
+++ b/cmake/dependencies.cmake
@ -158,6 +158,7 @@ function(ov_download_tbb)
        update_deps_cache(TBB_DIR "${TBBROOT}/lib/cmake/TBB" "Path to TBB cmake folder")
    elseif(EXISTS "${TBBROOT}/lib/cmake/tbb/TBBConfig.cmake")
        # oneTBB release package version less than 2021.6.0
+        # or TBB from oneAPI package
        update_deps_cache(TBB_DIR "${TBBROOT}/lib/cmake/tbb" "Path to TBB cmake folder")
    elseif(EXISTS "${TBBROOT}/lib64/cmake/TBB/TBBConfig.cmake")
        # 64-bits oneTBB case
--- a/cmake/developer_package/compile_flags/os_flags.cmake
+++ b/cmake/developer_package/compile_flags/os_flags.cmake
@ -20,7 +20,7 @@ macro(ov_disable_deprecated_warnings)
        else()
            set(ov_c_cxx_deprecated "-diag-disable=1478,1786")
        endif()
-    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
+    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
        set(ov_c_cxx_deprecated "-Wno-deprecated-declarations")
    else()
        message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
@ -48,7 +48,7 @@ macro(ov_deprecated_no_errors)
        else()
            set(ov_c_cxx_deprecated_no_errors "-diag-warning=1478,1786")
        endif()
-    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
+    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
        set(ov_c_cxx_deprecated_no_errors "-Wno-error=deprecated-declarations")
        # Suppress #warning messages
        set(ov_c_cxx_deprecated_no_errors "${ov_c_cxx_deprecated_no_errors} -Wno-cpp")
@ -68,7 +68,7 @@ endmacro()
 # Exports flags for 3rdparty modules, but without errors
 #
 macro(ov_dev_package_no_errors)
-    if(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
+    if(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
        set(ov_c_cxx_dev_no_errors "-Wno-all")
        if(SUGGEST_OVERRIDE_SUPPORTED)
            set(ov_cxx_dev_no_errors "-Wno-error=suggest-override")
@ -100,7 +100,7 @@ endmacro()
 macro(ov_sse42_optimization_flags flags)
    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
        # No such option for MSVC 2019
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" OR OV_COMPILER_IS_INTEL_LLVM)
        if(WIN32)
            set(${flags} /QxSSE4.2)
        else()
@ -130,7 +130,7 @@ macro(ov_avx2_optimization_flags flags)
        else()
            set(${flags} -xCORE-AVX2)
        endif()
-    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
+    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
        set(${flags} -mavx2 -mfma -mf16c)
    else()
        message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
@ -152,7 +152,7 @@ macro(ov_avx512_optimization_flags flags)
        else()
            set(${flags} -xCOMMON-AVX512)
        endif()
-    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
+    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
        set(${flags} -mavx512f -mavx512bw -mavx512vl -mfma -mf16c)
    else()
        message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
@ -200,7 +200,7 @@ function(ov_disable_all_warnings)

        if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
            target_compile_options(${target} PRIVATE /WX-)
-        elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
+        elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
            target_compile_options(${target} PRIVATE -w)
            # required for LTO
            set(link_interface INTERFACE_LINK_OPTIONS)
@ -239,7 +239,7 @@ endmacro()
 function(ov_force_include target scope header_file)
    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
        target_compile_options(${target} ${scope} /FI"${header_file}")
-    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
+    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
        target_compile_options(${target} ${scope} -include "${header_file}")
    else()
        message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
@ -314,7 +314,7 @@ set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
 if(CMAKE_CL_64)
    # Default char Type Is unsigned
    # ov_add_compiler_flags(/J)
-elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
+elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
    ov_add_compiler_flags(-fsigned-char)
 endif()

@ -449,22 +449,12 @@ else()
    # To guarantee OpenVINO can be used with gcc versions 7 through 12
    # - https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Dialect-Options.html
    # - https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html
-    if(CMAKE_COMPILER_IS_GNUCXX)
-        if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "8")
+    if((CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8) OR
+       (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 10) OR OV_COMPILER_IS_INTEL_LLVM)
        # Enable __FILE__ trim only for release mode
        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ffile-prefix-map=${OV_NATIVE_PROJECT_ROOT_DIR}/= -ffile-prefix-map=${OV_RELATIVE_BIN_PATH}/=")
        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffile-prefix-map=${OV_NATIVE_PROJECT_ROOT_DIR}/= -ffile-prefix-map=${OV_RELATIVE_BIN_PATH}/=")
    endif()
-        # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wabi=11")
-    endif()
-
-    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "10")
-            # Enable __FILE__ trim only for release mode
-            set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ffile-prefix-map=${OV_NATIVE_PROJECT_ROOT_DIR}/= -ffile-prefix-map=${OV_RELATIVE_BIN_PATH}/=")
-            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffile-prefix-map=${OV_NATIVE_PROJECT_ROOT_DIR}/= -ffile-prefix-map=${OV_RELATIVE_BIN_PATH}/=")
-        endif()
-    endif()

    #
    # Warnings as errors
@ -483,6 +473,10 @@ else()
        ov_add_compiler_flags(-diag-disable=remark,177,2196)
    endif()

+    if(OV_COMPILER_IS_INTEL_LLVM)
+        ov_add_compiler_flags(-Wno-tautological-constant-compare)
+    endif()
+
    #
    # Linker flags
    #
@ -507,6 +501,11 @@ else()
        endif()
        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
    endif()
+
+    if(OV_COMPILER_IS_INTEL_LLVM)
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-intel")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-intel")
+    endif()
 endif()

 add_compile_definitions(
--- a/cmake/developer_package/compile_flags/sdl.cmake
+++ b/cmake/developer_package/compile_flags/sdl.cmake
@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR
+if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM OR
    (UNIX AND CMAKE_CXX_COMPILER_ID STREQUAL "Intel"))
    set(OV_C_CXX_FLAGS "${OV_C_CXX_FLAGS} -Wformat -Wformat-security")

@ -32,7 +32,7 @@ if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR
        if(NOT MINGW)
            set(OV_LINKER_FLAGS "${OV_LINKER_FLAGS} -z noexecstack -z relro -z now")
        endif()
-    elseif(OV_COMPILER_IS_CLANG)
+    elseif(OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
        if(EMSCRIPTEN)
            # emcc does not support fortification 
            # https://stackoverflow.com/questions/58854858/undefined-symbol-stack-chk-guard-in-libopenh264-so-when-building-ffmpeg-wit
--- a/cmake/developer_package/cross_compile/native_compile.cmake
+++ b/cmake/developer_package/cross_compile/native_compile.cmake
@ -62,7 +62,7 @@ function(ov_native_compile_external_project)
    endif()

    # compile flags
-    if(CMAKE_COMPILER_IS_GNUCXX)
+    if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
        set(compile_flags "-Wno-undef -Wno-error -Wno-deprecated-declarations")
    endif()

--- a/cmake/developer_package/frontends/frontends.cmake
+++ b/cmake/developer_package/frontends/frontends.cmake
@ -212,7 +212,7 @@ macro(ov_add_frontend)
    endif()

    # remove -Wmissing-declarations warning, because of frontends implementation specific
-    if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
+    if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
        target_compile_options(${TARGET_NAME} PRIVATE -Wno-missing-declarations)
    endif()

--- a/cmake/developer_package/target_flags.cmake
+++ b/cmake/developer_package/target_flags.cmake
@ -111,6 +111,10 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "^(Apple)?Clang$")
    endif()
 endif()

+if(CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
+    set(OV_COMPILER_IS_INTEL_LLVM ON)
+endif()
+
 get_property(OV_GENERATOR_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)

 function(ov_get_compiler_definition definition var)
--- a/docs/snippets/CMakeLists.txt
+++ b/docs/snippets/CMakeLists.txt
@ -4,11 +4,8 @@

 set(TARGET_NAME openvino_docs_snippets)

-if(CMAKE_COMPILER_IS_GNUCXX)
+if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
    ov_add_compiler_flags(-Wall)
-endif()
-
-if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
    ov_add_compiler_flags(-Wno-unused-variable)
 endif()
 if(UNUSED_BUT_SET_VARIABLE_SUPPORTED)
--- a/docs/snippets/template_pattern_transformation.cpp
+++ b/docs/snippets/template_pattern_transformation.cpp
@ -10,6 +10,7 @@
 #include "openvino/opsets/opset3.hpp"
 #include "openvino/pass/manager.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "transformations/utils/utils.hpp"
 #include "template_model_transformation.hpp"

 // ! [graph_rewrite:template_transformation_cpp]
@ -61,7 +62,7 @@ ov::pass::ReluReluFusionMatcher::ReluReluFusionMatcher() {
    auto m_relu1 = ov::pass::pattern::wrap_type<ov::opset3::Relu>(pattern::consumers_count(1));
    auto m_relu2 = ov::pass::pattern::wrap_type<ov::opset3::Relu>({m_relu1});

-    ov::matcher_pass_callback callback = [=](pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
        // Map that helps to connect labels with matched outputs
        auto& node_to_output = m.get_pattern_value_map();

--- a/src/bindings/python/src/pyopenvino/CMakeLists.txt
+++ b/src/bindings/python/src/pyopenvino/CMakeLists.txt
@ -21,18 +21,18 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
 set(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
 set(CMAKE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})

-# compile options
+# compile and linker options

 if(OV_COMPILER_IS_APPLECLANG)
    add_link_options(-stdlib=libc++)
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+elseif(CMAKE_COMPILER_IS_GNUCXX)
    # WA for GCC 7.5 "PYBIND11_NOINLINE inline" warning
-    add_compile_options(-Wno-error=attributes)
+    ov_add_compiler_flags(-Wno-error=attributes)
 endif()

-if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
-    # for proper fix need to update pybind to version which does not use PyEval_InitThreads()
-    add_compile_options(-Wno-deprecated-declarations -Wno-undef)
+if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
+    # TODO: remove this deprecated API usage
+    ov_add_compiler_flags(-Wno-error=deprecated-declarations)
 endif()

 if(ENABLE_TESTS)
--- a/src/cmake/install_tbb.cmake
+++ b/src/cmake/install_tbb.cmake
@ -139,6 +139,8 @@ if(THREADING MATCHES "^(TBB|TBB_AUTO)$" AND
        if(NOT DEFINED TBBROOT AND DEFINED ENV{TBBROOT})
            file(TO_CMAKE_PATH $ENV{TBBROOT} TBBROOT)
        endif()
+        # sometimes TBBROOT can be set with relative paths inside (e.g. oneAPI package)
+        get_filename_component(TBBROOT "${TBBROOT}" ABSOLUTE)
        if(NOT DEFINED TBBROOT)
            get_target_property(_tbb_include_dir TBB::tbb INTERFACE_INCLUDE_DIRECTORIES)
            get_filename_component(TBBROOT ${_tbb_include_dir} PATH)
@ -163,6 +165,7 @@ if(THREADING MATCHES "^(TBB|TBB_AUTO)$" AND
        # try to select proper library directory
        _ov_get_tbb_location(TBB::tbb _tbb_lib_location)
        get_filename_component(_tbb_libs_dir "${_tbb_lib_location}" DIRECTORY)
+        get_filename_component(_tbb_libs_dir "${_tbb_libs_dir}" REALPATH)
        file(RELATIVE_PATH tbb_libs_dir "${TBBROOT}" "${_tbb_libs_dir}")

        # install only meaningful directories
@ -176,11 +179,25 @@ if(THREADING MATCHES "^(TBB|TBB_AUTO)$" AND
                    set(tbb_component tbb)
                    set(exclude_pattern REGEX ".*(cmake|pkgconfig)$" EXCLUDE)
                endif()
+
+                if(tbb_libs_dir STREQUAL dir)
+                    file(GLOB _tbb_libs ${TBBROOT}/${tbb_libs_dir}/*)
+                    foreach(_tbb_lib IN LISTS _tbb_libs)
+                        if(_tbb_lib MATCHES ".*${CMAKE_SHARED_LIBRARY_SUFFIX}.*")
+                            # resolve absolute path to avoid issues with installation
+                            get_filename_component(_tbb_lib "${_tbb_lib}" REALPATH)
+                            install(PROGRAMS "${_tbb_lib}"
+                                    DESTINATION "${IE_TBBROOT_INSTALL}/${dir}"
+                                    COMPONENT ${tbb_component})
+                        endif()
+                    endforeach()
+                else()
                    install(DIRECTORY "${TBBROOT}/${dir}/"
                            DESTINATION "${IE_TBBROOT_INSTALL}/${dir}"
                            COMPONENT ${tbb_component}
                            ${exclude_pattern})
                endif()
+            endif()
        endforeach()

        set(TBB_LIB_INSTALL_DIR "${IE_TBBROOT_INSTALL}/${tbb_libs_dir}" CACHE PATH "TBB library install directory" FORCE)
--- a/src/common/low_precision_transformations/src/assign_and_read_value.cpp
+++ b/src/common/low_precision_transformations/src/assign_and_read_value.cpp
@ -23,7 +23,7 @@ AssignAndReadValueTransformation::AssignAndReadValueTransformation(const std::sh
    auto assign3 = pattern::wrap_type<opset3::Assign>({ pattern::wrap_type<ov::opset1::Multiply>() });
    auto assign6 = pattern::wrap_type<opset6::Assign>({ pattern::wrap_type<ov::opset1::Multiply>() });

-    ov::graph_rewrite_callback callback = [=](pattern::Matcher& m) {
+    ov::graph_rewrite_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
        const auto& opsMap = m.get_pattern_value_map();
        auto op = m.get_match_root();
        auto assignIt = opsMap.find(assign3);
--- a/src/common/low_precision_transformations/src/convert_subtract_constant.cpp
+++ b/src/common/low_precision_transformations/src/convert_subtract_constant.cpp
@ -44,7 +44,7 @@ ov::pass::low_precision::ConvertSubtractConstant::ConvertSubtractConstant(const
    auto multiplyConstantWrapper = ov::pass::pattern::wrap_type<opset1::Constant>(pattern::consumers_count(1));
    auto multiplyWrapper = ov::pass::pattern::wrap_type<opset1::Multiply>({ subtractWrapper, multiplyConstantWrapper }, pattern::consumers_count(1));

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher & m) -> bool {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher & m) -> bool {
        const auto& opsMap = m.get_pattern_value_map();
        const auto weightsConvert = opsMap.at(weightsConvertWrapper).get_node_shared_ptr();
        const auto quantizePrecision = weightsConvert->get_input_element_type(0);
--- a/src/common/low_precision_transformations/src/reshape.cpp
+++ b/src/common/low_precision_transformations/src/reshape.cpp
@ -33,7 +33,7 @@ ReshapeTransformation::ReshapeTransformation(const Params& params) : LayerTransf
    auto reshape_pattern = std::make_shared<pass::pattern::op::Or>(OutputVector{ reshape_pattern_const, reshape_pattern_nonconst });
    auto matcher = pattern::wrap_type<ov::opset1::Reshape>({ mul_m, reshape_pattern });

-    ov::graph_rewrite_callback callback = [=](pattern::Matcher& m) {
+    ov::graph_rewrite_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
        auto op = m.get_match_root();
        if (transformation_callback(op)) {
            return false;
--- a/src/common/snippets/src/pass/extract_reshapes_from_mha.cpp
+++ b/src/common/snippets/src/pass/extract_reshapes_from_mha.cpp
@ -10,6 +10,7 @@
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "snippets/itt.hpp"
 #include "snippets/pass/mha_tokenization.hpp"
+#include "transformations/utils/utils.hpp"

 using namespace ov::pass;

@ -26,7 +27,7 @@ ov::snippets::pass::ExtractReshapesFromMHA::ExtractReshapesFromMHA() {
    auto add_2_m = pattern::wrap_type<opset1::Add>({add_1_m, sparse_input_2_m}, static_shape_single_consumer);
    auto reshape_2_m = pattern::wrap_type<opset1::Reshape>({add_2_m, pattern::wrap_type<opset1::Constant>()}, pattern::has_static_shape());

-    matcher_pass_callback callback = [=](pattern::Matcher& m) {
+    matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
        OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::op::ExtractReshapesFromMHA")
        const auto& pattern_map = m.get_pattern_value_map();
        const auto& matmul = pattern_map.at(matmul_m);
--- a/src/common/snippets/src/pass/fq_decomposition.cpp
+++ b/src/common/snippets/src/pass/fq_decomposition.cpp
@ -12,6 +12,7 @@
 #include "openvino/pass/manager.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "openvino/pass/validate.hpp"
+#include "transformations/utils/utils.hpp"

 #include "openvino/reference/autobroadcast_binop.hpp"
 #include "openvino/reference/broadcast.hpp"
@ -31,7 +32,7 @@ ov::snippets::pass::FakeQuantizeDecomposition::FakeQuantizeDecomposition() {
                                        ov::pass::pattern::wrap_type<ov::op::v0::Constant>(),
                                        ov::pass::pattern::wrap_type<ov::op::v0::Constant>()});

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::op::FakeQuantizeDecomposition")
        auto& pattern_to_output = m.get_pattern_value_map();
        const auto fake_quantize_node = std::dynamic_pointer_cast<ov::op::v0::FakeQuantize>(
--- a/src/common/snippets/src/pass/matmul_to_brgemm.cpp
+++ b/src/common/snippets/src/pass/matmul_to_brgemm.cpp
@ -10,6 +10,7 @@

 #include "openvino/core/rt_info.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "transformations/utils/utils.hpp"

 namespace ov {
 namespace snippets {
@ -33,7 +34,7 @@ MatMulToBrgemm::MatMulToBrgemm() {
    MATCHER_SCOPE(MatMulToBrgemm);
    auto matmul_pattern = ov::pass::pattern::wrap_type<ov::opset1::MatMul>({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()});

-    auto callback = [=](ov::pass::pattern::Matcher& m) {
+    auto callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "ov::intel_cpu::pass::MatMulToBrgemm")
        auto& pm = m.get_pattern_value_map();
        const auto matmul = as_type_ptr<ov::opset1::MatMul>(pm.at(matmul_pattern).get_node_shared_ptr());
--- a/src/common/snippets/src/pass/mha_tokenization.cpp
+++ b/src/common/snippets/src/pass/mha_tokenization.cpp
@ -12,6 +12,7 @@
 #include "snippets/pass/explicit_transpose_matmul_inputs.hpp"
 #include "snippets/pass/mha_tokenization.hpp"
 #include "snippets/utils.hpp"
+#include "transformations/utils/utils.hpp"

 namespace {
 bool is_supported_tensor(const ov::descriptor::Tensor& t) {
@ -207,7 +208,7 @@ ov::snippets::pass::TokenizeMHASnippets::TokenizeMHASnippets(const SnippetsToken
                                                          ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()));

    register_matcher(std::make_shared<ov::pass::pattern::Matcher>(m_matmul0, matcher_name),
-        [=](ov::pass::pattern::Matcher &m) {
+        [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher &m) {
        OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::op::TokenizeMHASnippets")
        auto& pattern_to_output = m.get_pattern_value_map();

--- a/src/common/snippets/src/pass/transpose_decomposition.cpp
+++ b/src/common/snippets/src/pass/transpose_decomposition.cpp
@ -8,6 +8,7 @@
 #include "snippets/snippets_isa.hpp"
 #include "snippets/lowered/port_descriptor.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "transformations/utils/utils.hpp"

 namespace ov {
 namespace snippets {
@ -41,7 +42,7 @@ TransposeDecomposition::TransposeDecomposition() {
    auto match_order = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
    auto match_transpose = ov::pass::pattern::wrap_type<ov::opset1::Transpose>({match_data, match_order});

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::op::TransposeDecomposition")
        auto& pattern_to_output = m.get_pattern_value_map();
        const auto& data_input = pattern_to_output.at(match_data);
--- a/src/common/transformations/include/transformations/utils/utils.hpp
+++ b/src/common/transformations/include/transformations/utils/utils.hpp
@ -16,21 +16,10 @@
 #include "openvino/op/constant.hpp"
 #include "openvino/op/convert.hpp"
 #include "openvino/pass/graph_rewrite.hpp"
+#include "openvino/util/pp.hpp"
 #include "transformations/rt_info/attributes.hpp"
 #include "transformations_visibility.hpp"

-/* This macro is intended to fix C++20 [=] lambda
-warning. Although C++20 identifier is 202002L,
-some compilers supporting C++20, or their drafts like
-C++2a, producing the warning, are using 201402L value.
-Also, MSVC requires a special check due to the
-__cplusplus value compatibility issues.*/
-#if (defined(_MSVC_LANG) && (_MSVC_LANG >= 202002L)) || (__cplusplus >= 201402L)
-#    define OV_CAPTURE_CPY_AND_THIS =, this
-#else
-#    define OV_CAPTURE_CPY_AND_THIS =
-#endif /* C++20 */
-
 namespace ov {
 namespace op {
 namespace util {
--- a/src/common/transformations/src/transformations/op_conversions/convert_gather_to_compressed.cpp
+++ b/src/common/transformations/src/transformations/op_conversions/convert_gather_to_compressed.cpp
@ -55,7 +55,7 @@ ov::pass::ConvertGatherToGatherCompressed::ConvertGatherToGatherCompressed() {
        std::make_shared<ov::pass::pattern::op::Or>(ov::OutputVector{reshape_m, last_convert_m, mul_m});
    auto gather_m = wrap_type<ov::op::v8::Gather>({dicts_input_m, any_input(), wrap_type<ov::op::v0::Constant>()});

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();
        OPENVINO_ASSERT(pattern_map.count(gather_m));
        OPENVINO_ASSERT(pattern_map.count(mul_const_m));
--- a/src/common/util/include/openvino/util/pp.hpp
+++ b/src/common/util/include/openvino/util/pp.hpp
@ -51,3 +51,15 @@

 // Ignores inputs
 #define OV_PP_IGNORE(...)
+
+/* This macro is intended to fix C++20 [=] lambda
+warning. Although C++20 identifier is 202002L,
+some compilers supporting C++20, or their drafts like
+C++2a, producing the warning, are using 201402L value.
+Also, MSVC requires a special check due to the
+__cplusplus value compatibility issues.*/
+#if (defined(_MSVC_LANG) && (_MSVC_LANG >= 202002L)) || (__cplusplus >= 202002L)
+#    define OV_CAPTURE_CPY_AND_THIS =, this
+#else
+#    define OV_CAPTURE_CPY_AND_THIS =
+#endif /* C++20 */
--- a/src/frontends/paddle/src/internal/pass/transform_fakequantize.cpp
+++ b/src/frontends/paddle/src/internal/pass/transform_fakequantize.cpp
@ -54,7 +54,7 @@ ov::frontend::paddle::pass::TransformFakeQuantize::TransformFakeQuantize() {
    const auto dq_real_scale_label = pattern::wrap_type<Multiply>();
    const auto output_label = pattern::wrap_type<Multiply>({dq_sub_label, dq_real_scale_label});

-    matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool {
+    matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) -> bool {
        const auto& opsMap = m.get_pattern_value_map();
        if (transformation_callback(m.get_match_root())) {
            return false;
--- a/src/frontends/pytorch/src/transforms/remove_packing_ops.cpp
+++ b/src/frontends/pytorch/src/transforms/remove_packing_ops.cpp
@ -15,6 +15,7 @@
 #include "openvino/op/transpose.hpp"
 #include "openvino/pass/pattern/matcher.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "transformations/utils/utils.hpp"
 #include "utils.hpp"

 namespace ov {
@ -38,7 +39,7 @@ bool is_rnn(std::shared_ptr<Node> node) {
 MovePackThroughLstm::MovePackThroughLstm() {
    auto pack_op = pattern::wrap_type<PackPadded>();

-    ov::matcher_pass_callback callback = [=](pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
        auto pack = m.get_match_root();

        auto targets = pack->output(0).get_target_inputs();
--- a/src/plugins/intel_cpu/src/dnnl_extension_utils.h
+++ b/src/plugins/intel_cpu/src/dnnl_extension_utils.h
@ -14,7 +14,7 @@
 #include "onednn/dnnl.h"
 #include "onednn/iml_type_mapper.h"
 #include "openvino/core/type/element_type.hpp"
-#include <common/c_types_map.hpp>
+#include "common/c_types_map.hpp"

 namespace ov {
 namespace intel_cpu {
--- a/src/plugins/intel_cpu/src/edge.cpp
+++ b/src/plugins/intel_cpu/src/edge.cpp
@ -5,6 +5,7 @@
 #include "edge.h"
 #include "node.h"
 #include "dnnl_extension_utils.h"
+#include "openvino/util/pp.hpp"

 using namespace dnnl;
 namespace ov {
@ -264,7 +265,7 @@ void Edge::allocateCommon(const std::function<MemoryPtr(const MemoryDesc&)>& all
 }

 void Edge::allocate(const void* mem_ptr) {
-    auto allocateFunc = [=](const MemoryDesc& inputDesc) -> MemoryPtr {
+    auto allocateFunc = [OV_CAPTURE_CPY_AND_THIS](const MemoryDesc& inputDesc) -> MemoryPtr {
        auto parentPtr = getParent();
        return std::make_shared<Memory>(parentPtr->getEngine(), inputDesc, mem_ptr, false);  // no pads zeroing
    };
@ -277,7 +278,7 @@ void Edge::allocate(MemoryMngrPtr memMngr) {
        OPENVINO_THROW("Unexpected: Memory manager ptr is NULL");
    }

-    auto allocateFunc = [=](const MemoryDesc& inputDesc) -> MemoryPtr {
+    auto allocateFunc = [OV_CAPTURE_CPY_AND_THIS](const MemoryDesc& inputDesc) -> MemoryPtr {
        auto parentPtr = getParent();
        return std::make_shared<Memory>(parentPtr->getEngine(), inputDesc, memMngr);
    };
--- a/src/plugins/intel_cpu/src/node.cpp
+++ b/src/plugins/intel_cpu/src/node.cpp
@ -1707,7 +1707,7 @@ void Node::fuseDQScales(const float* scaleData, const size_t scaleSize) {
             DQScales[i] *= scaleData[i];
         }
     }
-     if (std::all_of(DQScales.begin(), DQScales.end(), [=](float val){ return (val == DQScales[0]);}))
+     if (std::all_of(DQScales.begin(), DQScales.end(), [OV_CAPTURE_CPY_AND_THIS](float val){ return (val == DQScales[0]);}))
        DQScales.resize(1);
 }

--- a/src/plugins/intel_cpu/src/nodes/causal_mask_preprocess.h
+++ b/src/plugins/intel_cpu/src/nodes/causal_mask_preprocess.h
@ -34,6 +34,7 @@ private:
        virtual void execute(dnnl::stream strm,
                             intel_cpu::Node * pnode,
                             const intel_cpu::CausalMaskPreprocessNode::Config& config) = 0;
+        virtual ~Executor() = default;
    };
    template <typename T>
    struct ExecutorCausalMaskPreprocess;
--- a/src/plugins/intel_cpu/src/nodes/def_conv.cpp
+++ b/src/plugins/intel_cpu/src/nodes/def_conv.cpp
@ -13,6 +13,7 @@
 #include "openvino/core/parallel.hpp"
 #include "memory_desc/dnnl_blocked_memory_desc.h"
 #include "common/primitive_hashing_utils.hpp"
+#include "openvino/util/pp.hpp"

 #include "dnnl_types.h"
 #include "dnnl_extension_utils.h"
@ -1129,7 +1130,7 @@ void DeformableConvolution::DefConvRefExecutor::exec(const float* src, const flo

    const int channel_per_deformable_group = (IC * G) / DG;
    const size_t group_wei_stride = weiStrides[0] * OC;
-    auto compKer = [=](int g, int mb, int oc, int oh, int ow) {
+    auto compKer = [OV_CAPTURE_CPY_AND_THIS](int g, int mb, int oc, int oh, int ow) {
        float d = 0;
        for (int ic = 0; ic < IC; ic++) {
            const float *data_im_ptr = src + mb * srcStrides[0] + (g * IC + ic) * srcStrides[1];
--- a/src/plugins/intel_cpu/src/nodes/depth_to_space.cpp
+++ b/src/plugins/intel_cpu/src/nodes/depth_to_space.cpp
@ -137,7 +137,7 @@ void DepthToSpace::initSupportedPrimitiveDescriptors() {
    std::vector<LayoutType> supportedTypes;
    if (inputDataShape.getRank() > 2) {
        const auto& srcDims = inputDataShape.getDims();
-        auto canUseBlocked = [=](const size_t block) {
+        auto canUseBlocked = [OV_CAPTURE_CPY_AND_THIS](const size_t block) {
            return srcDims[1] != Shape::UNDEFINED_DIM && srcDims[1] % block == 0 && (srcDims[1] / block) % attrs.blockStep == 0 &&
                   (attrs.mode == Mode::DEPTH_FIRST ? block % attrs.blockStep == 0 : true);
        };
--- a/src/plugins/intel_cpu/src/nodes/rdft.h
+++ b/src/plugins/intel_cpu/src/nodes/rdft.h
@ -14,6 +14,7 @@ namespace node {
 struct RDFTExecutor {
    public:
        RDFTExecutor(bool inverse) : isInverse(inverse) {}
+        virtual ~RDFTExecutor() = default;
        void execute(float* inputPtr, float* outputPtr,
                     const std::vector<std::vector<float>>& twiddles,
                     size_t rank, const std::vector<int>& axes,
--- a/src/plugins/intel_cpu/src/nodes/rope.h
+++ b/src/plugins/intel_cpu/src/nodes/rope.h
@ -35,6 +35,7 @@ private:
                             const RoPENode::Config& config,
                             const std::vector<MemoryPtr>& inputs,
                             const std::vector<MemoryPtr>& outputs) = 0;
+        virtual ~Executor() = default;
    };
    template <typename T>
    struct RoPEExecutorRotateHalf;
--- a/src/plugins/intel_cpu/src/nodes/scaled_attn.h
+++ b/src/plugins/intel_cpu/src/nodes/scaled_attn.h
@ -67,6 +67,7 @@ private:
        virtual void execute(dnnl::stream strm, const Config& config, const std::vector<MemoryPtr>& inputs, const MemoryPtr output,
                             const MemoryPtr presentk_input, const MemoryPtr presentv_input, const MemoryPtr beam_input,
                             const PlainTensor& k_scale_zp, const PlainTensor& v_scale_zp) = 0;
+        virtual ~Executor() = default;
    };

    bool m_is_pageattn;
--- a/src/plugins/intel_cpu/src/nodes/space_to_depth.cpp
+++ b/src/plugins/intel_cpu/src/nodes/space_to_depth.cpp
@ -12,6 +12,7 @@
 #include "cpu/x64/jit_generator.hpp"
 #include "openvino/opsets/opset1.hpp"
 #include <string>
+#include "openvino/util/pp.hpp"

 #include "common/blocked_desc_creator.h"

@ -140,7 +141,7 @@ void SpaceToDepth::initSupportedPrimitiveDescriptors() {
    std::vector<LayoutType> supportedTypes;
    if (inputDataShape.getRank() > 2) {
        const auto& srcDims = inputDataShape.getDims();
-        auto canUseBlocked = [=](const size_t block) {
+        auto canUseBlocked = [OV_CAPTURE_CPY_AND_THIS](const size_t block) {
            return srcDims[1] != Shape::UNDEFINED_DIM && srcDims[1] % block == 0 &&
                   (attrs.mode == Mode::DEPTH_FIRST ? block % attrs.blockStep == 0 : true);
        };
--- a/src/plugins/intel_cpu/src/nodes/split.cpp
+++ b/src/plugins/intel_cpu/src/nodes/split.cpp
@ -168,7 +168,8 @@ void Split::initSupportedPrimitiveDescriptors() {
    const auto& parentdDims = inputShapes[0].getDims();
    if (parentdDims[axis] != Shape::UNDEFINED_DIM &&
        std::all_of(parentdDims.begin(), parentdDims.begin() + axis, [](size_t dim) { return  dim == 1; }) &&
-        std::all_of(outputShapes.begin(), outputShapes.end(), [=](const Shape& shape){ return shape.getDims()[axis] != Shape::UNDEFINED_DIM; })) {
+        std::all_of(outputShapes.begin(), outputShapes.end(),
+            [OV_CAPTURE_CPY_AND_THIS](const Shape& shape){ return shape.getDims()[axis] != Shape::UNDEFINED_DIM; })) {
        for (auto refPdIndex : pdIndexesToReuse) {
            auto config = supportedPrimitiveDescriptors[refPdIndex].getConfig();

--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/causal_mask_preprocess_fusion.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/causal_mask_preprocess_fusion.cpp
@ -199,7 +199,7 @@ CausalMaskPreprocess::CausalMaskPreprocess() {
                                                        nullptr);  //  tensor_array<f32[?,1,?,..8192]>
    auto result = index_Gather;

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();
        auto root = m.get_match_root();
        PatternValidator validator(m);
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.cpp
@ -11,7 +11,8 @@
 #include "openvino/core/except.hpp"
 #include "openvino/core/node_output.hpp"
 #include "openvino/core/type/element_type.hpp"
-#include <ov_ops/type_relaxed.hpp>
+#include "ov_ops/type_relaxed.hpp"
+#include "transformations/utils/utils.hpp"

 #include "itt.hpp"
 #include "openvino/core/type/element_type.hpp"
@ -78,7 +79,7 @@ ov::intel_cpu::ConvertFqRnnToQuantizedRnn::ConvertFqRnnToQuantizedRnn() {
            gru_seq_m
        });

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        auto rnn = m.get_match_root();

        if (!rnn || transformation_callback(rnn))
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.cpp
@ -10,7 +10,7 @@
 #include "openvino/op/reshape.hpp"
 #include "openvino/core/rt_info.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
-#include <transformations/utils/utils.hpp>
+#include "transformations/utils/utils.hpp"

 #include "itt.hpp"

@ -23,7 +23,7 @@ ov::intel_cpu::ConvertMatMulToFC::ConvertMatMulToFC() {
    auto weights_m = ov::pass::pattern::any_input(weights_path);
    auto matmul_m = ov::pass::pattern::wrap_type<ov::op::v0::MatMul>({ activations_m, weights_m }, ov::pass::pattern::has_static_rank());

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();

        auto matmul = std::dynamic_pointer_cast<ov::op::v0::MatMul>(pattern_map.at(matmul_m).get_node_shared_ptr());
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/move_eltwise_up_data_movement.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/move_eltwise_up_data_movement.cpp
@ -11,6 +11,7 @@
 #include <openvino/opsets/opset8.hpp>
 #include "openvino/core/rt_info.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "transformations/utils/utils.hpp"

 #include "itt.hpp"

@ -45,7 +46,7 @@ ov::intel_cpu::MoveEltwiseUpThroughDataMov::MoveEltwiseUpThroughDataMov() {
                                                      ov::op::util::BinaryElementwiseArithmetic,
                                                      ov::op::v0::FakeQuantize>(ov::pass::pattern::has_static_rank());

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();

        auto eltwise = pattern_map.at(eltwise_pattern).get_node_shared_ptr();
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/rope_fusion.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/rope_fusion.cpp
@ -57,7 +57,7 @@ ov::intel_cpu::RoPEFusionGPTNEOX::RoPEFusionGPTNEOX() {
    // [x1, x2]*cos + [-x2, x1]*sin
    auto result = makePattern<opset1::Add>({mul_cos, mul_sin}, {{"auto_broadcast", "numpy"}});

-    matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        PatternValidator validator(m);
        if (!validator) {
            return false;
@ -163,7 +163,7 @@ ov::intel_cpu::RoPEFusionCosSinPreprocess::RoPEFusionCosSinPreprocess() {
    auto x = makePattern(ov::Rank(4));
    auto rope = makePattern<RoPENode>({x, cos_tab, sin_tab});

-    matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        PatternValidator validator(m);
        if (!validator) {
            return false;
@ -211,7 +211,7 @@ ov::intel_cpu::RoPEFusionIOSlicing::RoPEFusionIOSlicing() {
    auto x_emb = makePattern<RoPENode>({x, {}, {}}) | makePattern<RoPENode>({x, {}, {}, {}});
    auto result = makePattern<opset1::Concat>({x_emb, y}, {{"axis", -1}});

-    matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();
        auto root = m.get_match_root();

@ -262,7 +262,7 @@ ov::intel_cpu::RoPEFusionPreprocess::RoPEFusionPreprocess() {
    auto x = makePattern<opset1::Transpose>({input_slice | input_to_trans, {0, 2, 1, 3}});
    auto result = makePattern<RoPENode>({x, {}, {}}) | makePattern<RoPENode>({x, {}, {}, {}});

-    matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        PatternValidator validator(m);
        if (!validator) {
            return false;
@ -794,7 +794,7 @@ ov::intel_cpu::RoPEShareCosSin::RoPEShareCosSin() {
    auto sin_Sin = makePattern<opset1::Sin>({cat_Concat});
    auto result = makePattern<opset1::Unsqueeze>({cos_Cos | sin_Sin, 1});

-    matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();
        auto root = m.get_match_root();
        PatternValidator validator(m);
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mha_fusion.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mha_fusion.cpp
@ -10,6 +10,7 @@
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "openvino/pass/pattern/op/or.hpp"
 #include "transformations/cpu_opset/x64/op/mha.hpp"
+#include "transformations/utils/utils.hpp"
 #include "simplify_fakequantize.hpp"

 #include "itt.hpp"
@ -41,7 +42,7 @@ ov::intel_cpu::MHAFloatFusion::MHAFloatFusion() {
    auto matmul1 = std::make_shared<ov::opset3::MatMul>(reshape1, transpose2);
    auto transpose3 = std::make_shared<ov::opset3::Transpose>(matmul1, in10);

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        auto& pattern_to_output = m.get_pattern_value_map();
        auto transpose0_in = pattern_to_output.at(in0);
        auto transpose1_in = pattern_to_output.at(in1);
@ -180,7 +181,7 @@ ov::intel_cpu::MHAFloatFusion2::MHAFloatFusion2() {
    auto matmul1 = std::make_shared<ov::opset3::MatMul>(softmax, transpose2);
    auto transpose3 = std::make_shared<ov::opset3::Transpose>(matmul1, in10);

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        auto& pattern_to_output = m.get_pattern_value_map();
        auto transpose0_in = pattern_to_output.at(in0);
        auto transpose1_in = pattern_to_output.at(in1);
@ -293,7 +294,7 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
    auto transpose3 = std::make_shared<ov::opset3::Transpose>(fakeQuantize2, in10);

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        auto& pattern_to_output = m.get_pattern_value_map();
        auto transpose0_in = pattern_to_output.at(in0);
        auto transpose1_in = pattern_to_output.at(in1);
@ -473,7 +474,7 @@ ov::intel_cpu::MHAQuantFusion2::MHAQuantFusion2() {
    auto in11 = std::make_shared<ov::pass::pattern::op::Or>(OutputVector{ matmul1, fakeQuantize1 });
    auto transpose3 = std::make_shared<ov::opset3::Transpose>(in11, in10);

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        auto& pattern_to_output = m.get_pattern_value_map();
        auto transpose0_in = pattern_to_output.at(in0);
        auto transpose1_in = pattern_to_output.at(in1);
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/mul_add_to_fma.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/mul_add_to_fma.cpp
@ -7,6 +7,7 @@
 #include "mul_add_to_fma.hpp"
 #include "snippets/snippets_isa.hpp"
 #include "transformations/snippets/x64/op/fused_mul_add.hpp"
+#include "transformations/utils/utils.hpp"

 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "openvino/pass/pattern/matcher.hpp"
@ -28,7 +29,7 @@ ov::intel_cpu::pass::MulAddToFMA::MulAddToFMA() {
    auto add_input_2 = ov::pass::pattern::any_input();
    auto add_m = ov::pass::pattern::wrap_type<opset1::Add>({ mul_m, add_input_2 }, is_not_memory_access);

-    matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::op::MulAddToFMA_callback")
        const auto& pattern_map = m.get_pattern_value_map();
        const auto multiply = pattern_map.at(mul_m).get_node_shared_ptr();
--- a/src/plugins/intel_cpu/thirdparty/CMakeLists.txt
+++ b/src/plugins/intel_cpu/thirdparty/CMakeLists.txt
@ -16,6 +16,7 @@ if(ENABLE_LTO)
 endif()

 function(ov_add_onednn)
+    set(CMAKE_COMPILE_WARNING_AS_ERROR OFF)
    set(CMAKE_DISABLE_FIND_PACKAGE_PythonInterp ON)
    set(DNNL_ENABLE_JIT_PROFILING ${BUILD_SHARED_LIBS} CACHE BOOL "" FORCE)
    if(BUILD_SHARED_LIBS AND ENABLE_PROFILING_ITT)
@ -59,7 +60,7 @@ function(ov_add_onednn)
    endif()

    if(AARCH64 OR ARM)
-        set(DNNL_USE_ACL ON CACHE BOOL "Use ARM Conpute Library kernels in oneDNN" FORCE)
+        set(DNNL_USE_ACL ON CACHE BOOL "Use ARM Compute Library kernels in oneDNN" FORCE)
    endif()

    set(SDL_cmake_included ON)  ## to skip internal SDL flags. SDL flags are already set on OV level
@ -78,7 +79,7 @@ function(ov_add_onednn)
        link_libraries(TBB::tbb)
    endif()

-    if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
+    if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
        ov_add_compiler_flags(-Wno-undef)
        ov_add_compiler_flags(-Wno-missing-declarations)
        if(ARM OR AARCH64)
@ -92,6 +93,10 @@ function(ov_add_onednn)
                ov_add_compiler_flags(-Wno-restrict)
            endif()
        endif()
+        if(OV_COMPILER_IS_INTEL_LLVM)
+            ov_add_compiler_flags(-Wno-deprecated-this-capture)
+            ov_add_compiler_flags(-Wno-deprecated-enum-enum-conversion)
+        endif()
    elseif(UNIX AND CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -diag-disable=10121")
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
--- a/src/plugins/intel_gpu/include/intel_gpu/graph/kernel_impl_params.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/graph/kernel_impl_params.hpp
@ -89,6 +89,8 @@ struct kernel_impl_params final {
                       , primary_input_idx(0) {
    }

+    virtual ~kernel_impl_params() = default;
+
    const layout& get_input_layout(size_t idx = 0) const {
        OPENVINO_ASSERT(input_layouts.size() > idx,
                        "The size of input layouts must be greater than the requested index: ",
--- a/src/plugins/intel_gpu/include/intel_gpu/runtime/event.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/runtime/event.hpp
@ -22,6 +22,7 @@ struct event {
 public:
    using ptr = std::shared_ptr<event>;
    event() = default;
+    virtual ~event() = default;

    void wait();
    void set();
--- a/src/plugins/intel_gpu/src/kernel_selector/kernel_selector_params.h
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernel_selector_params.h
@ -441,6 +441,7 @@ struct base_activation_params {
                                                                                       m(m),
                                                                                       n(n) {}

+    virtual ~base_activation_params() = default;
    virtual std::string to_string() const;
 };

--- a/src/plugins/intel_gpu/src/plugin/transformations/bcast_and_pad_zp_buffers.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations/bcast_and_pad_zp_buffers.cpp
@ -12,6 +12,7 @@
 #include "openvino/pass/graph_rewrite.hpp"
 #include "openvino/pass/pattern/op/pattern.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "transformations/utils/utils.hpp"

 #include <memory>

@ -79,7 +80,7 @@ BroadcastAndPadZeroPointBuffers::BroadcastAndPadZeroPointBuffers(size_t pad_size

    auto convolution_m = wrap_type<op::Convolution>({ input_m, weights_m, bias_m, azp_m, wzp_m, cmp_m });

-    ov::matcher_pass_callback callback = [=](Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();
        if (transformation_callback(m.get_match_root())) {
            return false;
--- a/src/plugins/intel_gpu/src/plugin/transformations/clamp_fp16_output.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations/clamp_fp16_output.cpp
@ -17,6 +17,7 @@
 #include "openvino/pass/pattern/op/pattern.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "openvino/pass/pattern/op/or.hpp"
+#include "transformations/utils/utils.hpp"

 #include <memory>

@ -38,7 +39,7 @@ ClampFP16Output::ClampFP16Output() {
    auto softmax_input_m = std::make_shared<Or>(ov::OutputVector{eltwise_m, reshape_m, matmul_m});
    auto softmax_m = wrap_type<v8::Softmax>({softmax_input_m}, type_matches(ov::element::f16));

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();
        auto softmax = std::dynamic_pointer_cast<v8::Softmax>(pattern_map.at(softmax_m).get_node_shared_ptr());
        if (!softmax || transformation_callback(softmax)) {
--- a/src/plugins/intel_gpu/src/plugin/transformations/convert_convolution.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations/convert_convolution.cpp
@ -15,6 +15,7 @@
 #include "openvino/pass/pattern/op/or.hpp"
 #include "openvino/pass/pattern/op/pattern.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "transformations/utils/utils.hpp"

 #include <memory>

@ -125,7 +126,7 @@ AsymmetricConvolutionMatcher::AsymmetricConvolutionMatcher() {

    auto convolution_m = wrap_type<ov::op::v1::Convolution, ov::op::v1::GroupConvolution>({ conv_activations_m, conv_weights_m });

-    ov::matcher_pass_callback callback = [=](Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();
        if (transformation_callback(m.get_match_root())) {
            return false;
@ -189,7 +190,7 @@ ConvolutionMatcher::ConvolutionMatcher() {
    auto bias_val_m = wrap_type<ov::op::v0::Constant>();
    auto convolution_m = wrap_type<ov::op::v1::Convolution, ov::op::v1::GroupConvolution>({ input_m, weights_m });

-    ov::matcher_pass_callback callback = [=](Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();
        if (transformation_callback(m.get_match_root())) {
            return false;
--- a/src/plugins/intel_gpu/src/plugin/transformations/convert_fc_to_compressed.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations/convert_fc_to_compressed.cpp
@ -67,7 +67,7 @@ ConvertFullyConnectedToFullyConnectedCompressed::ConvertFullyConnectedToFullyCon
    auto weights_input_m = std::make_shared<ov::pass::pattern::op::Or>(ov::OutputVector{reshape_m, transpose_m, mul_m});
    auto fully_connected_m = wrap_type<op::FullyConnected>({data_m, weights_input_m, bias_m});

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();
        OPENVINO_ASSERT(pattern_map.count(fully_connected_m));
        OPENVINO_ASSERT(pattern_map.count(mul_const_m));
--- a/src/plugins/intel_gpu/src/plugin/transformations/convert_matmul_to_fc.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations/convert_matmul_to_fc.cpp
@ -33,7 +33,7 @@ ConvertMatMulToFullyConnected::ConvertMatMulToFullyConnected() {
    auto weights_m = ov::pass::pattern::any_input(weights_path);
    auto matmul_m = ov::pass::pattern::wrap_type<ov::op::v0::MatMul>({ activations_m, weights_m }, ov::pass::pattern::has_static_rank());

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();

        auto matmul = std::dynamic_pointer_cast<ov::op::v0::MatMul>(pattern_map.at(matmul_m).get_node_shared_ptr());
--- a/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_for_false_keepdims.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_for_false_keepdims.cpp
@ -11,6 +11,7 @@
 #include "openvino/op/reduce_max.hpp"
 #include "openvino/op/constant.hpp"
 #include "openvino/op/reshape.hpp"
+#include "transformations/utils/utils.hpp"

 #include "decompose_reduce_for_false_keepdims.hpp"

@ -34,7 +35,7 @@ DecomposeReduceForFalseKeepDims::DecomposeReduceForFalseKeepDims() {
        ov::pass::pattern::has_static_shape());

    // register callback
-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();
        auto reduce =
            as_type_ptr<op::util::ArithmeticReductionKeepDims>(pattern_map.at(reduce_pattern).get_node_shared_ptr());
--- a/src/plugins/intel_gpu/src/plugin/transformations/indirect_kv_cache.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations/indirect_kv_cache.cpp
@ -57,7 +57,7 @@ IndirectKVCache::IndirectKVCache() {
    auto matmul_1 = wrap_type<ov::intel_gpu::op::Gemm>({any_input(), kv_cache});
    auto matmul = std::make_shared<ov::pass::pattern::op::Or>(OutputVector{matmul_0, matmul_1});

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        if (transformation_callback(m.get_match_root())) {
            return false;
        }
--- a/src/plugins/intel_gpu/src/plugin/transformations/kv_cache_fusion.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations/kv_cache_fusion.cpp
@ -48,7 +48,7 @@ KVCacheFusionMatcher::KVCacheFusionMatcher() {
    auto present_input = std::make_shared<ov::pass::pattern::op::Or>(OutputVector{concat, convert_present});
    auto present = wrap_type<ov::op::v6::Assign>({present_input});

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        if (transformation_callback(m.get_match_root())) {
            return false;
        }
--- a/src/plugins/intel_gpu/src/plugin/transformations/swiglu_fusion.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations/swiglu_fusion.cpp
@ -41,7 +41,7 @@ SwiGLUFusion::SwiGLUFusion() {
    // Mul(Xw, Xv) = Swish(Xw) * Xv
    auto mul_m = wrap_type<ov::op::v1::Multiply>({swish_m, variadic_split_m->output(1)});

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();
        OPENVINO_ASSERT(pattern_map.count(mul_m));
        OPENVINO_ASSERT(pattern_map.count(swish_m));
--- a/src/plugins/intel_gpu/src/plugin/transformations/transpose_matmul_fusion.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations/transpose_matmul_fusion.cpp
@ -75,7 +75,7 @@ TransposeMatMulMatcher::TransposeMatMulMatcher() {

    auto matmul_m = wrap_type<ov::op::v0::MatMul>({ matmul_in_a, matmul_in_b }, is_dynamic);

-    ov::matcher_pass_callback callback = [=](Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();

        auto matmul = std::dynamic_pointer_cast<ov::op::v0::MatMul>(pattern_map.at(matmul_m).get_node_shared_ptr());
@ -161,7 +161,7 @@ TransposeMatMulTransposeMatcher::TransposeMatMulTransposeMatcher() {
    auto transpose_c_order_m = wrap_type<ov::op::v0::Constant>(consumers_count(1));
    auto transpose_c_m = wrap_type<ov::op::v1::Transpose>({matmul_m, transpose_c_order_m});

-    ov::matcher_pass_callback callback = [=](Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) {
        const auto& pattern_map = m.get_pattern_value_map();

        auto matmul = std::dynamic_pointer_cast<ov::op::v0::MatMul>(pattern_map.at(matmul_m).get_node_shared_ptr());
--- a/src/plugins/intel_gpu/src/plugin/transformations/unsqueeze_broadcast_reshape_matmul_fusion.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations/unsqueeze_broadcast_reshape_matmul_fusion.cpp
@ -49,7 +49,7 @@ UnsqueezeBroadcastReshapeMatmulFusion::UnsqueezeBroadcastReshapeMatmulFusion() {
    auto reshape_m = wrap_type<ov::op::v1::Reshape>({broadcast_m, any_input()}, reshape_predicate);
    auto matmul_m = wrap_type<op::Gemm>({input_a_m, reshape_m});

-    ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
+    ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
        if (transformation_callback(m.get_match_root())) {
            return false;
        }
--- a/src/plugins/intel_gpu/tests/functional/subgraph_tests/condition.cpp
+++ b/src/plugins/intel_gpu/tests/functional/subgraph_tests/condition.cpp
@ -63,7 +63,8 @@ enum InnerBodyType {
 };

 public:
-    InnerBodyGenerator() { }
+    InnerBodyGenerator()  = default;
+    virtual ~InnerBodyGenerator() = default;

    virtual std::shared_ptr<ov::Model> get_function() { return _func; }
    virtual std::shared_ptr<ov::op::v0::Parameter> get_input() { return _param; }
--- a/src/plugins/intel_gpu/thirdparty/CMakeLists.txt
+++ b/src/plugins/intel_gpu/thirdparty/CMakeLists.txt
@ -30,7 +30,7 @@ if(ENABLE_ONEDNN_FOR_GPU)
            message(WARNING "Intel GPU plugin unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}")
        endif()

-        if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
+        if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
            ov_add_compiler_flags(-Wno-undef)
            ov_add_compiler_flags(-Wno-missing-declarations)
            if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 11 AND CMAKE_COMPILER_IS_GNUCXX)
@ -47,7 +47,9 @@ if(ENABLE_ONEDNN_FOR_GPU)

        foreach(cmake_var IN ITEMS CMAKE_SYSTEM_NAME CMAKE_SYSTEM_VERSION
                                   CMAKE_SYSTEM_PROCESSOR CMAKE_TOOLCHAIN_FILE)
+            if(${cmake_var})
                list(APPEND cmake_extra_args "-D${cmake_var}=${${cmake_var}}")
+            endif()
        endforeach()

        if(OV_GENERATOR_MULTI_CONFIG)
--- a/thirdparty/cnpy/cnpy.cpp
+++ b/thirdparty/cnpy/cnpy.cpp
@ -66,8 +66,6 @@ template<> std::vector<char>& cnpy::operator+=(std::vector<char>& lhs, const cha

 void cnpy::parse_npy_header(unsigned char* buffer,size_t& word_size, std::vector<size_t>& shape, bool& fortran_order) {
    //std::string magic_string(buffer,6);
-    uint8_t major_version = *reinterpret_cast<uint8_t*>(buffer+6);
-    uint8_t minor_version = *reinterpret_cast<uint8_t*>(buffer+7);
    uint16_t header_len = *reinterpret_cast<uint16_t*>(buffer+8);
    std::string header(reinterpret_cast<char*>(buffer+9),header_len);

@ -236,6 +234,7 @@ cnpy::NpyArray load_the_npz_array(FILE* fp, uint32_t compr_bytes, uint32_t uncom

    err = inflate(&d_stream, Z_FINISH);
    err = inflateEnd(&d_stream);
+    (void)err;

    std::vector<size_t> shape(0);
    size_t word_size = 0;
--- a/thirdparty/dependencies.cmake
+++ b/thirdparty/dependencies.cmake
@ -359,7 +359,7 @@ if(ENABLE_OV_PADDLE_FRONTEND OR ENABLE_OV_ONNX_FRONTEND OR ENABLE_OV_TF_FRONTEND
        if(ENABLE_SYSTEM_PROTOBUF)
            set(link_type INTERFACE)
        endif()
-        if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
+        if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
            get_target_property(original_name ${target_name} ALIASED_TARGET)
            if(TARGET ${original_name})
                # during build protobuf's cmake creates aliased targets
@ -453,7 +453,7 @@ if(ENABLE_SNAPPY_COMPRESSION)
                ov_add_compiler_flags(/wd4245)
                # 'var' : conversion from 'size_t' to 'type', possible loss of data
                ov_add_compiler_flags(/wd4267)
-            elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
+            elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
                # we need to pass -Wextra first, then -Wno-sign-compare
                # otherwise, snappy's CMakeLists.txt will do it for us
                ov_add_compiler_flags(-Wextra)
--- a/thirdparty/protobuf/CMakeLists.txt
+++ b/thirdparty/protobuf/CMakeLists.txt
@ -8,7 +8,7 @@

 set(BUILD_SHARED_LIBS OFF)

-if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
+if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
    ov_add_compiler_flags(-Wno-all)
    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 11 AND CMAKE_COMPILER_IS_GNUCXX)
        ov_add_compiler_flags(-Wno-stringop-overflow)