import os
import pathlib
import platform
import subprocess
import sys
import itertools
import lldbsuite.test.lldbtest as lldbtest
import lldbsuite.test.lldbplatformutil as lldbplatformutil
import lldbsuite.test.lldbutil as lldbutil
from lldbsuite.test import configuration
from lldbsuite.test_event import build_exception
class Builder:
def getArchitecture(self):
"""Returns the architecture in effect the test suite is running with."""
return configuration.arch if configuration.arch else ""
def getCompiler(self):
"""Returns the compiler in effect the test suite is running with."""
compiler = configuration.compiler if configuration.compiler else "clang"
compiler = lldbutil.which(compiler)
return os.path.abspath(compiler)
def getTriple(self, arch):
"""Returns the triple for the given architecture or None."""
return None
def getExtraMakeArgs(self):
"""
Helper function to return extra argumentsfor the make system. This
method is meant to be overridden by platform specific builders.
"""
return []
def getArchCFlags(self, architecture):
"""Returns the ARCH_CFLAGS for the make system."""
return []
def getMake(self, test_subdir, test_name):
"""Returns the invocation for GNU make.
The first argument is a tuple of the relative path to the testcase
and its filename stem."""
# Construct the base make invocation.
lldb_test = os.environ["LLDB_TEST"]
if not (
lldb_test
and configuration.test_build_dir
and test_subdir
and test_name
and (not os.path.isabs(test_subdir))
):
raise Exception("Could not derive test directories")
build_dir = os.path.join(configuration.test_build_dir, test_subdir, test_name)
src_dir = os.path.join(configuration.test_src_root, test_subdir)
# This is a bit of a hack to make inline testcases work.
makefile = os.path.join(src_dir, "Makefile")
if not os.path.isfile(makefile):
makefile = os.path.join(build_dir, "Makefile")
return [
configuration.make_path,
"VPATH=" + src_dir,
"-C",
build_dir,
"-I",
src_dir,
"-I",
os.path.join(lldb_test, "make"),
"-f",
makefile,
]
def getCmdLine(self, d):
"""
Helper function to return a command line argument string used for the
make system.
"""
# If d is None or an empty mapping, just return an empty list.
if not d:
return []
def setOrAppendVariable(k, v):
append_vars = ["CFLAGS", "CFLAGS_EXTRAS", "LD_EXTRAS"]
if k in append_vars and k in os.environ:
v = os.environ[k] + " " + v
return "%s=%s" % (k, v)
cmdline = [setOrAppendVariable(k, v) for k, v in list(d.items())]
return cmdline
def getArchSpec(self, architecture):
"""
Helper function to return the key-value string to specify the architecture
used for the make system.
"""
return ["ARCH=" + architecture] if architecture else []
def getToolchainSpec(self, compiler):
"""
Helper function to return the key-value strings to specify the toolchain
used for the make system.
"""
cc = compiler if compiler else None
if not cc and configuration.compiler:
cc = configuration.compiler
if not cc:
return []
exe_ext = ""
if lldbplatformutil.getHostPlatform() == "windows":
exe_ext = ".exe"
cc = cc.strip()
cc_path = pathlib.Path(cc)
# We can get CC compiler string in the following formats:
# [<tool>] <compiler> - such as 'xrun clang', 'xrun /usr/bin/clang' & etc
#
# Where <compiler> could contain the following parts:
# <simple-name>[.<exe-ext>] - sucn as 'clang', 'clang.exe' ('clang-cl.exe'?)
# <target-triple>-<simple-name>[.<exe-ext>] - such as 'armv7-linux-gnueabi-gcc'
# <path>/<simple-name>[.<exe-ext>] - such as '/usr/bin/clang', 'c:\path\to\compiler\clang,exe'
# <path>/<target-triple>-<simple-name>[.<exe-ext>] - such as '/usr/bin/clang', 'c:\path\to\compiler\clang,exe'
cc_ext = cc_path.suffix
# Compiler name without extension
cc_name = cc_path.stem.split(" ")[-1]
# A kind of compiler (canonical name): clang, gcc, cc & etc.
cc_type = cc_name
# A triple prefix of compiler name: <armv7-none-linux-gnu->gcc
cc_prefix = ""
if not "clang-cl" in cc_name and not "llvm-gcc" in cc_name:
cc_name_parts = cc_name.split("-")
cc_type = cc_name_parts[-1]
if len(cc_name_parts) > 1:
cc_prefix = "-".join(cc_name_parts[:-1]) + "-"
# A kind of C++ compiler.
cxx_types = {
"icc": "icpc",
"llvm-gcc": "llvm-g++",
"gcc": "g++",
"cc": "c++",
"clang": "clang++",
}
cxx_type = cxx_types.get(cc_type, cc_type)
cc_dir = cc_path.parent
def getToolchainUtil(util_name):
return os.path.join(configuration.llvm_tools_dir, util_name + exe_ext)
cxx = cc_dir / (cc_prefix + cxx_type + cc_ext)
util_names = {
"OBJCOPY": "objcopy",
"STRIP": "strip",
"ARCHIVER": "ar",
"DWP": "dwp",
}
utils = []
# Required by API TestBSDArchives.py tests.
if not os.getenv("LLVM_AR"):
utils.extend(["LLVM_AR=%s" % getToolchainUtil("llvm-ar")])
if not lldbplatformutil.platformIsDarwin():
if cc_type in ["clang", "cc", "gcc"]:
util_paths = {}
# Assembly a toolchain side tool cmd based on passed CC.
for var, name in util_names.items():
# Do not override explicity specified tool from the cmd line.
if not os.getenv(var):
util_paths[var] = getToolchainUtil(name)
else:
util_paths[var] = os.getenv(var)
utils.extend(["AR=%s" % util_paths["ARCHIVER"]])
# Look for llvm-dwp or gnu dwp
if not lldbutil.which(util_paths["DWP"]):
util_paths["DWP"] = getToolchainUtil("llvm-dwp")
if not lldbutil.which(util_paths["DWP"]):
util_paths["DWP"] = lldbutil.which("llvm-dwp")
if not util_paths["DWP"]:
util_paths["DWP"] = lldbutil.which("dwp")
if not util_paths["DWP"]:
del util_paths["DWP"]
for var, path in util_paths.items():
utils.append("%s=%s" % (var, path))
else:
utils.extend(["AR=%slibtool" % os.getenv("CROSS_COMPILE", "")])
return [
"CC=%s" % cc,
"CC_TYPE=%s" % cc_type,
"CXX=%s" % cxx,
] + utils
def getSDKRootSpec(self):
"""
Helper function to return the key-value string to specify the SDK root
used for the make system.
"""
if configuration.sdkroot:
return ["SDKROOT={}".format(configuration.sdkroot)]
return []
def getModuleCacheSpec(self):
"""
Helper function to return the key-value string to specify the clang
module cache used for the make system.
"""
if configuration.clang_module_cache_dir:
return [
"CLANG_MODULE_CACHE_DIR={}".format(configuration.clang_module_cache_dir)
]
return []
def getLibCxxArgs(self):
if configuration.libcxx_include_dir and configuration.libcxx_library_dir:
libcpp_args = [
"LIBCPP_INCLUDE_DIR={}".format(configuration.libcxx_include_dir),
"LIBCPP_LIBRARY_DIR={}".format(configuration.libcxx_library_dir),
]
if configuration.libcxx_include_target_dir:
libcpp_args.append(
"LIBCPP_INCLUDE_TARGET_DIR={}".format(
configuration.libcxx_include_target_dir
)
)
return libcpp_args
return []
def getLLDBObjRoot(self):
return ["LLDB_OBJ_ROOT={}".format(configuration.lldb_obj_root)]
def _getDebugInfoArgs(self, debug_info):
if debug_info is None:
return []
if debug_info == "dwarf":
return ["MAKE_DSYM=NO"]
if debug_info == "dwo":
return ["MAKE_DSYM=NO", "MAKE_DWO=YES"]
if debug_info == "gmodules":
return ["MAKE_DSYM=NO", "MAKE_GMODULES=YES"]
return None
def getBuildCommand(
self,
debug_info,
architecture=None,
compiler=None,
dictionary=None,
testdir=None,
testname=None,
make_targets=None,
):
debug_info_args = self._getDebugInfoArgs(debug_info)
if debug_info_args is None:
return None
if make_targets is None:
make_targets = ["all"]
command_parts = [
self.getMake(testdir, testname),
debug_info_args,
make_targets,
self.getArchCFlags(architecture),
self.getArchSpec(architecture),
self.getToolchainSpec(compiler),
self.getExtraMakeArgs(),
self.getSDKRootSpec(),
self.getModuleCacheSpec(),
self.getLibCxxArgs(),
self.getLLDBObjRoot(),
self.getCmdLine(dictionary),
]
command = list(itertools.chain(*command_parts))
return command
def cleanup(self, dictionary=None):
"""Perform a platform-specific cleanup after the test."""
return True
Codebase Browser
llvm