CMakeLists.txt

# Copyright (C) 2020-2026 Intel Corporation
# SPDX-License-Identifier: MIT

cmake_minimum_required(VERSION 3.12.0 FATAL_ERROR)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

set(THIRD_PARTY_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/third_party)

if(MSVC AND (MSVC_VERSION LESS 1900))
    message(FATAL_ERROR "Visual Studio Compiler Version >= 1900 Required to build.")
endif()

# This project follows semantic versioning (https://semver.org/)
project(level-zero VERSION 1.34.0)
include(GNUInstallDirs)

find_package(Git)
if(Git_FOUND)
	if(MSVC)
		execute_process(
			COMMAND CMD /c ${GIT_EXECUTABLE} rev-parse HEAD
			OUTPUT_VARIABLE VERSION_SHA
			OUTPUT_STRIP_TRAILING_WHITESPACE
			WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
		)
	else()
	execute_process(
		COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
		OUTPUT_VARIABLE VERSION_SHA
		OUTPUT_STRIP_TRAILING_WHITESPACE
		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	)
	endif()
else()
	set(VERSION_SHA " - No git SHA found, compiled outside git folder.")
endif()
add_definitions(-DLOADER_VERSION_SHA="${VERSION_SHA}")

include(FetchContent)

if(BUILD_L0_LOADER_TESTS)
	set(INSTALL_GTEST OFF)
    FetchContent_Declare(
        googletest
        GIT_REPOSITORY https://github.com/google/googletest.git
        GIT_TAG        v1.14.0
    )
    add_library(GTest::GTest INTERFACE IMPORTED)
    target_link_libraries(GTest::GTest INTERFACE gtest_main)

	FetchContent_MakeAvailable(googletest)

	enable_testing()
endif()

# Update other relevant variables to include the patch
set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
set(CMAKE_PROJECT_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
set(CMAKE_PROJECT_VERSION "${PROJECT_VERSION}")
add_definitions(-DLOADER_VERSION_MAJOR=${PROJECT_VERSION_MAJOR})
add_definitions(-DLOADER_VERSION_MINOR=${PROJECT_VERSION_MINOR})
add_definitions(-DLOADER_VERSION_PATCH=${PROJECT_VERSION_PATCH})

file(WRITE "${PROJECT_BINARY_DIR}/VERSION" "${PROJECT_VERSION}")

string(TIMESTAMP CURRENT_YEAR "%Y")

if (NOT DEFINED CMAKE_RUNTIME_OUTPUT_DIRECTORY)
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
endif()
if (NOT DEFINED CMAKE_LIBRARY_OUTPUT_DIRECTORY)
    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
endif()
if (NOT DEFINED CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
endif()
#Define a path for custom commands to work around MSVC
set(CUSTOM_COMMAND_BINARY_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})

if(MSVC)
    #MSVC implicitly adds $<CONFIG> to the output path
    set(CUSTOM_COMMAND_BINARY_DIR ${CUSTOM_COMMAND_BINARY_DIR}/$<CONFIG>)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /DYNAMICBASE")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /DYNAMICBASE")
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_CXX_LINKER_WRAPPER_FLAG}/DYNAMICBASE")
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_CXX_LINKER_WRAPPER_FLAG}/guard:cf")
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_CXX_LINKER_WRAPPER_FLAG}/LTCG /INCREMENTAL:NO")
    # enable flags, that are not supported or unused by clang-cl
    if((NOT CMAKE_CXX_COMPILER_ID STREQUAL Clang) AND (NOT CMAKE_CXX_COMPILER_ID STREQUAL IntelLLVM))
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Qspectre")
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /guard:cf")
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GL")
    endif()
    if((NOT CMAKE_C_COMPILER_ID STREQUAL Clang) AND NOT (CMAKE_C_COMPILER_ID STREQUAL IntelLLVM))
        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Qspectre")
        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /guard:cf")
        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /GL")
    endif()
endif()

