Compile the LLDB tests out-of-tree

[aprantl]

Summary

This patch is the result of a discussion on lldb-dev, see http://lists.llvm.org/pipermail/lldb-dev/2018-January/013111.html for background.

This is a first sketch of how to move building of the testcases in the LLDB testsuite out of the source tree. The patch is buggy and incomplete, but I would like to develop this as much in the open as possible to solicit early feedback in case I'm unwittingly cutting any corners that will break somebody's platform.

For each test (should be eventually: each test configuration) a separate build directory is created and we execute make VPATH=$srcdir/path/to/test -C $builddir/path/to/test -f $srcdir/path/to/test/Makefile -I $srcdir/path/to/test.

In order to make this work all LLDB tests need to be updated to find the executable in the test build directory, since CWD still points at the test's source directory, which is a requirement for unittest2. That patch is very boring and therefore outsourced to https://reviews.llvm.org/D42280 to make this review easier to read.

[zturner]

packages/Python/lldbsuite/test/dotest.py

625

Here this has the possibility of setting os.environ["LLDB_BUILD"] = None. Is this desired?

1193

Nothing appears to use orig_working_dir, and we never set a new working directory anyway, so it doesn't seem necessary to save the original working directory. Can this line be removed?

1198

This relates to the environment variable comment earlier. The code that sets the environment variable gets run before this. So that could set the environment variable to None, and then this code could set configuration.test_build_dir to something valid. It seems to me like we should ensure that the environment variable always gets set to *something*, then the multiprocessing children can just assume it has a valid value.

packages/Python/lldbsuite/test/lldbtest.py

2246

Related to previous comments about the environment variable, can we just assume the variable is set here?

packages/Python/lldbsuite/test/plugins/builder_base.py

53

Can you call this maybe test_subdir or something, and update the docstring to indicate what it actually is?

62

Related to my previous comment about environment variables, but you are assuming it exists here, so it does seem like we can assume it exists in the other codepath too.

216

Can this be deleted?

[labath]

I like the direction this is going in. When looking at this, it occurred to me some of our tests do recursive make invocations, generally to build shared libraries (TestConflictingSymbol is a good example). The $(MAKE) line in those may need to be fixed somehow.

packages/Python/lldbsuite/test/dotest.py

1195

Can we just not specify the mode and let user's umask do the selection. That's the standard behaviour of all unix tools.

packages/Python/lldbsuite/test/plugins/builder_base.py

69

I like this trick. :)
Originally, I was afraid we'd have to copy the Makefile to the build folder or something...

[clayborg]

Looks like a good start. It might be nice to validate that after "clean" that we have no files that are untracked in the test directory? This could help us to verify that we don't leave artifacts around.

packages/Python/lldbsuite/test/dotest_args.py

166

Maybe add a default right here?:

default=os.getcwd()

[aprantl]

In D42281#981969, @clayborg wrote:

Looks like a good start. It might be nice to validate that after "clean" that we have no files that are untracked in the test directory? This could help us to verify that we don't leave artifacts around.

My idea was actually to remove the requirement that Makefiles have to implement a functional clean: rule, since we now can clean by merely wiping --build-dir. What do you think about that?

[davide]

In D42281#981973, @aprantl wrote:

In D42281#981969, @clayborg wrote:

Looks like a good start. It might be nice to validate that after "clean" that we have no files that are untracked in the test directory? This could help us to verify that we don't leave artifacts around.

My idea was actually to remove the requirement that Makefiles have to implement a functional clean: rule, since we now can clean by merely wiping --build-dir. What do you think about that?

I think that's a much more robust solution. We had a bunch of issues with clean in the past.

[davide]

This looks like a decent way of going forward, I'm a little concerned about swallowing an error, see comment inline.

packages/Python/lldbsuite/test/dotest.py

1196

should we actually print some warning here? (e.g. directory blah/ already exists?)

[aprantl]

Updating with my current work in progress to show that some progress is being made.
Note that this does not yet address everybody's feedback.

It's currently standing at

Failure:              69
Error:               189

and I'm slowly working through the remaining tests to see why they fail.

[aprantl]

packages/Python/lldbsuite/test/dotest_args.py

166

The default is in dotest.py:474. Let me know if this file is the more appropriate place for it.

[aprantl]

This is starting to look manageable.

Failure:              30
Error:               113

[aprantl]

Time for another status update:

===================
Test Result Summary
===================
Test Methods:       2694
Reruns:                0
Success:            2213
Expected Failure:     89
Failure:              22
Error:                29
Exceptional Exit:      0
Unexpected Success:   12
Skip:                329
Timeout:               0
Expected Timeout:      0

[aprantl]

This version actually passes all tests on Darwin. Time to give this a thorough review now!
@zturner: Would you be able to give this a try on Windows and let me know if there are any big problems that I overlooked?

thanks!

[jingham]

This looks good to me. I think it would be cleaner if there were a getSourceFileSpec equivalent to getBuildArtifact.

I had a few inline trivial questions.

Also, before you forget all the things you had to do, you need to write down the new rules in the README.testsuite. Might also be good to put a brief note in the sample_test testcases, since I imagine folks are just going to copy that and put it somewhere to make new tests, so reminding them there might not be a bad idea.

packages/Python/lldbsuite/test/api/check_public_api_headers/TestPublicAPIHeaders.py

46

Why do you have to call getBuildArtifact on the main source file?

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/TestBreakpointSetRestart.py

34–35

This is beginning to show up a bunch. Maybe TestBase should have:

def getSourceFileSpec( filename):
  fileSpec = lldb.SBFileSpec()
  fileSpec.SetDirectory(self.getSourceDir())
  fileSpec.SetFilename(filename)
  return fileSpec

packages/Python/lldbsuite/test/functionalities/exec/TestExec.py

47–49

Maybe also a TestBase getSourcePath(filename) that returns a string? That might be easier to read.

packages/Python/lldbsuite/test/plugins/builder_base.py

224–232

Probably can delete this now...

packages/Python/lldbsuite/test/types/AbstractBase.py

37–38

Why isn't this getBuildArtifact("golden-output.txt")?

[labath]

I've created D42572 with the fixups necessary to make this run on linux. It's way smaller than I expected we would need -- I basically fixed one typo and corrected for some shared library weirdness. Can you apply that on top of your CL?

I'll try to take a closer look at the actual changes on monday, but the changes seem mostly straight-forward.

I do have one request though: Could we make the default value for the test build folder a subfolder of the current directory? Right now if you run dotest from a directory containing some interesting stuff, it will pollute it with a bunch of subfolders and it can be hard to clean it up afterwards. If it was a subfolder with a recognisable name, I could just nuke it and be done with it.

[aprantl]

• incorporate pavel's Linux patch
• default the builddir to $PWD/lldb-test-build

[aprantl]

Address Jim's comments.

[aprantl]

packages/Python/lldbsuite/test/api/check_public_api_headers/TestPublicAPIHeaders.py

46

Because this test uses a generated source file, so it's in the build directory. I added a comment.

packages/Python/lldbsuite/test/dotest.py

1196

This the top-level build directory. In a cmake build it is expected to exist, but on the command line when running only a single test, you might want to pass a something like /tmp/mytest there.

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/TestBreakpointSetRestart.py

34–35

It is redundant. LLDB finds the file just fine with a relative FileSpec. I removed it.

[aprantl]

I am now working on building each test variant (dwarf,dwo,dsym,...) in its own build directory so they can run in parallel and we can get rid of the lockfile. While doing this I discovered that certain tests (e.g., TestPublicAPIHeaders.py, the MI tests) are invoking buildDefault() in the setUp() method. From what I can tell it looks like these tests build only whatever variant the Makefile produces by default, but they still run the tests for each variant. I'm not yet sure how to best fix this.

[aprantl]

I found the mechanism I was looking for. Generic testcases set
NO_DEBUG_INFO_TESTCASE = True

[labath]

In D42281#989793, @aprantl wrote:

I am now working on building each test variant (dwarf,dwo,dsym,...) in its own build directory so they can run in parallel and we can get rid of the lockfile.

Are you planning to merge that into this patch? I am hoping that can be done in a separate pass, once dust settles down from landing this batch.

I think this is in a pretty good shape now, and we should land it soon. The only thing i'd like to wait for is confirmation that this runs on windows (i.e. does not run into any fundamental make limitations on that platform). I'm going to see if I can get around to that today.

packages/Python/lldbsuite/test/functionalities/exec/TestExec.py

47–48

s/Sourc/Source/

packages/Python/lldbsuite/test/plugins/builder_base.py

66

delete

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

5139–5142

I think it makes sense to separate the single change in actual code from the gigantuous code refactor.

[labath]

I haven't gotten around to trying this out on windows yet, but I have tried running the tests remotely. I've updated D42572 with the two fixes necessary to make the remote tests pass (for android).

[aprantl]

In D42281#990296, @labath wrote:

In D42281#989793, @aprantl wrote:

I am now working on building each test variant (dwarf,dwo,dsym,...) in its own build directory so they can run in parallel and we can get rid of the lockfile.

Are you planning to merge that into this patch? I am hoping that can be done in a separate pass, once dust settles down from landing this batch.

I think this is in a pretty good shape now, and we should land it soon. The only thing i'd like to wait for is confirmation that this runs on windows (i.e. does not run into any fundamental make limitations on that platform). I'm going to see if I can get around to that today.

Sure that makes total sense. "Smaller" patches are always better. I'm mostly waiting for someone to greenlight Windows now.

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

5139–5142

Oh right. This is an actual bug that I found because my refactoring of makefiles happened to change the relative order of dylibs in the Mach-O headers.

[aprantl]

I think I now have addressed everybody's review comments.

[labath]

Right, so I tried this out on windows today (targetting android, because I know the state of that target, but I think this should catch problems with windows host builds as well). The main problem i ran into is that $(realpath) is just broken on windows -- in case the input path is already an absolute path it will just produce nonsensical values. I guess it worked before because MAKEFILE_LIST was relative, but with the new invocation, the variable contains absolute paths. However, I think this means we don't have to call realpath, so I suggest we just drop it.

The other problem was lack of mkdir -p functionality. Even though I have a gnuwin32 mkdir on my PATH (which supports the -p switch), make will execute the command through cmd.exe, which means the built-in mkdir will fire first (and blow up). The simplest solution for this I could come up with is to offload the mkdir functionality to python. I'm not sure I've caught all of the issues, but I think the rest of them can be handled incrementally.

I've uploaded the changes I made to D42572 (it also contains my previous batch of remote testing fixes). In case you agree with them, I say "let's ship it" before the patch starts rotting.

[aprantl]

Let's see how this fares on the bots. As I mentioned in the commit message, please don't hesitate to revert this patch. I'm watching all bots connected to lab.llvm.org, and green.lab.llvm.org but please let me know if I'm missing something.

[aprantl]

There are a few test failures, but they look manageable. I will need help resolving them though:

http://lab.llvm.org:8011/builders/lldb-windows7-android/builds/7843
FAIL: TestLoadUnload.LoadUnloadTestCase.test_lldb_process_load_and_unload_commands_dwarf

http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-android/builds/10506
test7 emulator-5554,i686-linux-android-clang,i386,abstract,-lldb-mi failed

[aprantl]

In D42281#992295, @aprantl wrote:

There are a few test failures, but they look manageable. I will need help resolving them though:

Updated list:

http://lab.llvm.org:8011/builders/lldb-windows7-android/builds/7843
FAIL: TestLoadUnload.LoadUnloadTestCase.test_lldb_process_load_and_unload_commands_dwarf
test3 HT4A1JT02945,aarch64-linux-android-clang,aarch64,tcp,-lldb-mi 8 unexpected failures failed ( 41 mins, 48 secs )
stdio
FAIL: TestBreakpointInGlobalConstructor.TestBreakpointInGlobalConstructors.test
FAIL: TestMoveNearest.TestMoveNearest.test
FAIL: TestGlobalVariables.GlobalVariablesTestCase.test_c_global_variables_dwarf
FAIL: TestGlobalVariables.GlobalVariablesTestCase.test_c_global_variables_dwo
FAIL: TestGlobalVariables.GlobalVariablesTestCase.test_c_global_variables_gmodules
FAIL: TestLoadUnload.LoadUnloadTestCase.test_lldb_process_load_and_unload_commands_dwarf
FAIL: TestLoadUnload.LoadUnloadTestCase.test_lldb_process_load_and_unload_commands_dwo
FAIL: TestLoadUnload.LoadUnloadTestCase.test_lldb_process_load_and_unload_commands_gmodules

http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-android/builds/10506
test7 emulator-5554,i686-linux-android-clang,i386,abstract,-lldb-mi failed

http://lab.llvm.org:8011/builders/lldb-x86_64-darwin-13.4/builds/8462
test2 5A24000830,aarch64-linux-android-gcc,aarch64,tcp,-lldb-mi:-watchpoint 2 unexpected failures failed
FAIL: TestMoveNearest.TestMoveNearest.test
FAIL: TestBreakpointInGlobalConstructor.TestBreakpointInGlobalConstructors.test

[labath]

In D42281#992359, @aprantl wrote:

In D42281#992295, @aprantl wrote:

There are a few test failures, but they look manageable. I will need help resolving them though:

Updated list:

http://lab.llvm.org:8011/builders/lldb-windows7-android/builds/7843
FAIL: TestLoadUnload.LoadUnloadTestCase.test_lldb_process_load_and_unload_commands_dwarf
test3 HT4A1JT02945,aarch64-linux-android-clang,aarch64,tcp,-lldb-mi 8 unexpected failures failed ( 41 mins, 48 secs )
stdio
FAIL: TestBreakpointInGlobalConstructor.TestBreakpointInGlobalConstructors.test
FAIL: TestMoveNearest.TestMoveNearest.test
FAIL: TestGlobalVariables.GlobalVariablesTestCase.test_c_global_variables_dwarf
FAIL: TestGlobalVariables.GlobalVariablesTestCase.test_c_global_variables_dwo
FAIL: TestGlobalVariables.GlobalVariablesTestCase.test_c_global_variables_gmodules
FAIL: TestLoadUnload.LoadUnloadTestCase.test_lldb_process_load_and_unload_commands_dwarf
FAIL: TestLoadUnload.LoadUnloadTestCase.test_lldb_process_load_and_unload_commands_dwo
FAIL: TestLoadUnload.LoadUnloadTestCase.test_lldb_process_load_and_unload_commands_gmodules

http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-android/builds/10506
test7 emulator-5554,i686-linux-android-clang,i386,abstract,-lldb-mi failed

http://lab.llvm.org:8011/builders/lldb-x86_64-darwin-13.4/builds/8462
test2 5A24000830,aarch64-linux-android-gcc,aarch64,tcp,-lldb-mi:-watchpoint 2 unexpected failures failed
FAIL: TestMoveNearest.TestMoveNearest.test
FAIL: TestBreakpointInGlobalConstructor.TestBreakpointInGlobalConstructors.test

Most of these turned out to be caused by leftover shared libraries in the source tree (fun fact: "svn status" refuses to list the .so files even though they are not present in the svn:ignore list), when I cleaned those up, the tests started passing again.

There is still the TestLoadUnload failure on the windows bot, which I suspect to be a real issue (we've changed the test a bit, and now it passes full paths to lldb, so I suspect a directory-separator issue), but I have not looked into that yet. I'll handle that on our side in the coming days.

All in all, I would say this was rather a painless experience. I think we are ready for phase two.

[aprantl]

Thanks a lot for your help, Pavel!

We also discovered the most amazing test failure on the green dragon bots yesterday (fix still underway) that was made much worse by my patch.
On Darwin LLDB automatically tries to find a .dSYM bundle for an executable by querying the Spotlight index for the executable's UUID. Because the UUID is a hash of filename and .text section, and the testsuite compiles many short hello-world-style files, all alike, and named a.out, two tests can have the same UUID and LLDB then sometimes picks up debug info from a .dSYM that belongs to different testcase! We are working on a mechanism to disable the UUID lookup inside the testsuite.

docs/testsuite/a-detailed-walkthrough.txt

 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     def test_with_dsym_and_run_command(self):
         """Test 'frame variable var_name' on some variables with array types."""
         self.buildDsym()
         self.array_types()
 
 This method is decorated with a skipUnless decorator so that it will only gets
-included into the test suite if the platform it is running on is 'darwin', aka
-Mac OS X.
+included into the test suite if the platform it is running on is 'darwin', a.k.a.
+macOS.
 
 Type 'man dsymutil' for more details. 
 
 After the binary is built, it is time to specify the file to be used as the main
 executable by lldb:
 
-        exe = os.path.join(os.getcwd(), "a.out")
+        # Construct the path to a file "a.out" inside the test's build folder.
+        exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
 This is where the attribute assignment:
 
 class SettingsCommandTestCase(TestBase):
 
     mydir = "settings"
 

 
 There are cases when we don't care about the return status from the command
 execution.  This can be accomplished by passing the keyword argument pair
 'check=False' to the method.
 
 After the current executable is set, we'll then execute two more commands:
 
         # Set the output-path and verify it is set.
-        self.runCmd("settings set target.process.output-path 'stdout.txt'")
+        stdout = self.getBuildArtifact('stdout.txt')
+        self.runCmd("settings set target.process.output-path '%s'" %stdout)
         self.expect("settings show target.process.output-path",
                     SETTING_MSG("target.process.output-path"),
-            startstr = "target.process.output-path (string) = 'stdout.txt'")
+            startstr = "target.process.output-path (string) = '.*stdout.txt'")
 
 The first uses the 'settings set' command to set the static setting
 target.process.output-path to be 'stdout.txt', instead of the default
 '/dev/stdout'.  We then immediately issue a 'settings show' command to check
 that, indeed, the setting did take place.  Notice that we use a new method
 expect() to accomplish the task, which in effect issues a runCmd() behind the
 door and grabs the output from the command execution and expects to match the
 start string of the output against what we pass in as the value of the keyword
 argument pair:
 
-            startstr = "target.process.output-path (string) = 'stdout.txt'"
+            startstr = "target.process.output-path (string) = '%s'" %stdout
 
 Take a look at TestBase.expect() within lldbtest.py for more details.  Among
 other things, it can also match against a list of regexp patterns as well as a
 list of sub strings.  And it can also perform negative matching, i.e., instead
 of expecting something from the output of command execution, it can perform the
 action of 'not expecting' something.
 
 This will launch/run the program:
 
         self.runCmd("run", RUN_SUCCEEDED)
 
 And this asserts that the file 'stdout.txt' should be present after running the
 program.
 
         # The 'stdout.txt' file should now exist.
-        self.assertTrue(os.path.isfile("stdout.txt"),
-                        "'stdout.txt' exists due to target.process.output-path.")
+        self.assertTrue(os.path.isfile(stdout),
+                        "stdout.txt' exists due to target.process.output-path.")
 
 Also take a look at main.cpp which emits some message to the stdout.  Now, if we
 pass this assertion, it's time to examine the contents of the file to make sure
 it contains the same message as programmed in main.cpp:
 
         # Read the output file produced by running the program.
-        with open('stdout.txt', 'r') as f:
+        with open(stdout, 'r') as f:
             output = f.read()
 
         self.expect(output, exe=False,
             startstr = "This message should go to standard out.")
 
 We open the file and read its contents into output, then issue an expect()
 method.  The 'exe=False' keyword argument pair tells expect() that don't try to
 execute the first arg as a command at all.  Instead, treat it as a string to
 match against whatever is thrown in as keyword argument pairs!
 
 There are also other test methods present in the TestSettings.py mode:
 test_set_prompt(), test_set_term_width(), test_set_auto_confirm(),
 test_with_dsym(), and test_with_dwarf().  We are using the default test loader
 from unittest framework, which uses the 'test' method name prefix to identify
 test methods automatically.
 
 This finishes the walkthrough of the test method test_set_output_path(self).
 Before we say goodbye, notice the little method definition at the top of the
 file:
 
     @classmethod
     def classCleanup(cls):
-        system(["/bin/sh", "-c", "rm -f output.txt"])
-        system(["/bin/sh", "-c", "rm -f stdout.txt"])
+        system(["/bin/sh", "-c", "rm -f "+self.getBuildArtifact("output.txt")])
+        system(["/bin/sh", "-c", "rm -f "+self.getBuildArtifact("stdout.txt")])
 
 This is a classmethod (as shown by the @classmethod decorator) which allows the
 individual test class to perform cleanup actions after the test harness finishes
 with the particular test class.  This is part of the so-called test fixture in
 the unittest framework.  From http://docs.python.org/library/unittest.html:
 
 A test fixture represents the preparation needed to perform one or more tests,
 and any associate cleanup actions. This may involve, for example, creating

packages/Python/lldbsuite/test/api/check_public_api_headers/TestPublicAPIHeaders.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class SBDirCheckerCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         TestBase.setUp(self)
         self.source = 'main.cpp'
-        self.exe_name = self.getBuildArtifact("a.out")
         self.generateSource(self.source)
 
     @skipIfNoSBHeaders
     def test_sb_api_directory(self):
         """Test the SB API directory and make sure there's no unwanted stuff."""
 
         # Only proceed if this is an Apple OS, "x86_64", and local platform.
         if not (self.platformIsDarwin() and self.getArchitecture() == "x86_64"):
             self.skipTest("This test is only for LLDB.framework built 64-bit")
         if self.getArchitecture() == "i386":
             self.skipTest(
                 "LLDB is 64-bit and cannot be linked to 32-bit test program.")
 
-        self.buildDriver(self.source, self.exe_name)
-        self.sanity_check_executable(self.exe_name)
+        exe_name = self.getBuildArtifact("a.out")
+        self.buildDriver(self.source, exe_name)
+        self.sanity_check_executable(exe_name)
 
     def sanity_check_executable(self, exe_name):
         """Sanity check executable compiled from the auto-generated program."""
+        exe_name = self.getBuildArtifact("a.out")
         exe = self.getBuildArtifact(exe_name)
         self.runCmd("file %s" % exe, CURRENT_EXECUTABLE_SET)
 
