074c591a7e
Instead of a new method for each variable any subclass might want to set, have a method getExtraMakeArgs that each subclass can use to return whatever extra Make arguments it wants. As per Pavel's suggestion in D85539.
240 lines
8.3 KiB
Python
240 lines
8.3 KiB
Python
import os
|
|
import platform
|
|
import subprocess
|
|
import sys
|
|
|
|
import lldbsuite.test.lldbtest as lldbtest
|
|
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 getExtraMakeArgs(self):
|
|
"""
|
|
Helper function to return extra argumentsfor the make system. This
|
|
method is meant to be overridden by platform specific builders.
|
|
"""
|
|
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."""
|
|
if platform.system() == "FreeBSD" or platform.system() == "NetBSD":
|
|
make = "gmake"
|
|
else:
|
|
make = "make"
|
|
|
|
# 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 [
|
|
make, "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 properly formatted command line argument(s)
|
|
string used for the make system.
|
|
"""
|
|
|
|
# If d is None or an empty mapping, just return an empty string.
|
|
if not d:
|
|
return ""
|
|
pattern = '%s="%s"' if "win32" in sys.platform else "%s='%s'"
|
|
|
|
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 pattern % (k, v)
|
|
|
|
cmdline = " ".join(
|
|
[setOrAppendVariable(k, v) for k, v in list(d.items())])
|
|
|
|
return cmdline
|
|
|
|
def runBuildCommands(self, commands, sender):
|
|
try:
|
|
lldbtest.system(commands, sender=sender)
|
|
except subprocess.CalledProcessError as called_process_error:
|
|
# Convert to a build-specific error.
|
|
# We don't do that in lldbtest.system() since that
|
|
# is more general purpose.
|
|
raise build_exception.BuildError(called_process_error)
|
|
|
|
def getArchSpec(self, architecture):
|
|
"""
|
|
Helper function to return the key-value string to specify the architecture
|
|
used for the make system.
|
|
"""
|
|
arch = architecture if architecture else None
|
|
if not arch and configuration.arch:
|
|
arch = configuration.arch
|
|
|
|
return ("ARCH=" + arch) if arch else ""
|
|
|
|
def getCCSpec(self, compiler):
|
|
"""
|
|
Helper function to return the key-value string to specify the compiler
|
|
used for the make system.
|
|
"""
|
|
cc = compiler if compiler else None
|
|
if not cc and configuration.compiler:
|
|
cc = configuration.compiler
|
|
if cc:
|
|
return "CC=\"%s\"" % cc
|
|
else:
|
|
return ""
|
|
|
|
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 buildDefault(self,
|
|
sender=None,
|
|
architecture=None,
|
|
compiler=None,
|
|
dictionary=None,
|
|
testdir=None,
|
|
testname=None):
|
|
"""Build the binaries the default way."""
|
|
commands = []
|
|
commands.append(
|
|
self.getMake(testdir, testname) + [
|
|
"all",
|
|
self.getArchSpec(architecture),
|
|
self.getCCSpec(compiler),
|
|
self.getExtraMakeArgs(),
|
|
self.getSDKRootSpec(),
|
|
self.getModuleCacheSpec(),
|
|
self.getCmdLine(dictionary)
|
|
])
|
|
|
|
self.runBuildCommands(commands, sender=sender)
|
|
|
|
# True signifies that we can handle building default.
|
|
return True
|
|
|
|
def buildDwarf(self,
|
|
sender=None,
|
|
architecture=None,
|
|
compiler=None,
|
|
dictionary=None,
|
|
testdir=None,
|
|
testname=None):
|
|
"""Build the binaries with dwarf debug info."""
|
|
commands = []
|
|
commands.append(
|
|
self.getMake(testdir, testname) + [
|
|
"MAKE_DSYM=NO",
|
|
self.getArchSpec(architecture),
|
|
self.getCCSpec(compiler),
|
|
self.getExtraMakeArgs(),
|
|
self.getSDKRootSpec(),
|
|
self.getModuleCacheSpec(),
|
|
self.getCmdLine(dictionary)
|
|
])
|
|
|
|
self.runBuildCommands(commands, sender=sender)
|
|
# True signifies that we can handle building dwarf.
|
|
return True
|
|
|
|
def buildDwo(self,
|
|
sender=None,
|
|
architecture=None,
|
|
compiler=None,
|
|
dictionary=None,
|
|
testdir=None,
|
|
testname=None):
|
|
"""Build the binaries with dwarf debug info."""
|
|
commands = []
|
|
commands.append(
|
|
self.getMake(testdir, testname) + [
|
|
"MAKE_DSYM=NO", "MAKE_DWO=YES",
|
|
self.getArchSpec(architecture),
|
|
self.getCCSpec(compiler),
|
|
self.getExtraMakeArgs(),
|
|
self.getSDKRootSpec(),
|
|
self.getModuleCacheSpec(),
|
|
self.getCmdLine(dictionary)
|
|
])
|
|
|
|
self.runBuildCommands(commands, sender=sender)
|
|
# True signifies that we can handle building dwo.
|
|
return True
|
|
|
|
def buildGModules(self,
|
|
sender=None,
|
|
architecture=None,
|
|
compiler=None,
|
|
dictionary=None,
|
|
testdir=None,
|
|
testname=None):
|
|
"""Build the binaries with dwarf debug info."""
|
|
commands = []
|
|
commands.append(
|
|
self.getMake(testdir, testname) + [
|
|
"MAKE_DSYM=NO", "MAKE_GMODULES=YES",
|
|
self.getArchSpec(architecture),
|
|
self.getCCSpec(compiler),
|
|
self.getExtraMakeArgs(),
|
|
self.getSDKRootSpec(),
|
|
self.getModuleCacheSpec(),
|
|
self.getCmdLine(dictionary)
|
|
])
|
|
|
|
self.runBuildCommands(commands, sender=sender)
|
|
# True signifies that we can handle building with gmodules.
|
|
return True
|
|
|
|
def buildDsym(self,
|
|
sender=None,
|
|
architecture=None,
|
|
compiler=None,
|
|
dictionary=None,
|
|
testdir=None,
|
|
testname=None):
|
|
# False signifies that we cannot handle building with dSYM.
|
|
return False
|
|
|
|
def cleanup(self, sender=None, dictionary=None):
|
|
"""Perform a platform-specific cleanup after the test."""
|
|
return True
|