3party/vcpkg
0
0
Fork 0
mirror of https://github.com/microsoft/vcpkg.git synced 2024-12-27 18:31:15 +08:00
Code Issues Projects Releases Wiki Activity

[lapack-reference|fortran] Add new port (#12805)

Browse Source 
* [vcpkg/script] add vcpkg_find_fortran

* [openblas] add pkg-config fixes

* [lapack] add lapack-reference and reduce dependency on clapack

* fix build issues

* dont touch any main files

* move toolchain var into parent scope

* fix a few more issues

* create link in the noblas case

* removed unnecessary check handled by vcpkg_find_fortran.

* move dumpbin check

* fix last issue

* depend on openblas

* set cmake_binary_dir so that compiler id run gets put into buildtree.

* more paths

* add missing PARENT_SCOPE

* ws change

* [mlpack] remove dep on clapack

* comment out patches

* remove openblas again

* Install lapack wrapper since it is missing linkage against -lm and -lgfortran

* PREPEND mingw path to make sure cmake picks it up correctly

* depend on openblas also on osx

* add clapack on windows to skip due to conflicting library installs

* add clapack to skip on linux

* add -fPIC as a fortran compiler flag

* do not add the flag on windows

* add gcc explicitly to the cmake args.

* ws change

* applyrequested changes from CR

* fix the failing patch
This commit is contained in:
Alexander Neumann 2020-08-12 19:28:41 +02:00 committed by GitHub
parent dea76199aa
commit f3b96f339c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 878 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ports/clapack/CONTROL
View File

@ -1,6 +1,6 @@
Source: clapack
Version: 3.2.1
Port-Version: 13
Port-Version: 14
Homepage: https://www.netlib.org/clapack
Description: CLAPACK (f2c'ed version of LAPACK)
Build-Depends: openblas (!osx)

6
ports/clapack/portfile.cmake
View File

@ -11,7 +11,7 @@ vcpkg_extract_source_archive_ex(
ARCHIVE ${ARCHIVE}
PATCHES
remove_internal_blas.patch
fix-ConfigFile.patch
fix-ConfigFile.patch
fix-install.patch
support-uwp.patch
)
@ -37,10 +37,6 @@ vcpkg_copy_pdbs()
#TODO: fix the official exported targets, since they are broken (luckily it seems that no-one uses them for now)
vcpkg_fixup_cmake_targets(CONFIG_PATH share/clapack)
#we install a cmake wrapper since the official FindLAPACK module in cmake does find clapack easily, unfortunately...
file(INSTALL ${CMAKE_CURRENT_LIST_DIR}/vcpkg-cmake-wrapper.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/lapack)
file(INSTALL ${CMAKE_CURRENT_LIST_DIR}/FindLAPACK.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/lapack)
file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/include)
# Handle copyright

16
ports/lapack-reference/CONTROL Normal file
View File

@ -0,0 +1,16 @@
Source: lapack-reference
Version: 3.8.0
Description: LAPACK — Linear Algebra PACKage http://www.netlib.org/lapack/
Default-Features: blas-select
Build-Depends: vcpkg-gfortran (windows)
Feature: cblas
Description: Builds CBLAS
Feature: noblas
Build-Depends: openblas
Description: Use external optimized BLAS
Feature: blas-select
Build-Depends: lapack-reference[core, noblas](!windows|(windows&!static))
Description: Use external optimized BLAS

568
ports/lapack-reference/FindLAPACK.cmake Normal file
View File

@ -0,0 +1,568 @@
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
#[=======================================================================[.rst:
FindLAPACK
----------
Find Linear Algebra PACKage (LAPACK) library
This module finds an installed Fortran library that implements the
LAPACK linear-algebra interface (see http://www.netlib.org/lapack/).
The approach follows that taken for the ``autoconf`` macro file,
``acx_lapack.m4`` (distributed at
http://ac-archive.sourceforge.net/ac-archive/acx_lapack.html).
Input Variables
^^^^^^^^^^^^^^^
The following variables may be set to influence this module's behavior:
``BLA_STATIC``
if ``ON`` use static linkage
``BLA_VENDOR``
If set, checks only the specified vendor, if not set checks all the
possibilities. List of vendors valid in this module:
* ``OpenBLAS``
* ``FLAME``
* ``Intel10_32`` (intel mkl v10 32 bit)
* ``Intel10_64lp`` (intel mkl v10+ 64 bit, threaded code, lp64 model)
* ``Intel10_64lp_seq`` (intel mkl v10+ 64 bit, sequential code, lp64 model)
* ``Intel10_64ilp`` (intel mkl v10+ 64 bit, threaded code, ilp64 model)
* ``Intel10_64ilp_seq`` (intel mkl v10+ 64 bit, sequential code, ilp64 model)
* ``Intel10_64_dyn`` (intel mkl v10+ 64 bit, single dynamic library)
* ``Intel`` (obsolete versions of mkl 32 and 64 bit)
* ``ACML``
* ``Apple``
* ``NAS``
* ``Arm``
* ``Arm_mp``
* ``Arm_ilp64``
* ``Arm_ilp64_mp``
* ``Generic``
``BLA_F95``
if ``ON`` tries to find the BLAS95/LAPACK95 interfaces
Imported targets
^^^^^^^^^^^^^^^^
This module defines the following :prop_tgt:`IMPORTED` target:
``LAPACK::LAPACK``
The libraries to use for LAPACK, if found.
Result Variables
^^^^^^^^^^^^^^^^
This module defines the following variables:
``LAPACK_FOUND``
library implementing the LAPACK interface is found
``LAPACK_LINKER_FLAGS``
uncached list of required linker flags (excluding ``-l`` and ``-L``).
``LAPACK_LIBRARIES``
uncached list of libraries (using full path name) to link against
to use LAPACK
``LAPACK95_LIBRARIES``
uncached list of libraries (using full path name) to link against
to use LAPACK95
``LAPACK95_FOUND``
library implementing the LAPACK95 interface is found
.. note::
C, CXX or Fortran must be enabled to detect a BLAS/LAPACK library.
C or CXX must be enabled to use Intel Math Kernel Library (MKL).
For example, to use Intel MKL libraries and/or Intel compiler:
.. code-block:: cmake
set(BLA_VENDOR Intel10_64lp)
find_package(LAPACK)
#]=======================================================================]
# Check the language being used
if(NOT (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED OR CMAKE_Fortran_COMPILER_LOADED))
if(LAPACK_FIND_REQUIRED)
message(FATAL_ERROR "FindLAPACK requires Fortran, C, or C++ to be enabled.")
else()
message(STATUS "Looking for LAPACK... - NOT found (Unsupported languages)")
return()
endif()
endif()
if(CMAKE_Fortran_COMPILER_LOADED)
include(${CMAKE_ROOT}/Modules/CheckFortranFunctionExists.cmake)
else()
include(${CMAKE_ROOT}/Modules/CheckFunctionExists.cmake)
endif()
include(${CMAKE_ROOT}/Modules/CMakePushCheckState.cmake)
cmake_push_check_state()
set(CMAKE_REQUIRED_QUIET ${LAPACK_FIND_QUIETLY})
set(LAPACK_FOUND FALSE)
set(LAPACK95_FOUND FALSE)
set(_lapack_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
if(BLA_STATIC)
if(WIN32)
set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES})
else()
set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
endif()
else()
if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
# for ubuntu's libblas3gf and liblapack3gf packages
set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES} .so.3gf)
endif()
endif()
# TODO: move this stuff to a separate module
macro(CHECK_LAPACK_LIBRARIES LIBRARIES _prefix _name _flags _list _threadlibs _addlibdir _subdirs _blas)
# This macro checks for the existence of the combination of fortran libraries
# given by _list. If the combination is found, this macro checks (using the
# Check_Fortran_Function_Exists macro) whether can link against that library
# combination using the name of a routine given by _name using the linker
# flags given by _flags. If the combination of libraries is found and passes
# the link test, LIBRARIES is set to the list of complete library paths that
# have been found. Otherwise, LIBRARIES is set to FALSE.
# N.B. _prefix is the prefix applied to the names of all cached variables that
# are generated internally and marked advanced by this macro.
# _addlibdir is a list of additional search paths. _subdirs is a list of path
# suffixes to be used by find_library().
set(_libraries_work TRUE)
set(${LIBRARIES})
set(_combined_name)
set(_extaddlibdir "${_addlibdir}")
if(WIN32)
list(APPEND _extaddlibdir ENV LIB)
elseif(APPLE)
list(APPEND _extaddlibdir ENV DYLD_LIBRARY_PATH)
else()
list(APPEND _extaddlibdir ENV LD_LIBRARY_PATH)
endif()
list(APPEND _extaddlibdir "${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}")
foreach(_library ${_list})
if(_library MATCHES "^-Wl,--(start|end)-group$")
# Respect linker flags like --start/end-group (required by MKL)
set(${LIBRARIES} ${${LIBRARIES}} "${_library}")
else()
set(_combined_name ${_combined_name}_${_library})
if(_libraries_work)
find_library(${_prefix}_${_library}_LIBRARY
NAMES ${_library}
PATHS ${_extaddlibdir}
PATH_SUFFIXES ${_subdirs}
)
#message("DEBUG: find_library(${_library}) got ${${_prefix}_${_library}_LIBRARY}")
mark_as_advanced(${_prefix}_${_library}_LIBRARY)
set(${LIBRARIES} ${${LIBRARIES}} ${${_prefix}_${_library}_LIBRARY})
set(_libraries_work ${${_prefix}_${_library}_LIBRARY})
endif()
endif()
endforeach()
if(_libraries_work)
# Test this combination of libraries.
set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${${LIBRARIES}} ${_blas} ${_threadlibs})
#message("DEBUG: CMAKE_REQUIRED_LIBRARIES = ${CMAKE_REQUIRED_LIBRARIES}")
if(CMAKE_Fortran_COMPILER_LOADED)
check_fortran_function_exists("${_name}" ${_prefix}${_combined_name}_WORKS)
else()
check_function_exists("${_name}_" ${_prefix}${_combined_name}_WORKS)
endif()
set(CMAKE_REQUIRED_LIBRARIES)
set(_libraries_work ${${_prefix}${_combined_name}_WORKS})
endif()
if(_libraries_work)
if("${_list}${_blas}" STREQUAL "")
set(${LIBRARIES} "${LIBRARIES}-PLACEHOLDER-FOR-EMPTY-LIBRARIES")
else()
set(${LIBRARIES} ${${LIBRARIES}} ${_blas} ${_threadlibs})
endif()
else()
set(${LIBRARIES} FALSE)
endif()
#message("DEBUG: ${LIBRARIES} = ${${LIBRARIES}}")
endmacro()
set(LAPACK_LINKER_FLAGS)
set(LAPACK_LIBRARIES)
set(LAPACK95_LIBRARIES)
if(LAPACK_FIND_QUIETLY OR NOT LAPACK_FIND_REQUIRED)
find_package(BLAS)
else()
find_package(BLAS REQUIRED)
endif()
if(BLAS_FOUND)
set(LAPACK_LINKER_FLAGS ${BLAS_LINKER_FLAGS})
if(NOT $ENV{BLA_VENDOR} STREQUAL "")
set(BLA_VENDOR $ENV{BLA_VENDOR})
else()
if(NOT BLA_VENDOR)
set(BLA_VENDOR "All")
endif()
endif()
# LAPACK in the Intel MKL 10+ library?
if(BLA_VENDOR MATCHES "Intel" OR BLA_VENDOR STREQUAL "All")
if(NOT LAPACK_LIBRARIES)
if(CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED)
# System-specific settings
if(NOT WIN32)
set(LAPACK_mkl_LM "-lm")
set(LAPACK_mkl_LDL "-ldl")
endif()
if(LAPACK_FIND_QUIETLY OR NOT LAPACK_FIND_REQUIRED)
find_package(Threads)
else()
find_package(Threads REQUIRED)
endif()
if(BLA_VENDOR MATCHES "_64ilp")
set(LAPACK_mkl_ILP_MODE "ilp64")
else()
set(LAPACK_mkl_ILP_MODE "lp64")
endif()
set(LAPACK_SEARCH_LIBS "")
if(BLA_F95)
set(LAPACK_mkl_SEARCH_SYMBOL "cheev_f95")
set(_LIBRARIES LAPACK95_LIBRARIES)
set(_BLAS_LIBRARIES ${BLAS95_LIBRARIES})
# old
list(APPEND LAPACK_SEARCH_LIBS
"mkl_lapack95")
# new >= 10.3
list(APPEND LAPACK_SEARCH_LIBS
"mkl_intel_c")
list(APPEND LAPACK_SEARCH_LIBS
"mkl_lapack95_${LAPACK_mkl_ILP_MODE}")
else()
set(LAPACK_mkl_SEARCH_SYMBOL "cheev")
set(_LIBRARIES LAPACK_LIBRARIES)
set(_BLAS_LIBRARIES ${BLAS_LIBRARIES})
# old and new >= 10.3
list(APPEND LAPACK_SEARCH_LIBS
"mkl_lapack")
endif()
# MKL uses a multitude of partially platform-specific subdirectories:
if(BLA_VENDOR STREQUAL "Intel10_32")
set(LAPACK_mkl_ARCH_NAME "ia32")
else()
set(LAPACK_mkl_ARCH_NAME "intel64")
endif()
if(WIN32)
set(LAPACK_mkl_OS_NAME "win")
elseif(APPLE)
set(LAPACK_mkl_OS_NAME "mac")
else()
set(LAPACK_mkl_OS_NAME "lin")
endif()
if(DEFINED ENV{MKLROOT})
file(TO_CMAKE_PATH "$ENV{MKLROOT}" LAPACK_mkl_MKLROOT)
# If MKLROOT points to the subdirectory 'mkl', use the parent directory instead
# so we can better detect other relevant libraries in 'compiler' or 'tbb':
get_filename_component(LAPACK_mkl_MKLROOT_LAST_DIR "${LAPACK_mkl_MKLROOT}" NAME)
if(LAPACK_mkl_MKLROOT_LAST_DIR STREQUAL "mkl")
get_filename_component(LAPACK_mkl_MKLROOT "${LAPACK_mkl_MKLROOT}" DIRECTORY)
endif()
endif()
set(LAPACK_mkl_LIB_PATH_SUFFIXES
"compiler/lib" "compiler/lib/${LAPACK_mkl_ARCH_NAME}_${LAPACK_mkl_OS_NAME}"
"mkl/lib" "mkl/lib/${LAPACK_mkl_ARCH_NAME}_${LAPACK_mkl_OS_NAME}"
"lib/${LAPACK_mkl_ARCH_NAME}_${LAPACK_mkl_OS_NAME}")
# First try empty lapack libs
if(NOT ${_LIBRARIES})
check_lapack_libraries(
${_LIBRARIES}
LAPACK
${LAPACK_mkl_SEARCH_SYMBOL}
""
""
"${CMAKE_THREAD_LIBS_INIT};${LAPACK_mkl_LM};${LAPACK_mkl_LDL}"
"${LAPACK_mkl_MKLROOT}"
"${LAPACK_mkl_LIB_PATH_SUFFIXES}"
"${_BLAS_LIBRARIES}"
)
endif()
# Then try the search libs
foreach(IT ${LAPACK_SEARCH_LIBS})
string(REPLACE " " ";" SEARCH_LIBS ${IT})
if(NOT ${_LIBRARIES})
check_lapack_libraries(
${_LIBRARIES}
LAPACK
${LAPACK_mkl_SEARCH_SYMBOL}
""
"${SEARCH_LIBS}"
"${CMAKE_THREAD_LIBS_INIT};${LAPACK_mkl_LM};${LAPACK_mkl_LDL}"
"${LAPACK_mkl_MKLROOT}"
"${LAPACK_mkl_LIB_PATH_SUFFIXES}"
"${_BLAS_LIBRARIES}"
)
endif()
endforeach()
unset(LAPACK_mkl_ILP_MODE)
unset(LAPACK_mkl_SEARCH_SYMBOL)
unset(LAPACK_mkl_LM)
unset(LAPACK_mkl_LDL)
unset(LAPACK_mkl_MKLROOT)
unset(LAPACK_mkl_ARCH_NAME)
unset(LAPACK_mkl_OS_NAME)
unset(LAPACK_mkl_LIB_PATH_SUFFIXES)
endif()
endif()
endif()
# gotoblas? (http://www.tacc.utexas.edu/tacc-projects/gotoblas2)
if(BLA_VENDOR STREQUAL "Goto" OR BLA_VENDOR STREQUAL "All")
if(NOT LAPACK_LIBRARIES)
check_lapack_libraries(
LAPACK_LIBRARIES
LAPACK
cheev
""
"goto2"
""
""
""
"${BLAS_LIBRARIES}"
)
endif()
endif()
# OpenBLAS? (http://www.openblas.net)
if(BLA_VENDOR STREQUAL "OpenBLAS" OR BLA_VENDOR STREQUAL "All")
if(NOT LAPACK_LIBRARIES)
check_lapack_libraries(
LAPACK_LIBRARIES
LAPACK
cheev
""
"openblas"
""
""
""
"${BLAS_LIBRARIES}"
)
endif()
endif()
# ArmPL? (https://developer.arm.com/tools-and-software/server-and-hpc/compile/arm-compiler-for-linux/arm-performance-libraries)
if(BLA_VENDOR MATCHES "Arm" OR BLA_VENDOR STREQUAL "All")
# Check for 64bit Integer support
if(BLA_VENDOR MATCHES "_ilp64")
set(LAPACK_armpl_LIB "armpl_ilp64")
else()
set(LAPACK_armpl_LIB "armpl_lp64")
endif()
# Check for OpenMP support, VIA BLA_VENDOR of Arm_mp or Arm_ipl64_mp
if(BLA_VENDOR MATCHES "_mp")
set(LAPACK_armpl_LIB "${LAPACK_armpl_LIB}_mp")
endif()
if(NOT LAPACK_LIBRARIES)
check_lapack_libraries(
LAPACK_LIBRARIES
LAPACK
cheev
""
"${LAPACK_armpl_LIB}"
""
""
""
"${BLAS_LIBRARIES}"
)
endif()
endif()
# FLAME's blis library? (https://github.com/flame/blis)
if(BLA_VENDOR STREQUAL "FLAME" OR BLA_VENDOR STREQUAL "All")
if(NOT LAPACK_LIBRARIES)
check_lapack_libraries(
LAPACK_LIBRARIES
LAPACK
cheev
""
"flame"
""
""
""
"${BLAS_LIBRARIES}"
)
endif()
endif()
# BLAS in acml library?
if(BLA_VENDOR MATCHES "ACML" OR BLA_VENDOR STREQUAL "All")
if(BLAS_LIBRARIES MATCHES ".+acml.+")
set(LAPACK_LIBRARIES ${BLAS_LIBRARIES})
endif()
endif()
# Apple LAPACK library?
if(BLA_VENDOR STREQUAL "Apple" OR BLA_VENDOR STREQUAL "All")
if(NOT LAPACK_LIBRARIES)
check_lapack_libraries(
LAPACK_LIBRARIES
LAPACK
cheev
""
"Accelerate"
""
""
""
"${BLAS_LIBRARIES}"
)
endif()
endif()
# Apple NAS (vecLib) library?
if(BLA_VENDOR STREQUAL "NAS" OR BLA_VENDOR STREQUAL "All")
if(NOT LAPACK_LIBRARIES)
check_lapack_libraries(
LAPACK_LIBRARIES
LAPACK
cheev
""
"vecLib"
""
""
""
"${BLAS_LIBRARIES}"
)
endif()
endif()
# Generic LAPACK library?
if(BLA_VENDOR STREQUAL "Generic" OR
BLA_VENDOR STREQUAL "ATLAS" OR
BLA_VENDOR STREQUAL "All")
if(NOT LAPACK_LIBRARIES)
check_lapack_libraries(
LAPACK_LIBRARIES
LAPACK
cheev
""
"lapack"
""
""
""
"${BLAS_LIBRARIES}"
)
endif()
if(NOT LAPACK_LIBRARIES AND NOT WIN32)
check_lapack_libraries(
LAPACK_LIBRARIES
LAPACK
cheev
""
"lapack;-lm;-lgfortran"
""
""
""
"${BLAS_LIBRARIES}"
)
endif()
endif()
else()
message(STATUS "LAPACK requires BLAS")
endif()
if(BLA_F95)
if(LAPACK95_LIBRARIES)
set(LAPACK95_FOUND TRUE)
else()
set(LAPACK95_FOUND FALSE)
endif()
if(NOT LAPACK_FIND_QUIETLY)
if(LAPACK95_FOUND)
message(STATUS "A library with LAPACK95 API found.")
else()
if(LAPACK_FIND_REQUIRED)
message(FATAL_ERROR
"A required library with LAPACK95 API not found. Please specify library location."
)
else()
message(STATUS
"A library with LAPACK95 API not found. Please specify library location."
)
endif()
endif()
endif()
set(LAPACK_FOUND "${LAPACK95_FOUND}")
set(LAPACK_LIBRARIES "${LAPACK95_LIBRARIES}")
else()
if(LAPACK_LIBRARIES)
set(LAPACK_FOUND TRUE)
else()
set(LAPACK_FOUND FALSE)
endif()
if(NOT LAPACK_FIND_QUIETLY)
if(LAPACK_FOUND)
message(STATUS "A library with LAPACK API found.")
else()
if(LAPACK_FIND_REQUIRED)
message(FATAL_ERROR
"A required library with LAPACK API not found. Please specify library location."
)
else()
message(STATUS
"A library with LAPACK API not found. Please specify library location."
)
endif()
endif()
endif()
endif()
# On compilers that implicitly link LAPACK (such as ftn, cc, and CC on Cray HPC machines)
# we used a placeholder for empty LAPACK_LIBRARIES to get through our logic above.
if(LAPACK_LIBRARIES STREQUAL "LAPACK_LIBRARIES-PLACEHOLDER-FOR-EMPTY-LIBRARIES")
set(LAPACK_LIBRARIES "")
endif()
if(NOT TARGET LAPACK::LAPACK)
add_library(LAPACK::LAPACK INTERFACE IMPORTED)
set(_lapack_libs "${LAPACK_LIBRARIES}")
if(_lapack_libs AND TARGET BLAS::BLAS)
# remove the ${BLAS_LIBRARIES} from the interface and replace it
# with the BLAS::BLAS target
list(REMOVE_ITEM _lapack_libs "${BLAS_LIBRARIES}")
endif()
if(_lapack_libs)
set_target_properties(LAPACK::LAPACK PROPERTIES
INTERFACE_LINK_LIBRARIES "${_lapack_libs}"
)
endif()
unset(_lapack_libs)
endif()
cmake_pop_check_state()
set(CMAKE_FIND_LIBRARY_SUFFIXES ${_lapack_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})