+        # This test uses a generated source file, so it's in the build directory.
         self.line_to_break = line_number(
-            self.source, '// Set breakpoint here.')
+            self.getBuildArtifact(self.source), '// Set breakpoint here.')
 
         env_cmd = "settings set target.env-vars %s=%s" % (
             self.dylibPath, self.getLLDBLibraryEnvVal())
         if self.TraceOn():
             print("Set environment to: ", env_cmd)
         self.runCmd(env_cmd)
         self.addTearDownHook(
             lambda: self.dbg.HandleCommand(

packages/Python/lldbsuite/test/api/multiple-debuggers/TestMultipleDebuggers.py

         oslist=[
             "windows",
             "linux",
             "freebsd"],
         bugnumber="llvm.org/pr20282")
     def test_multiple_debuggers(self):
         env = {self.dylibPath: self.getLLDBLibraryEnvVal()}
 
-        self.driver_exe = os.path.join(os.getcwd(), "multi-process-driver")
+        self.driver_exe = self.getBuildArtifact("multi-process-driver")
         self.buildDriver('multi-process-driver.cpp', self.driver_exe)
         self.addTearDownHook(lambda: os.remove(self.driver_exe))
         self.signBinary(self.driver_exe)
 
-        self.inferior_exe = os.path.join(os.getcwd(), "testprog")
+        self.inferior_exe = self.getBuildArtifact("testprog")
         self.buildDriver('testprog.cpp', self.inferior_exe)
         self.addTearDownHook(lambda: os.remove(self.inferior_exe))
 
 # check_call will raise a CalledProcessError if multi-process-driver doesn't return
 # exit code 0 to indicate success.  We can let this exception go - the test harness
 # will recognize it as a test failure.
 
         if self.TraceOn():
             print("Running test %s" % self.driver_exe)
             check_call([self.driver_exe, self.inferior_exe], env=env)
         else:
             with open(os.devnull, 'w') as fnull:
                 check_call([self.driver_exe, self.inferior_exe],
                            env=env, stdout=fnull, stderr=fnull)

packages/Python/lldbsuite/test/api/multiple-targets/TestMultipleTargets.py

     @skipIfNoSBHeaders
     @skipIfHostIncompatibleWithRemote
     @expectedFailureAll(
         oslist=["windows", "freebsd"],
         bugnumber="llvm.org/pr20282")
     def test_multiple_targets(self):
         env = {self.dylibPath: self.getLLDBLibraryEnvVal()}
 
-        self.driver_exe = os.path.join(os.getcwd(), "multi-target")
+        self.driver_exe = self.getBuildArtifact("multi-target")
         self.buildDriver('main.cpp', self.driver_exe)
         self.addTearDownHook(lambda: os.remove(self.driver_exe))
         self.signBinary(self.driver_exe)
 
 # check_call will raise a CalledProcessError if multi-process-driver doesn't return
 # exit code 0 to indicate success.  We can let this exception go - the test harness
 # will recognize it as a test failure.
 
         if self.TraceOn():
             print("Running test %s" % self.driver_exe)
             check_call([self.driver_exe, self.driver_exe], env=env)
         else:
             with open(os.devnull, 'w') as fnull:
                 check_call([self.driver_exe, self.driver_exe],
                            env=env, stdout=fnull, stderr=fnull)

packages/Python/lldbsuite/test/api/multithreaded/TestMultithreaded.py

         # because remote is disabled, we can assume that the os is the same
         # still need to check architecture
         if self.getLldbArchitecture() != self.getArchitecture():
             self.skipTest(
                 "This test is only run if the target arch is the same as the lldb binary arch")
 
         self.inferior = 'inferior_program'
         self.buildProgram('inferior.cpp', self.inferior)
-        self.addTearDownHook(lambda: os.remove(self.inferior))
+        self.addTearDownHook(lambda:
+                             os.remove(self.getBuildArtifact(self.inferior)))
 
         self.buildDriver(sources, test_name)
-        self.addTearDownHook(lambda: os.remove(test_name))
+        self.addTearDownHook(lambda:
+                             os.remove(self.getBuildArtifact(test_name)))
 
-        test_exe = os.path.join(os.getcwd(), test_name)
+        test_exe = self.getBuildArtifact(test_name)
         self.signBinary(test_exe)
-        exe = [test_exe, self.inferior]
+        exe = [test_exe, self.getBuildArtifact(self.inferior)]
 
         env = {self.dylibPath: self.getLLDBLibraryEnvVal()}
         if self.TraceOn():
             print("Running test %s" % " ".join(exe))
             check_call(exe, env=env)
         else:
             with open(os.devnull, 'w') as fnull:
                 check_call(exe, env=env, stdout=fnull, stderr=fnull)
 
     def build_program(self, sources, program):
         return self.buildDriver(sources, program)

packages/Python/lldbsuite/test/arm/emulation/TestEmulations.py

 
 
 class ARMEmulationTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @no_debug_info_test
     def test_thumb_emulations(self):
-        current_dir = os.getcwd()
-        test_dir = os.path.join(current_dir, "new-test-files")
+        test_dir = os.path.join(self.getSourceDir(), "new-test-files")
         files = os.listdir(test_dir)
         thumb_files = list()
         for f in files:
             if '-thumb.dat' in f:
                 thumb_files.append(f)
 
         for f in thumb_files:
             test_file = os.path.join(test_dir, f)
             self.run_a_single_test(test_file)
 
     @no_debug_info_test
     def test_arm_emulations(self):
-        current_dir = os.getcwd()
-        test_dir = os.path.join(current_dir, "new-test-files")
+        test_dir = os.path.join(self.getSourceDir(), "new-test-files")
         files = os.listdir(test_dir)
         arm_files = list()
         for f in files:
             if '-arm.dat' in f:
                 arm_files.append(f)
 
         for f in arm_files:
             test_file = os.path.join(test_dir, f)

packages/Python/lldbsuite/test/benchmarks/expression/TestRepeatedExprs.py

 
         self.lldb_avg = self.stopwatch.avg()
         if self.TraceOn():
             print("lldb expression benchmark:", str(self.stopwatch))
         self.child = None
 
     def run_gdb_repeated_exprs(self, exe_name, count):
         import pexpect
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
 
         # Set self.child_prompt, which is "(gdb) ".
         self.child_prompt = '(gdb) '
         prompt = self.child_prompt
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('gdb --nx %s' % exe)
         child = self.child

packages/Python/lldbsuite/test/configuration.py

 
 failed = False
 
 # LLDB Remote platform setting
 lldb_platform_name = None
 lldb_platform_url = None
 lldb_platform_working_dir = None
 
+# The base directory in which the tests are being built.
+test_build_dir = None
+
 # Parallel execution settings
 is_inferior_test_runner = False
 multiprocess_test_subdir = None
 num_threads = None
 no_multiprocess_test_runner = False
 test_runner_name = None
 
 # Test results handling globals

packages/Python/lldbsuite/test/darwin_log.py

         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         # Build the darwin-log enable command.
         enable_cmd = expand_darwinlog_command('enable')
         if enable_options is not None and len(enable_options) > 0:
             enable_cmd += ' ' + ' '.join(enable_options)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.run_lldb_to_breakpoint(exe, self.source, self.line,
                                     enable_command=enable_cmd,
                                     settings_commands=settings_commands)
         self.expect_prompt()
 
         # Now go.
         self.runCmd("process continue")
         self.expect(self.CONTINUE_REGEX)

         self.assertEqual(1, breakpoint.GetNumLocations(),
                          "Should have found one breakpoint")
 
         # Enable packet logging.
         # self.runCmd("log enable -f /tmp/packets.log gdb-remote packets")
         # self.runCmd("log enable lldb process")
 
         # Launch the process - doesn't stop at entry.
-        process = target.LaunchSimple(None, None, os.getcwd())
+        process = target.LaunchSimple(None, None, self.getBuildDir())
         self.assertIsNotNone(process, lldbtest.PROCESS_IS_VALID)
 
         # Keep track of whether we're tracing output.
         trace_on = self.TraceOn()
 
         # Get the next thread that stops.
         from lldbsuite.test.lldbutil import get_stopped_thread
         thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)

packages/Python/lldbsuite/test/dotest.py

     configuration.rerun_max_file_threshold = args.rerun_max_file_threshold
 
     if args.lldb_platform_name:
         configuration.lldb_platform_name = args.lldb_platform_name
     if args.lldb_platform_url:
         configuration.lldb_platform_url = args.lldb_platform_url
     if args.lldb_platform_working_dir:
         configuration.lldb_platform_working_dir = args.lldb_platform_working_dir
+    if args.test_build_dir:
+        configuration.test_build_dir = args.test_build_dir
 
     if args.event_add_entries and len(args.event_add_entries) > 0:
         entries = {}
         # Parse out key=val pairs, separated by comma
         for keyval in args.event_add_entries.split(","):
             key_val_entry = keyval.split("=")
             if len(key_val_entry) == 2:
                 (key, val) = key_val_entry

         scriptPath = os.environ["DOTEST_SCRIPT_DIR"]
     else:
         scriptPath = os.path.dirname(os.path.realpath(__file__))
     if not scriptPath.endswith('test'):
         print("This script expects to reside in lldb's test directory.")
         sys.exit(-1)
 
     os.environ["LLDB_TEST"] = scriptPath
 
+    # Set up the root build directory.
+    builddir = configuration.test_build_dir
+    if not configuration.test_build_dir:
+        raise Exception("test_build_dir is not set")
+    os.environ["LLDB_BUILD"] = os.path.abspath(configuration.test_build_dir)
+
     # Set up the LLDB_SRC environment variable, so that the tests can locate
     # the LLDB source code.
     os.environ["LLDB_SRC"] = lldbsuite.lldb_root
 
     pluginPath = os.path.join(scriptPath, 'plugins')
     toolsLLDBMIPath = os.path.join(scriptPath, 'tools', 'lldb-mi')
     toolsLLDBServerPath = os.path.join(scriptPath, 'tools', 'lldb-server')
 

 
         if not lldb.remote_platform.SetWorkingDirectory(
                 configuration.lldb_platform_working_dir):
             raise Exception("failed to set working directory '%s'" % remote_test_dir)
         lldb.DBG.SetSelectedPlatform(lldb.remote_platform)
     else:
         lldb.remote_platform = None
         configuration.lldb_platform_working_dir = None
         configuration.lldb_platform_url = None
 
+    # Set up the working directory.
+    # Note that it's not dotest's job to clean this directory.
+    try: os.makedirs(configuration.test_build_dir)
+    except: pass
+
     target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
 
     checkLibcxxSupport()
 
     # Don't do debugserver tests on everything except OS X.
     configuration.dont_do_debugserver_test = "linux" in target_platform or "freebsd" in target_platform or "windows" in target_platform
 
     # Don't do lldb-server (llgs) tests on anything except Linux.

packages/Python/lldbsuite/test/dotest_args.py

         dest='log_success',
         action='store_true',
         help="Leave logs/traces even for successful test runs (useful for creating reference log files during debugging.)")
     group.add_argument(
         '--codesign-identity',
         metavar='Codesigning identity',
         default='lldb_codesign',
         help='The codesigning identity to use')
+    group.add_argument(
+        '--build-dir',
+        dest='test_build_dir',
+        metavar='Test build directory',
+        default='lldb-test-build',
+        help='The root build directory for the tests. It will be removed before running.')
 
     # Configuration options
     group = parser.add_argument_group('Remote platform options')
     group.add_argument(
         '--platform-name',
         dest='lldb_platform_name',
         metavar='platform-name',
         help='The name of a remote platform to use')

packages/Python/lldbsuite/test/expression_command/call-overridden-method/TestCallOverriddenMethod.py

         # Find the line number to break for main.c.
         self.line = line_number('main.cpp', '// Set breakpoint here')
 
     def test(self):
         """Test calls to overridden methods in derived classes."""
         self.build()
 
         # Set breakpoint in main and run exe
-        self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact("a.out"),
+                    CURRENT_EXECUTABLE_SET)
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # Test call to method in base class (this should always work as the base
         # class method is never an override).
         self.expect("expr b->foo()")
 
         # Test call to overridden method in derived class (this will fail if the
         # overrides table is not correctly set up, as Derived::foo will be assigned
         # a vtable entry that does not exist in the compiled program).
         self.expect("expr d.foo()")

packages/Python/lldbsuite/test/expression_command/save_jit_objects/TestSaveJITObjects.py

 """
 Test that LLDB can emit JIT objects when the appropriate setting is enabled
 """
 
 from __future__ import print_function
 
 import os
 import time
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
-def enumerateJITFiles():
-    return [f for f in os.listdir(os.getcwd()) if f.startswith("jit")]
+class SaveJITObjectsTestCase(TestBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    def enumerateJITFiles(self):
+        return [f for f in os.listdir(self.getBuildDir()) if f.startswith("jit")]
     
-def countJITFiles():
-    return len(enumerateJITFiles())
+    def countJITFiles(self):
+        return len(self.enumerateJITFiles())
 
-def cleanJITFiles():
-    for j in enumerateJITFiles():
+    def cleanJITFiles(self):
+        for j in self.enumerateJITFiles():
             os.remove(j)
         return
 
-class SaveJITObjectsTestCase(TestBase):
-    mydir = TestBase.compute_mydir(__file__)
-
     @expectedFailureAll(oslist=["windows"])
     def test_save_jit_objects(self):
         self.build()
+        os.chdir(self.getBuildDir())
         src_file = "main.c"
         src_file_spec = lldb.SBFileSpec(src_file)
   
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, "break", src_file_spec)
 
         frame = thread.frames[0]
 
-        cleanJITFiles()
+        self.cleanJITFiles()
         frame.EvaluateExpression("(void*)malloc(0x1)")
-        self.assertTrue(countJITFiles() == 0,
+        self.assertTrue(self.countJITFiles() == 0,
                         "No files emitted with save-jit-objects=false")
 
         self.runCmd("settings set target.save-jit-objects true")
         frame.EvaluateExpression("(void*)malloc(0x1)")
-        jit_files_count = countJITFiles()
-        cleanJITFiles()
+        jit_files_count = self.countJITFiles()
+        self.cleanJITFiles()
         self.assertTrue(jit_files_count != 0,
                         "At least one file emitted with save-jit-objects=true")
 
         process.Kill()
+        os.chdir(self.getSourceDir())

packages/Python/lldbsuite/test/expression_command/top-level/Makefile

 LEVEL = ../../make
 
 CXX_SOURCES := main.cpp test.cpp
 
 include $(LEVEL)/Makefile.rules
 
 a.out: dummy
 
 dummy:
-  $(MAKE) -f dummy.mk
+  $(MAKE) VPATH=$(VPATH) -I $(SRCDIR) -f $(SRCDIR)/dummy.mk
 
 clean::
-  $(MAKE) -f dummy.mk clean
+  $(MAKE) VPATH=$(VPATH) -I $(SRCDIR) -f $(SRCDIR)/dummy.mk clean

packages/Python/lldbsuite/test/expression_command/top-level/TestTopLevelExprs.py

         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
     def run_dummy(self):
-        self.runCmd("file dummy", CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact("dummy"),
+                    CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self,
             "dummy.cpp",
             self.dummy_line,
             num_expected_locations=1,
             loc_exact=False)
 

packages/Python/lldbsuite/test/functionalities/attach_resume/TestAttachResume.py

     def test_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""
         self.build()
         self.process_attach_continue_interrupt_detach()
 
     def process_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""
 
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
 
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)
 
         self.runCmd("process attach -p " + str(popen.pid))
 
         self.setAsync(True)
         listener = self.dbg.GetListener()

packages/Python/lldbsuite/test/functionalities/breakpoint/address_breakpoints/TestBadAddressBreakpoints.py

         self.address_breakpoints()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
     def address_breakpoints(self):
         """Test that breakpoints set on a bad address say they are bad."""
-
-        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, 
-                "Set a breakpoint here", lldb.SBFileSpec("main.c"))
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
+            self, "Set a breakpoint here", lldb.SBFileSpec("main.c"))
 
         # Now see if we can read from 0.  If I can't do that, I don't have a good way to know
         # what an illegal address is...
         error = lldb.SBError()
 
         ptr = process.ReadPointerFromMemory(0x0, error)
 
         if not error.Success():
             bkpt = target.BreakpointCreateByAddress(0x0)
             for bp_loc in bkpt:
                 self.assertTrue(bp_loc.IsResolved() == False)
         else:
             self.fail(
                 "Could not find an illegal address at which to set a bad breakpoint.")

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_case_sensitivity/TestBreakpointCaseSensitivity.py

         if case_insensitive:
             exe = exe.upper()
 
         exe = self.getBuildArtifact(exe)
 
         # Create a target by the debugger.
         self.target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)
-        cwd = os.getcwd()
+        srcdir = self.getSourceDir()
 
         # try both BreakpointCreateByLocation and BreakpointCreateBySourceRegex
         for regex in [False, True]:
             # should always hit
             self.check_breakpoint('main.c', regex, True)
             # should always hit
-            self.check_breakpoint(os.path.join(cwd, 'main.c'), regex, True)
+            self.check_breakpoint(os.path.join(srcdir, 'main.c'), regex, True)
             # different case for directory
