5ec76fe720
This patch is the result of a discussion on lldb-dev, see http://lists.llvm.org/pipermail/lldb-dev/2018-January/013111.html for background. For each test (should be eventually: each test configuration) a separate build directory is created and we execute make VPATH=$srcdir/path/to/test -C $builddir/path/to/test -f $srcdir/path/to/test/Makefile -I $srcdir/path/to/test In order to make this work all LLDB tests need to be updated to find the executable in the test build directory, since CWD still points at the test's source directory, which is a requirement for unittest2. Although we have done extensive testing, I'm expecting that this first attempt will break a few bots. Please DO NOT HESITATE TO REVERT this patch in order to get the bots green again. We will likely have to iterate on this some more. Differential Revision: https://reviews.llvm.org/D42281 llvm-svn: 323803
224 lines
6.6 KiB
Python
224 lines
6.6 KiB
Python
"""
|
|
If the build* function is passed the compiler argument, for example, 'llvm-gcc',
|
|
it is passed as a make variable to the make command. Otherwise, we check the
|
|
LLDB_CC environment variable; if it is defined, it is passed as a make variable
|
|
to the make command.
|
|
|
|
If neither the compiler keyword argument nor the LLDB_CC environment variable is
|
|
specified, no CC make variable is passed to the make command. The Makefile gets
|
|
to define the default CC being used.
|
|
|
|
Same idea holds for LLDB_ARCH environment variable, which maps to the ARCH make
|
|
variable.
|
|
"""
|
|
|
|
# System imports
|
|
import os
|
|
import platform
|
|
import subprocess
|
|
import sys
|
|
|
|
# Our imports
|
|
import lldbsuite.test.lldbtest as lldbtest
|
|
import lldbsuite.test.lldbutil as lldbutil
|
|
from lldbsuite.test_event import build_exception
|
|
|
|
|
|
def getArchitecture():
|
|
"""Returns the architecture in effect the test suite is running with."""
|
|
return os.environ["ARCH"] if "ARCH" in os.environ else ""
|
|
|
|
|
|
def getCompiler():
|
|
"""Returns the compiler in effect the test suite is running with."""
|
|
compiler = os.environ.get("CC", "clang")
|
|
compiler = lldbutil.which(compiler)
|
|
return os.path.realpath(compiler)
|
|
|
|
|
|
def getArchFlag():
|
|
"""Returns the flag required to specify the arch"""
|
|
compiler = getCompiler()
|
|
if compiler is None:
|
|
return ""
|
|
elif "gcc" in compiler:
|
|
archflag = "-m"
|
|
elif "clang" in compiler:
|
|
archflag = "-arch"
|
|
else:
|
|
archflag = None
|
|
|
|
return ("ARCHFLAG=" + archflag) if archflag else ""
|
|
|
|
def getMake(test_subdir):
|
|
"""Returns the invocation for GNU make.
|
|
The argument test_subdir is the relative path to the testcase."""
|
|
if platform.system() == "FreeBSD" or platform.system() == "NetBSD":
|
|
make = "gmake"
|
|
else:
|
|
make = "make"
|
|
|
|
# Construct the base make invocation.
|
|
lldb_test = os.environ["LLDB_TEST"]
|
|
lldb_build = os.environ["LLDB_BUILD"]
|
|
if not (lldb_test and lldb_build and test_subdir and
|
|
(not os.path.isabs(test_subdir))):
|
|
raise Exception("Could not derive test directories")
|
|
build_dir = os.path.join(lldb_build, test_subdir)
|
|
test_dir = os.path.join(lldb_test, test_subdir)
|
|
# This is a bit of a hack to make inline testcases work.
|
|
makefile = os.path.join(test_dir, "Makefile")
|
|
if not os.path.isfile(makefile):
|
|
makefile = os.path.join(build_dir, "Makefile")
|
|
return [make,
|
|
"VPATH="+test_dir,
|
|
"-C", build_dir,
|
|
"-I", test_dir,
|
|
"-f", makefile]
|
|
|
|
|
|
def getArchSpec(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 "ARCH" in os.environ:
|
|
arch = os.environ["ARCH"]
|
|
|
|
return ("ARCH=" + arch) if arch else ""
|
|
|
|
|
|
def getCCSpec(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 "CC" in os.environ:
|
|
cc = os.environ["CC"]
|
|
if cc:
|
|
return "CC=\"%s\"" % cc
|
|
else:
|
|
return ""
|
|
|
|
|
|
def getCmdLine(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_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(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 buildDefault(
|
|
sender=None,
|
|
architecture=None,
|
|
compiler=None,
|
|
dictionary=None,
|
|
clean=True,
|
|
testdir=None):
|
|
"""Build the binaries the default way."""
|
|
commands = []
|
|
if clean:
|
|
commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
|
|
commands.append(getMake(testdir) + [getArchSpec(architecture),
|
|
getCCSpec(compiler), getCmdLine(dictionary)])
|
|
|
|
runBuildCommands(commands, sender=sender)
|
|
|
|
# True signifies that we can handle building default.
|
|
return True
|
|
|
|
|
|
def buildDwarf(
|
|
sender=None,
|
|
architecture=None,
|
|
compiler=None,
|
|
dictionary=None,
|
|
clean=True,
|
|
testdir=None):
|
|
"""Build the binaries with dwarf debug info."""
|
|
commands = []
|
|
if clean:
|
|
commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
|
|
commands.append(getMake(testdir) + ["MAKE_DSYM=NO", getArchSpec(
|
|
architecture), getCCSpec(compiler), getCmdLine(dictionary)])
|
|
|
|
runBuildCommands(commands, sender=sender)
|
|
# True signifies that we can handle building dwarf.
|
|
return True
|
|
|
|
|
|
def buildDwo(
|
|
sender=None,
|
|
architecture=None,
|
|
compiler=None,
|
|
dictionary=None,
|
|
clean=True,
|
|
testdir=None):
|
|
"""Build the binaries with dwarf debug info."""
|
|
commands = []
|
|
if clean:
|
|
commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
|
|
commands.append(getMake(testdir) +
|
|
["MAKE_DSYM=NO", "MAKE_DWO=YES",
|
|
getArchSpec(architecture),
|
|
getCCSpec(compiler),
|
|
getCmdLine(dictionary)])
|
|
|
|
runBuildCommands(commands, sender=sender)
|
|
# True signifies that we can handle building dwo.
|
|
return True
|
|
|
|
|
|
def buildGModules(
|
|
sender=None,
|
|
architecture=None,
|
|
compiler=None,
|
|
dictionary=None,
|
|
clean=True,
|
|
testdir=None):
|
|
"""Build the binaries with dwarf debug info."""
|
|
commands = []
|
|
if clean:
|
|
commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
|
|
commands.append(getMake(testdir) +
|
|
["MAKE_DSYM=NO",
|
|
"MAKE_GMODULES=YES",
|
|
getArchSpec(architecture),
|
|
getCCSpec(compiler),
|
|
getCmdLine(dictionary)])
|
|
|
|
lldbtest.system(commands, sender=sender)
|
|
# True signifies that we can handle building with gmodules.
|
|
return True
|
|
|
|
|
|
def cleanup(sender=None, dictionary=None):
|
|
"""Perform a platform-specific cleanup after the test."""
|
|
return True
|