Update Protobuf to 6.30.0

.github/workflows/linux_riscv_conan.yml

@@ -157,6 +157,9 @@ jobs:
             git submodule update --init -- ${OPENVINO_REPO}/thirdparty/telemetry
             git submodule update --init -- ${OPENVINO_REPO}/src/plugins/intel_cpu
             git submodule update --init -- ${OPENVINO_REPO}/thirdparty/flatbuffers/flatbuffers
+            # ONNX is no longer consumed from Conan (Conan Center Index lacks onnx 1.22),
+            # so the bundled submodule is built instead and must be checked out here.
+            git submodule update --init -- ${OPENVINO_REPO}/thirdparty/onnx/onnx
           popd
 
       #
@@ -185,6 +188,14 @@ jobs:
           echo "[buildenv]" >> ${CONAN_LINUX_RISCV64_PROFILE}
           echo "CC=riscv64-linux-gnu-gcc" >> ${CONAN_LINUX_RISCV64_PROFILE}
           echo "CXX=riscv64-linux-gnu-g++" >> ${CONAN_LINUX_RISCV64_PROFILE}
+          echo "LDFLAGS=-latomic" >> ${CONAN_LINUX_RISCV64_PROFILE}
+          echo "[conf]" >> ${CONAN_LINUX_RISCV64_PROFILE}
+          echo "tools.build:exelinkflags=[\"-latomic\"]" >> ${CONAN_LINUX_RISCV64_PROFILE}
+          echo "tools.build:sharedlinkflags=[\"-latomic\"]" >> ${CONAN_LINUX_RISCV64_PROFILE}
+          # Append -latomic to CMAKE_CXX/C_STANDARD_LIBRARIES so it appears at the
+          # END of the linker command line, after abseil static archives that
+          # reference __atomic_* symbols (GCC processes libraries left-to-right).
+          echo 'tools.cmake.cmaketoolchain:extra_variables={"CMAKE_CXX_STANDARD_LIBRARIES": "-latomic", "CMAKE_C_STANDARD_LIBRARIES": "-latomic"}' >> ${CONAN_LINUX_RISCV64_PROFILE}
           # install OpenVINO dependencies
           conan install ${OPENVINO_REPO}/conanfile.txt \
             -pr:h ${CONAN_LINUX_RISCV64_PROFILE} \

CMakeLists.txt

@@ -27,6 +27,14 @@ if(POLICY CMP0177)
     cmake_policy(SET CMP0177 NEW)
 endif()
 
+if(POLICY CMP0194)
+    # NOTE: Keeping the policy "OLD" in order to retain custom assembler search (icpx/icx/icx.exe)
+    # Making it "NEW" would result in (incorrect) usage of cl64.exe in certain contexts on Windows
+    set(CMAKE_POLICY_DEFAULT_CMP0194 OLD)
+    # NOTE: Some CMake versions have a typo in the policy number, so we set both to be safe
+    set(CMAKE_POLICY_DEFAULT_CMP194 OLD)
+endif()
+
 # set CMAKE_POLICY_VERSION_MINIMUM to avoid errors from 3rd party dependencies
 # after cmake is updated to 4.0
 set(CMAKE_POLICY_VERSION_MINIMUM 3.5)

cmake/developer_package/OpenVINODeveloperScriptsConfig.cmake

@@ -272,6 +272,7 @@ include(faster_build)
 include(whole_archive)
 include(linux_name)
 include(models)
+include(patches)
 include(api_validator/api_validator)
 
 include(vs_version/vs_version)

cmake/developer_package/frontends/frontends.cmake

@@ -223,7 +223,10 @@ macro(ov_add_frontend)
                 $<BUILD_INTERFACE:${${TARGET_NAME}_INCLUDE_DIR}>
             PRIVATE
                 $<TARGET_PROPERTY:openvino::frontend::common,INTERFACE_INCLUDE_DIRECTORIES>