-            self.check_breakpoint(os.path.join(cwd.upper(), 'main.c'),
+            self.check_breakpoint(os.path.join(srcdir.upper(), 'main.c'),
                                   regex,
                                   case_insensitive)
             # different case for file
             self.check_breakpoint('Main.c',
                                   regex,
                                   case_insensitive)
             # different case for both
-            self.check_breakpoint(os.path.join(cwd.upper(), 'Main.c'),
+            self.check_breakpoint(os.path.join(srcdir.upper(), 'Main.c'),
                                   regex,
                                   case_insensitive)
 
     def check_breakpoint(self, file, source_regex, should_hit):
         """
         Check breakpoint hit at given file set by given method
 
         file:

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestRegexpBreakCommand.py

         lldbutil.check_breakpoint_result(
             self,
             break_results,
             file_name='main.c',
             line_number=self.line,
             num_locations=1)
 
         # Check breakpoint with full file path.
-        full_path = os.path.join(os.getcwd(), self.source)
+        full_path = os.path.join(self.getSourceDir(), self.source)
         break_results = lldbutil.run_break_set_command(
             self, "b %s:%d" % (full_path, self.line))
         lldbutil.check_breakpoint_result(
             self,
             break_results,
             file_name='main.c',
             line_number=self.line,
             num_locations=1)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py

         self.do_check_configuring_permissions_cli()
 
     def setup_target(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a targets we are making breakpoint in and copying to:
         self.target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)
-        self.main_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), "main.c"))
+        self.main_file_spec = lldb.SBFileSpec(os.path.join(self.getSourceDir(), "main.c"))
         
     def check_name_in_target(self, bkpt_name):
         name_list = lldb.SBStringList()
         self.target.GetBreakpointNames(name_list)
         found_it = False
         for name in name_list:
             if name == bkpt_name:
                 found_it = True

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/TestBreakpointSetRestart.py

 class BreakpointSetRestart(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     BREAKPOINT_TEXT = 'Set a breakpoint here'
 
     def test_breakpoint_set_restart(self):
         self.build()
 
-        cwd = os.getcwd()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         self.dbg.SetAsync(True)
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         event = lldb.SBEvent()
         # Wait for inferior to transition to running state
         while self.dbg.GetListener().WaitForEvent(2, event):
             if lldb.SBProcess.GetStateFromEvent(event) == lldb.eStateRunning:
                 break
 
         bp = target.BreakpointCreateBySourceRegex(
-            self.BREAKPOINT_TEXT, lldb.SBFileSpec(
-                os.path.join(
-                    cwd, 'main.cpp')))
+            self.BREAKPOINT_TEXT, lldb.SBFileSpec('main.cpp'))
         self.assertTrue(
             bp.IsValid() and bp.GetNumLocations() == 1,
             VALID_BREAKPOINT)
 
         while self.dbg.GetListener().WaitForEvent(2, event):
             if lldb.SBProcess.GetStateFromEvent(
                     event) == lldb.eStateStopped and lldb.SBProcess.GetRestartedFromEvent(event):
                 continue
             if lldb.SBProcess.GetStateFromEvent(event) == lldb.eStateRunning:
                 continue
             self.fail(
                 "Setting a breakpoint generated an unexpected event: %s" %
                 lldb.SBDebugger.StateAsCString(
                     lldb.SBProcess.GetStateFromEvent(event)))

packages/Python/lldbsuite/test/functionalities/breakpoint/comp_dir_symlink/Makefile

 LEVEL = ../../../make
 
-CXX_SOURCES := main.cpp
+CXX_SOURCES := relative.cpp
 
 EXE := CompDirSymLink
 
 include $(LEVEL)/Makefile.rules
+
+# Force relative filenames by copying it into the build directory.
+relative.cpp: main.cpp
+  cp -f $< $@
+
+clean::
+  rm -rf relative.cpp

packages/Python/lldbsuite/test/functionalities/breakpoint/comp_dir_symlink/TestCompDirSymLink.py

 """
 Test breakpoint command with AT_comp_dir set to symbolic link.
 """
 from __future__ import print_function
 
 
 import os
 import shutil
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 _EXE_NAME = 'CompDirSymLink'  # Must match Makefile
-_SRC_FILE = 'main.cpp'
+_SRC_FILE = 'relative.cpp'
 _COMP_DIR_SYM_LINK_PROP = 'plugin.symbol-file.dwarf.comp-dir-symlink-paths'
 
 
 class CompDirSymLinkTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
-        self.line = line_number(_SRC_FILE, '// Set break point at this line.')
-        self.src_path = os.path.join(os.getcwd(), _SRC_FILE)
+        self.line = line_number(
+            os.path.join(self.getSourceDir(), "main.cpp"),
+            '// Set break point at this line.')
+        self.src_path = self.getBuildArtifact(_SRC_FILE)
+
 
     @skipIf(hostoslist=["windows"])
     def test_symlink_paths_set(self):
         pwd_symlink = self.create_src_symlink()
         self.doBuild(pwd_symlink)
         self.runCmd(
             "settings set %s %s" %
             (_COMP_DIR_SYM_LINK_PROP, pwd_symlink))
         lldbutil.run_break_set_by_file_and_line(self, self.src_path, self.line)
 
     @skipIf(hostoslist=no_match(["linux"]))
     def test_symlink_paths_set_procselfcwd(self):
+        os.chdir(self.getBuildDir())
         pwd_symlink = '/proc/self/cwd'
         self.doBuild(pwd_symlink)
         self.runCmd(
             "settings set %s %s" %
             (_COMP_DIR_SYM_LINK_PROP, pwd_symlink))
         lldbutil.run_break_set_by_file_and_line(self, self.src_path, self.line)
 
     @skipIf(hostoslist=["windows"])
     def test_symlink_paths_unset(self):
         pwd_symlink = self.create_src_symlink()
         self.doBuild(pwd_symlink)
         self.runCmd('settings clear ' + _COMP_DIR_SYM_LINK_PROP)
         self.assertRaises(
             AssertionError,
             lldbutil.run_break_set_by_file_and_line,
             self,
             self.src_path,
             self.line)
 
     def create_src_symlink(self):
-        pwd_symlink = os.path.join(os.getcwd(), 'pwd_symlink')
+        pwd_symlink = self.getBuildArtifact('pwd_symlink')
         if os.path.exists(pwd_symlink):
             os.unlink(pwd_symlink)
-        os.symlink(os.getcwd(), pwd_symlink)
+        os.symlink(self.getBuildDir(), pwd_symlink)
         self.addTearDownHook(lambda: os.remove(pwd_symlink))
         return pwd_symlink
 
     def doBuild(self, pwd_symlink):
         self.build(None, None, {'PWD': pwd_symlink}, True)
 
-        exe = os.path.join(os.getcwd(), _EXE_NAME)
+        exe = self.getBuildArtifact(_EXE_NAME)
         self.runCmd('file ' + exe, CURRENT_EXECUTABLE_SET)

packages/Python/lldbsuite/test/functionalities/breakpoint/serialize/TestBreakpointSerialization.py

         
         self.copy_target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.copy_target, VALID_TARGET)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
-        self.bkpts_file_path = os.path.join(os.getcwd(), "breakpoints.json")
+        self.bkpts_file_path = self.getBuildArtifact("breakpoints.json")
         self.bkpts_file_spec = lldb.SBFileSpec(self.bkpts_file_path)
 
     def check_equivalence(self, source_bps, do_write = True):
 
         error = lldb.SBError()
 
         if (do_write):
             error = self.orig_target.BreakpointsWriteToFile(self.bkpts_file_spec, source_bps)

             # print ("Source text for %d is %s."%(i, source_text))
             self.assertTrue (source_text == copy_text, "Source and dest breakpoints are not identical: \nsource: %s\ndest: %s"%(source_text, copy_text))
 
     def do_check_resolvers(self):
         """Use Python APIs to check serialization of breakpoint resolvers"""
 
         empty_module_list = lldb.SBFileSpecList()
         empty_cu_list = lldb.SBFileSpecList()
-        blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), "blubby.c"))
+        blubby_file_spec = lldb.SBFileSpec(os.path.join(self.getSourceDir(), "blubby.c"))
 
         # It isn't actually important for these purposes that these breakpoint
         # actually have locations.
         source_bps = lldb.SBBreakpointList(self.orig_target)
         source_bps.Append(self.orig_target.BreakpointCreateByLocation("blubby.c", 666))
         # Make sure we do one breakpoint right:
         self.check_equivalence(source_bps)
         source_bps.Clear()

         module_list.Append(lldb.SBFileSpec("SomeBinary"))
         module_list.Append(lldb.SBFileSpec("SomeOtherBinary"))
 
         cu_list = lldb.SBFileSpecList()
         cu_list.Append(lldb.SBFileSpec("SomeCU.c"))
         cu_list.Append(lldb.SBFileSpec("AnotherCU.c"))
         cu_list.Append(lldb.SBFileSpec("ThirdCU.c"))
 
-        blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), "blubby.c"))
+        blubby_file_spec = lldb.SBFileSpec(os.path.join(self.getSourceDir(), "blubby.c"))
 
         # It isn't actually important for these purposes that these breakpoint
         # actually have locations.
         source_bps = lldb.SBBreakpointList(self.orig_target)
         bkpt = self.orig_target.BreakpointCreateByLocation(blubby_file_spec, 666, 0, module_list)
         source_bps.Append(bkpt)
 
         # Make sure we do one right:

         # And some number greater than one:
         self.check_equivalence(source_bps)
 
     def do_check_options(self):
         """Use Python APIs to check serialization of breakpoint options."""
 
         empty_module_list = lldb.SBFileSpecList()
         empty_cu_list = lldb.SBFileSpecList()
-        blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), "blubby.c"))
+        blubby_file_spec = lldb.SBFileSpec(os.path.join(self.getSourceDir(), "blubby.c"))
 
         # It isn't actually important for these purposes that these breakpoint
         # actually have locations.
         source_bps = lldb.SBBreakpointList(self.orig_target)
 
         bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)
         bkpt.SetEnabled(False)
         bkpt.SetOneShot(True)

 
         self.check_equivalence(source_bps)
 
     def do_check_appending(self):
         """Use Python APIs to check appending to already serialized options."""
 
         empty_module_list = lldb.SBFileSpecList()
         empty_cu_list = lldb.SBFileSpecList()
-        blubby_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), "blubby.c"))
+        blubby_file_spec = lldb.SBFileSpec(os.path.join(self.getSourceDir(), "blubby.c"))
 
         # It isn't actually important for these purposes that these breakpoint
         # actually have locations.
 
         all_bps = lldb.SBBreakpointList(self.orig_target)
         source_bps = lldb.SBBreakpointList(self.orig_target)
 
         bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)

packages/Python/lldbsuite/test/functionalities/command_script_immediate_output/TestCommandScriptImmediateOutput.py

 
     @skipIfRemote  # test not remote-ready llvm.org/pr24813
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr26139")
     def test_command_script_immediate_output_console(self):
         """Test that LLDB correctly allows scripted commands to set immediate output to the console."""
+        self.makeBuildDir()
         self.launch(timeout=10)
 
-        script = os.path.join(os.getcwd(), 'custom_command.py')
+        script = os.path.join(self.getSourceDir(), 'custom_command.py')
         prompt = "\(lldb\) "
 
         self.sendline('command script import %s' % script, patterns=[prompt])
         self.sendline(
             'command script add -f custom_command.command_function mycommand',
             patterns=[prompt])
         self.sendline(
             'mycommand',
             patterns='this is a test string, just a test string')
         self.sendline('command script delete mycommand', patterns=[prompt])
         self.quit(gracefully=False)
 
     @skipIfRemote  # test not remote-ready llvm.org/pr24813
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr26139")
     def test_command_script_immediate_output_file(self):
         """Test that LLDB correctly allows scripted commands to set immediate output to a file."""
+        self.makeBuildDir()
         self.launch(timeout=10)
 
-        test_files = {os.path.join(os.getcwd(), 'read.txt'): 'r',
-                      os.path.join(os.getcwd(), 'write.txt'): 'w',
-                      os.path.join(os.getcwd(), 'append.txt'): 'a',
-                      os.path.join(os.getcwd(), 'write_plus.txt'): 'w+',
-                      os.path.join(os.getcwd(), 'read_plus.txt'): 'r+',
-                      os.path.join(os.getcwd(), 'append_plus.txt'): 'a+'}
+        test_files = {self.getBuildArtifact('read.txt'): 'r',
+                      self.getBuildArtifact('write.txt'): 'w',
+                      self.getBuildArtifact('append.txt'): 'a',
+                      self.getBuildArtifact('write_plus.txt'): 'w+',
+                      self.getBuildArtifact('read_plus.txt'): 'r+',
+                      self.getBuildArtifact('append_plus.txt'): 'a+'}
 
         starter_string = 'Starter Garbage\n'
         write_string = 'writing to file with mode: '
 
         for path, mode in test_files.iteritems():
             with open(path, 'w+') as init:
                 init.write(starter_string)
 
-        script = os.path.join(os.getcwd(), 'custom_command.py')
+        script = os.path.join(self.getSourceDir(), 'custom_command.py')
         prompt = "\(lldb\) "
 
         self.sendline('command script import %s' % script, patterns=[prompt])
 
         self.sendline(
             'command script add -f custom_command.write_file mywrite',
             patterns=[prompt])
         for path, mode in test_files.iteritems():

packages/Python/lldbsuite/test/functionalities/exec/TestExec.py

 
     @skipUnlessDarwin
     @expectedFailureAll(archs=['i386'], bugnumber="rdar://28656532")
     @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://problem/34559552") # this exec test has problems on ios systems
     def test_skipping_exec (self):
         self.do_test(True)
 
     def do_test(self, skip_exec):
+        self.makeBuildDir()
+        exe = self.getBuildArtifact("a.out")
         if self.getArchitecture() == 'x86_64':
-            source = os.path.join(os.getcwd(), "main.cpp")
-            o_file = os.path.join(os.getcwd(), "main.o")
+            source = self.getSourcePath("main.cpp")
+            o_file = self.getBuildArtifact("main.o")
             execute_command(
                 "'%s' -g -O0 -arch i386 -arch x86_64 '%s' -c -o '%s'" %
                 (os.environ["CC"], source, o_file))
             execute_command(
-                "'%s' -g -O0 -arch i386 -arch x86_64 '%s'" %
-                (os.environ["CC"], o_file))
+                "'%s' -g -O0 -arch i386 -arch x86_64 '%s' -o '%s'" %
+                (os.environ["CC"], o_file, exe))
             if self.debug_info != "dsym":
                 dsym_path = self.getBuildArtifact("a.out.dSYM")
                 execute_command("rm -rf '%s'" % (dsym_path))
         else:
             self.build()
 
-        exe = self.getBuildArtifact("a.out")
-
         # Create the target
         target = self.dbg.CreateTarget(exe)
 
         # Create any breakpoints we need
         breakpoint = target.BreakpointCreateBySourceRegex(
             'Set breakpoint 1 here', lldb.SBFileSpec("main.cpp", False))
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 

packages/Python/lldbsuite/test/functionalities/fat_archives/Makefile

-all: clean
-    $(CC) -arch i386 -g -c a.c
+SRCDIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))/
+
+all: a.c clean
+    $(CC) -arch i386 -g -c $(SRCDIR)/a.c
     ar -q liba-i386.a a.o
     ranlib liba-i386.a
-    $(CC) -arch x86_64 -g -c a.c
+    $(CC) -arch x86_64 -g -c $(SRCDIR)/a.c
     ar -q liba-x86_64.a a.o
     ranlib liba-x86_64.a
     lipo -create -output liba.a liba-i386.a liba-x86_64.a
-    $(CC) -g -c main.c
+    $(CC) -g -c $(SRCDIR)/main.c
     $(CC) -o a.out main.o -L. -la
 
 clean:
     rm -rf a.o a.out liba-i386.a liba-x86_64.a liba.a $(wildcard *un~ .*un~ main.o *.pyc)
 

packages/Python/lldbsuite/test/functionalities/frame-language/Makefile

 LEVEL = ../../make
 
 CXX_SOURCES := main.cpp other.cpp other-2.cpp
 C_SOURCES := somefunc.c
 
 include $(LEVEL)/Makefile.rules
 
 other-2.o: other-2.cpp
-  $(CXX) $(CFLAGS_NO_DEBUG) -c other-2.cpp
+  $(CXX) $(CFLAGS_NO_DEBUG) -c $(SRCDIR)/other-2.cpp
 
 somefunc.o: somefunc.c
-  $(CC) $(CFLAGS) -std=c99 -c somefunc.c
+  $(CC) $(CFLAGS) -std=c99 -c $(SRCDIR)/somefunc.c
 

packages/Python/lldbsuite/test/functionalities/launch_with_shellexpand/TestLaunchWithShellExpand.py

 
         # Create any breakpoints we need
         breakpoint = target.BreakpointCreateBySourceRegex(
             'break here', lldb.SBFileSpec("main.cpp", False))
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         self.runCmd(
             "process launch -X true -w %s -- fi*.tx? () > <" %
-            (os.getcwd()))
+            (self.getSourceDir()))
 
         process = self.process()
 
         self.assertTrue(process.GetState() == lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         thread = process.GetThreadAtIndex(0)
 

             "frame variable argv[8]",
             substrs=['file5.tyx'],
             matching=False)
 
         self.runCmd("process kill")
 
         self.runCmd(
             'process launch -X true -w %s -- "foo bar"' %
-            (os.getcwd()))
+            (self.getSourceDir()))
 
         process = self.process()
 
         self.assertTrue(process.GetState() == lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         thread = process.GetThreadAtIndex(0)
 
         self.assertTrue(thread.IsValid(),
                         "Process stopped at 'main' should have a valid thread")
 
         stop_reason = thread.GetStopReason()
 
         self.assertTrue(
             stop_reason == lldb.eStopReasonBreakpoint,
             "Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint")
 
         self.expect("frame variable argv[1]", substrs=['foo bar'])
 
         self.runCmd("process kill")
 
-        self.runCmd('process launch -X true -w %s -- foo\ bar' % (os.getcwd()))
+        self.runCmd('process launch -X true -w %s -- foo\ bar'
+                    % (self.getBuildDir()))
 
         process = self.process()
 
         self.assertTrue(process.GetState() == lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         thread = process.GetThreadAtIndex(0)
 

packages/Python/lldbsuite/test/functionalities/load_unload/Makefile

 LEVEL := ../../make
 
 LIB_PREFIX := loadunload_
 
 LD_EXTRAS := -L. -l$(LIB_PREFIX)d -ldl
 CXX_SOURCES := main.cpp
 
 include $(LEVEL)/Makefile.rules
 
-.PHONY:
 a.out: lib_a lib_b lib_c lib_d hidden_lib_d install_name_tool
 
 lib_%:
-  $(MAKE) -f $*.mk
+  $(MAKE) VPATH=$(SRCDIR) -I $(SRCDIR) -f $(SRCDIR)/$*.mk
 
 install_name_tool:
 ifeq ($(OS),Darwin)
   install_name_tool -id @executable_path/libloadunload_d.dylib libloadunload_d.dylib
 endif
 
 
 hidden_lib_d:
-  $(MAKE) -C hidden
+  mkdir -p hidden
+  $(MAKE) VPATH=$(SRCDIR)/hidden -I $(SRCDIR)/hidden -C hidden -f $(SRCDIR)/hidden/Makefile
 
 clean::
-  $(MAKE) -f a.mk clean
-  $(MAKE) -f b.mk clean
-  $(MAKE) -f c.mk clean
-  $(MAKE) -f d.mk clean
-  $(MAKE) -C hidden clean
+  $(MAKE) -f $(SRCDIR)/a.mk clean
+  $(MAKE) -f $(SRCDIR)/b.mk clean
+  $(MAKE) -f $(SRCDIR)/c.mk clean
+  $(MAKE) -f $(SRCDIR)/d.mk clean
+  mkdir -p hidden
+  $(MAKE) -I $(SRCDIR)/hidden -C hidden -f $(SRCDIR)/hidden/Makefile clean

packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py

         if not self.platformIsDarwin():
             if not lldb.remote_platform and "LD_LIBRARY_PATH" in os.environ:
                 self.runCmd(
                     "settings set target.env-vars " +
                     self.dylibPath +
                     "=" +
                     os.environ["LD_LIBRARY_PATH"] +
                     ":" +
-                    os.getcwd())
+                    self.getBuildDir())
             else:
                 if lldb.remote_platform:
                     wd = lldb.remote_platform.GetWorkingDirectory()
                 else:
-                    wd = os.getcwd()
+                    wd = self.getBuildDir()
                 self.runCmd(
                     "settings set target.env-vars " +
                     self.dylibPath +
                     "=" +
                     wd)
 
     def copy_shlibs_to_remote(self, hidden_dir=False):
         """ Copies the shared libs required by this test suite to remote.
         Does nothing in case of non-remote platforms.
         """
         if lldb.remote_platform:
             ext = 'so'
             if self.platformIsDarwin():
                 ext = 'dylib'
 
             shlibs = ['libloadunload_a.' + ext, 'libloadunload_b.' + ext,
                       'libloadunload_c.' + ext, 'libloadunload_d.' + ext]
             wd = lldb.remote_platform.GetWorkingDirectory()
             cwd = os.getcwd()
             for f in shlibs:
                 err = lldb.remote_platform.Put(
-                    lldb.SBFileSpec(os.path.join(cwd, f)),
+                    lldb.SBFileSpec(self.getBuildArtifact(f)),
                     lldb.SBFileSpec(os.path.join(wd, f)))
                 if err.Fail():
                     raise RuntimeError(
                         "Unable copy '%s' to '%s'.\n>>> %s" %
                         (f, wd, err.GetCString()))
             if hidden_dir:
                 shlib = 'libloadunload_d.' + ext
                 hidden_dir = os.path.join(wd, 'hidden')
                 hidden_file = os.path.join(hidden_dir, shlib)
                 err = lldb.remote_platform.MakeDirectory(hidden_dir)
                 if err.Fail():
                     raise RuntimeError(
                         "Unable to create a directory '%s'." % hidden_dir)
                 err = lldb.remote_platform.Put(
-                    lldb.SBFileSpec(os.path.join(cwd, 'hidden', shlib)),
+                    lldb.SBFileSpec(os.path.join('hidden', shlib)),
                     lldb.SBFileSpec(hidden_file))
                 if err.Fail():
                     raise RuntimeError(
                         "Unable copy 'libloadunload_d.so' to '%s'.\n>>> %s" %
                         (wd, err.GetCString()))
 
+    # libloadunload_d.so does not appear in the image list because executable
+    # dependencies are resolved relative to the debuggers PWD. Bug?
+    @expectedFailureAll(oslist=["linux"])
     @skipIfFreeBSD  # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
     @not_remote_testsuite_ready
     @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
     def test_modules_search_paths(self):
         """Test target modules list after loading a different copy of the library libd.dylib, and verifies that it works with 'target modules search-paths add'."""
 
         # Invoke the default build rule.
         self.build()
 
         if self.platformIsDarwin():
             dylibName = 'libloadunload_d.dylib'
         else:
             dylibName = 'libloadunload_d.so'
 
         # The directory with the dynamic library we did not link to.
-        new_dir = os.path.join(os.getcwd(), "hidden")
+        new_dir = os.path.join(self.getBuildDir(), "hidden")
 
-        old_dylib = os.path.join(os.getcwd(), dylibName)
+        old_dylib = os.path.join(self.getBuildDir(), dylibName)
         new_dylib = os.path.join(new_dir, dylibName)
-
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.expect("target modules list",
                     substrs=[old_dylib])
         # self.expect("target modules list -t 3",
         #    patterns = ["%s-[^-]*-[^-]*" % self.getArchitecture()])
         # Add an image search path substitution pair.
         self.runCmd(
             "target modules search-paths add %s %s" %
-            (os.getcwd(), new_dir))
+            (self.getBuildDir(), new_dir))
 
         self.expect("target modules search-paths list",
-                    substrs=[os.getcwd(), new_dir])
+                    substrs=[self.getBuildDir(), new_dir])
 
         self.expect(
             "target modules search-paths query %s" %
-            os.getcwd(),
+            self.getBuildDir(),
             "Image search path successfully transformed",
             substrs=[new_dir])
 
         # Obliterate traces of libd from the old location.
         os.remove(old_dylib)
         # Inform (DY)LD_LIBRARY_PATH of the new path, too.
         env_cmd_string = "settings set target.env-vars " + self.dylibPath + "=" + new_dir
         if self.TraceOn():
             print("Set environment to: ", env_cmd_string)
         self.runCmd(env_cmd_string)
         self.runCmd("settings show target.env-vars")
 
         remove_dyld_path_cmd = "settings remove target.env-vars " + self.dylibPath
         self.addTearDownHook(
             lambda: self.dbg.HandleCommand(remove_dyld_path_cmd))
 
         self.runCmd("run")
 
         self.expect(
             "target modules list",
             "LLDB successfully locates the relocated dynamic library",
             substrs=[new_dylib])
 
+    # libloadunload_d.so does not appear in the image list because executable
+    # dependencies are resolved relative to the debuggers PWD. Bug?
+    @expectedFailureAll(oslist=["linux"])
     @skipIfFreeBSD  # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
     @expectedFailureAndroid  # wrong source file shows up for hidden library
     @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
     def test_dyld_library_path(self):
         """Test (DY)LD_LIBRARY_PATH after moving libd.dylib, which defines d_function, somewhere else."""
 
         # Invoke the default build rule.
         self.build()

         else:
             dylibName = 'libloadunload_d.so'
 
         # The directory to relocate the dynamic library and its debugging info.
         special_dir = "hidden"
         if lldb.remote_platform:
             wd = lldb.remote_platform.GetWorkingDirectory()
         else:
-            wd = os.getcwd()
+            wd = self.getBuildDir()
 
         old_dir = wd
         new_dir = os.path.join(wd, special_dir)
         old_dylib = os.path.join(old_dir, dylibName)
 
-        remove_dyld_path_cmd = "settings remove target.env-vars " + self.dylibPath
+        remove_dyld_path_cmd = "settings remove target.env-vars " \
+                               + self.dylibPath
         self.addTearDownHook(
             lambda: self.dbg.HandleCommand(remove_dyld_path_cmd))
 
-        # For now we don't track (DY)LD_LIBRARY_PATH, so the old library will be in
-        # the modules list.
+        # For now we don't track (DY)LD_LIBRARY_PATH, so the old
+        # library will be in the modules list.
         self.expect("target modules list",
                     substrs=[os.path.basename(old_dylib)],
                     matching=True)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "d.cpp", self.line_d_function, num_expected_locations=1)
         # After run, make sure the non-hidden library is picked up.
         self.expect("run", substrs=["return", "700"])
 
         self.runCmd("continue")
 
         # Add the hidden directory first in the search path.
         env_cmd_string = ("settings set target.env-vars %s=%s" %
                           (self.dylibPath, new_dir))
         if not self.platformIsDarwin():
             env_cmd_string += ":" + wd
         self.runCmd(env_cmd_string)
         
         # This time, the hidden library should be picked up.
         self.expect("run", substrs=["return", "12345"])
 
     @expectedFailureAll(
         bugnumber="llvm.org/pr25805",
         hostoslist=["windows"],
         compiler="gcc",
         archs=["i386"],

         self.runCmd("run", RUN_SUCCEEDED)
 
         if lldb.remote_platform:
             shlib_dir = lldb.remote_platform.GetWorkingDirectory()
         else:
             shlib_dir = self.mydir
 
         if self.platformIsDarwin():
-            dylibName = 'libloadunload_a.dylib'
+            dylibName = self.getBuildArtifact('libloadunload_a.dylib')
         else:
-            dylibName = 'libloadunload_a.so'
+            dylibName = self.getBuildArtifact('libloadunload_a.so')
 
         # Make sure that a_function does not exist at this point.
         self.expect(
             "image lookup -n a_function",
             "a_function should not exist yet",
             error=True,
             matching=False,
             patterns=["1 match found"])
 
         # Use lldb 'process load' to load the dylib.
         self.expect(
-            "process load %s --install" %
-            dylibName,
+            "process load %s --install=%s" %
+            (dylibName, dylibName),
             "%s loaded correctly" %
             dylibName,
             patterns=[
                 'Loading "%s".*ok' %
                 dylibName,
                 'Image [0-9]+ loaded'])
 
         # Search for and match the "Image ([0-9]+) loaded" pattern.

             "thread step-over",
             "Stepping over function that loads library")
 
         # The stop reason should be step end.
         self.expect("thread list", "step over succeeded.",
                     substrs=['stopped',
                              'stop reason = step over'])
 
+    # We can't find a breakpoint location for d_init before launching because
+    # executable dependencies are resolved relative to the debuggers PWD. Bug?
+    @expectedFailureAll(oslist=["linux"])
     @skipIfFreeBSD  # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
     @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
     def test_static_init_during_load(self):
         """Test that we can set breakpoints correctly in static initializers"""
 
         self.build()
         self.copy_shlibs_to_remote()
 

packages/Python/lldbsuite/test/functionalities/load_unload/a.mk

 LEVEL := ../../make
 
 LIB_PREFIX := loadunload_
 
 CFLAGS_EXTRAS := -fPIC
 LD_EXTRAS := -L. -l$(LIB_PREFIX)b
 
 DYLIB_NAME := $(LIB_PREFIX)a
 DYLIB_CXX_SOURCES := a.cpp
 DYLIB_ONLY := YES
 
 CXXFLAGS += -fPIC
 
 include $(LEVEL)/Makefile.rules
 
-.PHONY:
 $(DYLIB_FILENAME): lib_b
 
-lib_b:
-  "$(MAKE)" -f b.mk
+.PHONY lib_b:
+  $(MAKE) VPATH=$(SRCDIR) -I $(SRCDIR) -f $(SRCDIR)/b.mk
 
 clean::
-  "$(MAKE)" -f b.mk clean
+  $(MAKE) -I $(SRCDIR) -f $(SRCDIR)/b.mk clean

packages/Python/lldbsuite/test/functionalities/plugins/commands/TestPluginCommands.py

         # Invoke the library build rule.
         self.buildLibrary("plugin.cpp", plugin_name)
 
         debugger = lldb.SBDebugger.Create()
 
         retobj = lldb.SBCommandReturnObject()
 
         retval = debugger.GetCommandInterpreter().HandleCommand(
-            "plugin load %s" % plugin_lib_name, retobj)
+            "plugin load %s" % self.getBuildArtifact(plugin_lib_name), retobj)
 
         retobj.Clear()
 
         retval = debugger.GetCommandInterpreter().HandleCommand(
             "plugin_loaded_command child abc def ghi", retobj)
 
         if self.TraceOn():
             print(retobj.GetOutput())

packages/Python/lldbsuite/test/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py

 
     def run_python_os_funcionality(self):
         """Test that the Python operating system plugin works correctly"""
 
         # Set debugger into synchronous mode
         self.dbg.SetAsync(False)
 
         # Create a target by the debugger.
-        cwd = os.getcwd()
         exe = self.getBuildArtifact("a.out")
-        python_os_plugin_path = os.path.join(cwd, "operating_system.py")
+        python_os_plugin_path = os.path.join(self.getSourceDir(),
+                                             "operating_system.py")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Set breakpoints inside and outside methods that take pointers to the
         # containing struct.
         lldbutil.run_break_set_by_source_regexp(self, "// Set breakpoint here")
 
         # Register our shared libraries for remote targets so they get

 
     def run_python_os_step(self):
         """Test that the Python operating system plugin works correctly and allows single stepping of a virtual thread that is backed by a real thread"""
 
         # Set debugger into synchronous mode
         self.dbg.SetAsync(False)
 
         # Create a target by the debugger.
-        cwd = os.getcwd()
         exe = self.getBuildArtifact("a.out")
-        python_os_plugin_path = os.path.join(cwd, "operating_system2.py")
+        python_os_plugin_path = os.path.join(self.getSourceDir(),
+                                             "operating_system2.py")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Set breakpoints inside and outside methods that take pointers to the
         # containing struct.
         lldbutil.run_break_set_by_source_regexp(self, "// Set breakpoint here")
 
         # Register our shared libraries for remote targets so they get

packages/Python/lldbsuite/test/functionalities/postmortem/minidump/TestMiniDump.py

             self.assertTrue(frame.IsValid())
             self.assertEqual(frame.GetPC(), pc_list[i])
 
     @skipUnlessWindows # Minidump saving works only on windows
     def test_deeper_stack_in_mini_dump(self):
         """Test that we can examine a more interesting stack in a mini dump."""
         self.build()
         exe = self.getBuildArtifact("a.out")
-        core = os.path.join(os.getcwd(), "core.dmp")
+        core = self.getBuildArtifact("core.dmp")
         try:
             # Set a breakpoint and capture a mini dump.
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
             self.assertEqual(process.GetState(), lldb.eStateStopped)
             self.assertTrue(process.SaveCore(core))

             if (os.path.isfile(core)):
                 os.unlink(core)
 
     @skipUnlessWindows # Minidump saving works only on windows
     def test_local_variables_in_mini_dump(self):
         """Test that we can examine local variables in a mini dump."""
         self.build()
         exe = self.getBuildArtifact("a.out")
-        core = os.path.join(os.getcwd(), "core.dmp")
+        core = self.getBuildArtifact("core.dmp")
         try:
             # Set a breakpoint and capture a mini dump.
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
             self.assertEqual(process.GetState(), lldb.eStateStopped)
             self.assertTrue(process.SaveCore(core))

packages/Python/lldbsuite/test/functionalities/process_attach/TestProcessAttach.py

 
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfiOSSimulator
     @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], bugnumber="<rdar://problem/34538611>") # old lldb-server has race condition, launching an inferior and then launching debugserver in quick succession sometimes fails
     def test_attach_to_process_by_id(self):
         """Test attach by process id"""
         self.build()
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
 
         # Spawn a new process
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)
 
         self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
 
         process = target.GetProcess()
         self.assertTrue(process, PROCESS_IS_VALID)
 
     @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], bugnumber="<rdar://problem/34538611>") # old lldb-server has race condition, launching an inferior and then launching debugserver in quick succession sometimes fails
     def test_attach_to_process_from_different_dir_by_id(self):
         """Test attach by process id"""
+        newdir = self.getBuildArtifact("newdir")
         try:
-            os.mkdir(os.path.join(os.getcwd(),'newdir'))
+            os.mkdir(newdir)
         except OSError, e:
             if e.errno != os.errno.EEXIST:
                 raise
-        testdir = os.getcwd()
-        newdir = os.path.join(testdir,'newdir')
+        testdir = self.getBuildDir()
         exe = os.path.join(newdir, 'proc_attach')
         self.buildProgram('main.cpp', exe)
         self.addTearDownHook(lambda: shutil.rmtree(newdir))
 
         # Spawn a new process
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)
 
-        os.chdir('newdir')
+        os.chdir(newdir)
         self.addTearDownHook(lambda: os.chdir(testdir))
         self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
 
         process = target.GetProcess()
         self.assertTrue(process, PROCESS_IS_VALID)
 
     @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], bugnumber="<rdar://problem/34538611>") # old lldb-server has race condition, launching an inferior and then launching debugserver in quick succession sometimes fails
     def test_attach_to_process_by_name(self):
         """Test attach by process name"""
         self.build()
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
 
         # Spawn a new process
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)
 
         self.runCmd("process attach -n " + exe_name)
 
         target = self.dbg.GetSelectedTarget()

packages/Python/lldbsuite/test/functionalities/process_attach/attach_denied/TestAttachDenied.py

     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows
     @skipIfiOSSimulator
     @skipIfDarwinEmbedded  # ptrace(ATTACH_REQUEST...) won't work on ios/tvos/etc
     def test_attach_to_process_by_id_denied(self):
         """Test attach by process id denied"""
         self.build()
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
 
         # Use a file as a synchronization point between test and inferior.
         pid_file_path = lldbutil.append_to_process_working_directory(
             "pid_file_%d" % (int(time.time())))
         self.addTearDownHook(
             lambda: self.run_platform_command(
                 "rm %s" %
                 (pid_file_path)))

packages/Python/lldbsuite/test/functionalities/process_launch/TestProcessLaunch.py

         self.setTearDownCleanup(d)
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe)
 
         mywd = 'my_working_dir'
         out_file_name = "my_working_dir_test.out"
         err_file_name = "my_working_dir_test.err"
 
-        my_working_dir_path = os.path.join(os.getcwd(), mywd)
+        my_working_dir_path = self.getBuildArtifact(mywd)
+        try: os.makedirs(my_working_dir_path)
+        except: pass
         out_file_path = os.path.join(my_working_dir_path, out_file_name)
         err_file_path = os.path.join(my_working_dir_path, err_file_name)
 
         # Make sure the output files do not exist before launching the process
         try:
             os.remove(out_file_path)
             os.remove(err_file_path)
         except OSError:

packages/Python/lldbsuite/test/functionalities/process_save_core/TestProcessSaveCore.py

class ProcessSaveCoreTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @not_remote_testsuite_ready
     @skipUnlessWindows
     def test_cannot_save_core_unless_process_stopped(self):
         """Test that SaveCore fails if the process isn't stopped."""
         self.build()
         exe = self.getBuildArtifact("a.out")
-        core = os.path.join(os.getcwd(), "core.dmp")
+        core = self.getBuildArtifact("core.dmp")
         target = self.dbg.CreateTarget(exe)
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertNotEqual(process.GetState(), lldb.eStateStopped)
         error = process.SaveCore(core)
         self.assertTrue(error.Fail())
 
     @not_remote_testsuite_ready
     @skipUnlessWindows
     def test_save_windows_mini_dump(self):
         """Test that we can save a Windows mini dump."""
         self.build()
         exe = self.getBuildArtifact("a.out")
-        core = os.path.join(os.getcwd(), "core.dmp")
+        core = self.getBuildArtifact("core.dmp")
         try:
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
             self.assertEqual(process.GetState(), lldb.eStateStopped)
             self.assertTrue(process.SaveCore(core))
             self.assertTrue(os.path.isfile(core))

packages/Python/lldbsuite/test/functionalities/register/register_command/TestRegisters.py

         # platform as logging is host side.
         self.platform = ""
         if (sys.platform.startswith("freebsd") or
                 sys.platform.startswith("linux") or
                 sys.platform.startswith("netbsd")):
             self.platform = "posix"
 
         if self.platform != "":
-            self.log_file = os.path.join(os.getcwd(), 'TestRegisters.log')
+            self.log_file = self.getBuildArtifact('TestRegisters.log')
             self.runCmd(
                 "log enable " +
                 self.platform +
                 " " +
                 str(category) +
                 " registers -v -f " +
                 self.log_file,
                 RUN_SUCCEEDED)

packages/Python/lldbsuite/test/functionalities/single-quote-in-filename-to-lldb/TestSingleQuoteInFilename.py

     @expectedFailureAll(
         hostoslist=["windows"],
         bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @no_debug_info_test
     def test_lldb_invocation_with_single_quote_in_filename(self):
         """Test that 'lldb my_file_name' works where my_file_name is a string with a single quote char in it."""
         import pexpect
         self.buildDefault()
+        try: os.makedirs(self.getBuildArtifact("path with '09"))
+        except: pass
         system([["cp",
                  self.getBuildArtifact("a.out"),
                  "\"%s\"" % self.getBuildArtifact(self.myexe)]])
 
         # The default lldb prompt.
         prompt = "(lldb) "
 
         # So that the child gets torn down after the test.

packages/Python/lldbsuite/test/functionalities/step-avoids-no-debug/Makefile

 LEVEL = ../../make
 
 C_SOURCES := with-debug.c without-debug.c
 
 include $(LEVEL)/Makefile.rules
 
 without-debug.o: without-debug.c
-  $(CC) $(CFLAGS_NO_DEBUG) -c without-debug.c 
+  $(CC) $(CFLAGS_NO_DEBUG) -c $<

packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py

         hostoslist=["windows"],
         bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_stop_hook_multiple_threads(self):
         """Test that lldb stop-hook works for multiple threads."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         import pexpect
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         prompt = "(lldb) "
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('%s %s' %
                                    (lldbtest_config.lldbExec, self.lldbOption))
         child = self.child
         # Turn on logging for what the child sends back.
         if self.TraceOn():

packages/Python/lldbsuite/test/functionalities/target_command/TestTargetCommand.py

         self.build(dictionary=d)
         self.addTearDownCleanup(dictionary=d)
 
         self.do_target_variable_command_no_fail('globals')
 
     def do_target_command(self):
         """Exercise 'target create', 'target list', 'target select' commands."""
         exe_a = self.getBuildArtifact("a.out")
-        exe_b = os.path.join(os.getcwd(), "b.out")
-        exe_c = os.path.join(os.getcwd(), "c.out")
+        exe_b = self.getBuildArtifact("b.out")
+        exe_c = self.getBuildArtifact("c.out")
 
         self.runCmd("target list")
         output = self.res.GetOutput()
         if output.startswith("No targets"):
             # We start from index 0.
             base = 0
         else:
             # Find the largest index of the existing list.

         self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['b.c:%d' % self.line_b,
                              'stop reason = breakpoint'])
 
         self.runCmd("target list")
 
     def do_target_variable_command(self, exe_name):
         """Exercise 'target variable' command before and after starting the inferior."""
-        self.runCmd("file " + exe_name, CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact(exe_name),
+                    CURRENT_EXECUTABLE_SET)
 
         self.expect(
             "target variable my_global_char",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "my_global_char",
                 "'X'"])
         self.expect(

             "target variable my_global_char",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "my_global_char",
                 "'X'"])
 
     def do_target_variable_command_no_fail(self, exe_name):
         """Exercise 'target variable' command before and after starting the inferior."""
-        self.runCmd("file " + exe_name, CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact(exe_name),
+                    CURRENT_EXECUTABLE_SET)
 
         self.expect(
             "target variable my_global_char",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "my_global_char",
                 "'X'"])
         self.expect(

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/breakpoint_delay_breakpoint_one_signal/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/breakpoint_one_delay_breakpoint_threads/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/breakpoints_delayed_breakpoint_one_watchpoint/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/crash_with_break/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/crash_with_signal/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/crash_with_watchpoint/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/crash_with_watchpoint_breakpoint_signal/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/delay_signal_break/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/delay_signal_watch/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/delay_watch_break/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/delayed_crash_with_breakpoint_signal/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/delayed_crash_with_breakpoint_watchpoint/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/many_breakpoints/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/many_crash/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/many_signals/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/many_watchpoints/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/n_watch_n_break/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/signal_break/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/signal_delay_break/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/signal_delay_watch/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/signal_n_watch_n_break/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/signal_watch/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/signal_watch_break/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/two_breakpoint_threads/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/two_breakpoints_one_delay_signal/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/two_breakpoints_one_signal/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/two_breakpoints_one_watchpoint/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/two_watchpoint_threads/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/two_watchpoints_one_breakpoint/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/two_watchpoints_one_delay_breakpoint/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/two_watchpoints_one_signal/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/watch_break/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/watch_break_delay/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/watchpoint_delay_watchpoint_one_breakpoint/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/watchpoint_with_delay_watchpoint_threads/Makefile

 LEVEL = ../../../../make
 
 CXX_SOURCES := main.cpp
 
 ENABLE_THREADS := YES
 
-VPATH = ..
-
 include $(LEVEL)/Makefile.rules
+
+main.cpp: ../main.cpp
+  cp $< $@

packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py

     @expectedFailureAll(triple=re.compile('^mips'))
     # SystemZ also currently supports only one H/W watchpoint
     @expectedFailureAll(archs=['s390x'])
     @skipIfDarwin
     def test_hello_watchlocation(self):
         """Test watching a location with '-s size' option."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1, loc_exact=False)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchpoint/TestMyFirstWatchpoint.py

         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     @add_test_categories(["basic_process"])
     def test_hello_watchpoint_using_watchpoint_set(self):
         """Test a simple sequence of watchpoint creation and watchpoint hit."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

packages/Python/lldbsuite/test/functionalities/watchpoint/multi_watchpoint_slots/TestWatchpointMultipleSlots.py

 
     # This is a arm and aarch64 specific test case. No other architectures tested.
     @skipIf(archs=no_match(['arm', 'aarch64']))
     def test_multiple_watchpoints_on_same_word(self):
 
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Detect line number after which we are going to increment arrayName.
         loc_line = line_number('main.c', '// About to write byteArray')
 
         # Set a breakpoint on the line detected above.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.c", loc_line, num_expected_locations=1, loc_exact=True)

packages/Python/lldbsuite/test/functionalities/watchpoint/variable_out_of_scope/TestWatchedVarHitWhenInScope.py

     # Test hangs due to a kernel bug, see fdfeff0f in the linux kernel for details
     @skipIfTargetAndroid(api_levels=list(range(25+1)), archs=["aarch64", "arm"])
     @unittest2.expectedFailure("rdar://problem/18685649")
     def test_watched_var_should_only_hit_when_in_scope(self):
         """Test that a variable watchpoint should only hit when in scope."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped in main.
         lldbutil.run_break_set_by_symbol(
             self, "main", num_expected_locations=-1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/TestWatchpointCommands.py

         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
     def test_rw_watchpoint(self):
         """Test read_write watchpoint and expect to stop two times."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
     def test_rw_watchpoint_delete(self):
         """Test delete watchpoint and expect not to stop for watchpoint."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
     def test_rw_watchpoint_set_ignore_count(self):
         """Test watchpoint ignore count and expect to not to stop at all."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
     def test_rw_disable_after_first_stop(self):
         """Test read_write watchpoint but disable it after the first stop."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
     def test_rw_disable_then_enable(self):
         """Test read_write watchpoint, disable initially, then enable it."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1)
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line2, num_expected_locations=1)
 

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandLLDB.py

     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_command(self):
         """Test 'watchpoint command'."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_command_can_disable_a_watchpoint(self):
         """Test that 'watchpoint command' action can disable a watchpoint after it is triggered."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py

         oslist=["linux"],
         archs=["aarch64"],
         bugnumber="llvm.org/pr27710")
     def test_watchpoint_command(self):
         """Test 'watchpoint command'."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

         oslist=["linux"],
         archs=["aarch64"],
         bugnumber="llvm.org/pr27710")
     def test_continue_in_watchpoint_command(self):
         """Test continue in a watchpoint command."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

             substrs=[
                 'Watchpoint created',
                 'size = 4',
                 'type = w',
                 '%s:%d' %
                 (self.source,
                  self.decl)])
 
-        cmd_script_file = os.path.join(os.getcwd(), "watchpoint_command.py")
+        cmd_script_file = os.path.join(self.getSourceDir(),
+                                       "watchpoint_command.py")
         self.runCmd("command script import '%s'" % (cmd_script_file))
 
         self.runCmd(
             'watchpoint command add -F watchpoint_command.watchpoint_command')
 
         # List the watchpoint command we just added.
         self.expect("watchpoint command list 1",
                     substrs=['watchpoint_command.watchpoint_command'])

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/condition/TestWatchpointConditionCmd.py

     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_cond(self):
         """Test watchpoint condition."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.line, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_disable/TestWatchpointDisable.py

         """Set a watchpoint, disable it and make sure it doesn't get hit."""
 
         exe = self.getBuildArtifact("a.out")
         main_file_spec = lldb.SBFileSpec("main.c")
 
         # Create a target by the debugger.
         self.target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)
-        cwd = os.getcwd()
-        
 
         bkpt_before = self.target.BreakpointCreateBySourceRegex("Set a breakpoint here", main_file_spec)
         self.assertEqual(bkpt_before.GetNumLocations(),  1, "Failed setting the before breakpoint.")
 
         bkpt_after = self.target.BreakpointCreateBySourceRegex("We should have stopped", main_file_spec)
         self.assertEqual(bkpt_after.GetNumLocations(), 1, "Failed setting the after breakpoint.")
 
         process = self.target.LaunchSimple(

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/TestWatchpointSizes.py

     def test_four_byte_watchpoints_with_dword_selection(self):
         """Test to selectively watch two double words in an 8-byte dword array."""
         self.run_watchpoint_size_test('dwordArray', 2, '4')
 
     def run_watchpoint_size_test(self, arrayName, array_size, watchsize):
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Detect line number after which we are going to increment arrayName.
         loc_line = line_number('main.c', '// About to write ' + arrayName)
 
         # Set a breakpoint on the line detected above.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.c", loc_line, num_expected_locations=1, loc_exact=True)

packages/Python/lldbsuite/test/lang/c/conflicting-symbol/Makefile

 LEVEL := ../../../make
 
-LD_EXTRAS := -L. -l$(LIB_PREFIX)One -l$(LIB_PREFIX)Two
+LD_EXTRAS := -L. -LOne -l$(LIB_PREFIX)One -LTwo -l$(LIB_PREFIX)Two
 C_SOURCES := main.c
 
-main.o : CFLAGS_EXTRAS += -g -O0
-
 include $(LEVEL)/Makefile.rules
 
 .PHONY:
 a.out: lib_One lib_Two
 
 lib_%:
-  $(MAKE) -f $*.mk
+  mkdir -p $*
+  $(MAKE) VPATH=$(SRCDIR)/$* -I $(SRCDIR) -f $(SRCDIR)/$*.mk
 
 clean::
-  $(MAKE) -f One.mk clean
-  $(MAKE) -f Two.mk clean
+  $(MAKE) -f $(SRCDIR)/One.mk clean
+  $(MAKE) -f $(SRCDIR)/Two.mk clean

packages/Python/lldbsuite/test/lang/c/conflicting-symbol/One.mk

 LEVEL := ../../../make
 
 DYLIB_NAME := One
-DYLIB_C_SOURCES := One/One.c One/OneConstant.c
+DYLIB_C_SOURCES := One.c OneConstant.c
 DYLIB_ONLY := YES
 
 include $(LEVEL)/Makefile.rules
 
 CFLAGS_EXTRAS += -fPIC
 
-One/OneConstant.o: One/OneConstant.c
+OneConstant.o: OneConstant.c
   $(CC) $(CFLAGS_NO_DEBUG) -c $< -o $@

packages/Python/lldbsuite/test/lang/c/conflicting-symbol/Two.mk

 LEVEL := ../../../make
 
 DYLIB_NAME := Two
-DYLIB_C_SOURCES := Two/Two.c Two/TwoConstant.c
+DYLIB_C_SOURCES := Two.c TwoConstant.c
 DYLIB_ONLY := YES
 
 include $(LEVEL)/Makefile.rules
 
 CFLAGS_EXTRAS += -fPIC
 
-Two/TwoConstant.o: Two/TwoConstant.c
+TwoConstant.o: TwoConstant.c
   $(CC) $(CFLAGS_NO_DEBUG) -c $< -o $@

packages/Python/lldbsuite/test/lang/c/tls_globals/TestTlsGlobals.py

             # startup
             if "LD_LIBRARY_PATH" in os.environ:
                 self.runCmd(
                     "settings set target.env-vars " +
                     self.dylibPath +
                     "=" +
                     os.environ["LD_LIBRARY_PATH"] +
                     ":" +
-                    os.getcwd())
+                    self.getBuildDir())
             else:
                 self.runCmd("settings set target.env-vars " +
-                            self.dylibPath + "=" + os.getcwd())
+                            self.dylibPath + "=" + self.getBuildDir())
             self.addTearDownHook(
                 lambda: self.runCmd(
                     "settings remove target.env-vars " +
                     self.dylibPath))
 
     # TLS works differently on Windows, this would need to be implemented
     # separately.
     @skipIfWindows

packages/Python/lldbsuite/test/lang/c/unions/TestUnionMembers.py

         self.assertTrue(val.IsValid())
         val = frame.EvaluateExpression("u.s")
         self.assertTrue(val.IsValid())
         self.assertEqual(val.GetNumChildren(), 2)
 
     def _load_exe(self):
         self.build()
 
-        cwd = os.getcwd()
-
-        src_file = os.path.join(cwd, "main.c")
+        src_file = os.path.join(self.getSourceDir(), "main.c")
         self.src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(self.src_file_spec.IsValid(), "breakpoint file")
 
         # Get the path of the executable
         exe_path = self.getBuildArtifact("a.out")
 
         # Load the executable
         self.target = self.dbg.CreateTarget(exe_path)
         self.assertTrue(self.target.IsValid(), VALID_TARGET)

packages/Python/lldbsuite/test/lang/cpp/chained-calls/TestCppChainedCalls.py

def test_with_run_command(self):
         self.build()
 
         # Get main source file
         src_file = "main.cpp"
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "Main source file")
 
         # Get the path of the executable
