ÿØÿà JFIF    ÿÛ „ ( %!1!%*+...983,7(-.- PK‹`]Ò´ñPP expat-2.5.0/expat-noconfig.cmakenu„[µü¤#---------------------------------------------------------------- # Generated CMake target import file for configuration "NoConfig". #---------------------------------------------------------------- # Commands may need to know the format version. set(CMAKE_IMPORT_FILE_VERSION 1) # Import target "expat::expat" for configuration "NoConfig" set_property(TARGET expat::expat APPEND PROPERTY IMPORTED_CONFIGURATIONS NOCONFIG) set_target_properties(expat::expat PROPERTIES IMPORTED_LOCATION_NOCONFIG "${_IMPORT_PREFIX}/lib64/libexpat.so.1.8.10" IMPORTED_SONAME_NOCONFIG "libexpat.so.1" ) list(APPEND _cmake_import_check_targets expat::expat ) list(APPEND _cmake_import_check_files_for_expat::expat "${_IMPORT_PREFIX}/lib64/libexpat.so.1.8.10" ) # Commands beyond this point should not need to know the version. set(CMAKE_IMPORT_FILE_VERSION) PK‹`]ŠzvcÎÎexpat-2.5.0/expat.cmakenu„[µü¤# Generated by CMake if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) message(FATAL_ERROR "CMake >= 2.8.0 required") endif() if(CMAKE_VERSION VERSION_LESS "2.8.3") message(FATAL_ERROR "CMake >= 2.8.3 required") endif() cmake_policy(PUSH) cmake_policy(VERSION 2.8.3...3.22) #---------------------------------------------------------------- # Generated CMake target import file. #---------------------------------------------------------------- # Commands may need to know the format version. set(CMAKE_IMPORT_FILE_VERSION 1) # Protect against multiple inclusion, which would fail when already imported targets are added once more. set(_cmake_targets_defined "") set(_cmake_targets_not_defined "") set(_cmake_expected_targets "") foreach(_cmake_expected_target IN ITEMS expat::expat) list(APPEND _cmake_expected_targets "${_cmake_expected_target}") if(TARGET "${_cmake_expected_target}") list(APPEND _cmake_targets_defined "${_cmake_expected_target}") else() list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") endif() endforeach() unset(_cmake_expected_target) if(_cmake_targets_defined STREQUAL _cmake_expected_targets) unset(_cmake_targets_defined) unset(_cmake_targets_not_defined) unset(_cmake_expected_targets) unset(CMAKE_IMPORT_FILE_VERSION) cmake_policy(POP) return() endif() if(NOT _cmake_targets_defined STREQUAL "") string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") endif() unset(_cmake_targets_defined) unset(_cmake_targets_not_defined) unset(_cmake_expected_targets) # Compute the installation prefix relative to this file. get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) if(_IMPORT_PREFIX STREQUAL "/") set(_IMPORT_PREFIX "") endif() # Create imported target expat::expat add_library(expat::expat SHARED IMPORTED) set_target_properties(expat::expat PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" INTERFACE_LINK_LIBRARIES "m" ) if(CMAKE_VERSION VERSION_LESS 2.8.12) message(FATAL_ERROR "This file relies on consumers using CMake 2.8.12 or greater.") endif() # Load information for each installed configuration. file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/expat-*.cmake") foreach(_cmake_config_file IN LISTS _cmake_config_files) include("${_cmake_config_file}") endforeach() unset(_cmake_config_file) unset(_cmake_config_files) # Cleanup temporary variables. set(_IMPORT_PREFIX) # Loop over all imported files and verify that they actually exist foreach(_cmake_target IN LISTS _cmake_import_check_targets) foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") if(NOT EXISTS "${_cmake_file}") message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file \"${_cmake_file}\" but this file does not exist. Possible reasons include: * The file was deleted, renamed, or moved to another location. * An install or uninstall procedure did not complete successfully. * The installation package was faulty and contained \"${CMAKE_CURRENT_LIST_FILE}\" but not all the files it references. ") endif() endforeach() unset(_cmake_file) unset("_cmake_import_check_files_for_${_cmake_target}") endforeach() unset(_cmake_target) unset(_cmake_import_check_targets) # This file does not depend on other imported targets which have # been exported from the same project but in a separate export set. # Commands beyond this point should not need to know the version. set(CMAKE_IMPORT_FILE_VERSION) cmake_policy(POP) PK‹`]ÖL755expat-2.5.0/expat-config.cmakenu„[µü¤# __ __ _ # ___\ \/ /_ __ __ _| |_ # / _ \\ /| '_ \ / _` | __| # | __// \| |_) | (_| | |_ # \___/_/\_\ .__/ \__,_|\__| # |_| XML parser # # Copyright (c) 2019 Expat development team # Licensed under the MIT license: # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to permit # persons to whom the Software is furnished to do so, subject to the # following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN # NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, # DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE # USE OR OTHER DEALINGS IN THE SOFTWARE. # if(NOT _expat_config_included) # Protect against multiple inclusion set(_expat_config_included TRUE) include("${CMAKE_CURRENT_LIST_DIR}/expat.cmake") ####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() ####### ####### Any changes to this file will be overwritten by the next CMake run #### ####### The input file was expat-config.cmake.in ######## get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE) macro(set_and_check _var _file) set(${_var} "${_file}") if(NOT EXISTS "${_file}") message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !") endif() endmacro() macro(check_required_components _NAME) foreach(comp ${${_NAME}_FIND_COMPONENTS}) if(NOT ${_NAME}_${comp}_FOUND) if(${_NAME}_FIND_REQUIRED_${comp}) set(${_NAME}_FOUND FALSE) endif() endif() endforeach() endmacro() #################################################################################### # # Supported components # macro(expat_register_component _NAME _AVAILABE) set(expat_${_NAME}_FOUND ${_AVAILABE}) endmacro() expat_register_component(attr_info OFF) expat_register_component(dtd ON) expat_register_component(large_size OFF) expat_register_component(min_size OFF) expat_register_component(ns ON) if(1024) expat_register_component(context_bytes ON) else() expat_register_component(context_bytes OFF) endif() if("char" STREQUAL "char") expat_register_component(char ON) expat_register_component(ushort OFF) expat_register_component(wchar_t OFF) elseif("char" STREQUAL "ushort") expat_register_component(char OFF) expat_register_component(ushort ON) expat_register_component(wchar_t OFF) elseif("char" STREQUAL "wchar_t") expat_register_component(char OFF) expat_register_component(ushort OFF) expat_register_component(wchar_t ON) endif() check_required_components(expat) endif(NOT _expat_config_included) PK‹`]¬+wí> > &expat-2.5.0/expat-config-version.cmakenu„[µü¤# This is a basic version file for the Config-mode of find_package(). # It is used by write_basic_package_version_file() as input file for configure_file() # to create a version-file which can be installed along a config.cmake file. # # The created file sets PACKAGE_VERSION_EXACT if the current version string and # the requested version string are exactly the same and it sets # PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version, # but only if the requested major version is the same as the current one. # The variable CVF_VERSION must be set before calling configure_file(). set(PACKAGE_VERSION "2.5.0") if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) set(PACKAGE_VERSION_COMPATIBLE FALSE) else() if("2.5.0" MATCHES "^([0-9]+)\\.") set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") endif() else() set(CVF_VERSION_MAJOR "2.5.0") endif() if(PACKAGE_FIND_VERSION_RANGE) # both endpoints of the range must have the expected major version math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1") if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR) OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT))) set(PACKAGE_VERSION_COMPATIBLE FALSE) elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX) OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX))) set(PACKAGE_VERSION_COMPATIBLE TRUE) else() set(PACKAGE_VERSION_COMPATIBLE FALSE) endif() else() if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) set(PACKAGE_VERSION_COMPATIBLE TRUE) else() set(PACKAGE_VERSION_COMPATIBLE FALSE) endif() if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) set(PACKAGE_VERSION_EXACT TRUE) endif() endif() endif() # if the installed project requested no architecture check, don't perform the check if("FALSE") return() endif() # if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") return() endif() # check that the installed version has the same 32/64bit-ness as the one which is currently searching: if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") math(EXPR installedBits "8 * 8") set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") set(PACKAGE_VERSION_UNSUITABLE TRUE) endif() PK‹`]ªZ:>;>;openmp/FindOpenMPTarget.cmakenu„[µü¤##===----------------------------------------------------------------------===## # # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # See https://llvm.org/LICENSE.txt for license information. # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # ##===----------------------------------------------------------------------===## # # Find OpenMP Target offloading Support for various compilers. # ##===----------------------------------------------------------------------===## #[========================================================================[.rst: FindOpenMPTarget ---------------- Finds OpenMP Target Offloading Support. This module can be used to detect OpenMP target offloading support in a compiler. If the compiler support OpenMP Offloading to a specified target, the flags required to compile offloading code to that target are output for each target. This module will automatically include OpenMP support if it was not loaded already. It does not need to be included separately to get full OpenMP support. Variables ^^^^^^^^^ The module exposes the components ``NVPTX`` and ``AMDGPU``. Each of these controls the various offloading targets to search OpenMP target offloasing support for. Depending on the enabled components the following variables will be set: ``OpenMPTarget_FOUND`` Variable indicating that OpenMP target offloading flags for all requested targets have been found. This module will set the following variables per language in your project, where ```` is one of NVPTX or AMDGPU ``OpenMPTarget__FOUND`` Variable indicating if OpenMP support for the ```` was detected. ``OpenMPTarget__FLAGS`` OpenMP compiler flags for offloading to ````, separated by spaces. For linking with OpenMP code written in ````, the following variables are provided: ``OpenMPTarget__LIBRARIES`` A list of libraries needed to link with OpenMP code written in ````. Additionally, the module provides :prop_tgt:`IMPORTED` targets: ``OpenMPTarget::OpenMPTarget_`` Target for using OpenMP offloading to ````. If the specific architecture of the target is needed, it can be manually specified by setting a variable to the desired architecture. Variables can also be used to override the standard flag searching for a given compiler. ``OpenMPTarget__ARCH`` Sets the architecture of ```` to compile for. Such as `sm_70` for NVPTX or `gfx908` for AMDGPU. ``OpenMPTarget__DEVICE`` Sets the name of the device to offload to. ``OpenMPTarget__FLAGS`` Sets the compiler flags for offloading to ````. #]========================================================================] # TODO: Support Fortran # TODO: Support multiple offloading targets by setting the "OpenMPTarget" target # to include flags for all components loaded # TODO: Configure target architecture without a variable (component NVPTX_SM_70) # TODO: Test more compilers cmake_policy(PUSH) cmake_policy(VERSION 3.20.0) find_package(OpenMP ${OpenMPTarget_FIND_VERSION} REQUIRED) # Find the offloading flags for each compiler. function(_OPENMP_TARGET_DEVICE_FLAG_CANDIDATES LANG DEVICE) if(NOT OpenMPTarget_${LANG}_FLAGS) unset(OpenMPTarget_FLAG_CANDIDATES) set(OMPTarget_FLAGS_Clang "-fopenmp-targets=${DEVICE}") set(OMPTarget_FLAGS_GNU "-foffload=${DEVICE}=\"-lm -latomic\"") set(OMPTarget_FLAGS_XL "-qoffload") set(OMPTarget_FLAGS_PGI "-mp=${DEVICE}") set(OMPTarget_FLAGS_NVHPC "-mp=${DEVICE}") if(DEFINED OMPTarget_FLAGS_${CMAKE_${LANG}_COMPILER_ID}) set(OpenMPTarget_FLAG_CANDIDATES "${OMPTarget_FLAGS_${CMAKE_${LANG}_COMPILER_ID}}") endif() set(OpenMPTarget_${LANG}_FLAG_CANDIDATES "${OpenMPTarget_FLAG_CANDIDATES}" PARENT_SCOPE) else() set(OpenMPTarget_${LANG}_FLAG_CANDIDATES "${OpenMPTarget_${LANG}_FLAGS}" PARENT_SCOPE) endif() endfunction() # Get the coded name of the device for each compiler. function(_OPENMP_TARGET_DEVICE_CANDIDATES LANG DEVICE) if (NOT OpenMPTarget_${DEVICE}_DEVICE) unset(OpenMPTarget_DEVICE_CANDIDATES) # Check each supported device. if("${DEVICE}" STREQUAL "NVPTX") if ("${CMAKE_SIZEOF_VOID_P}" STREQUAL "4") set(OMPTarget_DEVICE_Clang "nvptx32-nvidia-cuda") else() set(OMPTarget_DEVICE_Clang "nvptx64-nvidia-cuda") endif() set(OMPTarget_DEVICE_GNU "nvptx-none") set(OMPTarget_DEVICE_XL "") set(OMPTarget_DEVICE_PGI "gpu") set(OMPTarget_DEVICE_NVHPC "gpu") if(DEFINED OMPTarget_DEVICE_${CMAKE_${LANG}_COMPILER_ID}) set(OpenMPTarget_DEVICE_CANDIDATES "${OMPTarget_DEVICE_${CMAKE_${LANG}_COMPILER_ID}}") endif() elseif("${DEVICE}" STREQUAL "AMDGPU") set(OMPTarget_DEVICE_Clang "amdgcn-amd-amdhsa") set(OMPTarget_DEVICE_GNU "hsa") if(DEFINED OMPTarget_DEVICE_${CMAKE_${LANG}_COMPILER_ID}) set(OpenMPTarget_DEVICE_CANDIDATES "${OMPTarget_DEVICE_${CMAKE_${LANG}_COMPILER_ID}}") endif() endif() set(OpenMPTarget_${LANG}_DEVICE_CANDIDATES "${OpenMPTarget_DEVICE_CANDIDATES}" PARENT_SCOPE) else() set(OpenMPTarget_${LANG}_DEVICE_CANDIDATES "${OpenMPTarget_${LANG}_DEVICE}" PARENT_SCOPE) endif() endfunction() # Get flags for setting the device's architecture for each compiler. function(_OPENMP_TARGET_DEVICE_ARCH_CANDIDATES LANG DEVICE DEVICE_FLAG) if(OpenMPTarget_${DEVICE}_ARCH) # Only Clang supports selecting the architecture for now. set(OMPTarget_ARCH_Clang "-Xopenmp-target=${DEVICE_FLAG} -march=${OpenMPTarget_${DEVICE}_ARCH}") if(DEFINED OMPTarget_ARCH_${CMAKE_${LANG}_COMPILER_ID}) set(OpenMPTarget_DEVICE_ARCH_CANDIDATES "${OMPTarget_ARCH_${CMAKE_${LANG}_COMPILER_ID}}") endif() set(OpenMPTarget_${LANG}_DEVICE_ARCH_CANDIDATES "${OpenMPTarget_DEVICE_ARCH_CANDIDATES}" PARENT_SCOPE) else() set(OpenMPTarget_${LANG}_DEVICE_ARCH_CANDIDATES "" PARENT_SCOPE) endif() endfunction() set(OpenMPTarget_C_CXX_TEST_SOURCE "#include int main(void) { int isHost; #pragma omp target map(from: isHost) { isHost = omp_is_initial_device(); } return isHost; }") function(_OPENMP_TARGET_WRITE_SOURCE_FILE LANG SRC_FILE_CONTENT_VAR SRC_FILE_NAME SRC_FILE_FULLPATH) set(WORK_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/FindOpenMPTarget) if("${LANG}" STREQUAL "C") set(SRC_FILE "${WORK_DIR}/${SRC_FILE_NAME}.c") file(WRITE "${SRC_FILE}" "${OpenMPTarget_C_CXX_${SRC_FILE_CONTENT_VAR}}") elseif("${LANG}" STREQUAL "CXX") set(SRC_FILE "${WORK_DIR}/${SRC_FILE_NAME}.cpp") file(WRITE "${SRC_FILE}" "${OpenMPTarget_C_CXX_${SRC_FILE_CONTENT_VAR}}") endif() set(${SRC_FILE_FULLPATH} "${SRC_FILE}" PARENT_SCOPE) endfunction() # Get the candidate flags and try to compile a test application. If it compiles # and all the flags are found, we assume the compiler supports offloading. function(_OPENMP_TARGET_DEVICE_GET_FLAGS LANG DEVICE OPENMP_FLAG_VAR OPENMP_LIB_VAR OPENMP_DEVICE_VAR OPENMP_ARCH_VAR) _OPENMP_TARGET_DEVICE_CANDIDATES(${LANG} ${DEVICE}) _OPENMP_TARGET_DEVICE_FLAG_CANDIDATES(${LANG} "${OpenMPTarget_${LANG}_DEVICE_CANDIDATES}") _OPENMP_TARGET_DEVICE_ARCH_CANDIDATES(${LANG} ${DEVICE} "${OpenMPTarget_${LANG}_DEVICE_CANDIDATES}") _OPENMP_TARGET_WRITE_SOURCE_FILE("${LANG}" "TEST_SOURCE" OpenMPTargetTryFlag _OPENMP_TEST_SRC) # Try to compile a test application with the found flags. try_compile(OpenMPTarget_COMPILE_RESULT ${CMAKE_BINARY_DIR} ${_OPENMP_TEST_SRC} CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=${OpenMP_${LANG}_FLAGS} ${OpenMPTarget_${LANG}_FLAG_CANDIDATES} ${OpenMPTarget_${LANG}_DEVICE_ARCH_CANDIDATES}" "-DINCLUDE_DIRECTORIES:STRING=${OpenMP_${LANG}_INCLUDE_DIR}" LINK_LIBRARIES ${CMAKE_${LANG}_VERBOSE_FLAG} OUTPUT_VARIABLE OpenMP_TRY_COMPILE_OUTPUT ) file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log "Detecting OpenMP ${CMAKE_${LANG}_COMPILER_ID} ${DEVICE} target support with the following Flags: ${OpenMP_${LANG}_FLAGS} ${OpenMPTarget_${LANG}_FLAG_CANDIDATES} ${OpenMPTarget_${LANG}_DEVICE_ARCH_CANDIDATES} With the following output:\n ${OpenMP_TRY_COMPILE_OUTPUT}\n") # If compilation was successful and the device was found set the return variables. if (OpenMPTarget_COMPILE_RESULT AND DEFINED OpenMPTarget_${LANG}_DEVICE_CANDIDATES) file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log "Compilation successful, adding flags for ${DEVICE}.\n\n") # Clang has a separate library for target offloading. if(CMAKE_${LANG}_COMPILER_ID STREQUAL "Clang") find_library(OpenMPTarget_libomptarget_LIBRARY NAMES omptarget HINTS ${CMAKE_${LANG}_IMPLICIT_LINK_DIRECTORIES} ) mark_as_advanced(OpenMPTarget_libomptarget_LIBRARY) set("${OPENMP_LIB_VAR}" "${OpenMPTarget_libomptarget_LIBRARY}" PARENT_SCOPE) else() unset("${OPENMP_LIB_VAR}" PARENT_SCOPE) endif() set("${OPENMP_DEVICE_VAR}" "${OpenMPTarget_${LANG}_DEVICE_CANDIDATES}" PARENT_SCOPE) set("${OPENMP_FLAG_VAR}" "${OpenMPTarget_${LANG}_FLAG_CANDIDATES}" PARENT_SCOPE) set("${OPENMP_ARCH_VAR}" "${OpenMPTarget_${LANG}_DEVICE_ARCH_CANDIDATES}" PARENT_SCOPE) else() unset("${OPENMP_DEVICE_VAR}" PARENT_SCOPE) unset("${OPENMP_FLAG_VAR}" PARENT_SCOPE) unset("${OPENMP_ARCH_VAR}" PARENT_SCOPE) endif() endfunction() # Load the compiler support for each device. foreach(LANG IN ITEMS C CXX) # Cache the version in case CMake doesn't load the OpenMP package this time set(OpenMP_${LANG}_VERSION ${OpenMP_${LANG}_VERSION} CACHE STRING "OpenMP Version" FORCE) mark_as_advanced(OpenMP_${LANG}_VERSION) foreach(DEVICE IN ITEMS NVPTX AMDGPU) if(CMAKE_${LANG}_COMPILER_LOADED) if(NOT DEFINED OpenMPTarget_${LANG}_FLAGS OR NOT DEFINED OpenMPTarget_${LANG}_DEVICE) _OPENMP_TARGET_DEVICE_GET_FLAGS(${LANG} ${DEVICE} OpenMPTarget_${DEVICE}_FLAGS_WORK OpenMPTarget_${DEVICE}_LIBS_WORK OpenMPTarget_${DEVICE}_DEVICE_WORK OpenMPTarget_${DEVICE}_ARCHS_WORK) separate_arguments(_OpenMPTarget_${DEVICE}_FLAGS NATIVE_COMMAND "${OpenMPTarget_${DEVICE}_FLAGS_WORK}") separate_arguments(_OpenMPTarget_${DEVICE}_ARCHS NATIVE_COMMAND "${OpenMPTarget_${DEVICE}_ARCHS_WORK}") set(OpenMPTarget_${DEVICE}_FLAGS ${_OpenMPTarget_${DEVICE}_FLAGS} CACHE STRING "${DEVICE} target compile flags for OpenMP target offloading" FORCE) set(OpenMPTarget_${DEVICE}_ARCH ${_OpenMPTarget_${DEVICE}_ARCHS} CACHE STRING "${DEVICE} target architecture flags for OpenMP target offloading" FORCE) set(OpenMPTarget_${DEVICE}_LIBRARIES ${OpenMPTarget_${DEVICE}_LIBS_WORK} CACHE STRING "${DEVICE} target libraries for OpenMP target offloading" FORCE) mark_as_advanced(OpenMPTarget_${DEVICE}_FLAGS OpenMPTarget_${DEVICE}_ARCH OpenMPTarget_${DEVICE}_LIBRARIES) endif() endif() endforeach() endforeach() if(OpenMPTarget_FIND_COMPONENTS) set(OpenMPTarget_FINDLIST ${OpenMPTarget_FIND_COMPONENTS}) else() set(OpenMPTarget_FINDLIST NVPTX) endif() unset(_OpenMPTarget_MIN_VERSION) # Attempt to find each requested device. foreach(LANG IN ITEMS C CXX) foreach(DEVICE IN LISTS OpenMPTarget_FINDLIST) if(CMAKE_${LANG}_COMPILER_LOADED) set(OpenMPTarget_${DEVICE}_VERSION "${OpenMP_${LANG}_VERSION}") set(OpenMPTarget_${DEVICE}_VERSION_MAJOR "${OpenMP_${LANG}_VERSION}_MAJOR") set(OpenMPTarget_${DEVICE}_VERSION_MINOR "${OpenMP_${LANG}_VERSION}_MINOR") set(OpenMPTarget_${DEVICE}_FIND_QUIETLY ${OpenMPTarget_FIND_QUIETLY}) set(OpenMPTarget_${DEVICE}_FIND_REQUIRED ${OpenMPTarget_FIND_REQUIRED}) set(OpenMPTarget_${DEVICE}_FIND_VERSION ${OpenMPTarget_FIND_VERSION}) set(OpenMPTarget_${DEVICE}_FIND_VERSION_EXACT ${OpenMPTarget_FIND_VERSION_EXACT}) # OpenMP target offloading is only supported in OpenMP 4.0 an newer. if(OpenMPTarget_${DEVICE}_VERSION AND ("${OpenMPTarget_${DEVICE}_VERSION}" VERSION_LESS "4.0")) message(SEND_ERROR "FindOpenMPTarget requires at least OpenMP 4.0") endif() set(FPHSA_NAME_MISMATCHED TRUE) find_package_handle_standard_args(OpenMPTarget_${DEVICE} REQUIRED_VARS OpenMPTarget_${DEVICE}_FLAGS VERSION_VAR OpenMPTarget_${DEVICE}_VERSION) if(OpenMPTarget_${DEVICE}_FOUND) if(DEFINED OpenMPTarget_${DEVICE}_VERSION) if(NOT _OpenMPTarget_MIN_VERSION OR _OpenMPTarget_MIN_VERSION VERSION_GREATER OpenMPTarget_${LANG}_VERSION) set(_OpenMPTarget_MIN_VERSION OpenMPTarget_${DEVICE}_VERSION) endif() endif() # Create a new target. if(NOT TARGET OpenMPTarget::OpenMPTarget_${DEVICE}) add_library(OpenMPTarget::OpenMPTarget_${DEVICE} INTERFACE IMPORTED) endif() # Get compiler flags for offloading to the device and architecture and # set the target features. Include the normal OpenMP flags as well. set_property(TARGET OpenMPTarget::OpenMPTarget_${DEVICE} PROPERTY INTERFACE_COMPILE_OPTIONS "$<$:${OpenMPTarget_${DEVICE}_FLAGS}>" "$<$:${OpenMPTarget_${DEVICE}_ARCH}>" "$<$:${OpenMP_${LANG}_FLAGS}>") set_property(TARGET OpenMPTarget::OpenMPTarget_${DEVICE} PROPERTY INTERFACE_INCLUDE_DIRECTORIES "$") set_property(TARGET OpenMPTarget::OpenMPTarget_${DEVICE} PROPERTY INTERFACE_LINK_LIBRARIES "${OpenMPTarget_${DEVICE}_LIBRARIES}" "${OpenMP_${LANG}_LIBRARIES}") # The offloading flags must also be passed during the linking phase so # the compiler can pass the binary to the correct toolchain. set_property(TARGET OpenMPTarget::OpenMPTarget_${DEVICE} PROPERTY INTERFACE_LINK_OPTIONS "$<$:${OpenMPTarget_${DEVICE}_FLAGS}>" "$<$:${OpenMPTarget_${DEVICE}_ARCH}>" "$<$:${OpenMP_${LANG}_FLAGS}>") # Combine all the flags if not using the target for convenience. set(OpenMPTarget_${DEVICE}_FLAGS ${OpenMP_${LANG}_FLAGS} ${OpenMPTarget_${DEVICE}_FLAGS} ${OpenMPTarget_${DEVICE}_ARCH} CACHE STRING "${DEVICE} target compile flags for OpenMP target offloading" FORCE) endif() endif() endforeach() endforeach() unset(_OpenMPTarget_REQ_VARS) foreach(DEVICE IN LISTS OpenMPTarget_FINDLIST) list(APPEND _OpenMPTarget_REQ_VARS "OpenMPTarget_${DEVICE}_FOUND") endforeach() find_package_handle_standard_args(OpenMPTarget REQUIRED_VARS ${_OpenMPTarget_REQ_VARS} VERSION_VAR ${_OpenMPTarget_MIN_VERSION} HANDLE_COMPONENTS) if(NOT (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED) OR CMAKE_Fortran_COMPILER_LOADED) message(SEND_ERROR "FindOpenMPTarget requires the C or CXX languages to be enabled") endif() unset(OpenMPTarget_C_CXX_TEST_SOURCE) cmake_policy(POP) PK‹`]ÞœØhhlibxml2/libxml2-config.cmakenu„[µü¤# libxml2-config.cmake # -------------------- # # Libxml2 cmake module. # THis module sets the following variables: # # :: # # LIBXML2_INCLUDE_DIRS - Directory where libxml2 headers are located. # LIBXML2_LIBRARIES - xml2 libraries to link against. # LIBXML2_VERSION_MAJOR - The major version of libxml2. # LIBXML2_VERSION_MINOR - The minor version of libxml2. # LIBXML2_VERSION_PATCH - The patch version of libxml2. # LIBXML2_VERSION_STRING - version number as a string (ex: "2.3.4") # LIBXML2_MODULES - whether libxml2 as dso support get_filename_component(_libxml2_rootdir ${CMAKE_CURRENT_LIST_DIR}/../../../ ABSOLUTE) set(LIBXML2_VERSION_MAJOR 2) set(LIBXML2_VERSION_MINOR 9) set(LIBXML2_VERSION_MICRO 7) set(LIBXML2_VERSION_STRING "2.9.7") set(LIBXML2_INSTALL_PREFIX ${_libxml2_rootdir}) set(LIBXML2_INCLUDE_DIRS ${_libxml2_rootdir}/include ${_libxml2_rootdir}/include/libxml2) set(LIBXML2_LIBRARY_DIR ${_libxml2_rootdir}/lib) set(LIBXML2_LIBRARIES -L${LIBXML2_LIBRARY_DIR} -lxml2) if(1) find_package(Threads REQUIRED) list(APPEND LIBXML2_LIBRARIES ${CMAKE_THREAD_LIBS_INIT}) endif() if(1) find_package(LibLZMA REQUIRED) list(APPEND LIBXML2_LIBRARIES ${LIBLZMA_LIBRARIES}) list(APPEND LIBXML2_INCLUDE_DIRS ${LIBLZMA_INCLUDE_DIRS}) endif() if(1) find_package(ZLIB REQUIRED) list(APPEND LIBXML2_LIBRARIES ${ZLIB_LIBRARIES}) list(APPEND LIBXML2_INCLUDE_DIRS ${ZLIB_INCLUDE_DIRS}) endif() list(APPEND LIBXML2_LIBRARIES -lm ) # whether libxml2 has dso support set(LIBXML2_MODULES 1) mark_as_advanced( LIBXML2_INCLUDE_DIRS LIBXML2_LIBRARIES ) PK‹`]Ò´ñPP expat-2.5.0/expat-noconfig.cmakenu„[µü¤PK‹`]ŠzvcÎΠexpat-2.5.0/expat.cmakenu„[µü¤PK‹`]ÖL755µexpat-2.5.0/expat-config.cmakenu„[µü¤PK‹`]¬+wí> > &8"expat-2.5.0/expat-config-version.cmakenu„[µü¤PK‹`]ªZ:>;>;Ì-openmp/FindOpenMPTarget.cmakenu„[µü¤PK‹`]ÞœØhhWilibxml2/libxml2-config.cmakenu„[µü¤PK4 p