# Default settings common options.

KOKKOS_VERSION_MAJOR = 3
KOKKOS_VERSION_MINOR = 5
KOKKOS_VERSION_PATCH = 00
KOKKOS_VERSION = $(shell echo $(KOKKOS_VERSION_MAJOR)*10000+$(KOKKOS_VERSION_MINOR)*100+$(KOKKOS_VERSION_PATCH) | bc)

# Options: Cuda,HIP,SYCL,OpenMPTarget,OpenMP,Pthread,Serial
#KOKKOS_DEVICES ?= "OpenMP"
KOKKOS_DEVICES ?= "Pthread"
# Options:
# Intel:    KNC,KNL,SNB,HSW,BDW,SKX
# NVIDIA:   Kepler,Kepler30,Kepler32,Kepler35,Kepler37,Maxwell,Maxwell50,Maxwell52,Maxwell53,Pascal60,Pascal61,Volta70,Volta72,Turing75,Ampere80,Ampere86
# ARM:      ARMv80,ARMv81,ARMv8-ThunderX,ARMv8-TX2,A64FX
# IBM:      BGQ,Power7,Power8,Power9
# AMD-GPUS: Vega900,Vega906,Vega908,Vega90A
# AMD-CPUS: AMDAVX,Zen,Zen2,Zen3
KOKKOS_ARCH ?= ""
# Options: yes,no
KOKKOS_DEBUG ?= "no"
# Options: hwloc,librt,experimental_memkind
KOKKOS_USE_TPLS ?= ""
# Options: c++14,c++1y,c++17,c++1z,c++2a
KOKKOS_CXX_STANDARD ?= "c++14"
# Options: aggressive_vectorization,disable_profiling,enable_large_mem_tests,disable_complex_align,disable_deprecated_code,enable_deprecation_warnings
KOKKOS_OPTIONS ?= ""
KOKKOS_CMAKE ?= "no"
KOKKOS_TRIBITS ?= "no"
KOKKOS_STANDALONE_CMAKE ?= "no"

# Default settings specific options.
# Options: force_uvm,use_ldg,rdc,enable_lambda,enable_constexpr
KOKKOS_CUDA_OPTIONS ?= ""

# Options: rdc
KOKKOS_HIP_OPTIONS ?= ""

# Default settings specific options.
# Options: enable_async_dispatch
KOKKOS_HPX_OPTIONS ?= ""

# Helper functions for conversion to upper case
uppercase_TABLE:=a,A b,B c,C d,D e,E f,F g,G h,H i,I j,J k,K l,L m,M n,N o,O p,P q,Q r,R s,S t,T u,U v,V w,W x,X y,Y z,Z
uppercase_internal=$(if $1,$$(subst $(firstword $1),$(call uppercase_internal,$(wordlist 2,$(words $1),$1),$2)),$2)
uppercase=$(eval uppercase_RESULT:=$(call uppercase_internal,$(uppercase_TABLE),$1))$(uppercase_RESULT)
# Return a 1 if a string contains a substring and 0 if not
# Note the search string should be without '"'
# Example: $(call kokkos_has_string,"hwloc,librt",hwloc)
#   Will return a 1
kokkos_has_string=$(if $(findstring $(call uppercase,$2),$(call uppercase,$1)),1,0)
# Returns 1 if the path exists, 0 otherwise
# Example: $(call kokkos_path_exists,/path/to/file)
#   Will return a 1 if /path/to/file exists
kokkos_path_exists=$(if $(wildcard $1),1,0)

# Check for general settings

KOKKOS_INTERNAL_ENABLE_DEBUG := $(call kokkos_has_string,$(KOKKOS_DEBUG),yes)
KOKKOS_INTERNAL_ENABLE_CXX14 := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++14)
KOKKOS_INTERNAL_ENABLE_CXX1Y := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++1y)
KOKKOS_INTERNAL_ENABLE_CXX17 := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++17)
KOKKOS_INTERNAL_ENABLE_CXX1Z := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++1z)
KOKKOS_INTERNAL_ENABLE_CXX2A := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++2a)
KOKKOS_INTERNAL_ENABLE_CXX20 := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++20)

# Check for external libraries.
KOKKOS_INTERNAL_USE_HWLOC := $(call kokkos_has_string,$(KOKKOS_USE_TPLS),hwloc)
KOKKOS_INTERNAL_USE_LIBRT := $(call kokkos_has_string,$(KOKKOS_USE_TPLS),librt)
KOKKOS_INTERNAL_USE_MEMKIND := $(call kokkos_has_string,$(KOKKOS_USE_TPLS),experimental_memkind)

# Check for advanced settings.
KOKKOS_INTERNAL_ENABLE_COMPILER_WARNINGS := $(call kokkos_has_string,$(KOKKOS_OPTIONS),compiler_warnings)
KOKKOS_INTERNAL_AGGRESSIVE_VECTORIZATION := $(call kokkos_has_string,$(KOKKOS_OPTIONS),aggressive_vectorization)
KOKKOS_INTERNAL_ENABLE_TUNING := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_tuning)
KOKKOS_INTERNAL_DISABLE_COMPLEX_ALIGN := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_complex_align)
KOKKOS_INTERNAL_DISABLE_DUALVIEW_MODIFY_CHECK := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_dualview_modify_check)
KOKKOS_INTERNAL_ENABLE_PROFILING_LOAD_PRINT := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_profile_load_print)
KOKKOS_INTERNAL_ENABLE_LARGE_MEM_TESTS := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_large_mem_tests)
KOKKOS_INTERNAL_CUDA_USE_LDG := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),use_ldg)
KOKKOS_INTERNAL_CUDA_USE_UVM := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),force_uvm)
KOKKOS_INTERNAL_CUDA_USE_RELOC := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),rdc)
KOKKOS_INTERNAL_CUDA_USE_LAMBDA := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),enable_lambda)
KOKKOS_INTERNAL_CUDA_USE_CONSTEXPR := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),enable_constexpr)
KOKKOS_INTERNAL_HPX_ENABLE_ASYNC_DISPATCH := $(call kokkos_has_string,$(KOKKOS_HPX_OPTIONS),enable_async_dispatch)
KOKKOS_INTERNAL_ENABLE_DESUL_ATOMICS := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_desul_atomics)
KOKKOS_INTERNAL_DISABLE_DEPRECATED_CODE := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_deprecated_code)
KOKKOS_INTERNAL_ENABLE_DEPRECATION_WARNINGS := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_deprecation_warnings)

KOKKOS_INTERNAL_HIP_USE_RELOC := $(call kokkos_has_string,$(KOKKOS_HIP_OPTIONS),rdc)

# Check for Kokkos Host Execution Spaces one of which must be on.
KOKKOS_INTERNAL_USE_OPENMP := $(call kokkos_has_string,$(subst OpenMPTarget,,$(KOKKOS_DEVICES)),OpenMP)
KOKKOS_INTERNAL_USE_PTHREADS := $(call kokkos_has_string,$(KOKKOS_DEVICES),Pthread)
KOKKOS_INTERNAL_USE_HPX := $(call kokkos_has_string,$(KOKKOS_DEVICES),HPX)
KOKKOS_INTERNAL_USE_SERIAL := $(call kokkos_has_string,$(KOKKOS_DEVICES),Serial)

ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 0)
  ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 0)
    ifeq ($(KOKKOS_INTERNAL_USE_HPX), 0)
      KOKKOS_INTERNAL_USE_SERIAL := 1
    endif
  endif
endif

# Check for other Execution Spaces.
KOKKOS_INTERNAL_USE_CUDA := $(call kokkos_has_string,$(KOKKOS_DEVICES),Cuda)
KOKKOS_INTERNAL_USE_HIP := $(call kokkos_has_string,$(KOKKOS_DEVICES),HIP)
KOKKOS_INTERNAL_USE_SYCL := $(call kokkos_has_string,$(KOKKOS_DEVICES),SYCL)
KOKKOS_INTERNAL_USE_OPENMPTARGET := $(call kokkos_has_string,$(KOKKOS_DEVICES),OpenMPTarget)

KOKKOS_DEVICELIST =
ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
  KOKKOS_DEVICELIST += Serial
endif
ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
  KOKKOS_DEVICELIST += OpenMP
endif
ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 1)
  KOKKOS_DEVICELIST += Threads
endif
ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
  KOKKOS_DEVICELIST += HPX
endif
ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
  KOKKOS_DEVICELIST += Cuda
endif
ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
  KOKKOS_DEVICELIST += HIP