-        cwd = os.getcwd()
-        exe_file = self.getBuildArtifact("a.out")
-        exe_path = os.path.join(cwd, exe_file)
+        exe_path = self.getBuildArtifact("a.out")
 
         # Load the executable
         target = self.dbg.CreateTarget(exe_path)
         self.assertTrue(target.IsValid(), VALID_TARGET)
 
         # Break on main function
         main_breakpoint = target.BreakpointCreateBySourceRegex(
             "break here", src_file_spec)

packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestCppValueCast.py

         self.d_virtual = {
             'CXX_SOURCES': self.source,
             'EXE': self.exe_name,
             'CFLAGS_EXTRAS': '-DDO_VIRTUAL_INHERITANCE'}
         self.d_regular = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     def do_sbvalue_cast(self, exe_name):
         """Test SBValue::Cast(SBType) API for C++ types."""
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
 
         # Create a target from the debugger.
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Set up our breakpoints:
 

packages/Python/lldbsuite/test/lang/cpp/global_operators/TestCppGlobalOperators.py

def prepare_executable_and_get_frame(self):
         self.build()
 
         # Get main source file
         src_file = "main.cpp"
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "Main source file")
 
         # Get the path of the executable
-        cwd = os.getcwd()
         exe_path = self.getBuildArtifact("a.out")
 
         # Load the executable
         target = self.dbg.CreateTarget(exe_path)
         self.assertTrue(target.IsValid(), VALID_TARGET)
 
         # Break on main function
         main_breakpoint = target.BreakpointCreateBySourceRegex(

packages/Python/lldbsuite/test/lang/cpp/gmodules/TestWithModuleDebugging.py

 import lldb
 import os
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestWithGmodulesDebugInfo(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(["gmodules"])
     def test_specialized_typedef_from_pch(self):
         self.build()
-        cwd = os.getcwd()
 
-        src_file = os.path.join(cwd, "main.cpp")
+        src_file = os.path.join(self.getSourceDir(), "main.cpp")
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "breakpoint file")
 
         # Get the path of the executable
         exe_path = self.getBuildArtifact("a.out")
 
         # Load the executable
         target = self.dbg.CreateTarget(exe_path)

packages/Python/lldbsuite/test/lang/cpp/incomplete-types/Makefile

 
 limit: main.o length_limit.o a.o
   $(CXX) main.o length_limit.o a.o -o limit $(LDFLAGS)
 
 nolimit: main.o length_nolimit.o a.o
   $(CXX) main.o length_nolimit.o a.o -o nolimit $(LDFLAGS)
 
 main.o: main.cpp
-  $(CXX) $(CFLAGS_LIMIT) main.cpp -o main.o
+  $(CXX) $(CFLAGS_LIMIT) $(SRCDIR)/main.cpp -o main.o
 
 length_limit.o: length.cpp
-  $(CXX) $(CFLAGS_LIMIT) length.cpp -o length_limit.o
+  $(CXX) $(CFLAGS_LIMIT) $(SRCDIR)/length.cpp -o length_limit.o
 
 length_nolimit.o: length.cpp
-  $(CXX) $(CFLAGS_NO_LIMIT) length.cpp -o length_nolimit.o
+  $(CXX) $(CFLAGS_NO_LIMIT) $(SRCDIR)/length.cpp -o length_nolimit.o
 
 a.o: a.cpp
-  $(CXX) $(CFLAGS_NO_DEBUG) -c a.cpp -o a.o
+  $(CXX) $(CFLAGS_NO_DEBUG) -c $(SRCDIR)/a.cpp -o a.o
 
 clean: OBJECTS += limit nolimit length_limit.o length_nolimit.o length_limit.dwo length_nolimit.dwo
 
 include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py

 
     def get_test_frame(self, exe):
         # Get main source file
         src_file = "main.cpp"
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "Main source file")
 
         # Get the path of the executable
