Revert ""
[lldb.git] / lldb / packages / Python / lldbsuite / test / lldbtest.py
1 """
2 LLDB module which provides the abstract base class of lldb test case.
3
4 The concrete subclass can override lldbtest.TestBase in order to inherit the
5 common behavior for unitest.TestCase.setUp/tearDown implemented in this file.
6
7 The subclass should override the attribute mydir in order for the python runtime
8 to locate the individual test cases when running as part of a large test suite
9 or when running each test case as a separate python invocation.
10
11 ./dotest.py provides a test driver which sets up the environment to run the
12 entire of part of the test suite .  Example:
13
14 # Exercises the test suite in the types directory....
15 /Volumes/data/lldb/svn/ToT/test $ ./dotest.py -A x86_64 types
16 ...
17
18 Session logs for test failures/errors/unexpected successes will go into directory '2012-05-16-13_35_42'
19 Command invoked: python ./dotest.py -A x86_64 types
20 compilers=['clang']
21
22 Configuration: arch=x86_64 compiler=clang
23 ----------------------------------------------------------------------
24 Collected 72 tests
25
26 ........................................................................
27 ----------------------------------------------------------------------
28 Ran 72 tests in 135.468s
29
30 OK
31 $
32 """
33
34 from __future__ import absolute_import
35 from __future__ import print_function
36
37 # System modules
38 import abc
39 from distutils.version import LooseVersion
40 from functools import wraps
41 import gc
42 import glob
43 import io
44 import os.path
45 import re
46 import shutil
47 import signal
48 from subprocess import *
49 import sys
50 import time
51 import traceback
52 import distutils.spawn
53
54 # Third-party modules
55 import unittest2
56 from six import add_metaclass
57 from six import StringIO as SixStringIO
58 import six
59
60 # LLDB modules
61 import lldb
62 from . import configuration
63 from . import decorators
64 from . import lldbplatformutil
65 from . import lldbtest_config
66 from . import lldbutil
67 from . import test_categories
68 from lldbsuite.support import encoded_file
69 from lldbsuite.support import funcutils
70 from lldbsuite.test.builders import get_builder
71
72 # See also dotest.parseOptionsAndInitTestdirs(), where the environment variables
73 # LLDB_COMMAND_TRACE is set from '-t' option.
74
75 # By default, traceAlways is False.
76 if "LLDB_COMMAND_TRACE" in os.environ and os.environ[
77         "LLDB_COMMAND_TRACE"] == "YES":
78     traceAlways = True
79 else:
80     traceAlways = False
81
82 # By default, doCleanup is True.
83 if "LLDB_DO_CLEANUP" in os.environ and os.environ["LLDB_DO_CLEANUP"] == "NO":
84     doCleanup = False
85 else:
86     doCleanup = True
87
88
89 #
90 # Some commonly used assert messages.
91 #
92
93 COMMAND_FAILED_AS_EXPECTED = "Command has failed as expected"
94
95 CURRENT_EXECUTABLE_SET = "Current executable set successfully"
96
97 PROCESS_IS_VALID = "Process is valid"
98
99 PROCESS_KILLED = "Process is killed successfully"
100
101 PROCESS_EXITED = "Process exited successfully"
102
103 PROCESS_STOPPED = "Process status should be stopped"
104
105 RUN_SUCCEEDED = "Process is launched successfully"
106
107 RUN_COMPLETED = "Process exited successfully"
108
109 BACKTRACE_DISPLAYED_CORRECTLY = "Backtrace displayed correctly"
110
111 BREAKPOINT_CREATED = "Breakpoint created successfully"
112
113 BREAKPOINT_STATE_CORRECT = "Breakpoint state is correct"
114
115 BREAKPOINT_PENDING_CREATED = "Pending breakpoint created successfully"
116
117 BREAKPOINT_HIT_ONCE = "Breakpoint resolved with hit count = 1"
118
119 BREAKPOINT_HIT_TWICE = "Breakpoint resolved with hit count = 2"
120
121 BREAKPOINT_HIT_THRICE = "Breakpoint resolved with hit count = 3"
122
123 MISSING_EXPECTED_REGISTERS = "At least one expected register is unavailable."
124
125 OBJECT_PRINTED_CORRECTLY = "Object printed correctly"
126
127 SOURCE_DISPLAYED_CORRECTLY = "Source code displayed correctly"
128
129 STEP_OUT_SUCCEEDED = "Thread step-out succeeded"
130
131 STOPPED_DUE_TO_EXC_BAD_ACCESS = "Process should be stopped due to bad access exception"
132
133 STOPPED_DUE_TO_ASSERT = "Process should be stopped due to an assertion"
134
135 STOPPED_DUE_TO_BREAKPOINT = "Process should be stopped due to breakpoint"
136
137 STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS = "%s, %s" % (
138     STOPPED_DUE_TO_BREAKPOINT, "instead, the actual stop reason is: '%s'")
139
140 STOPPED_DUE_TO_BREAKPOINT_CONDITION = "Stopped due to breakpoint condition"
141
142 STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT = "Stopped due to breakpoint and ignore count"
143
144 STOPPED_DUE_TO_BREAKPOINT_JITTED_CONDITION = "Stopped due to breakpoint jitted condition"
145
146 STOPPED_DUE_TO_SIGNAL = "Process state is stopped due to signal"
147
148 STOPPED_DUE_TO_STEP_IN = "Process state is stopped due to step in"
149
150 STOPPED_DUE_TO_WATCHPOINT = "Process should be stopped due to watchpoint"
151
152 DATA_TYPES_DISPLAYED_CORRECTLY = "Data type(s) displayed correctly"
153
154 VALID_BREAKPOINT = "Got a valid breakpoint"
155
156 VALID_BREAKPOINT_LOCATION = "Got a valid breakpoint location"
157
158 VALID_COMMAND_INTERPRETER = "Got a valid command interpreter"
159
160 VALID_FILESPEC = "Got a valid filespec"
161
162 VALID_MODULE = "Got a valid module"
163
164 VALID_PROCESS = "Got a valid process"
165
166 VALID_SYMBOL = "Got a valid symbol"
167
168 VALID_TARGET = "Got a valid target"
169
170 VALID_PLATFORM = "Got a valid platform"
171
172 VALID_TYPE = "Got a valid type"
173
174 VALID_VARIABLE = "Got a valid variable"
175
176 VARIABLES_DISPLAYED_CORRECTLY = "Variable(s) displayed correctly"
177
178 WATCHPOINT_CREATED = "Watchpoint created successfully"
179
180
181 def CMD_MSG(str):
182     '''A generic "Command '%s' did not return successfully" message generator.'''
183     return "Command '%s' did not return successfully" % str
184
185
186 def COMPLETION_MSG(str_before, str_after, completions):
187     '''A generic assertion failed message generator for the completion mechanism.'''
188     return ("'%s' successfully completes to '%s', but completions were:\n%s"
189            % (str_before, str_after, "\n".join(completions)))
190
191
192 def EXP_MSG(str, actual, exe):
193     '''A generic "'%s' returned unexpected result" message generator if exe.
194     Otherwise, it generates "'%s' does not match expected result" message.'''
195
196     return "'%s' %s result, got '%s'" % (
197         str, 'returned unexpected' if exe else 'does not match expected', actual.strip())
198
199
200 def SETTING_MSG(setting):
201     '''A generic "Value of setting '%s' is not correct" message generator.'''
202     return "Value of setting '%s' is not correct" % setting
203
204
205 def line_number(filename, string_to_match):
206     """Helper function to return the line number of the first matched string."""
207     with io.open(filename, mode='r', encoding="utf-8") as f:
208         for i, line in enumerate(f):
209             if line.find(string_to_match) != -1:
210                 # Found our match.
211                 return i + 1
212     raise Exception(
213         "Unable to find '%s' within file %s" %
214         (string_to_match, filename))
215
216 def get_line(filename, line_number):
217     """Return the text of the line at the 1-based line number."""
218     with io.open(filename, mode='r', encoding="utf-8") as f:
219         return f.readlines()[line_number - 1]
220
221 def pointer_size():
222     """Return the pointer size of the host system."""
223     import ctypes
224     a_pointer = ctypes.c_void_p(0xffff)
225     return 8 * ctypes.sizeof(a_pointer)
226
227
228 def is_exe(fpath):
229     """Returns true if fpath is an executable."""
230     return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
231
232
233 def which(program):
234     """Returns the full path to a program; None otherwise."""
235     fpath, fname = os.path.split(program)
236     if fpath:
237         if is_exe(program):
238             return program
239     else:
240         for path in os.environ["PATH"].split(os.pathsep):
241             exe_file = os.path.join(path, program)
242             if is_exe(exe_file):
243                 return exe_file
244     return None
245
246 class ValueCheck:
247     def __init__(self, name=None, value=None, type=None, summary=None,
248                  children=None):
249         """
250         :param name: The name that the SBValue should have. None if the summary
251                      should not be checked.
252         :param summary: The summary that the SBValue should have. None if the
253                         summary should not be checked.
254         :param value: The value that the SBValue should have. None if the value
255                       should not be checked.
256         :param type: The type that the SBValue result should have. None if the
257                      type should not be checked.
258         :param children: A list of ValueChecks that need to match the children
259                          of this SBValue. None if children shouldn't be checked.
260                          The order of checks is the order of the checks in the
261                          list. The number of checks has to match the number of
262                          children.
263         """
264         self.expect_name = name
265         self.expect_value = value
266         self.expect_type = type
267         self.expect_summary = summary
268         self.children = children
269
270     def check_value(self, test_base, val, error_msg=None):
271         """
272         Checks that the given value matches the currently set properties
273         of this ValueCheck. If a match failed, the given TestBase will
274         be used to emit an error. A custom error message can be specified
275         that will be used to describe failed check for this SBValue (but
276         not errors in the child values).
277         """
278
279         this_error_msg = error_msg if error_msg else ""
280         this_error_msg += "\nChecking SBValue: " + str(val)
281
282         test_base.assertSuccess(val.GetError())
283
284         if self.expect_name:
285             test_base.assertEqual(self.expect_name, val.GetName(),
286                                   this_error_msg)
287         if self.expect_value:
288             test_base.assertEqual(self.expect_value, val.GetValue(),
289                                   this_error_msg)
290         if self.expect_type:
291             test_base.assertEqual(self.expect_type, val.GetDisplayTypeName(),
292                                   this_error_msg)
293         if self.expect_summary:
294             test_base.assertEqual(self.expect_summary, val.GetSummary(),
295                                   this_error_msg)
296         if self.children is not None:
297             self.check_value_children(test_base, val, error_msg)
298
299     def check_value_children(self, test_base, val, error_msg=None):
300         """
301         Checks that the children of a SBValue match a certain structure and
302         have certain properties.
303
304         :param test_base: The current test's TestBase object.
305         :param val: The SBValue to check.
306         """
307
308         this_error_msg = error_msg if error_msg else ""
309         this_error_msg += "\nChecking SBValue: " + str(val)
310
311         test_base.assertEqual(len(self.children), val.GetNumChildren(), this_error_msg)
312
313         for i in range(0, val.GetNumChildren()):
314             expected_child = self.children[i]
315             actual_child = val.GetChildAtIndex(i)
316             expected_child.check_value(test_base, actual_child, error_msg)
317
318 class recording(SixStringIO):
319     """
320     A nice little context manager for recording the debugger interactions into
321     our session object.  If trace flag is ON, it also emits the interactions
322     into the stderr.
323     """
324
325     def __init__(self, test, trace):
326         """Create a SixStringIO instance; record the session obj and trace flag."""
327         SixStringIO.__init__(self)
328         # The test might not have undergone the 'setUp(self)' phase yet, so that
329         # the attribute 'session' might not even exist yet.
330         self.session = getattr(test, "session", None) if test else None
331         self.trace = trace
332
333     def __enter__(self):
334         """
335         Context management protocol on entry to the body of the with statement.
336         Just return the SixStringIO object.
337         """
338         return self
339
340     def __exit__(self, type, value, tb):
341         """
342         Context management protocol on exit from the body of the with statement.
343         If trace is ON, it emits the recordings into stderr.  Always add the
344         recordings to our session object.  And close the SixStringIO object, too.
345         """
346         if self.trace:
347             print(self.getvalue(), file=sys.stderr)
348         if self.session:
349             print(self.getvalue(), file=self.session)
350         self.close()
351
352
353 @add_metaclass(abc.ABCMeta)
354 class _BaseProcess(object):
355
356     @abc.abstractproperty
357     def pid(self):
358         """Returns process PID if has been launched already."""
359
360     @abc.abstractmethod
361     def launch(self, executable, args):
362         """Launches new process with given executable and args."""
363
364     @abc.abstractmethod
365     def terminate(self):
366         """Terminates previously launched process.."""
367
368
369 class _LocalProcess(_BaseProcess):
370
371     def __init__(self, trace_on):
372         self._proc = None
373         self._trace_on = trace_on
374         self._delayafterterminate = 0.1
375
376     @property
377     def pid(self):
378         return self._proc.pid
379
380     def launch(self, executable, args):
381         self._proc = Popen(
382             [executable] + args,
383             stdout=open(
384                 os.devnull) if not self._trace_on else None,
385             stdin=PIPE)
386
387     def terminate(self):
388         if self._proc.poll() is None:
389             # Terminate _proc like it does the pexpect
390             signals_to_try = [
391                 sig for sig in [
392                     'SIGHUP',
393                     'SIGCONT',
394                     'SIGINT'] if sig in dir(signal)]
395             for sig in signals_to_try:
396                 try:
397                     self._proc.send_signal(getattr(signal, sig))
398                     time.sleep(self._delayafterterminate)
399                     if self._proc.poll() is not None:
400                         return
401                 except ValueError:
402                     pass  # Windows says SIGINT is not a valid signal to send
403             self._proc.terminate()
404             time.sleep(self._delayafterterminate)
405             if self._proc.poll() is not None:
406                 return
407             self._proc.kill()
408             time.sleep(self._delayafterterminate)
409
410     def poll(self):
411         return self._proc.poll()
412
413
414 class _RemoteProcess(_BaseProcess):
415
416     def __init__(self, install_remote):
417         self._pid = None
418         self._install_remote = install_remote
419
420     @property
421     def pid(self):
422         return self._pid
423
424     def launch(self, executable, args):
425         if self._install_remote:
426             src_path = executable
427             dst_path = lldbutil.join_remote_paths(
428                     lldb.remote_platform.GetWorkingDirectory(), os.path.basename(executable))
429
430             dst_file_spec = lldb.SBFileSpec(dst_path, False)
431             err = lldb.remote_platform.Install(
432                 lldb.SBFileSpec(src_path, True), dst_file_spec)
433             if err.Fail():
434                 raise Exception(
435                     "remote_platform.Install('%s', '%s') failed: %s" %
436                     (src_path, dst_path, err))
437         else:
438             dst_path = executable
439             dst_file_spec = lldb.SBFileSpec(executable, False)
440
441         launch_info = lldb.SBLaunchInfo(args)
442         launch_info.SetExecutableFile(dst_file_spec, True)
443         launch_info.SetWorkingDirectory(
444             lldb.remote_platform.GetWorkingDirectory())
445
446         # Redirect stdout and stderr to /dev/null
447         launch_info.AddSuppressFileAction(1, False, True)
448         launch_info.AddSuppressFileAction(2, False, True)
449
450         err = lldb.remote_platform.Launch(launch_info)
451         if err.Fail():
452             raise Exception(
453                 "remote_platform.Launch('%s', '%s') failed: %s" %
454                 (dst_path, args, err))
455         self._pid = launch_info.GetProcessID()
456
457     def terminate(self):
458         lldb.remote_platform.Kill(self._pid)
459
460 # From 2.7's subprocess.check_output() convenience function.
461 # Return a tuple (stdoutdata, stderrdata).
462
463
464 def system(commands, **kwargs):
465     r"""Run an os command with arguments and return its output as a byte string.
466
467     If the exit code was non-zero it raises a CalledProcessError.  The
468     CalledProcessError object will have the return code in the returncode
469     attribute and output in the output attribute.
470
471     The arguments are the same as for the Popen constructor.  Example:
472
473     >>> check_output(["ls", "-l", "/dev/null"])
474     'crw-rw-rw- 1 root root 1, 3 Oct 18  2007 /dev/null\n'
475
476     The stdout argument is not allowed as it is used internally.
477     To capture standard error in the result, use stderr=STDOUT.
478
479     >>> check_output(["/bin/sh", "-c",
480     ...               "ls -l non_existent_file ; exit 0"],
481     ...              stderr=STDOUT)
482     'ls: non_existent_file: No such file or directory\n'
483     """
484
485     # Assign the sender object to variable 'test' and remove it from kwargs.
486     test = kwargs.pop('sender', None)
487
488     # [['make', 'clean', 'foo'], ['make', 'foo']] -> ['make clean foo', 'make foo']
489     commandList = [' '.join(x) for x in commands]
490     output = ""
491     error = ""
492     for shellCommand in commandList:
493         if 'stdout' in kwargs:
494             raise ValueError(
495                 'stdout argument not allowed, it will be overridden.')
496         if 'shell' in kwargs and kwargs['shell'] == False:
497             raise ValueError('shell=False not allowed')
498         process = Popen(
499             shellCommand,
500             stdout=PIPE,
501             stderr=STDOUT,
502             shell=True,
503             **kwargs)
504         pid = process.pid
505         this_output, this_error = process.communicate()
506         retcode = process.poll()
507
508         if retcode:
509             cmd = kwargs.get("args")
510             if cmd is None:
511                 cmd = shellCommand
512             cpe = CalledProcessError(retcode, cmd)
513             # Ensure caller can access the stdout/stderr.
514             cpe.lldb_extensions = {
515                 "combined_output": this_output,
516                 "command": shellCommand
517             }
518             raise cpe
519         output = output + this_output.decode("utf-8", errors='ignore')
520     return output
521
522
523 def getsource_if_available(obj):
524     """
525     Return the text of the source code for an object if available.  Otherwise,
526     a print representation is returned.
527     """
528     import inspect
529     try:
530         return inspect.getsource(obj)
531     except:
532         return repr(obj)
533
534
535 def builder_module():
536     return get_builder(sys.platform)
537
538
539 class Base(unittest2.TestCase):
540     """
541     Abstract base for performing lldb (see TestBase) or other generic tests (see
542     BenchBase for one example).  lldbtest.Base works with the test driver to
543     accomplish things.
544
545     """
546
547     # The concrete subclass should override this attribute.
548     mydir = None
549
550     # Keep track of the old current working directory.
551     oldcwd = None
552
553     @staticmethod
554     def compute_mydir(test_file):
555         '''Subclasses should call this function to correctly calculate the
556            required "mydir" attribute as follows:
557
558             mydir = TestBase.compute_mydir(__file__)
559         '''
560         # /abs/path/to/packages/group/subdir/mytest.py -> group/subdir
561         lldb_test_src = configuration.test_src_root
562         if not test_file.startswith(lldb_test_src):
563           raise Exception(
564               "Test file '%s' must reside within lldb_test_src "
565               "(which is '%s')." % (test_file, lldb_test_src))
566         return os.path.dirname(os.path.relpath(test_file, start=lldb_test_src))
567
568     def TraceOn(self):
569         """Returns True if we are in trace mode (tracing detailed test execution)."""
570         return traceAlways
571
572     def trace(self, *args,**kwargs):
573         with recording(self, self.TraceOn()) as sbuf:
574             print(*args, file=sbuf, **kwargs)
575
576     @classmethod
577     def setUpClass(cls):
578         """
579         Python unittest framework class setup fixture.
580         Do current directory manipulation.
581         """
582         # Fail fast if 'mydir' attribute is not overridden.
583         if not cls.mydir or len(cls.mydir) == 0:
584             raise Exception("Subclasses must override the 'mydir' attribute.")
585
586         # Save old working directory.
587         cls.oldcwd = os.getcwd()
588
589         full_dir = os.path.join(configuration.test_src_root, cls.mydir)
590         if traceAlways:
591             print("Change dir to:", full_dir, file=sys.stderr)
592         os.chdir(full_dir)
593         lldb.SBReproducer.SetWorkingDirectory(full_dir)
594
595         # Set platform context.
596         cls.platformContext = lldbplatformutil.createPlatformContext()
597
598     @classmethod
599     def tearDownClass(cls):
600         """
601         Python unittest framework class teardown fixture.
602         Do class-wide cleanup.
603         """
604
605         if doCleanup:
606             # First, let's do the platform-specific cleanup.
607             module = builder_module()
608             module.cleanup()
609
610             # Subclass might have specific cleanup function defined.
611             if getattr(cls, "classCleanup", None):
612                 if traceAlways:
613                     print(
614                         "Call class-specific cleanup function for class:",
615                         cls,
616                         file=sys.stderr)
617                 try:
618                     cls.classCleanup()
619                 except:
620                     exc_type, exc_value, exc_tb = sys.exc_info()
621                     traceback.print_exception(exc_type, exc_value, exc_tb)
622
623         # Restore old working directory.
624         if traceAlways:
625             print("Restore dir to:", cls.oldcwd, file=sys.stderr)
626         os.chdir(cls.oldcwd)
627
628     def enableLogChannelsForCurrentTest(self):
629         if len(lldbtest_config.channels) == 0:
630             return
631
632         # if debug channels are specified in lldbtest_config.channels,
633         # create a new set of log files for every test
634         log_basename = self.getLogBasenameForCurrentTest()
635
636         # confirm that the file is writeable
637         host_log_path = "{}-host.log".format(log_basename)
638         open(host_log_path, 'w').close()
639         self.log_files.append(host_log_path)
640
641         log_enable = "log enable -Tpn -f {} ".format(host_log_path)
642         for channel_with_categories in lldbtest_config.channels:
643             channel_then_categories = channel_with_categories.split(' ', 1)
644             channel = channel_then_categories[0]
645             if len(channel_then_categories) > 1:
646                 categories = channel_then_categories[1]
647             else:
648                 categories = "default"
649
650             if channel == "gdb-remote" and lldb.remote_platform is None:
651                 # communicate gdb-remote categories to debugserver
652                 os.environ["LLDB_DEBUGSERVER_LOG_FLAGS"] = categories
653
654             self.ci.HandleCommand(
655                 log_enable + channel_with_categories, self.res)
656             if not self.res.Succeeded():
657                 raise Exception(
658                     'log enable failed (check LLDB_LOG_OPTION env variable)')
659
660         # Communicate log path name to debugserver & lldb-server
661         # For remote debugging, these variables need to be set when starting the platform
662         # instance.
663         if lldb.remote_platform is None:
664             server_log_path = "{}-server.log".format(log_basename)
665             open(server_log_path, 'w').close()
666             self.log_files.append(server_log_path)
667             os.environ["LLDB_DEBUGSERVER_LOG_FILE"] = server_log_path
668
669             # Communicate channels to lldb-server
670             os.environ["LLDB_SERVER_LOG_CHANNELS"] = ":".join(
671                 lldbtest_config.channels)
672
673         self.addTearDownHook(self.disableLogChannelsForCurrentTest)
674
675     def disableLogChannelsForCurrentTest(self):
676         # close all log files that we opened
677         for channel_and_categories in lldbtest_config.channels:
678             # channel format - <channel-name> [<category0> [<category1> ...]]
679             channel = channel_and_categories.split(' ', 1)[0]
680             self.ci.HandleCommand("log disable " + channel, self.res)
681             if not self.res.Succeeded():
682                 raise Exception(
683                     'log disable failed (check LLDB_LOG_OPTION env variable)')
684
685         # Retrieve the server log (if any) from the remote system. It is assumed the server log
686         # is writing to the "server.log" file in the current test directory. This can be
687         # achieved by setting LLDB_DEBUGSERVER_LOG_FILE="server.log" when starting remote
688         # platform.
689         if lldb.remote_platform:
690             server_log_path = self.getLogBasenameForCurrentTest() + "-server.log"
691             if lldb.remote_platform.Get(
692                 lldb.SBFileSpec("server.log"),
693                 lldb.SBFileSpec(server_log_path)).Success():
694                 self.log_files.append(server_log_path)
695
696     def setPlatformWorkingDir(self):
697         if not lldb.remote_platform or not configuration.lldb_platform_working_dir:
698             return
699
700         components = self.mydir.split(os.path.sep) + [str(self.test_number), self.getBuildDirBasename()]
701         remote_test_dir = configuration.lldb_platform_working_dir
702         for c in components:
703             remote_test_dir = lldbutil.join_remote_paths(remote_test_dir, c)
704             error = lldb.remote_platform.MakeDirectory(
705                 remote_test_dir, 448)  # 448 = 0o700
706             if error.Fail():
707                 raise Exception("making remote directory '%s': %s" % (
708                     remote_test_dir, error))
709
710         lldb.remote_platform.SetWorkingDirectory(remote_test_dir)
711
712         # This function removes all files from the current working directory while leaving
713         # the directories in place. The cleanup is required to reduce the disk space required
714         # by the test suite while leaving the directories untouched is neccessary because
715         # sub-directories might belong to an other test
716         def clean_working_directory():
717             # TODO: Make it working on Windows when we need it for remote debugging support
718             # TODO: Replace the heuristic to remove the files with a logic what collects the
719             # list of files we have to remove during test runs.
720             shell_cmd = lldb.SBPlatformShellCommand(
721                 "rm %s/*" % remote_test_dir)
722             lldb.remote_platform.Run(shell_cmd)
723         self.addTearDownHook(clean_working_directory)
724
725     def getSourceDir(self):
726         """Return the full path to the current test."""
727         return os.path.join(configuration.test_src_root, self.mydir)
728
729     def getBuildDirBasename(self):
730         return self.__class__.__module__ + "." + self.testMethodName
731
732     def getBuildDir(self):
733         """Return the full path to the current test."""
734         return os.path.join(configuration.test_build_dir, self.mydir,
735                             self.getBuildDirBasename())
736
737     def getReproducerDir(self):
738         """Return the full path to the reproducer if enabled."""
739         if configuration.capture_path:
740             return configuration.capture_path
741         if configuration.replay_path:
742             return configuration.replay_path
743         return None
744
745     def makeBuildDir(self):
746         """Create the test-specific working directory, deleting any previous
747         contents."""
748         bdir = self.getBuildDir()
749         if os.path.isdir(bdir):
750             shutil.rmtree(bdir)
751         lldbutil.mkdir_p(bdir)
752
753     def getBuildArtifact(self, name="a.out"):
754         """Return absolute path to an artifact in the test's build directory."""
755         return os.path.join(self.getBuildDir(), name)
756
757     def getSourcePath(self, name):
758         """Return absolute path to a file in the test's source directory."""
759         return os.path.join(self.getSourceDir(), name)
760
761     def getReproducerArtifact(self, name):
762         lldbutil.mkdir_p(self.getReproducerDir())
763         return os.path.join(self.getReproducerDir(), name)
764
765     def getReproducerRemappedPath(self, path):
766         assert configuration.replay_path
767         assert os.path.isabs(path)
768         path = os.path.relpath(path, '/')
769         return os.path.join(configuration.replay_path, 'root', path)
770
771     @classmethod
772     def setUpCommands(cls):
773         commands = [
774             # First of all, clear all settings to have clean state of global properties.
775             "settings clear -all",
776
777             # Disable Spotlight lookup. The testsuite creates
778             # different binaries with the same UUID, because they only
779             # differ in the debug info, which is not being hashed.
780             "settings set symbols.enable-external-lookup false",
781
782             # Inherit the TCC permissions from the inferior's parent.
783             "settings set target.inherit-tcc true",
784
785             # Disable fix-its by default so that incorrect expressions in tests don't
786             # pass just because Clang thinks it has a fix-it.
787             "settings set target.auto-apply-fixits false",
788
789             # Testsuite runs in parallel and the host can have also other load.
790             "settings set plugin.process.gdb-remote.packet-timeout 60",
791
792             'settings set symbols.clang-modules-cache-path "{}"'.format(
793                 configuration.lldb_module_cache_dir),
794             "settings set use-color false",
795         ]
796
797         # Set any user-overridden settings.
798         for setting, value in configuration.settings:
799             commands.append('setting set %s %s'%(setting, value))
800
801         # Make sure that a sanitizer LLDB's environment doesn't get passed on.
802         if cls.platformContext and cls.platformContext.shlib_environment_var in os.environ:
803             commands.append('settings set target.env-vars {}='.format(
804                 cls.platformContext.shlib_environment_var))
805
806         # Set environment variables for the inferior.
807         if lldbtest_config.inferior_env:
808             commands.append('settings set target.env-vars {}'.format(
809                 lldbtest_config.inferior_env))
810         return commands
811
812     def setUp(self):
813         """Fixture for unittest test case setup.
814
815         It works with the test driver to conditionally skip tests and does other
816         initializations."""
817         #import traceback
818         # traceback.print_stack()
819
820         if "LIBCXX_PATH" in os.environ:
821             self.libcxxPath = os.environ["LIBCXX_PATH"]
822         else:
823             self.libcxxPath = None
824
825         if "LLDBVSCODE_EXEC" in os.environ:
826             self.lldbVSCodeExec = os.environ["LLDBVSCODE_EXEC"]
827         else:
828             self.lldbVSCodeExec = None
829
830         self.lldbOption = " ".join(
831             "-o '" + s + "'" for s in self.setUpCommands())
832
833         # If we spawn an lldb process for test (via pexpect), do not load the
834         # init file unless told otherwise.
835         if os.environ.get("NO_LLDBINIT") != "NO":
836             self.lldbOption += " --no-lldbinit"
837
838         # Assign the test method name to self.testMethodName.
839         #
840         # For an example of the use of this attribute, look at test/types dir.
841         # There are a bunch of test cases under test/types and we don't want the
842         # module cacheing subsystem to be confused with executable name "a.out"
843         # used for all the test cases.
844         self.testMethodName = self._testMethodName
845
846         # This is for the case of directly spawning 'lldb'/'gdb' and interacting
847         # with it using pexpect.
848         self.child = None
849         self.child_prompt = "(lldb) "
850         # If the child is interacting with the embedded script interpreter,
851         # there are two exits required during tear down, first to quit the
852         # embedded script interpreter and second to quit the lldb command
853         # interpreter.
854         self.child_in_script_interpreter = False
855
856         # These are for customized teardown cleanup.
857         self.dict = None
858         self.doTearDownCleanup = False
859         # And in rare cases where there are multiple teardown cleanups.
860         self.dicts = []
861         self.doTearDownCleanups = False
862
863         # List of spawned subproces.Popen objects
864         self.subprocesses = []
865
866         # List of log files produced by the current test.
867         self.log_files = []
868
869         session_file = self.getLogBasenameForCurrentTest()+".log"
870         self.log_files.append(session_file)
871
872         # Python 3 doesn't support unbuffered I/O in text mode.  Open buffered.
873         self.session = encoded_file.open(session_file, "utf-8", mode="w")
874
875         # Optimistically set __errored__, __failed__, __expected__ to False
876         # initially.  If the test errored/failed, the session info
877         # (self.session) is then dumped into a session specific file for
878         # diagnosis.
879         self.__cleanup_errored__ = False
880         self.__errored__ = False
881         self.__failed__ = False
882         self.__expected__ = False
883         # We are also interested in unexpected success.
884         self.__unexpected__ = False
885         # And skipped tests.
886         self.__skipped__ = False
887
888         # See addTearDownHook(self, hook) which allows the client to add a hook
889         # function to be run during tearDown() time.
890         self.hooks = []
891
892         # See HideStdout(self).
893         self.sys_stdout_hidden = False
894
895         if self.platformContext:
896             # set environment variable names for finding shared libraries
897             self.dylibPath = self.platformContext.shlib_environment_var
898
899         # Create the debugger instance.
900         self.dbg = lldb.SBDebugger.Create()
901         # Copy selected platform from a global instance if it exists.
902         if lldb.selected_platform is not None:
903             self.dbg.SetSelectedPlatform(lldb.selected_platform)
904
905         if not self.dbg:
906             raise Exception('Invalid debugger instance')
907
908         # Retrieve the associated command interpreter instance.
909         self.ci = self.dbg.GetCommandInterpreter()
910         if not self.ci:
911             raise Exception('Could not get the command interpreter')
912
913         # And the result object.
914         self.res = lldb.SBCommandReturnObject()
915
916         self.setPlatformWorkingDir()
917         self.enableLogChannelsForCurrentTest()
918
919         self.lib_lldb = None
920         self.framework_dir = None
921         self.darwinWithFramework = False
922
923         if sys.platform.startswith("darwin") and configuration.lldb_framework_path:
924             framework = configuration.lldb_framework_path
925             lib = os.path.join(framework, 'LLDB')
926             if os.path.exists(lib):
927                 self.framework_dir = os.path.dirname(framework)
928                 self.lib_lldb = lib
929                 self.darwinWithFramework = self.platformIsDarwin()
930
931         self.makeBuildDir()
932
933     def setAsync(self, value):
934         """ Sets async mode to True/False and ensures it is reset after the testcase completes."""
935         old_async = self.dbg.GetAsync()
936         self.dbg.SetAsync(value)
937         self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
938
939     def cleanupSubprocesses(self):
940         # Terminate subprocesses in reverse order from how they were created.
941         for p in reversed(self.subprocesses):
942             p.terminate()
943             del p
944         del self.subprocesses[:]
945
946     def spawnSubprocess(self, executable, args=[], install_remote=True):
947         """ Creates a subprocess.Popen object with the specified executable and arguments,
948             saves it in self.subprocesses, and returns the object.
949         """
950         proc = _RemoteProcess(
951             install_remote) if lldb.remote_platform else _LocalProcess(self.TraceOn())
952         proc.launch(executable, args)
953         self.subprocesses.append(proc)
954         return proc
955
956     def HideStdout(self):
957         """Hide output to stdout from the user.
958
959         During test execution, there might be cases where we don't want to show the
960         standard output to the user.  For example,
961
962             self.runCmd(r'''sc print("\n\n\tHello!\n")''')
963
964         tests whether command abbreviation for 'script' works or not.  There is no
965         need to show the 'Hello' output to the user as long as the 'script' command
966         succeeds and we are not in TraceOn() mode (see the '-t' option).
967
968         In this case, the test method calls self.HideStdout(self) to redirect the
969         sys.stdout to a null device, and restores the sys.stdout upon teardown.
970
971         Note that you should only call this method at most once during a test case
972         execution.  Any subsequent call has no effect at all."""
973         if self.sys_stdout_hidden:
974             return
975
976         self.sys_stdout_hidden = True
977         old_stdout = sys.stdout
978         sys.stdout = open(os.devnull, 'w')
979
980         def restore_stdout():
981             sys.stdout = old_stdout
982         self.addTearDownHook(restore_stdout)
983
984     # =======================================================================
985     # Methods for customized teardown cleanups as well as execution of hooks.
986     # =======================================================================
987
988     def setTearDownCleanup(self, dictionary=None):
989         """Register a cleanup action at tearDown() time with a dictionary"""
990         self.dict = dictionary
991         self.doTearDownCleanup = True
992
993     def addTearDownCleanup(self, dictionary):
994         """Add a cleanup action at tearDown() time with a dictionary"""
995         self.dicts.append(dictionary)
996         self.doTearDownCleanups = True
997
998     def addTearDownHook(self, hook):
999         """
1000         Add a function to be run during tearDown() time.
1001
1002         Hooks are executed in a first come first serve manner.
1003         """
1004         if six.callable(hook):
1005             with recording(self, traceAlways) as sbuf:
1006                 print(
1007                     "Adding tearDown hook:",
1008                     getsource_if_available(hook),
1009                     file=sbuf)
1010             self.hooks.append(hook)
1011
1012         return self
1013
1014     def deletePexpectChild(self):
1015         # This is for the case of directly spawning 'lldb' and interacting with it
1016         # using pexpect.
1017         if self.child and self.child.isalive():
1018             import pexpect
1019             with recording(self, traceAlways) as sbuf:
1020                 print("tearing down the child process....", file=sbuf)
1021             try:
1022                 if self.child_in_script_interpreter:
1023                     self.child.sendline('quit()')
1024                     self.child.expect_exact(self.child_prompt)
1025                 self.child.sendline(
1026                     'settings set interpreter.prompt-on-quit false')
1027                 self.child.sendline('quit')
1028                 self.child.expect(pexpect.EOF)
1029             except (ValueError, pexpect.ExceptionPexpect):
1030                 # child is already terminated
1031                 pass
1032             except OSError as exception:
1033                 import errno
1034                 if exception.errno != errno.EIO:
1035                     # unexpected error
1036                     raise
1037                 # child is already terminated
1038             finally:
1039                 # Give it one final blow to make sure the child is terminated.
1040                 self.child.close()
1041
1042     def tearDown(self):
1043         """Fixture for unittest test case teardown."""
1044         self.deletePexpectChild()
1045
1046         # Check and run any hook functions.
1047         for hook in reversed(self.hooks):
1048             with recording(self, traceAlways) as sbuf:
1049                 print(
1050                     "Executing tearDown hook:",
1051                     getsource_if_available(hook),
1052                     file=sbuf)
1053             if funcutils.requires_self(hook):
1054                 hook(self)
1055             else:
1056                 hook()  # try the plain call and hope it works
1057
1058         del self.hooks
1059
1060         # Perform registered teardown cleanup.
1061         if doCleanup and self.doTearDownCleanup:
1062             self.cleanup(dictionary=self.dict)
1063
1064         # In rare cases where there are multiple teardown cleanups added.
1065         if doCleanup and self.doTearDownCleanups:
1066             if self.dicts:
1067                 for dict in reversed(self.dicts):
1068                     self.cleanup(dictionary=dict)
1069
1070         # Remove subprocesses created by the test.
1071         self.cleanupSubprocesses()
1072
1073         # This must be the last statement, otherwise teardown hooks or other
1074         # lines might depend on this still being active.
1075         lldb.SBDebugger.Destroy(self.dbg)
1076         del self.dbg
1077
1078         # All modules should be orphaned now so that they can be cleared from
1079         # the shared module cache.
1080         lldb.SBModule.GarbageCollectAllocatedModules()
1081
1082         # Modules are not orphaned during reproducer replay because they're
1083         # leaked on purpose.
1084         if not configuration.is_reproducer():
1085             # Assert that the global module cache is empty.
1086             self.assertEqual(lldb.SBModule.GetNumberAllocatedModules(), 0)
1087
1088
1089     # =========================================================
1090     # Various callbacks to allow introspection of test progress
1091     # =========================================================
1092
1093     def markError(self):
1094         """Callback invoked when an error (unexpected exception) errored."""
1095         self.__errored__ = True
1096         with recording(self, False) as sbuf:
1097             # False because there's no need to write "ERROR" to the stderr twice.
1098             # Once by the Python unittest framework, and a second time by us.
1099             print("ERROR", file=sbuf)
1100
1101     def markCleanupError(self):
1102         """Callback invoked when an error occurs while a test is cleaning up."""
1103         self.__cleanup_errored__ = True
1104         with recording(self, False) as sbuf:
1105             # False because there's no need to write "CLEANUP_ERROR" to the stderr twice.
1106             # Once by the Python unittest framework, and a second time by us.
1107             print("CLEANUP_ERROR", file=sbuf)
1108
1109     def markFailure(self):
1110         """Callback invoked when a failure (test assertion failure) occurred."""
1111         self.__failed__ = True
1112         with recording(self, False) as sbuf:
1113             # False because there's no need to write "FAIL" to the stderr twice.
1114             # Once by the Python unittest framework, and a second time by us.
1115             print("FAIL", file=sbuf)
1116
1117     def markExpectedFailure(self, err, bugnumber):
1118         """Callback invoked when an expected failure/error occurred."""
1119         self.__expected__ = True
1120         with recording(self, False) as sbuf:
1121             # False because there's no need to write "expected failure" to the
1122             # stderr twice.
1123             # Once by the Python unittest framework, and a second time by us.
1124             if bugnumber is None:
1125                 print("expected failure", file=sbuf)
1126             else:
1127                 print(
1128                     "expected failure (problem id:" + str(bugnumber) + ")",
1129                     file=sbuf)
1130
1131     def markSkippedTest(self):
1132         """Callback invoked when a test is skipped."""
1133         self.__skipped__ = True
1134         with recording(self, False) as sbuf:
1135             # False because there's no need to write "skipped test" to the
1136             # stderr twice.
1137             # Once by the Python unittest framework, and a second time by us.
1138             print("skipped test", file=sbuf)
1139
1140     def markUnexpectedSuccess(self, bugnumber):
1141         """Callback invoked when an unexpected success occurred."""
1142         self.__unexpected__ = True
1143         with recording(self, False) as sbuf:
1144             # False because there's no need to write "unexpected success" to the
1145             # stderr twice.
1146             # Once by the Python unittest framework, and a second time by us.
1147             if bugnumber is None:
1148                 print("unexpected success", file=sbuf)
1149             else:
1150                 print(
1151                     "unexpected success (problem id:" + str(bugnumber) + ")",
1152                     file=sbuf)
1153
1154     def getRerunArgs(self):
1155         return " -f %s.%s" % (self.__class__.__name__, self._testMethodName)
1156
1157     def getLogBasenameForCurrentTest(self, prefix=None):
1158         """
1159         returns a partial path that can be used as the beginning of the name of multiple
1160         log files pertaining to this test
1161
1162         <session-dir>/<arch>-<compiler>-<test-file>.<test-class>.<test-method>
1163         """
1164         dname = os.path.join(configuration.test_src_root,
1165                              os.environ["LLDB_SESSION_DIRNAME"])
1166         if not os.path.isdir(dname):
1167             os.mkdir(dname)
1168
1169         components = []
1170         if prefix is not None:
1171             components.append(prefix)
1172         for c in configuration.session_file_format:
1173             if c == 'f':
1174                 components.append(self.__class__.__module__)
1175             elif c == 'n':
1176                 components.append(self.__class__.__name__)
1177             elif c == 'c':
1178                 compiler = self.getCompiler()
1179
1180                 if compiler[1] == ':':
1181                     compiler = compiler[2:]
1182                 if os.path.altsep is not None:
1183                     compiler = compiler.replace(os.path.altsep, os.path.sep)
1184                 path_components = [x for x in compiler.split(os.path.sep) if x != ""]
1185
1186                 # Add at most 4 path components to avoid generating very long
1187                 # filenames
1188                 components.extend(path_components[-4:])
1189             elif c == 'a':
1190                 components.append(self.getArchitecture())
1191             elif c == 'm':
1192                 components.append(self.testMethodName)
1193         fname = "-".join(components)
1194
1195         return os.path.join(dname, fname)
1196
1197     def dumpSessionInfo(self):
1198         """
1199         Dump the debugger interactions leading to a test error/failure.  This
1200         allows for more convenient postmortem analysis.
1201
1202         See also LLDBTestResult (dotest.py) which is a singlton class derived
1203         from TextTestResult and overwrites addError, addFailure, and
1204         addExpectedFailure methods to allow us to to mark the test instance as
1205         such.
1206         """
1207
1208         # We are here because self.tearDown() detected that this test instance
1209         # either errored or failed.  The lldb.test_result singleton contains
1210         # two lists (errors and failures) which get populated by the unittest
1211         # framework.  Look over there for stack trace information.
1212         #
1213         # The lists contain 2-tuples of TestCase instances and strings holding
1214         # formatted tracebacks.
1215         #
1216         # See http://docs.python.org/library/unittest.html#unittest.TestResult.
1217
1218         # output tracebacks into session
1219         pairs = []
1220         if self.__errored__:
1221             pairs = configuration.test_result.errors
1222             prefix = 'Error'
1223         elif self.__cleanup_errored__:
1224             pairs = configuration.test_result.cleanup_errors
1225             prefix = 'CleanupError'
1226         elif self.__failed__:
1227             pairs = configuration.test_result.failures
1228             prefix = 'Failure'
1229         elif self.__expected__:
1230             pairs = configuration.test_result.expectedFailures
1231             prefix = 'ExpectedFailure'
1232         elif self.__skipped__:
1233             prefix = 'SkippedTest'
1234         elif self.__unexpected__:
1235             prefix = 'UnexpectedSuccess'
1236         else:
1237             prefix = 'Success'
1238
1239         if not self.__unexpected__ and not self.__skipped__:
1240             for test, traceback in pairs:
1241                 if test is self:
1242                     print(traceback, file=self.session)
1243
1244         import datetime
1245         print(
1246             "Session info generated @",
1247             datetime.datetime.now().ctime(),
1248             file=self.session)
1249         self.session.close()
1250         del self.session
1251
1252         # process the log files
1253         if prefix != 'Success' or lldbtest_config.log_success:
1254             # keep all log files, rename them to include prefix
1255             src_log_basename = self.getLogBasenameForCurrentTest(None)
1256             dst_log_basename = self.getLogBasenameForCurrentTest(prefix)
1257             for src in self.log_files:
1258                 if os.path.isfile(src):
1259                     dst = src.replace(src_log_basename, dst_log_basename)
1260                     if os.name == "nt" and os.path.isfile(dst):
1261                         # On Windows, renaming a -> b will throw an exception if
1262                         # b exists.  On non-Windows platforms it silently
1263                         # replaces the destination.  Ultimately this means that
1264                         # atomic renames are not guaranteed to be possible on
1265                         # Windows, but we need this to work anyway, so just
1266                         # remove the destination first if it already exists.
1267                         remove_file(dst)
1268
1269                     lldbutil.mkdir_p(os.path.dirname(dst))
1270                     os.rename(src, dst)
1271         else:
1272             # success!  (and we don't want log files) delete log files
1273             for log_file in self.log_files:
1274                 if os.path.isfile(log_file):
1275                     remove_file(log_file)
1276
1277     # ====================================================
1278     # Config. methods supported through a plugin interface
1279     # (enables reading of the current test configuration)
1280     # ====================================================
1281
1282     def isMIPS(self):
1283         """Returns true if the architecture is MIPS."""
1284         arch = self.getArchitecture()
1285         if re.match("mips", arch):
1286             return True
1287         return False
1288
1289     def isPPC64le(self):
1290         """Returns true if the architecture is PPC64LE."""
1291         arch = self.getArchitecture()
1292         if re.match("powerpc64le", arch):
1293             return True
1294         return False
1295
1296     def isAArch64SVE(self):
1297         triple = self.dbg.GetSelectedPlatform().GetTriple()
1298
1299         # TODO other platforms, please implement this function
1300         if not re.match(".*-.*-linux", triple):
1301             return False
1302
1303         # Need to do something different for non-Linux/Android targets
1304         cpuinfo_path = self.getBuildArtifact("cpuinfo")
1305         if configuration.lldb_platform_name:
1306             self.runCmd('platform get-file "/proc/cpuinfo" ' + cpuinfo_path)
1307         else:
1308             cpuinfo_path = "/proc/cpuinfo"
1309
1310         try:
1311             f = open(cpuinfo_path, 'r')
1312             cpuinfo = f.read()
1313             f.close()
1314         except:
1315             return False
1316
1317         return " sve " in cpuinfo
1318
1319     def getArchitecture(self):
1320         """Returns the architecture in effect the test suite is running with."""
1321         module = builder_module()
1322         arch = module.getArchitecture()
1323         if arch == 'amd64':
1324             arch = 'x86_64'
1325         if arch in ['armv7l', 'armv8l'] :
1326             arch = 'arm'
1327         return arch
1328
1329     def getLldbArchitecture(self):
1330         """Returns the architecture of the lldb binary."""
1331         if not hasattr(self, 'lldbArchitecture'):
1332
1333             # spawn local process
1334             command = [
1335                 lldbtest_config.lldbExec,
1336                 "-o",
1337                 "file " + lldbtest_config.lldbExec,
1338                 "-o",
1339                 "quit"
1340             ]
1341
1342             output = check_output(command)
1343             str = output.decode("utf-8")
1344
1345             for line in str.splitlines():
1346                 m = re.search(
1347                     "Current executable set to '.*' \\((.*)\\)\\.", line)
1348                 if m:
1349                     self.lldbArchitecture = m.group(1)
1350                     break
1351
1352         return self.lldbArchitecture
1353
1354     def getCompiler(self):
1355         """Returns the compiler in effect the test suite is running with."""
1356         module = builder_module()
1357         return module.getCompiler()
1358
1359     def getCompilerBinary(self):
1360         """Returns the compiler binary the test suite is running with."""
1361         return self.getCompiler().split()[0]
1362
1363     def getCompilerVersion(self):
1364         """ Returns a string that represents the compiler version.
1365             Supports: llvm, clang.
1366         """
1367         compiler = self.getCompilerBinary()
1368         version_output = system([[compiler, "--version"]])
1369         for line in version_output.split(os.linesep):
1370             m = re.search('version ([0-9.]+)', line)
1371             if m:
1372                 return m.group(1)
1373         return 'unknown'
1374
1375     def getDwarfVersion(self):
1376         """ Returns the dwarf version generated by clang or '0'. """
1377         if configuration.dwarf_version:
1378             return str(configuration.dwarf_version)
1379         if 'clang' in self.getCompiler():
1380             try:
1381                 driver_output = check_output(
1382                     [self.getCompiler()] + '-g -c -x c - -o - -###'.split(),
1383                     stderr=STDOUT)
1384                 driver_output = driver_output.decode("utf-8")
1385                 for line in driver_output.split(os.linesep):
1386                     m = re.search('dwarf-version=([0-9])', line)
1387                     if m:
1388                         return m.group(1)
1389             except: pass
1390         return '0'
1391
1392     def platformIsDarwin(self):
1393         """Returns true if the OS triple for the selected platform is any valid apple OS"""
1394         return lldbplatformutil.platformIsDarwin()
1395
1396     def hasDarwinFramework(self):
1397         return self.darwinWithFramework
1398
1399     def getPlatform(self):
1400         """Returns the target platform the test suite is running on."""
1401         return lldbplatformutil.getPlatform()
1402
1403     def isIntelCompiler(self):
1404         """ Returns true if using an Intel (ICC) compiler, false otherwise. """
1405         return any([x in self.getCompiler() for x in ["icc", "icpc", "icl"]])
1406
1407     def expectedCompilerVersion(self, compiler_version):
1408         """Returns True iff compiler_version[1] matches the current compiler version.
1409            Use compiler_version[0] to specify the operator used to determine if a match has occurred.
1410            Any operator other than the following defaults to an equality test:
1411              '>', '>=', "=>", '<', '<=', '=<', '!=', "!" or 'not'
1412
1413            If the current compiler version cannot be determined, we assume it is close to the top
1414            of trunk, so any less-than or equal-to comparisons will return False, and any
1415            greater-than or not-equal-to comparisons will return True.
1416         """
1417         if compiler_version is None:
1418             return True
1419         operator = str(compiler_version[0])
1420         version = compiler_version[1]
1421
1422         if version is None:
1423             return True
1424
1425         test_compiler_version = self.getCompilerVersion()
1426         if test_compiler_version == 'unknown':
1427             # Assume the compiler version is at or near the top of trunk.
1428             return operator in ['>', '>=', '!', '!=', 'not']
1429
1430         if operator == '>':
1431             return LooseVersion(test_compiler_version) > LooseVersion(version)
1432         if operator == '>=' or operator == '=>':
1433             return LooseVersion(test_compiler_version) >= LooseVersion(version)
1434         if operator == '<':
1435             return LooseVersion(test_compiler_version) < LooseVersion(version)
1436         if operator == '<=' or operator == '=<':
1437             return LooseVersion(test_compiler_version) <= LooseVersion(version)
1438         if operator == '!=' or operator == '!' or operator == 'not':
1439             return str(version) not in str(test_compiler_version)
1440         return str(version) in str(test_compiler_version)
1441
1442     def expectedCompiler(self, compilers):
1443         """Returns True iff any element of compilers is a sub-string of the current compiler."""
1444         if (compilers is None):
1445             return True
1446
1447         for compiler in compilers:
1448             if compiler in self.getCompiler():
1449                 return True
1450
1451         return False
1452
1453     def expectedArch(self, archs):
1454         """Returns True iff any element of archs is a sub-string of the current architecture."""
1455         if (archs is None):
1456             return True
1457
1458         for arch in archs:
1459             if arch in self.getArchitecture():
1460                 return True
1461
1462         return False
1463
1464     def getRunOptions(self):
1465         """Command line option for -A and -C to run this test again, called from
1466         self.dumpSessionInfo()."""
1467         arch = self.getArchitecture()
1468         comp = self.getCompiler()
1469         option_str = ""
1470         if arch:
1471             option_str = "-A " + arch
1472         if comp:
1473             option_str += " -C " + comp
1474         return option_str
1475
1476     def getDebugInfo(self):
1477         method = getattr(self, self.testMethodName)
1478         return getattr(method, "debug_info", None)
1479
1480     # ==================================================
1481     # Build methods supported through a plugin interface
1482     # ==================================================
1483
1484     def getstdlibFlag(self):
1485         """ Returns the proper -stdlib flag, or empty if not required."""
1486         if self.platformIsDarwin() or self.getPlatform() == "freebsd" or self.getPlatform() == "openbsd":
1487             stdlibflag = "-stdlib=libc++"
1488         else:  # this includes NetBSD
1489             stdlibflag = ""
1490         return stdlibflag
1491
1492     def getstdFlag(self):
1493         """ Returns the proper stdflag. """
1494         if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
1495             stdflag = "-std=c++0x"
1496         else:
1497             stdflag = "-std=c++11"
1498         return stdflag
1499
1500     def buildDriver(self, sources, exe_name):
1501         """ Platform-specific way to build a program that links with LLDB (via the liblldb.so
1502             or LLDB.framework).
1503         """
1504         stdflag = self.getstdFlag()
1505         stdlibflag = self.getstdlibFlag()
1506
1507         lib_dir = configuration.lldb_libs_dir
1508         if self.hasDarwinFramework():
1509             d = {'CXX_SOURCES': sources,
1510                  'EXE': exe_name,
1511                  'CFLAGS_EXTRAS': "%s %s" % (stdflag, stdlibflag),
1512                  'FRAMEWORK_INCLUDES': "-F%s" % self.framework_dir,
1513                  'LD_EXTRAS': "%s -Wl,-rpath,%s" % (self.lib_lldb, self.framework_dir),
1514                  }
1515         elif sys.platform.startswith('win'):
1516             d = {
1517                 'CXX_SOURCES': sources,
1518                 'EXE': exe_name,
1519                 'CFLAGS_EXTRAS': "%s %s -I%s" % (stdflag,
1520                                                  stdlibflag,
1521                                                  os.path.join(
1522                                                      os.environ["LLDB_SRC"],
1523                                                      "include")),
1524                 'LD_EXTRAS': "-L%s -lliblldb" % lib_dir}
1525         else:
1526             d = {
1527                 'CXX_SOURCES': sources,
1528                 'EXE': exe_name,
1529                 'CFLAGS_EXTRAS': "%s %s -I%s" % (stdflag,
1530                                                  stdlibflag,
1531                                                  os.path.join(
1532                                                      os.environ["LLDB_SRC"],
1533                                                      "include")),
1534                 'LD_EXTRAS': "-L%s -llldb -Wl,-rpath,%s" % (lib_dir, lib_dir)}
1535         if self.TraceOn():
1536             print(
1537                 "Building LLDB Driver (%s) from sources %s" %
1538                 (exe_name, sources))
1539
1540         self.buildDefault(dictionary=d)
1541
1542     def buildLibrary(self, sources, lib_name):
1543         """Platform specific way to build a default library. """
1544
1545         stdflag = self.getstdFlag()
1546
1547         lib_dir = configuration.lldb_libs_dir
1548         if self.hasDarwinFramework():
1549             d = {'DYLIB_CXX_SOURCES': sources,
1550                  'DYLIB_NAME': lib_name,
1551                  'CFLAGS_EXTRAS': "%s -stdlib=libc++" % stdflag,
1552                  'FRAMEWORK_INCLUDES': "-F%s" % self.framework_dir,
1553                  'LD_EXTRAS': "%s -Wl,-rpath,%s -dynamiclib" % (self.lib_lldb, self.framework_dir),
1554                  }
1555         elif self.getPlatform() == 'windows':
1556             d = {
1557                 'DYLIB_CXX_SOURCES': sources,
1558                 'DYLIB_NAME': lib_name,
1559                 'CFLAGS_EXTRAS': "%s -I%s " % (stdflag,
1560                                                os.path.join(
1561                                                    os.environ["LLDB_SRC"],
1562                                                    "include")),
1563                 'LD_EXTRAS': "-shared -l%s\liblldb.lib" % lib_dir}
1564         else:
1565             d = {
1566                 'DYLIB_CXX_SOURCES': sources,
1567                 'DYLIB_NAME': lib_name,
1568                 'CFLAGS_EXTRAS': "%s -I%s -fPIC" % (stdflag,
1569                                                     os.path.join(
1570                                                         os.environ["LLDB_SRC"],
1571                                                         "include")),
1572                 'LD_EXTRAS': "-shared -L%s -llldb -Wl,-rpath,%s" % (lib_dir, lib_dir)}
1573         if self.TraceOn():
1574             print(
1575                 "Building LLDB Library (%s) from sources %s" %
1576                 (lib_name, sources))
1577
1578         self.buildDefault(dictionary=d)
1579
1580     def buildProgram(self, sources, exe_name):
1581         """ Platform specific way to build an executable from C/C++ sources. """
1582         d = {'CXX_SOURCES': sources,
1583              'EXE': exe_name}
1584         self.buildDefault(dictionary=d)
1585
1586     def buildDefault(
1587             self,
1588             architecture=None,
1589             compiler=None,
1590             dictionary=None):
1591         """Platform specific way to build the default binaries."""
1592         testdir = self.mydir
1593         testname = self.getBuildDirBasename()
1594
1595         if not architecture and configuration.arch:
1596             architecture = configuration.arch
1597
1598         if self.getDebugInfo():
1599             raise Exception("buildDefault tests must set NO_DEBUG_INFO_TESTCASE")
1600         module = builder_module()
1601         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1602         if not module.buildDefault(self, architecture, compiler,
1603                                    dictionary, testdir, testname):
1604             raise Exception("Don't know how to build default binary")
1605
1606     def buildDsym(
1607             self,
1608             architecture=None,
1609             compiler=None,
1610             dictionary=None):
1611         """Platform specific way to build binaries with dsym info."""
1612         testdir = self.mydir
1613         testname = self.getBuildDirBasename()
1614         if self.getDebugInfo() != "dsym":
1615             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
1616
1617         module = builder_module()
1618         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1619         if not module.buildDsym(self, architecture, compiler,
1620                                 dictionary, testdir, testname):
1621             raise Exception("Don't know how to build binary with dsym")
1622
1623     def buildDwarf(
1624             self,
1625             architecture=None,
1626             compiler=None,
1627             dictionary=None):
1628         """Platform specific way to build binaries with dwarf maps."""
1629         testdir = self.mydir
1630         testname = self.getBuildDirBasename()
1631         if self.getDebugInfo() != "dwarf":
1632             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
1633
1634         module = builder_module()
1635         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1636         if not module.buildDwarf(self, architecture, compiler,
1637                                    dictionary, testdir, testname):
1638             raise Exception("Don't know how to build binary with dwarf")
1639
1640     def buildDwo(
1641             self,
1642             architecture=None,
1643             compiler=None,
1644             dictionary=None):
1645         """Platform specific way to build binaries with dwarf maps."""
1646         testdir = self.mydir
1647         testname = self.getBuildDirBasename()
1648         if self.getDebugInfo() != "dwo":
1649             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
1650
1651         module = builder_module()
1652         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1653         if not module.buildDwo(self, architecture, compiler,
1654                                    dictionary, testdir, testname):
1655             raise Exception("Don't know how to build binary with dwo")
1656
1657     def buildGModules(
1658             self,
1659             architecture=None,
1660             compiler=None,
1661             dictionary=None):
1662         """Platform specific way to build binaries with gmodules info."""
1663         testdir = self.mydir
1664         testname = self.getBuildDirBasename()
1665         if self.getDebugInfo() != "gmodules":
1666             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
1667
1668         module = builder_module()
1669         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1670         if not module.buildGModules(self, architecture, compiler,
1671                                     dictionary, testdir, testname):
1672             raise Exception("Don't know how to build binary with gmodules")
1673
1674     def buildDWZ(
1675             self,
1676             architecture=None,
1677             compiler=None,
1678             dictionary=None):
1679         """Platform specific way to build binaries with dwz optimizer."""
1680         testdir = self.mydir
1681         testname = self.getBuildDirBasename()
1682         if self.getDebugInfo() != "dwz":
1683             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
1684
1685         module = builder_module()
1686         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
1687         if not module.buildDWZ(self, architecture, compiler,
1688                                dictionary, testdir, testname):
1689             raise Exception("Don't know how to build binary with dwz")
1690
1691     def signBinary(self, binary_path):
1692         if sys.platform.startswith("darwin"):
1693             codesign_cmd = "codesign --force --sign \"%s\" %s" % (
1694                 lldbtest_config.codesign_identity, binary_path)
1695             call(codesign_cmd, shell=True)
1696
1697     def findBuiltClang(self):
1698         """Tries to find and use Clang from the build directory as the compiler (instead of the system compiler)."""
1699         paths_to_try = [
1700             "llvm-build/Release+Asserts/x86_64/bin/clang",
1701             "llvm-build/Debug+Asserts/x86_64/bin/clang",
1702             "llvm-build/Release/x86_64/bin/clang",
1703             "llvm-build/Debug/x86_64/bin/clang",
1704         ]
1705         lldb_root_path = os.path.join(
1706             os.path.dirname(__file__), "..", "..", "..", "..")
1707         for p in paths_to_try:
1708             path = os.path.join(lldb_root_path, p)
1709             if os.path.exists(path):
1710                 return path
1711
1712         # Tries to find clang at the same folder as the lldb
1713         lldb_dir = os.path.dirname(lldbtest_config.lldbExec)
1714         path = distutils.spawn.find_executable("clang", lldb_dir)
1715         if path is not None:
1716             return path
1717
1718         return os.environ["CC"]
1719
1720
1721     def yaml2obj(self, yaml_path, obj_path):
1722         """
1723         Create an object file at the given path from a yaml file.
1724
1725         Throws subprocess.CalledProcessError if the object could not be created.
1726         """
1727         yaml2obj_bin = configuration.get_yaml2obj_path()
1728         if not yaml2obj_bin:
1729             self.assertTrue(False, "No valid yaml2obj executable specified")
1730         command = [yaml2obj_bin, "-o=%s" % obj_path, yaml_path]
1731         system([command])
1732
1733     def getBuildFlags(
1734             self,
1735             use_cpp11=True,
1736             use_libcxx=False,
1737             use_libstdcxx=False):
1738         """ Returns a dictionary (which can be provided to build* functions above) which
1739             contains OS-specific build flags.
1740         """
1741         cflags = ""
1742         ldflags = ""
1743
1744         # On Mac OS X, unless specifically requested to use libstdc++, use
1745         # libc++
1746         if not use_libstdcxx and self.platformIsDarwin():
1747             use_libcxx = True
1748
1749         if use_libcxx and self.libcxxPath:
1750             cflags += "-stdlib=libc++ "
1751             if self.libcxxPath:
1752                 libcxxInclude = os.path.join(self.libcxxPath, "include")
1753                 libcxxLib = os.path.join(self.libcxxPath, "lib")
1754                 if os.path.isdir(libcxxInclude) and os.path.isdir(libcxxLib):
1755                     cflags += "-nostdinc++ -I%s -L%s -Wl,-rpath,%s " % (
1756                         libcxxInclude, libcxxLib, libcxxLib)
1757
1758         if use_cpp11:
1759             cflags += "-std="
1760             if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
1761                 cflags += "c++0x"
1762             else:
1763                 cflags += "c++11"
1764         if self.platformIsDarwin() or self.getPlatform() == "freebsd":
1765             cflags += " -stdlib=libc++"
1766         elif self.getPlatform() == "openbsd":
1767             cflags += " -stdlib=libc++"
1768         elif self.getPlatform() == "netbsd":
1769             # NetBSD defaults to libc++
1770             pass
1771         elif "clang" in self.getCompiler():
1772             cflags += " -stdlib=libstdc++"
1773
1774         return {'CFLAGS_EXTRAS': cflags,
1775                 'LD_EXTRAS': ldflags,
1776                 }
1777
1778     def cleanup(self, dictionary=None):
1779         """Platform specific way to do cleanup after build."""
1780         module = builder_module()
1781         if not module.cleanup(self, dictionary):
1782             raise Exception(
1783                 "Don't know how to do cleanup with dictionary: " +
1784                 dictionary)
1785
1786     def getLLDBLibraryEnvVal(self):
1787         """ Returns the path that the OS-specific library search environment variable
1788             (self.dylibPath) should be set to in order for a program to find the LLDB
1789             library. If an environment variable named self.dylibPath is already set,
1790             the new path is appended to it and returned.
1791         """
1792         existing_library_path = os.environ[
1793             self.dylibPath] if self.dylibPath in os.environ else None
1794         if existing_library_path:
1795             return "%s:%s" % (existing_library_path, configuration.lldb_libs_dir)
1796         if sys.platform.startswith("darwin") and configuration.lldb_framework_path:
1797             return configuration.lldb_framework_path
1798         return configuration.lldb_libs_dir
1799
1800     def getLibcPlusPlusLibs(self):
1801         if self.getPlatform() in ('freebsd', 'linux', 'netbsd', 'openbsd'):
1802             return ['libc++.so.1']
1803         else:
1804             return ['libc++.1.dylib', 'libc++abi.']
1805
1806 # Metaclass for TestBase to change the list of test metods when a new TestCase is loaded.
1807 # We change the test methods to create a new test method for each test for each debug info we are
1808 # testing. The name of the new test method will be '<original-name>_<debug-info>' and with adding
1809 # the new test method we remove the old method at the same time. This functionality can be
1810 # supressed by at test case level setting the class attribute NO_DEBUG_INFO_TESTCASE or at test
1811 # level by using the decorator @no_debug_info_test.
1812
1813
1814 class LLDBTestCaseFactory(type):
1815
1816     def __new__(cls, name, bases, attrs):
1817         original_testcase = super(
1818             LLDBTestCaseFactory, cls).__new__(
1819             cls, name, bases, attrs)
1820         if original_testcase.NO_DEBUG_INFO_TESTCASE:
1821             return original_testcase
1822
1823         newattrs = {}
1824         for attrname, attrvalue in attrs.items():
1825             if attrname.startswith("test") and not getattr(
1826                     attrvalue, "__no_debug_info_test__", False):
1827
1828                 # If any debug info categories were explicitly tagged, assume that list to be
1829                 # authoritative.  If none were specified, try with all debug
1830                 # info formats.
1831                 all_dbginfo_categories = set(test_categories.debug_info_categories)
1832                 categories = set(
1833                     getattr(
1834                         attrvalue,
1835                         "categories",
1836                         [])) & all_dbginfo_categories
1837                 if not categories:
1838                     categories = all_dbginfo_categories
1839
1840                 for cat in categories:
1841                     @decorators.add_test_categories([cat])
1842                     @wraps(attrvalue)
1843                     def test_method(self, attrvalue=attrvalue):
1844                         return attrvalue(self)
1845
1846                     method_name = attrname + "_" + cat
1847                     test_method.__name__ = method_name
1848                     test_method.debug_info = cat
1849                     newattrs[method_name] = test_method
1850
1851             else:
1852                 newattrs[attrname] = attrvalue
1853         return super(
1854             LLDBTestCaseFactory,
1855             cls).__new__(
1856             cls,
1857             name,
1858             bases,
1859             newattrs)
1860
1861 # Setup the metaclass for this class to change the list of the test
1862 # methods when a new class is loaded
1863
1864
1865 @add_metaclass(LLDBTestCaseFactory)
1866 class TestBase(Base):
1867     """
1868     This abstract base class is meant to be subclassed.  It provides default
1869     implementations for setUpClass(), tearDownClass(), setUp(), and tearDown(),
1870     among other things.
1871
1872     Important things for test class writers:
1873
1874         - Overwrite the mydir class attribute, otherwise your test class won't
1875           run.  It specifies the relative directory to the top level 'test' so
1876           the test harness can change to the correct working directory before
1877           running your test.
1878
1879         - The setUp method sets up things to facilitate subsequent interactions
1880           with the debugger as part of the test.  These include:
1881               - populate the test method name
1882               - create/get a debugger set with synchronous mode (self.dbg)
1883               - get the command interpreter from with the debugger (self.ci)
1884               - create a result object for use with the command interpreter
1885                 (self.res)
1886               - plus other stuffs
1887
1888         - The tearDown method tries to perform some necessary cleanup on behalf
1889           of the test to return the debugger to a good state for the next test.
1890           These include:
1891               - execute any tearDown hooks registered by the test method with
1892                 TestBase.addTearDownHook(); examples can be found in
1893                 settings/TestSettings.py
1894               - kill the inferior process associated with each target, if any,
1895                 and, then delete the target from the debugger's target list
1896               - perform build cleanup before running the next test method in the
1897                 same test class; examples of registering for this service can be
1898                 found in types/TestIntegerTypes.py with the call:
1899                     - self.setTearDownCleanup(dictionary=d)
1900
1901         - Similarly setUpClass and tearDownClass perform classwise setup and
1902           teardown fixtures.  The tearDownClass method invokes a default build
1903           cleanup for the entire test class;  also, subclasses can implement the
1904           classmethod classCleanup(cls) to perform special class cleanup action.
1905
1906         - The instance methods runCmd and expect are used heavily by existing
1907           test cases to send a command to the command interpreter and to perform
1908           string/pattern matching on the output of such command execution.  The
1909           expect method also provides a mode to peform string/pattern matching
1910           without running a command.
1911
1912         - The build methods buildDefault, buildDsym, and buildDwarf are used to
1913           build the binaries used during a particular test scenario.  A plugin
1914           should be provided for the sys.platform running the test suite.  The
1915           Mac OS X implementation is located in builders/darwin.py.
1916     """
1917
1918     # Subclasses can set this to true (if they don't depend on debug info) to avoid running the
1919     # test multiple times with various debug info types.
1920     NO_DEBUG_INFO_TESTCASE = False
1921
1922     # Maximum allowed attempts when launching the inferior process.
1923     # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
1924     maxLaunchCount = 1
1925
1926     # Time to wait before the next launching attempt in second(s).
1927     # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
1928     timeWaitNextLaunch = 1.0
1929
1930     def generateSource(self, source):
1931         template = source + '.template'
1932         temp = os.path.join(self.getSourceDir(), template)
1933         with open(temp, 'r') as f:
1934             content = f.read()
1935
1936         public_api_dir = os.path.join(
1937             os.environ["LLDB_SRC"], "include", "lldb", "API")
1938
1939         # Look under the include/lldb/API directory and add #include statements
1940         # for all the SB API headers.
1941         public_headers = os.listdir(public_api_dir)
1942         # For different platforms, the include statement can vary.
1943         if self.hasDarwinFramework():
1944             include_stmt = "'#include <%s>' % os.path.join('LLDB', header)"
1945         else:
1946             include_stmt = "'#include <%s>' % os.path.join('" + public_api_dir + "', header)"
1947         list = [eval(include_stmt) for header in public_headers if (
1948             header.startswith("SB") and header.endswith(".h"))]
1949         includes = '\n'.join(list)
1950         new_content = content.replace('%include_SB_APIs%', includes)
1951         new_content = new_content.replace('%SOURCE_DIR%', self.getSourceDir())
1952         src = os.path.join(self.getBuildDir(), source)
1953         with open(src, 'w') as f:
1954             f.write(new_content)
1955
1956         self.addTearDownHook(lambda: os.remove(src))
1957
1958     def setUp(self):
1959         # Works with the test driver to conditionally skip tests via
1960         # decorators.
1961         Base.setUp(self)
1962
1963         for s in self.setUpCommands():
1964             self.runCmd(s)
1965
1966         if "LLDB_MAX_LAUNCH_COUNT" in os.environ:
1967             self.maxLaunchCount = int(os.environ["LLDB_MAX_LAUNCH_COUNT"])
1968
1969         if "LLDB_TIME_WAIT_NEXT_LAUNCH" in os.environ:
1970             self.timeWaitNextLaunch = float(
1971                 os.environ["LLDB_TIME_WAIT_NEXT_LAUNCH"])
1972
1973         # We want our debugger to be synchronous.
1974         self.dbg.SetAsync(False)
1975
1976         # Retrieve the associated command interpreter instance.
1977         self.ci = self.dbg.GetCommandInterpreter()
1978         if not self.ci:
1979             raise Exception('Could not get the command interpreter')
1980
1981         # And the result object.
1982         self.res = lldb.SBCommandReturnObject()
1983
1984     def registerSharedLibrariesWithTarget(self, target, shlibs):
1985         '''If we are remotely running the test suite, register the shared libraries with the target so they get uploaded, otherwise do nothing
1986
1987         Any modules in the target that have their remote install file specification set will
1988         get uploaded to the remote host. This function registers the local copies of the
1989         shared libraries with the target and sets their remote install locations so they will
1990         be uploaded when the target is run.
1991         '''
1992         if not shlibs or not self.platformContext:
1993             return None
1994
1995         shlib_environment_var = self.platformContext.shlib_environment_var
1996         shlib_prefix = self.platformContext.shlib_prefix
1997         shlib_extension = '.' + self.platformContext.shlib_extension
1998
1999         dirs = []
2000         # Add any shared libraries to our target if remote so they get
2001         # uploaded into the working directory on the remote side
2002         for name in shlibs:
2003             # The path can be a full path to a shared library, or a make file name like "Foo" for
2004             # "libFoo.dylib" or "libFoo.so", or "Foo.so" for "Foo.so" or "libFoo.so", or just a
2005             # basename like "libFoo.so". So figure out which one it is and resolve the local copy
2006             # of the shared library accordingly
2007             if os.path.isfile(name):
2008                 local_shlib_path = name  # name is the full path to the local shared library
2009             else:
2010                 # Check relative names
2011                 local_shlib_path = os.path.join(
2012                     self.getBuildDir(), shlib_prefix + name + shlib_extension)
2013                 if not os.path.exists(local_shlib_path):
2014                     local_shlib_path = os.path.join(
2015                         self.getBuildDir(), name + shlib_extension)
2016                     if not os.path.exists(local_shlib_path):
2017                         local_shlib_path = os.path.join(self.getBuildDir(), name)
2018
2019                 # Make sure we found the local shared library in the above code
2020                 self.assertTrue(os.path.exists(local_shlib_path))
2021
2022
2023             # Add the shared library to our target
2024             shlib_module = target.AddModule(local_shlib_path, None, None, None)
2025             if lldb.remote_platform:
2026                 # We must set the remote install location if we want the shared library
2027                 # to get uploaded to the remote target
2028                 remote_shlib_path = lldbutil.append_to_process_working_directory(self,
2029                     os.path.basename(local_shlib_path))
2030                 shlib_module.SetRemoteInstallFileSpec(
2031                     lldb.SBFileSpec(remote_shlib_path, False))
2032                 dir_to_add = self.get_process_working_directory()
2033             else:
2034                 dir_to_add = os.path.dirname(local_shlib_path)
2035
2036             if dir_to_add not in dirs:
2037                 dirs.append(dir_to_add)
2038
2039         env_value = self.platformContext.shlib_path_separator.join(dirs)
2040         return ['%s=%s' % (shlib_environment_var, env_value)]
2041
2042     def registerSanitizerLibrariesWithTarget(self, target):
2043         runtimes = []
2044         for m in target.module_iter():
2045             libspec = m.GetFileSpec()
2046             if "clang_rt" in libspec.GetFilename():
2047                 runtimes.append(os.path.join(libspec.GetDirectory(),
2048                                              libspec.GetFilename()))
2049         return self.registerSharedLibrariesWithTarget(target, runtimes)
2050
2051     # utility methods that tests can use to access the current objects
2052     def target(self):
2053         if not self.dbg:
2054             raise Exception('Invalid debugger instance')
2055         return self.dbg.GetSelectedTarget()
2056
2057     def process(self):
2058         if not self.dbg:
2059             raise Exception('Invalid debugger instance')
2060         return self.dbg.GetSelectedTarget().GetProcess()
2061
2062     def thread(self):
2063         if not self.dbg:
2064             raise Exception('Invalid debugger instance')
2065         return self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread()
2066
2067     def frame(self):
2068         if not self.dbg:
2069             raise Exception('Invalid debugger instance')
2070         return self.dbg.GetSelectedTarget().GetProcess(
2071         ).GetSelectedThread().GetSelectedFrame()
2072
2073     def get_process_working_directory(self):
2074         '''Get the working directory that should be used when launching processes for local or remote processes.'''
2075         if lldb.remote_platform:
2076             # Remote tests set the platform working directory up in
2077             # TestBase.setUp()
2078             return lldb.remote_platform.GetWorkingDirectory()
2079         else:
2080             # local tests change directory into each test subdirectory
2081             return self.getBuildDir()
2082
2083     def tearDown(self):
2084         # Ensure all the references to SB objects have gone away so that we can
2085         # be sure that all test-specific resources have been freed before we
2086         # attempt to delete the targets.
2087         gc.collect()
2088
2089         # Delete the target(s) from the debugger as a general cleanup step.
2090         # This includes terminating the process for each target, if any.
2091         # We'd like to reuse the debugger for our next test without incurring
2092         # the initialization overhead.
2093         targets = []
2094         for target in self.dbg:
2095             if target:
2096                 targets.append(target)
2097                 process = target.GetProcess()
2098                 if process:
2099                     rc = self.invoke(process, "Kill")
2100                     assert rc.Success()
2101         for target in targets:
2102             self.dbg.DeleteTarget(target)
2103
2104         if not configuration.is_reproducer():
2105             # Assert that all targets are deleted.
2106             self.assertEqual(self.dbg.GetNumTargets(), 0)
2107
2108         # Do this last, to make sure it's in reverse order from how we setup.
2109         Base.tearDown(self)
2110
2111     def switch_to_thread_with_stop_reason(self, stop_reason):
2112         """
2113         Run the 'thread list' command, and select the thread with stop reason as
2114         'stop_reason'.  If no such thread exists, no select action is done.
2115         """
2116         from .lldbutil import stop_reason_to_str
2117         self.runCmd('thread list')
2118         output = self.res.GetOutput()
2119         thread_line_pattern = re.compile(
2120             "^[ *] thread #([0-9]+):.*stop reason = %s" %
2121             stop_reason_to_str(stop_reason))
2122         for line in output.splitlines():
2123             matched = thread_line_pattern.match(line)
2124             if matched:
2125                 self.runCmd('thread select %s' % matched.group(1))
2126
2127     def runCmd(self, cmd, msg=None, check=True, trace=False, inHistory=False):
2128         """
2129         Ask the command interpreter to handle the command and then check its
2130         return status.
2131         """
2132         # Fail fast if 'cmd' is not meaningful.
2133         if cmd is None:
2134             raise Exception("Bad 'cmd' parameter encountered")
2135
2136         trace = (True if traceAlways else trace)
2137
2138         if cmd.startswith("target create "):
2139             cmd = cmd.replace("target create ", "file ")
2140
2141         running = (cmd.startswith("run") or cmd.startswith("process launch"))
2142
2143         for i in range(self.maxLaunchCount if running else 1):
2144             self.ci.HandleCommand(cmd, self.res, inHistory)
2145
2146             with recording(self, trace) as sbuf:
2147                 print("runCmd:", cmd, file=sbuf)
2148                 if not check:
2149                     print("check of return status not required", file=sbuf)
2150                 if self.res.Succeeded():
2151                     print("output:", self.res.GetOutput(), file=sbuf)
2152                 else:
2153                     print("runCmd failed!", file=sbuf)
2154                     print(self.res.GetError(), file=sbuf)
2155
2156             if self.res.Succeeded():
2157                 break
2158             elif running:
2159                 # For process launch, wait some time before possible next try.
2160                 time.sleep(self.timeWaitNextLaunch)
2161                 with recording(self, trace) as sbuf:
2162                     print("Command '" + cmd + "' failed!", file=sbuf)
2163
2164         if check:
2165             output = ""
2166             if self.res.GetOutput():
2167                 output += "\nCommand output:\n" + self.res.GetOutput()
2168             if self.res.GetError():
2169                 output += "\nError output:\n" + self.res.GetError()
2170             if msg:
2171                 msg += output
2172             if cmd:
2173                 cmd += output
2174             self.assertTrue(self.res.Succeeded(),
2175                             msg if (msg) else CMD_MSG(cmd))
2176
2177     def match(
2178             self,
2179             str,
2180             patterns,
2181             msg=None,
2182             trace=False,
2183             error=False,
2184             matching=True,
2185             exe=True):
2186         """run command in str, and match the result against regexp in patterns returning the match object for the first matching pattern
2187
2188         Otherwise, all the arguments have the same meanings as for the expect function"""
2189
2190         trace = (True if traceAlways else trace)
2191
2192         if exe:
2193             # First run the command.  If we are expecting error, set check=False.
2194             # Pass the assert message along since it provides more semantic
2195             # info.
2196             self.runCmd(
2197                 str,
2198                 msg=msg,
2199                 trace=(
2200                     True if trace else False),
2201                 check=not error)
2202
2203             # Then compare the output against expected strings.
2204             output = self.res.GetError() if error else self.res.GetOutput()
2205
2206             # If error is True, the API client expects the command to fail!
2207             if error:
2208                 self.assertFalse(self.res.Succeeded(),
2209                                  "Command '" + str + "' is expected to fail!")
2210         else:
2211             # No execution required, just compare str against the golden input.
2212             output = str
2213             with recording(self, trace) as sbuf:
2214                 print("looking at:", output, file=sbuf)
2215
2216         # The heading says either "Expecting" or "Not expecting".
2217         heading = "Expecting" if matching else "Not expecting"
2218
2219         for pattern in patterns:
2220             # Match Objects always have a boolean value of True.
2221             match_object = re.search(pattern, output)
2222             matched = bool(match_object)
2223             with recording(self, trace) as sbuf:
2224                 print("%s pattern: %s" % (heading, pattern), file=sbuf)
2225                 print("Matched" if matched else "Not matched", file=sbuf)
2226             if matched:
2227                 break
2228
2229         self.assertTrue(matched if matching else not matched,
2230                         msg if msg else EXP_MSG(str, output, exe))
2231
2232         return match_object
2233
2234     def check_completion_with_desc(self, str_input, match_desc_pairs, enforce_order=False):
2235         """
2236         Checks that when the given input is completed at the given list of
2237         completions and descriptions is returned.
2238         :param str_input: The input that should be completed. The completion happens at the end of the string.
2239         :param match_desc_pairs: A list of pairs that indicate what completions have to be in the list of
2240                                  completions returned by LLDB. The first element of the pair is the completion
2241                                  string that LLDB should generate and the second element the description.
2242         :param enforce_order: True iff the order in which the completions are returned by LLDB
2243                               should match the order of the match_desc_pairs pairs.
2244         """
2245         interp = self.dbg.GetCommandInterpreter()
2246         match_strings = lldb.SBStringList()
2247         description_strings = lldb.SBStringList()
2248         num_matches = interp.HandleCompletionWithDescriptions(str_input, len(str_input), 0, -1, match_strings, description_strings)
2249         self.assertEqual(len(description_strings), len(match_strings))
2250
2251         # The index of the last matched description in description_strings or
2252         # -1 if no description has been matched yet.
2253         last_found_index = -1
2254         out_of_order_errors = ""
2255         missing_pairs = []
2256         for pair in match_desc_pairs:
2257             found_pair = False
2258             for i in range(num_matches + 1):
2259                 match_candidate = match_strings.GetStringAtIndex(i)
2260                 description_candidate = description_strings.GetStringAtIndex(i)
2261                 if match_candidate == pair[0] and description_candidate == pair[1]:
2262                     found_pair = True
2263                     if enforce_order and last_found_index > i:
2264                         new_err = ("Found completion " + pair[0] + " at index " +
2265                                   str(i) + " in returned completion list but " +
2266                                   "should have been after completion " +
2267                                   match_strings.GetStringAtIndex(last_found_index) +
2268                                   " (index:" + str(last_found_index) + ")\n")
2269                         out_of_order_errors += new_err
2270                     last_found_index = i
2271                     break
2272             if not found_pair:
2273                 missing_pairs.append(pair)
2274
2275         error_msg = ""
2276         got_failure = False
2277         if len(missing_pairs):
2278             got_failure = True
2279             error_msg += "Missing pairs:\n"
2280             for pair in missing_pairs:
2281                 error_msg += " [" + pair[0] + ":" + pair[1] + "]\n"
2282         if len(out_of_order_errors):
2283             got_failure = True
2284             error_msg += out_of_order_errors
2285         if got_failure:
2286             error_msg += "Got the following " + str(num_matches) + " completions back:\n"
2287             for i in range(num_matches + 1):
2288                 match_candidate = match_strings.GetStringAtIndex(i)
2289                 description_candidate = description_strings.GetStringAtIndex(i)
2290                 error_msg += "[" + match_candidate + ":" + description_candidate + "] index " + str(i) + "\n"
2291             self.assertFalse(got_failure, error_msg)
2292
2293     def complete_exactly(self, str_input, patterns):
2294         self.complete_from_to(str_input, patterns, True)
2295
2296     def complete_from_to(self, str_input, patterns, turn_off_re_match=False):
2297         """Test that the completion mechanism completes str_input to patterns,
2298         where patterns could be a pattern-string or a list of pattern-strings"""
2299         # Patterns should not be None in order to proceed.
2300         self.assertFalse(patterns is None)
2301         # And should be either a string or list of strings.  Check for list type
2302         # below, if not, make a list out of the singleton string.  If patterns
2303         # is not a string or not a list of strings, there'll be runtime errors
2304         # later on.
2305         if not isinstance(patterns, list):
2306             patterns = [patterns]
2307
2308         interp = self.dbg.GetCommandInterpreter()
2309         match_strings = lldb.SBStringList()
2310         num_matches = interp.HandleCompletion(str_input, len(str_input), 0, -1, match_strings)
2311         common_match = match_strings.GetStringAtIndex(0)
2312         if num_matches == 0:
2313             compare_string = str_input
2314         else:
2315             if common_match != None and len(common_match) > 0:
2316                 compare_string = str_input + common_match
2317             else:
2318                 compare_string = ""
2319                 for idx in range(1, num_matches+1):
2320                     compare_string += match_strings.GetStringAtIndex(idx) + "\n"
2321
2322         for p in patterns:
2323             if turn_off_re_match:
2324                 self.expect(
2325                     compare_string, msg=COMPLETION_MSG(
2326                         str_input, p, match_strings), exe=False, substrs=[p])
2327             else:
2328                 self.expect(
2329                     compare_string, msg=COMPLETION_MSG(
2330                         str_input, p, match_strings), exe=False, patterns=[p])
2331
2332     def completions_match(self, command, completions):
2333         """Checks that the completions for the given command are equal to the
2334         given list of completions"""
2335         interp = self.dbg.GetCommandInterpreter()
2336         match_strings = lldb.SBStringList()
2337         interp.HandleCompletion(command, len(command), 0, -1, match_strings)
2338         # match_strings is a 1-indexed list, so we have to slice...
2339         self.assertItemsEqual(completions, list(match_strings)[1:],
2340                               "List of returned completion is wrong")
2341
2342     def completions_contain(self, command, completions):
2343         """Checks that the completions for the given command contain the given
2344         list of completions."""
2345         interp = self.dbg.GetCommandInterpreter()
2346         match_strings = lldb.SBStringList()
2347         interp.HandleCompletion(command, len(command), 0, -1, match_strings)
2348         for completion in completions:
2349             # match_strings is a 1-indexed list, so we have to slice...
2350             self.assertIn(completion, list(match_strings)[1:],
2351                           "Couldn't find expected completion")
2352
2353     def filecheck(
2354             self,
2355             command,
2356             check_file,
2357             filecheck_options = '',
2358             expect_cmd_failure = False):
2359         # Run the command.
2360         self.runCmd(
2361                 command,
2362                 check=(not expect_cmd_failure),
2363                 msg="FileCheck'ing result of `{0}`".format(command))
2364
2365         self.assertTrue((not expect_cmd_failure) == self.res.Succeeded())
2366
2367         # Get the error text if there was an error, and the regular text if not.
2368         output = self.res.GetOutput() if self.res.Succeeded() \
2369                 else self.res.GetError()
2370
2371         # Assemble the absolute path to the check file. As a convenience for
2372         # LLDB inline tests, assume that the check file is a relative path to
2373         # a file within the inline test directory.
2374         if check_file.endswith('.pyc'):
2375             check_file = check_file[:-1]
2376         check_file_abs = os.path.abspath(check_file)
2377
2378         # Run FileCheck.
2379         filecheck_bin = configuration.get_filecheck_path()
2380         if not filecheck_bin:
2381             self.assertTrue(False, "No valid FileCheck executable specified")
2382         filecheck_args = [filecheck_bin, check_file_abs]
2383         if filecheck_options:
2384             filecheck_args.append(filecheck_options)
2385         subproc = Popen(filecheck_args, stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines = True)
2386         cmd_stdout, cmd_stderr = subproc.communicate(input=output)
2387         cmd_status = subproc.returncode
2388
2389         filecheck_cmd = " ".join(filecheck_args)
2390         filecheck_trace = """
2391 --- FileCheck trace (code={0}) ---
2392 {1}
2393
2394 FileCheck input:
2395 {2}
2396
2397 FileCheck output:
2398 {3}
2399 {4}
2400 """.format(cmd_status, filecheck_cmd, output, cmd_stdout, cmd_stderr)
2401
2402         trace = cmd_status != 0 or traceAlways
2403         with recording(self, trace) as sbuf:
2404             print(filecheck_trace, file=sbuf)
2405
2406         self.assertTrue(cmd_status == 0)
2407
2408     def expect(
2409             self,
2410             str,
2411             msg=None,
2412             patterns=None,
2413             startstr=None,
2414             endstr=None,
2415             substrs=None,
2416             trace=False,
2417             error=False,
2418             ordered=True,
2419             matching=True,
2420             exe=True,
2421             inHistory=False):
2422         """
2423         Similar to runCmd; with additional expect style output matching ability.
2424
2425         Ask the command interpreter to handle the command and then check its
2426         return status.  The 'msg' parameter specifies an informational assert
2427         message.  We expect the output from running the command to start with
2428         'startstr', matches the substrings contained in 'substrs', and regexp
2429         matches the patterns contained in 'patterns'.
2430
2431         When matching is true and ordered is true, which are both the default,
2432         the strings in the substrs array have to appear in the command output
2433         in the order in which they appear in the array.
2434
2435         If the keyword argument error is set to True, it signifies that the API
2436         client is expecting the command to fail.  In this case, the error stream
2437         from running the command is retrieved and compared against the golden
2438         input, instead.
2439
2440         If the keyword argument matching is set to False, it signifies that the API
2441         client is expecting the output of the command not to match the golden
2442         input.
2443
2444         Finally, the required argument 'str' represents the lldb command to be
2445         sent to the command interpreter.  In case the keyword argument 'exe' is
2446         set to False, the 'str' is treated as a string to be matched/not-matched
2447         against the golden input.
2448         """
2449         # Catch cases where `expect` has been miscalled. Specifically, prevent
2450         # this easy to make mistake:
2451         #     self.expect("lldb command", "some substr")
2452         # The `msg` parameter is used only when a failed match occurs. A failed
2453         # match can only occur when one of `patterns`, `startstr`, `endstr`, or
2454         # `substrs` has been given. Thus, if a `msg` is given, it's an error to
2455         # not also provide one of the matcher parameters.
2456         if msg and not (patterns or startstr or endstr or substrs or error):
2457             assert False, "expect() missing a matcher argument"
2458
2459         # Check `patterns` and `substrs` are not accidentally given as strings.
2460         assert not isinstance(patterns, six.string_types), \
2461             "patterns must be a collection of strings"
2462         assert not isinstance(substrs, six.string_types), \
2463             "substrs must be a collection of strings"
2464
2465         trace = (True if traceAlways else trace)
2466
2467         if exe:
2468             # First run the command.  If we are expecting error, set check=False.
2469             # Pass the assert message along since it provides more semantic
2470             # info.
2471             self.runCmd(
2472                 str,
2473                 msg=msg,
2474                 trace=(
2475                     True if trace else False),
2476                 check=not error,
2477                 inHistory=inHistory)
2478
2479             # Then compare the output against expected strings.
2480             output = self.res.GetError() if error else self.res.GetOutput()
2481
2482             # If error is True, the API client expects the command to fail!
2483             if error:
2484                 self.assertFalse(self.res.Succeeded(),
2485                                  "Command '" + str + "' is expected to fail!")
2486         else:
2487             # No execution required, just compare str against the golden input.
2488             if isinstance(str, lldb.SBCommandReturnObject):
2489                 output = str.GetOutput()
2490             else:
2491                 output = str
2492             with recording(self, trace) as sbuf:
2493                 print("looking at:", output, file=sbuf)
2494
2495         expecting_str = "Expecting" if matching else "Not expecting"
2496         def found_str(matched):
2497             return "was found" if matched else "was not found"
2498
2499         # To be used as assert fail message and/or trace content
2500         log_lines = [
2501                 "{}:".format("Ran command" if exe else "Checking string"),
2502                 "\"{}\"".format(str),
2503                 # Space out command and output
2504                 "",
2505         ]
2506         if exe:
2507             # Newline before output to make large strings more readable
2508             log_lines.append("Got output:\n{}".format(output))
2509
2510         # Assume that we start matched if we want a match
2511         # Meaning if you have no conditions, matching or
2512         # not matching will always pass
2513         matched = matching
2514
2515         # We will stop checking on first failure
2516         if startstr:
2517             matched = output.startswith(startstr)
2518             log_lines.append("{} start string: \"{}\" ({})".format(
2519                     expecting_str, startstr, found_str(matched)))
2520
2521         if endstr and matched == matching:
2522             matched = output.endswith(endstr)
2523             log_lines.append("{} end string: \"{}\" ({})".format(
2524                     expecting_str, endstr, found_str(matched)))
2525
2526         if substrs and matched == matching:
2527             start = 0
2528             for substr in substrs:
2529                 index = output[start:].find(substr)
2530                 start = start + index if ordered and matching else 0
2531                 matched = index != -1
2532                 log_lines.append("{} sub string: \"{}\" ({})".format(
2533                         expecting_str, substr, found_str(matched)))
2534
2535                 if matched != matching:
2536                     break
2537
2538         if patterns and matched == matching:
2539             for pattern in patterns:
2540                 matched = re.search(pattern, output)
2541
2542                 pattern_line = "{} regex pattern: \"{}\" ({}".format(
2543                         expecting_str, pattern, found_str(matched))
2544                 if matched:
2545                     pattern_line += ", matched \"{}\"".format(
2546                             matched.group(0))
2547                 pattern_line += ")"
2548                 log_lines.append(pattern_line)
2549
2550                 # Convert to bool because match objects
2551                 # are True-ish but != True itself
2552                 matched = bool(matched)
2553                 if matched != matching:
2554                     break
2555
2556         # If a check failed, add any extra assert message
2557         if msg is not None and matched != matching:
2558             log_lines.append(msg)
2559
2560         log_msg = "\n".join(log_lines)
2561         with recording(self, trace) as sbuf:
2562             print(log_msg, file=sbuf)
2563         if matched != matching:
2564             self.fail(log_msg)
2565
2566     def expect_expr(
2567             self,
2568             expr,
2569             result_summary=None,
2570             result_value=None,
2571             result_type=None,
2572             result_children=None
2573             ):
2574         """
2575         Evaluates the given expression and verifies the result.
2576         :param expr: The expression as a string.
2577         :param result_summary: The summary that the expression should have. None if the summary should not be checked.
2578         :param result_value: The value that the expression should have. None if the value should not be checked.
2579         :param result_type: The type that the expression result should have. None if the type should not be checked.
2580         :param result_children: The expected children of the expression result
2581                                 as a list of ValueChecks. None if the children shouldn't be checked.
2582         """
2583         self.assertTrue(expr.strip() == expr, "Expression contains trailing/leading whitespace: '" + expr + "'")
2584
2585         frame = self.frame()
2586         options = lldb.SBExpressionOptions()
2587
2588         # Disable fix-its that tests don't pass by accident.
2589         options.SetAutoApplyFixIts(False)
2590
2591         # Set the usual default options for normal expressions.
2592         options.SetIgnoreBreakpoints(True)
2593
2594         if self.frame().IsValid():
2595             options.SetLanguage(frame.GuessLanguage())
2596             eval_result = self.frame().EvaluateExpression(expr, options)
2597         else:
2598             target = self.target()
2599             # If there is no selected target, run the expression in the dummy
2600             # target.
2601             if not target.IsValid():
2602                 target = self.dbg.GetDummyTarget()
2603             eval_result = target.EvaluateExpression(expr, options)
2604
2605         value_check = ValueCheck(type=result_type, value=result_value,
2606                                  summary=result_summary, children=result_children)
2607         value_check.check_value(self, eval_result, str(eval_result))
2608         return eval_result
2609
2610     def invoke(self, obj, name, trace=False):
2611         """Use reflection to call a method dynamically with no argument."""
2612         trace = (True if traceAlways else trace)
2613
2614         method = getattr(obj, name)
2615         import inspect
2616         self.assertTrue(inspect.ismethod(method),
2617                         name + "is a method name of object: " + str(obj))
2618         result = method()
2619         with recording(self, trace) as sbuf:
2620             print(str(method) + ":", result, file=sbuf)
2621         return result
2622
2623     def build(
2624             self,
2625             architecture=None,
2626             compiler=None,
2627             dictionary=None):
2628         """Platform specific way to build the default binaries."""
2629         module = builder_module()
2630
2631         if not architecture and configuration.arch:
2632             architecture = configuration.arch
2633
2634         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
2635         if self.getDebugInfo() is None:
2636             return self.buildDefault(architecture, compiler, dictionary)
2637         elif self.getDebugInfo() == "dsym":
2638             return self.buildDsym(architecture, compiler, dictionary)
2639         elif self.getDebugInfo() == "dwarf":
2640             return self.buildDwarf(architecture, compiler, dictionary)
2641         elif self.getDebugInfo() == "dwo":
2642             return self.buildDwo(architecture, compiler, dictionary)
2643         elif self.getDebugInfo() == "gmodules":
2644             return self.buildGModules(architecture, compiler, dictionary)
2645         elif self.getDebugInfo() == "dwz":
2646             return self.buildDWZ(architecture, compiler, dictionary)
2647         else:
2648             self.fail("Can't build for debug info: %s" % self.getDebugInfo())
2649
2650     def run_platform_command(self, cmd):
2651         platform = self.dbg.GetSelectedPlatform()
2652         shell_command = lldb.SBPlatformShellCommand(cmd)
2653         err = platform.Run(shell_command)
2654         return (err, shell_command.GetStatus(), shell_command.GetOutput())
2655
2656     """Assert that an lldb.SBError is in the "success" state."""
2657     def assertSuccess(self, obj, msg=None):
2658         if not obj.Success():
2659             error = obj.GetCString()
2660             self.fail(self._formatMessage(msg,
2661                 "'{}' is not success".format(error)))
2662
2663     # =================================================
2664     # Misc. helper methods for debugging test execution
2665     # =================================================
2666
2667     def DebugSBValue(self, val):
2668         """Debug print a SBValue object, if traceAlways is True."""
2669         from .lldbutil import value_type_to_str
2670
2671         if not traceAlways:
2672             return
2673
2674         err = sys.stderr
2675         err.write(val.GetName() + ":\n")
2676         err.write('\t' + "TypeName         -> " + val.GetTypeName() + '\n')
2677         err.write('\t' + "ByteSize         -> " +
2678                   str(val.GetByteSize()) + '\n')
2679         err.write('\t' + "NumChildren      -> " +
2680                   str(val.GetNumChildren()) + '\n')
2681         err.write('\t' + "Value            -> " + str(val.GetValue()) + '\n')
2682         err.write('\t' + "ValueAsUnsigned  -> " +
2683                   str(val.GetValueAsUnsigned()) + '\n')
2684         err.write(
2685             '\t' +
2686             "ValueType        -> " +
2687             value_type_to_str(
2688                 val.GetValueType()) +
2689             '\n')
2690         err.write('\t' + "Summary          -> " + str(val.GetSummary()) + '\n')
2691         err.write('\t' + "IsPointerType    -> " +
2692                   str(val.TypeIsPointerType()) + '\n')
2693         err.write('\t' + "Location         -> " + val.GetLocation() + '\n')
2694
2695     def DebugSBType(self, type):
2696         """Debug print a SBType object, if traceAlways is True."""
2697         if not traceAlways:
2698             return
2699
2700         err = sys.stderr
2701         err.write(type.GetName() + ":\n")
2702         err.write('\t' + "ByteSize        -> " +
2703                   str(type.GetByteSize()) + '\n')
2704         err.write('\t' + "IsPointerType   -> " +
2705                   str(type.IsPointerType()) + '\n')
2706         err.write('\t' + "IsReferenceType -> " +
2707                   str(type.IsReferenceType()) + '\n')
2708
2709     def DebugPExpect(self, child):
2710         """Debug the spwaned pexpect object."""
2711         if not traceAlways:
2712             return
2713
2714         print(child)
2715
2716     @classmethod
2717     def RemoveTempFile(cls, file):
2718         if os.path.exists(file):
2719             remove_file(file)
2720
2721 # On Windows, the first attempt to delete a recently-touched file can fail
2722 # because of a race with antimalware scanners.  This function will detect a
2723 # failure and retry.
2724
2725
2726 def remove_file(file, num_retries=1, sleep_duration=0.5):
2727     for i in range(num_retries + 1):
2728         try:
2729             os.remove(file)
2730             return True
2731         except:
2732             time.sleep(sleep_duration)
2733             continue
2734     return False