endif
KOKKOS_INTERNAL_HAVE_CXX17_OR_NEWER := $(shell expr $(KOKKOS_INTERNAL_ENABLE_CXX17) \
                                                  + $(KOKKOS_INTERNAL_ENABLE_CXX20) \
                                                  + $(KOKKOS_INTERNAL_ENABLE_CXX2A))
ifeq ($(KOKKOS_INTERNAL_USE_SYCL), 1)
  KOKKOS_DEVICELIST += SYCL
  ifneq ($(KOKKOS_INTERNAL_HAVE_CXX17_OR_NEWER), 1)
    $(error SYCL backend requires C++17 or newer)
  endif

endif
ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
  KOKKOS_DEVICELIST += OPENMPTARGET
  ifneq ($(KOKKOS_INTERNAL_HAVE_CXX17_OR_NEWER), 1)
    $(error OpenMPTarget backend requires C++17 or newer)
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
  KOKKOS_INTERNAL_NVCC_PATH := $(shell which nvcc)
  ifeq ($(origin CUDA_PATH), undefined)
    CUDA_PATH = $(KOKKOS_INTERNAL_NVCC_PATH:/bin/nvcc=)
  endif
  ifeq ($(CUDA_PATH),)
    CUDA_PATH = $(KOKKOS_INTERNAL_NVCC_PATH:/bin/nvcc=)
  endif
  KOKKOS_INTERNAL_COMPILER_NVCC_VERSION := $(shell nvcc --version 2>&1 | grep release | cut -d' ' -f5 | cut -d',' -f1 | tr -d .)
endif

# Check OS.
KOKKOS_OS                      := $(strip $(shell uname -s))
KOKKOS_INTERNAL_OS_CYGWIN      := $(call kokkos_has_string,$(KOKKOS_OS),CYGWIN)
KOKKOS_INTERNAL_OS_LINUX       := $(call kokkos_has_string,$(KOKKOS_OS),Linux)
KOKKOS_INTERNAL_OS_DARWIN      := $(call kokkos_has_string,$(KOKKOS_OS),Darwin)

# Check compiler.
KOKKOS_CXX_VERSION                   := $(strip $(shell $(CXX) --version       2>&1))
KOKKOS_INTERNAL_COMPILER_INTEL       := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),Intel Corporation)
KOKKOS_INTERNAL_COMPILER_PGI         := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),PGI)
KOKKOS_INTERNAL_COMPILER_XL          := $(strip $(shell $(CXX) -qversion       2>&1 | grep -c XL))
KOKKOS_INTERNAL_COMPILER_CRAY        := $(strip $(shell $(CXX) -craype-verbose 2>&1 | grep -c "CC-"))
KOKKOS_INTERNAL_COMPILER_NVCC        := $(strip $(shell echo "$(shell export OMPI_CXX=$(OMPI_CXX); export MPICH_CXX=$(MPICH_CXX); $(CXX) --version 2>&1 | grep -c nvcc)>0" | bc))
KOKKOS_INTERNAL_COMPILER_CLANG       := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),clang)
KOKKOS_INTERNAL_COMPILER_CRAY_CLANG  := $(strip $(shell $(CXX) -craype-verbose 2>&1 | grep -c "clang++"))
KOKKOS_INTERNAL_COMPILER_INTEL_CLANG := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),oneAPI)
KOKKOS_INTERNAL_COMPILER_APPLE_CLANG := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),Apple clang)
KOKKOS_INTERNAL_COMPILER_HCC         := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),HCC)
KOKKOS_INTERNAL_COMPILER_GCC         := $(call kokkos_has_string,$(KOKKOS_CXX_VERSION),GCC)

# Check Host Compiler if using NVCC through nvcc_wrapper
ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
  KOKKOS_INTERNAL_COMPILER_NVCC_WRAPPER := $(strip $(shell echo $(CXX) | grep -c nvcc_wrapper))
  ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC_WRAPPER), 1)

    KOKKOS_CXX_HOST_VERSION             := $(strip $(shell $(CXX) $(CXXFLAGS) --host-version       2>&1))
    KOKKOS_INTERNAL_COMPILER_PGI    := $(call kokkos_has_string,$(KOKKOS_CXX_HOST_VERSION),PGI)
    KOKKOS_INTERNAL_COMPILER_INTEL  := $(call kokkos_has_string,$(KOKKOS_CXX_HOST_VERSION),Intel Corporation)
    KOKKOS_INTERNAL_COMPILER_CLANG  := $(call kokkos_has_string,$(KOKKOS_CXX_HOST_VERSION),clang)
  endif
endif

ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 2)
  KOKKOS_INTERNAL_COMPILER_CLANG = 1
endif
ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 2)
  KOKKOS_INTERNAL_COMPILER_XL = 1
endif

# Apple Clang passes both clang and apple clang tests, so turn off clang.
ifeq ($(KOKKOS_INTERNAL_COMPILER_APPLE_CLANG), 1)
  KOKKOS_INTERNAL_COMPILER_CLANG = 0
endif
# AMD HCC passes both clang and hcc test so turn off clang
ifeq ($(KOKKOS_INTERNAL_COMPILER_HCC), 1)
  KOKKOS_INTENAL_COMPILER_CLANG = 0
endif

ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
  KOKKOS_INTERNAL_COMPILER_CLANG_VERSION := $(shell $(CXX) --version | grep version | cut -d ' ' -f3 | tr -d '.')

  ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
    ifeq ($(shell test $(KOKKOS_INTERNAL_COMPILER_CLANG_VERSION) -lt 400; echo $$?),0)
      $(error Compiling Cuda code directly with Clang requires version 4.0.0 or higher)
    endif

    KOKKOS_INTERNAL_CUDA_USE_LAMBDA := 1
  endif
endif

# Set compiler warnings flags.
ifeq ($(KOKKOS_INTERNAL_ENABLE_COMPILER_WARNINGS), 1)
  ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
    # TODO check if PGI accepts GNU style warnings
    KOKKOS_INTERNAL_COMPILER_WARNINGS =
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
      KOKKOS_INTERNAL_COMPILER_WARNINGS = -Wall -Wunused-parameter -Wshadow -pedantic -Wsign-compare -Wtype-limits -Wuninitialized
    else
      ifeq ($(KOKKOS_INTERNAL_COMPILER_APPLE_CLANG), 1)
        KOKKOS_INTERNAL_COMPILER_WARNINGS = -Wall -Wunused-parameter -Wshadow -pedantic -Wsign-compare -Wtype-limits -Wuninitialized
      else
        ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1)
          KOKKOS_INTERNAL_COMPILER_WARNINGS = -Wall -Wunused-parameter -Wshadow -pedantic -Wsign-compare -Wtype-limits -Wuninitialized
        else
          ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
            # TODO check if cray accepts GNU style warnings
            KOKKOS_INTERNAL_COMPILER_WARNINGS =
          else
            #gcc
            KOKKOS_INTERNAL_COMPILER_WARNINGS = -Wall -Wunused-parameter -Wshadow -pedantic -Wsign-compare -Wtype-limits -Wignored-qualifiers -Wempty-body -Wclobbered -Wuninitialized
          endif
        endif
      endif
    endif
  endif
else
  KOKKOS_INTERNAL_COMPILER_WARNINGS =
endif

# Set OpenMP flags.
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
  KOKKOS_INTERNAL_OPENMP_FLAG := -mp
else
  ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY_CLANG), 1)
    KOKKOS_INTERNAL_OPENMP_FLAG := -fopenmp
    else
    KOKKOS_INTERNAL_OPENMP_FLAG := -fopenmp=libomp
    endif
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_APPLE_CLANG), 1)
      KOKKOS_INTERNAL_OPENMP_FLAG := -fopenmp=libomp
    else
      ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1)
        KOKKOS_INTERNAL_OPENMP_FLAG := -qsmp=omp
      else
        ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
          # OpenMP is turned on by default in Cray compiler environment.
          KOKKOS_INTERNAL_OPENMP_FLAG :=
        else
          ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL_CLANG), 1)
            KOKKOS_INTERNAL_OPENMP_FLAG := -fiopenmp
          else
            KOKKOS_INTERNAL_OPENMP_FLAG := -fopenmp
          endif
        endif
      endif
    endif
  endif
endif
ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1)
  KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -DKOKKOS_IBM_XL_OMP45_WORKAROUND -qsmp=omp -qoffload -qnoeh
else
  ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
    #KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -DKOKKOS_BUG_WORKAROUND_IBM_CLANG_OMP45_VIEW_INIT -fopenmp-implicit-declare-target -fopenmp-targets=nvptx64-nvidia-cuda -fopenmp -fopenmp=libomp
    KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -DKOKKOS_WORKAROUND_OPENMPTARGET_CLANG -fopenmp -fopenmp=libomp
    KOKKOS_INTERNAL_OPENMPTARGET_LIB := -lomptarget
  else
    #Assume GCC
    KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -fopenmp -foffload=nvptx-none
  endif