-        cwd = os.getcwd()
-        exe_path = os.path.join(cwd, exe)
+        exe_path = self.getBuildArtifact(exe)
 
         # Load the executable
         target = self.dbg.CreateTarget(exe_path)
         self.assertTrue(target.IsValid(), VALID_TARGET)
 
         # Break on main function
         main_breakpoint = target.BreakpointCreateBySourceRegex(
             "break here", src_file_spec)

packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/TestWithLimitDebugInfo.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestWithLimitDebugInfo(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIf(debug_info=no_match(["dwarf"]))
     def test_limit_debug_info(self):
         self.build()
 
-        cwd = os.getcwd()
-
-        src_file = os.path.join(cwd, "main.cpp")
+        src_file = os.path.join(self.getSourceDir(), "main.cpp")
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "breakpoint file")
 
         # Get the path of the executable
         exe_path = self.getBuildArtifact("a.out")
 
         # Load the executable
         target = self.dbg.CreateTarget(exe_path)

packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/Makefile

 LEVEL := ../../../make
 
 LD_EXTRAS := -L. -l$(LIB_PREFIX)a -l$(LIB_PREFIX)b
 CXX_SOURCES := main.cpp
 
 include $(LEVEL)/Makefile.rules
 
 .PHONY:
 a.out: lib_a lib_b
 
 lib_%:
-  $(MAKE) -f $*.mk
+  $(MAKE) VPATH=$(VPATH) -f $(SRCDIR)/$*.mk
 
 hidden_lib_d:
   $(MAKE) -C hidden
 
 clean::
-  $(MAKE) -f a.mk clean
-  $(MAKE) -f b.mk clean
+  $(MAKE) -f $(SRCDIR)/a.mk clean
+  $(MAKE) -f $(SRCDIR)/b.mk clean

packages/Python/lldbsuite/test/lang/cpp/nsimport/TestCppNsImport.py

class TestCppNsImport(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def test_with_run_command(self):
         """Tests imported namespaces in C++."""
         self.build()
 
         # Get main source file
-        src_file = "main.cpp"
+        src_file = os.path.join(self.getSourceDir(), "main.cpp")
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "Main source file")
 
         # Get the path of the executable
-        cwd = os.getcwd()
         exe_path = self.getBuildArtifact("a.out")
 
         # Load the executable
         target = self.dbg.CreateTarget(exe_path)
         self.assertTrue(target.IsValid(), VALID_TARGET)
 
         # Break on main function
         break_0 = target.BreakpointCreateBySourceRegex(

packages/Python/lldbsuite/test/lang/cpp/scope/TestCppScope.py

     @expectedFailureAll(oslist=["windows"])
     def test_c(self):
         self.do_test(True)
     
     def do_test(self, test_c):
         self.build()
 
         # Get main source file
-        src_file = "main.cpp"
+        src_file = os.path.join(self.getSourceDir(), "main.cpp")
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "Main source file")
 
         # Get the path of the executable
-        cwd = os.getcwd()
         exe_path = self.getBuildArtifact("a.out")
 
         # Load the executable
         target = self.dbg.CreateTarget(exe_path)
         self.assertTrue(target.IsValid(), VALID_TARGET)
 
         # Break on main function
         main_breakpoint = target.BreakpointCreateBySourceRegex(

packages/Python/lldbsuite/test/lang/objc/conflicting-definition/Makefile

 LEVEL = ../../../make
 
-CC ?= clang
-ifeq "$(ARCH)" ""
-  ARCH = x86_64
-endif
+LD_EXTRAS = -lobjc -framework Foundation
 
-ifeq "$(OS)" ""
-  OS = $(shell uname -s)
-endif
+include $(LEVEL)/Makefile.rules
 
-CFLAGS ?= -g -O0
-
-ifeq "$(OS)" "Darwin"
-  CFLAGS += -arch $(ARCH)
-endif
-
-LDFLAGS = $(CFLAGS) -lobjc -framework Foundation
-
-all: a.out libTest.dylib libTestExt.dylib
+all: a.out
 
 libTest.dylib:  Test/Test.m
-  $(CC) $(CFLAGS) -I. -c -o Test.o Test/Test.m
-  $(CC) $(LDFLAGS) -shared -o libTest.dylib Test.o
-  dsymutil libTest.dylib
+  mkdir -p Test
+  $(MAKE) MAKE_DSYM=YES VPATH=$(SRCDIR) -I $(SRCDIR) -f $(SRCDIR)/Test/Test.mk all
 
 libTestExt.dylib: TestExt/TestExt.m
-  $(CC) $(CFLAGS) -I. -c -o TestExt.o TestExt/TestExt.m
-  $(CC) $(LDFLAGS) -L. -lTest -shared -o libTestExt.dylib TestExt.o
-  dsymutil libTestExt.dylib
+  mkdir -p TestExt
+  $(MAKE) MAKE_DSYM=YES VPATH=$(SRCDIR) -I $(SRCDIR) -f $(SRCDIR)/TestExt/TestExt.mk all
 
 a.out: main.m libTest.dylib libTestExt.dylib
-  $(CC) $(LDFLAGS) -I. -L. -lTest -lTestExt -o a.out main.m 
-
-.PHONY: clean
+  $(CC) $(LDFLAGS) -I$(SRCDIR) -L. -lTest -lTestExt -o a.out $<
 
-clean:
-  rm -rf libTest.dylib libTestExt.dylib a.out Test.o TestExt.o libTest.dylib.dSYM libTest.dylib.dSYM
+clean::
+  rm -rf libTest.dylib libTestExt.dylib a.out Test.o TestExt.o libTest.dylib.dSYM libTestExt.dylib.dSYM
+  $(MAKE) MAKE_DSYM=YES VPATH=$(SRCDIR) -I $(SRCDIR) -f $(SRCDIR)/Test/Test.mk clean
+  $(MAKE) MAKE_DSYM=YES VPATH=$(SRCDIR) -I $(SRCDIR) -f $(SRCDIR)/TestExt/TestExt.mk clean

packages/Python/lldbsuite/test/lang/objc/conflicting-definition/Test/Test.mk

+LEVEL = ../../../make
+
+DYLIB_NAME := Test
+DYLIB_ONLY := YES
+CFLAGS_EXTRAS = -I$(SRCDIR)/..
+LD_EXTRAS = -lobjc -framework Foundation
+
+DYLIB_OBJC_SOURCES = Test/Test.m
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/lang/objc/conflicting-definition/TestExt/TestExt.mk

+LEVEL = ../../../make
+
+DYLIB_NAME := TestExt
+DYLIB_ONLY := YES
+CFLAGS_EXTRAS = -I$(SRCDIR)/..
+LD_EXTRAS = -L. -lTest -lobjc -framework Foundation
+
+DYLIB_OBJC_SOURCES = TestExt/TestExt.m
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/lang/objc/foundation/TestObjCMethods.py

             sym_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         global file_index
         # Log any DWARF lookups
         ++file_index
         logfile = os.path.join(
-            os.getcwd(),
+            self.getBuildDir(),
             "dwarf-lookups-" +
             self.getArchitecture() +
             "-" +
             str(file_index) +
             ".txt")
         self.runCmd("log enable -f %s dwarf lookups" % (logfile))
         self.runCmd("expr self")
         self.runCmd("log disable dwarf lookups")

packages/Python/lldbsuite/test/lang/objc/foundation/TestObjectDescriptionAPI.py

     # rdar://problem/10857337
     @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test_find_global_variables_then_object_description(self):
         """Exercise SBTarget.FindGlobalVariables() API."""
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        exe = os.path.join(os.getcwd(), 'b.out')
+        exe = self.getBuildArtifact('b.out')
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 

packages/Python/lldbsuite/test/lang/objc/hidden-ivars/TestHiddenIvars.py

                 "frame variable k->bar",
                 VARIABLES_DISPLAYED_CORRECTLY,
                 substrs=["= 3"])
 
     def common_setup(self, strip):
 
         if strip:
             self.assertTrue(subprocess.call(
-                ['/usr/bin/strip', '-Sx', 'libInternalDefiner.dylib']) == 0, 'stripping dylib succeeded')
-            self.assertTrue(subprocess.call(['/bin/rm',
-                                             '-rf',
-                                             'libInternalDefiner.dylib.dSYM']) == 0,
+                ['/usr/bin/strip', '-Sx',
+                 self.getBuildArtifact('libInternalDefiner.dylib')]) == 0,
+                            'stripping dylib succeeded')
+            self.assertTrue(subprocess.call(
+                ['/bin/rm', '-rf',
+                 self.getBuildArtifact('libInternalDefiner.dylib.dSYM')]) == 0,
                             'remove dylib dSYM file succeeded')
             self.assertTrue(subprocess.call(['/usr/bin/strip', '-Sx',
                                              self.getBuildArtifact("a.out")
                                             ]) == 0,
                             'stripping a.out succeeded')
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)

packages/Python/lldbsuite/test/lang/objc/ivar-IMP/Makefile

 ifeq "$(OS)" "Darwin"
         CFLAGS += -arch $(ARCH)
     CFLAGS_NO_DEBUG += -arch $(ARCH)
 endif
 
 all: aout
 
 aout: 
-  $(CC) $(CFLAGS_NO_DEBUG) myclass.m -c -o myclass.o
-  $(CC) $(CFLAGS) myclass.o repro.m -framework Foundation
+  $(CC) $(CFLAGS_NO_DEBUG) $(SRCDIR)/myclass.m -c -o myclass.o
+  $(CC) $(CFLAGS) myclass.o $(SRCDIR)/repro.m -framework Foundation
 
 clean::
   rm -f myclass.o
 
 include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/lang/objc/modules-incomplete/TestIncompleteModules.py

                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
         self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
                     substrs=[' resolved, hit count = 1'])
 
         self.runCmd(
             "settings set target.clang-module-search-paths \"" +
-            os.getcwd() +
+            self.getSourceDir() +
             "\"")
 
         self.expect("expr @import myModule; 3", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["int", "3"])
 
         self.expect(
             "expr [myObject privateMethod]",
             VARIABLES_DISPLAYED_CORRECTLY,

packages/Python/lldbsuite/test/lang/objc/modules-inline-functions/TestModulesInlineFunctions.py

                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
         self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
                     substrs=[' resolved, hit count = 1'])
 
         self.runCmd(
             "settings set target.clang-module-search-paths \"" +
-            os.getcwd() +
+            self.getSourceDir() +
             "\"")
 
         self.expect("expr @import myModule; 3", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["int", "3"])
 
         self.expect("expr isInline(2)", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["4"])

packages/Python/lldbsuite/test/lang/objc/objc-dyn-sbtype/TestObjCDynamicSBType.py

 
     @skipIf(archs="i[3-6]86")
     def test_dyn(self):
         """Test that we are able to properly report a usable dynamic type."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self,
             self.main_source,
             self.line,
             num_expected_locations=1,
             loc_exact=True)

packages/Python/lldbsuite/test/lang/objc/objc-ivar-stripped/Makefile

 LEVEL = ../../../make
 
 OBJC_SOURCES := main.m
 LDFLAGS = $(CFLAGS) -lobjc -framework Foundation
 
-default:        a.out.stripped
+all:        a.out.stripped
 
 a.out.stripped: a.out.dSYM
   strip -o a.out.stripped a.out
 
 clean::
   rm -f a.out.stripped
   rm -rf a.out.stripped.dSYM
 
 include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/lang/objc/print-obj/TestPrintObj.py

         Set a breakpoint on the line in my_pthread_routine.  Then switch threads
         to the main thread, and do print the lock_me object.  Since that will
         try to get the lock already gotten by my_pthread_routime thread, it will
         have to switch to running all threads, and that should then succeed.
         """
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        exe = os.path.join(os.getcwd(), 'b.out')
+        exe = self.getBuildArtifact('b.out')
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
         self.runCmd("breakpoint list")
 

packages/Python/lldbsuite/test/lang/objc/radar-9691614/TestObjCMethodReturningBOOL.py

         self.line = line_number(self.main_source, '// Set breakpoint here.')
 
     def test_method_ret_BOOL(self):
         """Test that objective-c method returning BOOL works correctly."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.expect("process status", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=[" at %s:%d" % (self.main_source, self.line),
                              "stop reason = breakpoint"])
 
         # rdar://problem/9691614
         self.runCmd('p (int)[my isValid]')

packages/Python/lldbsuite/test/lang/objc/rdar-10967107/TestRdar10967107.py

         self.line = line_number(self.main_source, '// Set breakpoint here.')
 
     def test_cfrange_diff_cfgregoriandate(self):
         """Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self,
             self.main_source,
             self.line,
             num_expected_locations=1,
             loc_exact=True)

packages/Python/lldbsuite/test/lang/objc/rdar-11355592/TestRdar11355592.py

         self.line = line_number(self.main_source, '// Set breakpoint here.')
 
     def test_charstar_dyntype(self):
         """Test that we do not attempt to make a dynamic type for a 'const char*'"""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self,
             self.main_source,
             self.line,
             num_expected_locations=1,
             loc_exact=True)

packages/Python/lldbsuite/test/lang/objc/rdar-12408181/TestRdar12408181.py

         """Test that we are able to find out how many children NSWindow has."""
 
         self.skipTest("Skipping this test due to timeout flakiness")
 
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self,
             self.main_source,
             self.line,
             num_expected_locations=1,
             loc_exact=True)

packages/Python/lldbsuite/test/lldbinline.py

             # The test was skipped altogether.
             return ""
         elif self.using_dsym:
             return "-N dwarf %s" % (self.mydir)
         else:
             return "-N dsym %s" % (self.mydir)
 
     def BuildMakefile(self):
-        if os.path.exists("Makefile"):
+        self.makeBuildDir()
+        makefilePath = self.getBuildArtifact("Makefile")
+        if os.path.exists(makefilePath):
             return
 
         categories = {}
 
-        for f in os.listdir(os.getcwd()):
+        for f in os.listdir(self.getSourceDir()):
             t = source_type(f)
             if t:
                 if t in list(categories.keys()):
                     categories[t].append(f)
                 else:
                     categories[t] = [f]
 
-        makefile = open("Makefile", 'w+')
+        makefile = open(makefilePath, 'w+')
 
         level = os.sep.join(
             [".."] * len(self.mydir.split(os.sep))) + os.sep + "make"
 
         makefile.write("LEVEL = " + level + "\n")
 
         for t in list(categories.keys()):
             line = t + " := " + " ".join(categories[t])

         makefile.write("include $(LEVEL)/Makefile.rules\n")
         makefile.write("\ncleanup:\n\trm -f Makefile *.d\n\n")
         makefile.flush()
         makefile.close()
 
     @add_test_categories(["dsym"])
     def __test_with_dsym(self):
         self.using_dsym = True
+        self.debug_info = "dsym"
         self.BuildMakefile()
-        self.buildDsym()
+        self.build()
         self.do_test()
 
     @add_test_categories(["dwarf"])
     def __test_with_dwarf(self):
         self.using_dsym = False
+        self.debug_info = "dwarf"
         self.BuildMakefile()
-        self.buildDwarf()
+        self.build()
         self.do_test()
 
     @add_test_categories(["dwo"])
     def __test_with_dwo(self):
         self.using_dsym = False
+        self.debug_info = "dwo"
         self.BuildMakefile()
-        self.buildDwo()
+        self.build()
         self.do_test()
 
     @add_test_categories(["gmodules"])
     def __test_with_gmodules(self):
         self.using_dsym = False
+        self.debug_info = "gmodules"
         self.BuildMakefile()
-        self.buildGModules()
+        self.build()
         self.do_test()
 
     def execute_user_command(self, __command):
         exec(__command, globals(), locals())
 
     def do_test(self):
         exe = self.getBuildArtifact("a.out")
-        source_files = [f for f in os.listdir(os.getcwd()) if source_type(f)]
+        source_files = [f for f in os.listdir(self.getSourceDir())
+                        if source_type(f)]
         target = self.dbg.CreateTarget(exe)
 
         parser = CommandParser()
         parser.parse_source_files(source_files)
         parser.set_breakpoints(target)
 
-        process = target.LaunchSimple(None, None, os.getcwd())
+        process = target.LaunchSimple(None, None, self.getBuildDir())
 
         while lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint):
             thread = lldbutil.get_stopped_thread(
                 process, lldb.eStopReasonBreakpoint)
             breakpoint_id = thread.GetStopReasonDataAtIndex(0)
             parser.handle_breakpoint(self, breakpoint_id)
             process.Continue()
 

packages/Python/lldbsuite/test/lldbtest.py

         # Change current working directory if ${LLDB_TEST} is defined.
         # See also dotest.py which sets up ${LLDB_TEST}.
         if ("LLDB_TEST" in os.environ):
             full_dir = os.path.join(os.environ["LLDB_TEST"], cls.mydir)
             if traceAlways:
                 print("Change dir to:", full_dir, file=sys.stderr)
             os.chdir(os.path.join(os.environ["LLDB_TEST"], cls.mydir))
 
+        # TODO: Obsolete this by creating one working dir per configuration.
         if debug_confirm_directory_exclusivity:
             import lock
             cls.dir_lock = lock.Lock(os.path.join(full_dir, ".dirlock"))
             try:
                 cls.dir_lock.try_acquire()
                 # write the class that owns the lock into the lock file
                 cls.dir_lock.handle.write(cls.__name__)
             except IOError as ioerror:

             # TODO: Make it working on Windows when we need it for remote debugging support
             # TODO: Replace the heuristic to remove the files with a logic what collects the
             # list of files we have to remove during test runs.
             shell_cmd = lldb.SBPlatformShellCommand(
                 "rm %s/*" % remote_test_dir)
             lldb.remote_platform.Run(shell_cmd)
         self.addTearDownHook(clean_working_directory)
 
+    def getSourceDir(self):
+        """Return the full path to the current test."""
+        return os.path.join(os.environ["LLDB_TEST"], self.mydir)
+
+    def getBuildDir(self):
+        """Return the full path to the current test."""
+        return os.path.join(os.environ["LLDB_BUILD"], self.mydir)
+    
+     
+    def makeBuildDir(self):
+        """Create the test-specific working directory."""
+        # See also dotest.py which sets up ${LLDB_BUILD}.
+        try: os.makedirs(self.getBuildDir())
+        except: pass
+ 
     def getBuildArtifact(self, name="a.out"):
         """Return absolute path to an artifact in the test's build directory."""
-        return os.path.join(os.getcwd(), name)
+        return os.path.join(self.getBuildDir(), name)
+ 
+    def getSourcePath(self, name):
+        """Return absolute path to a file in the test's source directory."""
+        return os.path.join(self.getSourceDir(), name)
 
     def setUp(self):
         """Fixture for unittest test case setup.
 
         It works with the test driver to conditionally skip tests and does other
         initializations."""
         #import traceback
         # traceback.print_stack()

             self.dsym = os.path.join(self.framework_dir, 'LLDB.framework', 'LLDB')
             # If the framework binary doesn't exist, assume we didn't actually
             # build a framework, and fallback to standard *nix behavior by
             # setting framework_dir and dsym to None.
             if not os.path.exists(self.dsym):
                 self.framework_dir = None
                 self.dsym = None
                 self.darwinWithFramework = False
+        self.makeBuildDir()
 
     def setAsync(self, value):
         """ Sets async mode to True/False and ensures it is reset after the testcase completes."""
         old_async = self.dbg.GetAsync()
         self.dbg.SetAsync(value)
         self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
 
     def cleanupSubprocesses(self):

         else:
             stdflag = "-std=c++11"
         return stdflag
 
     def buildDriver(self, sources, exe_name):
         """ Platform-specific way to build a program that links with LLDB (via the liblldb.so
             or LLDB.framework).
         """
-
         stdflag = self.getstdFlag()
         stdlibflag = self.getstdlibFlag()
 
         lib_dir = os.environ["LLDB_LIB_DIR"]
         if self.hasDarwinFramework():
             d = {'CXX_SOURCES': sources,
                  'EXE': exe_name,
                  'CFLAGS_EXTRAS': "%s %s" % (stdflag, stdlibflag),

              'EXE': exe_name}
         self.buildDefault(dictionary=d)
 
     def buildDefault(
             self,
             architecture=None,
             compiler=None,
             dictionary=None,
-            clean=True):
+            clean=True,
+            testdir=None):
         """Platform specific way to build the default binaries."""
