def GetNugetCmd():
file = "NuGet.exe"
cmd = []
if GetHostInfo().os == "Linux":
cmd += ["mono"]
# TODO Find the Nuget rom our bin file
requirement = pkg_resources.Requirement.parse("edk2-pytool-extensions")
nuget_file_path = os.path.join("edk2toolext", "bin", file)
nuget_path = pkg_resources.resource_filename(requirement, nuget_file_path)
# check if we don't have it, look for nuget in the path
if not os.path.isfile(nuget_path):
for env_var in os.getenv("PATH").split(os.pathsep):
env_var = os.path.join(os.path.normpath(env_var), file)
if os.path.isfile(env_var):
nuget_path = '"' + env_var + '"'
break
# we've probably found something by now?
cmd += [nuget_path]
# if we're still hosed
if not os.path.isfile(nuget_path):
logging.error("We weren't able to find Nuget! Please reinstall your pip environment")
return None
return cmd
def GetActiveScopes(self):
''' return tuple containing scopes that should be active for this process '''
if self.ActualScopes is None:
scopes = ("cibuild", "edk2-build", "host-based-test")
self.ActualToolChainTag = shell_environment.GetBuildVars(
).GetValue("TOOL_CHAIN_TAG", "")
is_linux = GetHostInfo().os.upper() == "LINUX"
if self.UseBuiltInBaseTools is None:
# MU_CHANGE - redundant is_linux = GetHostInfo().os.upper() == "LINUX"
# try and import the pip module for basetools
try:
import edk2basetools
self.UseBuiltInBaseTools = True
except ImportError:
self.UseBuiltInBaseTools = False
pass
if self.UseBuiltInBaseTools == True:
scopes += ('pipbuild-unix', ) if is_linux else (
'pipbuild-win', )
logging.warning("Using Pip Tools based BaseTools")
else:
logging.warning("Falling back to using in-tree BaseTools")
if is_linux and self.ActualToolChainTag.upper().startswith("GCC"):
if "AARCH64" in self.ActualArchitectures:
scopes += ("gcc_aarch64_linux", )
if "ARM" in self.ActualArchitectures:
scopes += ("gcc_arm_linux", )
if "RISCV64" in self.ActualArchitectures:
scopes += ("gcc_riscv64_unknown", )
self.ActualScopes = scopes
return self.ActualScopes
def GetActiveScopes(self):
''' return tuple containing scopes that should be active for this process '''
if self.ActualScopes is None:
scopes = ("cibuild", "edk2-build", "host-based-test")
self.ActualToolChainTag = shell_environment.GetBuildVars().GetValue("TOOL_CHAIN_TAG", "")
is_linux = GetHostInfo().os.upper() == "LINUX"
scopes += ('pipbuild-unix',) if is_linux else ('pipbuild-win',)
if is_linux and self.ActualToolChainTag.upper().startswith("GCC"):
if "AARCH64" in self.ActualArchitectures:
scopes += ("gcc_aarch64_linux",)
if "ARM" in self.ActualArchitectures:
scopes += ("gcc_arm_linux",)
if "RISCV64" in self.ActualArchitectures:
scopes += ("gcc_riscv64_unknown",)
# If EDK2_REPO is not provided, download it.
if not shell_environment.GetBuildVars().GetValue("EDK2_REPO", ""):
scopes += ("edk2-repo",)
self.ActualScopes = scopes
return self.ActualScopes
def do_pre_build(self, thebuilder):
self.Logger = logging.getLogger("WindowsVsToolChain")
interesting_keys = ["ExtensionSdkDir", "INCLUDE", "LIB", "LIBPATH", "UniversalCRTSdkDir",
"UCRTVersion", "WindowsLibPath", "WindowsSdkBinPath", "WindowsSdkDir", "WindowsSdkVerBinPath",
"WindowsSDKVersion", "VCToolsInstallDir", "Path"]
#
# VS2017 - Follow VS2017 where there is potential for many versions of the tools.
# If a specific version is required then the user must set both env variables:
# VS150INSTALLPATH: base install path on system to VC install dir. Here you will find the VC folder, etc
# VS150TOOLVER: version number for the VC compiler tools
# VS2017_PREFIX: path to MSVC compiler folder with trailing slash (can be used instead of two vars above)
# VS2017_HOST: set the host architecture to use for host tools, and host libs, etc
if thebuilder.env.GetValue("TOOL_CHAIN_TAG") == "VS2017":
# check to see if host is configured
# HostType for VS2017 should be (defined in tools_def):
# x86 == 32bit Intel
# x64 == 64bit Intel
# arm == 32bit Arm
# arm64 == 64bit Arm
#
HostType = shell_environment.GetEnvironment().get_shell_var("VS2017_HOST")
if HostType is not None:
HostType = HostType.lower()
self.Logger.info(
f"HOST TYPE defined by environment. Host Type is {HostType}")
else:
HostInfo = GetHostInfo()
if HostInfo.arch == "x86":
if HostInfo.bit == "32":
HostType = "x86"
elif HostInfo.bit == "64":
HostType = "x64"
else:
raise NotImplementedError()
# VS2017_HOST options are not exactly the same as QueryVcVariables. This translates.
VC_HOST_ARCH_TRANSLATOR = {
"x86": "x86", "x64": "AMD64", "arm": "not supported", "arm64": "not supported"}
# check to see if full path already configured
if shell_environment.GetEnvironment().get_shell_var("VS2017_PREFIX") is not None:
self.Logger.debug("VS2017_PREFIX is already set.")
else:
install_path = self._get_vs_install_path(
"VS2017".lower(), "VS150INSTALLPATH")
vc_ver = self._get_vc_version(install_path, "VS150TOOLVER")
if install_path is None or vc_ver is None:
self.Logger.error(
"Failed to configure environment for VS2017")
return -1
version_aggregator.GetVersionAggregator().ReportVersion(
"Visual Studio Install Path", install_path, version_aggregator.VersionTypes.INFO)
version_aggregator.GetVersionAggregator().ReportVersion(
"VC Version", vc_ver, version_aggregator.VersionTypes.TOOL)
# make VS2017_PREFIX to align with tools_def.txt
prefix = os.path.join(install_path, "VC",
"Tools", "MSVC", vc_ver)
prefix = prefix + os.path.sep
shell_environment.GetEnvironment().set_shell_var("VS2017_PREFIX", prefix)
shell_environment.GetEnvironment().set_shell_var("VS2017_HOST", HostType)
shell_env = shell_environment.GetEnvironment()
# Use the tools lib to determine the correct values for the vars that interest us.
vs_vars = locate_tools.QueryVcVariables(
interesting_keys, VC_HOST_ARCH_TRANSLATOR[HostType], vs_version="vs2017")
for (k, v) in vs_vars.items():
shell_env.set_shell_var(k, v)
# now confirm it exists
if not os.path.exists(shell_environment.GetEnvironment().get_shell_var("VS2017_PREFIX")):
self.Logger.error("Path for VS2017 toolchain is invalid")
return -2
#
# VS2019 - Follow VS2019 where there is potential for many versions of the tools.
# If a specific version is required then the user must set both env variables:
# VS160INSTALLPATH: base install path on system to VC install dir. Here you will find the VC folder, etc
# VS160TOOLVER: version number for the VC compiler tools
# VS2019_PREFIX: path to MSVC compiler folder with trailing slash (can be used instead of two vars above)
# VS2019_HOST: set the host architecture to use for host tools, and host libs, etc
elif thebuilder.env.GetValue("TOOL_CHAIN_TAG") == "VS2019":
# check to see if host is configured
# HostType for VS2019 should be (defined in tools_def):
# x86 == 32bit Intel
# x64 == 64bit Intel
# arm == 32bit Arm
# arm64 == 64bit Arm
#
HostType = shell_environment.GetEnvironment().get_shell_var("VS2019_HOST")
if HostType is not None:
HostType = HostType.lower()
self.Logger.info(
f"HOST TYPE defined by environment. Host Type is {HostType}")
else:
HostInfo = GetHostInfo()
if HostInfo.arch == "x86":
if HostInfo.bit == "32":
HostType = "x86"
elif HostInfo.bit == "64":
HostType = "x64"
else:
raise NotImplementedError()
# VS2019_HOST options are not exactly the same as QueryVcVariables. This translates.
VC_HOST_ARCH_TRANSLATOR = {
"x86": "x86", "x64": "AMD64", "arm": "not supported", "arm64": "not supported"}
# check to see if full path already configured
if shell_environment.GetEnvironment().get_shell_var("VS2019_PREFIX") is not None:
self.Logger.debug("VS2019_PREFIX is already set.")
else:
install_path = self._get_vs_install_path(
"VS2019".lower(), "VS160INSTALLPATH")
vc_ver = self._get_vc_version(install_path, "VS160TOOLVER")
if install_path is None or vc_ver is None:
self.Logger.error(
"Failed to configure environment for VS2019")
return -1
version_aggregator.GetVersionAggregator().ReportVersion(
"Visual Studio Install Path", install_path, version_aggregator.VersionTypes.INFO)
version_aggregator.GetVersionAggregator().ReportVersion(
"VC Version", vc_ver, version_aggregator.VersionTypes.TOOL)
# make VS2019_PREFIX to align with tools_def.txt
prefix = os.path.join(install_path, "VC",
"Tools", "MSVC", vc_ver)
prefix = prefix + os.path.sep
shell_environment.GetEnvironment().set_shell_var("VS2019_PREFIX", prefix)
shell_environment.GetEnvironment().set_shell_var("VS2019_HOST", HostType)
shell_env = shell_environment.GetEnvironment()
# Use the tools lib to determine the correct values for the vars that interest us.
vs_vars = locate_tools.QueryVcVariables(
interesting_keys, VC_HOST_ARCH_TRANSLATOR[HostType], vs_version="vs2019")
for (k, v) in vs_vars.items():
shell_env.set_shell_var(k, v)
# now confirm it exists
if not os.path.exists(shell_environment.GetEnvironment().get_shell_var("VS2019_PREFIX")):
self.Logger.error("Path for VS2019 toolchain is invalid")
return -2
#
# VS2022 - VS2022 allows a user to install many copies/versions of the tools.
# If a specific version is required then the user must set both env variables:
# VS170INSTALLPATH: base install path on system to VC install dir. Here you will find the VC folder, etc
# VS170TOOLVER: version number for the VC compiler tools
# VS2022_PREFIX: path to MSVC compiler folder with trailing slash (can be used instead of two vars above)
# VS2022_HOST: set the host architecture to use for host tools, and host libs, etc
elif thebuilder.env.GetValue("TOOL_CHAIN_TAG") == "VS2022":
# check to see if host is configured
# HostType for VS2022 should be (defined in tools_def):
# x86 == 32bit Intel
# x64 == 64bit Intel
# arm == 32bit Arm
# arm64 == 64bit Arm
#
HostType = shell_environment.GetEnvironment().get_shell_var("VS2022_HOST")
if HostType is not None:
HostType = HostType.lower()
self.Logger.info(
f"HOST TYPE defined by environment. Host Type is {HostType}")
else:
HostInfo = GetHostInfo()
if HostInfo.arch == "x86":
if HostInfo.bit == "32":
HostType = "x86"
elif HostInfo.bit == "64":
HostType = "x64"
else:
raise NotImplementedError()
# VS2022_HOST options are not exactly the same as QueryVcVariables. This translates.
VC_HOST_ARCH_TRANSLATOR = {
"x86": "x86", "x64": "AMD64", "arm": "not supported", "arm64": "not supported"}
# check to see if full path already configured
if shell_environment.GetEnvironment().get_shell_var("VS2022_PREFIX") is not None:
self.Logger.debug("VS2022_PREFIX is already set.")
else:
install_path = self._get_vs_install_path(
"VS2022".lower(), "VS170INSTALLPATH")
vc_ver = self._get_vc_version(install_path, "VS170TOOLVER")
if install_path is None or vc_ver is None:
self.Logger.error(
"Failed to configure environment for VS2022")
return -1
version_aggregator.GetVersionAggregator().ReportVersion(
"Visual Studio Install Path", install_path, version_aggregator.VersionTypes.INFO)
version_aggregator.GetVersionAggregator().ReportVersion(
"VC Version", vc_ver, version_aggregator.VersionTypes.TOOL)
# make VS2022_PREFIX to align with tools_def.txt
prefix = os.path.join(install_path, "VC",
"Tools", "MSVC", vc_ver)
prefix = prefix + os.path.sep
shell_environment.GetEnvironment().set_shell_var("VS2022_PREFIX", prefix)
shell_environment.GetEnvironment().set_shell_var("VS2022_HOST", HostType)
shell_env = shell_environment.GetEnvironment()
# Use the tools lib to determine the correct values for the vars that interest us.
vs_vars = locate_tools.QueryVcVariables(
interesting_keys, VC_HOST_ARCH_TRANSLATOR[HostType], vs_version="VS2022")
for (k, v) in vs_vars.items():
shell_env.set_shell_var(k, v)
# now confirm it exists
if not os.path.exists(shell_environment.GetEnvironment().get_shell_var("VS2022_PREFIX")):
self.Logger.error("Path for VS2022 toolchain is invalid")
return -2
#
# CLANGPDB on Windows uses nmake from
# the VS compiler toolchain. Find a version and set
# as the CLANG_HOST_BIN path if not already set.
#
# Also get the platform header files, SDK, etc based on the
# host type. This is used for unit test compilation.
# If CLANG_VS_HOST is not set then find the host type based on Host Info.
##
elif thebuilder.env.GetValue("TOOL_CHAIN_TAG") == "CLANGPDB":
HostInfo = GetHostInfo()
# check to see if host is configured
# HostType for VS tools should be (defined in tools_def):
# x86 == 32bit Intel
# x64 == 64bit Intel
# arm == 32bit Arm
# arm64 == 64bit Arm
#
HostType = shell_environment.GetEnvironment().get_shell_var("CLANG_VS_HOST")
if HostType is not None:
HostType = HostType.lower()
self.Logger.info(
f"CLANG_VS_HOST defined by environment. Value is {HostType}")
else:
#figure it out based on host info
if HostInfo.arch == "x86":
if HostInfo.bit == "32":
HostType = "x86"
elif HostInfo.bit == "64":
HostType = "x64"
else:
# anything other than x86 or x64 is not supported
raise NotImplementedError()
# CLANG_VS_HOST options are not exactly the same as QueryVcVariables. This translates.
VC_HOST_ARCH_TRANSLATOR = {
"x86": "x86", "x64": "AMD64", "arm": "not supported", "arm64": "not supported"}
# now get the environment variables for the platform
shell_env = shell_environment.GetEnvironment()
# Use the tools lib to determine the correct values for the vars that interest us.
vs_vars = locate_tools.QueryVcVariables(
interesting_keys, VC_HOST_ARCH_TRANSLATOR[HostType])
for (k, v) in vs_vars.items():
shell_env.set_shell_var(k, v)
##
# If environment already has CLANG_HOST_BIN set then user has already
# set the path to the VS tools like nmake.exe
##
if shell_environment.GetEnvironment().get_shell_var("CLANG_HOST_BIN") is not None:
self.Logger.debug("CLANG_HOST_BIN is already set.")
else:
install_path = self._get_vs_install_path(None, None)
vc_ver = self._get_vc_version(install_path, None)
if install_path is None or vc_ver is None:
self.Logger.error("Failed to find the VS environment for use by CLANGPDB")
return -1
version_aggregator.GetVersionAggregator().ReportVersion(
"Visual Studio Install Path", install_path, version_aggregator.VersionTypes.INFO)
version_aggregator.GetVersionAggregator().ReportVersion(
"VC Version", vc_ver, version_aggregator.VersionTypes.TOOL)
# make path align with tools_def.txt
prefix = os.path.join(install_path, "VC", "Tools", "MSVC", vc_ver)
clang_host_bin_prefix = os.path.join(prefix, "bin", "Host%s" % HostType, HostType)
# now confirm it exists
if not os.path.exists(clang_host_bin_prefix):
self.Logger.error("Path for VS toolchain is invalid")
return -2
# The environment is using nmake (not make) so add "n" to the end of the path.
# The rest of the command is derived from definitions in tools.def.
shell_environment.GetEnvironment().set_shell_var("CLANG_HOST_BIN", os.path.join(clang_host_bin_prefix, "n"))
return 0
def do_post_build(self, thebuilder):
'''
After a build, will automatically locate and run all host-based unit tests. Logs any
failures with Warning severity and will return a count of the failures as the return code.
EXPECTS:
- Build Var 'CI_BUILD_TYPE' - If not set to 'host_unit_test', will not do anything.
UPDATES:
- Shell Var 'CMOCKA_XML_FILE'
'''
ci_type = thebuilder.env.GetValue('CI_BUILD_TYPE')
if ci_type != 'host_unit_test':
return 0
shell_env = shell_environment.GetEnvironment()
logging.log(edk2_logging.get_section_level(),
"Run Host based Unit Tests")
path = thebuilder.env.GetValue("BUILD_OUTPUT_BASE")
failure_count = 0
# Set up the reporting type for Cmocka.
shell_env.set_shell_var('CMOCKA_MESSAGE_OUTPUT', 'xml')
for arch in thebuilder.env.GetValue("TARGET_ARCH").split():
logging.log(edk2_logging.get_subsection_level(),
"Testing for architecture: " + arch)
cp = os.path.join(path, arch)
# If any old results XML files exist, clean them up.
for old_result in glob.iglob(os.path.join(cp, "*.result.xml")):
os.remove(old_result)
# Find and Run any Host Tests
if GetHostInfo().os.upper() == "LINUX":
testList = glob.glob(os.path.join(cp, "*Test*"))
for a in testList[:]:
p = os.path.join(cp, a)
# It must be a file
if not os.path.isfile(p):
testList.remove(a)
logging.debug(f"Remove directory file: {p}")
continue
# It must be executable
if os.stat(p).st_mode & (stat.S_IEXEC | stat.S_IXGRP
| stat.S_IXOTH) == 0:
testList.remove(a)
logging.debug(f"Remove non-executable file: {p}")
continue
logging.info(f"Test file found: {p}")
elif GetHostInfo().os.upper() == "WINDOWS":
testList = glob.glob(os.path.join(cp, "*Test*.exe"))
else:
raise NotImplementedError("Unsupported Operating System")
for test in testList:
# Configure output name.
shell_env.set_shell_var('CMOCKA_XML_FILE',
test + ".%g." + arch + ".result.xml")
# Run the test.
ret = RunCmd('"' + test + '"', "", workingdir=cp)
if (ret != 0):
logging.error("UnitTest Execution Error: " +
os.path.basename(test))
else:
logging.info("UnitTest Completed: " +
os.path.basename(test))
file_match_pattern = test + ".*." + arch + ".result.xml"
xml_results_list = glob.glob(file_match_pattern)
for xml_result_file in xml_results_list:
root = xml.etree.ElementTree.parse(
xml_result_file).getroot()
for suite in root:
for case in suite:
for result in case:
if result.tag == 'failure':
logging.warning("%s Test Failed" %
os.path.basename(test))
logging.warning(
" %s - %s" %
(case.attrib['name'], result.text))
failure_count += 1
return failure_count
def do_pre_build(self, thebuilder):
self.Logger = logging.getLogger("WindowsVsToolChain")
interesting_keys = [
"ExtensionSdkDir", "INCLUDE", "LIB", "LIBPATH",
"UniversalCRTSdkDir", "UCRTVersion", "WindowsLibPath",
"WindowsSdkBinPath", "WindowsSdkDir", "WindowsSdkVerBinPath",
"WindowsSDKVersion", "VCToolsInstallDir", "Path"
]
#
# VS2017 - Follow VS2017 where there is potential for many versions of the tools.
# If a specific version is required then the user must set both env variables:
# VS150INSTALLPATH: base install path on system to VC install dir. Here you will find the VC folder, etc
# VS150TOOLVER: version number for the VC compiler tools
# VS2017_PREFIX: path to MSVC compiler folder with trailing slash (can be used instead of two vars above)
# VS2017_HOST: set the host architecture to use for host tools, and host libs, etc
if thebuilder.env.GetValue("TOOL_CHAIN_TAG") == "VS2017":
# check to see if host is configured
# HostType for VS2017 should be (defined in tools_def):
# x86 == 32bit Intel
# x64 == 64bit Intel
# arm == 32bit Arm
# arm64 == 64bit Arm
#
HostType = shell_environment.GetEnvironment().get_shell_var(
"VS2017_HOST")
if HostType is not None:
HostType = HostType.lower()
self.Logger.info(
f"HOST TYPE defined by environment. Host Type is {HostType}"
)
else:
HostInfo = GetHostInfo()
if HostInfo.arch == "x86":
if HostInfo.bit == "32":
HostType = "x86"
elif HostInfo.bit == "64":
HostType = "x64"
else:
raise NotImplementedError()
# VS2017_HOST options are not exactly the same as QueryVcVariables. This translates.
VC_HOST_ARCH_TRANSLATOR = {
"x86": "x86",
"x64": "AMD64",
"arm": "not supported",
"arm64": "not supported"
}
# check to see if full path already configured
if shell_environment.GetEnvironment().get_shell_var(
"VS2017_PREFIX") != None:
self.Logger.info("VS2017_PREFIX is already set.")
else:
install_path = self._get_vs_install_path(
"VS2017".lower(), "VS150INSTALLPATH")
vc_ver = self._get_vc_version(install_path, "VS150TOOLVER")
if install_path is None or vc_ver is None:
self.Logger.error(
"Failed to configure environment for VS2017")
return -1
version_aggregator.GetVersionAggregator().ReportVersion(
"Visual Studio Install Path", install_path,
version_aggregator.VersionTypes.INFO)
version_aggregator.GetVersionAggregator().ReportVersion(
"VC Version", vc_ver, version_aggregator.VersionTypes.TOOL)
# make VS2017_PREFIX to align with tools_def.txt
prefix = os.path.join(install_path, "VC", "Tools", "MSVC",
vc_ver)
prefix = prefix + os.path.sep
shell_environment.GetEnvironment().set_shell_var(
"VS2017_PREFIX", prefix)
shell_environment.GetEnvironment().set_shell_var(
"VS2017_HOST", HostType)
shell_env = shell_environment.GetEnvironment()
# Use the tools lib to determine the correct values for the vars that interest us.
vs_vars = locate_tools.QueryVcVariables(
interesting_keys,
VC_HOST_ARCH_TRANSLATOR[HostType],
vs_version="vs2017")
for (k, v) in vs_vars.items():
shell_env.set_shell_var(k, v)
# now confirm it exists
if not os.path.exists(shell_environment.GetEnvironment().
get_shell_var("VS2017_PREFIX")):
self.Logger.error("Path for VS2017 toolchain is invalid")
return -2
#
# VS2019 - Follow VS2019 where there is potential for many versions of the tools.
# If a specific version is required then the user must set both env variables:
# VS160INSTALLPATH: base install path on system to VC install dir. Here you will find the VC folder, etc
# VS160TOOLVER: version number for the VC compiler tools
# VS2019_PREFIX: path to MSVC compiler folder with trailing slash (can be used instead of two vars above)
# VS2017_HOST: set the host architecture to use for host tools, and host libs, etc
elif thebuilder.env.GetValue("TOOL_CHAIN_TAG") == "VS2019":
# check to see if host is configured
# HostType for VS2019 should be (defined in tools_def):
# x86 == 32bit Intel
# x64 == 64bit Intel
# arm == 32bit Arm
# arm64 == 64bit Arm
#
HostType = shell_environment.GetEnvironment().get_shell_var(
"VS2019_HOST")
if HostType is not None:
HostType = HostType.lower()
self.Logger.info(
f"HOST TYPE defined by environment. Host Type is {HostType}"
)
else:
HostInfo = GetHostInfo()
if HostInfo.arch == "x86":
if HostInfo.bit == "32":
HostType = "x86"
elif HostInfo.bit == "64":
HostType = "x64"
else:
raise NotImplementedError()
# VS2019_HOST options are not exactly the same as QueryVcVariables. This translates.
VC_HOST_ARCH_TRANSLATOR = {
"x86": "x86",
"x64": "AMD64",
"arm": "not supported",
"arm64": "not supported"
}
# check to see if full path already configured
if shell_environment.GetEnvironment().get_shell_var(
"VS2019_PREFIX") != None:
self.Logger.info("VS2019_PREFIX is already set.")
else:
install_path = self._get_vs_install_path(
"VS2019".lower(), "VS160INSTALLPATH")
vc_ver = self._get_vc_version(install_path, "VS160TOOLVER")
if install_path is None or vc_ver is None:
self.Logger.error(
"Failed to configure environment for VS2019")
return -1
version_aggregator.GetVersionAggregator().ReportVersion(
"Visual Studio Install Path", install_path,
version_aggregator.VersionTypes.INFO)
version_aggregator.GetVersionAggregator().ReportVersion(
"VC Version", vc_ver, version_aggregator.VersionTypes.TOOL)
# make VS2019_PREFIX to align with tools_def.txt
prefix = os.path.join(install_path, "VC", "Tools", "MSVC",
vc_ver)
prefix = prefix + os.path.sep
shell_environment.GetEnvironment().set_shell_var(
"VS2019_PREFIX", prefix)
shell_environment.GetEnvironment().set_shell_var(
"VS2019_HOST", HostType)
shell_env = shell_environment.GetEnvironment()
# Use the tools lib to determine the correct values for the vars that interest us.
vs_vars = locate_tools.QueryVcVariables(
interesting_keys,
VC_HOST_ARCH_TRANSLATOR[HostType],
vs_version="vs2019")
for (k, v) in vs_vars.items():
shell_env.set_shell_var(k, v)
# now confirm it exists
if not os.path.exists(shell_environment.GetEnvironment().
get_shell_var("VS2019_PREFIX")):
self.Logger.error("Path for VS2019 toolchain is invalid")
return -2
return 0
def do_pre_build(self, thebuilder):
self.Logger = logging.getLogger("ClangPdbToolChain")
##
# CLANGPBD
# - Need to find the clang path.
# - Report path and version for logging
#
# if CLANG_BIN already set the plugin will confirm it exists and get the version of clang
# If not set it will look for clang on the path. If found it will configure for that.
# if still not found it will try the default install directory.
# finally an error will be reported if not found
##
if thebuilder.env.GetValue("TOOL_CHAIN_TAG") == "CLANGPDB":
HostInfo = GetHostInfo()
ClangBin_Default = "UNDEFINED"
clang_exe = "clang"
if HostInfo.os == "Windows":
ClangBin_Default = "C:\\Program Files\\LLVM\\bin\\\\" #need to escape the last slash as it seems to be removed
clang_exe += ".exe"
elif HostInfo.os == "Linux":
ClangBin_Default = "/LLVM/bin/" #this isn't right
else:
pass
# no defaults set
ClangBin = shell_environment.GetEnvironment().get_shell_var(
"CLANG_BIN")
if ClangBin is not None:
self.Logger.info("CLANG_BIN is already set.")
else:
# see if clang is on path.
for path_entry in os.getenv("PATH").split(os.pathsep):
path_entry = os.path.normpath(path_entry)
if os.path.isfile(os.path.join(path_entry, clang_exe)):
ClangBin = os.path.abspath(path_entry) + os.sep
break
if ClangBin is None:
# Didn't find it on path - try the install default.
ClangBin = ClangBin_Default
shell_environment.GetEnvironment().set_shell_var(
"CLANG_BIN", ClangBin)
version_aggregator.GetVersionAggregator().ReportVersion(
"CLANG BIN", ClangBin, version_aggregator.VersionTypes.INFO)
# now confirm it exists
if not os.path.exists(shell_environment.GetEnvironment().
get_shell_var("CLANG_BIN")):
self.Logger.error(
f"Path for CLANGPDB toolchain is invalid. {ClangBin}")
return -2
version_aggregator.GetVersionAggregator().ReportVersion(
"CLANG Version", self._get_clang_version(ClangBin),
version_aggregator.VersionTypes.TOOL)
return 0
