955 lines
37 KiB
Python
Vendored
955 lines
37 KiB
Python
Vendored
#
|
|
# MIT License
|
|
#
|
|
# Copyright The SCons Foundation
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining
|
|
# a copy of this software and associated documentation files (the
|
|
# "Software"), to deal in the Software without restriction, including
|
|
# without limitation the rights to use, copy, modify, merge, publish,
|
|
# distribute, sublicense, and/or sell copies of the Software, and to
|
|
# permit persons to whom the Software is furnished to do so, subject to
|
|
# the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included
|
|
# in all copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
|
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
|
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
#
|
|
"""Module for Visual C/C++ detection and configuration.
|
|
|
|
# TODO:
|
|
# * gather all the information from a single vswhere call instead
|
|
# of calling repeatedly (use json format?)
|
|
# * support passing/setting location for vswhere in env.
|
|
# * supported arch for versions: for old versions of batch file without
|
|
# argument, giving bogus argument cannot be detected, so we have to hardcode
|
|
# this here
|
|
# * print warning when msvc version specified but not found
|
|
# * find out why warning do not print
|
|
# * test on 64 bits XP + VS 2005 (and VS 6 if possible)
|
|
# * SDK
|
|
# * Assembly
|
|
"""
|
|
|
|
import SCons.compat
|
|
import SCons.Util
|
|
|
|
import subprocess
|
|
import os
|
|
import platform
|
|
from string import digits as string_digits
|
|
from subprocess import PIPE
|
|
|
|
import SCons.Warnings
|
|
from SCons.Tool import find_program_path
|
|
|
|
from . import common
|
|
from .common import CONFIG_CACHE, debug
|
|
from .sdk import get_installed_sdks
|
|
|
|
|
|
class VisualCException(Exception):
|
|
pass
|
|
|
|
class UnsupportedVersion(VisualCException):
|
|
pass
|
|
|
|
class MSVCUnsupportedHostArch(VisualCException):
|
|
pass
|
|
|
|
class MSVCUnsupportedTargetArch(VisualCException):
|
|
pass
|
|
|
|
class MissingConfiguration(VisualCException):
|
|
pass
|
|
|
|
class NoVersionFound(VisualCException):
|
|
pass
|
|
|
|
class BatchFileExecutionError(VisualCException):
|
|
pass
|
|
|
|
# Dict to 'canonalize' the arch
|
|
_ARCH_TO_CANONICAL = {
|
|
"amd64" : "amd64",
|
|
"emt64" : "amd64",
|
|
"i386" : "x86",
|
|
"i486" : "x86",
|
|
"i586" : "x86",
|
|
"i686" : "x86",
|
|
"ia64" : "ia64", # deprecated
|
|
"itanium" : "ia64", # deprecated
|
|
"x86" : "x86",
|
|
"x86_64" : "amd64",
|
|
"arm" : "arm",
|
|
"arm64" : "arm64",
|
|
"aarch64" : "arm64",
|
|
}
|
|
|
|
# Starting with 14.1 (aka VS2017), the tools are organized by host directory.
|
|
# subdirs for each target. They are now in .../VC/Auxuiliary/Build.
|
|
# Note 2017 Express uses Hostx86 even if it's on 64-bit Windows,
|
|
# not reflected in this table.
|
|
_HOST_TARGET_TO_CL_DIR_GREATER_THAN_14 = {
|
|
("amd64","amd64") : ("Hostx64","x64"),
|
|
("amd64","x86") : ("Hostx64","x86"),
|
|
("amd64","arm") : ("Hostx64","arm"),
|
|
("amd64","arm64") : ("Hostx64","arm64"),
|
|
("x86","amd64") : ("Hostx86","x64"),
|
|
("x86","x86") : ("Hostx86","x86"),
|
|
("x86","arm") : ("Hostx86","arm"),
|
|
("x86","arm64") : ("Hostx86","arm64"),
|
|
}
|
|
|
|
# before 14.1 (VS2017): the original x86 tools are in the tools dir,
|
|
# any others are in a subdir named by the host/target pair,
|
|
# or just a single word if host==target
|
|
_HOST_TARGET_TO_CL_DIR = {
|
|
("amd64","amd64") : "amd64",
|
|
("amd64","x86") : "amd64_x86",
|
|
("amd64","arm") : "amd64_arm",
|
|
("amd64","arm64") : "amd64_arm64",
|
|
("x86","amd64") : "x86_amd64",
|
|
("x86","x86") : "",
|
|
("x86","arm") : "x86_arm",
|
|
("x86","arm64") : "x86_arm64",
|
|
("arm","arm") : "arm",
|
|
}
|
|
|
|
# 14.1 (VS2017) and later:
|
|
# Given a (host, target) tuple, return the batch file to look for.
|
|
# We can't rely on returning an arg to use for vcvarsall.bat,
|
|
# because that script will run even if given a pair that isn't installed.
|
|
# Targets that already look like a pair are pseudo targets that
|
|
# effectively mean to skip whatever the host was specified as.
|
|
_HOST_TARGET_TO_BAT_ARCH_GT14 = {
|
|
("amd64", "amd64"): "vcvars64.bat",
|
|
("amd64", "x86"): "vcvarsamd64_x86.bat",
|
|
("amd64", "x86_amd64"): "vcvarsx86_amd64.bat",
|
|
("amd64", "x86_x86"): "vcvars32.bat",
|
|
("amd64", "arm"): "vcvarsamd64_arm.bat",
|
|
("amd64", "x86_arm"): "vcvarsx86_arm.bat",
|
|
("amd64", "arm64"): "vcvarsamd64_arm64.bat",
|
|
("amd64", "x86_arm64"): "vcvarsx86_arm64.bat",
|
|
("x86", "x86"): "vcvars32.bat",
|
|
("x86", "amd64"): "vcvarsx86_amd64.bat",
|
|
("x86", "x86_amd64"): "vcvarsx86_amd64.bat",
|
|
("x86", "arm"): "vcvarsx86_arm.bat",
|
|
("x86", "x86_arm"): "vcvarsx86_arm.bat",
|
|
("x86", "arm64"): "vcvarsx86_arm64.bat",
|
|
("x86", "x86_arm64"): "vcvarsx86_arm64.bat",
|
|
}
|
|
|
|
# before 14.1 (VS2017):
|
|
# Given a (host, target) tuple, return the argument for the bat file;
|
|
# Both host and target should be canoncalized.
|
|
# If the target already looks like a pair, return it - these are
|
|
# pseudo targets (mainly used by Express versions)
|
|
_HOST_TARGET_ARCH_TO_BAT_ARCH = {
|
|
("x86", "x86"): "x86",
|
|
("x86", "amd64"): "x86_amd64",
|
|
("x86", "x86_amd64"): "x86_amd64",
|
|
("amd64", "x86_amd64"): "x86_amd64", # This is present in (at least) VS2012 express
|
|
("amd64", "amd64"): "amd64",
|
|
("amd64", "x86"): "x86",
|
|
("amd64", "x86_x86"): "x86",
|
|
("x86", "ia64"): "x86_ia64", # gone since 14.0
|
|
("x86", "arm"): "x86_arm", # since 14.0
|
|
("x86", "arm64"): "x86_arm64", # since 14.1
|
|
("amd64", "arm"): "amd64_arm", # since 14.0
|
|
("amd64", "arm64"): "amd64_arm64", # since 14.1
|
|
("x86", "x86_arm"): "x86_arm", # since 14.0
|
|
("x86", "x86_arm64"): "x86_arm64", # since 14.1
|
|
("amd64", "x86_arm"): "x86_arm", # since 14.0
|
|
("amd64", "x86_arm64"): "x86_arm64", # since 14.1
|
|
}
|
|
|
|
_CL_EXE_NAME = 'cl.exe'
|
|
|
|
def get_msvc_version_numeric(msvc_version):
|
|
"""Get the raw version numbers from a MSVC_VERSION string, so it
|
|
could be cast to float or other numeric values. For example, '14.0Exp'
|
|
would get converted to '14.0'.
|
|
|
|
Args:
|
|
msvc_version: str
|
|
string representing the version number, could contain non
|
|
digit characters
|
|
|
|
Returns:
|
|
str: the value converted to a numeric only string
|
|
|
|
"""
|
|
return ''.join([x for x in msvc_version if x in string_digits + '.'])
|
|
|
|
def get_host_target(env):
|
|
host_platform = env.get('HOST_ARCH')
|
|
debug("HOST_ARCH:" + str(host_platform))
|
|
if not host_platform:
|
|
host_platform = platform.machine()
|
|
|
|
# Solaris returns i86pc for both 32 and 64 bit architectures
|
|
if host_platform == "i86pc":
|
|
if platform.architecture()[0] == "64bit":
|
|
host_platform = "amd64"
|
|
else:
|
|
host_platform = "x86"
|
|
|
|
# Retain user requested TARGET_ARCH
|
|
req_target_platform = env.get('TARGET_ARCH')
|
|
debug("TARGET_ARCH:" + str(req_target_platform))
|
|
if req_target_platform:
|
|
# If user requested a specific platform then only try that one.
|
|
target_platform = req_target_platform
|
|
else:
|
|
target_platform = host_platform
|
|
|
|
try:
|
|
host = _ARCH_TO_CANONICAL[host_platform.lower()]
|
|
except KeyError:
|
|
msg = "Unrecognized host architecture %s"
|
|
raise MSVCUnsupportedHostArch(msg % repr(host_platform))
|
|
|
|
try:
|
|
target = _ARCH_TO_CANONICAL[target_platform.lower()]
|
|
except KeyError:
|
|
all_archs = str(list(_ARCH_TO_CANONICAL.keys()))
|
|
raise MSVCUnsupportedTargetArch(
|
|
"Unrecognized target architecture %s\n\tValid architectures: %s"
|
|
% (target_platform, all_archs)
|
|
)
|
|
|
|
return (host, target, req_target_platform)
|
|
|
|
# If you update this, update SupportedVSList in Tool/MSCommon/vs.py, and the
|
|
# MSVC_VERSION documentation in Tool/msvc.xml.
|
|
_VCVER = ["14.2", "14.1", "14.1Exp", "14.0", "14.0Exp", "12.0", "12.0Exp", "11.0", "11.0Exp", "10.0", "10.0Exp", "9.0", "9.0Exp","8.0", "8.0Exp","7.1", "7.0", "6.0"]
|
|
|
|
# if using vswhere, configure command line arguments to probe for installed VC editions
|
|
_VCVER_TO_VSWHERE_VER = {
|
|
'14.2': [
|
|
["-version", "[16.0, 17.0)", ], # default: Enterprise, Professional, Community (order unpredictable?)
|
|
["-version", "[16.0, 17.0)", "-products", "Microsoft.VisualStudio.Product.BuildTools"], # BuildTools
|
|
],
|
|
'14.1': [
|
|
["-version", "[15.0, 16.0)", ], # default: Enterprise, Professional, Community (order unpredictable?)
|
|
["-version", "[15.0, 16.0)", "-products", "Microsoft.VisualStudio.Product.BuildTools"], # BuildTools
|
|
],
|
|
'14.1Exp': [
|
|
["-version", "[15.0, 16.0)", "-products", "Microsoft.VisualStudio.Product.WDExpress"], # Express
|
|
],
|
|
}
|
|
|
|
_VCVER_TO_PRODUCT_DIR = {
|
|
'14.2': [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'')], # not set by this version
|
|
'14.1': [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'')], # not set by this version
|
|
'14.1Exp': [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'')], # not set by this version
|
|
'14.0' : [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\14.0\Setup\VC\ProductDir')],
|
|
'14.0Exp' : [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\14.0\Setup\VC\ProductDir')],
|
|
'12.0' : [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\12.0\Setup\VC\ProductDir'),
|
|
],
|
|
'12.0Exp' : [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\12.0\Setup\VC\ProductDir'),
|
|
],
|
|
'11.0': [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\11.0\Setup\VC\ProductDir'),
|
|
],
|
|
'11.0Exp' : [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\11.0\Setup\VC\ProductDir'),
|
|
],
|
|
'10.0': [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\10.0\Setup\VC\ProductDir'),
|
|
],
|
|
'10.0Exp' : [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\10.0\Setup\VC\ProductDir'),
|
|
],
|
|
'9.0': [
|
|
(SCons.Util.HKEY_CURRENT_USER, r'Microsoft\DevDiv\VCForPython\9.0\installdir',),
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\9.0\Setup\VC\ProductDir',),
|
|
],
|
|
'9.0Exp' : [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\9.0\Setup\VC\ProductDir'),
|
|
],
|
|
'8.0': [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\8.0\Setup\VC\ProductDir'),
|
|
],
|
|
'8.0Exp': [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VCExpress\8.0\Setup\VC\ProductDir'),
|
|
],
|
|
'7.1': [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\7.1\Setup\VC\ProductDir'),
|
|
],
|
|
'7.0': [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\7.0\Setup\VC\ProductDir'),
|
|
],
|
|
'6.0': [
|
|
(SCons.Util.HKEY_LOCAL_MACHINE, r'Microsoft\VisualStudio\6.0\Setup\Microsoft Visual C++\ProductDir'),
|
|
]
|
|
}
|
|
|
|
|
|
def msvc_version_to_maj_min(msvc_version):
|
|
msvc_version_numeric = get_msvc_version_numeric(msvc_version)
|
|
|
|
t = msvc_version_numeric.split(".")
|
|
if not len(t) == 2:
|
|
raise ValueError("Unrecognized version %s (%s)" % (msvc_version,msvc_version_numeric))
|
|
try:
|
|
maj = int(t[0])
|
|
min = int(t[1])
|
|
return maj, min
|
|
except ValueError as e:
|
|
raise ValueError("Unrecognized version %s (%s)" % (msvc_version,msvc_version_numeric))
|
|
|
|
|
|
def is_host_target_supported(host_target, msvc_version):
|
|
"""Check if (host, target) pair is supported for a VC version.
|
|
|
|
Only checks whether a given version *may* support the given
|
|
(host, target) pair, not that the toolchain is actually on the machine.
|
|
|
|
Args:
|
|
host_target: canonalized host-target pair, e.g.
|
|
("x86", "amd64") for cross compilation from 32- to 64-bit Windows.
|
|
msvc_version: Visual C++ version (major.minor), e.g. "10.0"
|
|
|
|
Returns:
|
|
True or False
|
|
|
|
"""
|
|
# We assume that any Visual Studio version supports x86 as a target
|
|
if host_target[1] != "x86":
|
|
maj, min = msvc_version_to_maj_min(msvc_version)
|
|
if maj < 8:
|
|
return False
|
|
return True
|
|
|
|
|
|
VSWHERE_PATHS = [os.path.join(p,'vswhere.exe') for p in [
|
|
os.path.expandvars(r"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer"),
|
|
os.path.expandvars(r"%ProgramFiles%\Microsoft Visual Studio\Installer"),
|
|
os.path.expandvars(r"%ChocolateyInstall%\bin"),
|
|
]]
|
|
|
|
def msvc_find_vswhere():
|
|
""" Find the location of vswhere """
|
|
# For bug 3333: support default location of vswhere for both
|
|
# 64 and 32 bit windows installs.
|
|
# For bug 3542: also accommodate not being on C: drive.
|
|
# NB: this gets called from testsuite on non-Windows platforms.
|
|
# Whether that makes sense or not, don't break it for those.
|
|
vswhere_path = None
|
|
for pf in VSWHERE_PATHS:
|
|
if os.path.exists(pf):
|
|
vswhere_path = pf
|
|
break
|
|
|
|
return vswhere_path
|
|
|
|
def find_vc_pdir_vswhere(msvc_version, env=None):
|
|
""" Find the MSVC product directory using the vswhere program.
|
|
|
|
Args:
|
|
msvc_version: MSVC version to search for
|
|
env: optional to look up VSWHERE variable
|
|
|
|
Returns:
|
|
MSVC install dir or None
|
|
|
|
Raises:
|
|
UnsupportedVersion: if the version is not known by this file
|
|
|
|
"""
|
|
try:
|
|
vswhere_version = _VCVER_TO_VSWHERE_VER[msvc_version]
|
|
except KeyError:
|
|
debug("Unknown version of MSVC: %s" % msvc_version)
|
|
raise UnsupportedVersion("Unknown version %s" % msvc_version)
|
|
|
|
if env is None or not env.get('VSWHERE'):
|
|
vswhere_path = msvc_find_vswhere()
|
|
else:
|
|
vswhere_path = env.subst('$VSWHERE')
|
|
|
|
if vswhere_path is None:
|
|
return None
|
|
|
|
debug('VSWHERE: %s' % vswhere_path)
|
|
for vswhere_version_args in vswhere_version:
|
|
|
|
vswhere_cmd = [vswhere_path] + vswhere_version_args + ["-property", "installationPath"]
|
|
|
|
debug("running: %s" % vswhere_cmd)
|
|
|
|
#cp = subprocess.run(vswhere_cmd, capture_output=True) # 3.7+ only
|
|
cp = subprocess.run(vswhere_cmd, stdout=PIPE, stderr=PIPE)
|
|
|
|
if cp.stdout:
|
|
# vswhere could return multiple lines, e.g. if Build Tools
|
|
# and {Community,Professional,Enterprise} are both installed.
|
|
# We could define a way to pick the one we prefer, but since
|
|
# this data is currently only used to make a check for existence,
|
|
# returning the first hit should be good enough.
|
|
lines = cp.stdout.decode("mbcs").splitlines()
|
|
return os.path.join(lines[0], 'VC')
|
|
else:
|
|
# We found vswhere, but no install info available for this version
|
|
pass
|
|
|
|
return None
|
|
|
|
|
|
def find_vc_pdir(env, msvc_version):
|
|
"""Find the MSVC product directory for the given version.
|
|
|
|
Tries to look up the path using a registry key from the table
|
|
_VCVER_TO_PRODUCT_DIR; if there is no key, calls find_vc_pdir_wshere
|
|
for help instead.
|
|
|
|
Args:
|
|
msvc_version: str
|
|
msvc version (major.minor, e.g. 10.0)
|
|
|
|
Returns:
|
|
str: Path found in registry, or None
|
|
|
|
Raises:
|
|
UnsupportedVersion: if the version is not known by this file.
|
|
MissingConfiguration: found version but the directory is missing.
|
|
|
|
Both exceptions inherit from VisualCException.
|
|
|
|
"""
|
|
root = 'Software\\'
|
|
try:
|
|
hkeys = _VCVER_TO_PRODUCT_DIR[msvc_version]
|
|
except KeyError:
|
|
debug("Unknown version of MSVC: %s" % msvc_version)
|
|
raise UnsupportedVersion("Unknown version %s" % msvc_version)
|
|
|
|
for hkroot, key in hkeys:
|
|
try:
|
|
comps = None
|
|
if not key:
|
|
comps = find_vc_pdir_vswhere(msvc_version, env)
|
|
if not comps:
|
|
debug('no VC found for version {}'.format(repr(msvc_version)))
|
|
raise SCons.Util.WinError
|
|
debug('VC found: {}'.format(repr(msvc_version)))
|
|
return comps
|
|
else:
|
|
if common.is_win64():
|
|
try:
|
|
# ordinarily at win64, try Wow6432Node first.
|
|
comps = common.read_reg(root + 'Wow6432Node\\' + key, hkroot)
|
|
except SCons.Util.WinError as e:
|
|
# at Microsoft Visual Studio for Python 2.7, value is not in Wow6432Node
|
|
pass
|
|
if not comps:
|
|
# not Win64, or Microsoft Visual Studio for Python 2.7
|
|
comps = common.read_reg(root + key, hkroot)
|
|
except SCons.Util.WinError as e:
|
|
debug('no VC registry key {}'.format(repr(key)))
|
|
else:
|
|
debug('found VC in registry: {}'.format(comps))
|
|
if os.path.exists(comps):
|
|
return comps
|
|
else:
|
|
debug('reg says dir is {}, but it does not exist. (ignoring)'.format(comps))
|
|
raise MissingConfiguration("registry dir {} not found on the filesystem".format(comps))
|
|
return None
|
|
|
|
def find_batch_file(env,msvc_version,host_arch,target_arch):
|
|
"""
|
|
Find the location of the batch script which should set up the compiler
|
|
for any TARGET_ARCH whose compilers were installed by Visual Studio/VCExpress
|
|
|
|
In newer (2017+) compilers, make use of the fact there are vcvars
|
|
scripts named with a host_target pair that calls vcvarsall.bat properly,
|
|
so use that and return an indication we don't need the argument
|
|
we would have computed to run vcvarsall.bat.
|
|
"""
|
|
pdir = find_vc_pdir(env, msvc_version)
|
|
if pdir is None:
|
|
raise NoVersionFound("No version of Visual Studio found")
|
|
debug('looking in {}'.format(pdir))
|
|
|
|
# filter out e.g. "Exp" from the version name
|
|
msvc_ver_numeric = get_msvc_version_numeric(msvc_version)
|
|
use_arg = True
|
|
vernum = float(msvc_ver_numeric)
|
|
if 7 <= vernum < 8:
|
|
pdir = os.path.join(pdir, os.pardir, "Common7", "Tools")
|
|
batfilename = os.path.join(pdir, "vsvars32.bat")
|
|
elif vernum < 7:
|
|
pdir = os.path.join(pdir, "Bin")
|
|
batfilename = os.path.join(pdir, "vcvars32.bat")
|
|
elif 8 <= vernum <= 14:
|
|
batfilename = os.path.join(pdir, "vcvarsall.bat")
|
|
else: # vernum >= 14.1 VS2017 and above
|
|
batfiledir = os.path.join(pdir, "Auxiliary", "Build")
|
|
targ = _HOST_TARGET_TO_BAT_ARCH_GT14[(host_arch, target_arch)]
|
|
batfilename = os.path.join(batfiledir, targ)
|
|
use_arg = False
|
|
|
|
if not os.path.exists(batfilename):
|
|
debug("Not found: %s" % batfilename)
|
|
batfilename = None
|
|
|
|
installed_sdks = get_installed_sdks()
|
|
for _sdk in installed_sdks:
|
|
sdk_bat_file = _sdk.get_sdk_vc_script(host_arch,target_arch)
|
|
if not sdk_bat_file:
|
|
debug("batch file not found:%s" % _sdk)
|
|
else:
|
|
sdk_bat_file_path = os.path.join(pdir,sdk_bat_file)
|
|
if os.path.exists(sdk_bat_file_path):
|
|
debug('sdk_bat_file_path:%s' % sdk_bat_file_path)
|
|
return (batfilename, use_arg, sdk_bat_file_path)
|
|
return (batfilename, use_arg, None)
|
|
|
|
|
|
__INSTALLED_VCS_RUN = None
|
|
_VC_TOOLS_VERSION_FILE_PATH = ['Auxiliary', 'Build', 'Microsoft.VCToolsVersion.default.txt']
|
|
_VC_TOOLS_VERSION_FILE = os.sep.join(_VC_TOOLS_VERSION_FILE_PATH)
|
|
|
|
def _check_cl_exists_in_vc_dir(env, vc_dir, msvc_version):
|
|
"""Return status of finding a cl.exe to use.
|
|
|
|
Locates cl in the vc_dir depending on TARGET_ARCH, HOST_ARCH and the
|
|
msvc version. TARGET_ARCH and HOST_ARCH can be extracted from the
|
|
passed env, unless it is None, in which case the native platform is
|
|
assumed for both host and target.
|
|
|
|
Args:
|
|
env: Environment
|
|
a construction environment, usually if this is passed its
|
|
because there is a desired TARGET_ARCH to be used when searching
|
|
for a cl.exe
|
|
vc_dir: str
|
|
the path to the VC dir in the MSVC installation
|
|
msvc_version: str
|
|
msvc version (major.minor, e.g. 10.0)
|
|
|
|
Returns:
|
|
bool:
|
|
|
|
"""
|
|
|
|
# determine if there is a specific target platform we want to build for and
|
|
# use that to find a list of valid VCs, default is host platform == target platform
|
|
# and same for if no env is specified to extract target platform from
|
|
if env:
|
|
(host_platform, target_platform, req_target_platform) = get_host_target(env)
|
|
else:
|
|
host_platform = platform.machine().lower()
|
|
target_platform = host_platform
|
|
|
|
host_platform = _ARCH_TO_CANONICAL[host_platform]
|
|
target_platform = _ARCH_TO_CANONICAL[target_platform]
|
|
|
|
debug('host platform %s, target platform %s for version %s' % (host_platform, target_platform, msvc_version))
|
|
|
|
ver_num = float(get_msvc_version_numeric(msvc_version))
|
|
|
|
# make sure the cl.exe exists meaning the tool is installed
|
|
if ver_num > 14:
|
|
# 2017 and newer allowed multiple versions of the VC toolset to be
|
|
# installed at the same time. This changes the layout.
|
|
# Just get the default tool version for now
|
|
#TODO: support setting a specific minor VC version
|
|
default_toolset_file = os.path.join(vc_dir, _VC_TOOLS_VERSION_FILE)
|
|
try:
|
|
with open(default_toolset_file) as f:
|
|
vc_specific_version = f.readlines()[0].strip()
|
|
except IOError:
|
|
debug('failed to read ' + default_toolset_file)
|
|
return False
|
|
except IndexError:
|
|
debug('failed to find MSVC version in ' + default_toolset_file)
|
|
return False
|
|
|
|
host_trgt_dir = _HOST_TARGET_TO_CL_DIR_GREATER_THAN_14.get((host_platform, target_platform), None)
|
|
if host_trgt_dir is None:
|
|
debug('unsupported host/target platform combo: (%s,%s)'%(host_platform, target_platform))
|
|
return False
|
|
|
|
cl_path = os.path.join(vc_dir, 'Tools','MSVC', vc_specific_version, 'bin', host_trgt_dir[0], host_trgt_dir[1], _CL_EXE_NAME)
|
|
debug('checking for ' + _CL_EXE_NAME + ' at ' + cl_path)
|
|
if os.path.exists(cl_path):
|
|
debug('found ' + _CL_EXE_NAME + '!')
|
|
return True
|
|
|
|
elif host_platform == "amd64" and host_trgt_dir[0] == "Hostx64":
|
|
# Special case: fallback to Hostx86 if Hostx64 was tried
|
|
# and failed. This is because VS 2017 Express running on amd64
|
|
# will look to our probe like the host dir should be Hostx64,
|
|
# but Express uses Hostx86 anyway.
|
|
# We should key this off the "x86_amd64" and related pseudo
|
|
# targets, but we don't see those in this function.
|
|
host_trgt_dir = ("Hostx86", host_trgt_dir[1])
|
|
cl_path = os.path.join(vc_dir, 'Tools','MSVC', vc_specific_version, 'bin', host_trgt_dir[0], host_trgt_dir[1], _CL_EXE_NAME)
|
|
debug('checking for ' + _CL_EXE_NAME + ' at ' + cl_path)
|
|
if os.path.exists(cl_path):
|
|
debug('found ' + _CL_EXE_NAME + '!')
|
|
return True
|
|
|
|
elif 14 >= ver_num >= 8:
|
|
# Set default value to be -1 as "", which is the value for x86/x86,
|
|
# yields true when tested if not host_trgt_dir
|
|
host_trgt_dir = _HOST_TARGET_TO_CL_DIR.get((host_platform, target_platform), None)
|
|
if host_trgt_dir is None:
|
|
debug('unsupported host/target platform combo')
|
|
return False
|
|
|
|
cl_path = os.path.join(vc_dir, 'bin', host_trgt_dir, _CL_EXE_NAME)
|
|
debug('checking for ' + _CL_EXE_NAME + ' at ' + cl_path)
|
|
|
|
cl_path_exists = os.path.exists(cl_path)
|
|
if not cl_path_exists and host_platform == 'amd64':
|
|
# older versions of visual studio only had x86 binaries,
|
|
# so if the host platform is amd64, we need to check cross
|
|
# compile options (x86 binary compiles some other target on a 64 bit os)
|
|
|
|
# Set default value to be -1 as "" which is the value for x86/x86 yields true when tested
|
|
# if not host_trgt_dir
|
|
host_trgt_dir = _HOST_TARGET_TO_CL_DIR.get(('x86', target_platform), None)
|
|
if host_trgt_dir is None:
|
|
return False
|
|
|
|
cl_path = os.path.join(vc_dir, 'bin', host_trgt_dir, _CL_EXE_NAME)
|
|
debug('checking for ' + _CL_EXE_NAME + ' at ' + cl_path)
|
|
cl_path_exists = os.path.exists(cl_path)
|
|
|
|
if cl_path_exists:
|
|
debug('found ' + _CL_EXE_NAME + '!')
|
|
return True
|
|
|
|
elif 8 > ver_num >= 6:
|
|
# quick check for vc_dir/bin and vc_dir/ before walk
|
|
# need to check root as the walk only considers subdirectories
|
|
for cl_dir in ('bin', ''):
|
|
cl_path = os.path.join(vc_dir, cl_dir, _CL_EXE_NAME)
|
|
if os.path.exists(cl_path):
|
|
debug(_CL_EXE_NAME + ' found %s' % cl_path)
|
|
return True
|
|
# not in bin or root: must be in a subdirectory
|
|
for cl_root, cl_dirs, _ in os.walk(vc_dir):
|
|
for cl_dir in cl_dirs:
|
|
cl_path = os.path.join(cl_root, cl_dir, _CL_EXE_NAME)
|
|
if os.path.exists(cl_path):
|
|
debug(_CL_EXE_NAME + ' found %s' % cl_path)
|
|
return True
|
|
return False
|
|
else:
|
|
# version not support return false
|
|
debug('unsupported MSVC version: ' + str(ver_num))
|
|
|
|
return False
|
|
|
|
def get_installed_vcs(env=None):
|
|
global __INSTALLED_VCS_RUN
|
|
|
|
if __INSTALLED_VCS_RUN is not None:
|
|
return __INSTALLED_VCS_RUN
|
|
|
|
installed_versions = []
|
|
|
|
for ver in _VCVER:
|
|
debug('trying to find VC %s' % ver)
|
|
try:
|
|
VC_DIR = find_vc_pdir(env, ver)
|
|
if VC_DIR:
|
|
debug('found VC %s' % ver)
|
|
if _check_cl_exists_in_vc_dir(env, VC_DIR, ver):
|
|
installed_versions.append(ver)
|
|
else:
|
|
debug('no compiler found %s' % ver)
|
|
else:
|
|
debug('return None for ver %s' % ver)
|
|
except (MSVCUnsupportedTargetArch, MSVCUnsupportedHostArch):
|
|
# Allow this exception to propagate further as it should cause
|
|
# SCons to exit with an error code
|
|
raise
|
|
except VisualCException as e:
|
|
debug('did not find VC %s: caught exception %s' % (ver, str(e)))
|
|
|
|
__INSTALLED_VCS_RUN = installed_versions
|
|
return __INSTALLED_VCS_RUN
|
|
|
|
def reset_installed_vcs():
|
|
"""Make it try again to find VC. This is just for the tests."""
|
|
global __INSTALLED_VCS_RUN
|
|
__INSTALLED_VCS_RUN = None
|
|
|
|
# Running these batch files isn't cheap: most of the time spent in
|
|
# msvs.generate() is due to vcvars*.bat. In a build that uses "tools='msvs'"
|
|
# in multiple environments, for example:
|
|
# env1 = Environment(tools='msvs')
|
|
# env2 = Environment(tools='msvs')
|
|
# we can greatly improve the speed of the second and subsequent Environment
|
|
# (or Clone) calls by memoizing the environment variables set by vcvars*.bat.
|
|
#
|
|
# Updated: by 2018, vcvarsall.bat had gotten so expensive (vs2017 era)
|
|
# it was breaking CI builds because the test suite starts scons so many
|
|
# times and the existing memo logic only helped with repeated calls
|
|
# within the same scons run. Windows builds on the CI system were split
|
|
# into chunks to get around single-build time limits.
|
|
# With VS2019 it got even slower and an optional persistent cache file
|
|
# was introduced. The cache now also stores only the parsed vars,
|
|
# not the entire output of running the batch file - saves a bit
|
|
# of time not parsing every time.
|
|
|
|
script_env_cache = None
|
|
|
|
def script_env(script, args=None):
|
|
global script_env_cache
|
|
|
|
if script_env_cache is None:
|
|
script_env_cache = common.read_script_env_cache()
|
|
cache_key = "{}--{}".format(script, args)
|
|
cache_data = script_env_cache.get(cache_key, None)
|
|
if cache_data is None:
|
|
stdout = common.get_output(script, args)
|
|
|
|
# Stupid batch files do not set return code: we take a look at the
|
|
# beginning of the output for an error message instead
|
|
olines = stdout.splitlines()
|
|
if olines[0].startswith("The specified configuration type is missing"):
|
|
raise BatchFileExecutionError("\n".join(olines[:2]))
|
|
|
|
cache_data = common.parse_output(stdout)
|
|
script_env_cache[cache_key] = cache_data
|
|
# once we updated cache, give a chance to write out if user wanted
|
|
common.write_script_env_cache(script_env_cache)
|
|
|
|
return cache_data
|
|
|
|
def get_default_version(env):
|
|
msvc_version = env.get('MSVC_VERSION')
|
|
msvs_version = env.get('MSVS_VERSION')
|
|
debug('msvc_version:%s msvs_version:%s' % (msvc_version, msvs_version))
|
|
|
|
if msvs_version and not msvc_version:
|
|
SCons.Warnings.warn(
|
|
SCons.Warnings.DeprecatedWarning,
|
|
"MSVS_VERSION is deprecated: please use MSVC_VERSION instead ")
|
|
return msvs_version
|
|
elif msvc_version and msvs_version:
|
|
if not msvc_version == msvs_version:
|
|
SCons.Warnings.warn(
|
|
SCons.Warnings.VisualVersionMismatch,
|
|
"Requested msvc version (%s) and msvs version (%s) do " \
|
|
"not match: please use MSVC_VERSION only to request a " \
|
|
"visual studio version, MSVS_VERSION is deprecated" \
|
|
% (msvc_version, msvs_version))
|
|
return msvs_version
|
|
|
|
if not msvc_version:
|
|
installed_vcs = get_installed_vcs(env)
|
|
debug('installed_vcs:%s' % installed_vcs)
|
|
if not installed_vcs:
|
|
#msg = 'No installed VCs'
|
|
#debug('msv %s' % repr(msg))
|
|
#SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, msg)
|
|
debug('No installed VCs')
|
|
return None
|
|
msvc_version = installed_vcs[0]
|
|
debug('using default installed MSVC version %s' % repr(msvc_version))
|
|
else:
|
|
debug('using specified MSVC version %s' % repr(msvc_version))
|
|
|
|
return msvc_version
|
|
|
|
def msvc_setup_env_once(env):
|
|
try:
|
|
has_run = env["MSVC_SETUP_RUN"]
|
|
except KeyError:
|
|
has_run = False
|
|
|
|
if not has_run:
|
|
msvc_setup_env(env)
|
|
env["MSVC_SETUP_RUN"] = True
|
|
|
|
def msvc_find_valid_batch_script(env, version):
|
|
"""Find and execute appropriate batch script to set up build env.
|
|
|
|
The MSVC build environment depends heavily on having the shell
|
|
environment set. SCons does not inherit that, and does not count
|
|
on that being set up correctly anyway, so it tries to find the right
|
|
MSVC batch script, or the right arguments to the generic batch script
|
|
vcvarsall.bat, and run that, so we have a valid environment to build in.
|
|
There are dragons here: the batch scripts don't fail (see comments
|
|
elsewhere), they just leave you with a bad setup, so try hard to
|
|
get it right.
|
|
"""
|
|
|
|
# Find the host, target, and if present the requested target:
|
|
platforms = get_host_target(env)
|
|
debug("host_platform %s, target_platform %s req_target_platform %s" % platforms)
|
|
host_platform, target_platform, req_target_platform = platforms
|
|
|
|
# Most combinations of host + target are straightforward.
|
|
# While all MSVC / Visual Studio tools are pysically 32-bit, they
|
|
# make it look like there are 64-bit tools if the host is 64-bit,
|
|
# so you can invoke the environment batch script to set up to build,
|
|
# say, amd64 host -> x86 target. Express versions are an exception:
|
|
# they always look 32-bit, so the batch scripts with 64-bit
|
|
# host parts are absent. We try to fix that up in a couple of ways.
|
|
# One is here: we make a table of "targets" to try, with the extra
|
|
# targets being tags that tell us to try a different "host" instead
|
|
# of the deduced host.
|
|
try_target_archs = [target_platform]
|
|
if req_target_platform in ('amd64', 'x86_64'):
|
|
try_target_archs.append('x86_amd64')
|
|
elif req_target_platform in ('x86',):
|
|
try_target_archs.append('x86_x86')
|
|
elif req_target_platform in ('arm',):
|
|
try_target_archs.append('x86_arm')
|
|
elif req_target_platform in ('arm64',):
|
|
try_target_archs.append('x86_arm64')
|
|
elif not req_target_platform:
|
|
if target_platform in ('amd64', 'x86_64'):
|
|
try_target_archs.append('x86_amd64')
|
|
# If the user hasn't specifically requested a TARGET_ARCH,
|
|
# and the TARGET_ARCH is amd64 then also try 32 bits
|
|
# if there are no viable 64 bit tools installed
|
|
try_target_archs.append('x86')
|
|
|
|
debug("host_platform: %s, try_target_archs: %s"%(host_platform, try_target_archs))
|
|
|
|
d = None
|
|
for tp in try_target_archs:
|
|
# Set to current arch.
|
|
env['TARGET_ARCH'] = tp
|
|
|
|
debug("trying target_platform:%s" % tp)
|
|
host_target = (host_platform, tp)
|
|
if not is_host_target_supported(host_target, version):
|
|
warn_msg = "host, target = %s not supported for MSVC version %s" % \
|
|
(host_target, version)
|
|
SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)
|
|
arg = _HOST_TARGET_ARCH_TO_BAT_ARCH[host_target]
|
|
|
|
# Try to locate a batch file for this host/target platform combo
|
|
try:
|
|
(vc_script, use_arg, sdk_script) = find_batch_file(env, version, host_platform, tp)
|
|
debug('vc_script:%s sdk_script:%s'%(vc_script,sdk_script))
|
|
except VisualCException as e:
|
|
msg = str(e)
|
|
debug('Caught exception while looking for batch file (%s)' % msg)
|
|
warn_msg = "VC version %s not installed. " + \
|
|
"C/C++ compilers are most likely not set correctly.\n" + \
|
|
" Installed versions are: %s"
|
|
warn_msg = warn_msg % (version, get_installed_vcs(env))
|
|
SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)
|
|
continue
|
|
|
|
# Try to use the located batch file for this host/target platform combo
|
|
debug('use_script 2 %s, args:%s' % (repr(vc_script), arg))
|
|
found = None
|
|
if vc_script:
|
|
if not use_arg:
|
|
arg = '' # bat file will supply platform type
|
|
# Get just version numbers
|
|
maj, min = msvc_version_to_maj_min(version)
|
|
# VS2015+
|
|
if maj >= 14:
|
|
if env.get('MSVC_UWP_APP') == '1':
|
|
# Initialize environment variables with store/UWP paths
|
|
arg = (arg + ' store').lstrip()
|
|
|
|
try:
|
|
d = script_env(vc_script, args=arg)
|
|
found = vc_script
|
|
except BatchFileExecutionError as e:
|
|
debug('use_script 3: failed running VC script %s: %s: Error:%s'%(repr(vc_script),arg,e))
|
|
vc_script=None
|
|
continue
|
|
if not vc_script and sdk_script:
|
|
debug('use_script 4: trying sdk script: %s' % sdk_script)
|
|
try:
|
|
d = script_env(sdk_script)
|
|
found = sdk_script
|
|
except BatchFileExecutionError as e:
|
|
debug('use_script 5: failed running SDK script %s: Error:%s'%(repr(sdk_script), e))
|
|
continue
|
|
elif not vc_script and not sdk_script:
|
|
debug('use_script 6: Neither VC script nor SDK script found')
|
|
continue
|
|
|
|
debug("Found a working script/target: %s/%s"%(repr(found),arg))
|
|
break # We've found a working target_platform, so stop looking
|
|
|
|
# If we cannot find a viable installed compiler, reset the TARGET_ARCH
|
|
# To it's initial value
|
|
if not d:
|
|
env['TARGET_ARCH']=req_target_platform
|
|
|
|
return d
|
|
|
|
|
|
def msvc_setup_env(env):
|
|
debug('called')
|
|
version = get_default_version(env)
|
|
if version is None:
|
|
warn_msg = "No version of Visual Studio compiler found - C/C++ " \
|
|
"compilers most likely not set correctly"
|
|
SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)
|
|
return None
|
|
|
|
# XXX: we set-up both MSVS version for backward
|
|
# compatibility with the msvs tool
|
|
env['MSVC_VERSION'] = version
|
|
env['MSVS_VERSION'] = version
|
|
env['MSVS'] = {}
|
|
|
|
|
|
use_script = env.get('MSVC_USE_SCRIPT', True)
|
|
if SCons.Util.is_String(use_script):
|
|
debug('use_script 1 %s' % repr(use_script))
|
|
d = script_env(use_script)
|
|
elif use_script:
|
|
d = msvc_find_valid_batch_script(env,version)
|
|
debug('use_script 2 %s' % d)
|
|
if not d:
|
|
return d
|
|
else:
|
|
debug('MSVC_USE_SCRIPT set to False')
|
|
warn_msg = "MSVC_USE_SCRIPT set to False, assuming environment " \
|
|
"set correctly."
|
|
SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)
|
|
return None
|
|
|
|
for k, v in d.items():
|
|
env.PrependENVPath(k, v, delete_existing=True)
|
|
debug("env['ENV']['%s'] = %s" % (k, env['ENV'][k]))
|
|
|
|
# final check to issue a warning if the compiler is not present
|
|
if not find_program_path(env, 'cl'):
|
|
debug("did not find " + _CL_EXE_NAME)
|
|
if CONFIG_CACHE:
|
|
propose = "SCONS_CACHE_MSVC_CONFIG caching enabled, remove cache file {} if out of date.".format(CONFIG_CACHE)
|
|
else:
|
|
propose = "It may need to be installed separately with Visual Studio."
|
|
warn_msg = "Could not find MSVC compiler 'cl'. {}".format(propose)
|
|
SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)
|
|
|
|
def msvc_exists(env=None, version=None):
|
|
vcs = get_installed_vcs(env)
|
|
if version is None:
|
|
return len(vcs) > 0
|
|
return version in vcs
|