Debian Codegraph @

lldb/packages/Python/lldbsuite/test/lldbplatformutil.py

raw
1 """ This module contains functions used by the test cases to hide the
2 architecture and/or the platform dependent nature of the tests. """
3
4 # System modules
5 import itertools
6 import json
7 import re
8 import subprocess
9 import sys
10 import os
11 from packaging import version
12
13 # LLDB modules
14 import lldb
15 from . import configuration
16 from . import lldbtest_config
17 import lldbsuite.test.lldbplatform as lldbplatform
18 from lldbsuite.test.builders import get_builder
19 from lldbsuite.test.lldbutil import is_exe
20
21
22 def check_first_register_readable(test_case):
23 arch = test_case.getArchitecture()
24
25 if arch in ["x86_64", "i386"]:
26 test_case.expect("register read eax", substrs=["eax = 0x"])
27 elif arch in ["arm", "armv7", "armv7k", "armv8l", "armv7l"]:
28 test_case.expect("register read r0", substrs=["r0 = 0x"])
29 elif arch in ["aarch64", "arm64", "arm64e", "arm64_32"]:
30 test_case.expect("register read x0", substrs=["x0 = 0x"])
31 elif re.match("mips", arch):
32 test_case.expect("register read zero", substrs=["zero = 0x"])
33 elif arch in ["s390x"]:
34 test_case.expect("register read r0", substrs=["r0 = 0x"])
35 elif arch in ["powerpc64le"]:
36 test_case.expect("register read r0", substrs=["r0 = 0x"])
37 elif re.match("^rv(32|64)", arch):
38 test_case.expect("register read zero", substrs=["zero = 0x"])
39 else:
40 # TODO: Add check for other architectures
41 test_case.fail(
42 "Unsupported architecture for test case (arch: %s)"
43 % test_case.getArchitecture()
44 )
45
46
47 def _run_adb_command(cmd, device_id):
48 device_id_args = []
49 if device_id:
50 device_id_args = ["-s", device_id]
51 full_cmd = ["adb"] + device_id_args + cmd
52 p = subprocess.Popen(full_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
53 stdout, stderr = p.communicate()
54 return p.returncode, stdout, stderr
55
56
57 def target_is_android():
58 return configuration.lldb_platform_name == "remote-android"
59
60
61 def android_device_api():
62 if not hasattr(android_device_api, "result"):
63 assert configuration.lldb_platform_url is not None
64 device_id = None
65 parsed_url = urlparse(configuration.lldb_platform_url)
66 host_name = parsed_url.netloc.split(":")[0]
67 if host_name != "localhost":
68 device_id = host_name
69 if device_id.startswith("[") and device_id.endswith("]"):
70 device_id = device_id[1:-1]
71 retcode, stdout, stderr = _run_adb_command(
72 ["shell", "getprop", "ro.build.version.sdk"], device_id
73 )
74 if retcode == 0:
75 android_device_api.result = int(stdout)
76 else:
77 raise LookupError(
78 ">>> Unable to determine the API level of the Android device.\n"
79 ">>> stdout:\n%s\n"
80 ">>> stderr:\n%s\n" % (stdout, stderr)
81 )
82 return android_device_api.result
83
84
85 def match_android_device(device_arch, valid_archs=None, valid_api_levels=None):
86 if not target_is_android():
87 return False
88 if valid_archs is not None and device_arch not in valid_archs:
89 return False
90 if valid_api_levels is not None and android_device_api() not in valid_api_levels:
91 return False
92
93 return True
94
95
96 def finalize_build_dictionary(dictionary):
97 # Provide uname-like platform name
98 platform_name_to_uname = {
99 "linux": "Linux",
100 "netbsd": "NetBSD",
101 "freebsd": "FreeBSD",
102 "windows": "Windows_NT",
103 "macosx": "Darwin",
104 "darwin": "Darwin",
105 }
106
107 if dictionary is None:
108 dictionary = {}
109 if target_is_android():
110 dictionary["OS"] = "Android"
111 dictionary["PIE"] = 1
112 elif platformIsDarwin():
113 dictionary["OS"] = "Darwin"
114 else:
115 dictionary["OS"] = platform_name_to_uname[getPlatform()]
116
117 dictionary["HOST_OS"] = platform_name_to_uname[getHostPlatform()]
118
119 return dictionary
120
121
122 def _get_platform_os(p):
123 # Use the triple to determine the platform if set.
124 triple = p.GetTriple()
125 if triple:
126 platform = triple.split("-")[2]
127 if platform.startswith("freebsd"):
128 platform = "freebsd"
129 elif platform.startswith("netbsd"):
130 platform = "netbsd"
131 elif platform.startswith("openbsd"):
132 platform = "openbsd"
133 return platform
134
135 return ""
136
137
138 def getHostPlatform():
139 """Returns the host platform running the test suite."""
140 return _get_platform_os(lldb.SBPlatform("host"))
141
142
143 def getDarwinOSTriples():
144 return lldbplatform.translate(lldbplatform.darwin_all)
145
146
147 def getPlatform():
148 """Returns the target platform which the tests are running on."""
149 # Use the Apple SDK to determine the platform if set.
150 if configuration.apple_sdk:
151 platform = configuration.apple_sdk
152 dot = platform.find(".")
153 if dot != -1:
154 platform = platform[:dot]
155 if platform == "iphoneos":
156 platform = "ios"
157 return platform
158
159 return _get_platform_os(lldb.selected_platform)
160
161
162 def platformIsDarwin():
163 """Returns true if the OS triple for the selected platform is any valid apple OS"""
164 return getPlatform() in getDarwinOSTriples()
165
166
167 def findMainThreadCheckerDylib():
168 if not platformIsDarwin():
169 return ""
170
171 if getPlatform() in lldbplatform.translate(lldbplatform.darwin_embedded):
172 return "/Developer/usr/lib/libMainThreadChecker.dylib"
173
174 with os.popen("xcode-select -p") as output:
175 xcode_developer_path = output.read().strip()
176 mtc_dylib_path = "%s/usr/lib/libMainThreadChecker.dylib" % xcode_developer_path
177 if os.path.isfile(mtc_dylib_path):
178 return mtc_dylib_path
179
180 return ""
181
182
183 class _PlatformContext(object):
184 """Value object class which contains platform-specific options."""
185
186 def __init__(
187 self, shlib_environment_var, shlib_path_separator, shlib_prefix, shlib_extension
188 ):
189 self.shlib_environment_var = shlib_environment_var
190 self.shlib_path_separator = shlib_path_separator
191 self.shlib_prefix = shlib_prefix
192 self.shlib_extension = shlib_extension
193
194
195 def createPlatformContext():
196 if platformIsDarwin():
197 return _PlatformContext("DYLD_LIBRARY_PATH", ":", "lib", "dylib")
198 elif getPlatform() in ("linux", "freebsd", "netbsd", "openbsd"):
199 return _PlatformContext("LD_LIBRARY_PATH", ":", "lib", "so")
200 else:
201 return _PlatformContext("PATH", ";", "", "dll")
202
203
204 def hasChattyStderr(test_case):
205 """Some targets produce garbage on the standard error output. This utility function
206 determines whether the tests can be strict about the expected stderr contents."""
207 if match_android_device(
208 test_case.getArchitecture(), ["aarch64"], range(22, 25 + 1)
209 ):
210 return True # The dynamic linker on the device will complain about unknown DT entries
211 return False
212
213
214 def builder_module():
215 return get_builder(sys.platform)
216
217
218 def getArchitecture():
219 """Returns the architecture in effect the test suite is running with."""
220 module = builder_module()
221 arch = module.getArchitecture()
222 if arch == "amd64":
223 arch = "x86_64"
224 if arch in ["armv7l", "armv8l"]:
225 arch = "arm"
226 return arch
227
228
229 lldbArchitecture = None
230
231
232 def getLLDBArchitecture():
233 """Returns the architecture of the lldb binary."""
234 global lldbArchitecture
235 if not lldbArchitecture:
236 # These two target settings prevent lldb from doing setup that does
237 # nothing but slow down the end goal of printing the architecture.
238 command = [
239 lldbtest_config.lldbExec,
240 "-x",
241 "-b",
242 "-o",
243 "settings set target.preload-symbols false",
244 "-o",
245 "settings set target.load-script-from-symbol-file false",
246 "-o",
247 "file " + lldbtest_config.lldbExec,
248 ]
249
250 output = subprocess.check_output(command)
251 str = output.decode()
252
253 for line in str.splitlines():
254 m = re.search(r"Current executable set to '.*' \((.*)\)\.", line)
255 if m:
256 lldbArchitecture = m.group(1)
257 break
258
259 return lldbArchitecture
260
261
262 def getCompiler():
263 """Returns the compiler in effect the test suite is running with."""
264 module = builder_module()
265 return module.getCompiler()
266
267
268 def getCompilerBinary():
269 """Returns the compiler binary the test suite is running with."""
270 return getCompiler().split()[0]
271
272
273 def getCompilerVersion():
274 """Returns a string that represents the compiler version.
275 Supports: llvm, clang.
276 """
277 compiler = getCompilerBinary()
278 version_output = subprocess.check_output([compiler, "--version"], errors="replace")
279 m = re.search("version ([0-9.]+)", version_output)
280 if m:
281 return m.group(1)
282 return "unknown"
283
284
285 def getDwarfVersion():
286 """Returns the dwarf version generated by clang or '0'."""
287 if configuration.dwarf_version:
288 return str(configuration.dwarf_version)
289 if "clang" in getCompiler():
290 try:
291 triple = builder_module().getTriple(getArchitecture())
292 target = ["-target", triple] if triple else []
293 driver_output = subprocess.check_output(
294 [getCompiler()] + target + "-g -c -x c - -o - -###".split(),
295 stderr=subprocess.STDOUT,
296 )
297 driver_output = driver_output.decode("utf-8")
298 for line in driver_output.split(os.linesep):
299 m = re.search("dwarf-version=([0-9])", line)
300 if m:
301 return m.group(1)
302 except subprocess.CalledProcessError:
303 pass
304 return "0"
305
306
307 def expectedCompilerVersion(compiler_version):
308 """Returns True iff compiler_version[1] matches the current compiler version.
309 Use compiler_version[0] to specify the operator used to determine if a match has occurred.
310 Any operator other than the following defaults to an equality test:
311 '>', '>=', "=>", '<', '<=', '=<', '!=', "!" or 'not'
312
313 If the current compiler version cannot be determined, we assume it is close to the top
314 of trunk, so any less-than or equal-to comparisons will return False, and any
315 greater-than or not-equal-to comparisons will return True.
316 """
317 if compiler_version is None:
318 return True
319 operator = str(compiler_version[0])
320 version_str = str(compiler_version[1])
321
322 if not version_str:
323 return True
324
325 test_compiler_version_str = getCompilerVersion()
326 if test_compiler_version_str == "unknown":
327 # Assume the compiler version is at or near the top of trunk.
328 return operator in [">", ">=", "!", "!=", "not"]
329
330 actual_version = version.parse(version_str)
331 test_compiler_version = version.parse(test_compiler_version_str)
332
333 if operator == ">":
334 return test_compiler_version > actual_version
335 if operator == ">=" or operator == "=>":
336 return test_compiler_version >= actual_version
337 if operator == "<":
338 return test_compiler_version < actual_version
339 if operator == "<=" or operator == "=<":
340 return test_compiler_version <= actual_version
341 if operator == "!=" or operator == "!" or operator == "not":
342 return version_str not in test_compiler_version_str
343 return version_str in test_compiler_version_str
344
345
346 def expectedCompiler(compilers):
347 """Returns True iff any element of compilers is a sub-string of the current compiler."""
348 if compilers is None:
349 return True
350
351 for compiler in compilers:
352 if compiler in getCompiler():
353 return True
354
355 return False
356
357
358 # This is a helper function to determine if a specific version of Xcode's linker
359 # contains a TLS bug. We want to skip TLS tests if they contain this bug, but
360 # adding a linker/linker_version conditions to a decorator is challenging due to
361 # the number of ways linkers can enter the build process.
362 def xcode15LinkerBug():
363 """Returns true iff a test is running on a darwin platform and the host linker is between versions 1000 and 1109."""
364 darwin_platforms = lldbplatform.translate(lldbplatform.darwin_all)
365 if getPlatform() not in darwin_platforms:
366 return False
367
368 try:
369 raw_version_details = subprocess.check_output(
370 ("xcrun", "ld", "-version_details")
371 )
372 version_details = json.loads(raw_version_details)
373 version = version_details.get("version", "0")
374 version_tuple = tuple(int(x) for x in version.split("."))
375 if (1000,) <= version_tuple <= (1109,):
376 return True
377 except:
378 pass
379
380 return False