diff --git a/scripts/cmake/vcpkg_build_make.cmake b/scripts/cmake/vcpkg_build_make.cmake
index dd845bde45d522..a454c2570968e4 100755
--- a/scripts/cmake/vcpkg_build_make.cmake
+++ b/scripts/cmake/vcpkg_build_make.cmake
@@ -55,8 +55,17 @@ function(vcpkg_build_make)
         # vcpkg_build_make called without using vcpkg_configure_make before
         vcpkg_internal_get_cmake_vars(OUTPUT_FILE _VCPKG_CMAKE_VARS_FILE)
     endif()
+
     include("${_VCPKG_CMAKE_VARS_FILE}")
 
+    if(VCPKG_CROSSCOMPILING)
+        if(NOT _VCPKG_HOST_CMAKE_VARS_FILE)
+            _vcpkg_cmake_to_vcpkg_arch(${CMAKE_HOST_SYSTEM_PROCESSOR} _host_arch)
+            vcpkg_internal_get_cmake_vars(OUTPUT_FILE _VCPKG_HOST_CMAKE_VARS_FILE TRIPLET ${_HOST_TRIPLET} VAR_PREFIX VCPKG_DETECTED_FOR_BUILD TARGET_ARCHITECTURE ${_host_arch})
+        endif()
+        include("${_VCPKG_HOST_CMAKE_VARS_FILE}")
+    endif()
+
     # parse parameters such that semicolons in options arguments to COMMAND don't get erased
     cmake_parse_arguments(PARSE_ARGV 0 _bc "ADD_BIN_TO_PATH;ENABLE_INSTALL;DISABLE_PARALLEL" "LOGFILE_ROOT;BUILD_TARGET;SUBPATH;MAKEFILE;INSTALL_TARGET" "")
 
@@ -79,9 +88,11 @@ function(vcpkg_build_make)
     if(WIN32)
         set(_VCPKG_PREFIX ${CURRENT_PACKAGES_DIR})
         set(_VCPKG_INSTALLED ${CURRENT_INSTALLED_DIR})
+        set(_VCPKG_HOST_INSTALLED ${CURRENT_HOST_INSTALLED_DIR})
     else()
         string(REPLACE " " "\ " _VCPKG_PREFIX "${CURRENT_PACKAGES_DIR}")
         string(REPLACE " " "\ " _VCPKG_INSTALLED "${CURRENT_INSTALLED_DIR}")
+        string(REPLACE " " "\ " _VCPKG_HOST_INSTALLED "${CURRENT_HOST_INSTALLED_DIR}")
     endif()
 
     set(MAKE )
@@ -141,19 +152,41 @@ function(vcpkg_build_make)
             set(WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}${SHORT_BUILDTYPE}${_bc_SUBPATH}")
             message(STATUS "Building ${TARGET_TRIPLET}${SHORT_BUILDTYPE}")
 
-            _vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags(${CMAKE_BUILDTYPE})
+            _vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags(${CMAKE_BUILDTYPE} FALSE)
+            _vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags(${CMAKE_BUILDTYPE} TRUE)
 
             if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
-                set(LINKER_FLAGS_${CMAKE_BUILDTYPE} "${VCPKG_DETECTED_STATIC_LINKER_FLAGS_${CMAKE_BUILDTYPE}}")
+                _vcpkg_select_for_build_detected(
+                    CMAKE_STATIC_LINKER_FLAGS_${CMAKE_BUILDTYPE} 
+                    FALSE 
+                    LINKER_FLAGS_${CMAKE_BUILDTYPE})
+                _vcpkg_select_for_build_detected(
+                    CMAKE_STATIC_LINKER_FLAGS_${CMAKE_BUILDTYPE} 
+                    TRUE 
+                    LINKER_FLAGS_${CMAKE_BUILDTYPE}_FOR_BUILD)
             else() # dynamic
-                set(LINKER_FLAGS_${CMAKE_BUILDTYPE} "${VCPKG_DETECTED_SHARED_LINKER_FLAGS_${CMAKE_BUILDTYPE}}")
+                _vcpkg_select_for_build_detected(
+                    CMAKE_SHARED_LINKER_FLAGS_${CMAKE_BUILDTYPE} 
+                    FALSE 
+                    LINKER_FLAGS_${CMAKE_BUILDTYPE})
+                _vcpkg_select_for_build_detected(
+                    CMAKE_SHARED_LINKER_FLAGS_${CMAKE_BUILDTYPE} 
+                    TRUE 
+                    LINKER_FLAGS_${CMAKE_BUILDTYPE}_FOR_BUILD)
             endif()
+
             if (CMAKE_HOST_WIN32 AND VCPKG_DETECTED_C_COMPILER MATCHES "cl.exe")
                 set(LDFLAGS_${CMAKE_BUILDTYPE} "-L${_VCPKG_INSTALLED}${PATH_SUFFIX}/lib -L${_VCPKG_INSTALLED}${PATH_SUFFIX}/lib/manual-link")
                 set(LINK_ENV_${CMAKE_BUILDTYPE} "$ENV{_LINK_} ${LINKER_FLAGS_${CMAKE_BUILDTYPE}}")
             else()
                 set(LDFLAGS_${CMAKE_BUILDTYPE} "-L${_VCPKG_INSTALLED}${PATH_SUFFIX}/lib -L${_VCPKG_INSTALLED}${PATH_SUFFIX}/lib/manual-link ${LINKER_FLAGS_${CMAKE_BUILDTYPE}}")
             endif()
+
+            if (CMAKE_HOST_WIN32 AND VCPKG_DETECTED_FOR_BUILD_C_COMPILER MATCHES "cl.exe")
+                set(LDFLAGS_${CMAKE_BUILDTYPE}_FOR_BUILD "-L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX}/lib -L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX}/lib/manual-link")
+            else()
+                set(LDFLAGS_${CMAKE_BUILDTYPE}_FOR_BUILD "-L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX}/lib -L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX}/lib/manual-link ${LINKER_FLAGS_${CMAKE_BUILDTYPE}_FOR_BUILD}")
+            endif()
             
             # Setup environment
             set(ENV{CPPFLAGS} "${CPPFLAGS_${CMAKE_BUILDTYPE}}")
@@ -164,6 +197,12 @@ function(vcpkg_build_make)
             set(ENV{LIB} "${_VCPKG_INSTALLED}${PATH_SUFFIX}/lib/${VCPKG_HOST_PATH_SEPARATOR}${_VCPKG_INSTALLED}${PATH_SUFFIX}/lib/manual-link/${LIB_PATHLIKE_CONCAT}")
             set(ENV{LIBPATH} "${_VCPKG_INSTALLED}${PATH_SUFFIX}/lib/${VCPKG_HOST_PATH_SEPARATOR}${_VCPKG_INSTALLED}${PATH_SUFFIX}/lib/manual-link/${LIBPATH_PATHLIKE_CONCAT}")
             set(ENV{LIBRARY_PATH} "${_VCPKG_INSTALLED}${PATH_SUFFIX}/lib/${VCPKG_HOST_PATH_SEPARATOR}${_VCPKG_INSTALLED}${PATH_SUFFIX}/lib/manual-link/${LIBRARY_PATH_PATHLIKE_CONCAT}")
+
+            set(ENV{CPPFLAGS_FOR_BUILD} "${CPPFLAGS_${CMAKE_BUILDTYPE}_FOR_BUILD}")
+            set(ENV{CFLAGS_FOR_BUILD} "${CFLAGS_${CMAKE_BUILDTYPE}_FOR_BUILD}")
+            set(ENV{CXXFLAGS_FOR_BUILD} "${CXXFLAGS_${CMAKE_BUILDTYPE}_FOR_BUILD}")
+            set(ENV{LDFLAGS_FOR_BUILD} "${LDFLAGS_${CMAKE_BUILDTYPE}_FOR_BUILD}")
+
             #set(ENV{LD_LIBRARY_PATH} "${_VCPKG_INSTALLED}${PATH_SUFFIX_${BUILDTYPE}}/lib/${VCPKG_HOST_PATH_SEPARATOR}${_VCPKG_INSTALLED}${PATH_SUFFIX_${BUILDTYPE}}/lib/manual-link/${LD_LIBRARY_PATH_PATHLIKE_CONCAT}")
 
             if(LINK_ENV_${_VAR_SUFFIX})