endif

# Set C++ version flags.
ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
  KOKKOS_INTERNAL_CXX14_FLAG := --c++14
  KOKKOS_INTERNAL_CXX17_FLAG := --c++17
else
  ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1)
     KOKKOS_INTERNAL_CXX14_FLAG := -std=c++14
     KOKKOS_INTERNAL_CXX1Y_FLAG := -std=c++1y
     #KOKKOS_INTERNAL_CXX17_FLAG := -std=c++17
     #KOKKOS_INTERNAL_CXX1Z_FLAG := -std=c++1Z
     #KOKKOS_INTERNAL_CXX2A_FLAG := -std=c++2a
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
      KOKKOS_INTERNAL_CXX14_FLAG := -hstd=c++14
      #KOKKOS_INTERNAL_CXX1Y_FLAG := -hstd=c++1y
      #KOKKOS_INTERNAL_CXX17_FLAG := -hstd=c++17
      #KOKKOS_INTERNAL_CXX1Z_FLAG := -hstd=c++1z
      #KOKKOS_INTERNAL_CXX2A_FLAG := -hstd=c++2a
    else
      KOKKOS_INTERNAL_CXX14_FLAG := -std=c++14
      KOKKOS_INTERNAL_CXX1Y_FLAG := -std=c++1y
      KOKKOS_INTERNAL_CXX17_FLAG := -std=c++17
      KOKKOS_INTERNAL_CXX1Z_FLAG := -std=c++1z
      KOKKOS_INTERNAL_CXX2A_FLAG := -std=c++2a
    endif
  endif
endif

# Check for Kokkos Architecture settings.

# Intel based.
KOKKOS_INTERNAL_USE_ARCH_KNC := $(call kokkos_has_string,$(KOKKOS_ARCH),KNC)
KOKKOS_INTERNAL_USE_ARCH_WSM := $(call kokkos_has_string,$(KOKKOS_ARCH),WSM)
KOKKOS_INTERNAL_USE_ARCH_SNB := $(call kokkos_has_string,$(KOKKOS_ARCH),SNB)
KOKKOS_INTERNAL_USE_ARCH_HSW := $(call kokkos_has_string,$(KOKKOS_ARCH),HSW)
KOKKOS_INTERNAL_USE_ARCH_BDW := $(call kokkos_has_string,$(KOKKOS_ARCH),BDW)
KOKKOS_INTERNAL_USE_ARCH_SKX := $(call kokkos_has_string,$(KOKKOS_ARCH),SKX)
KOKKOS_INTERNAL_USE_ARCH_KNL := $(call kokkos_has_string,$(KOKKOS_ARCH),KNL)

KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelGen)
KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN9 := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelGen9)
KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN11 := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelGen11)
KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN12LP := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelGen12LP)
KOKKOS_INTERNAL_USE_ARCH_INTEL_DG1 := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelDG1)
KOKKOS_INTERNAL_USE_ARCH_INTEL_XEHP := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelXeHP)

# NVIDIA based.
NVCC_WRAPPER := $(KOKKOS_PATH)/bin/nvcc_wrapper
KOKKOS_INTERNAL_USE_ARCH_KEPLER30 := $(call kokkos_has_string,$(KOKKOS_ARCH),Kepler30)
KOKKOS_INTERNAL_USE_ARCH_KEPLER32 := $(call kokkos_has_string,$(KOKKOS_ARCH),Kepler32)
KOKKOS_INTERNAL_USE_ARCH_KEPLER35 := $(call kokkos_has_string,$(KOKKOS_ARCH),Kepler35)
KOKKOS_INTERNAL_USE_ARCH_KEPLER37 := $(call kokkos_has_string,$(KOKKOS_ARCH),Kepler37)
KOKKOS_INTERNAL_USE_ARCH_MAXWELL50 := $(call kokkos_has_string,$(KOKKOS_ARCH),Maxwell50)
KOKKOS_INTERNAL_USE_ARCH_MAXWELL52 := $(call kokkos_has_string,$(KOKKOS_ARCH),Maxwell52)
KOKKOS_INTERNAL_USE_ARCH_MAXWELL53 := $(call kokkos_has_string,$(KOKKOS_ARCH),Maxwell53)
KOKKOS_INTERNAL_USE_ARCH_PASCAL61 := $(call kokkos_has_string,$(KOKKOS_ARCH),Pascal61)
KOKKOS_INTERNAL_USE_ARCH_PASCAL60 := $(call kokkos_has_string,$(KOKKOS_ARCH),Pascal60)
KOKKOS_INTERNAL_USE_ARCH_VOLTA70 := $(call kokkos_has_string,$(KOKKOS_ARCH),Volta70)
KOKKOS_INTERNAL_USE_ARCH_VOLTA72 := $(call kokkos_has_string,$(KOKKOS_ARCH),Volta72)
KOKKOS_INTERNAL_USE_ARCH_TURING75 := $(call kokkos_has_string,$(KOKKOS_ARCH),Turing75)
KOKKOS_INTERNAL_USE_ARCH_AMPERE80 := $(call kokkos_has_string,$(KOKKOS_ARCH),Ampere80)
KOKKOS_INTERNAL_USE_ARCH_AMPERE86 := $(call kokkos_has_string,$(KOKKOS_ARCH),Ampere86)
KOKKOS_INTERNAL_USE_ARCH_NVIDIA := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_KEPLER30)  \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_KEPLER32)  \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_KEPLER35)  \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_KEPLER37)  \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_MAXWELL50) \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_MAXWELL52) \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_MAXWELL53) \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_PASCAL61)  \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_PASCAL60)  \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_VOLTA70)   \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_VOLTA72)   \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_TURING75)  \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_AMPERE80)  \
                                              + $(KOKKOS_INTERNAL_USE_ARCH_AMPERE86))

#SEK: This seems like a bug to me
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_NVIDIA), 0)
  KOKKOS_INTERNAL_USE_ARCH_MAXWELL50 := $(call kokkos_has_string,$(KOKKOS_ARCH),Maxwell)
  KOKKOS_INTERNAL_USE_ARCH_KEPLER35 := $(call kokkos_has_string,$(KOKKOS_ARCH),Kepler)
  KOKKOS_INTERNAL_USE_ARCH_NVIDIA := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_KEPLER35)  \
                                                + $(KOKKOS_INTERNAL_USE_ARCH_MAXWELL50))
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_NVIDIA), 1)
  ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
    KOKKOS_INTERNAL_NVCC_PATH := $(shell which nvcc)
    CUDA_PATH ?= $(KOKKOS_INTERNAL_NVCC_PATH:/bin/nvcc=)
    ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
      KOKKOS_INTERNAL_OPENMPTARGET_FLAG := $(KOKKOS_INTERNAL_OPENMPTARGET_FLAG) --cuda-path=$(CUDA_PATH)
    endif
  endif
endif
# ARM based.
KOKKOS_INTERNAL_USE_ARCH_ARMV80 := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv80)
KOKKOS_INTERNAL_USE_ARCH_ARMV81 := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv81)
KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv8-ThunderX)
KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX2 := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv8-TX2)
KOKKOS_INTERNAL_USE_ARCH_A64FX := $(call kokkos_has_string,$(KOKKOS_ARCH),A64FX)
KOKKOS_INTERNAL_USE_ARCH_ARM := $(strip $(shell echo $(KOKKOS_INTERNAL_USE_ARCH_ARMV80)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV81)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX2)+$(KOKKOS_INTERNAL_USE_ARCH_A64FX) | bc))

# IBM based.
KOKKOS_INTERNAL_USE_ARCH_BGQ := $(call kokkos_has_string,$(KOKKOS_ARCH),BGQ)
KOKKOS_INTERNAL_USE_ARCH_POWER7 := $(call kokkos_has_string,$(KOKKOS_ARCH),Power7)
KOKKOS_INTERNAL_USE_ARCH_POWER8 := $(call kokkos_has_string,$(KOKKOS_ARCH),Power8)
KOKKOS_INTERNAL_USE_ARCH_POWER9 := $(call kokkos_has_string,$(KOKKOS_ARCH),Power9)
KOKKOS_INTERNAL_USE_ARCH_IBM := $(strip $(shell echo $(KOKKOS_INTERNAL_USE_ARCH_BGQ)+$(KOKKOS_INTERNAL_USE_ARCH_POWER7)+$(KOKKOS_INTERNAL_USE_ARCH_POWER8)+$(KOKKOS_INTERNAL_USE_ARCH_POWER9) | bc))

