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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
|
import os
import platform
import re
import subprocess
import sys
import lit.formats
import lit.util
from lit.llvm import llvm_config
from lit.llvm.subst import ToolSubst
# Configuration file for the 'lit' test runner.
# name: The name of this test suite.
config.name = "cross-project-tests"
# testFormat: The test format to use to interpret tests.
config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
# suffixes: A list of file extensions to treat as test files.
config.suffixes = [".c", ".cl", ".cpp", ".m"]
# excludes: A list of directories to exclude from the testsuite. The 'Inputs'
# subdirectories contain auxiliary inputs for various tests in their parent
# directories.
config.excludes = ["Inputs"]
# test_source_root: The root path where tests are located.
config.test_source_root = config.cross_project_tests_src_root
# test_exec_root: The root path where tests should be run.
config.test_exec_root = config.cross_project_tests_obj_root
llvm_config.use_default_substitutions()
tools = [
ToolSubst(
"%test_debuginfo",
command=os.path.join(
config.cross_project_tests_src_root,
"debuginfo-tests",
"llgdb-tests",
"test_debuginfo.pl",
),
),
ToolSubst("%llvm_src_root", config.llvm_src_root),
ToolSubst("%llvm_tools_dir", config.llvm_tools_dir),
]
def get_required_attr(config, attr_name):
attr_value = getattr(config, attr_name, None)
if attr_value == None:
lit_config.fatal(
"No attribute %r in test configuration! You may need to run "
"tests from your build directory or add this attribute "
"to lit.site.cfg " % attr_name
)
return attr_value
# If this is an MSVC environment, the tests at the root of the tree are
# unsupported. The local win_cdb test suite, however, is supported.
is_msvc = get_required_attr(config, "is_msvc")
if is_msvc:
config.available_features.add("msvc")
# FIXME: We should add some llvm lit utility code to find the Windows SDK
# and set up the environment appopriately.
win_sdk = "C:/Program Files (x86)/Windows Kits/10/"
arch = "x64"
llvm_config.with_system_environment(["LIB", "LIBPATH", "INCLUDE"])
# Clear _NT_SYMBOL_PATH to prevent cdb from attempting to load symbols from
# the network.
llvm_config.with_environment("_NT_SYMBOL_PATH", "")
tools.append(
ToolSubst("%cdb", '"%s"' % os.path.join(win_sdk, "Debuggers", arch, "cdb.exe"))
)
# clang_src_dir and lld_src_dir are not used by these tests, but are required by
# use_clang() and use_lld() respectively, so set them to "", if needed.
if not hasattr(config, "clang_src_dir"):
config.clang_src_dir = ""
llvm_config.use_clang(required=("clang" in config.llvm_enabled_projects))
if not hasattr(config, "lld_src_dir"):
config.lld_src_dir = ""
llvm_config.use_lld(required=("lld" in config.llvm_enabled_projects))
if "compiler-rt" in config.llvm_enabled_projects:
config.available_features.add("compiler-rt")
# Check which debuggers are available:
lldb_path = llvm_config.use_llvm_tool("lldb", search_env="LLDB")
if lldb_path is not None:
config.available_features.add("lldb")
def configure_dexter_substitutions():
"""Configure substitutions for host platform and return list of dependencies"""
# Produce dexter path, lldb path, and combine into the %dexter substitution
# for running a test.
dexter_path = os.path.join(
config.cross_project_tests_src_root, "debuginfo-tests", "dexter", "dexter.py"
)
dexter_test_cmd = '"{}" "{}" test'.format(sys.executable, dexter_path)
if lldb_path is not None:
dexter_test_cmd += ' --lldb-executable "{}"'.format(lldb_path)
tools.append(ToolSubst("%dexter", dexter_test_cmd))
# For testing other bits of dexter that aren't under the "test" subcommand,
# have a %dexter_base substitution.
dexter_base_cmd = '"{}" "{}"'.format(sys.executable, dexter_path)
tools.append(ToolSubst("%dexter_base", dexter_base_cmd))
# Set up commands for DexTer regression tests.
# Builder, debugger, optimisation level and several other flags differ
# depending on whether we're running a unix like or windows os.
if platform.system() == "Windows":
# The Windows builder script uses lld.
dependencies = ["clang", "lld-link"]
dexter_regression_test_builder = "clang-cl"
dexter_regression_test_debugger = "dbgeng"
dexter_regression_test_flags = "/Zi /Od"
else:
# Use lldb as the debugger on non-Windows platforms.
dependencies = ["clang", "lldb"]
dexter_regression_test_builder = "clang++"
dexter_regression_test_debugger = "lldb"
dexter_regression_test_flags = "-O0 -glldb -std=gnu++11"
tools.append(
ToolSubst("%dexter_regression_test_builder", dexter_regression_test_builder)
)
tools.append(
ToolSubst("%dexter_regression_test_debugger", dexter_regression_test_debugger)
)
# We don't need to distinguish cflags and ldflags because for Dexter
# regression tests we use clang to drive the linker, and so all flags will be
# passed in a single command.
tools.append(
ToolSubst("%dexter_regression_test_flags", dexter_regression_test_flags)
)
# Typical command would take the form:
# ./path_to_py/python.exe ./path_to_dex/dexter.py test --fail-lt 1.0 -w --binary %t --debugger lldb --cflags '-O0 -g'
dexter_regression_test_run = " ".join(
# "python", "dexter.py", test, fail_mode, builder, debugger, cflags, ldflags
[
'"{}"'.format(sys.executable),
'"{}"'.format(dexter_path),
"test",
"--fail-lt 1.0 -w",
"--debugger",
dexter_regression_test_debugger,
]
)
tools.append(ToolSubst("%dexter_regression_test_run", dexter_regression_test_run))
# Include build flags for %dexter_regression_test.
dexter_regression_test_build = " ".join(
[
dexter_regression_test_builder,
dexter_regression_test_flags,
]
)
tools.append(ToolSubst("%dexter_regression_test_build", dexter_regression_test_build))
return dependencies
def add_host_triple(clang):
return "{} --target={}".format(clang, config.host_triple)
# The set of arches we can build.
targets = set(config.targets_to_build)
# Add aliases to the target set.
if "AArch64" in targets:
targets.add("arm64")
if "ARM" in config.targets_to_build:
targets.add("thumbv7")
def can_target_host():
# Check if the targets set contains anything that looks like our host arch.
# The arch name in the triple and targets set may be spelled differently
# (e.g. x86 vs X86).
return any(config.host_triple.lower().startswith(x.lower()) for x in targets)
# Dexter tests run on the host machine. If the host arch is supported add
# 'dexter' as an available feature and force the dexter tests to use the host
# triple.
if can_target_host():
if config.host_triple != config.target_triple:
print("Forcing dexter tests to use host triple {}.".format(config.host_triple))
dependencies = configure_dexter_substitutions()
if all(d in config.available_features for d in dependencies):
config.available_features.add("dexter")
llvm_config.with_environment(
"PATHTOCLANG", add_host_triple(llvm_config.config.clang)
)
llvm_config.with_environment(
"PATHTOCLANGPP", add_host_triple(llvm_config.use_llvm_tool("clang++"))
)
llvm_config.with_environment(
"PATHTOCLANGCL", add_host_triple(llvm_config.use_llvm_tool("clang-cl"))
)
else:
print(
"Host triple {} not supported. Skipping dexter tests in the "
"debuginfo-tests project.".format(config.host_triple)
)
tool_dirs = [config.llvm_tools_dir]
llvm_config.add_tool_substitutions(tools, tool_dirs)
lit.util.usePlatformSdkOnDarwin(config, lit_config)
if platform.system() == "Darwin":
xcode_lldb_vers = subprocess.check_output(["xcrun", "lldb", "--version"]).decode(
"utf-8"
)
match = re.search("lldb-(\d+)", xcode_lldb_vers)
if match:
apple_lldb_vers = int(match.group(1))
if apple_lldb_vers < 1000:
config.available_features.add("apple-lldb-pre-1000")
def get_gdb_version_string():
"""Return gdb's version string, or None if gdb cannot be found or the
--version output is formatted unexpectedly.
"""
# See if we can get a gdb version, e.g.
# $ gdb --version
# GNU gdb (GDB) 10.2
# ...More stuff...
try:
gdb_vers_lines = (
subprocess.check_output(["gdb", "--version"]).decode().splitlines()
)
except:
return None # We coudln't find gdb or something went wrong running it.
if len(gdb_vers_lines) < 1:
print("Unkown GDB version format (too few lines)", file=sys.stderr)
return None
match = re.search("GNU gdb \(.*?\) ((\d|\.)+)", gdb_vers_lines[0].strip())
if match is None:
print(f"Unkown GDB version format: {gdb_vers_lines[0]}", file=sys.stderr)
return None
return match.group(1)
def get_clang_default_dwarf_version_string(triple):
"""Return the default dwarf version string for clang on this (host) platform
or None if we can't work it out.
"""
# Get the flags passed by the driver and look for -dwarf-version.
cmd = f'{llvm_config.use_llvm_tool("clang")} -g -xc -c - -v -### --target={triple}'
stderr = subprocess.run(cmd.split(), stderr=subprocess.PIPE).stderr.decode()
match = re.search("-dwarf-version=(\d+)", stderr)
if match is None:
print("Cannot determine default dwarf version", file=sys.stderr)
return None
return match.group(1)
# Some cross-project-tests use gdb, but not all versions of gdb are compatible
# with clang's dwarf. Add feature `gdb-clang-incompatibility` to signal that
# there's an incompatibility between clang's default dwarf version for this
# platform and the installed gdb version.
dwarf_version_string = get_clang_default_dwarf_version_string(config.host_triple)
gdb_version_string = get_gdb_version_string()
if dwarf_version_string and gdb_version_string:
if int(dwarf_version_string) >= 5:
try:
from packaging import version
except:
lit_config.fatal("Running gdb tests requires the packaging package")
if version.parse(gdb_version_string) < version.parse("10.1"):
# Example for llgdb-tests, which use lldb on darwin but gdb elsewhere:
# XFAIL: !system-darwin && gdb-clang-incompatibility
config.available_features.add("gdb-clang-incompatibility")
print(
"XFAIL some tests: use gdb version >= 10.1 to restore test coverage",
file=sys.stderr,
)
llvm_config.feature_config([("--build-mode", {"Debug|RelWithDebInfo": "debug-info"})])
# Allow 'REQUIRES: XXX-registered-target' in tests.
for arch in config.targets_to_build:
config.available_features.add(arch.lower() + "-registered-target")
|