cmake CMAKE_CROSSCOMPILING examples

u3d-community/U3D cmake/Modules/UrhoCommon.cmake :303

cmake_dependent_option (URHO3D_CLANG_TOOLS "Build Clang tools (native on host system only)" FALSE "NOT CMAKE_CROSSCOMPILING" FALSE)

mgerhardy/caveexpress cmake/toolchains/windows-toolchain.cmake :4

set(CMAKE_CROSSCOMPILING TRUE)

prusa3d/Prusa-Firmware CMakeLists.txt :655

if(NOT CMAKE_CROSSCOMPILING)

awawa-dev/HyperHDR cmake/installers.cmake :341

install(CODE [[

		set(SYSTEM_LIBS_SKIP
			"libc"
			"libglib-2"
			"libsystemd0"
			"libdl"
			"libexpat"
			"libfontconfig"
			"libgcc_s"
			"libm"
			"libpthread"
			"librt"
			"libstdc++"
			"libudev"
			"libz.so"
			"libxrender1"
			"libxi6"
			"libxext6"
			"libx11-xcb1"
			"libsm"
			"libice6"
			"libdrm2"
			"libxkbcommon0"
			"libwacom2"
			"libmtdev1"
			"libinput10"
			"libgudev-1.0-0"
			"libffi6"
			"libevdev2"
			"libuuid1"
			"libselinux1"
			"libmount1"
			"libblkid1"
			"libwayland"
			"libxcb-icccm4"
			"libxcb-image0"
			"libxcb-keysyms1"
			"libxcb-randr0"
			"libxcb-render-util0"
			"libxcb-render0"
			"libxcb-shape0"
			"libxcb-shm0"
			"libxcb-sync1"
			"libxcb-util0"
			"libxcb-xfixes0"
			"libxcb-xkb1"
			"libxkbcommon-x11-0"
			"ld-"
			"libasound"
			"libblkid"
			"libbrotlicommon"
			"libbrotlidec"
			"libffi"
			"libgio-2"
			"libgmodule-2"
			"libgobject-2"
			"libidn2"
			"libnghttp"
			"libsystemd"
			"libpsl"
			"libunistring"
			"libssh"
			"libselinux"
			"libevent-2"
			"libldap"
			"libutils"
		)

		#message(STATUS "Collecting Dependencies for target file: ${TARGET_FILE}")
		include(GetPrerequisites)		
		# Extract dependencies ignoring the system ones
		if (NOT CMAKE_CROSSCOMPILING)
			# get HyperHDR deps
			file(GET_RUNTIME_DEPENDENCIES
				RESOLVED_DEPENDENCIES_VAR DEPENDENCIES
				EXECUTABLES ${TARGET_FILE}
			)

			# get Systray deps (always present even if it's a dummy implementation)
			file(INSTALL FILES $<TARGET_FILE:systray-widget> DESTINATION "${CMAKE_INSTALL_PREFIX}/share/hyperhdr/lib" TYPE SHARED_LIBRARY)
			file(GET_RUNTIME_DEPENDENCIES
				RESOLVED_DEPENDENCIES_VAR SYS_DEPENDENCIES
				EXECUTABLES $<TARGET_FILE:systray-widget>)
			foreach(systrayLib ${SYS_DEPENDENCIES})
				string(FIND ${systrayLib} "libayatana" _sysindex)
				if (${_sysindex} GREATER -1)
					list(APPEND DEPENDENCIES ${systrayLib})
				endif()
				string(FIND ${systrayLib} "libdbusmenu" _sysDBusindex)
				if (${_sysDBusindex} GREATER -1)
					list(APPEND DEPENDENCIES ${systrayLib})
				endif()
			endforeach()						
		endif()

		# Copy Qt plugins to 'share/hyperhdr/lib/plugins'
		foreach(PLUGIN "tls")
			#message(WARNING "Collecting Dependencies for QT plugin folder: ${PLUGIN}")
			if(EXISTS ${QT_PLUGINS_DIR}/${PLUGIN})
				file(GLOB files "${QT_PLUGINS_DIR}/${PLUGIN}/*openssl*")
				foreach(file ${files})
					file(GET_RUNTIME_DEPENDENCIES
						RESOLVED_DEPENDENCIES_VAR QT_DEPENDENCIES
						EXECUTABLES ${file}
					)
					#message(WARNING "${file} => ${DEPENDENCIES} <= ${QT_DEPENDENCIES}")
					list(APPEND DEPENDENCIES ${QT_DEPENDENCIES})

					file(INSTALL
						DESTINATION "${CMAKE_INSTALL_PREFIX}/share/hyperhdr/lib/plugins/${PLUGIN}"
						TYPE SHARED_LIBRARY
						FILES ${file}
					)
						
				endforeach()
			endif()
		endforeach()

		# Append symlink and non-symlink dependencies to the list		
		foreach(DEPENDENCY ${DEPENDENCIES})
			get_filename_component(resolved ${DEPENDENCY} NAME_WE)
			
			foreach(myitem ${SYSTEM_LIBS_SKIP})
				string(FIND ${resolved} ${myitem} _index)
				if (${_index} EQUAL 0)
					break()									
				endif()
			endforeach()
					
			if (${_index} EQUAL 0)
				continue() # Skip system libraries
			else()
				gp_resolve_item("${TARGET_FILE}" "${DEPENDENCY}" "" "" resolved_file)
				get_filename_component(resolved_file ${resolved_file} ABSOLUTE)
				gp_append_unique(PREREQUISITE_LIBS ${resolved_file})
				get_filename_component(file_canonical ${resolved_file} REALPATH)
				gp_append_unique(PREREQUISITE_LIBS ${file_canonical})
				#message("Basic check added: ${resolved_file} (${resolved})")
			endif()
		endforeach()		

		# Copy dependencies to 'share/hyperhdr/lib/external'
		foreach(PREREQUISITE_LIB ${PREREQUISITE_LIBS})
			set(FILE_TO_INSTALL ${PREREQUISITE_LIB})
			string(FIND ${PREREQUISITE_LIB} "libproxy" libproxyindex)
			string(FIND ${PREREQUISITE_LIB} "libpxbackend" libpxbackendindex)
			if((NOT IS_SYMLINK ${PREREQUISITE_LIB}) AND (${libproxyindex} GREATER -1 OR ${libpxbackendindex} GREATER -1))				
				get_filename_component(pathingFilename ${PREREQUISITE_LIB} NAME)
				set(FILE_TO_INSTALL "${CMAKE_BINARY_DIR}/${pathingFilename}")
				message("Patching RPATH: ${FILE_TO_INSTALL}")
				file(COPY_FILE ${PREREQUISITE_LIB} ${FILE_TO_INSTALL} )				
				execute_process (
					COMMAND bash -c "chrpath -d ${FILE_TO_INSTALL}"
					OUTPUT_VARIABLE outputResult
				)
			endif()
			message("Installing: " ${FILE_TO_INSTALL})
			file(
				INSTALL
				FILES ${FILE_TO_INSTALL}
				DESTINATION "${CMAKE_INSTALL_PREFIX}/share/hyperhdr/lib/external"
				TYPE SHARED_LIBRARY
			)
		endforeach()		
	]] COMPONENT "HyperHDR")