# AMD based.
KOKKOS_INTERNAL_USE_ARCH_AMDAVX := $(call kokkos_has_string,$(KOKKOS_ARCH),AMDAVX)
KOKKOS_INTERNAL_USE_ARCH_ZEN3 := $(call kokkos_has_string,$(KOKKOS_ARCH),Zen3)
KOKKOS_INTERNAL_USE_ARCH_ZEN2 := $(call kokkos_has_string,$(KOKKOS_ARCH),Zen2)
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ZEN3), 0)
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ZEN2), 0)
    KOKKOS_INTERNAL_USE_ARCH_ZEN := $(call kokkos_has_string,$(KOKKOS_ARCH),Zen)
  endif
endif
KOKKOS_INTERNAL_USE_ARCH_VEGA900 := $(call kokkos_has_string,$(KOKKOS_ARCH),Vega900)
KOKKOS_INTERNAL_USE_ARCH_VEGA906 := $(call kokkos_has_string,$(KOKKOS_ARCH),Vega906)
KOKKOS_INTERNAL_USE_ARCH_VEGA908 := $(call kokkos_has_string,$(KOKKOS_ARCH),Vega908)
KOKKOS_INTERNAL_USE_ARCH_VEGA90A := $(call kokkos_has_string,$(KOKKOS_ARCH),Vega90A)

# Any AVX?
KOKKOS_INTERNAL_USE_ARCH_SSE42      := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_WSM))
KOKKOS_INTERNAL_USE_ARCH_AVX        := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_SNB) + $(KOKKOS_INTERNAL_USE_ARCH_AMDAVX))
KOKKOS_INTERNAL_USE_ARCH_AVX2       := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_HSW) + $(KOKKOS_INTERNAL_USE_ARCH_BDW) + $(KOKKOS_INTERNAL_USE_ARCH_ZEN) + $(KOKKOS_INTERNAL_USE_ARCH_ZEN2) + $(KOKKOS_INTERNAL_USE_ARCH_ZEN3))
KOKKOS_INTERNAL_USE_ARCH_AVX512MIC  := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_KNL))
KOKKOS_INTERNAL_USE_ARCH_AVX512XEON := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_SKX))

# Decide what ISA level we are able to support.
KOKKOS_INTERNAL_USE_ISA_X86_64    := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_WSM) + $(KOKKOS_INTERNAL_USE_ARCH_SNB) + $(KOKKOS_INTERNAL_USE_ARCH_HSW) + $(KOKKOS_INTERNAL_USE_ARCH_BDW) + $(KOKKOS_INTERNAL_USE_ARCH_KNL) + $(KOKKOS_INTERNAL_USE_ARCH_SKX) + $(KOKKOS_INTERNAL_USE_ARCH_ZEN) + $(KOKKOS_INTERNAL_USE_ARCH_ZEN2) + $(KOKKOS_INTERNAL_USE_ARCH_ZEN3))
KOKKOS_INTERNAL_USE_ISA_KNC       := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_KNC))
KOKKOS_INTERNAL_USE_ISA_POWERPCLE := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_POWER8) + $(KOKKOS_INTERNAL_USE_ARCH_POWER9))
KOKKOS_INTERNAL_USE_ISA_POWERPCBE := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_POWER7))

# Decide whether we can support transactional memory
KOKKOS_INTERNAL_USE_TM            := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_BDW) + $(KOKKOS_INTERNAL_USE_ARCH_SKX))

# Incompatible flags?
KOKKOS_INTERNAL_USE_ARCH_MULTIHOST := $(strip $(shell echo "$(KOKKOS_INTERNAL_USE_ARCH_SSE42)+$(KOKKOS_INTERNAL_USE_ARCH_AVX)+$(KOKKOS_INTERNAL_USE_ARCH_AVX2)+$(KOKKOS_INTERNAL_USE_ARCH_AVX512MIC)+$(KOKKOS_INTERNAL_USE_ARCH_AVX512XEON)+$(KOKKOS_INTERNAL_USE_ARCH_KNC)+$(KOKKOS_INTERNAL_USE_ARCH_IBM)+$(KOKKOS_INTERNAL_USE_ARCH_ARM)>1") | bc)
KOKKOS_INTERNAL_USE_ARCH_MULTIGPU := $(strip $(shell echo "$(KOKKOS_INTERNAL_USE_ARCH_NVIDIA)>1") | bc)

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MULTIHOST), 1)
  $(error Defined Multiple Host architectures: KOKKOS_ARCH=$(KOKKOS_ARCH) )
endif
ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MULTIGPU), 1)
  $(error Defined Multiple GPU architectures: KOKKOS_ARCH=$(KOKKOS_ARCH) )
endif

# Generating the list of Flags.

KOKKOS_CPPFLAGS =
KOKKOS_LIBDIRS =
ifneq ($(KOKKOS_CMAKE), yes)
  KOKKOS_CPPFLAGS = -I./ -I$(KOKKOS_PATH)/core/src -I$(KOKKOS_PATH)/containers/src -I$(KOKKOS_PATH)/algorithms/src
endif
KOKKOS_TPL_INCLUDE_DIRS =
KOKKOS_TPL_LIBRARY_DIRS =
KOKKOS_TPL_LIBRARY_NAMES =

ifeq ($(KOKKOS_INTERNAL_ENABLE_COMPILER_WARNINGS), 1)
  KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_COMPILER_WARNINGS)
endif

KOKKOS_LIBS = -ldl
KOKKOS_TPL_LIBRARY_NAMES += dl
ifneq ($(KOKKOS_CMAKE), yes)
  KOKKOS_LIBDIRS = -L$(shell pwd)
  # CXXLDFLAGS is used together with CXXFLAGS in a combined compile/link command
  KOKKOS_CXXLDFLAGS = -L$(shell pwd)
endif
KOKKOS_LINK_FLAGS = 
KOKKOS_SRC =
KOKKOS_HEADERS =

#ifeq ($(KOKKOS_INTERNAL_COMPILER_GCC), 1)
  KOKKOS_LIBS += -latomic
#endif

# Generating the KokkosCore_config.h file.

KOKKOS_INTERNAL_CONFIG_TMP=KokkosCore_config.tmp
KOKKOS_CONFIG_HEADER=KokkosCore_config.h
# Functions for generating config header file
kokkos_append_header = $(shell echo $1 >> $(KOKKOS_INTERNAL_CONFIG_TMP))

# assign hash sign to variable for compat. with make 4.3
H := \#

# Do not append first line
tmp := $(shell echo "/* ---------------------------------------------" > KokkosCore_config.tmp)
tmp := $(call kokkos_append_header,"Makefile constructed configuration:")
tmp := $(call kokkos_append_header,"----------------------------------------------*/")

tmp := $(call kokkos_append_header,'$H''if !defined(KOKKOS_MACROS_HPP) || defined(KOKKOS_CORE_CONFIG_H)')
tmp := $(call kokkos_append_header,'$H''error "Do not include $(KOKKOS_CONFIG_HEADER) directly; include Kokkos_Macros.hpp instead."')
tmp := $(call kokkos_append_header,'$H''else')
tmp := $(call kokkos_append_header,'$H''define KOKKOS_CORE_CONFIG_H')
tmp := $(call kokkos_append_header,'$H''endif')

tmp := $(call kokkos_append_header,"")
tmp := $(call kokkos_append_header,"$H""define KOKKOS_VERSION $(KOKKOS_VERSION)")
tmp := $(call kokkos_append_header,"")
	
tmp := $(call kokkos_append_header,"/* Execution Spaces */")

ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_COMPILER_CUDA_VERSION $(KOKKOS_INTERNAL_COMPILER_NVCC_VERSION)")
endif

ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
  tmp := $(call kokkos_append_header,'$H''define KOKKOS_ENABLE_HIP')
endif

ifeq ($(KOKKOS_INTERNAL_USE_SYCL), 1)
  tmp := $(call kokkos_append_header,'$H''define KOKKOS_ENABLE_SYCL')
