FindHIP: First version of re-implementation

Change-Id: I84332a0f7d89271bf9370dbcd19d893119e738f9


[ROCm/hip commit: b0621a4794]

projects/hip/bin/hipcc

@@ -168,6 +168,8 @@ my $hasCU = 0;         # options contain a cu-style file (HCC must force recogni
 my $needHipHcc = ($HIP_PLATFORM eq 'hcc');      # set if we need to link hip_hcc.o from src tree. (some builds, ie cmake, provide their own)
 my $printHipVersion = 0;    # print HIP version
 my $runCmd = 1;
+my $buildDeps = 0;
+
 
 my @options = ();
 my @inputs  = ();
@@ -240,6 +242,10 @@ foreach $arg (@ARGV)
         $printHipVersion = 1;
         $runCmd = 0;
     }
+    if($arg eq '-M') {
+        $compileOnly = 1;
+        $buildDeps = 1;
+    }
 
     if ($arg =~ m/^-/) {
         # options start with -
@@ -278,6 +284,9 @@ if ($hasC and $HIP_PLATFORM eq 'nvcc') {
 if ($hasCU and $HIP_PLATFORM eq 'hcc') {
     $HIPCXXFLAGS .= " -x c++";
 }
+if ($buildDeps and $HIP_PLATFORM eq 'nvcc') {
+    $HIPCXXFLAGS .= " -M -D__CUDACC__";
+}
 
 if ($setStdLib eq 0 and $HIP_PLATFORM eq 'hcc')
 {

projects/hip/cmake/CMakeLists.txt

@@ -1,12 +0,0 @@
-
-
-#Our FindHCC is in the same directory as the this CMakeLists.txt, which is CMAKE_SOURCE_DIR
-# Let cmake know where to find FindHCC.cmake
-#
-
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR})
-
-find_package(HIP REQUIRED)
-
-message(STATUS "HIP_PLATFORM = ${HIP_PLATFORM}")
-

projects/hip/cmake/FindHCC.cmake

@@ -1,73 +0,0 @@
-
-# findHCC does not currently address versioning, i.e.
-# a rich directory structure where version number is a subdirectory under root
-# Also, supported only on UNIX 64 bit systems.
-
-if(UNIX)
-	if(CMAKE_SIZEOF_VOID_P EQUAL 8)  
-  
-		find_library(HSA_LIBRARY
-			NAMES  hsa-runtime64
-			PATHS
-			  ENV HSA_PATH
-			  /opt/rocm/hsa
-			PATH_SUFFIXES
-			  lib)
-		
-		if( NOT DEFINED ENV{HSA_PATH} )
-			set( ENV{HSA_PATH} /opt/rocm/hsa)
-		endif()
-		
-		find_program(HCC
-			NAMES  hcc
-			PATHS
-				ENV HCC_PATH
-				/opt/rocm/hcc
-			PATH_SUFFIXES
-				/bin)
-
-		if( NOT DEFINED  ENV{HCC_PATH} )
-			set( ENV{HCC_PATH} /opt/rocm/hcc)
-		endif()
-		
-# this is now dynamic
-#		find_library(AMP_LIBRARY
-#			NAMES  mcwamp
-#			PATHS
-#				ENV NCC_PATH
-#				/opt/rocm/hcc
-#			PATH_SUFFIXES
-#				/lib)
-				
-		find_path(HCC_INCLUDE_DIR
-			NAMES
-				hc.hpp
-			PATHS
-				ENV NCC_PATH
-				/opt/rocm/hcc
-			PATH_SUFFIXES
-				/include)				
-				
-			  
-
-		set(HSA_LIBRARIES ${HSA_LIBRARY})
-		#set(HCC_LIBRARIES ${AMP_LIBRARY})
-		set(HCC_INCLUDE_DIRS ${HCC_INCLUDE_DIR})
-
-		include(FindPackageHandleStandardArgs)
-		find_package_handle_standard_args(
-		  HCC
-		  FOUND_VAR HCC_FOUND
-		  REQUIRED_VARS HSA_LIBRARIES HCC_INCLUDE_DIRS HCC)
-
-		mark_as_advanced(
-		  HSA_LIBRARIES
-		  HCC_INCLUDE_DIRS
-		)
-
-	else()
-		message(SEND_ERROR "HCC is currently supported only on 64 bit UNIX platforms")
-	endif()
-else()
-	message(SEND_ERROR "HCC is currently supported on unix platforms")
-endif()

projects/hip/cmake/FindHIP.cmake

@@ -1,56 +1,463 @@
+###############################################################################
+# FindHIP.cmake
+###############################################################################
 
-find_package(CUDA)
+###############################################################################
+# SET: Variable defaults
+###############################################################################
+# User defined flags
+set(HIP_HIPCC_FLAGS "" CACHE STRING "Semicolon delimited flags for HIPCC")
+set(HIP_HCC_FLAGS "" CACHE STRING "Semicolon delimited flags for HCC")
+set(HIP_NVCC_FLAGS "" CACHE STRING "Semicolon delimted flags for NVCC")
+mark_as_advanced(HIP_HIPCC_FLAGS HIP_HCC_FLAGS HIP_NVCC_FLAGS)
+set(_hip_configuration_types ${CMAKE_CONFIGURATION_TYPES} ${CMAKE_BUILD_TYPE} Debug MinSizeRel Release RelWithDebInfo)
+list(REMOVE_DUPLICATES _hip_configuration_types)
+foreach(config ${_hip_configuration_types})
+    string(TOUPPER ${config} config_upper)
+    set(HIP_HIPCC_FLAGS_${config_upper} "" CACHE STRING "Semicolon delimited flags for HIPCC")
+    set(HIP_HCC_FLAGS_${config_upper} "" CACHE STRING "Semicolon delimited flags for HCC")
+    set(HIP_NVCC_FLAGS_${config_upper} "" CACHE STRING "Semicolon delimited flags for NVCC")
+    mark_as_advanced(HIP_HIPCC_FLAGS_${config_upper} HIP_HCC_FLAGS_${config_upper} HIP_NVCC_FLAGS_${config_upper})
+endforeach()
+option(HIP_HOST_COMPILATION_CPP "Host code compilation mode" ON)
+mark_as_advanced(HIP_HOST_COMPILATION_CPP)
 
-if( CUDA_INCLUDE_DIRS AND CUDA_VERSION AND CUDA_NVCC_EXECUTABLE)
+###############################################################################
-	message(STATUS "CUDA_VERSION = ${CUDA_VERSION}")
+# FIND: HIP and associated helper binaries
-	message(STATUS "CUDA_INCLUDE_DIRS = ${CUDA_INCLUDE_DIRS}")
+###############################################################################
-	message(STATUS "CUDA_NVCC_EXECUTABLE = ${CUDA_NVCC_EXECUTABLE}")
+# HIP is supported on Linux only
-	
+if(UNIX AND NOT APPLE AND NOT CYGWIN)
-    set( HIP_PLATFORM "nvcc" )
+    # Search for HIP installation
-	
+    if(NOT HIP_ROOT_DIR)
-	#export the environment variable, so that HIPCC can find it.
+        # Search in user specified path first
-    set(ENV{HIP_PLATFORM} nvcc)
+        find_path(
-	
+            HIP_ROOT_DIR
-else()
+            NAMES hipconfig
-	find_package(HCC)
+            PATHS
-	
+            ENV ROCM_PATH
-	message(STATUS "HCC_FOUND = ${HCC_FOUND}")
+            ENV HIP_PATH
-	message(STATUS "HCC = ${HCC}")
+            PATH_SUFFIXES bin
-	message(STATUS "HCC_INCLUDE_DIRS = ${HCC_INCLUDE_DIRS}")
+            DOC "HIP installed location"
-	message(STATUS "HSA_LIBRARIES = ${HSA_LIBRARIES}")
+            NO_DEFAULT_PATH
+            )
+        # Now search in default path
+        find_path(
+            HIP_ROOT_DIR
+            NAMES hipconfig
+            PATHS
+            /opt/rocm
+            /opt/rocm/hip
+            PATH_SUFFIXES bin
+            DOC "HIP installed location"
+            )
 
-	if( ${HCC_FOUND} STREQUAL  "TRUE" )
+        # Check if we found HIP installation
-	
+        if(HIP_ROOT_DIR)
-	# This directory is hip/cmake! HIP_PATH should be one directory up!
+            # If so, fix the path
-		set (HIP_PATH $ENV{HIP_PATH})
+            string(REGEX REPLACE "[/\\\\]?bin[64]*[/\\\\]?$" "" HIP_ROOT_DIR ${HIP_ROOT_DIR})
-		if (NOT DEFINED HIP_PATH)
+            # And push it back to the cache
-			set (HIP_PATH ${CMAKE_CURRENT_SOURCE_DIR}/..)
+            set(HIP_ROOT_DIR ${HIP_ROOT_DIR} CACHE PATH "HIP installed location" FORCE)
-			set( ENV{HIP_PATH} ${HIP_PATH})
+        endif()
-		endif()
+        if(NOT EXISTS ${HIP_ROOT_DIR})
+            if(HIP_FIND_REQUIRED)
+                message(FATAL_ERROR "Specify HIP_ROOT_DIR")
+            elseif(NOT HIP_FIND_QUIETLY)
+                message("HIP_ROOT_DIR not found or specified")
+            endif()
+        endif()
+    endif()
 
-		message(STATUS "ENV HIP_PATH = $ENV{HIP_PATH}")
+    # Find HIPCC executable
-		
+    find_program(
-		find_program(HIPCC
+        HIP_HIPCC_EXECUTABLE
-			NAMES  hipcc
+        NAMES hipcc
-			PATHS
+        PATHS
-				ENV HIP_PATH
+        "${HIP_ROOT_DIR}"
-			PATH_SUFFIXES
+        ENV ROCM_PATH
-				/bin)
+        ENV HIP_PATH
-			
+        /opt/rocm
-			message(STATUS "HIPCC = ${HIPCC}")
+        /opt/rocm/hip
-			
+        PATH_SUFFIXES bin
-		if( DEFINED HIPCC)
+        NO_DEFAULT_PATH
-		
+        )
-            set( HIP_PLATFORM "hcc" )		
+    if(NOT HIP_HIPCC_EXECUTABLE)
-			#export the environment variable, so that HIPCC can find it.
+        # Now search in default paths
-            set(ENV{HIP_PLATFORM} "hcc")	
+        find_program(HIP_HIPCC_EXECUTABLE hipcc)
-			set (CMAKE_CXX_COMPILER ${HIPCC})
+    endif()
-			
+    mark_as_advanced(HIP_HIPCC_EXECUTABLE)
-		else()
+
-			message(SEND_ERROR "Did not find HIPCC")
+    # Find HIPCONFIG executable
-		endif()
+    find_program(
-	else()
+        HIP_HIPCONFIG_EXECUTABLE
-		message(SEND_ERROR "hcc not found")
+        NAMES hipconfig
-	endif()
+        PATHS
-	
+        "${HIP_ROOT_DIR}"
+        ENV ROCM_PATH
+        ENV HIP_PATH
+        /opt/rocm
+        /opt/rocm/hip
+        PATH_SUFFIXES bin
+        NO_DEFAULT_PATH
+        )
+    if(NOT HIP_HIPCONFIG_EXECUTABLE)
+        # Now search in default paths
+        find_program(HIP_HIPCONFIG_EXECUTABLE hipconfig)
+    endif()
+    mark_as_advanced(HIP_HIPCONFIG_EXECUTABLE)
+
+    if(HIP_HIPCONFIG_EXECUTABLE AND NOT HIP_VERSION)
+        # Compute the version
+        execute_process(
+            COMMAND ${HIP_HIPCONFIG_EXECUTABLE} --version
+            OUTPUT_VARIABLE _hip_version
+            ERROR_VARIABLE _hip_error
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            ERROR_STRIP_TRAILING_WHITESPACE
+            )
+        if(NOT _hip_error)
+            set(HIP_VERSION ${_hip_version} CACHE STRING "Version of HIP as computed from hipcc")
+        else()
+            set(HIP_VERSION "0.0.0" CACHE STRING "Version of HIP as computed by FindHIP()")
+        endif()
+        mark_as_advanced(HIP_VERSION)
+    endif()
+    if(HIP_VERSION)
+        string(REPLACE "." ";" _hip_version_list "${HIP_VERSION}")
+        list(GET _hip_version_list 0 HIP_VERSION_MAJOR)
+        list(GET _hip_version_list 1 HIP_VERSION_MINOR)
+        list(GET _hip_version_list 2 HIP_VERSION_PATCH)
+        set(HIP_VERSION_STRING "${HIP_VERSION}")
+    endif()
+
+    if(HIP_HIPCONFIG_EXECUTABLE AND NOT HIP_PLATFORM)
+        # Compute the platform
+        execute_process(
+            COMMAND ${HIP_HIPCONFIG_EXECUTABLE} --platform
+            OUTPUT_VARIABLE _hip_platform
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            )
+        set(HIP_PLATFORM ${_hip_platform} CACHE STRING "HIP platform as computed by hipconfig")
+        mark_as_advanced(HIP_PLATFORM)
+    endif()
 endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+    HIP
+    REQUIRED_VARS
+    HIP_ROOT_DIR
+    HIP_HIPCC_EXECUTABLE
+    HIP_HIPCONFIG_EXECUTABLE
+    HIP_PLATFORM
+    VERSION_VAR HIP_VERSION
+    )
+
+###############################################################################
+# MACRO: Locate helper files
+###############################################################################
+macro(HIP_FIND_HELPER_FILE _name _extension)
+    set(_hip_full_name "${_name}.${_extension}")
+    get_filename_component(CMAKE_CURRENT_LIST_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+    set(HIP_${_name} "${CMAKE_CURRENT_LIST_DIR}/FindHIP/${_hip_full_name}")
+    if(NOT EXISTS "${HIP_${_name}}")
+        set(error_message "${_hip_full_name} not found in ${CMAKE_CURRENT_LIST_DIR}/FindHIP")
+        if(HIP_FIND_REQUIRED)
+            message(FATAL_ERROR "${error_message}")
+        else()
+            if(NOT HIP_FIND_QUIETLY)
+                message(STATUS "${error_message}")
+            endif()
+        endif()
+    endif()
+    # Set this variable as internal, so the user isn't bugged with it.
+    set(HIP_${_name} ${HIP_${_name}} CACHE INTERNAL "Location of ${_full_name}" FORCE)
+endmacro()
+
+###############################################################################
+hip_find_helper_file(run_make2cmake cmake)
+hip_find_helper_file(run_hipcc cmake)
+###############################################################################
+
+###############################################################################
+# MACRO: Seperate the options from the sources
+###############################################################################
+macro(HIP_GET_SOURCES_AND_OPTIONS _sources _cmake_options _hipcc_options _hcc_options _nvcc_options)
+    set(${_sources})
+    set(${_cmake_options})
+    set(${_hipcc_options})
+    set(${_hcc_options})
+    set(${_nvcc_options})
+    set(_hipcc_found_options FALSE)
+    set(_hcc_found_options FALSE)
+    set(_nvcc_found_options FALSE)
+    foreach(arg ${ARGN})
+        if("x${arg}" STREQUAL "xHIPCC_OPTIONS")
+            set(_hipcc_found_options TRUE)
+        elseif("x${arg}" STREQUAL "xHCC_OPTIONS")
+            set(_hcc_found_options TRUE)
+        elseif("x${arg}" STREQUAL "xNVCC_OPTIONS")
+            set(_nvcc_found_options TRUE)
+        elseif(
+                "x${arg}" STREQUAL "xEXCLUDE_FROM_ALL" OR
+                "x${arg}" STREQUAL "xSTATIC" OR
+                "x${arg}" STREQUAL "xSHARED" OR
+                "x${arg}" STREQUAL "xMODULE"
+                )
+            list(APPEND ${_cmake_options} ${arg})
+        else()
+            if(_hipcc_found_options)
+                list(APPEND ${_hipcc_options} ${arg})
+            elseif(_hcc_found_options)
+                list(APPEND ${_hcc_options} ${arg})
+            elseif(_nvcc_found_options)
+                list(APPEND ${_nvcc_options} ${arg})
+            else()
+                # Assume this is a file
+                list(APPEND ${_sources} ${arg})
+            endif()
+        endif()
+    endforeach()
+endmacro()
+
+###############################################################################
+# MACRO: Add include directories to pass to the hipcc command
+###############################################################################
+set(HIP_HIPCC_INCLUDE_ARGS_USER "")
+macro(HIP_INCLUDE_DIRECTORIES)
+    foreach(dir ${ARGN})
+        list(APPEND HIP_HIPCC_INCLUDE_ARGS_USER -I${dir})
+    endforeach()
+endmacro()
+
+###############################################################################
+# FUNCTION: Helper to avoid clashes of files with the same basename but different paths
+###############################################################################
+function(HIP_COMPUTE_BUILD_PATH path build_path)
+    # Convert to cmake style paths
+    file(TO_CMAKE_PATH "${path}" bpath)
+    if (IS_ABSOLUTE "${bpath}")
+        string(FIND "${bpath}" "${CMAKE_CURRENT_BINARY_DIR}" _binary_dir_pos)
+        if (_binary_dir_pos EQUAL 0)
+            file(RELATIVE_PATH bpath "${CMAKE_CURRENT_BINARY_DIR}" "${bpath}")
+        else()
+            file(RELATIVE_PATH bpath "${CMAKE_CURRENT_SOURCE_DIR}" "${bpath}")
+        endif()
+    endif()
+
+    # Remove leading /
+    string(REGEX REPLACE "^[/]+" "" bpath "${bpath}")
+    # Avoid absolute paths by removing ':'
+    string(REPLACE ":" "_" bpath "${bpath}")
+    # Avoid relative paths that go up the tree
+    string(REPLACE "../" "__/" bpath "${bpath}")
+    # Avoid spaces
+    string(REPLACE " " "_" bpath "${bpath}")
+    # Strip off the filename
+    get_filename_component(bpath "${bpath}" PATH)
+
+    set(${build_path} "${bpath}" PARENT_SCOPE)
+endfunction()
+
+###############################################################################
+# MACRO: Parse OPTIONS from ARGN & set variables prefixed by _option_prefix
+###############################################################################
+macro(HIP_PARSE_HIPCC_OPTIONS _option_prefix)
+    set(_hip_found_config)
+    foreach(arg ${ARGN})
+        # Determine if we are dealing with a per-configuration flag
+        foreach(config ${_hip_configuration_types})
+            string(TOUPPER ${config} config_upper)
+            if(arg STREQUAL "${config_upper}")
+                set(_hip_found_config _${arg})
+                # Clear arg to prevent it from being processed anymore
+                set(arg)
+            endif()
+        endforeach()
+        if(arg)
+            list(APPEND ${_option_prefix}${_hip_found_config} "${arg}")
+        endif()
+    endforeach()
+endmacro()
+
+###############################################################################
+# MACRO: Try and include dependency file if it exists
+###############################################################################
+macro(HIP_INCLUDE_HIPCC_DEPENDENCIES dependency_file)
+    set(HIP_HIPCC_DEPEND)
+    set(HIP_HIPCC_DEPEND_REGENERATE FALSE)
+
+    # Create the dependency file if it doesn't exist
+    if(NOT EXISTS ${dependency_file})
+        file(WRITE ${dependency_file} "# Generated by: FindHIP.cmake. Do not edit.\n")
+    endif()
+    # Include the dependency file
+    include(${dependency_file})
+
+    # Verify the existence of all the included files
+    if(HIP_HIPCC_DEPEND)
+        foreach(f ${HIP_HIPCC_DEPEND})
+            if(NOT EXISTS ${f})
+                # If they aren't there, regenerate the file again
+                set(HIP_HIPCC_DEPEND_REGENERATE TRUE)
+            endif()
+        endforeach()
+    else()
+        # No dependencies, so regenerate the file
+        set(CUDA_NVCC_DEPEND_REGENERATE TRUE)
+    endif()
+
+    # Regenerate the dependency file if needed
+    if(HIP_HIPCC_DEPEND_REGENERATE)
+        set(HIP_HIPCC_DEPEND ${dependency_file})
+        file(WRITE ${dependency_file} "# Generated by: FindHIP.cmake. Do not edit.\n")
+    endif()
+endmacro()
+
+###############################################################################
+# MACRO: Prepare cmake commands for the target
+###############################################################################
+macro(HIP_PREPARE_TARGET_COMMANDS _target _format _generated_files)
+    set(_hip_flags "")
+    set(_hip_build_configuration "${CMAKE_BUILD_TYPE}")
+    if(HIP_HOST_COMPILATION_CPP)
+        set(HIP_C_OR_CXX CXX)
+    else()
+        set(HIP_C_OR_CXX C)
+    endif()
+    set(generated_extension ${CMAKE_${HIP_C_OR_CXX}_OUTPUT_EXTENSION})
+
+    # Initialize list of includes with those specified by the user. Append with
+    # ones specified to cmake directly.
+    set(HIP_HIPCC_INCLUDE_ARGS ${HIP_HIPCC_INCLUDE_ARGS_USER})
+    get_directory_property(_hip_include_directories INCLUDE_DIRECTORIES)
+    list(REMOVE_DUPLICATES _hip_include_directories)
+    if(_hip_include_directories)
+        foreach(dir ${_hip_include_directories})
+            list(APPEND HIP_HIPCC_INCLUDE_ARGS -I${dir})
+        endforeach()
+    endif()
+
+    HIP_GET_SOURCES_AND_OPTIONS(_hip_sources _hip_cmake_options _hipcc_options _hcc_options _nvcc_options ${ARGN})
+    HIP_PARSE_HIPCC_OPTIONS(HIP_HIPCC_FLAGS ${_hipcc_options})
+    HIP_PARSE_HIPCC_OPTIONS(HIP_HCC_FLAGS ${_hcc_options})
+    HIP_PARSE_HIPCC_OPTIONS(HIP_NVCC_FLAGS ${_nvcc_options})
+
+    # Set host compiler
+    set(HIP_HOST_COMPILER "${CMAKE_${HIP_C_OR_CXX}_COMPILER}")
+
+    # Set compiler flags
+    set(_HIP_HOST_FLAGS "set(CMAKE_HOST_FLAGS ${CMAKE_${HIP_C_OR_CXX}_FLAGS})")
+    set(_HIP_HIPCC_FLAGS "set(HIP_HIPCC_FLAGS ${HIP_HIPCC_FLAGS})")
+    set(_HIP_HCC_FLAGS "set(HIP_HCC_FLAGS ${HIP_HCC_FLAGS})")
+    set(_HIP_NVCC_FLAGS "set(HIP_NVCC_FLAGS ${HIP_NVCC_FLAGS})")
+    foreach(config ${_hip_configuration_types})
+        string(TOUPPER ${config} config_upper)
+        set(_HIP_HOST_FLAGS "${_HIP_HOST_FLAGS}\nset(CMAKE_HOST_FLAGS_${config_upper} ${CMAKE_${HIP_C_OR_CXX}_FLAGS_${config_upper}})")
+        set(_HIP_HIPCC_FLAGS "${_HIP_HIPCC_FLAGS}\nset(HIP_HIPCC_FLAGS_${config_upper} ${HIP_HIPCC_FLAGS_${config_upper}})")
+        set(_HIP_HCC_FLAGS "${_HIP_HCC_FLAGS}\nset(HIP_HCC_FLAGS_${config_upper} ${HIP_HCC_FLAGS_${config_upper}})")
+        set(_HIP_NVCC_FLAGS "${_HIP_NVCC_FLAGS}\nset(HIP_NVCC_FLAGS_${config_upper} ${HIP_NVCC_FLAGS_${config_upper}})")
+    endforeach()
+
+    # Reset the output variable
+    set(_hip_generated_files "")
+
+    # Iterate over all arguments and create custom commands for all source files
+    foreach(file ${ARGN})
+        # Ignore any file marked as a HEADER_FILE_ONLY
+        get_source_file_property(_is_header ${file} HEADER_FILE_ONLY)
+        # Allow per source file overrides of the format. Also allows compiling non .cu files.
+        get_source_file_property(_hip_source_format ${file} HIP_SOURCE_PROPERTY_FORMAT)
+        if((${file} MATCHES "\\.cu$" OR _hip_source_format) AND NOT _is_header)
+            set(host_flag FALSE)
+        else()
+            set(host_flag TRUE)
+        endif()
+
+        if (NOT host_flag)
+        # Determine output directory
+        HIP_COMPUTE_BUILD_PATH("${file}" hip_build_path)
+        set(hip_compile_output_dir "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_target}.dir/${hip_build_path}")
+
+        get_filename_component(basename ${file} NAME)
+        set(generated_file_path "${hip_compile_output_dir}/${CMAKE_CFG_INTDIR}")
+        set(generated_file_basename "${_target}_generated_${basename}${generated_extension}")
+
+        # Set file names
+        set(generated_file "${generated_file_path}/${generated_file_basename}")
+        set(cmake_dependency_file "${hip_compile_output_dir}/${generated_file_basename}.depend")
+        set(custom_target_script_pregen "${hip_compile_output_dir}/${generated_file_basename}.cmake.pre-gen")
+        set(custom_target_script "${hip_compile_output_dir}/${generated_file_basename}.cmake")
+
+        # Set properties for object files
+        set_source_files_properties("${generated_file}"
+            PROPERTIES
+            EXTERNAL_OBJECT true # This is an object file not to be compiled, but only be linked
+            )
+
+        # Don't add CMAKE_CURRENT_SOURCE_DIR if the path is already an absolute path
+        get_filename_component(file_path "${file}" PATH)
+        if(IS_ABSOLUTE "${file_path}")
+            set(source_file "${file}")
+        else()
+            set(source_file "${CMAKE_CURRENT_SOURCE_DIR}/${file}")
+        endif()
+
+        # Bring in the dependencies
+        HIP_INCLUDE_HIPCC_DEPENDENCIES(${cmake_dependency_file})
+
+        # Configure the build script
+        configure_file("${HIP_run_hipcc}" "${custom_target_script_pregen}" @ONLY)
+        file(GENERATE
+            OUTPUT "${custom_target_script}"
+            INPUT "${custom_target_script_pregen}"
+            )
+        set(main_dep DEPENDS ${source_file})
+        set(verbose_output "$(VERBOSE)")
+
+        # Create up the comment string
+        file(RELATIVE_PATH generated_file_relative_path "${CMAKE_BINARY_DIR}" "${generated_file}")
+        set(hip_build_comment_string "Building HIPCC (${cuda_build_type}) object ${generated_file_relative_path}")
+
+        # Build the generated file and dependency file
+        add_custom_command(
+            OUTPUT ${generated_file}
+            # These output files depend on the source_file and the contents of cmake_dependency_file
+            ${main_dep}
+            DEPENDS ${HIP_HIPCC_DEPEND}
+            DEPENDS ${custom_target_script}
+            # Make sure the output directory exists before trying to write to it.
+            COMMAND ${CMAKE_COMMAND} -E make_directory "${generated_file_path}"
+            COMMAND ${CMAKE_COMMAND} ARGS
+            -D verbose:BOOL=${verbose_output}
+            -D build_configuration:STRING=${_hip_build_configuration}
+            -D "generated_file:STRING=${generated_file}"
+            -P "${custom_target_script}"
+            WORKING_DIRECTORY "${hip_compile_output_dir}"
+            COMMENT "${hip_build_comment_string}"
+            )
+
+        # Make sure the build system knows the file is generated
+        set_source_files_properties(${generated_file} PROPERTIES GENERATED TRUE)
+        list(APPEND _hip_generated_files ${generated_file})
+        endif()
+    endforeach()
+
+    # Set the return parameter
+    set(${_generated_files} ${_hip_generated_files})
+endmacro()
+
+###############################################################################
+# HIP_ADD_EXECUTABLE
+###############################################################################
+macro(HIP_ADD_EXECUTABLE hip_target)
+    # Separate the sources from the options
+    HIP_GET_SOURCES_AND_OPTIONS(_sources _cmake_options _hipcc_options _hcc_options _nvcc_options ${ARGN})
+    HIP_PREPARE_TARGET_COMMANDS(${hip_target} OBJ _generated_files ${_sources} HIPCC_OPTIONS ${_hipcc_options} HCC_OPTIONS ${_hcc_options} NVCC_OPTIONS ${_nvcc_options})
+    set(HIP_CMAKE_CXX_LINK_EXECUTABLE ${CMAKE_CXX_LINK_EXECUTABLE})
+    set(CMAKE_CXX_LINK_EXECUTABLE "${HIP_HIPCC_EXECUTABLE} <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET>")
+    add_executable(${hip_target} ${_cmake_options} ${_generated_files} ${_sources})
+    set_target_properties(${hip_target} PROPERTIES LINKER_LANGUAGE ${HIP_C_OR_CXX})
+    #set(CMAKE_CXX_COMPILER ${ORIGINAL_CMAKE_CXX_COMPILER})
+endmacro()
+
+# vim: ts=4:sw=4:expandtab:smartindent

projects/hip/cmake/FindHIP/run_hipcc.cmake

@@ -0,0 +1,163 @@
+###############################################################################
+# Runs commands using HIPCC
+###############################################################################
+
+###############################################################################
+# This file runs the hipcc commands to produce the desired output file
+# along with the dependency file needed by CMake to compute dependencies.
+#
+# Input variables:
+#
+# verbose:BOOL=<>               OFF: Be as quiet as possible (default)
+#                               ON : Describe each step
+# build_configuration:STRING=<> Build configuration. Defaults to Debug.
+# generated_file:STRING=<>      File to generate. Mandatory argument.
+
+if(NOT build_configuration)
+    set(build_configuration Debug)
+endif()
+if(NOT generated_file)
+    message(FATAL_ERROR "You must specify generated_file on the command line")
+endif()
+
+# Set these up as variables to make reading the generated file easier
+set(HIP_HIPCC_EXECUTABLE "@HIP_HIPCC_EXECUTABLE@") # path
+set(HIP_HOST_COMPILER "@CUDA_HOST_COMPILER@") # path
+set(HIP_PLATFORM "@HIP_PLATFORM@") #string
+set(CMAKE_COMMAND "@CMAKE_COMMAND@") # path
+set(HIP_run_make2cmake "@HIP_run_make2cmake@") # path
+
+@HIP_HOST_FLAGS@
+@_HIP_HIPCC_FLAGS@
+@_HIP_HCC_FLAGS@
+@_HIP_NVCC_FLAGS@
+set(HIP_HIPCC_INCLUDE_ARGS "@HIP_HIPCC_INCLUDE_ARGS@") # list (needs to be in quotes to handle spaces properly)
+
+set(cmake_dependency_file "@cmake_dependency_file@") # path
+set(source_file "@source_file@") # path
+set(host_flag "@host_flag@") # bool
+
+# Determine compiler and compiler flags
+if(NOT host_flag)
+    set(__CC ${HIP_HIPCC_EXECUTABLE})
+    if(HIP_PLATFORM STREQUAL "hcc")
+        set(__CC_FLAGS ${HIP_HIPCC_FLAGS} ${HIP_HCC_FLAGS} ${HIP_HIPCC_FLAGS_${build_configuration}} ${HIP_HCC_FLAGS_${build_configuration}})
+    else()
+        set(__CC_FLAGS ${HIP_HIPCC_FLAGS} ${HIP_NVCC_FLAGS} ${HIP_HIPCC_FLAGS_${build_configuration}} ${HIP_NVCC_FLAGS_${build_configuration}})
+    endif()
+else()
+    set(__CC ${HIP_HOST_COMPILER})
+    set(__CC_FLAGS ${CMAKE_HOST_FLAGS} ${CMAKE_HOST_FLAGS_${build_configuration}})
+endif()
+set(__CC_INCLUDES ${HIP_HIPCC_INCLUDE_ARGS})
+
+# hip_execute_process - Executes a command with optional command echo and status message.
+#   status     - Status message to print if verbose is true
+#   command    - COMMAND argument from the usual execute_process argument structure
+#   ARGN       - Remaining arguments are the command with arguments
+#   HIP_result - Return value from running the command
+macro(hip_execute_process status command)
+    set(_command ${command})
+    if(NOT "x${_command}" STREQUAL "xCOMMAND")
+        message(FATAL_ERROR "Malformed call to hip_execute_process.  Missing COMMAND as second argument. (command = ${command})")
+    endif()
+    if(verbose)
+        execute_process(COMMAND "${CMAKE_COMMAND}" -E echo -- ${status})
+        # Build command string to print
+        set(hip_execute_process_string)
+        foreach(arg ${ARGN})
+            # Escape quotes if any
+            string(REPLACE "\"" "\\\"" arg ${arg})
+            # Surround args with spaces with quotes
+            if(arg MATCHES " ")
+                list(APPEND hip_execute_process_string "\"${arg}\"")
+            else()
+                list(APPEND hip_execute_process_string ${arg})
+            endif()
+        endforeach()
+        # Echo the command
+        execute_process(COMMAND ${CMAKE_COMMAND} -E echo ${hip_execute_process_string})
+    endif()
+    # Run the command
+    execute_process(COMMAND ${ARGN} RESULT_VARIABLE HIP_result)
+endmacro()
+
+# Delete the target file
+hip_execute_process(
+    "Removing ${generated_file}"
+    COMMAND "${CMAKE_COMMAND}" -E remove "${generated_file}"
+    )
+
+# Generate the dependency file
+hip_execute_process(
+    "Generating dependency file: ${cmake_dependency_file}.pre"
+    COMMAND "${__CC}"
+    -M
+    "${source_file}"
+    -o "${cmake_dependency_file}.pre"
+    ${__CC_FLAGS}
+    ${__CC_INCLUDES}
+    )
+
+if(HIP_result)
+    message(FATAL_ERROR "Error generating ${generated_file}")
+endif()
+
+# Generate the cmake readable dependency file to a temp file
+hip_execute_process(
+    "Generating temporary cmake readable file: ${cmake_dependency_file}.tmp"
+    COMMAND "${CMAKE_COMMAND}"
+    -D "input_file:FILEPATH=${cmake_dependency_file}.pre"
+    -D "output_file:FILEPATH=${cmake_dependency_file}.tmp"
+    -D "verbose=${verbose}"
+    -P "${HIP_run_make2cmake}"
+    )
+
+if(HIP_result)
+    message(FATAL_ERROR "Error generating ${generated_file}")
+endif()
+
+# Copy the file if it is different
+hip_execute_process(
+    "Copy if different ${cmake_dependency_file}.tmp to ${cmake_dependency_file}"
+    COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${cmake_dependency_file}.tmp" "${cmake_dependency_file}"
+    )
+
+if(HIP_result)
+    message(FATAL_ERROR "Error generating ${generated_file}")
+endif()
+
+# Delete the temporary file
+hip_execute_process(
+    "Removing ${cmake_dependency_file}.tmp and ${cmake_dependency_file}.pre"
+    COMMAND "${CMAKE_COMMAND}" -E remove "${cmake_dependency_file}.tmp" "${cmake_dependency_file}.pre"
+    )
+
+if(HIP_result)
+    message(FATAL_ERROR "Error generating ${generated_file}")
+endif()
+
+# Generate the output file
+hip_execute_process(
+    "Generating ${generated_file}"
+    COMMAND "${__CC}"
+    -c
+    "${source_file}"
+    -o "${generated_file}"
+    ${__CC_FLAGS}
+    ${__CC_INCLUDES}
+    )
+
+if(HIP_result)
+    # Make sure that we delete the output file
+    hip_execute_process(
+        "Removing ${generated_file}"
+        COMMAND "${CMAKE_COMMAND}" -E remove "${generated_file}"
+        )
+    message(FATAL_ERROR "Error generating file ${generated_file}")
+else()
+    if(verbose)
+        message("Generated ${generated_file} successfully.")
+    endif()
+endif()
+# vim: ts=4:sw=4:expandtab:smartindent

projects/hip/cmake/FindHIP/run_make2cmake.cmake

@@ -0,0 +1,50 @@
+###############################################################################
+# Computes dependencies using HIPCC
+###############################################################################
+
+###############################################################################
+# This file converts dependency files generated using hipcc to a format that
+# cmake can understand.
+
+# Input variables:
+#
+# input_file:STRING=<> Dependency file to parse. Required argument
+# output_file:STRING=<> Output file to generate. Required argument
+
+if(NOT input_file OR NOT output_file)
+    message(FATAL_ERROR "You must specify input_file and output_file on the command line")
+endif()
+
+file(READ ${input_file} depend_text)
+
+if (NOT "${depend_text}" STREQUAL "")
+    string(REPLACE " /" "\n/" depend_text ${depend_text})
+    string(REGEX REPLACE "^.*:" "" depend_text ${depend_text})
+    string(REGEX REPLACE "[ \\\\]*\n" ";" depend_text ${depend_text})
+
+    set(dependency_list "")
+
+    foreach(file ${depend_text})
+        string(REGEX REPLACE "^ +" "" file ${file})
+        if(NOT EXISTS "${file}")
+            message(WARNING " Removing non-existent dependency file: ${file}")
+            set(file "")
+        endif()
+
+        if(NOT IS_DIRECTORY "${file}")
+            get_filename_component(file_absolute "${file}" ABSOLUTE)
+            list(APPEND dependency_list "${file_absolute}")
+        endif()
+    endforeach()
+endif()
+
+# Remove the duplicate entries and sort them.
+list(REMOVE_DUPLICATES dependency_list)
+list(SORT dependency_list)
+
+foreach(file ${dependency_list})
+    set(hip_hipcc_depend "${hip_hipcc_depend} \"${file}\"\n")
+endforeach()
+
+file(WRITE ${output_file} "# Generated by: FindHIP.cmake. Do not edit.\nSET(HIP_HIPCC_DEPEND\n ${hip_hipcc_depend})\n\n")
+# vim: ts=4:sw=4:expandtab:smartindent