diff --git a/scripts/cmake/vcpkg_configure_cmake.cmake b/scripts/cmake/vcpkg_configure_cmake.cmake
index bce3f6af583629..a413c4f1e03c13 100644
--- a/scripts/cmake/vcpkg_configure_cmake.cmake
+++ b/scripts/cmake/vcpkg_configure_cmake.cmake
@@ -78,7 +78,7 @@ function(vcpkg_configure_cmake)
 
     cmake_parse_arguments(PARSE_ARGV 0 arg
         "PREFER_NINJA;DISABLE_PARALLEL_CONFIGURE;NO_CHARSET_FLAG;Z_VCPKG_IGNORE_UNUSED_VARIABLES"
-        "SOURCE_PATH;GENERATOR;LOGNAME"
+        "SOURCE_PATH;GENERATOR;LOGNAME;TRIPLET;TARGET_ARCHITECTURE"
         "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;MAYBE_UNUSED_VARIABLES"
     )
 
@@ -87,8 +87,16 @@ function(vcpkg_configure_cmake)
             "however, vcpkg.exe must be rebuilt by re-running bootstrap-vcpkg.bat\n")
     endif()
 
+    if(NOT arg_TRIPLET)
+        set(arg_TRIPLET ${TARGET_TRIPLET})
+    endif()
+
+    if(NOT arg_TARGET_ARCHITECTURE)
+        set(arg_TARGET_ARCHITECTURE ${VCPKG_TARGET_ARCHITECTURE})
+    endif()
+
     if(NOT arg_LOGNAME)
-        set(arg_LOGNAME config-${TARGET_TRIPLET})
+        set(arg_LOGNAME config-${arg_TRIPLET})
     endif()
 
     set(manually_specified_variables "")
@@ -134,40 +142,40 @@ function(vcpkg_configure_cmake)
     elseif(VCPKG_CHAINLOAD_TOOLCHAIN_FILE OR (VCPKG_CMAKE_SYSTEM_NAME AND NOT _TARGETTING_UWP))
         set(GENERATOR "Ninja")
 
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v120")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v120")
         set(GENERATOR "Visual Studio 12 2013")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v120")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v120")
         set(GENERATOR "Visual Studio 12 2013 Win64")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v120")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v120")
         set(GENERATOR "Visual Studio 12 2013 ARM")
 
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v140")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v140")
         set(GENERATOR "Visual Studio 14 2015")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v140")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v140")
         set(GENERATOR "Visual Studio 14 2015 Win64")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v140")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v140")
         set(GENERATOR "Visual Studio 14 2015 ARM")
 
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141")
         set(GENERATOR "Visual Studio 15 2017")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141")
         set(GENERATOR "Visual Studio 15 2017 Win64")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141")
         set(GENERATOR "Visual Studio 15 2017 ARM")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "arm64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v141")
         set(GENERATOR "Visual Studio 15 2017")
         set(ARCH "ARM64")
 
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "x86" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142")
         set(GENERATOR "Visual Studio 16 2019")
         set(ARCH "Win32")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "x64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142")
         set(GENERATOR "Visual Studio 16 2019")
         set(ARCH "x64")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "arm" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142")
         set(GENERATOR "Visual Studio 16 2019")
         set(ARCH "ARM")
-    elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142")
+    elseif(arg_TARGET_ARCHITECTURE STREQUAL "arm64" AND VCPKG_PLATFORM_TOOLSET STREQUAL "v142")
         set(GENERATOR "Visual Studio 16 2019")
         set(ARCH "ARM64")
 
@@ -176,7 +184,7 @@ function(vcpkg_configure_cmake)
             set(VCPKG_CMAKE_SYSTEM_NAME Windows)
         endif()
         message(FATAL_ERROR "Unable to determine appropriate generator for: "
-            "${VCPKG_CMAKE_SYSTEM_NAME}-${VCPKG_TARGET_ARCHITECTURE}-${VCPKG_PLATFORM_TOOLSET}")
+            "${VCPKG_CMAKE_SYSTEM_NAME}-${arg_TARGET_ARCHITECTURE}-${VCPKG_PLATFORM_TOOLSET}")
     endif()
 
     # If we use Ninja, make sure it's on PATH
@@ -187,7 +195,7 @@ function(vcpkg_configure_cmake)
         list(APPEND arg_OPTIONS "-DCMAKE_MAKE_PROGRAM=${NINJA}")
     endif()
 
-    file(REMOVE_RECURSE ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg)
+    file(REMOVE_RECURSE ${CURRENT_BUILDTREES_DIR}/${arg_TRIPLET}-rel ${CURRENT_BUILDTREES_DIR}/${arg_TRIPLET}-dbg)
 
     if(DEFINED VCPKG_CMAKE_SYSTEM_NAME)
         list(APPEND arg_OPTIONS "-DCMAKE_SYSTEM_NAME=${VCPKG_CMAKE_SYSTEM_NAME}")
@@ -247,10 +255,11 @@ function(vcpkg_configure_cmake)
         endif()
     endif()
 
-    list(JOIN VCPKG_TARGET_ARCHITECTURE "\;" target_architecure_string)
+    list(JOIN arg_TARGET_ARCHITECTURE "\;" target_architecure_string)
     list(APPEND arg_OPTIONS
         "-DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}"
-        "-DVCPKG_TARGET_TRIPLET=${TARGET_TRIPLET}"
+        "-DVCPKG_TARGET_TRIPLET=${arg_TRIPLET}"
+        "-DVCPKG_TARGET_ARCHITECTURE=${target_architecure_string}"
         "-DVCPKG_SET_CHARSET_FLAG=${VCPKG_SET_CHARSET_FLAG}"
         "-DVCPKG_PLATFORM_TOOLSET=${VCPKG_PLATFORM_TOOLSET}"
         "-DCMAKE_EXPORT_NO_PACKAGE_REGISTRY=ON"
@@ -270,8 +279,7 @@ function(vcpkg_configure_cmake)
         "-DVCPKG_CRT_LINKAGE=${VCPKG_CRT_LINKAGE}"
         "-DVCPKG_LINKER_FLAGS=${VCPKG_LINKER_FLAGS}"
         "-DVCPKG_LINKER_FLAGS_RELEASE=${VCPKG_LINKER_FLAGS_RELEASE}"
-        "-DVCPKG_LINKER_FLAGS_DEBUG=${VCPKG_LINKER_FLAGS_DEBUG}"
-        "-DVCPKG_TARGET_ARCHITECTURE=${target_architecure_string}"
+	"-DVCPKG_LINKER_FLAGS_DEBUG=${VCPKG_LINKER_FLAGS_DEBUG}"
         "-DCMAKE_INSTALL_LIBDIR:STRING=lib"
         "-DCMAKE_INSTALL_BINDIR:STRING=bin"
         "-D_VCPKG_ROOT_DIR=${VCPKG_ROOT_DIR}"
@@ -326,20 +334,20 @@ function(vcpkg_configure_cmake)
 
         if(NOT DEFINED VCPKG_BUILD_TYPE)
             _build_cmakecache(".." "rel")
-            _build_cmakecache("../../${TARGET_TRIPLET}-dbg" "dbg")
+            _build_cmakecache("../../${arg_TRIPLET}-dbg" "dbg")
         elseif(VCPKG_BUILD_TYPE STREQUAL "release")
             _build_cmakecache(".." "rel")
         elseif(VCPKG_BUILD_TYPE STREQUAL "debug")
-            _build_cmakecache("../../${TARGET_TRIPLET}-dbg" "dbg")
+            _build_cmakecache("../../${arg_TRIPLET}-dbg" "dbg")
         endif()
 
-        file(MAKE_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/vcpkg-parallel-configure)
-        file(WRITE ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/vcpkg-parallel-configure/build.ninja "${_contents}")
+        file(MAKE_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${arg_TRIPLET}-rel/vcpkg-parallel-configure)
+        file(WRITE ${CURRENT_BUILDTREES_DIR}/${arg_TRIPLET}-rel/vcpkg-parallel-configure/build.ninja "${_contents}")
 
-        message(STATUS "Configuring ${TARGET_TRIPLET}")
+        message(STATUS "Configuring ${arg_TRIPLET}")
         vcpkg_execute_required_process(
             COMMAND ninja -v
-            WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/vcpkg-parallel-configure
+            WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${arg_TRIPLET}-rel/vcpkg-parallel-configure
             LOGNAME ${arg_LOGNAME}
         )
         
@@ -348,11 +356,11 @@ function(vcpkg_configure_cmake)
             "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-err.log")
     else()
         if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