-                ${frontend_root_dir}/src
+                ${frontend_root_dir}/src)
+
+    # Add binary dir as SYSTEM so generated protobuf headers don't trigger warnings
+    target_include_directories(${TARGET_NAME} SYSTEM PRIVATE
                 ${CMAKE_CURRENT_BINARY_DIR})
 
     ov_add_vs_version_file(NAME ${TARGET_NAME}
@@ -247,17 +250,84 @@ macro(ov_add_frontend)
         if(OV_FRONTEND_PROTOBUF_LITE)
             set(protobuf_target_name libprotobuf-lite)
             set(protobuf_install_name "protobuf_lite_installed")
+            set(protobuf_dependencies 
+                absl::absl_check
+                absl::absl_log
+                absl::base
+                absl::bits
+                absl::core_headers
+                absl::debugging
+                absl::die_if_null
+                absl::dynamic_annotations
+                absl::endian
+                absl::fixed_array
+                absl::inlined_vector
+                absl::log_severity
+                absl::memory
+                absl::raw_logging_internal
+                absl::span
+                absl::strings
+                absl::synchronization
+                absl::type_traits
+                absl::utility
+            )
         else()
             set(protobuf_target_name libprotobuf)
             set(protobuf_install_name "protobuf_installed")
+            set(protobuf_dependencies 
+                absl::absl_check
+                absl::absl_log
+                absl::algorithm
+                absl::base
+                absl::bind_front
+                absl::bits
+                absl::btree
+                absl::cleanup
+                absl::cord
+                absl::core_headers
+                absl::debugging
+                absl::die_if_null
+                absl::dynamic_annotations
+                absl::flags
+                absl::flat_hash_map
+                absl::flat_hash_set
+                absl::function_ref
+                absl::hash
+                absl::layout
+                absl::log_initialize
+                absl::log_globals
+                absl::log_severity
+                absl::memory
+                absl::node_hash_map
+                absl::node_hash_set
+                absl::optional
+                absl::span
+                absl::status
+                absl::statusor
+                absl::strings
+                absl::synchronization
+                absl::time
+                absl::type_traits
+                absl::utility
+                absl::variant
+            )
         endif()
+
         if(ENABLE_SYSTEM_PROTOBUF)
             # use imported target name with namespace
             set(protobuf_target_name "protobuf::${protobuf_target_name}")
         endif()
 
         ov_link_system_libraries(${TARGET_NAME} PRIVATE ${protobuf_target_name})
 
+        # GCC emits -Warray-bounds / -Wstringop-overflow even from SYSTEM includes
+        # when instantiating header-only abseil code inside frontend translation units.
+        # With -Werror these become hard errors; downgrade to warnings here.
+        if(CMAKE_COMPILER_IS_GNUCXX)
+            target_compile_options(${TARGET_NAME} PRIVATE
+                -Wno-error=array-bounds -Wno-error=stringop-overflow)
+        endif()
+
         # protobuf generated code emits -Wsuggest-override error
         if(SUGGEST_OVERRIDE_SUPPORTED)
             target_compile_options(${TARGET_NAME} PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-Wno-suggest-override>)
@@ -269,7 +339,14 @@ macro(ov_add_frontend)
                 # we have to add find_package(Protobuf) to the OpenVINOConfig.cmake for static build
                 # no needs to install protobuf
             else()
-                ov_install_static_lib(${protobuf_target_name} ${OV_CPACK_COMP_CORE})
+                # Install protobuf and ALL of its non-imported transitive deps (including
+                # internal abseil targets like absl_log_internal_check_impl).  A shallow
+                # ov_install_static_lib loop over the public protobuf_dependencies list is
+                # insufficient because each public absl target itself depends on many internal
+                # ones that must also be present in OpenVINOTargets for consumers to link.
+                set(_ov_protobuf_roots ${protobuf_target_name} ${protobuf_dependencies})
+                ov_install_static_deps(_ov_protobuf_roots ${OV_CPACK_COMP_CORE})
+                unset(_ov_protobuf_roots)
                 set("${protobuf_install_name}" ON CACHE INTERNAL "" FORCE)
             endif()
         endif()

cmake/developer_package/packaging/debian/post_build.cmake

@@ -22,7 +22,12 @@ endif()
 set(lintian_passed ON)
 
 foreach(deb_file IN LISTS CPACK_PACKAGE_FILES)
-    execute_process(COMMAND "${lintian_PROGRAM}" ${deb_file}
+    execute_process(COMMAND "${lintian_PROGRAM}"
+                            # absl stub/aggregation static libraries (e.g. libabsl_string_view.a)
+                            # are intentionally code-free on modern platforms where the underlying
+                            # types come from the C++ standard library. Suppress the false-positive.
+                            --suppress-tags no-code-sections
+                            ${deb_file}
                     WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
                     RESULT_VARIABLE lintian_exit_code
                     OUTPUT_VARIABLE lintian_output)

cmake/developer_package/packaging/packaging.cmake

@@ -74,30 +74,195 @@ macro(ov_install_pdb target)
     endif()
 endmacro()
 
+#
+# _ov_collect_static_deps_impl(<target>)
+#
+# Internal recursive helper: walks both INTERFACE_LINK_LIBRARIES and
+# LINK_LIBRARIES depth-first and accumulates all non-imported project targets
+# (resolved through ALIAS) into the global property _OV_STATIC_DEP_RESULT.
+# A companion global property _OV_STATIC_DEP_VISITED prevents re-visiting.
+# Generator expressions in the dep lists are silently skipped.
+#
+# Both property lists are traversed because, for fully-static builds, CMake
+# may still namespace-qualify PRIVATE (LINK_LIBRARIES-only) deps of a static
+# library target when generating the export file, making them appear as
+# openvino::X in the exported INTERFACE_LINK_LIBRARIES even though X was
+# linked privately.  Every such target must therefore be in the export set.
+#
+function(_ov_collect_static_deps_impl target)
+    # Resolve ALIAS target
+    get_target_property(_csd_alias "${target}" ALIASED_TARGET)
+    if(_csd_alias)
+        set(_csd_real "${_csd_alias}")
+    else()
+        set(_csd_real "${target}")
+    endif()
+
+    if(NOT TARGET "${_csd_real}")
+        return()
+    endif()
+
+    # Guard: skip already-visited targets
+    get_property(_csd_visited GLOBAL PROPERTY _OV_STATIC_DEP_VISITED)
+    if("${_csd_real}" IN_LIST _csd_visited)
+        return()
+    endif()
+    set_property(GLOBAL APPEND PROPERTY _OV_STATIC_DEP_VISITED "${_csd_real}")
+
+    # Skip IMPORTED targets — they belong to external packages (e.g. system TBB)
+    get_target_property(_csd_imp "${_csd_real}" IMPORTED)
+    if(_csd_imp)
+        return()
+    endif()
+
+    set_property(GLOBAL APPEND PROPERTY _OV_STATIC_DEP_RESULT "${_csd_real}")
+
+    # Collect both interface and private link deps.
+    # INTERFACE_LINK_LIBRARIES: public/interface deps visible to consumers.
+    # LINK_LIBRARIES: all deps (public + private) that this target links.
+    # For fully-static builds we need both because CMake may reference private
+    # project targets in the exported interface with the openvino:: namespace.
+    set(_csd_all_deps "")
+    foreach(_csd_prop IN ITEMS INTERFACE_LINK_LIBRARIES LINK_LIBRARIES)
+        get_target_property(_csd_prop_deps "${_csd_real}" "${_csd_prop}")
+        if(_csd_prop_deps)
+            list(APPEND _csd_all_deps ${_csd_prop_deps})
+        endif()
+    endforeach()
+
+    foreach(_csd_dep IN LISTS _csd_all_deps)
+        # Skip generator expressions such as $<LINK_ONLY:...>
+        if(_csd_dep MATCHES "^\\$<")
+            continue()
+        endif()
+        if(TARGET "${_csd_dep}")
+            _ov_collect_static_deps_impl("${_csd_dep}")
+        endif()
+    endforeach()
+endfunction()
+
+#
+# ov_install_static_deps(<targets-list-variable> <comp>)
+#
+# Installs every target named in <targets-list-variable> and all of their
+# non-imported transitive link dependencies (both INTERFACE and LINK_LIBRARIES)
+# into the OpenVINO export set (OpenVINOTargets).  Uses global CMake properties
+# as scratch space so that the recursion can be arbitrarily deep.
+#
+# Both public (INTERFACE_LINK_LIBRARIES) and private (LINK_LIBRARIES) deps are
+# traversed because, for fully-static builds, CMake may namespace-qualify even
+# private project deps in the exported interface (e.g. openvino::utf8_validity),
+# requiring them to be defined in OpenVINOTargets.
+#
+macro(ov_install_static_deps _ov_isd_targets_var _ov_isd_comp)
+    set_property(GLOBAL PROPERTY _OV_STATIC_DEP_VISITED "")
+    set_property(GLOBAL PROPERTY _OV_STATIC_DEP_RESULT "")
+    foreach(_ov_isd_root IN LISTS ${_ov_isd_targets_var})
+        if(TARGET "${_ov_isd_root}")
+            _ov_collect_static_deps_impl("${_ov_isd_root}")
+        endif()
+    endforeach()
+    get_property(_ov_isd_all GLOBAL PROPERTY _OV_STATIC_DEP_RESULT)
+    foreach(_ov_isd_dep IN LISTS _ov_isd_all)
+        ov_install_static_lib("${_ov_isd_dep}" "${_ov_isd_comp}")
+    endforeach()
+    unset(_ov_isd_targets_var)
+    unset(_ov_isd_root)
+    unset(_ov_isd_dep)
+    unset(_ov_isd_all)
+endmacro()
+
+#
+# ov_register_static_deps_in_export(<targets-list-variable> <export-set-name>)
+#
+# Registers every target in <targets-list-variable> and all of their
+# non-imported transitive link dependencies into a NAMED export set without
+# the BUILD_SHARED_LIBS guard that ov_install_static_deps has.
+#
+# Used to satisfy CMake's install(EXPORT ...) validation for third-party export
+# sets (e.g. ONNXTargets) in shared builds, where ov_install_static_lib's
+# if(NOT BUILD_SHARED_LIBS) guard would otherwise leave the deps unregistered
+# and CMake's generate-step export validation would fail with "not in any
+# export set".
+#
+# NOTE: Do NOT call this for OpenVINOTargets in static builds — use
+# ov_install_static_deps instead.  Registering the same target in two export
+# sets (one via ov_install_static_deps and one via this macro) causes CMake to
+# error with "exported multiple times" when any other target depends on it.
+#
+macro(ov_register_static_deps_in_export _ov_rsde_targets_var _ov_rsde_export)
+    set_property(GLOBAL PROPERTY _OV_STATIC_DEP_VISITED "")
+    set_property(GLOBAL PROPERTY _OV_STATIC_DEP_RESULT "")
+    foreach(_ov_rsde_root IN LISTS ${_ov_rsde_targets_var})
+        if(TARGET "${_ov_rsde_root}")
+            _ov_collect_static_deps_impl("${_ov_rsde_root}")
+        endif()
+    endforeach()
+    get_property(_ov_rsde_all GLOBAL PROPERTY _OV_STATIC_DEP_RESULT)
+    foreach(_ov_rsde_dep IN LISTS _ov_rsde_all)
+        get_target_property(_ov_rsde_alias "${_ov_rsde_dep}" ALIASED_TARGET)
+        if(_ov_rsde_alias)
+            set(_ov_rsde_real "${_ov_rsde_alias}")
+        else()
+            set(_ov_rsde_real "${_ov_rsde_dep}")
+        endif()
+        get_target_property(_ov_rsde_imp "${_ov_rsde_real}" IMPORTED)
+        if(NOT _ov_rsde_imp)
+            install(TARGETS "${_ov_rsde_real}"
+                    EXPORT "${_ov_rsde_export}"
+                    ARCHIVE DESTINATION ${OV_CPACK_ARCHIVEDIR}
+                    COMPONENT ${OV_CPACK_COMP_CORE}
+                    ${OV_CPACK_COMP_CORE_EXCLUDE_ALL})
+        endif()
+    endforeach()
+    unset(_ov_rsde_root)
+    unset(_ov_rsde_dep)
+    unset(_ov_rsde_real)
+    unset(_ov_rsde_alias)
+    unset(_ov_rsde_imp)
+    unset(_ov_rsde_all)
+endmacro()
+
 #
 # ov_install_static_lib(<target> <comp>)
 #
 macro(ov_install_static_lib target comp)
     if(NOT BUILD_SHARED_LIBS)
-        get_target_property(target_type ${target} TYPE)
-        if(target_type STREQUAL "STATIC_LIBRARY")
-            set_target_properties(${target} PROPERTIES EXCLUDE_FROM_ALL OFF)
+        # Resolve alias targets — install(TARGETS) does not accept aliases
+        get_target_property(aliased_target ${target} ALIASED_TARGET)
+        if(aliased_target)
+            set(install_target ${aliased_target})
+        else()
+            set(install_target ${target})
         endif()
 
-        # save all internal installed targets to filter them later in 'ov_generate_dev_package_config'
-        list(APPEND openvino_installed_targets ${target})
-        set(openvino_installed_targets "${openvino_installed_targets}" CACHE INTERNAL
-            "A list of OpenVINO internal targets" FORCE)
+        # Skip imported targets — they are owned by their own package config
+        # and are not installed as part of OpenVINO.
+        # Alias targets (e.g. absl::absl_check → absl_check) are resolved above;
+        # the underlying non-imported target must still be exported so that
+        # openvino::libprotobuf's INTERFACE_LINK_LIBRARIES can resolve at consumer time.
+        get_target_property(is_imported ${install_target} IMPORTED)
+        if(NOT is_imported)
+            get_target_property(target_type ${install_target} TYPE)
+            if(target_type STREQUAL "STATIC_LIBRARY")
+                set_target_properties(${install_target} PROPERTIES EXCLUDE_FROM_ALL OFF)
+            endif()
 
-        install(TARGETS ${target} EXPORT OpenVINOTargets
-                ARCHIVE DESTINATION ${OV_CPACK_ARCHIVEDIR} COMPONENT ${comp} ${ARGN})
+            # save all internal installed targets to filter them later in 'ov_generate_dev_package_config'
+            list(APPEND openvino_installed_targets ${install_target})
+            set(openvino_installed_targets "${openvino_installed_targets}" CACHE INTERNAL
+                "A list of OpenVINO internal targets" FORCE)
 
-        # install compile PDB file as well
-        ov_install_pdb(${target})
+            install(TARGETS ${install_target} EXPORT OpenVINOTargets
+                    ARCHIVE DESTINATION ${OV_CPACK_ARCHIVEDIR} COMPONENT ${comp} ${ARGN})
 
-        # export to local tree to build against static build tree
-        export(TARGETS ${target} NAMESPACE openvino::
-               APPEND FILE "${CMAKE_BINARY_DIR}/OpenVINOTargets.cmake")
+            # install compile PDB file as well
+            ov_install_pdb(${install_target})
+
+            # export to local tree to build against static build tree
+            export(TARGETS ${install_target} NAMESPACE openvino::
+                   APPEND FILE "${CMAKE_BINARY_DIR}/OpenVINOTargets.cmake")
+        endif()
     endif()
 endmacro()