+        if not testdir:
+            testdir = self.mydir
         module = builder_module()
+        self.makeBuildDir()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if not module.buildDefault(
-                self,
-                architecture,
-                compiler,
-                dictionary,
-                clean):
+        if not module.buildDefault(self, architecture, compiler,
+                                   dictionary, clean, testdir):
             raise Exception("Don't know how to build default binary")
 
     def buildDsym(
             self,
             architecture=None,
             compiler=None,
             dictionary=None,
-            clean=True):
+            clean=True,
+            testdir=None):
         """Platform specific way to build binaries with dsym info."""
+        if not testdir:
+            testdir = self.mydir
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if not module.buildDsym(
-                self,
-                architecture,
-                compiler,
-                dictionary,
-                clean):
+        if not module.buildDsym(self, architecture, compiler,
+                                dictionary, clean, testdir):
             raise Exception("Don't know how to build binary with dsym")
 
     def buildDwarf(
             self,
             architecture=None,
             compiler=None,
             dictionary=None,
-            clean=True):
+            clean=True,
+            testdir=None):
         """Platform specific way to build binaries with dwarf maps."""
+        if not testdir:
+            testdir = self.mydir
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if not module.buildDwarf(
-                self,
-                architecture,
-                compiler,
-                dictionary,
-                clean):
+        if not module.buildDwarf(self, architecture, compiler,
+                                   dictionary, clean, testdir):
             raise Exception("Don't know how to build binary with dwarf")
 
     def buildDwo(
             self,
             architecture=None,
             compiler=None,
             dictionary=None,
-            clean=True):
+            clean=True,
+            testdir=None):
         """Platform specific way to build binaries with dwarf maps."""
+        if not testdir:
+            testdir = self.mydir
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if not module.buildDwo(
-                self,
-                architecture,
-                compiler,
-                dictionary,
-                clean):
+        if not module.buildDwo(self, architecture, compiler,
+                                   dictionary, clean, testdir):
             raise Exception("Don't know how to build binary with dwo")
 
     def buildGModules(
             self,
             architecture=None,
             compiler=None,
             dictionary=None,
-            clean=True):
+            clean=True,
+            testdir=None):
         """Platform specific way to build binaries with gmodules info."""
+        if not testdir:
+            testdir = self.mydir
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if not module.buildGModules(
-                self,
-                architecture,
-                compiler,
-                dictionary,
-                clean):
+        if not module.buildGModules(self, architecture, compiler,
+                                   dictionary, clean, testdir):
             raise Exception("Don't know how to build binary with gmodules")
 
     def buildGo(self):
         """Build the default go binary.
         """
         exe = self.getBuildArtifact("a.out")
         system([[which('go'), 'build -gcflags "-N -l" -o %s main.go' % exe]])
 

     # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
     maxLaunchCount = 3
 
     # Time to wait before the next launching attempt in second(s).
     # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
     timeWaitNextLaunch = 1.0
 
     def generateSource(self, source):
+        self.makeBuildDir()
         template = source + '.template'
-        temp = os.path.join(os.getcwd(), template)
+        temp = os.path.join(self.getSourceDir(), template)
         with open(temp, 'r') as f:
             content = f.read()
             
         public_api_dir = os.path.join(
             os.environ["LLDB_SRC"], "include", "lldb", "API")
 
         # Look under the include/lldb/API directory and add #include statements
         # for all the SB API headers.
         public_headers = os.listdir(public_api_dir)
         # For different platforms, the include statement can vary.
         if self.hasDarwinFramework():
             include_stmt = "'#include <%s>' % os.path.join('LLDB', header)"
         else:
             include_stmt = "'#include <%s>' % os.path.join('" + public_api_dir + "', header)"
         list = [eval(include_stmt) for header in public_headers if (
             header.startswith("SB") and header.endswith(".h"))]
         includes = '\n'.join(list)
         new_content = content.replace('%include_SB_APIs%', includes)
-        src = os.path.join(os.getcwd(), source)
+        src = os.path.join(self.getBuildDir(), source)
         with open(src, 'w') as f:
             f.write(new_content)
 
         self.addTearDownHook(lambda: os.remove(src))
 
     def setUp(self):
         #import traceback
         # traceback.print_stack()

             # "libFoo.dylib" or "libFoo.so", or "Foo.so" for "Foo.so" or "libFoo.so", or just a
             # basename like "libFoo.so". So figure out which one it is and resolve the local copy
             # of the shared library accordingly
             if os.path.isfile(name):
                 local_shlib_path = name  # name is the full path to the local shared library
             else:
                 # Check relative names
                 local_shlib_path = os.path.join(
-                    os.getcwd(), shlib_prefix + name + shlib_extension)
+                    self.getBuildDir(), shlib_prefix + name + shlib_extension)
                 if not os.path.exists(local_shlib_path):
                     local_shlib_path = os.path.join(
-                        os.getcwd(), name + shlib_extension)
+                        self.getBuildDir(), name + shlib_extension)
                     if not os.path.exists(local_shlib_path):
-                        local_shlib_path = os.path.join(os.getcwd(), name)
+                        local_shlib_path = os.path.join(self.getBuildDir(), name)
 
                 # Make sure we found the local shared library in the above code
                 self.assertTrue(os.path.exists(local_shlib_path))
 
             # Add the shared library to our target
             shlib_module = target.AddModule(local_shlib_path, None, None, None)
             if lldb.remote_platform:
                 # We must set the remote install location if we want the shared library

     def get_process_working_directory(self):
         '''Get the working directory that should be used when launching processes for local or remote processes.'''
         if lldb.remote_platform:
             # Remote tests set the platform working directory up in
             # TestBase.setUp()
             return lldb.remote_platform.GetWorkingDirectory()
         else:
             # local tests change directory into each test subdirectory
-            return os.getcwd()
+            return self.getBuildDir()
 
     def tearDown(self):
         #import traceback
         # traceback.print_stack()
 
         # Ensure all the references to SB objects have gone away so that we can
         # be sure that all test-specific resources have been freed before we
         # attempt to delete the targets.
         gc.collect()
 
         # Delete the target(s) from the debugger as a general cleanup step.
         # This includes terminating the process for each target, if any.
         # We'd like to reuse the debugger for our next test without incurring
         # the initialization overhead.
         targets = []
         for target in self.dbg:
             if target:
                 targets.append(target)
                 process = target.GetProcess()
                 if process:
                     rc = self.invoke(process, "Kill")
                     self.assertTrue(rc.Success(), PROCESS_KILLED)
         for target in targets:
             self.dbg.DeleteTarget(target)

     def build(
             self,
             architecture=None,
             compiler=None,
             dictionary=None,
             clean=True):
         """Platform specific way to build the default binaries."""
         module = builder_module()
+        self.makeBuildDir()
+
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if self.debug_info is None:
-            return self.buildDefault(architecture, compiler, dictionary, clean)
+            return self.buildDefault(architecture, compiler, dictionary,
+                                     clean, self.mydir)
         elif self.debug_info == "dsym":
-            return self.buildDsym(architecture, compiler, dictionary, clean)
+            return self.buildDsym(architecture, compiler, dictionary,
+                                  clean, self.mydir)
         elif self.debug_info == "dwarf":
-            return self.buildDwarf(architecture, compiler, dictionary, clean)
+            return self.buildDwarf(architecture, compiler, dictionary,
+                                   clean, self.mydir)
         elif self.debug_info == "dwo":
-            return self.buildDwo(architecture, compiler, dictionary, clean)
+            return self.buildDwo(architecture, compiler, dictionary,
+                                 clean, self.mydir)
         elif self.debug_info == "gmodules":
-            return self.buildGModules(
-                architecture, compiler, dictionary, clean)
+            return self.buildGModules(architecture, compiler, dictionary,
+                                      clean, self.mydir)
         else:
             self.fail("Can't build for debug info: %s" % self.debug_info)
 
     def run_platform_command(self, cmd):
         platform = self.dbg.GetSelectedPlatform()
         shell_command = lldb.SBPlatformShellCommand(cmd)
         err = platform.Run(shell_command)
         return (err, shell_command.GetStatus(), shell_command.GetOutput())

packages/Python/lldbsuite/test/logging/TestLogging.py

             self.command_log_tests("dwarf")
 
     def command_log_tests(self, type):
         exe = self.getBuildArtifact("a.out")
         self.expect("file " + exe,
                     patterns=["Current executable set to .*a.out"])
 
         log_file = os.path.join(
-            os.getcwd(),
+            self.getBuildDir(),
             "lldb-commands-log-%s-%s-%s.txt" %
             (type,
              os.path.basename(
                  self.getCompiler()),
                 self.getArchitecture()))
 
         if (os.path.exists(log_file)):
             os.remove(log_file)

packages/Python/lldbsuite/test/macosx/add-dsym/Makefile

 CC ?= clang
 ifeq "$(ARCH)" ""
   ARCH = x86_64
 endif
 
 ifeq "$(OS)" ""
   OS = $(shell uname -s)
 endif
 
 CFLAGS ?= -g -O0
 
 ifeq "$(OS)" "Darwin"
   CFLAGS += -arch $(ARCH)
 endif
 
-all: clean
+all: main.c clean
   mkdir hide.app
   mkdir hide.app/Contents
-  $(CC) $(CFLAGS) -g main.c
+  $(CC) $(CFLAGS) -g $<
   mv a.out.dSYM hide.app/Contents
   strip -x a.out
 
 clean:
   rm -rf a.out a.out.dSYM hide.app

packages/Python/lldbsuite/test/macosx/find-app-in-bundle/Makefile

+SRCDIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))/
+
 CC ?= clang
 
 ifeq "$(ARCH)" ""
      ARCH = x86_64
 endif
 
 CFLAGS ?= -g -O0 -arch $(ARCH)
 
 all:  TestApp.app/Contents/MacOS/TestApp
 
-TestApp.app/Contents/MacOS/TestApp: 
-  $(CC) $(CFLAGS) -o TestApp main.c
+TestApp.app/Contents/MacOS/TestApp: $(SRCDIR)/main.c
+  $(CC) $(CFLAGS) -o TestApp $<
+  rm -rf TestApp.app
+  cp -r $(SRCDIR)/TestApp.app .
   mv TestApp TestApp.app/Contents/MacOS/TestApp
   mv TestApp.dSYM TestApp.app.dSYM
+
 clean:
   rm -rf TestApp.app/Contents/MacOS/TestApp TestApp.app.dSYM

packages/Python/lldbsuite/test/macosx/find-app-in-bundle/TestFindAppInBundle.py

 
     def find_app_in_bundle_test(self):
         """This reads in the .app, makes sure we get the right binary and can run it."""
 
         # This function starts a process, "a.out" by default, sets a source
         # breakpoint, runs to it, and returns the thread, process & target.
         # It optionally takes an SBLaunchOption argument if you want to pass
         # arguments or environment variables.
-        exe = os.path.join(os.getcwd(), "TestApp.app")
+        exe = self.getBuildArtifact("TestApp.app")
         error = lldb.SBError()
         target = self.dbg.CreateTarget(exe, None, None, False, error)
         self.assertTrue(error.Success(), "Could not create target: %s"%(error.GetCString()))
         self.assertTrue(target.IsValid(), "Target: TestApp.app is not valid.")
         exe_module_spec = target.GetExecutable()
         self.assertTrue(exe_module_spec.GetFilename(), "TestApp")
 
         bkpt = target.BreakpointCreateBySourceRegex("Set a breakpoint here", self.main_source_file)

packages/Python/lldbsuite/test/macosx/find-dsym/bundle-with-dot-in-filename/Makefile

+SRCDIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))/
+
 CC ?= clang
 
 ifeq "$(ARCH)" ""
   ARCH = x86_64
 endif
 
 CFLAGS ?= -g -O0 -arch $(ARCH)
 
 all: clean
-  $(CC) $(CFLAGS) -dynamiclib -o com.apple.sbd bundle.c
+  $(CC) $(CFLAGS) -dynamiclib -o com.apple.sbd $(SRCDIR)/bundle.c
   mkdir com.apple.sbd.xpc
   mv com.apple.sbd com.apple.sbd.xpc/
   mkdir -p com.apple.sbd.xpc.dSYM/Contents/Resources/DWARF
   mv com.apple.sbd.dSYM/Contents/Resources/DWARF/com.apple.sbd com.apple.sbd.xpc.dSYM/Contents/Resources/DWARF/
   rm -rf com.apple.sbd.dSYM
   mkdir hide.app
   tar cf - com.apple.sbd.xpc com.apple.sbd.xpc.dSYM | ( cd hide.app;tar xBpf -)
-  $(CC) $(CFLAGS) -o find-bundle-with-dots-in-fn main.c
+  $(CC) $(CFLAGS) -o find-bundle-with-dots-in-fn $(SRCDIR)/main.c
 
 clean:
   rm -rf a.out a.out.dSYM hide.app com.apple.sbd com.apple.sbd.dSYM com.apple.sbd.xpc com.apple.sbd.xpc.dSYM find-bundle-with-dots-in-fn find-bundle-with-dots-in-fn.dSYM

packages/Python/lldbsuite/test/macosx/find-dsym/bundle-with-dot-in-filename/TestBundleWithDotInFilename.py

         # Destroy process before TestBase.tearDown()
         self.dbg.GetSelectedTarget().GetProcess().Destroy()
 
         # Call super's tearDown().
         TestBase.tearDown(self)
 
     def test_attach_and_check_dsyms(self):
         """Test attach to binary, see if the bundle dSYM is found"""
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
         self.build()
+        os.chdir(self.getBuildDir());
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)
 
         # Give the inferior time to start up, dlopen a bundle, remove the bundle it linked in
         sleep(5)
 
         # Since the library that was dlopen()'ed is now removed, lldb will need to find the
         # binary & dSYM via target.exec-search-paths 

         # Find the bundle module, see if we found the dSYM too (they're both in "hide.app")
         i = 0
         while i < target.GetNumModules():
             mod = target.GetModuleAtIndex(i)
             if mod.GetFileSpec().GetFilename() == 'com.apple.sbd':
                 dsym_name = mod.GetSymbolFileSpec().GetFilename()
                 self.assertTrue (dsym_name == 'com.apple.sbd', "Check that we found the dSYM for the bundle that was loaded")
             i=i+1
+        os.chdir(self.getSourceDir());
 
 if __name__ == '__main__':
     unittest.main()

packages/Python/lldbsuite/test/macosx/find-dsym/deep-bundle/Makefile

+SRCDIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))/
+
 CC ?= clang
 
 ifeq "$(ARCH)" ""
   ARCH = x86_64
 endif
 
 CFLAGS ?= -g -O0 -arch $(ARCH)
 
 all: clean
-  $(CC) $(CFLAGS) -install_name $(PWD)/MyFramework.framework/Versions/A/MyFramework -dynamiclib -o MyFramework myframework.c
+  $(CC) $(CFLAGS) -install_name $(shell pwd)/MyFramework.framework/Versions/A/MyFramework -dynamiclib -o MyFramework $(SRCDIR)/myframework.c
   mkdir -p MyFramework.framework/Versions/A/Headers
   mkdir -p MyFramework.framework/Versions/A/Resources
   cp MyFramework MyFramework.framework/Versions/A
-  cp MyFramework.h MyFramework.framework/Versions/A/Headers
-  cp Info.plist MyFramework.framework/Versions/A/Resources
+  cp $(SRCDIR)/MyFramework.h MyFramework.framework/Versions/A/Headers
+  cp $(SRCDIR)/Info.plist MyFramework.framework/Versions/A/Resources
   ( cd MyFramework.framework/Versions ; ln -s A Current )
   ( cd MyFramework.framework/ ; ln -s Versions/Current/Headers . )
   ( cd MyFramework.framework/ ; ln -s Versions/Current/MyFramework . )
   ( cd MyFramework.framework/ ; ln -s Versions/Current/Resources . )
   mv MyFramework.dSYM MyFramework.framework.dSYM
   mkdir hide.app
   rm -f MyFramework
   tar cf - MyFramework.framework MyFramework.framework.dSYM | ( cd hide.app;tar xBpf -)
-  $(CC) $(CFLAGS) -o deep-bundle main.c -F. -framework MyFramework
-  
+  $(CC) $(CFLAGS) -o deep-bundle $(SRCDIR)/main.c -F. -framework MyFramework
 
 clean:
   rm -rf a.out a.out.dSYM deep-bundle deep-bundle.dSYM MyFramework.framework MyFramework.framework.dSYM MyFramework MyFramework.dSYM hide.app

packages/Python/lldbsuite/test/macosx/find-dsym/deep-bundle/TestDeepBundle.py

         # Destroy process before TestBase.tearDown()
         self.dbg.GetSelectedTarget().GetProcess().Destroy()
 
         # Call super's tearDown().
         TestBase.tearDown(self)
 
     def test_attach_and_check_dsyms(self):
         """Test attach to binary, see if the framework dSYM is found"""
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
         self.build()
-        popen = self.spawnSubprocess(exe)
+        popen = self.spawnSubprocess(exe, [self.getBuildDir()])
         self.addTearDownHook(self.cleanupSubprocesses)
 
         # Give the inferior time to start up, dlopen a bundle, remove the bundle it linked in
         sleep(5)
 
         # Since the library that was dlopen()'ed is now removed, lldb will need to find the
         # binary & dSYM via target.exec-search-paths 
         settings_str = "settings set target.exec-search-paths " + self.get_process_working_directory() + "/hide.app"
         self.runCmd(settings_str)
-
         self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
         self.assertTrue(target.IsValid(), 'Should have a valid Target after attaching to process')
 
         setup_complete = target.FindFirstGlobalVariable("setup_is_complete")
         self.assertTrue(setup_complete.GetValueAsUnsigned() == 1, 'Check that inferior process has completed setup')
 

packages/Python/lldbsuite/test/macosx/find-dsym/deep-bundle/main.c

 #include <MyFramework/MyFramework.h>
 #include <unistd.h>
+#include <stdio.h>
 #include <stdlib.h>
 
 int setup_is_complete = 0;
 
-int main()
+int main(int argc, const char **argv)
 {
-    system ("/bin/rm -rf MyFramework MyFramework.framework MyFramework.framework.dSYM");
+    char command[8192];
+    sprintf (command,
+             "/bin/rm -rf %s/MyFramework %s/MyFramework.framework %s/MyFramework.framework.dSYM",
+             argv[1], argv[1], argv[1]);
+    system (command);
 
     setup_is_complete = 1;
 
     // At this point we want lldb to attach to the process.  If lldb attaches
     // before we've removed the framework we're running against, it will be
     // easy for lldb to find the binary & dSYM without using target.exec-search-paths,
     // which is the point of this test.
 
     for (int loop_limiter = 0; loop_limiter < 100; loop_limiter++)
         sleep (1);
 
      return foo();
 }

packages/Python/lldbsuite/test/macosx/indirect_symbol/Makefile

-CC ?= clang
-ifeq "$(ARCH)" ""
-  ARCH = x86_64
-endif
-
-ifeq "$(OS)" ""
-  OS = $(shell uname -s)
-endif
+LEVEL = ../../make
 
-CFLAGS ?= -g -O0
-CWD := $(shell pwd)
+include $(LEVEL)/Makefile.rules
 
 LIB_PREFIX := lib
 
 ifeq "$(OS)" "Darwin"
   CFLAGS += -arch $(ARCH)
   DS := dsymutil
   LD_FLAGS := -dynamiclib
   LIB_INDIRECT := $(LIB_PREFIX)indirect.dylib
   LIB_REEXPORT := $(LIB_PREFIX)reexport.dylib
   EXEC_PATH := "@executable_path"
   EXEC_PATH_INDIRECT := -install_name $(EXEC_PATH)/$(LIB_INDIRECT)
   EXEC_PATH_REEXPORT := -install_name $(EXEC_PATH)/$(LIB_REEXPORT)
 endif
 
 all: a.out $(LIB_INDIRECT) $(LIB_REEXPORT)
 
 a.out: main.o $(LIB_INDIRECT) $(LIB_REEXPORT)
   $(CC) $(CFLAGS) -o a.out main.o -L. $(LIB_INDIRECT) $(LIB_REEXPORT)
 
-main.o: main.c
-  $(CC) $(CFLAGS) -c main.c
+main.o: $(SRCDIR)/main.c
+  $(CC) $(CFLAGS) -c $(SRCDIR)/main.c
 
 $(LIB_INDIRECT): indirect.o
   $(CC) $(CFLAGS) $(LD_FLAGS) $(EXEC_PATH_INDIRECT) -o $(LIB_INDIRECT) indirect.o
   if [ "$(OS)" = "Darwin" ]; then dsymutil $(LIB_INDIRECT); fi
 
-indirect.o: indirect.c
-  $(CC) $(CFLAGS) -c indirect.c
+indirect.o: $(SRCDIR)/indirect.c
+  $(CC) $(CFLAGS) -c $(SRCDIR)/indirect.c
 
 $(LIB_REEXPORT): reexport.o $(LIB_INDIRECT)
-  $(CC) $(CFLAGS) $(LD_FLAGS) $(EXEC_PATH_REEXPORT) -o $(LIB_REEXPORT) reexport.o -L. -lindirect -Wl,-alias_list,$(CWD)/alias.list
+  $(CC) $(CFLAGS) $(LD_FLAGS) $(EXEC_PATH_REEXPORT) -o $(LIB_REEXPORT) reexport.o -L. -lindirect -Wl,-alias_list,$(SRCDIR)/alias.list
   if [ "$(OS)" = "Darwin" ]; then dsymutil $(LIB_REEXPORT); fi
 
-reexport.o: reexport.c
-  $(CC) $(CFLAGS) -c reexport.c
-clean:
+reexport.o: $(SRCDIR)/reexport.c
+  $(CC) $(CFLAGS) -c $(SRCDIR)/reexport.c
+clean::
   rm -rf $(wildcard *.o *~ *.dylib *.so a.out *.dSYM)