endif

ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
  tmp := $(call kokkos_append_header,'$H''define KOKKOS_ENABLE_OPENMPTARGET')
  ifeq ($(KOKKOS_INTERNAL_COMPILER_GCC), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_WORKAROUND_OPENMPTARGET_GCC")
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
  tmp := $(call kokkos_append_header,'$H''define KOKKOS_ENABLE_OPENMP')
endif

ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_THREADS")
endif

ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_HPX")
endif

ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_SERIAL")
endif

ifeq ($(KOKKOS_INTERNAL_USE_TM), 1)
  tmp := $(call kokkos_append_header,"$H""ifndef __CUDA_ARCH__")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_TM")
  tmp := $(call kokkos_append_header,"$H""endif")
endif

ifeq ($(KOKKOS_INTERNAL_USE_ISA_X86_64), 1)
  tmp := $(call kokkos_append_header,"$H""ifndef __CUDA_ARCH__")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_USE_ISA_X86_64")
  tmp := $(call kokkos_append_header,"$H""endif")
endif

ifeq ($(KOKKOS_INTERNAL_USE_ISA_KNC), 1)
  tmp := $(call kokkos_append_header,"$H""ifndef __CUDA_ARCH__")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_USE_ISA_KNC")
  tmp := $(call kokkos_append_header,"$H""endif")
endif

ifeq ($(KOKKOS_INTERNAL_USE_ISA_POWERPCLE), 1)
  tmp := $(call kokkos_append_header,"$H""ifndef __CUDA_ARCH__")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_USE_ISA_POWERPCLE")
  tmp := $(call kokkos_append_header,"$H""endif")
endif

ifeq ($(KOKKOS_INTERNAL_USE_ISA_POWERPCBE), 1)
  tmp := $(call kokkos_append_header,"$H""ifndef __CUDA_ARCH__")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_USE_ISA_POWERPCBE")
  tmp := $(call kokkos_append_header,"$H""endif")
endif

#only add the c++ standard flags if this is not CMake
tmp := $(call kokkos_append_header,"/* General Settings */")
ifneq ($(KOKKOS_INTERNAL_DISABLE_DEPRECATED_CODE), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_DEPRECATED_CODE_3")
endif
ifeq ($(KOKKOS_INTERNAL_ENABLE_DEPRECATION_WARNINGS), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_DEPRECATION_WARNINGS")
endif
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX14), 1)
ifneq ($(KOKKOS_STANDALONE_CMAKE), yes)
  KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX14_FLAG)
endif
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CXX14")
endif
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX1Y), 1)
  #I cannot make CMake add this in a good way - so add it here
  KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX1Y_FLAG)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CXX14")
endif
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX17), 1)
ifneq ($(KOKKOS_STANDALONE_CMAKE), yes)
  KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX17_FLAG)
endif
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CXX17")
endif
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX1Z), 1)
  #I cannot make CMake add this in a good way - so add it here
  KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX1Z_FLAG)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CXX17")
endif
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX2A), 1)
  #I cannot make CMake add this in a good way - so add it here
  KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX2A_FLAG)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CXX20")
endif
ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX20), 1)
  #I cannot make CMake add this in a good way - so add it here
  KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX20_FLAG)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CXX20")
endif

ifeq ($(KOKKOS_INTERNAL_ENABLE_DEBUG), 1)
  ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
    KOKKOS_CXXFLAGS += -lineinfo
  endif

  KOKKOS_CXXFLAGS += -g
  KOKKOS_LDFLAGS += -g
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_DEBUG")
  ifeq ($(KOKKOS_INTERNAL_DISABLE_DUALVIEW_MODIFY_CHECK), 0)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK")
  endif
endif
ifeq ($(KOKKOS_INTERNAL_DISABLE_COMPLEX_ALIGN), 0)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_COMPLEX_ALIGN")
endif