#CXX compiler support
if(NOT MSVC)
    include(CheckCXXCompilerFlag)
    CHECK_CXX_COMPILER_FLAG("-std=c++14" COMPILER_SUPPORTS_CXX14)
    if(COMPILER_SUPPORTS_CXX14)
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
    else()
        message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++14 support.  Please use a different C++ compiler.")
    endif()
    if (UNIX)
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fpermissive -fPIC")
    else()
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fpermissive")
    endif()
    if(NOT CMAKE_CXX_COMPILER_ID STREQUAL IntelLLVM)
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wnon-virtual-dtor")
    endif()
endif()

#MSVC compile flags
if(MSVC)
    IF (NOT MSVC_BUILD_L0_DYNAMIC_VCRUNTIME)
        string(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG           "${CMAKE_CXX_FLAGS_DEBUG}")
        string(REPLACE "/MD"  "/MT"  CMAKE_CXX_FLAGS_RELEASE         "${CMAKE_CXX_FLAGS_RELEASE}")
        string(REPLACE "/MD"  "/MT"  CMAKE_CXX_FLAGS_RELWITHDEBINFO  "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
    ELSE()
        string(REPLACE "/MTd" "/MDd" CMAKE_CXX_FLAGS_DEBUG           "${CMAKE_CXX_FLAGS_DEBUG}")
        string(REPLACE "/MT"  "/MD"  CMAKE_CXX_FLAGS_RELEASE         "${CMAKE_CXX_FLAGS_RELEASE}")
        string(REPLACE "/MT"  "/MD"  CMAKE_CXX_FLAGS_RELWITHDEBINFO  "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
        if(NOT (CMAKE_CXX_FLAGS_RELEASE MATCHES "/MD"))
            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MD")
        endif()
        if(NOT (CMAKE_CXX_FLAGS_DEBUG MATCHES "/MDd"))
            set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MDd")
        endif()
        if(NOT (CMAKE_CXX_FLAGS_RELWITHDEBINFO MATCHES "/MD"))
            set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /MD")
        endif()
    ENDIF()

    if(NOT CMAKE_CXX_COMPILER_ID STREQUAL IntelLLVM)
        # treat warnings as errors
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX /W3")
    endif()

    # enable multi-process compilation, not supported by clang-cl
    if((NOT CMAKE_CXX_COMPILER_ID STREQUAL Clang) AND (NOT CMAKE_CXX_COMPILER_ID STREQUAL IntelLLVM))
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
    endif()

    # enable exceptions handling
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")

    # enable creation of PDB files for Release Builds
    set(CMAKE_CXX_FLAGS_RELEASE         "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO  "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Zi")
    set(CMAKE_SHARED_LINKER_FLAGS_RELEASE
        "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} \
         ${CMAKE_CXX_LINKER_WRAPPER_FLAG}/DEBUG \
         ${CMAKE_CXX_LINKER_WRAPPER_FLAG}/OPT:REF \
         ${CMAKE_CXX_LINKER_WRAPPER_FLAG}/OPT:ICF")

    # VTune-friendly settings for RelWithDebInfo
    set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
        "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} \
         ${CMAKE_CXX_LINKER_WRAPPER_FLAG}/DEBUG \
         ${CMAKE_CXX_LINKER_WRAPPER_FLAG}/INCREMENTAL:NO")

    # enable CET shadow stack
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_CXX_LINKER_WRAPPER_FLAG}/CETCOMPAT")

    #Use of sccache with MSVC requires workaround of replacing /Zi with /Z7
    #https://github.com/mozilla/sccache
    if(USE_Z7) #sccache
      string(REPLACE "/Zi" "/Z7" CMAKE_CXX_FLAGS_DEBUG          "${CMAKE_CXX_FLAGS_DEBUG}")
      string(REPLACE "/Zi" "/Z7" CMAKE_C_FLAGS_DEBUG            "${CMAKE_C_FLAGS_DEBUG}")
      string(REPLACE "/Zi" "/Z7" CMAKE_CXX_FLAGS_RELEASE        "${CMAKE_CXX_FLAGS_RELEASE}")
      string(REPLACE "/Zi" "/Z7" CMAKE_C_FLAGS_RELEASE          "${CMAKE_C_FLAGS_RELEASE}")
      string(REPLACE "/Zi" "/Z7" CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
      string(REPLACE "/Zi" "/Z7" CMAKE_C_FLAGS_RELWITHDEBINFO   "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
    endif()

endif()

if(USE_ASAN)
    if(NOT MSVC)
        # -fno-omit-frame-pointer is included for nicer stack traces in error messages
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
    else()
        message(WARNING "Address Sanitizer is not supported on Windows")
    endif()
endif()

# Enable -Werror only if not building as a subproject. For subprojects, leave
# this up to the parent project.
if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
  if(CMAKE_VERSION VERSION_LESS 3.24)
    if(NOT MSVC)
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
    endif()
  else()
    set(CMAKE_COMPILE_WARNING_AS_ERROR ON)
  endif()
endif()

include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/source/wrapper/include)


include_directories("${CMAKE_CURRENT_SOURCE_DIR}")

set(TARGET_LOADER_NAME ze_loader)

# Canonical Ubuntu/Debian package names (libze1 / libze-dev)
# produced alongside the existing level-zero / level-zero-devel packages.
# Restricted to Debian/Ubuntu systems only; RPM-based distros (SLES, RHEL, …)
# must not produce libze1/libze-dev packages.
if(NOT BUILD_INSTALLER AND EXISTS "/etc/debian_version")
    set(CANONICAL_LIB_COMPONENT "libze1")
    set(CANONICAL_SDK_COMPONENT "libze-dev")
endif()

if (MSVC)
    set (PYTHON_EXECUTABLE "python")
else()
    set (PYTHON_EXECUTABLE "python3")
endif()

# Most of the files under source/ are generated by scripts/json2src.py from the
# Mako templates in scripts/templates/, using the specification metadata archived
# in scripts/spec_metadata/. They are committed, so a normal build never
# regenerates them and needs no Python at all.
#
# This target is a convenience wrapper around the real entry point:
#   python3 scripts/spec_metadata.py regen
# It rewrites committed files in the source tree, so it only ever runs when named
# explicitly -- deliberately not wired into the default build or into configure,
# where a cached option would silently rewrite the tree on every reconfigure.
#   cmake --build <dir> --target regenerate-source
add_custom_target(regenerate-source
    COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/spec_metadata.py regen
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    COMMENT "Regenerating loader source from archived spec metadata"
    VERBATIM
)

add_subdirectory(source)
add_subdirectory(samples)

if(BUILD_L0_LOADER_TESTS)
    include(CTest)
    add_subdirectory(test)
endif()

include("os_release_info.cmake")
get_os_release_info(os_name os_version os_codename)
string(APPEND os_type "${os_name}")
string(COMPARE EQUAL "${os_type}" "sles" sles_distro)
#Pick only first character of os_name
string(SUBSTRING "${os_name}" 0 1 os_name)

file(GLOB LEVEL_ZERO_API_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/include/*.h")

set(SDK_COMPONENT_STRING "level-zero-devel")

if(BUILD_INSTALLER)
    set(SDK_COMPONENT_STRING "SDK")
endif()

install(FILES ${LEVEL_ZERO_API_HEADERS}
    DESTINATION include/level_zero
    COMPONENT ${SDK_COMPONENT_STRING}
)

file(GLOB LEVEL_ZERO_LAYERS_API_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/include/layers/*.h")

install(FILES ${LEVEL_ZERO_LAYERS_API_HEADERS}
    DESTINATION include/level_zero/layers
    COMPONENT ${SDK_COMPONENT_STRING}
)

file(GLOB LEVEL_ZERO_LOADER_API_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/include/loader/*.h")

install(FILES ${LEVEL_ZERO_LOADER_API_HEADERS}
    DESTINATION include/level_zero/loader
    COMPONENT ${SDK_COMPONENT_STRING}
)

# Canonical Ubuntu/Debian package naming (libze1 / libze-dev) mirrors Canonical's own packaging.
# EXCLUDE_FROM_ALL prevents these rules from running during 'make install' — the same files are
# already installed by the level-zero / level-zero-devel components above. CPack ignores
# EXCLUDE_FROM_ALL when building component packages, so 'cmake --build . --target package'
# still produces all four .deb files without duplicating entries in install_manifest.txt.
if(CANONICAL_SDK_COMPONENT)
    install(FILES ${LEVEL_ZERO_API_HEADERS}
        DESTINATION ./include/level_zero
        COMPONENT ${CANONICAL_SDK_COMPONENT}
        EXCLUDE_FROM_ALL
    )
    install(FILES ${LEVEL_ZERO_LAYERS_API_HEADERS}
        DESTINATION ./include/level_zero/layers
        COMPONENT ${CANONICAL_SDK_COMPONENT}
        EXCLUDE_FROM_ALL
    )
    install(FILES ${LEVEL_ZERO_LOADER_API_HEADERS}
        DESTINATION ./include/level_zero/loader
        COMPONENT ${CANONICAL_SDK_COMPONENT}
        EXCLUDE_FROM_ALL
    )
endif()

# PYTHON_EXECUTABLE is set above, next to the source regeneration options.
set(PRODUCT_GUID_FILE "${CMAKE_CURRENT_SOURCE_DIR}/PRODUCT_GUID.txt")
if(EXISTS "${PRODUCT_GUID_FILE}")
    file(STRINGS "${PRODUCT_GUID_FILE}" SAVED_PRODUCT_GUID)
    list(GET SAVED_PRODUCT_GUID 0 SAVED_PRODUCT_GUID_VERSION)
    message(STATUS "Saved Product GUID: ${SAVED_PRODUCT_GUID_VERSION}")
    message(STATUS "project version: ${PROJECT_VERSION}")
    if(NOT SAVED_PRODUCT_GUID_VERSION STREQUAL "${PROJECT_VERSION}")
        execute_process(
            COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/generate_wix_guid.py
            OUTPUT_VARIABLE GENERATED_PRODUCT_GUID
            OUTPUT_STRIP_TRAILING_WHITESPACE
        )
        file(WRITE "${PRODUCT_GUID_FILE}" "${PROJECT_VERSION}\n${GENERATED_PRODUCT_GUID}")
        message(STATUS "Generated Product GUID: ${GENERATED_PRODUCT_GUID} for version ${PROJECT_VERSION}")
        message(FATAL_ERROR
            "PRODUCT_GUID.txt has been regenerated for version ${PROJECT_VERSION}.\n"
            "Please commit the updated PRODUCT_GUID.txt before continuing:\n"
            "  git add ${PRODUCT_GUID_FILE}\n"
            "  git commit -m 'Update PRODUCT_GUID.txt for version ${PROJECT_VERSION}'\n"
            "Then re-run cmake.")
        else()
        list(GET SAVED_PRODUCT_GUID 1 GENERATED_PRODUCT_GUID)
    endif()
else()
    execute_process(
        COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/generate_wix_guid.py
        OUTPUT_VARIABLE GENERATED_PRODUCT_GUID
        OUTPUT_STRIP_TRAILING_WHITESPACE
    )
    file(WRITE "${PRODUCT_GUID_FILE}" "${PROJECT_VERSION}\n${GENERATED_PRODUCT_GUID}")
    message(FATAL_ERROR
        "PRODUCT_GUID.txt did not exist and has been created for version ${PROJECT_VERSION}.\n"
        "Please commit it before continuing:\n"
        "  git add ${PRODUCT_GUID_FILE}\n"
        "  git commit -m 'Add PRODUCT_GUID.txt for version ${PROJECT_VERSION}'\n"
        "Then re-run cmake.")
endif()
message(STATUS "Using Product GUID: ${GENERATED_PRODUCT_GUID} for version ${PROJECT_VERSION}")

# If generators list was not define build native package for current distro
if(NOT DEFINED CPACK_GENERATOR)
	if(EXISTS "/etc/debian_version")
		set(CPACK_GENERATOR "DEB")
	elseif(EXISTS "/etc/redhat-release")
		set(CPACK_GENERATOR "RPM")
	elseif(EXISTS "/etc/SUSE-brand" OR EXISTS "/etc/SUSE-release" OR sles_distro)
		set(CPACK_GENERATOR "RPM")
    elseif(BUILD_INSTALLER)
        set(CPACK_GENERATOR "WIX")
        set(CPACK_PACKAGE_NAME "oneAPI Level Zero")
        set(CPACK_PACKAGE_FILE_NAME "oneAPI_Level_Zero-${PROJECT_VERSION}-win64")
        set(CPACK_WIX_ROOT_FEATURE_TITLE "oneAPI Level Zero")
        set(CPACK_WIX_PROGRAM_MENU_FOLDER "oneAPI Level Zero")

        set(CMAKE_INSTALL_PREFIX "LevelZeroSDK/${PROJECT_VERSION}/")
        # Add the script to the install directory
        install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/scripts/level_zero_sdk_setup.ps1"
            DESTINATION ./scripts
            COMPONENT ${SDK_COMPONENT_STRING}
        )

        set(CPACK_WIX_PATCH_FILE "${CMAKE_CURRENT_SOURCE_DIR}/scripts/wix_env_installation.wxs")

        # sharing GUIDs between product and upgrade codes such that side by side installation is allowed.
        set(CPACK_WIX_PRODUCT_GUID ${GENERATED_PRODUCT_GUID})
        set(CPACK_WIX_UPGRADE_GUID ${GENERATED_PRODUCT_GUID})
        set(CPACK_WIX_UI_DIALOG "${CMAKE_CURRENT_SOURCE_DIR}/icons/oneapi-icon-left-aligned.png")
        set(CPACK_WIX_UI_BANNER "${CMAKE_CURRENT_SOURCE_DIR}/icons/oneapi-icon-right-aligned.png")
        get_cmake_property(CPACK_COMPONENTS_ALL COMPONENTS)
        list(REMOVE_ITEM CPACK_COMPONENTS_ALL "Loader")
        set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSES/MIT.txt")
	else()
		set(CPACK_GENERATOR "ZIP")
	endif()
endif()

if(MSVC)
	set(CPACK_SET_DESTDIR FALSE)
	set(CPACK_PACKAGING_INSTALL_PREFIX "")
else()
	set(CPACK_SET_DESTDIR TRUE)
endif()
set(CPACK_PACKAGE_RELOCATABLE FALSE)
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "oneAPI Level Zero")
set(CPACK_PACKAGE_VENDOR "Intel Corporation")

set(CPACK_PACKAGE_INSTALL_DIRECTORY ${CMAKE_INSTALL_PREFIX})
set(CPACK_PACKAGE_CONTACT "Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>")

set(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
set(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")

if(CPACK_GENERATOR MATCHES "RPM")
	set(CPACK_RPM_COMPRESSION_TYPE "xz")
	string(FIND "${CMAKE_CXX_COMPILER}" "aarch64" compiler_arch_check)
	if((NOT ${compiler_arch_check} MATCHES "-1") OR (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64"))
		set(CPACK_RPM_PACKAGE_ARCHITECTURE "aarch64")
	elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64")
		set(CPACK_RPM_PACKAGE_ARCHITECTURE "x86_64")
	endif()
	set(CPACK_RPM_PACKAGE_AUTOREQ OFF)
	set(CPACK_RPM_PACKAGE_DESCRIPTION "oneAPI Level Zero")
	set(CPACK_RPM_PACKAGE_GROUP "System Environment/Libraries")
	set(CPACK_RPM_PACKAGE_LICENSE "MIT")
	set(CPACK_RPM_PACKAGE_RELEASE 1)
	set(CPACK_RPM_PACKAGE_RELEASE_DIST ON)
	set(CPACK_RPM_PACKAGE_URL "https://github.com/oneapi-src/level-zero")
	set(CPACK_RPM_COMPONENT_INSTALL ON)
	set(CPACK_RPM_LEVEL-ZERO_PACKAGE_NAME "${PROJECT_NAME}")
	set(CPACK_RPM_LEVEL-ZERO-DEVEL_PACKAGE_NAME "${PROJECT_NAME}-devel")
	set(CPACK_RPM_LEVEL-ZERO_FILE_NAME "${PROJECT_NAME}-${PROJECT_VERSION}-${os_name}${os_version}.${CPACK_RPM_PACKAGE_ARCHITECTURE}.rpm")
	set(CPACK_RPM_LEVEL-ZERO-DEVEL_FILE_NAME "${PROJECT_NAME}-devel-${PROJECT_VERSION}-${os_name}${os_version}.${CPACK_RPM_PACKAGE_ARCHITECTURE}.rpm")
	set(CPACK_RPM_LEVEL-ZERO-DEVEL_PACKAGE_REQUIRES "level-zero = ${PROJECT_VERSION}")

	set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
	  /etc/ld.so.conf.d
	  /usr/lib64
	  /usr/lib64/pkgconfig
	  /usr/local
	  /usr/local/lib64
	  /usr/local/bin
	  /usr/local/include
	)
endif()

if(CPACK_GENERATOR MATCHES "DEB")
	string(FIND "${CMAKE_CXX_COMPILER}" "aarch64" compiler_arch_check)
	if((NOT ${compiler_arch_check} MATCHES "-1") OR (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64"))
		SET(CPACK_DEBIAN_PACKAGE_ARCHITECTURE arm64)
	elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64")
		SET(CPACK_DEBIAN_PACKAGE_ARCHITECTURE amd64)
	endif()
	set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "https://github.com/oneapi-src/level-zero")
	set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
	set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "oneAPI Level Zero")
	set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "oneAPI Level Zero")

    # Canonical Ubuntu naming: libze1 (runtime) and libze-dev (development)
    # For Debian/Ubuntu, only produce libze1 and libze-dev packages, not level-zero and level-zero-devel
    get_cmake_property(CPACK_COMPONENTS_ALL COMPONENTS)
    list(REMOVE_ITEM CPACK_COMPONENTS_ALL "level-zero" "level-zero-devel")

    set(CPACK_DEBIAN_LIBZE1_PACKAGE_NAME "libze1")
    set(CPACK_DEBIAN_LIBZE-DEV_PACKAGE_NAME "libze-dev")
    set(CPACK_DEBIAN_LIBZE1_FILE_NAME "libze1_${PROJECT_VERSION}+${os_name}${os_version}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}.deb")
    set(CPACK_DEBIAN_LIBZE-DEV_FILE_NAME "libze-dev_${PROJECT_VERSION}+${os_name}${os_version}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}.deb")
    set(CPACK_DEBIAN_LIBZE-DEV_PACKAGE_DEPENDS "libze1 (= ${PROJECT_VERSION})")

    # Mutual exclusion with the level-zero / level-zero-devel packages
    # Allows seamless upgrade from old naming to new Canonical naming
    set(CPACK_DEBIAN_LIBZE1_PACKAGE_CONFLICTS "level-zero")
    set(CPACK_DEBIAN_LIBZE1_PACKAGE_PROVIDES "level-zero")
    set(CPACK_DEBIAN_LIBZE1_PACKAGE_REPLACES "level-zero")
    set(CPACK_DEBIAN_LIBZE-DEV_PACKAGE_CONFLICTS "level-zero-devel")
    set(CPACK_DEBIAN_LIBZE-DEV_PACKAGE_PROVIDES "level-zero-devel")
    set(CPACK_DEBIAN_LIBZE-DEV_PACKAGE_REPLACES "level-zero-devel")

    set(CPACK_DEB_COMPONENT_INSTALL ON)
    set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
endif()

INCLUDE(CPack)