packages/Python/lldbsuite/test/macosx/indirect_symbol/TestIndirectSymbols.py

         """Test stepping and setting breakpoints in indirect and re-exported symbols."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         if self.platformIsDarwin():
-            lib1 = os.path.join(os.getcwd(), 'libindirect.dylib')
-            lib2 = os.path.join(os.getcwd(), 'libreexport.dylib')
+            lib1 = self.getBuildArtifact('libindirect.dylib')
+            lib2 = self.getBuildArtifact('libreexport.dylib')
             self.registerSharedLibrariesWithTarget(target, [lib1, lib2])
 
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
         break1 = target.BreakpointCreateBySourceRegex(
             "Set breakpoint here to step in indirect.", self.main_source_spec)
         self.assertTrue(break1, VALID_BREAKPOINT)
 

packages/Python/lldbsuite/test/macosx/nslog/TestDarwinNSLogOutput.py

             return self.child.expect_exact(pattern, *args, **kwargs)
         return self.child.expect(pattern, *args, **kwargs)
 
     def do_test(self, expect_regexes=None, settings_commands=None):
         """ Run a test. """
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
         self.run_lldb_to_breakpoint(exe, self.source, self.line,
                                     settings_commands=settings_commands)
         self.expect_prompt()
 
         # Now go.
         self.runCmd("process continue")
         self.expect(expect_regexes)
 

packages/Python/lldbsuite/test/macosx/order/Makefile

 LEVEL = ../../make
 
 C_SOURCES := main.c
-LDFLAGS = $(CFLAGS) -Xlinker -order_file -Xlinker ./order-file
+LDFLAGS = $(CFLAGS) -Xlinker -order_file -Xlinker $(SRCDIR)/order-file
 MAKE_DSYM := NO
 
 include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/macosx/queues/Makefile

-CC ?= clang
-ifeq "$(ARCH)" ""
-  ARCH = x86_64
-endif
+LEVEL = ../../make
 
-ifeq "$(OS)" ""
-  OS = $(shell uname -s)
-endif
+C_SOURCES := main.c
 
-CFLAGS ?= -g -O0
-CWD := $(shell pwd)
-
-LIB_PREFIX := lib
-
-ifeq "$(OS)" "Darwin"
-  CFLAGS += -arch $(ARCH)
-endif
-
-all: a.out
-
-a.out: main.o
-  $(CC) $(CFLAGS) -o a.out main.o
-
-main.o: main.c
-  $(CC) $(CFLAGS) -c main.c
-
-clean:
-  rm -rf $(wildcard *.o *~ *.dylib *.so a.out *.dSYM)
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/macosx/safe-to-func-call/Makefile

-CC ?= clang
-ifeq "$(ARCH)" ""
-  ARCH = x86_64
-endif
+LEVEL = ../../make
 
-ifeq "$(OS)" ""
-  OS = $(shell uname -s)
-endif
+C_SOURCES := main.c
 
-CFLAGS ?= -g -O0
-CWD := $(shell pwd)
-
-LIB_PREFIX := lib
-
-ifeq "$(OS)" "Darwin"
-  CFLAGS += -arch $(ARCH)
-endif
-
-all: a.out
-
-a.out: main.o
-  $(CC) $(CFLAGS) -o a.out main.o
-
-main.o: main.c
-  $(CC) $(CFLAGS) -c main.c
-
-clean:
-  rm -rf $(wildcard *.o *~ *.dylib *.so a.out *.dSYM)
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/macosx/thread-names/Makefile

-CC ?= clang
-ifeq "$(ARCH)" ""
-  ARCH = x86_64
-endif
+LEVEL = ../../make
 
-ifeq "$(OS)" ""
-  OS = $(shell uname -s)
-endif
+C_SOURCES := main.c
 
-CFLAGS ?= -g -O0
-CWD := $(shell pwd)
-
-LIB_PREFIX := lib
-
-ifeq "$(OS)" "Darwin"
-  CFLAGS += -arch $(ARCH)
-endif
-
-all: a.out
-
-a.out: main.o
-  $(CC) $(CFLAGS) -o a.out main.o
-
-main.o: main.c
-  $(CC) $(CFLAGS) -c main.c
-
-clean:
-  rm -rf $(wildcard *.o *~ *.dylib *.so a.out *.dSYM)
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/macosx/universal/Makefile

 CC ?= clang
 
+all: testit
+
 testit: testit.i386 testit.x86_64
-  lipo -create -o testit testit.i386 testit.x86_64
+  lipo -create -o testit $^
 
 testit.i386: testit.i386.o
-  $(CC) -arch i386 -o testit.i386 testit.i386.o
+  $(CC) -arch i386 -o testit.i386 $<
 
 testit.x86_64: testit.x86_64.o
-  $(CC) -arch x86_64 -o testit.x86_64 testit.x86_64.o
+  $(CC) -arch x86_64 -o testit.x86_64 $<
 
 testit.i386.o: main.c
-  $(CC) -g -O0 -arch i386 -c -o testit.i386.o main.c
+  $(CC) -g -O0 -arch i386 -c -o testit.i386.o $<
 
 testit.x86_64.o: main.c
-  $(CC) -g -O0 -arch x86_64 -c -o testit.x86_64.o main.c
+  $(CC) -g -O0 -arch x86_64 -c -o testit.x86_64.o $<
 
 clean:
   rm -rf $(wildcard testit* *~)

packages/Python/lldbsuite/test/macosx/universal/TestUniversal.py

                           'i386', 'x86_64'], "requires i386 or x86_64")
     @skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system
     def test_sbdebugger_create_target_with_file_and_target_triple(self):
         """Test the SBDebugger.CreateTargetWithFileAndTargetTriple() API."""
         # Invoke the default build rule.
         self.build()
 
         # Note that "testit" is a universal binary.
-        exe = os.path.join(os.getcwd(), "testit")
+        exe = self.getBuildArtifact("testit")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTargetWithFileAndTargetTriple(
             exe, "i386-apple-macosx")
         self.assertTrue(target, VALID_TARGET)
 
         # Now launch the process, and do not stop at entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
     @skipUnlessDarwin
     @unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in [
                           'i386', 'x86_64'], "requires i386 or x86_64")
     @skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system
     def test_process_launch_for_universal(self):
         """Test process launch of a universal binary."""
         from lldbsuite.test.lldbutil import print_registers
 
         # Invoke the default build rule.
         self.build()
 
         # Note that "testit" is a universal binary.
-        exe = os.path.join(os.getcwd(), "testit")
+        exe = self.getBuildArtifact("testit")
 
         # By default, x86_64 is assumed if no architecture is specified.
         self.expect("file " + exe, CURRENT_EXECUTABLE_SET,
                     startstr="Current executable set to ",
                     substrs=["testit' (x86_64)."])
 
         # Break inside the main.
         lldbutil.run_break_set_by_file_and_line(

         # Now keep the architecture at 32 bit, but switch the binary we launch to
         # 64 bit, and make sure on attach we switch to the correct
         # architecture.
 
         # Invoke the default build rule.
         self.build()
 
         # Note that "testit" is a universal binary.
-        exe = os.path.join(os.getcwd(), "testit")
+        exe = self.getBuildArtifact("testit")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTargetWithFileAndTargetTriple(
             exe, "i386-apple-macosx")
         self.assertTrue(target, VALID_TARGET)
         pointer_size = target.GetAddressByteSize()
         self.assertTrue(pointer_size == 4, "Initially we were 32 bit.")
 

packages/Python/lldbsuite/test/make/Makefile.rules

 #----------------------------------------------------------------------
 # Clients fill in the source files to build
 #----------------------------------------------------------------------
 # C_SOURCES := main.c
 # CXX_SOURCES :=
 # OBJC_SOURCES :=
 # OBJCXX_SOURCES :=
 # DYLIB_C_SOURCES :=
+# DYLIB_OBJC_SOURCES :=
 # DYLIB_CXX_SOURCES :=
 #
 # Specifying DYLIB_ONLY has the effect of building dylib only, skipping
 # the building of the a.out executable program.  For example,
 # DYLIB_ONLY := YES
 #
 # Also might be of interest:
 # FRAMEWORK_INCLUDES (Darwin only) :=
 # CFLAGS_EXTRAS :=
 # LD_EXTRAS :=
 # SPLIT_DEBUG_SYMBOLS := YES
 # CROSS_COMPILE :=
 #
 # And test/functionalities/archives/Makefile:
 # MAKE_DSYM := NO
 # ARCHIVE_NAME := libfoo.a
 # ARCHIVE_C_SOURCES := a.c b.c
 
 # Uncomment line below for debugging shell commands
 # SHELL = /bin/sh -x
 
+SRCDIR := $(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))/
 THIS_FILE_DIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))/
 LLDB_BASE_DIR := $(THIS_FILE_DIR)../../../../../
 
 
 #----------------------------------------------------------------------
 # If OS is not defined, use 'uname -s' to determine the OS name.
 #
 # uname on Windows gives "windows32", but most environments standardize

 
 CFLAGS ?= $(DEBUG_INFO_FLAG) -O0 -fno-builtin
 ifeq "$(OS)" "Darwin"
   CFLAGS += $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) -I$(LLDB_BASE_DIR)include
 else
   CFLAGS += $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) -I$(LLDB_BASE_DIR)include
 endif
 
-CFLAGS += -include $(THIS_FILE_DIR)test_common.h -I$(THIS_FILE_DIR)
+CFLAGS += -I$(SRCDIR) -include $(THIS_FILE_DIR)test_common.h -I$(THIS_FILE_DIR)
 CFLAGS += $(NO_LIMIT_DEBUG_INFO_FLAGS) $(ARCH_CFLAGS) $(CFLAGS_EXTRAS)
 
 # Use this one if you want to build one part of the result without debug information:
 ifeq "$(OS)" "Darwin"
   CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) $(ARCH_CFLAGS) $(CFLAGS_EXTRAS)
 else
   CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(ARCH_CFLAGS) $(CFLAGS_EXTRAS)
 endif

 endif
 
 #----------------------------------------------------------------------
 # DYLIB_ONLY variable can be used to skip the building of a.out.
 # See the sections below regarding dSYM file as well as the building of
 # EXE from all the objects.
 #----------------------------------------------------------------------
 
-#----------------------------------------------------------------------
-# Make the dSYM file from the executable if $(MAKE_DSYM) != "NO"
-#----------------------------------------------------------------------
-ifneq "$(DYLIB_ONLY)" "YES"
-$(DSYM) : $(EXE)
-ifeq "$(OS)" "Darwin"
-ifneq "$(MAKE_DSYM)" "NO"
-  "$(DS)" $(DSFLAGS) -o "$(DSYM)" "$(EXE)"
-endif
-else
-ifeq "$(SPLIT_DEBUG_SYMBOLS)" "YES"
-  $(OBJCOPY) --only-keep-debug "$(EXE)" "$(DSYM)"
-  $(OBJCOPY) --strip-debug --add-gnu-debuglink="$(DSYM)" "$(EXE)" "$(EXE)"
-endif
-endif
-endif
-
 #----------------------------------------------------------------------
 # Compile the executable from all the objects.
 #----------------------------------------------------------------------
 ifneq "$(DYLIB_NAME)" ""
 ifeq "$(DYLIB_ONLY)" ""
 $(EXE) : $(OBJECTS) $(ARCHIVE_NAME) $(DYLIB_FILENAME)
   $(LD) $(OBJECTS) $(ARCHIVE_NAME) -L. -l$(DYLIB_NAME) $(LDFLAGS) -o "$(EXE)"
 else
 EXE = $(DYLIB_FILENAME)
 endif
 else
 $(EXE) : $(OBJECTS) $(ARCHIVE_NAME)
   $(LD) $(OBJECTS) $(LDFLAGS) $(ARCHIVE_NAME) -o "$(EXE)"
 endif
 
+#----------------------------------------------------------------------
+# Make the dSYM file from the executable if $(MAKE_DSYM) != "NO"
+#----------------------------------------------------------------------
+$(DSYM) : $(EXE)
+ifeq "$(OS)" "Darwin"
+ifneq "$(MAKE_DSYM)" "NO"
+  "$(DS)" $(DSFLAGS) -o "$(DSYM)" "$(EXE)"
+else
+endif
+else
+ifeq "$(SPLIT_DEBUG_SYMBOLS)" "YES"
+  $(OBJCOPY) --only-keep-debug "$(EXE)" "$(DSYM)"
+  $(OBJCOPY) --strip-debug --add-gnu-debuglink="$(DSYM)" "$(EXE)" "$(EXE)"
+endif
+endif
+
 #----------------------------------------------------------------------
 # Make the archive
 #----------------------------------------------------------------------
 ifneq "$(ARCHIVE_NAME)" ""
 ifeq "$(OS)" "Darwin"
 $(ARCHIVE_NAME) : $(ARCHIVE_OBJECTS)
   $(AR) $(ARFLAGS) $(ARCHIVE_NAME) $(ARCHIVE_OBJECTS)
   $(RM) $(ARCHIVE_OBJECTS)

 endif
 
 #----------------------------------------------------------------------
 # Make the precompiled header and compile C++ sources against it
 #----------------------------------------------------------------------
 
 #ifneq "$(PCH_OUTPUT)" ""
 $(PCH_OUTPUT) : $(PCH_CXX_SOURCE)
-  $(CXX) $(CXXFLAGS) -x c++-header -o $(PCH_OUTPUT) $(PCH_CXX_SOURCE)
+  $(CXX) $(CXXFLAGS) -x c++-header -o $@ $<
 %.o : %.cpp $(PCH_OUTPUT)
   $(CXX) $(PCHFLAGS) $(CXXFLAGS) -c -o $@ $<
 #endif
 
 #----------------------------------------------------------------------
 # Automatic variables based on items already entered. Below we create
 # an object's lists from the list of sources by replacing all entries
 # that end with .c with .o, and we also create a list of prerequisite

packages/Python/lldbsuite/test/plugins/builder_base.py

         archflag = "-m"
     elif "clang" in compiler:
         archflag = "-arch"
     else:
         archflag = None
 
     return ("ARCHFLAG=" + archflag) if archflag else ""
 
-
-def getMake():
-    """Returns the name for GNU make"""
+def getMake(test_subdir):
+    """Returns the invocation for GNU make.
+       The argument test_subdir is the relative path to the testcase."""
     if platform.system() == "FreeBSD" or platform.system() == "NetBSD":
-        return "gmake"
+        make = "gmake"
     else:
-        return "make"
+        make = "make"
+
+    # Construct the base make invocation.
+    lldb_test = os.environ["LLDB_TEST"]
+    lldb_build = os.environ["LLDB_BUILD"]
+    if not (lldb_test and lldb_build and test_subdir and
+            (not os.path.isabs(test_subdir))):
+        raise Exception("Could not derive test directories")
+    build_dir = os.path.join(lldb_build, test_subdir)
+    test_dir = os.path.join(lldb_test, test_subdir)
+    # This is a bit of a hack to make inline testcases work.
+    makefile = os.path.join(test_dir, "Makefile")
+    if not os.path.isfile(makefile):
+        makefile = os.path.join(build_dir, "Makefile")
+    return [make,
+            "VPATH="+test_dir,
+            "-C", build_dir,
+            "-I", test_dir,
+            "-f", makefile]
 
 
 def getArchSpec(architecture):
     """
     Helper function to return the key-value string to specify the architecture
     used for the make system.
     """
     arch = architecture if architecture else None

         raise build_exception.BuildError(called_process_error)
 
 
 def buildDefault(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True):
+        clean=True,
+        testdir=None):
     """Build the binaries the default way."""
     commands = []
     if clean:
-        commands.append([getMake(), "clean", getCmdLine(dictionary)])
-    commands.append([getMake(), getArchSpec(architecture),
+        commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
+    commands.append(getMake(testdir) + [getArchSpec(architecture),
                      getCCSpec(compiler), getCmdLine(dictionary)])
 
     runBuildCommands(commands, sender=sender)
 
     # True signifies that we can handle building default.
     return True
 
 
 def buildDwarf(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True):
+        clean=True,
+        testdir=None):
     """Build the binaries with dwarf debug info."""
     commands = []
     if clean:
-        commands.append([getMake(), "clean", getCmdLine(dictionary)])
-    commands.append([getMake(), "MAKE_DSYM=NO", getArchSpec(
+        commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
+    commands.append(getMake(testdir) + ["MAKE_DSYM=NO", getArchSpec(
         architecture), getCCSpec(compiler), getCmdLine(dictionary)])
 
     runBuildCommands(commands, sender=sender)
     # True signifies that we can handle building dwarf.
     return True
 
 
 def buildDwo(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True):
+        clean=True,
+        testdir=None):
     """Build the binaries with dwarf debug info."""
     commands = []
     if clean:
-        commands.append([getMake(), "clean", getCmdLine(dictionary)])
-    commands.append([getMake(), "MAKE_DSYM=NO", "MAKE_DWO=YES", getArchSpec(
-        architecture), getCCSpec(compiler), getCmdLine(dictionary)])
+        commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
+    commands.append(getMake(testdir) +
+                    ["MAKE_DSYM=NO", "MAKE_DWO=YES",
+                     getArchSpec(architecture),
+                     getCCSpec(compiler),
+                     getCmdLine(dictionary)])
 
     runBuildCommands(commands, sender=sender)
     # True signifies that we can handle building dwo.
     return True
 
 
 def buildGModules(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True):
+        clean=True,
+        testdir=None):
     """Build the binaries with dwarf debug info."""
     commands = []
     if clean:
-        commands.append([getMake(), "clean", getCmdLine(dictionary)])
-    commands.append([getMake(),
-                     "MAKE_DSYM=NO",
+        commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
+    commands.append(getMake(testdir) +
+                    ["MAKE_DSYM=NO",
                      "MAKE_GMODULES=YES",
                      getArchSpec(architecture),
                      getCCSpec(compiler),
                      getCmdLine(dictionary)])
 
     lldbtest.system(commands, sender=sender)
     # True signifies that we can handle building with gmodules.
     return True
 
 
 def cleanup(sender=None, dictionary=None):
     """Perform a platform-specific cleanup after the test."""
-    #import traceback
-    # traceback.print_stack()
-    commands = []
-    if os.path.isfile("Makefile"):
-        commands.append([getMake(), "clean", getCmdLine(dictionary)])
-
-    runBuildCommands(commands, sender=sender)
-    # True signifies that we can handle cleanup.
     return True

packages/Python/lldbsuite/test/plugins/builder_darwin.py

 
 from __future__ import print_function
 import os
 import lldbsuite.test.lldbtest as lldbtest
 
 from builder_base import *
 
-
 def buildDsym(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True):
+        clean=True,
+        testdir=None):
     """Build the binaries with dsym debug info."""
     commands = []
 
     if clean:
-        commands.append(["make", "clean", getCmdLine(dictionary)])
-    commands.append(["make", "MAKE_DSYM=YES", getArchSpec(
-        architecture), getCCSpec(compiler), getCmdLine(dictionary)])
+        commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
+    commands.append(getMake(testdir) +
+                    ["MAKE_DSYM=YES",
+                     getArchSpec(architecture),
+                     getCCSpec(compiler),
+                     "all", getCmdLine(dictionary)])
 
     runBuildCommands(commands, sender=sender)
 
     # True signifies that we can handle building dsym.
     return True

packages/Python/lldbsuite/test/plugins/builder_freebsd.py

 from builder_base import *
 
 
 def buildDsym(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True):
+        clean=True,
+        testdir=None):
     return False

packages/Python/lldbsuite/test/plugins/builder_linux.py

 from builder_base import *
 
 
 def buildDsym(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True):
+        clean=True,
+        testdir=None):
     return False

packages/Python/lldbsuite/test/plugins/builder_netbsd.py

 from builder_base import *
 
 
 def buildDsym(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True):
+        clean=True,
+        testdir=None):
     return False

packages/Python/lldbsuite/test/plugins/builder_win32.py

 from builder_base import *
 
 
 def buildDsym(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True):
+        clean=True,
+        testdir=None):
     return False

packages/Python/lldbsuite/test/python_api/class_members/TestSBTypeClassMembers.py

 
     @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test(self):
         """Test SBType APIs to fetch member function types."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Create the breakpoint inside function 'main'.
         breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)

packages/Python/lldbsuite/test/python_api/formatters/TestFormattersSBAPI.py

 
     @add_test_categories(['pyapi'])
     def test_formatters_api(self):
         """Test Python APIs for working with formatters"""
         self.build()
         self.setTearDownCleanup()
 
         """Test Python APIs for working with formatters"""
-        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact("a.out"),
+                    CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
-            self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
+            self, "main.cpp", self.line, num_expected_locations=1,
+            loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 

             "ObjC category is None")
 
     @add_test_categories(['pyapi'])
     def test_force_synth_off(self):
         """Test that one can have the public API return non-synthetic SBValues if desired"""
         self.build(dictionary={'EXE': 'no_synth'})
         self.setTearDownCleanup()
 