123
ports/lapack-reference/portfile.cmake Normal file
View File

@ -0,0 +1,123 @@
#TODO: Features to add:
# USE_XBLAS??? extended precision blas. needs xblas
# LAPACKE should be its own PORT
# USE_OPTIMIZED_LAPACK (Probably not what we want. Does a find_package(LAPACK): probably for LAPACKE only builds _> own port?)
# LAPACKE Builds LAPACKE
# LAPACKE_WITH_TMG Build LAPACKE with tmglib routines
include(vcpkg_find_fortran)
SET(VCPKG_POLICY_EMPTY_INCLUDE_FOLDER enabled)
set(lapack_ver 3.8.0)
vcpkg_from_github(
OUT_SOURCE_PATH SOURCE_PATH
REPO "Reference-LAPACK/lapack"
REF "v${lapack_ver}"
SHA512 17786cb7306fccdc9b4a242de7f64fc261ebe6a10b6ec55f519deb4cb673cb137e8742aa5698fd2dc52f1cd56d3bd116af3f593a01dcf6770c4dcc86c50b2a7f
HEAD_REF master
)
if(NOT VCPKG_TARGET_IS_WINDOWS)
set(ENV{FFLAGS} "$ENV{FFLAGS} -fPIC")
endif()
set(CBLAS OFF)
if("cblas" IN_LIST FEATURES)
set(CBLAS ON)
endif()
set(USE_OPTIMIZED_BLAS OFF)
if("noblas" IN_LIST FEATURES)
set(USE_OPTIMIZED_BLAS ON)
set(pcfile "${CURRENT_INSTALLED_DIR}/lib/pkgconfig/openblas.pc")
if(EXISTS "${pcfile}")
file(CREATE_LINK "${pcfile}" "${CURRENT_PACKAGES_DIR}/lib/pkgconfig/blas.pc" COPY_ON_ERROR)
endif()
set(pcfile "${CURRENT_INSTALLED_DIR}/debug/lib/pkgconfig/openblas.pc")
if(EXISTS "${pcfile}")
file(CREATE_LINK "${pcfile}" "${CURRENT_PACKAGES_DIR}/debug/lib/pkgconfig/blas.pc" COPY_ON_ERROR)
endif()
endif()
set(VCPKG_CRT_LINKAGE_BACKUP ${VCPKG_CRT_LINKAGE})
vcpkg_find_fortran(FORTRAN_CMAKE)
if(VCPKG_USE_INTERNAL_Fortran)
if(VCPKG_CRT_LINKAGE_BACKUP STREQUAL static)
# If openblas has been built with static crt linkage we cannot use it with gfortran!
set(USE_OPTIMIZED_BLAS OFF)
#Cannot use openblas from vcpkg if we are building with gfortran here.
if("noblas" IN_LIST FEATURES)
message(FATAL_ERROR "Feature 'noblas' cannot be used without supplying an external fortran compiler")
endif()
endif()
else()
set(USE_OPTIMIZED_BLAS ON)
endif()
vcpkg_configure_cmake(
PREFER_NINJA
SOURCE_PATH ${SOURCE_PATH}
OPTIONS
"-DUSE_OPTIMIZED_BLAS=${USE_OPTIMIZED_BLAS}"
"-DCBLAS=${CBLAS}"
"${FORTRAN_CMAKE}"
)
vcpkg_install_cmake()
vcpkg_fixup_cmake_targets(CONFIG_PATH lib/cmake/lapack-${lapack_ver}) #Should the target path be lapack and not lapack-reference?
set(pcfile "${CURRENT_PACKAGES_DIR}/lib/pkgconfig/lapack.pc")
if(EXISTS "${pcfile}")
file(READ "${pcfile}" _contents)
set(_contents "prefix=${CURRENT_INSTALLED_DIR}\n${_contents}")
file(WRITE "${pcfile}" "${_contents}")
endif()
set(pcfile "${CURRENT_PACKAGES_DIR}/debug/lib/pkgconfig/lapack.pc")
if(EXISTS "${pcfile}")
file(READ "${pcfile}" _contents)
set(_contents "prefix=${CURRENT_INSTALLED_DIR}/debug\n${_contents}")
file(WRITE "${pcfile}" "${_contents}")
endif()
if(NOT USE_OPTIMIZED_BLAS)
set(pcfile "${CURRENT_PACKAGES_DIR}/lib/pkgconfig/blas.pc")
if(EXISTS "${pcfile}")
file(READ "${pcfile}" _contents)
set(_contents "prefix=${CURRENT_INSTALLED_DIR}\n${_contents}")
file(WRITE "${pcfile}" "${_contents}")
endif()
set(pcfile "${CURRENT_PACKAGES_DIR}/debug/lib/pkgconfig/blas.pc")
if(EXISTS "${pcfile}")
file(READ "${pcfile}" _contents)
set(_contents "prefix=${CURRENT_INSTALLED_DIR}/debug\n${_contents}")
file(WRITE "${pcfile}" "${_contents}")
endif()
endif()
vcpkg_fixup_pkgconfig()
vcpkg_copy_pdbs()
# Handle copyright
file(INSTALL "${SOURCE_PATH}/LICENSE" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}" RENAME copyright)
# remove debug includs
file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/include)
if(VCPKG_TARGET_IS_WINDOWS)
if(EXISTS "${CURRENT_PACKAGES_DIR}/lib/liblapack.lib")
file(RENAME "${CURRENT_PACKAGES_DIR}/lib/liblapack.lib" "${CURRENT_PACKAGES_DIR}/lib/lapack.lib")
endif()
if(EXISTS "${CURRENT_PACKAGES_DIR}/debug/lib/liblapack.lib")
file(RENAME "${CURRENT_PACKAGES_DIR}/debug/lib/liblapack.lib" "${CURRENT_PACKAGES_DIR}/debug/lib/lapack.lib")
endif()
if(NOT USE_OPTIMIZED_BLAS)
if(EXISTS "${CURRENT_PACKAGES_DIR}/lib/libblas.lib")
file(RENAME "${CURRENT_PACKAGES_DIR}/lib/libblas.lib" "${CURRENT_PACKAGES_DIR}/lib/blas.lib")
endif()
if(EXISTS "${CURRENT_PACKAGES_DIR}/debug/lib/libblas.lib")
file(RENAME "${CURRENT_PACKAGES_DIR}/debug/lib/libblas.lib" "${CURRENT_PACKAGES_DIR}/debug/lib/blas.lib")
endif()
endif()
endif()
if(NOT VCPKG_TARGET_IS_WINDOWS)
file(COPY ${CMAKE_CURRENT_LIST_DIR}/vcpkg-cmake-wrapper.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/lapack)
file(COPY ${CMAKE_CURRENT_LIST_DIR}/FindLAPACK.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/lapack)
endif()