ifeq ($(KOKKOS_INTERNAL_ENABLE_PROFILING_LOAD_PRINT), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_PROFILING_LOAD_PRINT")
endif

ifeq ($(KOKKOS_INTERNAL_ENABLE_TUNING), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_TUNING")
endif

tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_LIBDL")

ifeq ($(KOKKOS_INTERNAL_USE_HWLOC), 1)
  ifneq ($(KOKKOS_CMAKE), yes)
    ifneq ($(HWLOC_PATH),)
      KOKKOS_CPPFLAGS += -I$(HWLOC_PATH)/include
      KOKKOS_LIBDIRS += -L$(HWLOC_PATH)/lib
      KOKKOS_CXXLDFLAGS += -L$(HWLOC_PATH)/lib
      KOKKOS_TPL_INCLUDE_DIRS += $(HWLOC_PATH)/include
      KOKKOS_TPL_LIBRARY_DIRS += $(HWLOC_PATH)/lib
    endif
    KOKKOS_LIBS += -lhwloc
    KOKKOS_TPL_LIBRARY_NAMES += hwloc
  endif
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_HWLOC")
endif

ifeq ($(KOKKOS_INTERNAL_USE_LIBRT), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_USE_LIBRT")
  KOKKOS_LIBS += -lrt
  KOKKOS_TPL_LIBRARY_NAMES += rt
endif

ifeq ($(KOKKOS_INTERNAL_USE_MEMKIND), 1)
  ifneq ($(KOKKOS_CMAKE), yes)
    ifneq ($(MEMKIND_PATH),)
      KOKKOS_CPPFLAGS += -I$(MEMKIND_PATH)/include
      KOKKOS_LIBDIRS += -L$(MEMKIND_PATH)/lib
      KOKKOS_CXXLDFLAGS += -L$(MEMKIND_PATH)/lib
      KOKKOS_TPL_INCLUDE_DIRS += $(MEMKIND_PATH)/include
      KOKKOS_TPL_LIBRARY_DIRS += $(MEMKIND_PATH)/lib
    endif
    KOKKOS_LIBS += -lmemkind -lnuma
    KOKKOS_TPL_LIBRARY_NAMES += memkind numa
  endif
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_HBWSPACE")
endif

ifeq ($(KOKKOS_INTERNAL_ENABLE_LARGE_MEM_TESTS), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_LARGE_MEM_TESTS")
endif

tmp := $(call kokkos_append_header,"/* Optimization Settings */")

ifeq ($(KOKKOS_INTERNAL_AGGRESSIVE_VECTORIZATION), 1)
  # deprecated
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION")
endif

tmp := $(call kokkos_append_header,"/* Cuda Settings */")

ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
  ifeq ($(KOKKOS_INTERNAL_CUDA_USE_LDG), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_LDG_INTRINSIC")
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_LDG_INTRINSIC")
    endif
  endif

  ifeq ($(KOKKOS_INTERNAL_CUDA_USE_UVM), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_UVM")
  endif

  ifeq ($(KOKKOS_INTERNAL_CUDA_USE_RELOC), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE")
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
      KOKKOS_CXXFLAGS += -fcuda-rdc
      KOKKOS_LDFLAGS += -fcuda-rdc
    else
      KOKKOS_CXXFLAGS += --relocatable-device-code=true
      KOKKOS_LDFLAGS += --relocatable-device-code=true
    endif
  endif

  ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
    ifeq ($(shell test $(KOKKOS_INTERNAL_COMPILER_NVCC_VERSION) -ge 90; echo $$?),0)
      # This diagnostic is just plain wrong in CUDA 9
      # See https://github.com/kokkos/kokkos/issues/1470
      KOKKOS_CXXFLAGS += -Xcudafe --diag_suppress=esa_on_defaulted_function_ignored
    endif
  endif

  ifeq ($(KOKKOS_INTERNAL_CUDA_USE_LAMBDA), 1)
    ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
      ifeq ($(shell test $(KOKKOS_INTERNAL_COMPILER_NVCC_VERSION) -gt 70; echo $$?),0)
        tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_LAMBDA")
        KOKKOS_CXXFLAGS += -expt-extended-lambda
      else
        $(warning Warning: Cuda Lambda support was requested but NVCC version is too low. This requires NVCC for Cuda version 7.5 or higher. Disabling Lambda support now.)
      endif
    endif

    ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_LAMBDA")
    endif
  endif

  ifeq ($(KOKKOS_INTERNAL_CUDA_USE_CONSTEXPR), 1)
    ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
      ifeq ($(shell test $(KOKKOS_INTERNAL_COMPILER_NVCC_VERSION) -ge 80; echo $$?),0)
        tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_CONSTEXPR")
        KOKKOS_CXXFLAGS += -expt-relaxed-constexpr
      else
        $(warning Warning: Cuda relaxed constexpr support was requested but NVCC version is too low. This requires NVCC for Cuda version 8.0 or higher. Disabling relaxed constexpr support now.)
      endif
    endif

    ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_CONSTEXPR")
    endif
  endif

  ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_IMPL_CUDA_CLANG_WORKAROUND")
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
  ifeq ($(KOKKOS_INTERNAL_HPX_ENABLE_ASYNC_DISPATCH), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_HPX_ASYNC_DISPATCH")
  endif
endif

# Add Architecture flags.

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV80), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV80")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
    KOKKOS_CXXFLAGS +=
    KOKKOS_LDFLAGS +=
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
      KOKKOS_CXXFLAGS +=
      KOKKOS_LDFLAGS +=
    else
      KOKKOS_CXXFLAGS += -march=armv8-a
      KOKKOS_LDFLAGS += -march=armv8-a
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV81), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV81")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
    KOKKOS_CXXFLAGS +=
    KOKKOS_LDFLAGS +=
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
      KOKKOS_CXXFLAGS +=
      KOKKOS_LDFLAGS +=
    else
      KOKKOS_CXXFLAGS += -march=armv8.1-a
      KOKKOS_LDFLAGS += -march=armv8.1-a
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_A64FX), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_A64FX")

  KOKKOS_CXXFLAGS += -march=armv8.2-a+sve
  KOKKOS_LDFLAGS += -march=armv8.2-a+sve
  ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
    KOKKOS_CXXFLAGS += -msve-vector-bits=512
    KOKKOS_LDFLAGS += -msve-vector-bits=512
  endif
  ifeq ($(KOKKOS_INTERNAL_COMPILER_GCC), 1)
    KOKKOS_CXXFLAGS += -msve-vector-bits=512
    KOKKOS_LDFLAGS += -msve-vector-bits=512
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ZEN), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_ZEN")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_AVX2")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
    KOKKOS_CXXFLAGS += -mavx2
    KOKKOS_LDFLAGS += -mavx2
  else
    KOKKOS_CXXFLAGS += -march=znver1 -mtune=znver1
    KOKKOS_LDFLAGS += -march=znver1 -mtune=znver1
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ZEN2), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_ZEN2")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_AVX2")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
    KOKKOS_CXXFLAGS += -mavx2
    KOKKOS_LDFLAGS += -mavx2
  else
    KOKKOS_CXXFLAGS += -march=znver2 -mtune=znver2
    KOKKOS_LDFLAGS += -march=znver2 -mtune=znver2
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ZEN3), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_ZEN3")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_AVX2")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
    KOKKOS_CXXFLAGS += -mavx2
    KOKKOS_LDFLAGS += -mavx2
  else
    KOKKOS_CXXFLAGS += -march=znver3 -mtune=znver3
    KOKKOS_LDFLAGS += -march=znver3 -mtune=znver3
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV80")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV8_THUNDERX")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
    KOKKOS_CXXFLAGS +=
    KOKKOS_LDFLAGS +=
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
      KOKKOS_CXXFLAGS +=
      KOKKOS_LDFLAGS +=
    else
      KOKKOS_CXXFLAGS += -march=armv8-a -mtune=thunderx
      KOKKOS_LDFLAGS += -march=armv8-a -mtune=thunderx
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX2), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV81")
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV8_THUNDERX2")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
    KOKKOS_CXXFLAGS +=
    KOKKOS_LDFLAGS +=
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
      KOKKOS_CXXFLAGS +=
      KOKKOS_LDFLAGS +=
    else
      KOKKOS_CXXFLAGS += -mtune=thunderx2t99 -mcpu=thunderx2t99
      KOKKOS_LDFLAGS += -mtune=thunderx2t99 -mcpu=thunderx2t99
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_SSE42), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_SSE42")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
    KOKKOS_CXXFLAGS += -xSSE4.2
    KOKKOS_LDFLAGS  += -xSSE4.2
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)

    else
      ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
        KOKKOS_CXXFLAGS += -tp=nehalem
        KOKKOS_LDFLAGS  += -tp=nehalem
      else
        # Assume that this is a really a GNU compiler.
        KOKKOS_CXXFLAGS += -msse4.2
        KOKKOS_LDFLAGS  += -msse4.2
      endif
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AVX), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AVX")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
    KOKKOS_CXXFLAGS += -mavx
    KOKKOS_LDFLAGS  += -mavx
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)

    else
      ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
        KOKKOS_CXXFLAGS += -tp=sandybridge
        KOKKOS_LDFLAGS  += -tp=sandybridge
      else
        # Assume that this is a really a GNU compiler.
        KOKKOS_CXXFLAGS += -mavx
        KOKKOS_LDFLAGS  += -mavx
      endif
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_POWER7), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_POWER7")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)

  else
    # Assume that this is a really a GNU compiler or it could be XL on P8.
    KOKKOS_CXXFLAGS += -mcpu=power7 -mtune=power7
    KOKKOS_LDFLAGS  += -mcpu=power7 -mtune=power7
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_POWER8), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_POWER8")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)

  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1) 
        KOKKOS_CXXFLAGS += -mcpu=power8 -mtune=power8
        KOKKOS_LDFLAGS  += -mcpu=power8 -mtune=power8
    else
      ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)

      else 
        # Assume that this is a really a GNU compiler on P8.
        KOKKOS_CXXFLAGS += -mcpu=power8 -mtune=power8
        KOKKOS_LDFLAGS  += -mcpu=power8 -mtune=power8
      endif
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_POWER9), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_POWER9")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)

  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_XL), 1) 
        KOKKOS_CXXFLAGS += -mcpu=power9 -mtune=power9
        KOKKOS_LDFLAGS  += -mcpu=power9 -mtune=power9
    else
      ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)

      else 
        # Assume that this is a really a GNU compiler on P9
        KOKKOS_CXXFLAGS += -mcpu=power9 -mtune=power9
        KOKKOS_LDFLAGS  += -mcpu=power9 -mtune=power9
      endif
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_HSW), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AVX2")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
    KOKKOS_CXXFLAGS += -xCORE-AVX2
    KOKKOS_LDFLAGS  += -xCORE-AVX2
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)

    else
      ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
        KOKKOS_CXXFLAGS += -tp=haswell
        KOKKOS_LDFLAGS  += -tp=haswell
      else
        # Assume that this is a really a GNU compiler.
        KOKKOS_CXXFLAGS += -march=core-avx2 -mtune=core-avx2
        KOKKOS_LDFLAGS  += -march=core-avx2 -mtune=core-avx2
      endif
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_BDW), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AVX2")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
    KOKKOS_CXXFLAGS += -xCORE-AVX2
    KOKKOS_LDFLAGS  += -xCORE-AVX2
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)

    else
      ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)
        KOKKOS_CXXFLAGS += -tp=haswell
        KOKKOS_LDFLAGS  += -tp=haswell
      else
        # Assume that this is a really a GNU compiler.
        KOKKOS_CXXFLAGS += -march=core-avx2 -mtune=core-avx2 -mrtm
        KOKKOS_LDFLAGS  += -march=core-avx2 -mtune=core-avx2 -mrtm
      endif
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AVX512MIC), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AVX512MIC")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
    KOKKOS_CXXFLAGS += -xMIC-AVX512
    KOKKOS_LDFLAGS  += -xMIC-AVX512
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)

    else
      ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)

      else
        # Asssume that this is really a GNU compiler.
        KOKKOS_CXXFLAGS += -march=knl -mtune=knl
        KOKKOS_LDFLAGS  += -march=knl -mtune=knl
      endif
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AVX512XEON), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AVX512XEON")

  ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
    KOKKOS_CXXFLAGS += -xCORE-AVX512
    KOKKOS_LDFLAGS  += -xCORE-AVX512
  else
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)

    else
      ifeq ($(KOKKOS_INTERNAL_COMPILER_PGI), 1)

      else
        # Nothing here yet.
        KOKKOS_CXXFLAGS += -march=skylake-avx512 -mtune=skylake-avx512 -mrtm
        KOKKOS_LDFLAGS  += -march=skylake-avx512 -mtune=skylake-avx512 -mrtm
      endif
    endif
  endif
endif

ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KNC), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KNC")
  KOKKOS_CXXFLAGS += -mmic
  KOKKOS_LDFLAGS += -mmic
endif

# Figure out the architecture flag for Cuda.
ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
   KOKKOS_INTERNAL_USE_CUDA_ARCH=1
endif
ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
   ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
     KOKKOS_INTERNAL_USE_CUDA_ARCH=1
   endif
endif
ifeq ($(KOKKOS_INTERNAL_USE_CUDA_ARCH), 1)
  ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG=-arch
  else ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
		KOKKOS_INTERNAL_CUDA_ARCH_FLAG=--cuda-gpu-arch
		KOKKOS_CXXFLAGS += -x cuda
  else
    $(error Makefile.kokkos: CUDA is enabled but the compiler is neither NVCC nor Clang (got version string $(KOKKOS_CXX_VERSION)) )
  endif
  KOKKOS_INTERNAL_USE_CUDA_ARCH = 1
endif

ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
  ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG=-fopenmp-targets=nvptx64-nvidia-cuda -Xopenmp-target -march
  endif
  KOKKOS_INTERNAL_USE_CUDA_ARCH = 1
endif

