diff options
Diffstat (limited to 'gnu/llvm/lldb/packages/Python/lldbsuite/test/plugins/builder_base.py')
| -rw-r--r-- | gnu/llvm/lldb/packages/Python/lldbsuite/test/plugins/builder_base.py | 263 |
1 files changed, 263 insertions, 0 deletions
diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/plugins/builder_base.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/plugins/builder_base.py new file mode 100644 index 00000000000..aede03da14c --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/plugins/builder_base.py @@ -0,0 +1,263 @@ +""" +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, 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"] + lldb_build = os.environ["LLDB_BUILD"] + if not (lldb_test and lldb_build 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(lldb_build, test_subdir, test_name) + src_dir = os.path.join(lldb_test, 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 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 getDsymutilSpec(): + """ + Helper function to return the key-value string to specify the dsymutil + used for the make system. + """ + if "DSYMUTIL" in os.environ: + return "DSYMUTIL={}".format(os.environ["DSYMUTIL"]) + return ""; + +def getSDKRootSpec(): + """ + Helper function to return the key-value string to specify the SDK root + used for the make system. + """ + if "SDKROOT" in os.environ: + return "SDKROOT={}".format(os.environ["SDKROOT"]) + return ""; + +def getModuleCacheSpec(): + """ + Helper function to return the key-value string to specify the clang + module cache used for the make system. + """ + if "CLANG_MODULE_CACHE_DIR" in os.environ: + return "CLANG_MODULE_CACHE_DIR={}".format( + os.environ["CLANG_MODULE_CACHE_DIR"]) + 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", "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, + testdir=None, + testname=None): + """Build the binaries the default way.""" + commands = [] + commands.append(getMake(testdir, testname) + + ["all", + getArchSpec(architecture), + getCCSpec(compiler), + getDsymutilSpec(), + getSDKRootSpec(), + getModuleCacheSpec(), + 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, + testdir=None, + testname=None): + """Build the binaries with dwarf debug info.""" + commands = [] + commands.append(getMake(testdir, testname) + + ["MAKE_DSYM=NO", + getArchSpec(architecture), + getCCSpec(compiler), + getDsymutilSpec(), + getSDKRootSpec(), + getModuleCacheSpec(), + 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, + testdir=None, + testname=None): + """Build the binaries with dwarf debug info.""" + commands = [] + commands.append(getMake(testdir, testname) + + ["MAKE_DSYM=NO", + "MAKE_DWO=YES", + getArchSpec(architecture), + getCCSpec(compiler), + getDsymutilSpec(), + getSDKRootSpec(), + getModuleCacheSpec(), + 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, + testdir=None, + testname=None): + """Build the binaries with dwarf debug info.""" + commands = [] + commands.append(getMake(testdir, testname) + + ["MAKE_DSYM=NO", + "MAKE_GMODULES=YES", + getArchSpec(architecture), + getCCSpec(compiler), + getDsymutilSpec(), + getSDKRootSpec(), + getModuleCacheSpec(), + 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 |