gnuradio/gnuradio gr-utils/CMakeLists.txt :28

endif(NOT CMAKE_CROSSCOMPILING)

audacity/audacity au3/lib-src/libsoxr/CMakeLists.txt :72

cmake_dependent_option (BUILD_LSR_TESTS "Build LSR tests." OFF
  "UNIX;NOT CMAKE_CROSSCOMPILING;EXISTS ${PROJECT_SOURCE_DIR}/lsr-tests;WITH_LSR_BINDINGS" OFF)

aws/aws-sdk-cpp generated/smoke-tests/route53/CMakeLists.txt :38

if(NOT CMAKE_CROSSCOMPILING)

logicalclocks/rondb extra/base64/CMakeLists.txt :52

cmake_dependent_option(BASE64_REGENERATE_TABLES "regenerate the codec tables" OFF "NOT CMAKE_CROSSCOMPILING" OFF)

ornladios/ADIOS2 cmake/upstream/FindPython/Support.cmake :2204

if ((NOT ${_PYTHON_PREFIX}_Interpreter_FOUND OR CMAKE_CROSSCOMPILING)
        AND "CPython" IN_LIST _${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS)

mhx/dwarfs CMakeLists.txt :653

target_compile_definitions(tools_test PRIVATE
      $<$<AND:$<BOOL:${WITH_UNIVERSAL_BINARY}>,$<BOOL:${WITH_TOOLS}>>:DWARFS_HAVE_UNIVERSAL_BINARY>
      $<$<BOOL:${WITH_TOOLS}>:DWARFS_WITH_TOOLS>
      $<$<BOOL:${WITH_FUSE_DRIVER}>:DWARFS_WITH_FUSE_DRIVER>
      $<$<BOOL:${MKDWARFS_EXE}>:MKDWARFS_BINARY=\"${MKDWARFS_EXE}\">
      $<$<BOOL:${DWARFSCK_EXE}>:DWARFSCK_BINARY=\"${DWARFSCK_EXE}\">
      $<$<BOOL:${DWARFSEXTRACT_EXE}>:DWARFSEXTRACT_BINARY=\"${DWARFSEXTRACT_EXE}\">
      $<$<BOOL:${CMAKE_CROSSCOMPILING}>:DWARFS_CROSSCOMPILING_EMULATOR=\"${CMAKE_CROSSCOMPILING_EMULATOR}\">
    )

cwida/ALP CMakeLists.txt :28

cmake_print_variables(
            CMAKE_SYSTEM_PROCESSOR
            CMAKE_SYSTEM_NAME
            CMAKE_VERSION
            CMAKE_BUILD_TYPE
            CMAKE_CXX_COMPILER
            CMAKE_CXX_COMPILER_VERSION
            CMAKE_CXX_STANDARD
            CMAKE_SYSTEM
            CMAKE_HOST_SYSTEM_NAME
            CMAKE_HOST_SYSTEM_PROCESSOR
            CMAKE_GENERATOR
            CMAKE_BINARY_DIR
            CMAKE_SOURCE_DIR
            CMAKE_LINKER
            CMAKE_CXX_FLAGS
            CMAKE_C_FLAGS
            CMAKE_CROSSCOMPILING
    )

cwida/FastLanes publications/data_parallelized_encodings/CMakeLists.txt :132

cmake_print_variables(CMAKE_CROSSCOMPILING)

usb-tools/USBProxy-legacy src/lib/CMakeLists.txt :94

IF(CMAKE_CROSSCOMPILING)

trailofbits/maat CMakeLists.txt :158

if(CMAKE_CROSSCOMPILING)

swiftlang/swift CMakeLists.txt :1649

ExternalProject_Add("${stdlib_target}-core"
        SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Runtimes/Core"
        # TODO: Add this once we're ready to start swapping out the libraries
        #       for testing
        # INSTALL_DIR "${CMAKE_BINARY_DIR}/"

        DEPENDS PopulateRuntimeSourceDir
        # To ensure incremental builds work as expected
        BUILD_ALWAYS 1
        CMAKE_ARGS
          -DCMAKE_INSTALL_LIBDIR:FILEPATH=lib
          # Compiler will see mismatched swift modules and fail initial checks
          -DCMAKE_Swift_COMPILER_WORKS:BOOLEAN=YES
          -DBUILD_SHARED_LIBS:BOOLEAN=YES # TODO: Make this configurable
          ${stdlib_cache_file_flag}
          ${stdlib_deployment_version_flag}
          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
          -DCMAKE_INSTALL_PREFIX:FILEPATH=<INSTALL_DIR>
          -DCMAKE_Swift_COMPILER:FILEPATH=$<IF:$<BOOL:${CMAKE_CROSSCOMPILING}>,${CMAKE_Swift_COMPILER},$<PATH:REPLACE_FILENAME,$<TARGET_FILE:swift-frontend>,swiftc>>
          -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
          -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
          -DCMAKE_Swift_COMPILER_TARGET:STRING=${stdlib_target_triple}
          -DCMAKE_C_COMPILER_TARGET:STRING=${stdlib_target_triple}
          -DCMAKE_CXX_COMPILER_TARGET:STRING=${stdlib_target_triple}
          -DCMAKE_COLOR_DIAGNOSTICS:BOOLEAN=${CMAKE_COLOR_DIAGNOSTICS}
          -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
          -DSwiftCore_INSTALL_NESTED_SUBDIR=YES
          -DSwiftCore_ENABLE_CONCURRENCY=${build_concurrency})

MeltwaterArchive/served src/served/CMakeLists.txt :56

ELSE (CMAKE_CROSSCOMPILING)

o2e/OLLVM-9.0.1 cmake/modules/CrossCompile.cmake :26

if (LLVM_USE_LINKER AND NOT CMAKE_CROSSCOMPILING)

qt/qtwebengine tests/auto/widgets/proxypac/CMakeLists.txt :51

if(LINUX AND CMAKE_CROSSCOMPILING)

Sneeds-Feed-and-Seed/sneedacity lib-src/libsoxr/CMakeLists.txt :72

cmake_dependent_option (BUILD_LSR_TESTS "Build LSR tests." OFF
  "UNIX;NOT CMAKE_CROSSCOMPILING;EXISTS ${PROJECT_SOURCE_DIR}/lsr-tests;WITH_LSR_BINDINGS" OFF)

SWI-Prolog/swipl-devel cmake/Ports.cmake :98

else(CMAKE_CROSSCOMPILING)

DynamoRIO/dynamorio clients/drcpusim/CMakeLists.txt :122

add_custom_command(
  OUTPUT ${gendoc}
  DEPENDS ${srcdoc}
  drcpusim_ops
  options.h
  COMMAND ${CMAKE_COMMAND}
  ARGS -D src=${srcdoc}
       -D dst=${gendoc}
       -D CMAKE_CROSSCOMPILING=${CMAKE_CROSSCOMPILING}
       -D prog=$<TARGET_FILE:drcpusim_ops>
       -P ${CMAKE_CURRENT_SOURCE_DIR}/../common/gendocs.cmake
  VERBATIM)

embeddedartistry/libc BuildOptions.cmake :36

CMAKE_DEPENDENT_OPTION(LIBC_BUILD_TESTING
  "Enable libc testing even when used as an external project."
  OFF
  "NOT CMAKE_CROSSCOMPILING" OFF)

szcom/rnnlib hdf5_snap/config/cmake/ConfigureChecks.cmake :863

else (CMAKE_CROSSCOMPILING AND "${HAVE_IOEO_EXITCODE}" MATCHES  "FAILED_TO_RUN")