ifeq ($(KOKKOS_INTERNAL_USE_CUDA_ARCH), 1)
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER30), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER30")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_30
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER32), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER32")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_32
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER35), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER35")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_35
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER37), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER37")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_37
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL50), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL50")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_50
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL52), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL52")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_52
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL53), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL53")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_53
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_PASCAL60), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL60")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_60
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_PASCAL61), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL61")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_61
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VOLTA70), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA70")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_70
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VOLTA72), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA72")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_72
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_TURING75), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_TURING")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_TURING75")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_75
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMPERE80), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE80")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_80
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMPERE86), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE86")
    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_86
  endif

  ifneq ($(KOKKOS_INTERNAL_USE_ARCH_NVIDIA), 0)
    KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)

    ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
      KOKKOS_LDFLAGS += $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)
    endif
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
      ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
        KOKKOS_LDFLAGS += $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)
      endif
    endif
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
    KOKKOS_CXXFLAGS += --expt-extended-lambda
  endif
endif


# Figure out the architecture flag for ROCm.
ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
  # Lets start with adding architecture defines
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA900), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_HIP 900")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA900")
    KOKKOS_INTERNAL_HIP_ARCH_FLAG := --amdgpu-target=gfx900
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA906), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_HIP 906")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA906")
    KOKKOS_INTERNAL_HIP_ARCH_FLAG := --amdgpu-target=gfx906
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA908), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_HIP 908")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA908")
    KOKKOS_INTERNAL_HIP_ARCH_FLAG := --amdgpu-target=gfx908
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA90A), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_HIP 90A")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA90A")
    KOKKOS_INTERNAL_HIP_ARCH_FLAG := --amdgpu-target=gfx90a
  endif


  KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/HIP/*.cpp)
  KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/HIP/*.hpp)

  KOKKOS_CXXFLAGS+=$(KOKKOS_INTERNAL_HIP_ARCH_FLAG)
  KOKKOS_LDFLAGS+=$(KOKKOS_INTERNAL_HIP_ARCH_FLAG)

  ifeq ($(KOKKOS_INTERNAL_HIP_USE_RELOC), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE")
    KOKKOS_CXXFLAGS+=-fgpu-rdc
    KOKKOS_LDFLAGS+=-fgpu-rdc
  else
    KOKKOS_CXXFLAGS+=-fno-gpu-rdc
    KOKKOS_LDFLAGS+=-fno-gpu-rdc
  endif
endif

# Figure out the architecture flag for SYCL.
ifeq ($(KOKKOS_INTERNAL_USE_SYCL), 1)
  # Lets start with adding architecture defines
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_GPU")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_GEN")
    KOKKOS_INTERNAL_SYCL_ARCH_FLAG := -fsycl-targets=spir64_gen-unknown-unknown-sycldevice -Xsycl-target-backend "-device gen9-"
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN9), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_GPU")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_GEN9")
    KOKKOS_INTERNAL_SYCL_ARCH_FLAG := -fsycl-targets=spir64_gen-unknown-unknown-sycldevice -Xsycl-target-backend "-device gen9"
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN11), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_GPU")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_GEN11")
    KOKKOS_INTERNAL_SYCL_ARCH_FLAG := -fsycl-targets=spir64_gen-unknown-unknown-sycldevice -Xsycl-target-backend "-device gen11"
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN12LP), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_GPU")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_GEN12LP")
    KOKKOS_INTERNAL_SYCL_ARCH_FLAG := -fsycl-targets=spir64_gen-unknown-unknown-sycldevice -Xsycl-target-backend "-device gen12lp"
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_DG1), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_GPU")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_DG1")
    KOKKOS_INTERNAL_SYCL_ARCH_FLAG := -fsycl-targets=spir64_gen-unknown-unknown-sycldevice -Xsycl-target-backend "-device dg1"
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_XEHP), 1)
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_GPU")
    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_INTEL_XEHP")
    KOKKOS_INTERNAL_SYCL_ARCH_FLAG := -fsycl-targets=spir64_gen-unknown-unknown-sycldevice -Xsycl-target-backend "-device xehp"
  endif

  KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/SYCL/*.cpp)
  KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/SYCL/*.hpp)

  KOKKOS_CXXFLAGS+=-fsycl -fno-sycl-id-queries-fit-in-int -fsycl-unnamed-lambda
  KOKKOS_CXXFLAGS+=$(KOKKOS_INTERNAL_SYCL_ARCH_FLAG)
  KOKKOS_LDFLAGS+=-fsycl
  KOKKOS_LDFLAGS+=$(KOKKOS_INTERNAL_SYCL_ARCH_FLAG)
endif

ifeq ($(KOKKOS_INTERNAL_ENABLE_DESUL_ATOMICS), 1)
  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_IMPL_DESUL_ATOMICS")
endif

KOKKOS_INTERNAL_LS_CONFIG := $(shell ls KokkosCore_config.h 2>&1)

ifeq ($(KOKKOS_INTERNAL_LS_CONFIG), KokkosCore_config.h)
  KOKKOS_INTERNAL_NEW_CONFIG := $(strip $(shell diff KokkosCore_config.h KokkosCore_config.tmp | grep -c define))
else
  KOKKOS_INTERNAL_NEW_CONFIG := 1
endif

ifneq ($(KOKKOS_INTERNAL_NEW_CONFIG), 0)
  tmp := $(shell cp KokkosCore_config.tmp KokkosCore_config.h)

  # Functions for generating config header file
  kokkos_start_config_header = $(shell sed 's~@INCLUDE_NEXT_FILE@~~g' $(KOKKOS_PATH)/cmake/KokkosCore_Config_HeaderSet.in > $1)
  kokkos_update_config_header = $(shell sed 's~@HEADER_GUARD_TAG@~$1~g' $2 > $3)
  kokkos_append_config_header = $(shell echo $1 >> $2))
  tmp := $(call kokkos_start_config_header, "KokkosCore_Config_FwdBackend.tmp")
  tmp := $(call kokkos_start_config_header, "KokkosCore_Config_SetupBackend.tmp")
  tmp := $(call kokkos_start_config_header, "KokkosCore_Config_DeclareBackend.tmp")
  tmp := $(call kokkos_start_config_header, "KokkosCore_Config_PostInclude.tmp")
  tmp := $(call kokkos_update_config_header, KOKKOS_FWD_HPP_, "KokkosCore_Config_FwdBackend.tmp", "KokkosCore_Config_FwdBackend.hpp")
  tmp := $(call kokkos_update_config_header, KOKKOS_SETUP_HPP_, "KokkosCore_Config_SetupBackend.tmp", "KokkosCore_Config_SetupBackend.hpp")
  tmp := $(call kokkos_update_config_header, KOKKOS_DECLARE_HPP_, "KokkosCore_Config_DeclareBackend.tmp", "KokkosCore_Config_DeclareBackend.hpp")
  tmp := $(call kokkos_update_config_header, KOKKOS_POST_INCLUDE_HPP_, "KokkosCore_Config_PostInclude.tmp", "KokkosCore_Config_PostInclude.hpp")
  ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_CUDA.hpp>","KokkosCore_Config_FwdBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_CUDA.hpp>","KokkosCore_Config_DeclareBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <setup/Kokkos_Setup_Cuda.hpp>","KokkosCore_Config_SetupBackend.hpp")
    ifeq ($(KOKKOS_INTERNAL_CUDA_USE_UVM), 1)
    else
    endif
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_OPENMPTARGET.hpp>","KokkosCore_Config_FwdBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_OPENMPTARGET.hpp>","KokkosCore_Config_DeclareBackend.hpp")
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_SYCL), 1)
    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_SYCL.hpp>","KokkosCore_Config_FwdBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_SYCL.hpp>","KokkosCore_Config_DeclareBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <setup/Kokkos_Setup_SYCL.hpp>","KokkosCore_Config_SetupBackend.hpp")
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_HIP.hpp>","KokkosCore_Config_FwdBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_HIP.hpp>","KokkosCore_Config_DeclareBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <setup/Kokkos_Setup_HIP.hpp>","KokkosCore_Config_SetupBackend.hpp")
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_OPENMP.hpp>","KokkosCore_Config_FwdBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_OPENMP.hpp>","KokkosCore_Config_DeclareBackend.hpp")
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 1)
    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_THREADS.hpp>","KokkosCore_Config_FwdBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_THREADS.hpp>","KokkosCore_Config_DeclareBackend.hpp")
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_HPX.hpp>","KokkosCore_Config_FwdBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_HPX.hpp>","KokkosCore_Config_DeclareBackend.hpp")
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_SERIAL.hpp>","KokkosCore_Config_FwdBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_SERIAL.hpp>","KokkosCore_Config_DeclareBackend.hpp")
  endif
  ifeq ($(KOKKOS_INTERNAL_USE_MEMKIND), 1)
    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_HBWSpace.hpp>","KokkosCore_Config_FwdBackend.hpp")
    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_HBWSpace.hpp>","KokkosCore_Config_DeclareBackend.hpp")
  endif
endif

KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/*.hpp)
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/impl/*.hpp)
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/containers/src/*.hpp)
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/containers/src/impl/*.hpp)
KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/algorithms/src/*.hpp)

KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/impl/*.cpp)
KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/containers/src/impl/*.cpp)

ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
  KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/Cuda/*.cpp)
  ifeq ($(KOKKOS_INTERNAL_ENABLE_DESUL_ATOMICS), 1)
    KOKKOS_SRC += $(KOKKOS_PATH)/core/src/desul/src/Lock_Array_CUDA.cpp
  endif
  KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/Cuda/*.hpp)
  ifneq ($(CUDA_PATH),)
    KOKKOS_CPPLAGS += -I$(CUDA_PATH)/include
    ifeq ($(call kokkos_path_exists,$(CUDA_PATH)/lib64), 1)
      KOKKOS_LIBDIRS += -L$(CUDA_PATH)/lib64
      KOKKOS_CXXLDFLAGS += -L$(CUDA_PATH)/lib64
      KOKKOS_TPL_LIBRARY_DIRS += $(CUDA_PATH)/lib64
    else ifeq ($(call kokkos_path_exists,$(CUDA_PATH)/lib), 1)
      KOKKOS_LIBDIRS += -L$(CUDA_PATH)/lib
      KOKKOS_CXXLDFLAGS += -L$(CUDA_PATH)/lib
      KOKKOS_TPL_LIBRARY_DIRS += $(CUDA_PATH)/lib
    else
      $(error Can't find CUDA library directory: no lib64 or lib directory in $(CUDA_PATH))
    endif
    KOKKOS_TPL_INCLUDE_DIRS += $(CUDA_PATH)/include
    ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
      KOKKOS_CXXFLAGS += --cuda-path=$(CUDA_PATH)
    endif
  endif
  KOKKOS_LIBS += -lcudart -lcuda
  KOKKOS_TPL_LIBRARY_NAMES += cudart cuda
endif

ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
  KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/OpenMPTarget/*.cpp)
  KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/OpenMPTarget/*.hpp)
  ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
    KOKKOS_CXXFLAGS += -Xcompiler $(KOKKOS_INTERNAL_OPENMPTARGET_FLAG)
  else
    KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_OPENMPTARGET_FLAG)
  endif
  KOKKOS_LDFLAGS += $(KOKKOS_INTERNAL_OPENMPTARGET_FLAG)
  KOKKOS_LIBS += $(KOKKOS_INTERNAL_OPENMPTARGET_LIB)
endif

ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
  KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/OpenMP/*.cpp)
  KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/OpenMP/*.hpp)

  ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
    KOKKOS_CXXFLAGS += -Xcompiler $(KOKKOS_INTERNAL_OPENMP_FLAG)
  else
    KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_OPENMP_FLAG)
  endif

  KOKKOS_LDFLAGS += $(KOKKOS_INTERNAL_OPENMP_FLAG)
  KOKKOS_LINK_FLAGS += $(KOKKOS_INTERNAL_OPENMP_FLAG)
endif

ifeq ($(KOKKOS_INTERNAL_USE_PTHREADS), 1)
  KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/Threads/*.cpp)
  KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/Threads/*.hpp)
  KOKKOS_LIBS += -lpthread
  KOKKOS_TPL_LIBRARY_NAMES += pthread
endif

ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
  KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/HPX/*.cpp)
  KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/HPX/*.hpp)
  ifneq ($(HPX_PATH),)
    ifeq ($(KOKKOS_INTERNAL_ENABLE_DEBUG), 1)
      KOKKOS_CXXFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --cflags hpx_application_debug)
      KOKKOS_CXXLDFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application_debug)
      KOKKOS_LIBS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application_debug)
    else
      KOKKOS_CXXFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --cflags hpx_application)
      KOKKOS_CXXLDFLAGS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application)
      KOKKOS_LIBS += $(shell PKG_CONFIG_PATH=$(HPX_PATH)/lib64/pkgconfig pkg-config --libs hpx_application)
    endif
  else
    ifeq ($(KOKKOS_INTERNAL_ENABLE_DEBUG), 1)
      KOKKOS_CXXFLAGS += $(shell pkg-config --cflags hpx_application_debug)
      KOKKOS_CXXLDFLAGS += $(shell pkg-config --libs hpx_application_debug)
      KOKKOS_LIBS += $(shell pkg-config --libs hpx_application_debug)
    else
      KOKKOS_CXXFLAGS += $(shell pkg-config --cflags hpx_application)
      KOKKOS_CXXLDFLAGS += $(shell pkg-config --libs hpx_application)
      KOKKOS_LIBS += $(shell pkg-config --libs hpx_application)
    endif
  endif
  KOKKOS_TPL_LIBRARY_NAMES += hpx
endif

# Explicitly set the GCC Toolchain for Clang.
ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
  KOKKOS_INTERNAL_GCC_PATH = $(shell which g++)
  KOKKOS_INTERNAL_GCC_TOOLCHAIN = $(KOKKOS_INTERNAL_GCC_PATH:/bin/g++=)
  KOKKOS_CXXFLAGS += --gcc-toolchain=$(KOKKOS_INTERNAL_GCC_TOOLCHAIN)
  KOKKOS_LDFLAGS += --gcc-toolchain=$(KOKKOS_INTERNAL_GCC_TOOLCHAIN)
endif

# Don't include Kokkos_HBWSpace.cpp if not using MEMKIND to avoid a link warning.
ifneq ($(KOKKOS_INTERNAL_USE_MEMKIND), 1)
  KOKKOS_SRC := $(filter-out $(KOKKOS_PATH)/core/src/impl/Kokkos_HBWSpace.cpp,$(KOKKOS_SRC))
endif

# Don't include Kokkos_Serial.cpp or Kokkos_Serial_Task.cpp if not using Serial
# device to avoid a link warning.
ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
endif
ifneq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
  KOKKOS_SRC := $(filter-out $(KOKKOS_PATH)/core/src/impl/Kokkos_Serial.cpp,$(KOKKOS_SRC))
  KOKKOS_SRC := $(filter-out $(KOKKOS_PATH)/core/src/impl/Kokkos_Serial_Task.cpp,$(KOKKOS_SRC))
endif

# With Cygwin functions such as fdopen and fileno are not defined
# when strict ansi is enabled. strict ansi gets enabled with -std=c++14
# though. So we hard undefine it here. Not sure if that has any bad side effects
# This is needed for gtest actually, not for Kokkos itself!
ifeq ($(KOKKOS_INTERNAL_OS_CYGWIN), 1)
  KOKKOS_CXXFLAGS += -U__STRICT_ANSI__
endif

# Set KokkosExtraLibs and add -lkokkos to link line
KOKKOS_EXTRA_LIBS := ${KOKKOS_LIBS}
KOKKOS_LIBS := -lkokkos ${KOKKOS_LIBS}

# Setting up dependencies.

KokkosCore_config.h:

KOKKOS_CPP_DEPENDS := KokkosCore_config.h $(KOKKOS_HEADERS)

KOKKOS_OBJ = $(KOKKOS_SRC:.cpp=.o)
KOKKOS_OBJ_LINK = $(notdir $(KOKKOS_OBJ))

include $(KOKKOS_PATH)/Makefile.targets

kokkos-clean:
	rm -f $(KOKKOS_OBJ_LINK) KokkosCore_config.h KokkosCore_config.tmp libkokkos.a KokkosCore_Config_SetupBackend.hpp \
	KokkosCore_Config_FwdBackend.hpp KokkosCore_Config_DeclareBackend.hpp KokkosCore_Config_DeclareBackend.tmp \
        KokkosCore_Config_FwdBackend.tmp KokkosCore_Config_PostInclude.hpp KokkosCore_Config_PostInclude.tmp KokkosCore_Config_SetupBackend.tmp

libkokkos.a: $(KOKKOS_OBJ_LINK) $(KOKKOS_SRC) $(KOKKOS_HEADERS)
	ar cr libkokkos.a $(KOKKOS_OBJ_LINK)
	ranlib libkokkos.a

print-cxx-flags: 
	echo "$(KOKKOS_CXXFLAGS)"

KOKKOS_LINK_DEPENDS=libkokkos.a

#we have carefully separated LDFLAGS from LIBS and LIBDIRS
#we have also separated CPPFLAGS from CXXFLAGS
#if this is not cmake, for backwards compatibility
#we just jam everything together into the CXXFLAGS and LDFLAGS
ifneq ($(KOKKOS_CMAKE), yes)
  KOKKOS_CXXFLAGS += $(KOKKOS_CPPFLAGS)
  KOKKOS_LDFLAGS += $(KOKKOS_LIBDIRS)
endif