2
ports/lapack-reference/vcpkg-cmake-wrapper.cmake Normal file
View File

@ -0,0 +1,2 @@
message(STATUS "Using VCPKG FindLAPACK. Remove if CMake has been updated to account for -lm and -lgfortran in lapack-reference!")
include(${CMAKE_CURRENT_LIST_DIR}/FindLAPACK.cmake)

4
ports/lapack/CONTROL
View File

@ -1,4 +1,4 @@
Source: lapack
Version: 0
Version: 1
Description: Metapackage for packages which provide LAPACK
Build-Depends: clapack (!osx)
Build-Depends: clapack ((arm&windows)|uwp), lapack-reference(!uwp&!(arm&windows))

0
ports/clapack/FindLAPACK.cmake → ports/lapack/clapack/FindLAPACK.cmake
View File

0
ports/clapack/vcpkg-cmake-wrapper.cmake → ports/lapack/clapack/vcpkg-cmake-wrapper.cmake
View File

9
ports/lapack/portfile.cmake
View File

@ -1,3 +1,10 @@
SET(VCPKG_POLICY_EMPTY_PACKAGE enabled)
# Make sure LAPACK can be found
vcpkg_configure_cmake(SOURCE_PATH ${CURRENT_PORT_DIR})
if(VCPKG_TARGET_IS_UWP OR VCPKG_TARGET_IS_WINDOWS AND VCPKG_TARGET_ARCHITECTURE MATCHES "arm")
# Install clapack wrappers.
file(INSTALL ${CMAKE_CURRENT_LIST_DIR}/clapack/vcpkg-cmake-wrapper.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share//${PORT})
file(INSTALL ${CMAKE_CURRENT_LIST_DIR}/clapack/FindLAPACK.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share//${PORT})
endif()
vcpkg_configure_cmake(SOURCE_PATH ${CURRENT_PORT_DIR}
OPTIONS -DCMAKE_PREFIX_PATH="${CURRENT_PACKAGES_DIR}")

2
ports/mlpack/CONTROL
View File

@ -1,6 +1,6 @@
Source: mlpack
Version: 3.2.2
Port-Version: 4
Port-Version: 5
Homepage: https://github.com/mlpack/mlpack
Description: mlpack is a fast, flexible machine learning library, written in C++, that aims to provide fast, extensible implementations of cutting-edge machine learning algorithms.
Build-Depends: openblas (!osx), lapack, boost, armadillo, ensmallen, stb

18
ports/mlpack/cmakelists.patch
View File

@ -2,7 +2,7 @@ diff --git a/CMakeLists.txt b/CMakeLists.txt
index 26757a5..c200b40 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -288,6 +288,7 @@ endif()
@@ -288,6 +282,7 @@ endif()
# and find LAPACK and BLAS ourselves, using a slightly modified variant of the
# script Armadillo uses to find these.
if (WIN32)
@ -10,16 +10,14 @@ index 26757a5..c200b40 100644
find_library(LAPACK_LIBRARY
NAMES lapack liblapack lapack_win32_MT lapack_win32
PATHS "C:/Program Files/Armadillo"
@@ -305,24 +306,31 @@ if (WIN32)
@@ -305,24 +306,25 @@ if (WIN32)
if (NOT BLAS_LIBRARY)
message(FATAL_ERROR "Cannot find BLAS library (.lib)!")
endif ()
+ endif()
+ find_package(clapack CONFIG REQUIRED)
+ set(LAPACK_LIBRARIES lapack)
+ find_package(OpenBLAS CONFIG REQUIRED)
+ set(BLAS_LIBRARIES OpenBLAS::OpenBLAS)
+ find_package(LAPACK REQUIRED)
+ find_package(BLAS REQUIRED)
# Piggyback LAPACK and BLAS linking into Armadillo link.
set(ARMADILLO_LIBRARIES
- ${ARMADILLO_LIBRARIES} ${BLAS_LIBRARY} ${LAPACK_LIBRARY})
@ -28,23 +26,19 @@ index 26757a5..c200b40 100644
# Ensure that the libraries are added to the MSVC IDE runtime path.
- get_filename_component(BLAS_DIR ${BLAS_LIBRARY} DIRECTORY)
- get_filename_component(LAPACK_DIR ${LAPACK_LIBRARY} DIRECTORY)
+ get_property(BLAS_DIR TARGET OpenBLAS::OpenBLAS PROPERTY IMPORTED_LOCATION_RELEASE)
+ get_filename_component(BLAS_DIR ${BLAS_DIR} DIRECTORY)
+ get_property(LAPACK_DIR TARGET lapack PROPERTY IMPORTED_LOCATION_RELEASE)
+ get_filename_component(LAPACK_DIR ${LAPACK_DIR} DIRECTORY)
# Sometimes, especially with an OpenBLAS install via nuget, the DLLs are
# actually in ../../bin/x64/. Automatically add these.
- if (EXISTS "${BLAS_DIR}/../../bin/x64/")
- get_filename_component(BLAS_DLL_DIR "${BLAS_DIR}/../../bin/x64" ABSOLUTE)
+ if (EXISTS "${BLAS_DIR}")
+ if (0)
+ get_filename_component(BLAS_DLL_DIR "${BLAS_DIR}" ABSOLUTE)
set(DLL_COPY_DIRS ${DLL_COPY_DIRS} "${BLAS_DLL_DIR}")
endif ()
- if (EXISTS "${LAPACK_DIR}/../../bin/x64/")
- get_filename_component(LAPACK_DLL_DIR "${LAPACK_DIR}/../../bin/x64" ABSOLUTE)
+ if (EXISTS "${LAPACK_DIR}")
+ if (0)
+ get_filename_component(LAPACK_DLL_DIR "${LAPACK_DIR}" ABSOLUTE)
set(DLL_COPY_DIRS ${DLL_COPY_DIRS} "${BLAS_DLL_DIR}")
endif ()

5
ports/openblas/CONTROL
View File

@ -1,5 +1,6 @@
Source: openblas
Version: 0.3.9-1
Version: 0.3.9
Port-Version: 2
Homepage: https://github.com/xianyi/OpenBLAS
Build-Depends: pthread (linux)
Build-Depends: pthread (linux&osx)
Description: OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version.

32
ports/openblas/portfile.cmake
View File

@ -1,5 +1,3 @@
include(vcpkg_common_functions)
vcpkg_from_github(
OUT_SOURCE_PATH SOURCE_PATH
REPO xianyi/OpenBLAS
@ -22,13 +20,15 @@ set(SED_EXE_PATH "${GIT_EXE_PATH}/../usr/bin")
# openblas require perl to generate .def for exports
vcpkg_find_acquire_program(PERL)
get_filename_component(PERL_EXE_PATH ${PERL} DIRECTORY)
set(ENV{PATH} "$ENV{PATH};${PERL_EXE_PATH};${SED_EXE_PATH}")
set(PATH_BACKUP "$ENV{PATH}")
vcpkg_add_to_path("${PERL_EXE_PATH}")
vcpkg_add_to_path("${SED_EXE_PATH}")
set(COMMON_OPTIONS -DBUILD_WITHOUT_LAPACK=ON)
# for UWP version, must build non uwp first for helper
# binaries.
if(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
if(VCPKG_TARGET_IS_UWP)
message(STATUS "Building Windows helper files")
set(TEMP_CMAKE_SYSTEM_NAME "${VCPKG_CMAKE_SYSTEM_NAME}")
set(TEMP_CMAKE_SYSTEM_VERSION "${VCPKG_CMAKE_SYSTEM_VERSION}")
@ -46,7 +46,7 @@ if(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
# add just built path to environment for gen_config_h.exe,
# getarch.exe and getarch_2nd.exe
set(ENV{PATH} "$ENV{PATH};${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
vcpkg_add_to_path("${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
# restore target build information
set(VCPKG_CMAKE_SYSTEM_NAME "${TEMP_CMAKE_SYSTEM_NAME}")
@ -63,7 +63,7 @@ if(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
-DVS_WINRT_COMPONENT=TRUE
"-DBLASHELPER_BINARY_DIR=${CURRENT_BUILDTREES_DIR}/x64-windows-rel")
elseif(NOT VCPKG_CMAKE_SYSTEM_NAME)
elseif(VCPKG_TARGET_IS_WINDOWS)
vcpkg_configure_cmake(
PREFER_NINJA
SOURCE_PATH ${SOURCE_PATH}
@ -85,6 +85,23 @@ endif()
vcpkg_install_cmake()
vcpkg_fixup_cmake_targets(CONFIG_PATH share/cmake/OpenBLAS TARGET_PATH share/openblas)
set(ENV{PATH} "${PATH_BACKUP}")
set(pcfile "${CURRENT_PACKAGES_DIR}/lib/pkgconfig/openblas.pc")
if(EXISTS "${pcfile}")
file(READ "${pcfile}" _contents)
set(_contents "prefix=${CURRENT_INSTALLED_DIR}\n${_contents}")
file(WRITE "${pcfile}" "${_contents}")
#file(CREATE_LINK "${pcfile}" "${CURRENT_PACKAGES_DIR}/lib/pkgconfig/blas.pc" COPY_ON_ERROR)
endif()
set(pcfile "${CURRENT_PACKAGES_DIR}/debug/lib/pkgconfig/openblas.pc")
if(EXISTS "${pcfile}")
file(READ "${pcfile}" _contents)
set(_contents "prefix=${CURRENT_INSTALLED_DIR}/debug\n${_contents}")
file(WRITE "${pcfile}" "${_contents}")
#file(CREATE_LINK "${pcfile}" "${CURRENT_PACKAGES_DIR}/debug/lib/pkgconfig/blas.pc" COPY_ON_ERROR)
endif()
vcpkg_fixup_pkgconfig()
#maybe we need also to write a wrapper inside share/blas to search implicitly for openblas, whenever we feel it's ready for its own -config.cmake file
# openblas do not make the config file , so I manually made this
@ -97,8 +114,7 @@ string(REPLACE "#include \"common.h\"" "#include \"openblas_common.h\"" CBLAS_H
file(WRITE ${CURRENT_PACKAGES_DIR}/include/cblas.h "${CBLAS_H}")
# openblas is BSD
file(COPY ${SOURCE_PATH}/LICENSE DESTINATION ${CURRENT_PACKAGES_DIR}/share/openblas)
file(RENAME ${CURRENT_PACKAGES_DIR}/share/openblas/LICENSE ${CURRENT_PACKAGES_DIR}/share/openblas/copyright)
file(INSTALL ${SOURCE_PATH}/LICENSE DESTINATION ${CURRENT_PACKAGES_DIR}/share/${PORT} RENAME copyright)
file(COPY ${CMAKE_CURRENT_LIST_DIR}/vcpkg-cmake-wrapper.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/blas)
file(COPY ${CMAKE_CURRENT_LIST_DIR}/FindBLAS.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/blas)

4
ports/vcpkg-gfortran/CONTROL Normal file
View File

@ -0,0 +1,4 @@
Source: vcpkg-gfortran
Version: 1
Description: Metaport to install gfortran dependencies from msys if VCPKG_USE_EXTERNAL_Fortran is false
Supports: windows & !arm

53
ports/vcpkg-gfortran/portfile.cmake Normal file
View File

@ -0,0 +1,53 @@
vcpkg_fail_port_install(ON_ARCH "arm" ON_TARGET "linux" "osx")
include(vcpkg_find_fortran)
vcpkg_find_fortran(FORTRAN_CMAKE)
if(VCPKG_USE_INTERNAL_Fortran)
set(VCPKG_CRT_LINKAGE dynamic) # Will always be dynamic no way to overwrite internal CRT linkage here
vcpkg_check_linkage(ONLY_DYNAMIC_LIBRARY)
if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
set(HOST_ARCH $ENV{PROCESSOR_ARCHITEW6432})
else()
set(HOST_ARCH $ENV{PROCESSOR_ARCHITECTURE})
endif()
if(HOST_ARCH MATCHES "(amd|AMD)64")
set(MINGW_W w64)
set(MSYS_HOST x86_64)
elseif(HOST_ARCH MATCHES "(x|X)86")
set(MINGW_W w32)
set(MSYS_HOST i686)
else()
message(FATAL_ERROR "Unsupported host architecture ${HOST_ARCH}!" )
endif()
if(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)64")
set(MSYS_TARGET x86_64)
set(MINGW_W_TARGET 64)
set(GCC_LIB_SUFFIX s_seh-1)
elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86")
set(MSYS_TARGET i686)
set(MINGW_W_TARGET 32)
set(GCC_LIB_SUFFIX s_dw2-1)
else()
message(FATAL_ERROR "Unsupported target architecture ${VCPKG_TARGET_ARCHITECTURE}!" )
endif()
vcpkg_acquire_msys(MSYS_ROOT PACKAGES "mingw-w64-${MSYS_TARGET}-gcc-fortran") # TODO: make x86 work
set(MINGW_BIN "${MSYS_ROOT}/mingw${MINGW_W_TARGET}/bin/")
set(MINGW_Fortran_DLLS "${MINGW_BIN}/libgfortran-5.dll"
"${MINGW_BIN}/libquadmath-0.dll"
"${MINGW_BIN}/libwinpthread-1.dll"
"${MINGW_BIN}/libgcc_${GCC_LIB_SUFFIX}.dll")
file(INSTALL ${MINGW_Fortran_DLLS} DESTINATION "${CURRENT_PACKAGES_DIR}/bin")
file(INSTALL ${MINGW_Fortran_DLLS} DESTINATION "${CURRENT_PACKAGES_DIR}/debug/bin")
set(VCPKG_POLICY_SKIP_DUMPBIN_CHECKS enabled) # due to outdated msvcrt
set(VCPKG_POLICY_DLLS_WITHOUT_LIBS enabled)
set(VCPKG_POLICY_EMPTY_INCLUDE_FOLDER enabled)
file(INSTALL "${MSYS_ROOT}/mingw${MINGW_W_TARGET}/share/licenses/winpthreads" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}/license")
file(INSTALL "${MSYS_ROOT}/mingw${MINGW_W_TARGET}/share/licenses/gcc-libs" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}/license")
file(INSTALL "${MSYS_ROOT}/mingw${MINGW_W_TARGET}/share/licenses/crt/COPYING.MinGW-w64-runtime.txt" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}" RENAME copyright)
else()
set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
endif()

5
scripts/ci.baseline.txt
View File

@ -208,6 +208,11 @@ chmlib:x64-uwp=fail
civetweb:arm64-windows = skip
civetweb:arm-uwp = skip
civetweb:x64-uwp = skip
# clapack is replaced by lapack-reference.
clapack:x64-linux = skip
clapack:x64-windows = skip
clapack:x64-windows-static = skip
clapack:x86-windows = skip
clapack:x64-uwp=fail
clblas:arm64-windows=fail
clblast:x64-linux=fail

61
scripts/cmake/vcpkg_find_fortran.cmake Normal file
View File

@ -0,0 +1,61 @@
## # vcpkg_find_fortran
##
## Checks if a Fortran compiler can be found.
## Windows(x86/x64) Only: If not it will switch/enable MinGW gfortran
## and return required cmake args for building.
##
## ## Usage
## ```cmake
## vcpkg_find_fortran(<additional_cmake_args_out>
## )
## ```
function(vcpkg_find_fortran additional_cmake_args_out)
set(ARGS_OUT)
set(CMAKE_BINARY_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}")
set(CMAKE_CURRENT_BINARY_DIR "${CMAKE_BINARY_DIR}")
set(CMAKE_PLATFORM_INFO_DIR "${CMAKE_BINARY_DIR}/Platform")
include(CMakeDetermineFortranCompiler)
if(NOT CMAKE_Fortran_COMPILER AND NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
# This intentionally breaks users with a custom toolchain which do not have a Fortran compiler setup
# because they either need to use a port-overlay (for e.g. lapack), remove the toolchain for the port using fortran
# or setup fortran in their VCPKG_CHAINLOAD_TOOLCHAIN_FILE themselfs!
if(WIN32)
message(STATUS "No Fortran compiler found on the PATH. Using MinGW gfortran!")
# If no Fortran compiler is on the path we switch to use gfortan from MinGW within vcpkg
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/mingw.cmake") # Switching to mingw toolchain
if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
set(MINGW_PATH mingw32)
set(MSYS_TARGET i686)
set(MACHINE_FLAG -m32)
elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
set(MINGW_PATH mingw64)
set(MSYS_TARGET x86_64)
set(MACHINE_FLAG -m64)
else()
message(FATAL_ERROR "Unknown architecture '${VCPKG_TARGET_ARCHITECTURE}' for MinGW Fortran build!")
endif()
vcpkg_acquire_msys(MSYS_ROOT "mingw-w64-${MSYS_TARGET}-gcc-fortran")
set(MINGW_BIN "${MSYS_ROOT}/${MINGW_PATH}/bin")
vcpkg_add_to_path(PREPEND "${MINGW_BIN}")
list(APPEND ARGS_OUT -DCMAKE_GNUtoMS=ON
"-DCMAKE_Fortran_COMPILER=${MINGW_BIN}/gfortran.exe"
"-DCMAKE_C_COMPILER=${MINGW_BIN}/gcc.exe"
"-DCMAKE_Fortran_FLAGS_INIT:STRING= -mabi=ms ${MACHINE_FLAG} ${VCPKG_Fortran_FLAGS}")
set(VCPKG_USE_INTERNAL_Fortran TRUE PARENT_SCOPE)
set(VCPKG_POLICY_SKIP_DUMPBIN_CHECKS enabled PARENT_SCOPE)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/mingw.cmake" PARENT_SCOPE) # Switching to MinGW toolchain for Fortran
if(VCPKG_CRT_LINKAGE STREQUAL "static")
set(VCPKG_CRT_LINKAGE dynamic PARENT_SCOPE)
message(STATUS "VCPKG_CRT_LINKAGE linkage for ${PORT} using vcpkg's internal gfortran cannot be static due to linking against MinGW libraries. Forcing dynamic CRT linkage")
endif()
if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
set(VCPKG_LIBRARY_LINKAGE dynamic PARENT_SCOPE)
message(STATUS "VCPKG_LIBRARY_LINKAGE linkage for ${PORT} using vcpkg's internal gfortran cannot be static due to linking against MinGW libraries. Forcing dynamic library linkage")
endif()
else()
message(FATAL_ERROR "Unable to find a Fortran compiler using 'CMakeDetermineFortranCompiler'. Please install one (e.g. gfortran) and make it available on the PATH!")
endif()
endif()
set(${additional_cmake_args_out} ${ARGS_OUT} PARENT_SCOPE)
endfunction()