-            message(STATUS "Configuring ${TARGET_TRIPLET}-dbg")
-            file(MAKE_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg)
+            message(STATUS "Configuring ${arg_TRIPLET}-dbg")
+            file(MAKE_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${arg_TRIPLET}-dbg)
             vcpkg_execute_required_process(
                 COMMAND ${dbg_command}
-                WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg
+                WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${arg_TRIPLET}-dbg
                 LOGNAME ${arg_LOGNAME}-dbg
             )
             list(APPEND config_logs
@@ -361,11 +369,11 @@ function(vcpkg_configure_cmake)
         endif()
 
         if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
-            message(STATUS "Configuring ${TARGET_TRIPLET}-rel")
-            file(MAKE_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel)
+            message(STATUS "Configuring ${arg_TRIPLET}-rel")
+            file(MAKE_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${arg_TRIPLET}-rel)
             vcpkg_execute_required_process(
                 COMMAND ${rel_command}
-                WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel
+                WORKING_DIRECTORY ${CURRENT_BUILDTREES_DIR}/${arg_TRIPLET}-rel
                 LOGNAME ${arg_LOGNAME}-rel
             )
             list(APPEND config_logs
diff --git a/scripts/cmake/vcpkg_configure_make.cmake b/scripts/cmake/vcpkg_configure_make.cmake
index d1b87d454a0848..d6589b190efd06 100644
--- a/scripts/cmake/vcpkg_configure_make.cmake
+++ b/scripts/cmake/vcpkg_configure_make.cmake
@@ -105,43 +105,108 @@ macro(_vcpkg_determine_host_mingw out_var)
     unset(HOST_ARCH)
 endmacro()
 
+function(_vcpkg_cmake_to_autotools_arch in_arch out_var)
+    unset(${out_var} PARENT_SCOPE)
+    if(in_arch MATCHES "(amd|AMD)64" OR in_arch MATCHES "(x|X)86[-_]+64" OR in_arch MATCHES "x64")
+        set(${out_var} x86_64 PARENT_SCOPE)
+    elseif(in_arch MATCHES "(x|X)86")
+        set(${out_var} i686 PARENT_SCOPE)
+    elseif(in_arch MATCHES "^(ARM|arm)64$")
+        set(${out_var} aarch64 PARENT_SCOPE)
+    elseif(in_arch MATCHES "^(ARM|arm)$")
+        set(${out_var} arm PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(_vcpkg_cmake_to_vcpkg_arch in_arch out_var)
+    unset(${out_var} PARENT_SCOPE)
+    if(in_arch MATCHES "(amd|AMD)64" OR in_arch MATCHES "(x|X)86[-_]+64" OR in_arch MATCHES "x64")
+        set(${out_var} x64 PARENT_SCOPE)
+    elseif(in_arch MATCHES "(x|X)86")
+        set(${out_var} x86 PARENT_SCOPE)
+    elseif(in_arch MATCHES "^(ARM|arm)64$")
+        set(${out_var} arm64 PARENT_SCOPE)
+    elseif(in_arch MATCHES "^(ARM|arm)$")
+        set(${out_var} arm PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(_vcpkg_cmake_to_autotools_system in_system out_var)
+    unset(${out_var} PARENT_SCOPE)
+    if(in_system MATCHES "Linux")
+        set(${out_var} "linux-gnu" PARENT_SCOPE)
+    elseif(in_system MATCHES "Windows")
+        set(${out_var} "pc-mingw32" PARENT_SCOPE)
+    elseif(in_system MATCHES "Darwin")
+        set(${out_var} "apple-darwin" PARENT_SCOPE)
+    elseif(in_system MATCHES "Android")
+        set(${out_var} "linux-android" PARENT_SCOPE)
+    endif()
+endfunction()
+
 macro(_vcpkg_determine_autotools_host_cpu out_var)
-    # TODO: the host system processor architecture can differ from the host triplet target architecture
-    if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
-        set(HOST_ARCH $ENV{PROCESSOR_ARCHITEW6432})
-    elseif(DEFINED ENV{PROCESSOR_ARCHITECTURE})
-        set(HOST_ARCH $ENV{PROCESSOR_ARCHITECTURE})
+    if(DEFINED VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR)
+        set(_HOST_ARCH ${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR})
+    elseif(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+        set(_HOST_ARCH $ENV{PROCESSOR_ARCHITEW6432})
     else()
-        set(HOST_ARCH "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}")
+        set(_HOST_ARCH $ENV{PROCESSOR_ARCHITECTURE})
     endif()
-    if(HOST_ARCH MATCHES "(amd|AMD)64")
-        set(${out_var} x86_64)
-    elseif(HOST_ARCH MATCHES "(x|X)86")
-        set(${out_var} i686)
-    elseif(HOST_ARCH MATCHES "^(ARM|arm)64$")
-        set(${out_var} aarch64)
-    elseif(HOST_ARCH MATCHES "^(ARM|arm)$")
-        set(${out_var} arm)
+    _vcpkg_cmake_to_autotools_arch(${_HOST_ARCH} ${out_var})
+    if (NOT DEFINED ${out_var})
+        message(FATAL_ERROR "Unsupported host architecture ${_HOST_ARCH} in _vcpkg_determine_autotools_host_cpu!" )
+    endif()
+    unset(_HOST_ARCH)
+endmacro()
+
+macro(_vcpkg_determine_vcpkg_host_cpu out_var)
+    if(DEFINED VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR)
+        set(_HOST_ARCH ${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR})
+    elseif(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+        set(_HOST_ARCH $ENV{PROCESSOR_ARCHITEW6432})
     else()
-        message(FATAL_ERROR "Unsupported host architecture ${HOST_ARCH} in _vcpkg_determine_autotools_host_cpu!" )
+        set(_HOST_ARCH $ENV{PROCESSOR_ARCHITECTURE})
     endif()
-    unset(HOST_ARCH)
+    _vcpkg_cmake_to_vcpkg_arch(${_HOST_ARCH} ${out_var})
+    if (NOT DEFINED ${out_var})
+        message(FATAL_ERROR "Unsupported host architecture ${_HOST_ARCH} in _vcpkg_determine_autotools_host_cpu!" )
+    endif()
+    unset(_HOST_ARCH)
+endmacro()
+
+macro(_vcpkg_determine_autotools_host_os out_var)
+    if(DEFINED VCPKG_DETECTED_CMAKE_HOST_SYSTEM_NAME)
+        set(_HOST_SYSTEM ${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_NAME})
+    elseif(VCPKG_TARGET_IS_WINDOWS)
+        set(_HOST_SYSTEM "Windows")
+    elseif(VCPKG_TARGET_IS_LINUX)
+        set(_HOST_SYSTEM "Linux")
+    elseif(VCPKG_TARGET_IS_OSX)
+        set(_HOST_SYSTEM "Darwin")
+    elseif(VCPKG_TARGET_IS_ANDROID)
+        set(_HOST_SYSTEM "Android")
+    endif()
+    _vcpkg_cmake_to_autotools_system(${_HOST_SYSTEM} ${out_var})
+    if (NOT DEFINED ${out_var})
+        message(FATAL_ERROR "Unsupported host os ${_HOST_SYSTEM} in _vcpkg_determine_autotools_host_os!" )
+    endif()
+    unset(_HOST_SYSTEM)
 endmacro()
 
 macro(_vcpkg_determine_autotools_target_cpu out_var)
-    if(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)64")
-        set(${out_var} x86_64)
-    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86")
-        set(${out_var} i686)
-    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)64$")
-        set(${out_var} aarch64)
-    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)$")
-        set(${out_var} arm)
-    else()
+    _vcpkg_cmake_to_autotools_arch(${VCPKG_TARGET_ARCHITECTURE} ${out_var})
+    if(NOT DEFINED ${out_var})
         message(FATAL_ERROR "Unsupported VCPKG_TARGET_ARCHITECTURE architecture ${VCPKG_TARGET_ARCHITECTURE} in _vcpkg_determine_autotools_target_cpu!" )
     endif()
 endmacro()
 
+macro(_vcpkg_determine_autotools_target_os out_var)
+    _vcpkg_cmake_to_autotools_system(${VCPKG_DETECTED_CMAKE_SYSTEM_NAME} ${out_var})
+    if(NOT DEFINED ${out_var})
+        message(FATAL_ERROR "Unsupported target os ${VCPKG_DETECTED_CMAKE_SYSTEM_NAME} in _vcpkg_determine_autotools_target_os!")
+    endif()
+endmacro()
+
 macro(_vcpkg_determine_autotools_host_arch_mac out_var)
     set(${out_var} "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}")
 endmacro()
@@ -192,39 +257,99 @@ macro(_vcpkg_restore_env_variables)
     endforeach()
 endmacro()
 
-macro(_vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags _SUFFIX)
-    string(REGEX MATCHALL "( |^)-D[^ ]+" CPPFLAGS_${_SUFFIX} "${VCPKG_DETECTED_CMAKE_C_FLAGS_${_SUFFIX}}")
-    string(REGEX MATCHALL "( |^)-D[^ ]+" CXXPPFLAGS_${_SUFFIX} "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${_SUFFIX}}")
-    list(JOIN CXXPPFLAGS_${_SUFFIX} "|" CXXREGEX)
+macro(_vcpkg_select_for_build_detected cmake_var for_build out_var)
+    if (${VCPKG_CROSSCOMPILING} AND ${for_build})
+        set(${out_var} ${VCPKG_DETECTED_FOR_BUILD_${cmake_var}})
+    else()
+        set(${out_var} ${VCPKG_DETECTED_${cmake_var}})
+    endif()
+endmacro()
+
+macro(_vcpkg_setup_detected_env env_name cmake_var)
+    if(VCPKG_DETECTED_${cmake_var})
+        set(ENV{${env_name}} "${VCPKG_DETECTED_${cmake_var}}")
+    endif()
+    set(env_name_for_build ${env_name}_FOR_BUILD)
+    _vcpkg_select_for_build_detected(${cmake_var} TRUE ${env_name}_for_build)
+    if (${env_name}_for_build)
+        set(ENV{${env_name_for_build}} "${${env_name}_for_build}")
+    endif()
+endmacro()
+
+macro(_vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags _SUFFIX _FOR_BUILD)
+    _vcpkg_select_for_build_detected(CMAKE_C_FLAGS_${_SUFFIX} ${_FOR_BUILD} C_FLAGS)
+    _vcpkg_select_for_build_detected(CMAKE_CXX_FLAGS_${_SUFFIX} ${_FOR_BUILD} CXX_FLAGS)
+    _vcpkg_select_for_build_detected(CMAKE_OSX_SYSROOT ${_FOR_BUILD} OSX_SYSROOT)
+    _vcpkg_select_for_build_detected(CMAKE_INCLUDE_FLAG_C ${_FOR_BUILD} INCLUDE_FLAG_C)
+    _vcpkg_select_for_build_detected(CMAKE_INCLUDE_FLAG_CXX ${_FOR_BUILD} INCLUDE_FLAG_CXX)
+    _vcpkg_select_for_build_detected(CMAKE_INCLUDE_FLAG_C_SEP ${_FOR_BUILD} INCLUDE_FLAG_C_SEP)
+    _vcpkg_select_for_build_detected(CMAKE_INCLUDE_FLAG_CXX_SEP ${_FOR_BUILD} INCLUDE_FLAG_CXX_SEP)
+    _vcpkg_select_for_build_detected(CMAKE_INCLUDE_SYSTEM_FLAG_C ${_FOR_BUILD} INCLUDE_SYSTEM_FLAG_C)
+    _vcpkg_select_for_build_detected(CMAKE_INCLUDE_SYSTEM_FLAG_CXX ${_FOR_BUILD} INCLUDE_SYSTEM_FLAG_CXX)
+    if(${_FOR_BUILD})
+        set(VAR_SUFFIX ${_SUFFIX}_FOR_BUILD)
+    else()
+        set(VAR_SUFFIX ${_SUFFIX})
+    endif()
+
+    string(REGEX MATCHALL "( |^)-D[^ ]+" CPPFLAGS_${VAR_SUFFIX} "${C_FLAGS}")
+    string(REGEX MATCHALL "( |^)-D[^ ]+" CXXPPFLAGS_${VAR_SUFFIX} "${CXX_FLAGS}")
+    list(JOIN CXXPPFLAGS_${VAR_SUFFIX} "|" CXXREGEX)
     if(CXXREGEX)
-        list(FILTER CPPFLAGS_${_SUFFIX} INCLUDE REGEX "(${CXXREGEX})")
+        list(FILTER CPPFLAGS_${VAR_SUFFIX} INCLUDE REGEX "(${CXXREGEX})")
     else()
-        set(CPPFLAGS_${_SUFFIX})
+        set(CPPFLAGS_${VAR_SUFFIX})
     endif()
-    list(JOIN CPPFLAGS_${_SUFFIX} "|" CPPREGEX)
-    list(JOIN CPPFLAGS_${_SUFFIX} " " CPPFLAGS_${_SUFFIX})
-    set(CPPFLAGS_${_SUFFIX} "${CPPFLAGS_${_SUFFIX}}")
+    list(JOIN CPPFLAGS_${VAR_SUFFIX} "|" CPPREGEX)
+    list(JOIN CPPFLAGS_${VAR_SUFFIX} " " CPPFLAGS_${VAR_SUFFIX})
+    set(CPPFLAGS_${VAR_SUFFIX} "${CPPFLAGS_${VAR_SUFFIX}}")
     if(CPPREGEX)
-        string(REGEX REPLACE "(${CPPREGEX})" "" CFLAGS_${_SUFFIX} "${VCPKG_DETECTED_CMAKE_C_FLAGS_${_SUFFIX}}")
-        string(REGEX REPLACE "(${CPPREGEX})" "" CXXFLAGS_${_SUFFIX} "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${_SUFFIX}}")
+        string(REGEX REPLACE "(${CPPREGEX})" "" CFLAGS_${VAR_SUFFIX} "${C_FLAGS}")
+        string(REGEX REPLACE "(${CPPREGEX})" "" CXXFLAGS_${VAR_SUFFIX} "${CXX_FLAGS}")
     else()
-        set(CFLAGS_${_SUFFIX} "${VCPKG_DETECTED_CMAKE_C_FLAGS_${_SUFFIX}}")
-        set(CXXFLAGS_${_SUFFIX} "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${_SUFFIX}}")
+        set(CFLAGS_${VAR_SUFFIX} "${C_FLAGS}")
+        set(CXXFLAGS_${VAR_SUFFIX} "${CXX_FLAGS}")
     endif()
-    string(REGEX REPLACE " +" " " CPPFLAGS_${_SUFFIX} "${CPPFLAGS_${_SUFFIX}}")
-    string(REGEX REPLACE " +" " " CFLAGS_${_SUFFIX} "${CFLAGS_${_SUFFIX}}")
-    string(REGEX REPLACE " +" " " CXXFLAGS_${_SUFFIX} "${CXXFLAGS_${_SUFFIX}}")
+    string(REGEX REPLACE " +" " " CPPFLAGS_${VAR_SUFFIX} "${CPPFLAGS_${VAR_SUFFIX}}")
+    string(REGEX REPLACE " +" " " CFLAGS_${VAR_SUFFIX} "${CFLAGS_${VAR_SUFFIX}}")
+    string(REGEX REPLACE " +" " " CXXFLAGS_${VAR_SUFFIX} "${CXXFLAGS_${VAR_SUFFIX}}")
     # libtool has and -R option so we need to guard against -RTC by using -Xcompiler
     # while configuring there might be a lot of unknown compiler option warnings due to that
     # just ignore them. 
-    string(REGEX REPLACE "((-|/)RTC[^ ]+)" "-Xcompiler \\1" CFLAGS_${_SUFFIX} "${CFLAGS_${_SUFFIX}}")
-    string(REGEX REPLACE "((-|/)RTC[^ ]+)" "-Xcompiler \\1" CXXFLAGS_${_SUFFIX} "${CXXFLAGS_${_SUFFIX}}")
-    string(STRIP "${CPPFLAGS_${_SUFFIX}}" CPPFLAGS_${_SUFFIX})
-    string(STRIP "${CFLAGS_${_SUFFIX}}" CFLAGS_${_SUFFIX})
-    string(STRIP "${CXXFLAGS_${_SUFFIX}}" CXXFLAGS_${_SUFFIX})
-    debug_message("CPPFLAGS_${_SUFFIX}: ${CPPFLAGS_${_SUFFIX}}")
-    debug_message("CFLAGS_${_SUFFIX}: ${CFLAGS_${_SUFFIX}}")
-    debug_message("CXXFLAGS_${_SUFFIX}: ${CXXFLAGS_${_SUFFIX}}")
+    string(REGEX REPLACE "((-|/)RTC[^ ]+)" "-Xcompiler \\1" CFLAGS_${VAR_SUFFIX} "${CFLAGS_${VAR_SUFFIX}}")
+    string(REGEX REPLACE "((-|/)RTC[^ ]+)" "-Xcompiler \\1" CXXFLAGS_${VAR_SUFFIX} "${CXXFLAGS_${VAR_SUFFIX}}")
+
+    if (OSX_SYSROOT)
+        string(APPEND CPPFLAGS_${VAR_SUFFIX} " -isysroot ${OSX_SYSROOT}")
+    endif()
+
+    if (${VCPKG_CROSSCOMPILING} AND ${_FOR_BUILD})
+        set(VCPKG_INCLUDE_PATH "${CURRENT_HOST_INSTALLED_DIR}/include")
+    else()
+        set(VCPKG_INCLUDE_PATH "${CURRENT_INSTALLED_DIR}/include")
+    endif()
+    if ("${INCLUDE_SYSTEM_FLAG_C}" STREQUAL "")
+        set(INCLUDE_PREFIX_C ${INCLUDE_FLAG_C}${INCLUDE_FLAG_C_SEP})
+    else()
+        set(INCLUDE_PREFIX_C ${INCLUDE_SYSTEM_FLAG_C})
+    endif()
+    if ("${INCLUDE_SYSTEM_FLAG_CXX}" STREQUAL "")
+        set(INCLUDE_PREFIX_CXX ${INCLUDE_FLAG_CXX}${INCLUDE_FLAG_CXX_SEP})
+    else()
+        set(INCLUDE_PREFIX_CXX ${INCLUDE_SYSTEM_FLAG_CXX})
+    endif()
+    file(TO_NATIVE_PATH "${VCPKG_INCLUDE_PATH}" VCPKG_INCLUDE_PATH)
+    set(VCPKG_INCLUDE_PATH "\"${VCPKG_INCLUDE_PATH}\"")
+
+    string(PREPEND CFLAGS_${VAR_SUFFIX} "${INCLUDE_PREFIX_C}${VCPKG_INCLUDE_PATH} ")
+    string(PREPEND CXXFLAGS_${VAR_SUFFIX} "${INCLUDE_PREFIX_CXX}${VCPKG_INCLUDE_PATH} ")
+
+    string(STRIP "${CPPFLAGS_${VAR_SUFFIX}}" CPPFLAGS_${VAR_SUFFIX})
+    string(STRIP "${CFLAGS_${VAR_SUFFIX}}" CFLAGS_${VAR_SUFFIX})
+    string(STRIP "${CXXFLAGS_${VAR_SUFFIX}}" CXXFLAGS_${VAR_SUFFIX})
+    debug_message(STATUS "CPPFLAGS_${VAR_SUFFIX}: ${CPPFLAGS_${VAR_SUFFIX}}")
+    debug_message(STATUS "CFLAGS_${VAR_SUFFIX}: ${CFLAGS_${VAR_SUFFIX}}")
+    debug_message(STATUS "CXXFLAGS_${VAR_SUFFIX}: ${CXXFLAGS_${VAR_SUFFIX}}")
 endmacro()
 
 function(vcpkg_configure_make)
@@ -241,6 +366,13 @@ function(vcpkg_configure_make)
     if(DEFINED VCPKG_MAKE_BUILD_TRIPLET)
         set(_csc_BUILD_TRIPLET ${VCPKG_MAKE_BUILD_TRIPLET}) # Triplet overwrite for crosscompiling
     endif()
+    if(VCPKG_CROSSCOMPILING)
+        _vcpkg_determine_vcpkg_host_cpu(_host_arch)
+        vcpkg_internal_get_cmake_vars(OUTPUT_FILE _VCPKG_HOST_CMAKE_VARS_FILE TRIPLET ${_HOST_TRIPLET} VAR_PREFIX VCPKG_DETECTED_FOR_BUILD TARGET_ARCHITECTURE ${_host_arch})
+        set(_VCPKG_HOST_CMAKE_VARS_FILE "${_VCPKG_HOST_CMAKE_VARS_FILE}" PARENT_SCOPE)
+        debug_message("Including host cmake vars from: ${_VCPKG_HOST_CMAKE_VARS_FILE}")
+        include("${_VCPKG_HOST_CMAKE_VARS_FILE}")
+    endif()
 
     set(SRC_DIR "${_csc_SOURCE_PATH}/${_csc_PROJECT_SUBPATH}")
 
@@ -280,8 +412,10 @@ function(vcpkg_configure_make)
     # Backup environment variables
     # CCAS CC C CPP CXX FC FF GC LD LF LIBTOOL OBJC OBJCXX R UPC Y 
     set(_cm_FLAGS AS CCAS CC C CPP CXX FC FF GC LD LF LIBTOOL OBJC OBJXX R UPC Y RC)
+    set(_cm_TOOLS CC CXX AR AS LD RANLIB STRIP)
     list(TRANSFORM _cm_FLAGS APPEND "FLAGS")
     _vcpkg_backup_env_variables(${_cm_FLAGS})
+    _vcpkg_backup_env_variables(${_cm_TOOLS})
 
 
     # FC fotran compiler | FF Fortran 77 compiler 
@@ -452,10 +586,26 @@ function(vcpkg_configure_make)
         string(REPLACE " " "\\\ " _VCPKG_PREFIX ${CURRENT_INSTALLED_DIR})
         string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" _VCPKG_PREFIX "${_VCPKG_PREFIX}")
         set(_VCPKG_INSTALLED ${CURRENT_INSTALLED_DIR})
+        set(_VCPKG_HOST_INSTALLED ${CURRENT_HOST_INSTALLED_DIR})
         set(prefix_var "'\${prefix}'") # Windows needs extra quotes or else the variable gets expanded in the makefile!
     else()
+        if (NOT _csc_BUILD_TRIPLET)
+            _vcpkg_determine_autotools_host_cpu(HOST_ARCH)
+            _vcpkg_determine_autotools_host_os(HOST_OS)
+            _vcpkg_determine_autotools_target_cpu(TARGET_ARCH)
+            _vcpkg_determine_autotools_target_os(TARGET_OS)
+            # --build: the machine you are building on usualy guessed ok
+            # --host: the machine you are building for
+            # --target: the machine that CC will produce binaries for
+            # https://stackoverflow.com/questions/21990021/how-to-determine-host-value-for-configure-when-using-cross-compiler
+            # Only for ports using autotools so we can assume that they follow the common conventions for build/target/host
+            list(APPEND _csc_BUILD_TRIPLET "--host=${TARGET_ARCH}-${TARGET_OS}" "--build=${HOST_ARCH}-${HOST_OS}") 
+            debug_message("Using make triplet: ${_csc_BUILD_TRIPLET}")
+        endif()
+
         string(REPLACE " " "\ " _VCPKG_PREFIX ${CURRENT_INSTALLED_DIR})
         string(REPLACE " " "\ " _VCPKG_INSTALLED ${CURRENT_INSTALLED_DIR})
+        string(REPLACE " " "\ " _VCPKG_HOST_INSTALLED ${CURRENT_HOST_INSTALLED_DIR})
         set(EXTRA_QUOTES)
         set(prefix_var "\${prefix}")
     endif()
@@ -676,11 +826,26 @@ function(vcpkg_configure_make)
         set(SHORT_NAME_${_VAR_SUFFIX} "dbg")
         list(APPEND _buildtypes ${_VAR_SUFFIX})
         if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
-            set(LINKER_FLAGS_${_VAR_SUFFIX} "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${_VAR_SUFFIX}}")
+            _vcpkg_select_for_build_detected(
+                CMAKE_STATIC_LINKER_FLAGS_${_VAR_SUFFIX} 
+                FALSE 
+                LINKER_FLAGS_${_VAR_SUFFIX})
+            _vcpkg_select_for_build_detected(
+                CMAKE_STATIC_LINKER_FLAGS_${_VAR_SUFFIX} 
+                TRUE 
+                LINKER_FLAGS_${_VAR_SUFFIX}_FOR_BUILD)
         else() # dynamic
-            set(LINKER_FLAGS_${_VAR_SUFFIX} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${_VAR_SUFFIX}}")
+            _vcpkg_select_for_build_detected(
+                CMAKE_SHARED_LINKER_FLAGS_${_VAR_SUFFIX} 
+                FALSE 
+                LINKER_FLAGS_${_VAR_SUFFIX})
+            _vcpkg_select_for_build_detected(
+                CMAKE_SHARED_LINKER_FLAGS_${_VAR_SUFFIX} 
+                TRUE 
+                LINKER_FLAGS_${_VAR_SUFFIX}_FOR_BUILD)
         endif()
-        _vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags(${_VAR_SUFFIX})
+        _vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags(${_VAR_SUFFIX} FALSE)
+        _vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags(${_VAR_SUFFIX} TRUE)
         if (CMAKE_HOST_WIN32 AND VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe")
             if(NOT _vcm_paths_with_spaces)
                 set(LDFLAGS_${_VAR_SUFFIX} "-L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib -L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link")
@@ -695,12 +860,28 @@ function(vcpkg_configure_make)
             if(EXISTS "${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib")
                 set(_link_dirs "-L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib")
             endif()
-            if(EXISTS "{_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link")
+            if(EXISTS "${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link")
                 set(_link_dirs "${_link_dirs} -L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link")
             endif()
             string(STRIP "${_link_dirs}" _link_dirs)
             set(LDFLAGS_${_VAR_SUFFIX} "${_link_dirs} ${LINKER_FLAGS_${_VAR_SUFFIX}}")
         endif()
+        if (CMAKE_HOST_WIN32 AND VCPKG_DETECTED_FOR_BUILD_CMAKE_C_COMPILER MATCHES "cl.exe")
+            if(NOT _vcm_paths_with_spaces)
+                set(LDFLAGS_${_VAR_SUFFIX}_FOR_BUILD "-L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib -L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link")
+            endif()
+            set(LINK_ENV_${_VAR_SUFFIX}_FOR_BUILD "${LINKER_FLAGS_${_VAR_SUFFIX}_FOR_BUILD}")
+        else()
+            set(_link_dirs)
+            if(EXISTS "${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib")
+                set(_link_dirs_for_build "-L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib")
+            endif()
+            if(EXISTS "${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link")
+                set(_link_dirs_for_build "${_link_dirs_for_build} -L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link")
+            endif()
+            string(STRIP "${_link_dirs_for_build}" _link_dirs_for_build)
+            set(LDFLAGS_${_VAR_SUFFIX}_FOR_BUILD "${_link_dirs_for_build} ${LINKER_FLAGS_${_VAR_SUFFIX}_FOR_BUILD}")
+        endif()
         unset(_VAR_SUFFIX)
     endif()
     if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
@@ -709,11 +890,26 @@ function(vcpkg_configure_make)
         set(SHORT_NAME_${_VAR_SUFFIX} "rel")
         list(APPEND _buildtypes ${_VAR_SUFFIX})
         if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
-            set(LINKER_FLAGS_${_VAR_SUFFIX} "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${_VAR_SUFFIX}}")
+            _vcpkg_select_for_build_detected(
+                CMAKE_STATIC_LINKER_FLAGS_${_VAR_SUFFIX} 
+                FALSE 
+                LINKER_FLAGS_${_VAR_SUFFIX})
+            _vcpkg_select_for_build_detected(
+                CMAKE_STATIC_LINKER_FLAGS_${_VAR_SUFFIX} 
+                TRUE 
+                LINKER_FLAGS_${_VAR_SUFFIX}_FOR_BUILD)
         else() # dynamic
-            set(LINKER_FLAGS_${_VAR_SUFFIX} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${_VAR_SUFFIX}}")
+            _vcpkg_select_for_build_detected(
+                CMAKE_SHARED_LINKER_FLAGS_${_VAR_SUFFIX} 
+                FALSE 
+                LINKER_FLAGS_${_VAR_SUFFIX})
+            _vcpkg_select_for_build_detected(
+                CMAKE_SHARED_LINKER_FLAGS_${_VAR_SUFFIX} 
+                TRUE 
+                LINKER_FLAGS_${_VAR_SUFFIX}_FOR_BUILD)
         endif()
-        _vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags(${_VAR_SUFFIX})
+        _vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags(${_VAR_SUFFIX} FALSE)
+        _vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags(${_VAR_SUFFIX} TRUE)
         if (CMAKE_HOST_WIN32 AND VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe")
             if(NOT _vcm_paths_with_spaces)
                 set(LDFLAGS_${_VAR_SUFFIX} "-L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib -L${_VCPKG_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link")
@@ -734,6 +930,22 @@ function(vcpkg_configure_make)
             string(STRIP "${_link_dirs}" _link_dirs)
             set(LDFLAGS_${_VAR_SUFFIX} "${_link_dirs} ${LINKER_FLAGS_${_VAR_SUFFIX}}")
         endif()
+        if (CMAKE_HOST_WIN32 AND VCPKG_DETECTED_FOR_BUILD_CMAKE_C_COMPILER MATCHES "cl.exe")
+            if(NOT _vcm_paths_with_spaces)
+                set(LDFLAGS_${_VAR_SUFFIX}_FOR_BUILD "-L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib -L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link")
+            endif()
+            set(LINK_ENV_${_VAR_SUFFIX}_FOR_BUILD "${LINKER_FLAGS_${_VAR_SUFFIX}_FOR_BUILD}")
+        else()
+            set(_link_dirs)
+            if(EXISTS "${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib")
+                set(_link_dirs_for_build "-L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib")
+            endif()
+            if(EXISTS "${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link")
+                set(_link_dirs_for_build "${_link_dirs_for_build} -L${_VCPKG_HOST_INSTALLED}${PATH_SUFFIX_${_VAR_SUFFIX}}/lib/manual-link")
+            endif()
+            string(STRIP "${_link_dirs_for_build}" _link_dirs_for_build)
+            set(LDFLAGS_${_VAR_SUFFIX}_FOR_BUILD "${_link_dirs_for_build} ${LINKER_FLAGS_${_VAR_SUFFIX}_FOR_BUILD}")
+        endif()
         unset(_VAR_SUFFIX)
     endif()
 
@@ -765,11 +977,25 @@ function(vcpkg_configure_make)
         endif()
 
         # Setup environment
+        _vcpkg_setup_detected_env(CC CMAKE_C_COMPILER)
+        _vcpkg_setup_detected_env(CXX CMAKE_CXX_COMPILER)
+        _vcpkg_setup_detected_env(LD CMAKE_LINKER)
+        set(_tools AR RANLIB STRIP NM OBJDUMP DLLTOOL MT STRIP AS)
+        foreach (_toolname ${_tools})
+            _vcpkg_setup_detected_env(${_toolname} CMAKE_${_toolname})
+        endforeach()
+        _vcpkg_setup_detected_env(MACOSX_DEPLOYMENT_TARGET CMAKE_OSX_DEPLOYMENT_TARGET)
+
+
         set(ENV{CPPFLAGS} "${CPPFLAGS_${_buildtype}}")
         set(ENV{CFLAGS} "${CFLAGS_${_buildtype}}")
         set(ENV{CXXFLAGS} "${CXXFLAGS_${_buildtype}}")
         set(ENV{RCFLAGS} "${VCPKG_DETECTED_CMAKE_RC_FLAGS_${_buildtype}}")
-        set(ENV{LDFLAGS} "${LDFLAGS_${_buildtype}}")
+        set(ENV{LDFLAGS} "${LDFLAGS_${_buildtype}} ${LINKER_FLAGS}")
+        set(ENV{CPPFLAGS_FOR_BUILD} "${CPPFLAGS_${_buildtype}_FOR_BUILD}")
+        set(ENV{CFLAGS_FOR_BUILD} "${CFLAGS_${_buildtype}_FOR_BUILD}")
+        set(ENV{CXXFLAGS_FOR_BUILD} "${CXXFLAGS_${_buildtype}_FOR_BUILD}")
+        set(ENV{LDFLAGS_FOR_BUILD} "${LDFLAGS_${_buildtype}_FOR_BUILD}")
         if(LINK_ENV_${_VAR_SUFFIX})
             set(_LINK_CONFIG_BACKUP "$ENV{_LINK_}")
             set(ENV{_LINK_} "${LINK_ENV_${_VAR_SUFFIX}}")
@@ -853,7 +1079,7 @@ function(vcpkg_configure_make)
     endforeach()
 
     # Restore environment
-    _vcpkg_restore_env_variables(${_cm_FLAGS} LIB LIBPATH LIBRARY_PATH LD_LIBRARY_PATH)
+    _vcpkg_restore_env_variables(${_cm_FLAGS} LIB LIBPATH LIBRARY_PATH LD_LIBRARY_PATH ${_cm_TOOLS} C_INCLUDE_PATH CPLUS_INCLUDE_PATH LIBRARY_PATH LD_LIBRARY_PATH)
 
     SET(_VCPKG_PROJECT_SOURCE_PATH ${_csc_SOURCE_PATH} PARENT_SCOPE)
     set(_VCPKG_PROJECT_SUBPATH ${_csc_PROJECT_SUBPATH} PARENT_SCOPE)
diff --git a/scripts/cmake/vcpkg_internal_get_cmake_vars.cmake b/scripts/cmake/vcpkg_internal_get_cmake_vars.cmake
index 030d74120d88f5..dd2ef1b8dc8838 100644
--- a/scripts/cmake/vcpkg_internal_get_cmake_vars.cmake
+++ b/scripts/cmake/vcpkg_internal_get_cmake_vars.cmake
@@ -28,12 +28,20 @@ If possible avoid usage in portfiles.
 #]===]
 
 function(vcpkg_internal_get_cmake_vars)
-    cmake_parse_arguments(PARSE_ARGV 0 _gcv "" "OUTPUT_FILE" "OPTIONS")
+    cmake_parse_arguments(PARSE_ARGV 0 _gcv "" "OUTPUT_FILE;TRIPLET;TARGET_ARCHITECTURE;VAR_PREFIX" "OPTIONS")
 
     if(_gcv_UNPARSED_ARGUMENTS)
         message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed unparsed arguments: '${_gcv_UNPARSED_ARGUMENTS}'")
     endif()
 
+    if(NOT _gcv_TRIPLET)
+        set(_gcv_TRIPLET ${TARGET_TRIPLET})
+    endif()
+
+    if(NOT _gcv_TARGET_ARCHITECTURE)
+        set(_gcv_TARGET_ARCHITECTURE ${VCPKG_TARGET_ARCHITECTURE})
+    endif()
+
     if(NOT _gcv_OUTPUT_FILE)
         message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} requires parameter OUTPUT_FILE!")
     endif()
@@ -41,27 +49,34 @@ function(vcpkg_internal_get_cmake_vars)
     if(${_gcv_OUTPUT_FILE})
         debug_message("OUTPUT_FILE ${${_gcv_OUTPUT_FILE}}")
     else()
-        set(DEFAULT_OUT "${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}.cmake.log") # So that the file gets included in CI artifacts.
+        set(DEFAULT_OUT "${CURRENT_BUILDTREES_DIR}/cmake-vars-${_gcv_TRIPLET}.cmake.log") # So that the file gets included in CI artifacts.
         set(${_gcv_OUTPUT_FILE} "${DEFAULT_OUT}" PARENT_SCOPE)
         set(${_gcv_OUTPUT_FILE} "${DEFAULT_OUT}")
     endif()
 
+    if(_gcv_VAR_PREFIX)
+        list(APPEND _gcv_OPTIONS "-DVCPKG_VAR_PREFIX=${_gcv_VAR_PREFIX}")
+    endif()
+
+
     vcpkg_configure_cmake(
         SOURCE_PATH "${SCRIPTS}/get_cmake_vars"
         OPTIONS ${_gcv_OPTIONS} "-DVCPKG_BUILD_TYPE=${VCPKG_BUILD_TYPE}"
-        OPTIONS_DEBUG "-DVCPKG_OUTPUT_FILE:PATH=${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}-dbg.cmake.log"
-        OPTIONS_RELEASE "-DVCPKG_OUTPUT_FILE:PATH=${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}-rel.cmake.log"
+        OPTIONS_DEBUG "-DVCPKG_OUTPUT_FILE:PATH=${CURRENT_BUILDTREES_DIR}/cmake-vars-${_gcv_TRIPLET}-dbg.cmake.log"
+        OPTIONS_RELEASE "-DVCPKG_OUTPUT_FILE:PATH=${CURRENT_BUILDTREES_DIR}/cmake-vars-${_gcv_TRIPLET}-rel.cmake.log"
         PREFER_NINJA
-        LOGNAME get-cmake-vars-${TARGET_TRIPLET}
+        TRIPLET ${_gcv_TRIPLET}
+        TARGET_ARCHITECTURE ${_gcv_TARGET_ARCHITECTURE}
+        LOGNAME get-cmake-vars-${_gcv_TRIPLET}
         Z_VCPKG_IGNORE_UNUSED_VARIABLES
     )
 
     set(_include_string)
     if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
-        string(APPEND _include_string "include(\"${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}-rel.cmake.log\")\n")
+        string(APPEND _include_string "include(\"${CURRENT_BUILDTREES_DIR}/cmake-vars-${_gcv_TRIPLET}-rel.cmake.log\")\n")
     endif()
     if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
-        string(APPEND _include_string "include(\"${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}-dbg.cmake.log\")\n")
+        string(APPEND _include_string "include(\"${CURRENT_BUILDTREES_DIR}/cmake-vars-${_gcv_TRIPLET}-dbg.cmake.log\")\n")
     endif()
     file(WRITE "${${_gcv_OUTPUT_FILE}}" "${_include_string}")
 
diff --git a/scripts/get_cmake_vars/CMakeLists.txt b/scripts/get_cmake_vars/CMakeLists.txt
index 084042fb116ab2..69088a396f6613 100644
--- a/scripts/get_cmake_vars/CMakeLists.txt
+++ b/scripts/get_cmake_vars/CMakeLists.txt
@@ -8,7 +8,15 @@ list(APPEND VCPKG_DEFAULT_VARS_TO_CHECK CMAKE_CROSSCOMPILING
                                         CMAKE_SYSTEM_NAME
                                         CMAKE_HOST_SYSTEM_NAME
                                         CMAKE_SYSTEM_PROCESSOR
-                                        CMAKE_HOST_SYSTEM_PROCESSOR)
+                                        CMAKE_HOST_SYSTEM_PROCESSOR
+                                        CMAKE_INCLUDE_FLAG_C
+                                        CMAKE_INCLUDE_FLAG_CXX
+                                        CMAKE_INCLUDE_FLAG_C_SEP
+                                        CMAKE_INCLUDE_FLAG_CXX_SEP
+                                        CMAKE_INCLUDE_SYSTEM_FLAG_C
+                                        CMAKE_INCLUDE_SYSTEM_FLAG_CXX
+)
+
 if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
     list(APPEND VCPKG_DEFAULT_VARS_TO_CHECK CMAKE_OSX_DEPLOYMENT_TARGET
                                             CMAKE_OSX_SYSROOT)
@@ -74,6 +82,77 @@ endif()
 
 project(get_cmake_vars LANGUAGES ${VCPKG_LANGUAGES})
 
+if(APPLE)
+ 
+    foreach(_arch ${CMAKE_OSX_ARCHITECTURES})
+        string(APPEND CMAKE_CXX_FLAGS " -arch ${_arch}")
+        string(APPEND CMAKE_C_FLAGS " -arch ${_arch}")
+        string(APPEND CMAKE_STATIC_LINKER_FLAGS " -arch ${_arch}")
+        string(APPEND CMAKE_SHARED_LINKER_FLAGS " -arch ${_arch}")
+    endforeach()
+ 
+    if(CMAKE_OSX_DEPLOYMENT_TARGET)
+        string(APPEND CMAKE_CXX_FLAGS " ${CMAKE_CXX_OSX_DEPLOYMENT_TARGET_FLAG}${CMAKE_OSX_DEPLOYMENT_TARGET}")
+        string(APPEND CMAKE_C_FLAGS " ${CMAKE_C_OSX_DEPLOYMENT_TARGET_FLAG}${CMAKE_OSX_DEPLOYMENT_TARGET}")
+        string(APPEND CMAKE_STATIC_LINKER_FLAGS " ${CMAKE_C_OSX_DEPLOYMENT_TARGET_FLAG}${CMAKE_OSX_DEPLOYMENT_TARGET}")
+        string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${CMAKE_C_OSX_DEPLOYMENT_TARGET_FLAG}${CMAKE_OSX_DEPLOYMENT_TARGET}")
+    endif()
+ 
+    if(CMAKE_OSX_SYSROOT)
+        string(APPEND CMAKE_CXX_FLAGS " ${CMAKE_CXX_SYSROOT_FLAG} ${CMAKE_OSX_SYSROOT}")
+        string(APPEND CMAKE_C_FLAGS " ${CMAKE_C_SYSROOT_FLAG} ${CMAKE_OSX_SYSROOT}")
+        string(APPEND CMAKE_STATIC_LINKER_FLAGS " ${CMAKE_C_SYSROOT_FLAG} ${CMAKE_OSX_SYSROOT}")
+        string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${CMAKE_C_SYSROOT_FLAG} ${CMAKE_OSX_SYSROOT}")
+    endif()
+ 
+else()
+ 
+    if(CMAKE_CXX_COMPILER_TARGET AND CMAKE_CXX_COMPILE_OPTIONS_TARGET)
+        if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+            string(APPEND CMAKE_CXX_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}")
+            string(APPEND CMAKE_C_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}")
+            string(APPEND CMAKE_STATIC_LINKER_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}")
+            string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}")
+        else()
+            string(APPEND CMAKE_CXX_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_TARGET} ${CMAKE_CXX_COMPILER_TARGET}")
+            string(APPEND CMAKE_C_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_TARGET} ${CMAKE_CXX_COMPILER_TARGET}")
+            string(APPEND CMAKE_STATIC_LINKER_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_TARGET} ${CMAKE_CXX_COMPILER_TARGET}")
+            string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_TARGET} ${CMAKE_CXX_COMPILER_TARGET}")
+        endif()
+    endif()
+ 
+    if(CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN AND CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN)
+        if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+            string(APPEND CMAKE_CXX_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
+            string(APPEND CMAKE_C_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
+            string(APPEND CMAKE_STATIC_LINKER_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
+            string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
+        else()
+            string(APPEND CMAKE_CXX_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN} ${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
+            string(APPEND CMAKE_C_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN} ${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
+            string(APPEND CMAKE_STATIC_LINKER_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN} ${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
+            string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN} ${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
+        endif()
+    endif()
+ 
+    if(CMAKE_SYSROOT AND CMAKE_CXX_COMPILE_OPTIONS_SYSROOT)
+        string(APPEND CMAKE_CXX_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}")
+        string(APPEND CMAKE_C_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}")
+        string(APPEND CMAKE_STATIC_LINKER_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}")
+        string(APPEND CMAKE_SHARED_LINKER_FLAGS " ${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}")
+    endif()
+ 
+endif()
+ 
+foreach(_lang IN ITEMS C CXX)
+    foreach(INCDIR ${CMAKE_${_lang}_IMPLICIT_INCLUDE_DIRECTORIES})
+        string(APPEND CMAKE_${_lang}_FLAGS " ${CMAKE_INCLUDE_SYSTEM_FLAG_${_lang}}${INCDIR}")
+    endforeach()
+    foreach(INCDIR ${CMAKE_${_lang}_STANDARD_INCLUDE_DIRECTORIES})
+        string(APPEND CMAKE_${_lang}_FLAGS " ${CMAKE_INCLUDE_FLAG_${_lang}}${CMAKE_INCLUDE_FLAG_${_lang}_SEP}${INCDIR}")
+    endforeach()
+endforeach()
+
 foreach(VAR IN LISTS VCPKG_VARS_TO_CHECK)
   string(APPEND OUTPUT_STRING "set(${VCPKG_VAR_PREFIX}_${VAR} \"${${VAR}}\")\n")
 endforeach()
@@ -91,18 +170,6 @@ macro(_vcpkg_adjust_flags flag_var)
     if(MSVC) # Transform MSVC /flags to -flags due to bash scripts intepreting /flag as a path.
         string(REGEX REPLACE "(^| )/" "\\1-" ${flag_var} "${${flag_var}}")
     endif()
-    if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
-        if("${flag_var}" IN_LIST VCPKG_LANG_FLAGS)
-            # macOS - append arch and isysroot if cross-compiling
-            if(NOT "${CMAKE_OSX_ARCHITECTURES}" STREQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}")
-
-                foreach(arch IN LISTS CMAKE_OSX_ARCHITECTURES)
-                    string(APPEND ${flag_var} " -arch ${arch}")
-                endforeach()
-                string(APPEND ${flag_var} " -isysroot ${CMAKE_OSX_SYSROOT}")
-            endif()
-        endif()
-    endif()
 endmacro()
 
 foreach(flag IN LISTS VCPKG_FLAGS_TO_CHECK)