1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
import os
import platform
import subprocess
import sys
import itertools
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 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."""
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 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 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]
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 getLibCxxArgs(self):
if configuration.libcxx_include_dir and configuration.libcxx_library_dir:
return ["LIBCPP_INCLUDE_DIR={}".format(configuration.libcxx_include_dir),
"LIBCPP_LIBRARY_DIR={}".format(configuration.libcxx_library_dir)]
return []
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.getCCSpec(compiler), self.getExtraMakeArgs(),
self.getSDKRootSpec(), self.getModuleCacheSpec(),
self.getLibCxxArgs(), 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
|