-        self.runCmd("file no_synth", CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact("no_synth"),
+                    CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,

packages/Python/lldbsuite/test/python_api/hello_world/TestHelloWorld.py

 class HelloWorldTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Get the full path to our executable to be attached/debugged.
-        self.exe = os.path.join(os.getcwd(), self.testMethodName)
+        self.exe = self.getBuildArtifact(self.testMethodName)
         self.d = {'EXE': self.testMethodName}
         # Find a couple of the line numbers within main.c.
         self.line1 = line_number('main.c', '// Set break point at this line.')
         self.line2 = line_number('main.c', '// Waiting to be attached...')
 
     def tearDown(self):
         # Destroy process before TestBase.tearDown()
         self.dbg.GetSelectedTarget().GetProcess().Destroy()

packages/Python/lldbsuite/test/python_api/process/io/TestProcessIO.py

 class ProcessIOTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Get the full path to our executable to be debugged.
-        self.exe = os.path.join(os.getcwd(), "process_io")
-        self.local_input_file = os.path.join(os.getcwd(), "input.txt")
-        self.local_output_file = os.path.join(os.getcwd(), "output.txt")
-        self.local_error_file = os.path.join(os.getcwd(), "error.txt")
+        self.exe = self.getBuildArtifact("process_io")
+        self.local_input_file = self.getBuildArtifact("input.txt")
+        self.local_output_file = self.getBuildArtifact("output.txt")
+        self.local_error_file = self.getBuildArtifact("error.txt")
 
         self.input_file = os.path.join(
             self.get_process_working_directory(), "input.txt")
         self.output_file = os.path.join(
             self.get_process_working_directory(), "output.txt")
         self.error_file = os.path.join(
             self.get_process_working_directory(), "error.txt")
         self.lines = ["Line 1", "Line 2", "Line 3"]

packages/Python/lldbsuite/test/python_api/process/read-mem-cstring/TestReadMemCString.py

class TestReadMemCString(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_read_memory_c_string(self):
         """Test corner case behavior of SBProcess::ReadCStringFromMemory"""
         self.build()
   self.dbg.SetAsync(False)
 
         self.main_source = "main.c"
-  self.main_source_spec = lldb.SBFileSpec(self.main_source)
-  self.exe = os.path.join(os.getcwd(), "read-mem-cstring")
+        self.main_source_path = os.path.join(self.getSourceDir(),
+                                             self.main_source)
+  self.main_source_spec = lldb.SBFileSpec(self.main_source_path)
+  self.exe = self.getBuildArtifact("read-mem-cstring")
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, 'breakpoint here', self.main_source_spec, None, self.exe)
 
   frame = thread.GetFrameAtIndex(0)
         
         err = lldb.SBError()
 

packages/Python/lldbsuite/test/python_api/section/TestSectionAPI.py

class SectionAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
     def test_get_target_byte_size(self):
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        exe = os.path.join(os.getcwd(), 'b.out')
+        exe = self.getBuildArtifact('b.out')
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # find the .data section of the main module
         mod = target.GetModuleAtIndex(0)
         data_section = None
         for s in mod.sections:
             sect_type = s.GetSectionType()

packages/Python/lldbsuite/test/python_api/target/TestTargetAPI.py

         data_section = self.find_data_section(target)
         sb_addr = lldb.SBAddress(data_section, 0)
         error = lldb.SBError()
         content = target.ReadMemory(sb_addr, 1, error)
         self.assertTrue(error.Success(), "Make sure memory read succeeded")
         self.assertEqual(len(content), 1)
 
     def create_simple_target(self, fn):
-        exe = os.path.join(os.getcwd(), fn)
+        exe = self.getBuildArtifact(fn)
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
         return target
 
     def find_data_section(self, target):
         mod = target.GetModuleAtIndex(0)
         data_section = None
         for s in mod.sections:

                         data_section = ss
                         break
 
         self.assertIsNotNone(data_section)
         return data_section
 
     def find_global_variables(self, exe_name):
         """Exercise SBTaget.FindGlobalVariables() API."""
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # rdar://problem/9700873
         # Find global variable value fails for dwarf if inferior not started
         # (Was CrashTracer: [USER] 1 crash in Python at _lldb.so: lldb_private::MemoryCache::Read + 94)

         self.expect(my_global_var.GetTypeName(), exe=False,
                     startstr="char")
         self.expect(my_global_var.GetValue(), exe=False,
                     startstr="'X'")
 
         # While we are at it, let's also exercise the similar
         # SBModule.FindGlobalVariables() API.
         for m in target.module_iter():
-            if os.path.normpath(m.GetFileSpec().GetDirectory()) == os.getcwd(
-            ) and m.GetFileSpec().GetFilename() == exe_name:
+            if os.path.normpath(m.GetFileSpec().GetDirectory()) == self.getBuildDir() and m.GetFileSpec().GetFilename() == exe_name:
                 value_list = m.FindGlobalVariables(
                     target, 'my_global_var_of_char_type', 3)
                 self.assertTrue(value_list.GetSize() == 1)
                 self.assertTrue(
                     value_list.GetValueAtIndex(0).GetValue() == "'X'")
                 break
 
     def find_functions(self, exe_name):
         """Exercise SBTaget.FindFunctions() API."""
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         list = target.FindFunctions('c', lldb.eFunctionNameTypeAuto)
         self.assertTrue(list.GetSize() == 1)
 

packages/Python/lldbsuite/test/python_api/thread/TestThreadAPI.py

         # and expect to get a Python string as the return object!
         # The 100 is just an arbitrary number specifying the buffer size.
         stop_description = thread.GetStopDescription(100)
         self.expect(stop_description, exe=False,
                     startstr='breakpoint')
 
     def step_out_of_malloc_into_function_b(self, exe_name):
         """Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b()."""
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByName('malloc')
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Launch the process, and do not stop at the entry point.

         thread.StepOut()
         self.runCmd("thread backtrace")
         self.assertTrue(
             thread.GetFrameAtIndex(0).GetLineEntry().GetLine() == self.step_out_of_malloc,
             "step out of malloc into function b is successful")
 
     def step_over_3_times(self, exe_name):
         """Test Python SBThread.StepOver() API."""
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation(
             'main2.cpp', self.step_out_of_malloc)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
         self.runCmd("breakpoint list")

         # rdar://problem/9223880
         #
         # Which has been fixed on the lldb by compensating for inaccurate line
         # table information with r140416.
         self.assertTrue(lineEntry.GetLine() == self.after_3_step_overs)
 
     def run_to_address(self, exe_name):
         """Test Python SBThread.RunToAddress() API."""
-        exe = os.path.join(os.getcwd(), exe_name)
+        exe = self.getBuildArtifact(exe_name)
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation(
             'main2.cpp', self.step_out_of_malloc)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
         self.runCmd("breakpoint list")

packages/Python/lldbsuite/test/python_api/type/TestTypeList.py

         self.line = line_number(self.source, '// Break at this line')
 
     @add_test_categories(['pyapi'])
     def test(self):
         """Exercise SBType and SBTypeList API."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Create the breakpoint inside function 'main'.
         breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)

packages/Python/lldbsuite/test/python_api/value/TestValueAPI.py

 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
     @add_test_categories(['pyapi'])
     def test(self):
         """Exercise some SBValue APIs."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Create the breakpoint inside function 'main'.
         breakpoint = target.BreakpointCreateByLocation('main.c', self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)

packages/Python/lldbsuite/test/python_api/value/change_values/TestChangeValueAPI.py

     @add_test_categories(['pyapi'])
     @expectedFlakeyLinux("llvm.org/pr25652")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
     def test_change_value(self):
         """Exercise the SBValue::SetValueFromCString API."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Create the breakpoint inside function 'main'.
         breakpoint = target.BreakpointCreateByLocation('main.c', self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)

packages/Python/lldbsuite/test/python_api/value/linked_list/TestValueAPILinkedList.py

     # SWIG 3.0.8.
     @skipIf(py_version=['>=', (3, 0)], swig_version=['<', (3, 0, 8)])
     @add_test_categories(['pyapi'])
     def test(self):
         """Exercise SBValue API linked_list_iter."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Create the breakpoint inside function 'main'.
         breakpoint = target.BreakpointCreateByLocation('main.cpp', self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)

packages/Python/lldbsuite/test/python_api/value_var_update/TestValueVarUpdate.py

 class HelloWorldTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Get the full path to our executable to be attached/debugged.
-        self.exe = os.path.join(os.getcwd(), self.testMethodName)
+        self.exe = self.getBuildArtifact(self.testMethodName)
         self.d = {'EXE': self.testMethodName}
 
     @add_test_categories(['pyapi'])
     def test_with_process_launch_api(self):
         """Test SBValue::GetValueDidChange"""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         target = self.dbg.CreateTarget(self.exe)

packages/Python/lldbsuite/test/python_api/watchpoint/condition/TestWatchpointConditionAPI.py

         oslist=["linux"],
         archs=["aarch64"],
         bugnumber="llvm.org/pr27710")
     @skipIfWindows  # Watchpoints not supported on Windows, and this test hangs
     def test_watchpoint_cond_api(self):
         """Test watchpoint condition API."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
-        exe = os.path.join(os.getcwd(), self.exe_name)
+        exe = self.getBuildArtifact(self.exe_name)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c.
         breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
         self.assertTrue(breakpoint and

packages/Python/lldbsuite/test/settings/TestSettings.py

 
         # Immediately test the setting.
         self.expect("settings show frame-format", SETTING_MSG("frame-format"),
                     substrs=[format_string])
 
         self.runCmd("breakpoint set -n main")
         self.runCmd("run")
         self.expect("thread backtrace",
-                    substrs=["`main", os.getcwd()])
+                    substrs=["`main", self.getSourceDir()])
 
     def test_set_auto_confirm(self):
         """Test that after 'set auto-confirm true', manual confirmation should not kick in."""
         self.build()
 
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

         # string
         self.runCmd("settings set target.arg0 abc")    # Set to known value
         # Set to new value with trailing whitespaces
         self.runCmd("settings set target.arg0 cde\t ")
         self.expect("settings show target.arg0", SETTING_MSG("target.arg0"),
                     startstr='target.arg0 (string) = "cde"')
         self.runCmd("settings clear target.arg0", check=False)
         # file
-        path1 = os.path.join(os.getcwd(), "path1.txt")
-        path2 = os.path.join(os.getcwd(), "path2.txt")
+        path1 = self.getBuildArtifact("path1.txt")
+        path2 = self.getBuildArtifact("path2.txt")
         self.runCmd(
             "settings set target.output-path %s" %
             path1)   # Set to known value
         self.expect(
             "settings show target.output-path",
             SETTING_MSG("target.output-path"),
             startstr='target.output-path (file) = ',
             substrs=[path1])

packages/Python/lldbsuite/test/settings/quoting/TestQuoting.py

 
 class SettingsCommandTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @classmethod
     def classCleanup(cls):
         """Cleanup the test byproducts."""
-        cls.RemoveTempFile("stdout.txt")
+        cls.RemoveTempFile(self.getBuildArtifact("stdout.txt"))
 
     @no_debug_info_test
     def test_no_quote(self):
         self.do_test_args("a b c", "a\0b\0c\0")
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24557")
     @no_debug_info_test
     def test_single_quote(self):

     def do_test_args(self, args_in, args_out):
         """Test argument parsing. Run the program with args_in. The program dumps its arguments
         to stdout. Compare the stdout with args_out."""
         self.buildDefault()
 
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
-        self.runCmd("process launch -- " + args_in)
+        outfile = self.getBuildArtifact("output.txt")
+        self.runCmd("process launch -- %s %s" %(outfile, args_in))
 
         if lldb.remote_platform:
-            src_file_spec = lldb.SBFileSpec('output.txt', False)
-            dst_file_spec = lldb.SBFileSpec('output.txt', True)
+            src_file_spec = lldb.SBFileSpec(outfile, False)
+            dst_file_spec = lldb.SBFileSpec(outfile, True)
             lldb.remote_platform.Get(src_file_spec, dst_file_spec)
 
-        with open('output.txt', 'r') as f:
+        with open(outfile, 'r') as f:
             output = f.read()
 
-        self.RemoveTempFile("output.txt")
+        self.RemoveTempFile(outfile)
 
         self.assertEqual(output, args_out)

packages/Python/lldbsuite/test/settings/quoting/main.c

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 
 /* This program writes its arguments (separated by '\0') to stdout. */
 int
 main(int argc, char const *argv[])
 {
     int i;
 
-    FILE *output = fopen ("output.txt", "w");
+    FILE *output = fopen (argv[1], "w");
     if (output == NULL)
         exit (1);
 
-    for (i = 1; i < argc; ++i)
+    for (i = 2; i < argc; ++i)
         fwrite(argv[i], strlen(argv[i])+1, 1, output);
 
     fclose (output);
 
     return 0;
 }

packages/Python/lldbsuite/test/source-manager/TestSourceManager.py

         # error
         self.expect(
             "settings set target.source-map /a/b/c/d/e /q/r/s/t/u",
             error=True,
             substrs=['''error: the replacement path doesn't exist: "/q/r/s/t/u"'''])
 
         # Set target.source-map settings.
         self.runCmd("settings set target.source-map %s %s" %
-                    (os.getcwd(), os.path.join(os.getcwd(), "hidden")))
+                    (self.getSourceDir(),
+                     os.path.join(self.getSourceDir(), "hidden")))
         # And verify that the settings work.
         self.expect("settings show target.source-map",
-                    substrs=[os.getcwd(), os.path.join(os.getcwd(), "hidden")])
+                    substrs=[self.getSourceDir(),
+                             os.path.join(self.getSourceDir(), "hidden")])
 
         # Display main() and verify that the source mapping has been kicked in.
         self.expect("source list -n main", SOURCE_DISPLAYED_CORRECTLY,
                     substrs=['Hello world'])
 
     def test_modify_source_file_while_debugging(self):
         """Modify a source file while debugging the executable."""
         self.build()

             "source list -f main.c -l %d" %
             self.line,
             SOURCE_DISPLAYED_CORRECTLY,
             substrs=['Hello lldb'])
 
     def test_set_breakpoint_with_absolute_path(self):
         self.build()
         self.runCmd("settings set target.source-map %s %s" %
-                    (os.getcwd(), os.path.join(os.getcwd(), "hidden")))
+                    (self.getSourceDir(),
+                     os.path.join(self.getSourceDir(), "hidden")))
 
         exe = self.getBuildArtifact("a.out")
-        main = os.path.join(os.getcwd(), "hidden", "main.c")
+        main = os.path.join(self.getSourceDir(), "hidden", "main.c")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, main, self.line, num_expected_locations=1, loc_exact=False)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'main.c:%d' % self.line,
                              'stop reason = breakpoint'])

packages/Python/lldbsuite/test/tools/lldb-mi/TestMiLibraryLoaded.py

         self.spawnLldbMi(args=None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Test =library-loaded
         import os
-        path = os.path.join(os.getcwd(), self.myexe)
+        path = self.getBuildArtifact(self.myexe)
         symbols_path = os.path.join(
             path + ".dSYM",
             "Contents",
             "Resources",
             "DWARF",
             "a.out")
 
         def add_slashes(x): return x.replace(

packages/Python/lldbsuite/test/tools/lldb-mi/breakpoint/TestMiBreak.py

         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
 
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         import os
-        path = os.path.join(os.getcwd(), "main.cpp")
+        path = os.path.join(self.getSourceDir(), "main.cpp")
         line = line_number('main.cpp', '// BP_return')
         self.runCmd("-break-insert %s:%d" % (path, line))
         self.expect("\^done,bkpt={number=\"2\"")
 
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 

packages/Python/lldbsuite/test/tools/lldb-mi/lldbmi_testcase.py

 """
 Base class for lldb-mi test cases.
 """
 
 from __future__ import print_function
 
 
 from lldbsuite.test.lldbtest import *
 
 
 class MiTestCaseBase(Base):
 
     mydir = None
     myexe = None
     mylog = None
+    NO_DEBUG_INFO_TESTCASE = True
 
     @classmethod
     def classCleanup(cls):
         if cls.myexe:
             TestBase.RemoveTempFile(cls.myexe)
         if cls.mylog:
             TestBase.RemoveTempFile(cls.mylog)
 
     def setUp(self):
+        if not self.mydir:
+            raise("mydir is empty")
+
         Base.setUp(self)
+        self.makeBuildDir()
         self.buildDefault()
         self.child_prompt = "(gdb)"
         self.myexe = self.getBuildArtifact("a.out")
 
     def tearDown(self):
         if self.TraceOn():
             print("\n\nContents of %s:" % self.mylog)
             try:

packages/Python/lldbsuite/test/tools/lldb-mi/symbol/TestMiSymbol.py

         # relative path
         self.runCmd("-symbol-list-lines ./main.cpp")
         self.expect(
             "\^error,message=\"error: No source filenames matched '\./main\.cpp'\. \"")
 
         # Test that -symbol-list-lines works when file is specified using
         # absolute path
         import os
-        path = os.path.join(os.getcwd(), "main.cpp")
+        path = os.path.join(self.getSourceDir(), "main.cpp")
         self.runCmd("-symbol-list-lines \"%s\"" % path)
         self.expect(
             "\^done,lines=\[\{pc=\"0x0*%x\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"\d+\"\})+\]" %
             (addr, line))
 
         # Test that -symbol-list-lines fails when file doesn't exist
         self.runCmd("-symbol-list-lines unknown_dir/main.cpp")
         self.expect(
             "\^error,message=\"error: No source filenames matched 'unknown_dir/main\.cpp'\. \"")

packages/Python/lldbsuite/test/tools/lldb-mi/target/TestMiTarget.py

         self.buildProgram("test_attach.cpp", exeName)
         self.addTearDownCleanup(dictionary=d)
 
         self.spawnLldbMi(args=None)
 
         # Load executable
         # FIXME: -file-exec-and-sybmols is not required for target attach, but
         # the test will not pass without this
-        self.runCmd("-file-exec-and-symbols %s" % exeName)
+        self.runCmd("-file-exec-and-symbols %s" % self.getBuildArtifact(exeName))
         self.expect("\^done")
 
         # Set up attach
         self.runCmd("-target-attach -n %s --waitfor" % exeName)
         time.sleep(4)  # Give attach time to setup
 
         # Start target process
-        self.spawnSubprocess(os.path.join(os.path.dirname(__file__), exeName))
+        self.spawnSubprocess(self.getBuildArtifact(exeName))
         self.addTearDownHook(self.cleanupSubprocesses)
         self.expect("\^done")
 
         # Set breakpoint on printf
         line = line_number('test_attach.cpp', '// BP_i++')
         self.runCmd("-break-insert -f test_attach.cpp:%d" % line)
         self.expect("\^done,bkpt={number=\"1\"")
 

 
         # Build target executable with unique name
         exeName = self.testMethodName
         d = {'EXE': exeName}
         self.buildProgram("test_attach.cpp", exeName)
         self.addTearDownCleanup(dictionary=d)
 
         # Start target process
-        targetProcess = self.spawnSubprocess(
-            os.path.join(os.path.dirname(__file__), exeName))
+        targetProcess = self.spawnSubprocess(self.getBuildArtifact(exeName))
         self.addTearDownHook(self.cleanupSubprocesses)
 
         self.spawnLldbMi(args=None)
 
         # Set up atatch
         self.runCmd("-target-attach -n %s" % exeName)
         self.expect("\^done")
 

         # Build target executable with unique name
         exeName = self.testMethodName
         d = {'EXE': exeName}
         self.buildProgram("test_attach.cpp", exeName)
         self.addTearDownCleanup(dictionary=d)
 
         # Start target process
         targetProcess = self.spawnSubprocess(
-            os.path.join(os.path.dirname(__file__), exeName))
+            self.getBuildArtifact(exeName))
         self.addTearDownHook(self.cleanupSubprocesses)
 
         self.spawnLldbMi(args=None)
 
         # Set up atatch
         self.runCmd("-target-attach %d" % targetProcess.pid)
         self.expect("\^done")
 

packages/Python/lldbsuite/test/types/AbstractBase.py

     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.
         # There are a bunch of test cases under test/types and we don't want the
         # module cacheing subsystem to be confused with executable name "a.out"
         # used for all the test cases.
         self.exe_name = self.testMethodName
-        self.golden_filename = os.path.join(os.getcwd(), "golden-output.txt")
+        self.golden_filename = self.getBuildArtifact("golden-output.txt")
 
     def tearDown(self):
         """Cleanup the test byproducts."""
         #print("Removing golden-output.txt...")
         if os.path.exists(self.golden_filename):
             os.remove(self.golden_filename)
         TestBase.tearDown(self)
 
     #==========================================================================#

 
     def generic_type_tester(
             self,
             exe_name,
             atoms,
             quotedDisplay=False,
             blockCaptured=False):
         """Test that variables with basic types are displayed correctly."""
-
-        self.runCmd("file %s" % exe_name, CURRENT_EXECUTABLE_SET)
+        self.runCmd("file %s" % self.getBuildArtifact(exe_name),
+                    CURRENT_EXECUTABLE_SET)
 
         # First, capture the golden output emitted by the oracle, i.e., the
         # series of printf statements.
 
         self.process_launch_o(self.golden_filename)
 
         with open(self.golden_filename) as f:
             go = f.read()

     def generic_type_expr_tester(
             self,
             exe_name,
             atoms,
             quotedDisplay=False,
             blockCaptured=False):
         """Test that variable expressions with basic types are evaluated correctly."""
 
-        self.runCmd("file %s" % exe_name, CURRENT_EXECUTABLE_SET)
+        self.runCmd("file %s" % self.getBuildArtifact(exe_name),
+                    CURRENT_EXECUTABLE_SET)
 
         # First, capture the golden output emitted by the oracle, i.e., the
         # series of printf statements.
 
         self.process_launch_o(self.golden_filename)
 
         with open(self.golden_filename) as f:
             go = f.read()

packages/Python/lldbsuite/test/warnings/uuid/TestAddDsymCommand.py

         self.generate_main_cpp(version=1)
         self.buildDsym(clean=True)
 
         self.exe_name = 'a.out'
         self.do_add_dsym_with_dSYM_bundle(self.exe_name)
 
     def generate_main_cpp(self, version=0):
         """Generate main.cpp from main.cpp.template."""
-        temp = os.path.join(os.getcwd(), self.template)
+        temp = os.path.join(self.getSourceDir(), self.template)
         with open(temp, 'r') as f:
             content = f.read()
 
         new_content = content.replace(
             '%ADD_EXTRA_CODE%',
             'printf("This is version %d\\n");' %
             version)
-        src = os.path.join(os.getcwd(), self.source)
+        self.makeBuildDir()
+        src = os.path.join(self.getBuildDir(), self.source)
         with open(src, 'w') as f:
             f.write(new_content)
 
         # The main.cpp has been generated, add a teardown hook to remove it.
         if not self.teardown_hook_added:
             self.addTearDownHook(lambda: os.remove(src))
             self.teardown_hook_added = True
 
     def do_add_dsym_with_error(self, exe_name):
         """Test that the 'add-dsym' command informs the user about failures."""
         exe_path = self.getBuildArtifact(exe_name)
         self.runCmd("file " + exe_path, CURRENT_EXECUTABLE_SET)
 
-        wrong_path = os.path.join("%s.dSYM" % exe_name, "Contents")
+        wrong_path = os.path.join(self.getBuildDir(),
+                                  "%s.dSYM" % exe_name, "Contents")
         self.expect("add-dsym " + wrong_path, error=True,
                     substrs=['invalid module path'])
 
         right_path = os.path.join(
+            self.getBuildDir(),
             "%s.dSYM" %
             exe_path,
             "Contents",
             "Resources",
             "DWARF",
             exe_name)
         self.expect("add-dsym " + right_path, error=True,
                     substrs=['symbol file', 'does not match'])
 
     def do_add_dsym_with_success(self, exe_name):
         """Test that the 'add-dsym' command informs the user about success."""
         exe_path = self.getBuildArtifact(exe_name)
         self.runCmd("file " + exe_path, CURRENT_EXECUTABLE_SET)
 
         # This time, the UUID should match and we expect some feedback from
         # lldb.
         right_path = os.path.join(
+            self.getBuildDir(),
             "%s.dSYM" %
             exe_path,
             "Contents",
             "Resources",
             "DWARF",
             exe_name)
         self.expect("add-dsym " + right_path,
                     substrs=['symbol file', 'has been added to'])

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

     // get back to the actual executable otherwise, so we won't get the right
     // path.
     if (!at_exec_relative_paths.empty() && CalculateType() == eTypeExecutable) {
       FileSpec exec_dir = this_file_spec.CopyByRemovingLastPathComponent();
       for (const auto &at_exec_relative_path : at_exec_relative_paths) {
         FileSpec file_spec = 
             exec_dir.CopyByAppendingPathComponent(at_exec_relative_path);
         file_spec = file_spec.GetNormalizedPath();
-        if (file_spec.Exists() && files.AppendIfUnique(file_spec)) {
+        if (file_spec.Exists() && files.AppendIfUnique(file_spec))
           count++;
-          break;
-        }
       }
     }
   }
   return count;
 }
 
 lldb_private::Address ObjectFileMachO::GetEntryPointAddress() {
   // If the object file is not an executable it can't hold the entry point.

test/CMakeLists.txt

 function(add_python_test_target name test_script args comment)
   set(PYTHON_TEST_COMMAND
     ${PYTHON_EXECUTABLE}
     ${test_script}
     ${args}
     )
 
   add_custom_target(${name}
+    # Clear the test directory first.
+    COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_BINARY_DIR}/lldb-test-build
     COMMAND ${PYTHON_TEST_COMMAND} ${ARG_DEFAULT_ARGS}
     COMMENT "${comment}"
     DEPENDS ${LLDB_TEST_DEPS}
     USES_TERMINAL
     )
 endfunction()
 
 set(LLDB_TEST_DEPS lldb)

   ""
   CACHE STRING "Specify additional arguments to pass to test runner. For example: '-C gcc -C clang -A i386 -A x86_64'")
 
 set(LLDB_TEST_COMMON_ARGS
   --arch=${LLDB_TEST_ARCH}
   --executable $<TARGET_FILE:lldb>
   -s
   ${CMAKE_BINARY_DIR}/lldb-test-traces
+  --build-dir
+  ${CMAKE_BINARY_DIR}/lldb-test-build
   -S nm
   -u CXXFLAGS
   -u CFLAGS
   -C ${LLDB_TEST_C_COMPILER}
   )
 
 if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   # All tests are currently flaky on Windows, so rerun them all once when they fail.