This is an archive of the discontinued LLVM Phabricator instance.

Differential D42281

Compile the LLDB tests out-of-tree
ClosedPublic

Authored by aprantl on Jan 18 2018, 7:27 PM.

Details

Reviewers
davide
zturner
clayborg
labath
jingham
jasonmolenda
Commits
rG5ec76fe720e4: Compile the LLDB tests out-of-tree.
rLLDB323803: Compile the LLDB tests out-of-tree.
rL323803: Compile the LLDB tests out-of-tree.
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.

Diff Detail

Repository
rL LLVM

Event Timeline

aprantl created this revision.Jan 18 2018, 7:27 PM
zturner added a subscriber: zturner.Jan 18 2018, 8:00 PM
zturner added inline comments.
packages/Python/lldbsuite/test/dotest.py
625 ↗(On Diff #130546)

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

1193 ↗(On Diff #130546)

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 ↗(On Diff #130546)

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 ↗(On Diff #130546)

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 ↗(On Diff #130546)

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

62 ↗(On Diff #130546)

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 ↗(On Diff #130546)

Can this be deleted?

labath added a subscriber: labath.Jan 19 2018, 2:33 AM

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 ↗(On Diff #130546)

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 ↗(On Diff #130546)

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

clayborg added a subscriber: clayborg.Jan 19 2018, 8:50 AM

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 ↗(On Diff #130546)

Maybe add a default right here?:

default=os.getcwd()
aprantl added a comment.Jan 19 2018, 9:02 AM
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 added a subscriber: davide.Jan 19 2018, 9:07 AM
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 requested changes to this revision.Jan 19 2018, 9:09 AM

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 ↗(On Diff #130546)

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

This revision now requires changes to proceed.Jan 19 2018, 9:09 AM
JDevlieghere added a subscriber: JDevlieghere.Jan 22 2018, 3:15 PM
aprantl updated this revision to Diff 131103.Jan 23 2018, 10:21 AM

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.

Herald added subscribers: kbarton, eraman, javed.absar and 3 others. · View Herald TranscriptJan 23 2018, 10:21 AM
aprantl added inline comments.Jan 23 2018, 10:23 AM
packages/Python/lldbsuite/test/dotest_args.py
166 ↗(On Diff #130546)

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

aprantl updated this revision to Diff 131173.Jan 23 2018, 5:10 PM

This is starting to look manageable.

Failure:              30
Error:               113
aprantl updated this revision to Diff 131484.Jan 25 2018, 10:50 AM

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 updated this revision to Diff 131525.Jan 25 2018, 5:37 PM
aprantl marked 7 inline comments as done.

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!

aprantl added reviewers: zturner, clayborg, labath, jingham, jasonmolenda.Jan 25 2018, 5:38 PM
jingham requested changes to this revision.Jan 25 2018, 6:39 PM

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 ↗(On Diff #131525)

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

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/TestBreakpointSetRestart.py
35–37 ↗(On Diff #131525)

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–48 ↗(On Diff #131525)

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 ↗(On Diff #131525)

Probably can delete this now...

packages/Python/lldbsuite/test/types/AbstractBase.py
37–38 ↗(On Diff #131525)

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

This revision now requires changes to proceed.Jan 25 2018, 6:39 PM
labath added a comment.Jan 26 2018, 2:59 AM

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 updated this revision to Diff 131657.Jan 26 2018, 2:19 PM
  • incorporate pavel's Linux patch
  • default the builddir to $PWD/lldb-test-build
aprantl updated this revision to Diff 131658.Jan 26 2018, 2:29 PM
aprantl marked 4 inline comments as done.

Address Jim's comments.

aprantl retitled this revision from WIP: compile the LLDB tests out-of-tree to Compile the LLDB tests out-of-tree.Jan 26 2018, 2:29 PM
aprantl added inline comments.
packages/Python/lldbsuite/test/api/check_public_api_headers/TestPublicAPIHeaders.py
46 ↗(On Diff #131525)

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 ↗(On Diff #130546)

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
35–37 ↗(On Diff #131525)

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

aprantl added a comment.Jan 26 2018, 9:02 PM

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 added a comment.Jan 27 2018, 3:01 PM

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

labath added a comment.Jan 29 2018, 1:22 AM
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 ↗(On Diff #131658)

s/Sourc/Source/

packages/Python/lldbsuite/test/plugins/builder_base.py
65 ↗(On Diff #131658)

delete

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
5139–5142 ↗(On Diff #131658)

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

labath added a comment.Jan 29 2018, 6:22 AM

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 added a comment.Jan 29 2018, 10:24 AM
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 ↗(On Diff #131658)

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 updated this revision to Diff 131899.Jan 29 2018, 4:22 PM
aprantl marked 3 inline comments as done.

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

Herald added subscribers: hintonda, mgorny. · View Herald TranscriptJan 29 2018, 4:22 PM
labath accepted this revision.Jan 30 2018, 6:57 AM

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.

This revision was not accepted when it landed; it landed in state Needs Review.Jan 30 2018, 10:31 AM
Closed by commit rL323803: Compile the LLDB tests out-of-tree. (authored by adrian). · Explain Why
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptJan 30 2018, 10:31 AM
aprantl added a comment.Jan 30 2018, 10:38 AM

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 added a comment.Jan 30 2018, 12:34 PM

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 added a comment.Jan 30 2018, 1:20 PM
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 added a comment.Jan 31 2018, 8:14 AM
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 added a comment.Jan 31 2018, 9:18 AM

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.

Revision Contents

PathSize
lldb/
trunk/
docs/
testsuite/
24 lines
packages/
Python/
lldbsuite/
test/
api/
check_public_api_headers/
10 lines
multiple-debuggers/
4 lines
multiple-targets/
2 lines
multithreaded/
10 lines
arm/
emulation/
6 lines
benchmarks/
expression/
2 lines
3 lines
4 lines
13 lines
6 lines
expression_command/
call-overridden-method/
3 lines
save_jit_objects/
32 lines
top-level/
4 lines
3 lines
functionalities/
attach_resume/
2 lines
breakpoint/
address_breakpoints/
5 lines
breakpoint_case_sensitivity/
8 lines
breakpoint_command/
2 lines
breakpoint_names/
2 lines
breakpoint_set_restart/
5 lines
comp_dir_symlink/
9 lines
16 lines
serialize/
10 lines
command_script_immediate_output/
18 lines
exec/
12 lines
fat_archives/
10 lines
frame-language/
4 lines
launch_with_shellexpand/
7 lines
load_unload/
15 lines
62 lines
7 lines
plugins/
commands/
2 lines
python_os_plugin/
8 lines
postmortem/
minidump/
4 lines
process_attach/
12 lines
attach_denied/
2 lines
process_launch/
4 lines
my_working_dir/
process_save_core/
4 lines
register/
register_command/
2 lines
single-quote-in-filename-to-lldb/
2 lines
path with '09/
step-avoids-no-debug/
2 lines
stop-hook/
multiple_threads/
2 lines
target_command/
10 lines
thread/
concurrent_events/
breakpoint_delay_breakpoint_one_signal/
5 lines
breakpoint_one_delay_breakpoint_threads/
5 lines
breakpoints_delayed_breakpoint_one_watchpoint/
5 lines
crash_with_break/
5 lines
crash_with_signal/
5 lines
crash_with_watchpoint/
5 lines
crash_with_watchpoint_breakpoint_signal/
5 lines
delay_signal_break/
5 lines
delay_signal_watch/
5 lines
delay_watch_break/
5 lines
delayed_crash_with_breakpoint_signal/
5 lines
delayed_crash_with_breakpoint_watchpoint/
5 lines
many_breakpoints/
5 lines
many_crash/
5 lines
many_signals/
5 lines
many_watchpoints/
5 lines
n_watch_n_break/
5 lines
signal_break/
5 lines
signal_delay_break/
5 lines
signal_delay_watch/
5 lines
signal_n_watch_n_break/
5 lines
signal_watch/
5 lines
signal_watch_break/
5 lines
two_breakpoint_threads/
5 lines
two_breakpoints_one_delay_signal/
5 lines
two_breakpoints_one_signal/
5 lines
two_breakpoints_one_watchpoint/
5 lines
two_watchpoint_threads/
5 lines
two_watchpoints_one_breakpoint/
5 lines
two_watchpoints_one_delay_breakpoint/
5 lines
two_watchpoints_one_signal/
5 lines
watch_break/
5 lines
watch_break_delay/
5 lines
watchpoint_delay_watchpoint_one_breakpoint/
5 lines
watchpoint_with_delay_watchpoint_threads/
5 lines
watchpoint/
hello_watchlocation/
2 lines
hello_watchpoint/
2 lines
multi_watchpoint_slots/
2 lines
variable_out_of_scope/
2 lines
watchpoint_commands/
10 lines
command/
4 lines
7 lines
condition/
2 lines
watchpoint_disable/
2 lines
watchpoint_size/
2 lines
lang/
c/
conflicting-symbol/
10 lines
4 lines
5 lines
4 lines
tls_globals/
4 lines
unions/
4 lines
cpp/
chained-calls/
4 lines
dynamic-value/
2 lines
global_operators/
1 line
gmodules/
3 lines
incomplete-types/
8 lines
3 lines
limit-debug-info/
4 lines
namespace_definitions/
6 lines
nsimport/
3 lines
scope/
3 lines
objc/
conflicting-definition/
39 lines
Test/
10 lines
TestExt/
10 lines
foundation/
2 lines
2 lines
hidden-ivars/
10 lines
ivar-IMP/
4 lines
modules-incomplete/
2 lines
modules-inline-functions/
2 lines
objc-dyn-sbtype/
2 lines
objc-ivar-stripped/
2 lines
print-obj/
2 lines
radar-9691614/
2 lines
rdar-10967107/
2 lines
rdar-11355592/
2 lines
rdar-12408181/
2 lines
25 lines
121 lines
9 lines
logging/
2 lines
macosx/
add-dsym/
4 lines
find-app-in-bundle/
9 lines
2 lines
find-dsym/
bundle-with-dot-in-filename/
6 lines
4 lines
deep-bundle/
12 lines
5 lines
9 lines
indirect_symbol/
28 lines
4 lines
nslog/
2 lines
order/
2 lines
queues/
29 lines
safe-to-func-call/
29 lines
thread-names/
29 lines
universal/
12 lines
6 lines
make/
41 lines
plugins/
71 lines
13 lines
3 lines
3 lines
3 lines
3 lines
python_api/
class_members/
2 lines
formatters/
9 lines
hello_world/
2 lines
process/
io/
8 lines
read-mem-cstring/
6 lines
section/
2 lines
target/
9 lines
thread/
6 lines
type/
2 lines
value/
2 lines
change_values/
2 lines
linked_list/
2 lines
value_var_update/
2 lines
watchpoint/
condition/
2 lines
settings/
6 lines
quoting/
18 lines
4 lines
source-manager/
11 lines
tools/
lldb-mi/
2 lines
breakpoint/
2 lines
5 lines
symbol/
2 lines
target/
9 lines
types/
9 lines
warnings/
uuid/
10 lines
source/
Plugins/
ObjectFile/
Mach-O/
4 lines
test/
4 lines

Diff 132002

lldb/trunk/docs/testsuite/a-detailed-walkthrough.txt

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Linessee test/array_types/TestArrayTypes.py:
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
def test_with_dsym_and_run_command(self): def test_with_dsym_and_run_command(self):
"""Test 'frame variable var_name' on some variables with array types.""" """Test 'frame variable var_name' on some variables with array types."""
self.buildDsym() self.buildDsym()
self.array_types() self.array_types()
This method is decorated with a skipUnless decorator so that it will only gets 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 included into the test suite if the platform it is running on is 'darwin', a.k.a.
Mac OS X. macOS.
Type 'man dsymutil' for more details. Type 'man dsymutil' for more details.
After the binary is built, it is time to specify the file to be used as the main After the binary is built, it is time to specify the file to be used as the main
executable by lldb: 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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
This is where the attribute assignment: This is where the attribute assignment:
class SettingsCommandTestCase(TestBase): class SettingsCommandTestCase(TestBase):
mydir = "settings" mydir = "settings"
Show All 14 Lines
There are cases when we don't care about the return status from the command 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 execution. This can be accomplished by passing the keyword argument pair
'check=False' to the method. 'check=False' to the method.
After the current executable is set, we'll then execute two more commands: After the current executable is set, we'll then execute two more commands:
# Set the output-path and verify it is set. # 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", self.expect("settings show target.process.output-path",
SETTING_MSG("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 The first uses the 'settings set' command to set the static setting
target.process.output-path to be 'stdout.txt', instead of the default target.process.output-path to be 'stdout.txt', instead of the default
'/dev/stdout'. We then immediately issue a 'settings show' command to check '/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 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 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 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 start string of the output against what we pass in as the value of the keyword
argument pair: 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 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 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 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 of expecting something from the output of command execution, it can perform the
action of 'not expecting' something. action of 'not expecting' something.
This will launch/run the program: This will launch/run the program:
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
And this asserts that the file 'stdout.txt' should be present after running the And this asserts that the file 'stdout.txt' should be present after running the
program. program.
# The 'stdout.txt' file should now exist. # The 'stdout.txt' file should now exist.
self.assertTrue(os.path.isfile("stdout.txt"), self.assertTrue(os.path.isfile(stdout),
"'stdout.txt' exists due to target.process.output-path.") "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 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 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: it contains the same message as programmed in main.cpp:
# Read the output file produced by running the program. # 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() output = f.read()
self.expect(output, exe=False, self.expect(output, exe=False,
startstr = "This message should go to standard out.") startstr = "This message should go to standard out.")
We open the file and read its contents into output, then issue an expect() 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 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 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! match against whatever is thrown in as keyword argument pairs!
There are also other test methods present in the TestSettings.py mode: There are also other test methods present in the TestSettings.py mode:
test_set_prompt(), test_set_term_width(), test_set_auto_confirm(), 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 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 from unittest framework, which uses the 'test' method name prefix to identify
test methods automatically. test methods automatically.
This finishes the walkthrough of the test method test_set_output_path(self). 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 Before we say goodbye, notice the little method definition at the top of the
file: file:
@classmethod @classmethod
def classCleanup(cls): def classCleanup(cls):
system(["/bin/sh", "-c", "rm -f output.txt"]) system(["/bin/sh", "-c", "rm -f "+self.getBuildArtifact("output.txt")])
system(["/bin/sh", "-c", "rm -f stdout.txt"]) system(["/bin/sh", "-c", "rm -f "+self.getBuildArtifact("stdout.txt")])
This is a classmethod (as shown by the @classmethod decorator) which allows the 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 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 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: the unittest framework. From http://docs.python.org/library/unittest.html:
A test fixture represents the preparation needed to perform one or more tests, A test fixture represents the preparation needed to perform one or more tests,
and any associate cleanup actions. This may involve, for example, creating and any associate cleanup actions. This may involve, for example, creating
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

Show All 15 Lines
class SBDirCheckerCase(TestBase): class SBDirCheckerCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def setUp(self): def setUp(self):
TestBase.setUp(self) TestBase.setUp(self)
self.source = 'main.cpp' self.source = 'main.cpp'
self.exe_name = self.getBuildArtifact("a.out")
self.generateSource(self.source) self.generateSource(self.source)
@skipIfNoSBHeaders @skipIfNoSBHeaders
def test_sb_api_directory(self): def test_sb_api_directory(self):
"""Test the SB API directory and make sure there's no unwanted stuff.""" """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. # Only proceed if this is an Apple OS, "x86_64", and local platform.
if not (self.platformIsDarwin() and self.getArchitecture() == "x86_64"): if not (self.platformIsDarwin() and self.getArchitecture() == "x86_64"):
self.skipTest("This test is only for LLDB.framework built 64-bit") self.skipTest("This test is only for LLDB.framework built 64-bit")
if self.getArchitecture() == "i386": if self.getArchitecture() == "i386":
self.skipTest( self.skipTest(
"LLDB is 64-bit and cannot be linked to 32-bit test program.") "LLDB is 64-bit and cannot be linked to 32-bit test program.")
self.buildDriver(self.source, self.exe_name) exe_name = self.getBuildArtifact("a.out")
self.sanity_check_executable(self.exe_name) self.buildDriver(self.source, exe_name)
self.sanity_check_executable(exe_name)
def sanity_check_executable(self, exe_name): def sanity_check_executable(self, exe_name):
"""Sanity check executable compiled from the auto-generated program.""" """Sanity check executable compiled from the auto-generated program."""
exe_name = self.getBuildArtifact("a.out")
exe = self.getBuildArtifact(exe_name) exe = self.getBuildArtifact(exe_name)
self.runCmd("file %s" % exe, CURRENT_EXECUTABLE_SET) 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.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" % ( env_cmd = "settings set target.env-vars %s=%s" % (
self.dylibPath, self.getLLDBLibraryEnvVal()) self.dylibPath, self.getLLDBLibraryEnvVal())
if self.TraceOn(): if self.TraceOn():
print("Set environment to: ", env_cmd) print("Set environment to: ", env_cmd)
self.runCmd(env_cmd) self.runCmd(env_cmd)
self.addTearDownHook( self.addTearDownHook(
lambda: self.dbg.HandleCommand( lambda: self.dbg.HandleCommand(
Show All 14 Lines

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

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

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

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

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

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Lines def build_and_test(self, sources, test_name, args=None):
# because remote is disabled, we can assume that the os is the same # because remote is disabled, we can assume that the os is the same
# still need to check architecture # still need to check architecture
if self.getLldbArchitecture() != self.getArchitecture(): if self.getLldbArchitecture() != self.getArchitecture():
self.skipTest( self.skipTest(
"This test is only run if the target arch is the same as the lldb binary arch") "This test is only run if the target arch is the same as the lldb binary arch")
self.inferior = 'inferior_program' self.inferior = 'inferior_program'
self.buildProgram('inferior.cpp', self.inferior) 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.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) self.signBinary(test_exe)
exe = [test_exe, self.inferior] exe = [test_exe, self.getBuildArtifact(self.inferior)]
env = {self.dylibPath: self.getLLDBLibraryEnvVal()} env = {self.dylibPath: self.getLLDBLibraryEnvVal()}
if self.TraceOn(): if self.TraceOn():
print("Running test %s" % " ".join(exe)) print("Running test %s" % " ".join(exe))
check_call(exe, env=env) check_call(exe, env=env)
else: else:
with open(os.devnull, 'w') as fnull: with open(os.devnull, 'w') as fnull:
check_call(exe, env=env, stdout=fnull, stderr=fnull) check_call(exe, env=env, stdout=fnull, stderr=fnull)
def build_program(self, sources, program): def build_program(self, sources, program):
return self.buildDriver(sources, program) return self.buildDriver(sources, program)

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

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

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

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

lldb/trunk/packages/Python/lldbsuite/test/configuration.py

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
failed = False failed = False
# LLDB Remote platform setting # LLDB Remote platform setting
lldb_platform_name = None lldb_platform_name = None
lldb_platform_url = None lldb_platform_url = None
lldb_platform_working_dir = None lldb_platform_working_dir = None
# The base directory in which the tests are being built.
test_build_dir = None
# Parallel execution settings # Parallel execution settings
is_inferior_test_runner = False is_inferior_test_runner = False
multiprocess_test_subdir = None multiprocess_test_subdir = None
num_threads = None num_threads = None
no_multiprocess_test_runner = False no_multiprocess_test_runner = False
test_runner_name = None test_runner_name = None
# Test results handling globals # Test results handling globals
Show All 30 Lines

lldb/trunk/packages/Python/lldbsuite/test/darwin_log.py

Show First 20 Lines • Show All 156 Lines • ▼ Show 20 Lines def do_test(self, enable_options, expect_regexes=None,
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
# Build the darwin-log enable command. # Build the darwin-log enable command.
enable_cmd = expand_darwinlog_command('enable') enable_cmd = expand_darwinlog_command('enable')
if enable_options is not None and len(enable_options) > 0: if enable_options is not None and len(enable_options) > 0:
enable_cmd += ' ' + ' '.join(enable_options) 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, self.run_lldb_to_breakpoint(exe, self.source, self.line,
enable_command=enable_cmd, enable_command=enable_cmd,
settings_commands=settings_commands) settings_commands=settings_commands)
self.expect_prompt() self.expect_prompt()
# Now go. # Now go.
self.runCmd("process continue") self.runCmd("process continue")
self.expect(self.CONTINUE_REGEX) self.expect(self.CONTINUE_REGEX)
▲ Show 20 Lines • Show All 203 Lines • ▼ Show 20 Lines def do_test(self, enable_options, settings_commands=None,
self.assertEqual(1, breakpoint.GetNumLocations(), self.assertEqual(1, breakpoint.GetNumLocations(),
"Should have found one breakpoint") "Should have found one breakpoint")
# Enable packet logging. # Enable packet logging.
# self.runCmd("log enable -f /tmp/packets.log gdb-remote packets") # self.runCmd("log enable -f /tmp/packets.log gdb-remote packets")
# self.runCmd("log enable lldb process") # self.runCmd("log enable lldb process")
# Launch the process - doesn't stop at entry. # 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) self.assertIsNotNone(process, lldbtest.PROCESS_IS_VALID)
# Keep track of whether we're tracing output. # Keep track of whether we're tracing output.
trace_on = self.TraceOn() trace_on = self.TraceOn()
# Get the next thread that stops. # Get the next thread that stops.
from lldbsuite.test.lldbutil import get_stopped_thread from lldbsuite.test.lldbutil import get_stopped_thread
thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint) thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/dotest.py

Show First 20 Lines • Show All 468 Lines • ▼ Show 20 Linesdef parseOptionsAndInitTestdirs():
configuration.rerun_max_file_threshold = args.rerun_max_file_threshold configuration.rerun_max_file_threshold = args.rerun_max_file_threshold
if args.lldb_platform_name: if args.lldb_platform_name:
configuration.lldb_platform_name = args.lldb_platform_name configuration.lldb_platform_name = args.lldb_platform_name
if args.lldb_platform_url: if args.lldb_platform_url:
configuration.lldb_platform_url = args.lldb_platform_url configuration.lldb_platform_url = args.lldb_platform_url
if args.lldb_platform_working_dir: if args.lldb_platform_working_dir:
configuration.lldb_platform_working_dir = 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: if args.event_add_entries and len(args.event_add_entries) > 0:
entries = {} entries = {}
# Parse out key=val pairs, separated by comma # Parse out key=val pairs, separated by comma
for keyval in args.event_add_entries.split(","): for keyval in args.event_add_entries.split(","):
key_val_entry = keyval.split("=") key_val_entry = keyval.split("=")
if len(key_val_entry) == 2: if len(key_val_entry) == 2:
(key, val) = key_val_entry (key, val) = key_val_entry
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Linesdef setupSysPath():
else: else:
scriptPath = os.path.dirname(os.path.realpath(__file__)) scriptPath = os.path.dirname(os.path.realpath(__file__))
if not scriptPath.endswith('test'): if not scriptPath.endswith('test'):
print("This script expects to reside in lldb's test directory.") print("This script expects to reside in lldb's test directory.")
sys.exit(-1) sys.exit(-1)
os.environ["LLDB_TEST"] = scriptPath 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 # Set up the LLDB_SRC environment variable, so that the tests can locate
# the LLDB source code. # the LLDB source code.
os.environ["LLDB_SRC"] = lldbsuite.lldb_root os.environ["LLDB_SRC"] = lldbsuite.lldb_root
pluginPath = os.path.join(scriptPath, 'plugins') pluginPath = os.path.join(scriptPath, 'plugins')
toolsLLDBMIPath = os.path.join(scriptPath, 'tools', 'lldb-mi') toolsLLDBMIPath = os.path.join(scriptPath, 'tools', 'lldb-mi')
toolsLLDBServerPath = os.path.join(scriptPath, 'tools', 'lldb-server') toolsLLDBServerPath = os.path.join(scriptPath, 'tools', 'lldb-server')
▲ Show 20 Lines • Show All 547 Lines • ▼ Show 20 Lines if configuration.lldb_platform_working_dir:
configuration.lldb_platform_working_dir): configuration.lldb_platform_working_dir):
raise Exception("failed to set working directory '%s'" % remote_test_dir) raise Exception("failed to set working directory '%s'" % remote_test_dir)
lldb.DBG.SetSelectedPlatform(lldb.remote_platform) lldb.DBG.SetSelectedPlatform(lldb.remote_platform)
else: else:
lldb.remote_platform = None lldb.remote_platform = None
configuration.lldb_platform_working_dir = None configuration.lldb_platform_working_dir = None
configuration.lldb_platform_url = 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] target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
checkLibcxxSupport() checkLibcxxSupport()
# Don't do debugserver tests on everything except OS X. # 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 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. # Don't do lldb-server (llgs) tests on anything except Linux.
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/dotest_args.py

Show First 20 Lines • Show All 153 Lines • ▼ Show 20 Lines group.add_argument(
dest='log_success', dest='log_success',
action='store_true', action='store_true',
help="Leave logs/traces even for successful test runs (useful for creating reference log files during debugging.)") help="Leave logs/traces even for successful test runs (useful for creating reference log files during debugging.)")
group.add_argument( group.add_argument(
'--codesign-identity', '--codesign-identity',
metavar='Codesigning identity', metavar='Codesigning identity',
default='lldb_codesign', default='lldb_codesign',
help='The codesigning identity to use') 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 # Configuration options
group = parser.add_argument_group('Remote platform options') group = parser.add_argument_group('Remote platform options')
group.add_argument( group.add_argument(
'--platform-name', '--platform-name',
dest='lldb_platform_name', dest='lldb_platform_name',
metavar='platform-name', metavar='platform-name',
help='The name of a remote platform to use') help='The name of a remote platform to use')
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

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

Show All 25 Lines def setUp(self):
# Find the line number to break for main.c. # Find the line number to break for main.c.
self.line = line_number('main.cpp', '// Set breakpoint here') self.line = line_number('main.cpp', '// Set breakpoint here')
def test(self): def test(self):
"""Test calls to overridden methods in derived classes.""" """Test calls to overridden methods in derived classes."""
self.build() self.build()
# Set breakpoint in main and run exe # 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( 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) self.runCmd("run", RUN_SUCCEEDED)
# Test call to method in base class (this should always work as the base # Test call to method in base class (this should always work as the base
# class method is never an override). # class method is never an override).
self.expect("expr b->foo()") self.expect("expr b->foo()")
# Test call to overridden method in derived class (this will fail if the # 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 # overrides table is not correctly set up, as Derived::foo will be assigned
# a vtable entry that does not exist in the compiled program). # a vtable entry that does not exist in the compiled program).
self.expect("expr d.foo()") self.expect("expr d.foo()")

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

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

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

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

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

Show All 39 Lines def build_and_run(self):
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( lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False) self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
def run_dummy(self): 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( lldbutil.run_break_set_by_file_and_line(
self, self,
"dummy.cpp", "dummy.cpp",
self.dummy_line, self.dummy_line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=False) loc_exact=False)
Show All 39 Lines

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

Show All 24 Linesclass AttachResumeTestCase(TestBase):
def test_attach_continue_interrupt_detach(self): def test_attach_continue_interrupt_detach(self):
"""Test attach/continue/interrupt/detach""" """Test attach/continue/interrupt/detach"""
self.build() self.build()
self.process_attach_continue_interrupt_detach() self.process_attach_continue_interrupt_detach()
def process_attach_continue_interrupt_detach(self): def process_attach_continue_interrupt_detach(self):
"""Test attach/continue/interrupt/detach""" """Test attach/continue/interrupt/detach"""
exe = os.path.join(os.getcwd(), exe_name) exe = self.getBuildArtifact(exe_name)
popen = self.spawnSubprocess(exe) popen = self.spawnSubprocess(exe)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
self.runCmd("process attach -p " + str(popen.pid)) self.runCmd("process attach -p " + str(popen.pid))
self.setAsync(True) self.setAsync(True)
listener = self.dbg.GetListener() listener = self.dbg.GetListener()
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

Show All 24 Lines def test_bad_address_breakpoints(self):
self.address_breakpoints() self.address_breakpoints()
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
def address_breakpoints(self): def address_breakpoints(self):
"""Test that breakpoints set on a bad address say they are bad.""" """Test that breakpoints set on a bad address say they are bad."""
(target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
(target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, self, "Set a breakpoint here", lldb.SBFileSpec("main.c"))
"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 # 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... # what an illegal address is...
error = lldb.SBError() error = lldb.SBError()
ptr = process.ReadPointerFromMemory(0x0, error) ptr = process.ReadPointerFromMemory(0x0, error)
if not error.Success(): if not error.Success():
bkpt = target.BreakpointCreateByAddress(0x0) bkpt = target.BreakpointCreateByAddress(0x0)
for bp_loc in bkpt: for bp_loc in bkpt:
self.assertTrue(bp_loc.IsResolved() == False) self.assertTrue(bp_loc.IsResolved() == False)
else: else:
self.fail( self.fail(
"Could not find an illegal address at which to set a bad breakpoint.") "Could not find an illegal address at which to set a bad breakpoint.")

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

Show All 38 Lines def case_sensitivity_breakpoint(self, case_insensitive):
if case_insensitive: if case_insensitive:
exe = exe.upper() exe = exe.upper()
exe = self.getBuildArtifact(exe) exe = self.getBuildArtifact(exe)
# Create a target by the debugger. # Create a target by the debugger.
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) self.assertTrue(self.target, VALID_TARGET)
cwd = os.getcwd() srcdir = self.getSourceDir()
# try both BreakpointCreateByLocation and BreakpointCreateBySourceRegex # try both BreakpointCreateByLocation and BreakpointCreateBySourceRegex
for regex in [False, True]: for regex in [False, True]:
# should always hit # should always hit
self.check_breakpoint('main.c', regex, True) self.check_breakpoint('main.c', regex, True)
# should always hit # 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 # 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, regex,
case_insensitive) case_insensitive)
# different case for file # different case for file
self.check_breakpoint('Main.c', self.check_breakpoint('Main.c',
regex, regex,
case_insensitive) case_insensitive)
# different case for both # 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, regex,
case_insensitive) case_insensitive)
def check_breakpoint(self, file, source_regex, should_hit): def check_breakpoint(self, file, source_regex, should_hit):
""" """
Check breakpoint hit at given file set by given method Check breakpoint hit at given file set by given method
file: file:
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines def regexp_break_command(self):
lldbutil.check_breakpoint_result( lldbutil.check_breakpoint_result(
self, self,
break_results, break_results,
file_name='main.c', file_name='main.c',
line_number=self.line, line_number=self.line,
num_locations=1) num_locations=1)
# Check breakpoint with full file path. # 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( break_results = lldbutil.run_break_set_command(
self, "b %s:%d" % (full_path, self.line)) self, "b %s:%d" % (full_path, self.line))
lldbutil.check_breakpoint_result( lldbutil.check_breakpoint_result(
self, self,
break_results, break_results,
file_name='main.c', file_name='main.c',
line_number=self.line, line_number=self.line,
num_locations=1) num_locations=1)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', substrs=['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])

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

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines def test_configuring_permissions_cli(self):
self.do_check_configuring_permissions_cli() self.do_check_configuring_permissions_cli()
def setup_target(self): def setup_target(self):
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
# Create a targets we are making breakpoint in and copying to: # Create a targets we are making breakpoint in and copying to:
self.target = self.dbg.CreateTarget(exe) self.target = self.dbg.CreateTarget(exe)
self.assertTrue(self.target, VALID_TARGET) 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): def check_name_in_target(self, bkpt_name):
name_list = lldb.SBStringList() name_list = lldb.SBStringList()
self.target.GetBreakpointNames(name_list) self.target.GetBreakpointNames(name_list)
found_it = False found_it = False
for name in name_list: for name in name_list:
if name == bkpt_name: if name == bkpt_name:
found_it = True found_it = True
▲ Show 20 Lines • Show All 293 Lines • Show Last 20 Lines

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

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

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

LEVEL = ../../../make LEVEL = ../../../make
CXX_SOURCES := main.cpp CXX_SOURCES := relative.cpp
EXE := CompDirSymLink EXE := CompDirSymLink
include $(LEVEL)/Makefile.rules 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

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

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

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

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines def setup_targets_and_cleanup(self):
self.copy_target = self.dbg.CreateTarget(exe) self.copy_target = self.dbg.CreateTarget(exe)
self.assertTrue(self.copy_target, VALID_TARGET) self.assertTrue(self.copy_target, VALID_TARGET)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) 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) self.bkpts_file_spec = lldb.SBFileSpec(self.bkpts_file_path)
def check_equivalence(self, source_bps, do_write = True): def check_equivalence(self, source_bps, do_write = True):
error = lldb.SBError() error = lldb.SBError()
if (do_write): if (do_write):
error = self.orig_target.BreakpointsWriteToFile(self.bkpts_file_spec, source_bps) error = self.orig_target.BreakpointsWriteToFile(self.bkpts_file_spec, source_bps)
Show All 29 Lines def check_equivalence(self, source_bps, do_write = True):
# print ("Source text for %d is %s."%(i, source_text)) # 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)) 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): def do_check_resolvers(self):
"""Use Python APIs to check serialization of breakpoint resolvers""" """Use Python APIs to check serialization of breakpoint resolvers"""
empty_module_list = lldb.SBFileSpecList() empty_module_list = lldb.SBFileSpecList()
empty_cu_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 # It isn't actually important for these purposes that these breakpoint
# actually have locations. # actually have locations.
source_bps = lldb.SBBreakpointList(self.orig_target) source_bps = lldb.SBBreakpointList(self.orig_target)
source_bps.Append(self.orig_target.BreakpointCreateByLocation("blubby.c", 666)) source_bps.Append(self.orig_target.BreakpointCreateByLocation("blubby.c", 666))
# Make sure we do one breakpoint right: # Make sure we do one breakpoint right:
self.check_equivalence(source_bps) self.check_equivalence(source_bps)
source_bps.Clear() source_bps.Clear()
Show All 11 Lines def do_check_filters(self):
module_list.Append(lldb.SBFileSpec("SomeBinary")) module_list.Append(lldb.SBFileSpec("SomeBinary"))
module_list.Append(lldb.SBFileSpec("SomeOtherBinary")) module_list.Append(lldb.SBFileSpec("SomeOtherBinary"))
cu_list = lldb.SBFileSpecList() cu_list = lldb.SBFileSpecList()
cu_list.Append(lldb.SBFileSpec("SomeCU.c")) cu_list.Append(lldb.SBFileSpec("SomeCU.c"))
cu_list.Append(lldb.SBFileSpec("AnotherCU.c")) cu_list.Append(lldb.SBFileSpec("AnotherCU.c"))
cu_list.Append(lldb.SBFileSpec("ThirdCU.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 # It isn't actually important for these purposes that these breakpoint
# actually have locations. # actually have locations.
source_bps = lldb.SBBreakpointList(self.orig_target) source_bps = lldb.SBBreakpointList(self.orig_target)
bkpt = self.orig_target.BreakpointCreateByLocation(blubby_file_spec, 666, 0, module_list) bkpt = self.orig_target.BreakpointCreateByLocation(blubby_file_spec, 666, 0, module_list)
source_bps.Append(bkpt) source_bps.Append(bkpt)
# Make sure we do one right: # Make sure we do one right:
Show All 10 Lines def do_check_filters(self):
# And some number greater than one: # And some number greater than one:
self.check_equivalence(source_bps) self.check_equivalence(source_bps)
def do_check_options(self): def do_check_options(self):
"""Use Python APIs to check serialization of breakpoint options.""" """Use Python APIs to check serialization of breakpoint options."""
empty_module_list = lldb.SBFileSpecList() empty_module_list = lldb.SBFileSpecList()
empty_cu_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 # It isn't actually important for these purposes that these breakpoint
# actually have locations. # actually have locations.
source_bps = lldb.SBBreakpointList(self.orig_target) source_bps = lldb.SBBreakpointList(self.orig_target)
bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666) bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)
bkpt.SetEnabled(False) bkpt.SetEnabled(False)
bkpt.SetOneShot(True) bkpt.SetOneShot(True)
Show All 27 Lines def do_check_options(self):
self.check_equivalence(source_bps) self.check_equivalence(source_bps)
def do_check_appending(self): def do_check_appending(self):
"""Use Python APIs to check appending to already serialized options.""" """Use Python APIs to check appending to already serialized options."""
empty_module_list = lldb.SBFileSpecList() empty_module_list = lldb.SBFileSpecList()
empty_cu_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 # It isn't actually important for these purposes that these breakpoint
# actually have locations. # actually have locations.
all_bps = lldb.SBBreakpointList(self.orig_target) all_bps = lldb.SBBreakpointList(self.orig_target)
source_bps = lldb.SBBreakpointList(self.orig_target) source_bps = lldb.SBBreakpointList(self.orig_target)
bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666) bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

LEVEL = ../../make LEVEL = ../../make
CXX_SOURCES := main.cpp other.cpp other-2.cpp CXX_SOURCES := main.cpp other.cpp other-2.cpp
C_SOURCES := somefunc.c C_SOURCES := somefunc.c
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules
other-2.o: other-2.cpp 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 somefunc.o: somefunc.c
$(CC) $(CFLAGS) -std=c99 -c somefunc.c $(CC) $(CFLAGS) -std=c99 -c $(SRCDIR)/somefunc.c
No newline at end of file

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

Show All 33 Lines def test(self):
# Create any breakpoints we need # Create any breakpoints we need
breakpoint = target.BreakpointCreateBySourceRegex( breakpoint = target.BreakpointCreateBySourceRegex(
'break here', lldb.SBFileSpec("main.cpp", False)) 'break here', lldb.SBFileSpec("main.cpp", False))
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
self.runCmd( self.runCmd(
"process launch -X true -w %s -- fi*.tx? () > <" % "process launch -X true -w %s -- fi*.tx? () > <" %
(os.getcwd())) (self.getSourceDir()))
process = self.process() process = self.process()
self.assertTrue(process.GetState() == lldb.eStateStopped, self.assertTrue(process.GetState() == lldb.eStateStopped,
STOPPED_DUE_TO_BREAKPOINT) STOPPED_DUE_TO_BREAKPOINT)
thread = process.GetThreadAtIndex(0) thread = process.GetThreadAtIndex(0)
Show All 21 Lines def test(self):
"frame variable argv[8]", "frame variable argv[8]",
substrs=['file5.tyx'], substrs=['file5.tyx'],
matching=False) matching=False)
self.runCmd("process kill") self.runCmd("process kill")
self.runCmd( self.runCmd(
'process launch -X true -w %s -- "foo bar"' % 'process launch -X true -w %s -- "foo bar"' %
(os.getcwd())) (self.getSourceDir()))
process = self.process() process = self.process()
self.assertTrue(process.GetState() == lldb.eStateStopped, self.assertTrue(process.GetState() == lldb.eStateStopped,
STOPPED_DUE_TO_BREAKPOINT) STOPPED_DUE_TO_BREAKPOINT)
thread = process.GetThreadAtIndex(0) thread = process.GetThreadAtIndex(0)
self.assertTrue(thread.IsValid(), self.assertTrue(thread.IsValid(),
"Process stopped at 'main' should have a valid thread") "Process stopped at 'main' should have a valid thread")
stop_reason = thread.GetStopReason() stop_reason = thread.GetStopReason()
self.assertTrue( self.assertTrue(
stop_reason == lldb.eStopReasonBreakpoint, stop_reason == lldb.eStopReasonBreakpoint,
"Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint") "Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint")
self.expect("frame variable argv[1]", substrs=['foo bar']) self.expect("frame variable argv[1]", substrs=['foo bar'])
self.runCmd("process kill") 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() process = self.process()
self.assertTrue(process.GetState() == lldb.eStateStopped, self.assertTrue(process.GetState() == lldb.eStateStopped,
STOPPED_DUE_TO_BREAKPOINT) STOPPED_DUE_TO_BREAKPOINT)
thread = process.GetThreadAtIndex(0) thread = process.GetThreadAtIndex(0)
Show All 10 Lines

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

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

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

Show All 16 Lines
@skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
class LoadUnloadTestCase(TestBase): class LoadUnloadTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
lldbutil.mkdir_p(self.getBuildArtifact("hidden"))
# Find the line number to break for main.cpp. # Find the line number to break for main.cpp.
self.line = line_number( self.line = line_number(
'main.cpp', 'main.cpp',
'// Set break point at this line for test_lldb_process_load_and_unload_commands().') '// Set break point at this line for test_lldb_process_load_and_unload_commands().')
self.line_d_function = line_number( self.line_d_function = line_number(
'd.cpp', '// Find this line number within d_dunction().') 'd.cpp', '// Find this line number within d_dunction().')
if not self.platformIsDarwin(): if not self.platformIsDarwin():
if not lldb.remote_platform and "LD_LIBRARY_PATH" in os.environ: if not lldb.remote_platform and "LD_LIBRARY_PATH" in os.environ:
self.runCmd( self.runCmd(
"settings set target.env-vars " + "settings set target.env-vars " +
self.dylibPath + self.dylibPath +
"=" + "=" +
os.environ["LD_LIBRARY_PATH"] + os.environ["LD_LIBRARY_PATH"] +
":" + ":" +
os.getcwd()) self.getBuildDir())
else: else:
if lldb.remote_platform: if lldb.remote_platform:
wd = lldb.remote_platform.GetWorkingDirectory() wd = lldb.remote_platform.GetWorkingDirectory()
else: else:
wd = os.getcwd() wd = self.getBuildDir()
self.runCmd( self.runCmd(
"settings set target.env-vars " + "settings set target.env-vars " +
self.dylibPath + self.dylibPath +
"=" + "=" +
wd) wd)
def copy_shlibs_to_remote(self, hidden_dir=False): def copy_shlibs_to_remote(self, hidden_dir=False):
""" Copies the shared libs required by this test suite to remote. """ Copies the shared libs required by this test suite to remote.
Does nothing in case of non-remote platforms. Does nothing in case of non-remote platforms.
""" """
if lldb.remote_platform: if lldb.remote_platform:
ext = 'so' ext = 'so'
if self.platformIsDarwin(): if self.platformIsDarwin():
ext = 'dylib' ext = 'dylib'
shlibs = ['libloadunload_a.' + ext, 'libloadunload_b.' + ext, shlibs = ['libloadunload_a.' + ext, 'libloadunload_b.' + ext,
'libloadunload_c.' + ext, 'libloadunload_d.' + ext] 'libloadunload_c.' + ext, 'libloadunload_d.' + ext]
wd = lldb.remote_platform.GetWorkingDirectory() wd = lldb.remote_platform.GetWorkingDirectory()
cwd = os.getcwd() cwd = os.getcwd()
for f in shlibs: for f in shlibs:
err = lldb.remote_platform.Put( err = lldb.remote_platform.Put(
lldb.SBFileSpec(os.path.join(cwd, f)), lldb.SBFileSpec(self.getBuildArtifact(f)),
lldb.SBFileSpec(os.path.join(wd, f))) lldb.SBFileSpec(os.path.join(wd, f)))
if err.Fail(): if err.Fail():
raise RuntimeError( raise RuntimeError(
"Unable copy '%s' to '%s'.\n>>> %s" % "Unable copy '%s' to '%s'.\n>>> %s" %
(f, wd, err.GetCString())) (f, wd, err.GetCString()))
if hidden_dir: if hidden_dir:
shlib = 'libloadunload_d.' + ext shlib = 'libloadunload_d.' + ext
hidden_dir = os.path.join(wd, 'hidden') hidden_dir = os.path.join(wd, 'hidden')
hidden_file = os.path.join(hidden_dir, shlib) hidden_file = os.path.join(hidden_dir, shlib)
err = lldb.remote_platform.MakeDirectory(hidden_dir) err = lldb.remote_platform.MakeDirectory(hidden_dir)
if err.Fail(): if err.Fail():
raise RuntimeError( raise RuntimeError(
"Unable to create a directory '%s'." % hidden_dir) "Unable to create a directory '%s'." % hidden_dir)
err = lldb.remote_platform.Put( err = lldb.remote_platform.Put(
lldb.SBFileSpec(os.path.join(cwd, 'hidden', shlib)), lldb.SBFileSpec(os.path.join('hidden', shlib)),
lldb.SBFileSpec(hidden_file)) lldb.SBFileSpec(hidden_file))
if err.Fail(): if err.Fail():
raise RuntimeError( raise RuntimeError(
"Unable copy 'libloadunload_d.so' to '%s'.\n>>> %s" % "Unable copy 'libloadunload_d.so' to '%s'.\n>>> %s" %
(wd, err.GetCString())) (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 @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
@not_remote_testsuite_ready @not_remote_testsuite_ready
@skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
def test_modules_search_paths(self): 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'.""" """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. # Invoke the default build rule.
self.build() self.build()
if self.platformIsDarwin(): if self.platformIsDarwin():
dylibName = 'libloadunload_d.dylib' dylibName = 'libloadunload_d.dylib'
else: else:
dylibName = 'libloadunload_d.so' dylibName = 'libloadunload_d.so'
# The directory with the dynamic library we did not link to. # 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) new_dylib = os.path.join(new_dir, dylibName)
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.expect("target modules list", self.expect("target modules list",
substrs=[old_dylib]) substrs=[old_dylib])
# self.expect("target modules list -t 3", # self.expect("target modules list -t 3",
# patterns = ["%s-[^-]*-[^-]*" % self.getArchitecture()]) # patterns = ["%s-[^-]*-[^-]*" % self.getArchitecture()])
# Add an image search path substitution pair. # Add an image search path substitution pair.
self.runCmd( self.runCmd(
"target modules search-paths add %s %s" % "target modules search-paths add %s %s" %
(os.getcwd(), new_dir)) (self.getBuildDir(), new_dir))
self.expect("target modules search-paths list", self.expect("target modules search-paths list",
substrs=[os.getcwd(), new_dir]) substrs=[self.getBuildDir(), new_dir])
self.expect( self.expect(
"target modules search-paths query %s" % "target modules search-paths query %s" %
os.getcwd(), self.getBuildDir(),
"Image search path successfully transformed", "Image search path successfully transformed",
substrs=[new_dir]) substrs=[new_dir])
# Obliterate traces of libd from the old location. # Obliterate traces of libd from the old location.
os.remove(old_dylib) os.remove(old_dylib)
# Inform (DY)LD_LIBRARY_PATH of the new path, too. # Inform (DY)LD_LIBRARY_PATH of the new path, too.
env_cmd_string = "settings set target.env-vars " + self.dylibPath + "=" + new_dir env_cmd_string = "settings set target.env-vars " + self.dylibPath + "=" + new_dir
if self.TraceOn(): if self.TraceOn():
print("Set environment to: ", env_cmd_string) print("Set environment to: ", env_cmd_string)
self.runCmd(env_cmd_string) self.runCmd(env_cmd_string)
self.runCmd("settings show target.env-vars") self.runCmd("settings show target.env-vars")
remove_dyld_path_cmd = "settings remove target.env-vars " + self.dylibPath remove_dyld_path_cmd = "settings remove target.env-vars " + self.dylibPath
self.addTearDownHook( self.addTearDownHook(
lambda: self.dbg.HandleCommand(remove_dyld_path_cmd)) lambda: self.dbg.HandleCommand(remove_dyld_path_cmd))
self.runCmd("run") self.runCmd("run")
self.expect( self.expect(
"target modules list", "target modules list",
"LLDB successfully locates the relocated dynamic library", "LLDB successfully locates the relocated dynamic library",
substrs=[new_dylib]) 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 @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
@expectedFailureAndroid # wrong source file shows up for hidden library @expectedFailureAndroid # wrong source file shows up for hidden library
@skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
def test_dyld_library_path(self): def test_dyld_library_path(self):
"""Test (DY)LD_LIBRARY_PATH after moving libd.dylib, which defines d_function, somewhere else.""" """Test (DY)LD_LIBRARY_PATH after moving libd.dylib, which defines d_function, somewhere else."""
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
Show All 12 Lines def test_dyld_library_path(self):
else: else:
dylibName = 'libloadunload_d.so' dylibName = 'libloadunload_d.so'
# The directory to relocate the dynamic library and its debugging info. # The directory to relocate the dynamic library and its debugging info.
special_dir = "hidden" special_dir = "hidden"
if lldb.remote_platform: if lldb.remote_platform:
wd = lldb.remote_platform.GetWorkingDirectory() wd = lldb.remote_platform.GetWorkingDirectory()
else: else:
wd = os.getcwd() wd = self.getBuildDir()
old_dir = wd old_dir = wd
new_dir = os.path.join(wd, special_dir) new_dir = os.path.join(wd, special_dir)
old_dylib = os.path.join(old_dir, dylibName) 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( self.addTearDownHook(
lambda: self.dbg.HandleCommand(remove_dyld_path_cmd)) 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 # For now we don't track (DY)LD_LIBRARY_PATH, so the old
# the modules list. # library will be in the modules list.
self.expect("target modules list", self.expect("target modules list",
substrs=[os.path.basename(old_dylib)], substrs=[os.path.basename(old_dylib)],
matching=True) matching=True)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "d.cpp", self.line_d_function, num_expected_locations=1) self, "d.cpp", self.line_d_function, num_expected_locations=1)
# After run, make sure the non-hidden library is picked up. # After run, make sure the non-hidden library is picked up.
self.expect("run", substrs=["return", "700"]) self.expect("run", substrs=["return", "700"])
self.runCmd("continue") self.runCmd("continue")
# Add the hidden directory first in the search path. # Add the hidden directory first in the search path.
env_cmd_string = ("settings set target.env-vars %s=%s" % env_cmd_string = ("settings set target.env-vars %s=%s" %
(self.dylibPath, new_dir)) (self.dylibPath, new_dir))
if not self.platformIsDarwin(): if not self.platformIsDarwin():
env_cmd_string += ":" + wd env_cmd_string += ":" + wd
self.runCmd(env_cmd_string) self.runCmd(env_cmd_string)
# This time, the hidden library should be picked up. # This time, the hidden library should be picked up.
self.expect("run", substrs=["return", "12345"]) self.expect("run", substrs=["return", "12345"])
@expectedFailureAll( @expectedFailureAll(
bugnumber="llvm.org/pr25805", bugnumber="llvm.org/pr25805",
hostoslist=["windows"], hostoslist=["windows"],
compiler="gcc", compiler="gcc",
archs=["i386"], archs=["i386"],
Show All 13 Lines def test_lldb_process_load_and_unload_commands(self):
# Break at main.cpp before the call to dlopen(). # Break at main.cpp before the call to dlopen().
# Use lldb's process load command to load the dylib, instead. # Use lldb's process load command to load the dylib, instead.
lldbutil.run_break_set_by_file_and_line( 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) self.runCmd("run", RUN_SUCCEEDED)
ctx = self.platformContext
dylibName = ctx.shlib_prefix + 'loadunload_a.' + ctx.shlib_extension
localDylibPath = self.getBuildArtifact(dylibName)
if lldb.remote_platform: if lldb.remote_platform:
shlib_dir = lldb.remote_platform.GetWorkingDirectory() wd = lldb.remote_platform.GetWorkingDirectory()
else: remoteDylibPath = lldbutil.join_remote_paths(wd, dylibName)
shlib_dir = self.mydir
if self.platformIsDarwin():
dylibName = 'libloadunload_a.dylib'
else: else:
dylibName = 'libloadunload_a.so' remoteDylibPath = localDylibPath
# Make sure that a_function does not exist at this point. # Make sure that a_function does not exist at this point.
self.expect( self.expect(
"image lookup -n a_function", "image lookup -n a_function",
"a_function should not exist yet", "a_function should not exist yet",
error=True, error=True,
matching=False, matching=False,
patterns=["1 match found"]) patterns=["1 match found"])
# Use lldb 'process load' to load the dylib. # Use lldb 'process load' to load the dylib.
self.expect( self.expect(
"process load %s --install" % "process load %s --install=%s" % (localDylibPath, remoteDylibPath),
dylibName, "%s loaded correctly" % dylibName,
"%s loaded correctly" %
dylibName,
patterns=[ patterns=[
'Loading "%s".*ok' % 'Loading "%s".*ok' % localDylibPath,
dylibName,
'Image [0-9]+ loaded']) 'Image [0-9]+ loaded'])
# Search for and match the "Image ([0-9]+) loaded" pattern. # Search for and match the "Image ([0-9]+) loaded" pattern.
output = self.res.GetOutput() output = self.res.GetOutput()
pattern = re.compile("Image ([0-9]+) loaded") pattern = re.compile("Image ([0-9]+) loaded")
for l in output.split(os.linesep): for l in output.split(os.linesep):
#print("l:", l) #print("l:", l)
match = pattern.search(l) match = pattern.search(l)
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines def test_step_over_load(self):
"thread step-over", "thread step-over",
"Stepping over function that loads library") "Stepping over function that loads library")
# The stop reason should be step end. # The stop reason should be step end.
self.expect("thread list", "step over succeeded.", self.expect("thread list", "step over succeeded.",
substrs=['stopped', substrs=['stopped',
'stop reason = step over']) '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 @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
@skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
def test_static_init_during_load(self): def test_static_init_during_load(self):
"""Test that we can set breakpoints correctly in static initializers""" """Test that we can set breakpoints correctly in static initializers"""
self.build() self.build()
self.copy_shlibs_to_remote() self.copy_shlibs_to_remote()
Show All 36 Lines

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

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

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

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

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

Show All 38 Linesclass PluginPythonOSPlugin(TestBase):
def run_python_os_funcionality(self): def run_python_os_funcionality(self):
"""Test that the Python operating system plugin works correctly""" """Test that the Python operating system plugin works correctly"""
# Set debugger into synchronous mode # Set debugger into synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target by the debugger. # Create a target by the debugger.
cwd = os.getcwd()
exe = self.getBuildArtifact("a.out") 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) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set breakpoints inside and outside methods that take pointers to the # Set breakpoints inside and outside methods that take pointers to the
# containing struct. # containing struct.
lldbutil.run_break_set_by_source_regexp(self, "// Set breakpoint here") lldbutil.run_break_set_by_source_regexp(self, "// Set breakpoint here")
# Register our shared libraries for remote targets so they get # Register our shared libraries for remote targets so they get
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linesclass PluginPythonOSPlugin(TestBase):
def run_python_os_step(self): 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""" """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 # Set debugger into synchronous mode
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
# Create a target by the debugger. # Create a target by the debugger.
cwd = os.getcwd()
exe = self.getBuildArtifact("a.out") 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) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set breakpoints inside and outside methods that take pointers to the # Set breakpoints inside and outside methods that take pointers to the
# containing struct. # containing struct.
lldbutil.run_break_set_by_source_regexp(self, "// Set breakpoint here") lldbutil.run_break_set_by_source_regexp(self, "// Set breakpoint here")
# Register our shared libraries for remote targets so they get # Register our shared libraries for remote targets so they get
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines def test_stack_info_in_mini_dump(self):
self.assertTrue(frame.IsValid()) self.assertTrue(frame.IsValid())
self.assertEqual(frame.GetPC(), pc_list[i]) self.assertEqual(frame.GetPC(), pc_list[i])
@skipUnlessWindows # Minidump saving works only on windows @skipUnlessWindows # Minidump saving works only on windows
def test_deeper_stack_in_mini_dump(self): def test_deeper_stack_in_mini_dump(self):
"""Test that we can examine a more interesting stack in a mini dump.""" """Test that we can examine a more interesting stack in a mini dump."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
core = os.path.join(os.getcwd(), "core.dmp") core = self.getBuildArtifact("core.dmp")
try: try:
# Set a breakpoint and capture a mini dump. # Set a breakpoint and capture a mini dump.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
breakpoint = target.BreakpointCreateByName("bar") breakpoint = target.BreakpointCreateByName("bar")
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertEqual(process.GetState(), lldb.eStateStopped) self.assertEqual(process.GetState(), lldb.eStateStopped)
self.assertTrue(process.SaveCore(core)) self.assertTrue(process.SaveCore(core))
Show All 19 Lines def test_deeper_stack_in_mini_dump(self):
if (os.path.isfile(core)): if (os.path.isfile(core)):
os.unlink(core) os.unlink(core)
@skipUnlessWindows # Minidump saving works only on windows @skipUnlessWindows # Minidump saving works only on windows
def test_local_variables_in_mini_dump(self): def test_local_variables_in_mini_dump(self):
"""Test that we can examine local variables in a mini dump.""" """Test that we can examine local variables in a mini dump."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
core = os.path.join(os.getcwd(), "core.dmp") core = self.getBuildArtifact("core.dmp")
try: try:
# Set a breakpoint and capture a mini dump. # Set a breakpoint and capture a mini dump.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
breakpoint = target.BreakpointCreateByName("bar") breakpoint = target.BreakpointCreateByName("bar")
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertEqual(process.GetState(), lldb.eStateStopped) self.assertEqual(process.GetState(), lldb.eStateStopped)
self.assertTrue(process.SaveCore(core)) self.assertTrue(process.SaveCore(core))
Show All 16 Lines

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

Show All 21 Linesclass ProcessAttachTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
@skipIfiOSSimulator @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 @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): def test_attach_to_process_by_id(self):
"""Test attach by process id""" """Test attach by process id"""
self.build() self.build()
exe = os.path.join(os.getcwd(), exe_name) exe = self.getBuildArtifact(exe_name)
# Spawn a new process # Spawn a new process
popen = self.spawnSubprocess(exe) popen = self.spawnSubprocess(exe)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
self.runCmd("process attach -p " + str(popen.pid)) self.runCmd("process attach -p " + str(popen.pid))
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
process = target.GetProcess() process = target.GetProcess()
self.assertTrue(process, PROCESS_IS_VALID) 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 @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): def test_attach_to_process_from_different_dir_by_id(self):
"""Test attach by process id""" """Test attach by process id"""
newdir = self.getBuildArtifact("newdir")
try: try:
os.mkdir(os.path.join(os.getcwd(),'newdir')) os.mkdir(newdir)
except OSError, e: except OSError, e:
if e.errno != os.errno.EEXIST: if e.errno != os.errno.EEXIST:
raise raise
testdir = os.getcwd() testdir = self.getBuildDir()
newdir = os.path.join(testdir,'newdir')
exe = os.path.join(newdir, 'proc_attach') exe = os.path.join(newdir, 'proc_attach')
self.buildProgram('main.cpp', exe) self.buildProgram('main.cpp', exe)
self.addTearDownHook(lambda: shutil.rmtree(newdir)) self.addTearDownHook(lambda: shutil.rmtree(newdir))
# Spawn a new process # Spawn a new process
popen = self.spawnSubprocess(exe) popen = self.spawnSubprocess(exe)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
os.chdir('newdir') os.chdir(newdir)
self.addTearDownHook(lambda: os.chdir(testdir)) self.addTearDownHook(lambda: os.chdir(testdir))
self.runCmd("process attach -p " + str(popen.pid)) self.runCmd("process attach -p " + str(popen.pid))
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
process = target.GetProcess() process = target.GetProcess()
self.assertTrue(process, PROCESS_IS_VALID) 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 @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): def test_attach_to_process_by_name(self):
"""Test attach by process name""" """Test attach by process name"""
self.build() self.build()
exe = os.path.join(os.getcwd(), exe_name) exe = self.getBuildArtifact(exe_name)
# Spawn a new process # Spawn a new process
popen = self.spawnSubprocess(exe) popen = self.spawnSubprocess(exe)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
self.runCmd("process attach -n " + exe_name) self.runCmd("process attach -n " + exe_name)
target = self.dbg.GetSelectedTarget() target = self.dbg.GetSelectedTarget()
Show All 10 Lines

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

Show All 19 Linesclass AttachDeniedTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIfWindows @skipIfWindows
@skipIfiOSSimulator @skipIfiOSSimulator
@skipIfDarwinEmbedded # ptrace(ATTACH_REQUEST...) won't work on ios/tvos/etc @skipIfDarwinEmbedded # ptrace(ATTACH_REQUEST...) won't work on ios/tvos/etc
def test_attach_to_process_by_id_denied(self): def test_attach_to_process_by_id_denied(self):
"""Test attach by process id denied""" """Test attach by process id denied"""
self.build() 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. # Use a file as a synchronization point between test and inferior.
pid_file_path = lldbutil.append_to_process_working_directory( pid_file_path = lldbutil.append_to_process_working_directory(
"pid_file_%d" % (int(time.time()))) "pid_file_%d" % (int(time.time())))
self.addTearDownHook( self.addTearDownHook(
lambda: self.run_platform_command( lambda: self.run_platform_command(
"rm %s" % "rm %s" %
(pid_file_path))) (pid_file_path)))
Show All 10 Lines

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

Show First 20 Lines • Show All 126 Lines • ▼ Show 20 Lines def test_set_working_dir(self):
self.setTearDownCleanup(d) self.setTearDownCleanup(d)
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
self.runCmd("file " + exe) self.runCmd("file " + exe)
mywd = 'my_working_dir' mywd = 'my_working_dir'
out_file_name = "my_working_dir_test.out" out_file_name = "my_working_dir_test.out"
err_file_name = "my_working_dir_test.err" 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) 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) 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 # Make sure the output files do not exist before launching the process
try: try:
os.remove(out_file_path) os.remove(out_file_path)
os.remove(err_file_path) os.remove(err_file_path)
except OSError: except OSError:
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/functionalities/process_launch/my_working_dir/.keep

The contents of this file were not changed.

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

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

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

Show First 20 Lines • Show All 143 Lines • ▼ Show 20 Lines def log_enable(self, category):
# platform as logging is host side. # platform as logging is host side.
self.platform = "" self.platform = ""
if (sys.platform.startswith("freebsd") or if (sys.platform.startswith("freebsd") or
sys.platform.startswith("linux") or sys.platform.startswith("linux") or
sys.platform.startswith("netbsd")): sys.platform.startswith("netbsd")):
self.platform = "posix" self.platform = "posix"
if self.platform != "": if self.platform != "":
self.log_file = os.path.join(os.getcwd(), 'TestRegisters.log') self.log_file = self.getBuildArtifact('TestRegisters.log')
self.runCmd( self.runCmd(
"log enable " + "log enable " +
self.platform + self.platform +
" " + " " +
str(category) + str(category) +
" registers -v -f " + " registers -v -f " +
self.log_file, self.log_file,
RUN_SUCCEEDED) RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 304 Lines • Show Last 20 Lines

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

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

lldb/trunk/packages/Python/lldbsuite/test/functionalities/single-quote-in-filename-to-lldb/path with '09/.keep

The contents of this file were not changed.

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

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

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

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

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

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines def test_target_variable_command_no_fail(self):
self.build(dictionary=d) self.build(dictionary=d)
self.addTearDownCleanup(dictionary=d) self.addTearDownCleanup(dictionary=d)
self.do_target_variable_command_no_fail('globals') self.do_target_variable_command_no_fail('globals')
def do_target_command(self): def do_target_command(self):
"""Exercise 'target create', 'target list', 'target select' commands.""" """Exercise 'target create', 'target list', 'target select' commands."""
exe_a = self.getBuildArtifact("a.out") exe_a = self.getBuildArtifact("a.out")
exe_b = os.path.join(os.getcwd(), "b.out") exe_b = self.getBuildArtifact("b.out")
exe_c = os.path.join(os.getcwd(), "c.out") exe_c = self.getBuildArtifact("c.out")
self.runCmd("target list") self.runCmd("target list")
output = self.res.GetOutput() output = self.res.GetOutput()
if output.startswith("No targets"): if output.startswith("No targets"):
# We start from index 0. # We start from index 0.
base = 0 base = 0
else: else:
# Find the largest index of the existing list. # Find the largest index of the existing list.
Show All 34 Lines def do_target_command(self):
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
substrs=['b.c:%d' % self.line_b, substrs=['b.c:%d' % self.line_b,
'stop reason = breakpoint']) 'stop reason = breakpoint'])
self.runCmd("target list") self.runCmd("target list")
def do_target_variable_command(self, exe_name): def do_target_variable_command(self, exe_name):
"""Exercise 'target variable' command before and after starting the inferior.""" """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( self.expect(
"target variable my_global_char", "target variable my_global_char",
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
substrs=[ substrs=[
"my_global_char", "my_global_char",
"'X'"]) "'X'"])
self.expect( self.expect(
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines def do_target_variable_command(self, exe_name):
"target variable my_global_char", "target variable my_global_char",
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
substrs=[ substrs=[
"my_global_char", "my_global_char",
"'X'"]) "'X'"])
def do_target_variable_command_no_fail(self, exe_name): def do_target_variable_command_no_fail(self, exe_name):
"""Exercise 'target variable' command before and after starting the inferior.""" """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( self.expect(
"target variable my_global_char", "target variable my_global_char",
VARIABLES_DISPLAYED_CORRECTLY, VARIABLES_DISPLAYED_CORRECTLY,
substrs=[ substrs=[
"my_global_char", "my_global_char",
"'X'"]) "'X'"])
self.expect( self.expect(
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Show All 40 Linesclass HelloWatchLocationTestCase(TestBase):
@expectedFailureAll(triple=re.compile('^mips')) @expectedFailureAll(triple=re.compile('^mips'))
# SystemZ also currently supports only one H/W watchpoint # SystemZ also currently supports only one H/W watchpoint
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
@skipIfDarwin @skipIfDarwin
def test_hello_watchlocation(self): def test_hello_watchlocation(self):
"""Test watching a location with '-s size' option.""" """Test watching a location with '-s size' option."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1, loc_exact=False) self, None, self.line, num_expected_locations=1, loc_exact=False)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

Show All 34 Lines @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
@add_test_categories(["basic_process"]) @add_test_categories(["basic_process"])
def test_hello_watchpoint_using_watchpoint_set(self): def test_hello_watchpoint_using_watchpoint_set(self):
"""Test a simple sequence of watchpoint creation and watchpoint hit.""" """Test a simple sequence of watchpoint creation and watchpoint hit."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

Show All 31 Linesclass WatchpointSlotsTestCase(TestBase):
# This is a arm and aarch64 specific test case. No other architectures tested. # This is a arm and aarch64 specific test case. No other architectures tested.
@skipIf(archs=no_match(['arm', 'aarch64'])) @skipIf(archs=no_match(['arm', 'aarch64']))
def test_multiple_watchpoints_on_same_word(self): def test_multiple_watchpoints_on_same_word(self):
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Detect line number after which we are going to increment arrayName. # Detect line number after which we are going to increment arrayName.
loc_line = line_number('main.c', '// About to write byteArray') loc_line = line_number('main.c', '// About to write byteArray')
# Set a breakpoint on the line detected above. # Set a breakpoint on the line detected above.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", loc_line, num_expected_locations=1, loc_exact=True) self, "main.c", loc_line, num_expected_locations=1, loc_exact=True)
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

Show All 36 Linesclass WatchedVariableHitWhenInScopeTestCase(TestBase):
# Test hangs due to a kernel bug, see fdfeff0f in the linux kernel for details # 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"]) @skipIfTargetAndroid(api_levels=list(range(25+1)), archs=["aarch64", "arm"])
@unittest2.expectedFailure("rdar://problem/18685649") @unittest2.expectedFailure("rdar://problem/18685649")
def test_watched_var_should_only_hit_when_in_scope(self): def test_watched_var_should_only_hit_when_in_scope(self):
"""Test that a variable watchpoint should only hit when in scope.""" """Test that a variable watchpoint should only hit when in scope."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped in main. # Add a breakpoint to set a watchpoint when stopped in main.
lldbutil.run_break_set_by_symbol( lldbutil.run_break_set_by_symbol(
self, "main", num_expected_locations=-1) self, "main", num_expected_locations=-1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 35 Lines

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

Show All 40 Lines @expectedFailureAll(
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_rw_watchpoint(self): def test_rw_watchpoint(self):
"""Test read_write watchpoint and expect to stop two times.""" """Test read_write watchpoint and expect to stop two times."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines @expectedFailureAll(
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_rw_watchpoint_delete(self): def test_rw_watchpoint_delete(self):
"""Test delete watchpoint and expect not to stop for watchpoint.""" """Test delete watchpoint and expect not to stop for watchpoint."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 40 Lines @expectedFailureAll(
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_rw_watchpoint_set_ignore_count(self): def test_rw_watchpoint_set_ignore_count(self):
"""Test watchpoint ignore count and expect to not to stop at all.""" """Test watchpoint ignore count and expect to not to stop at all."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines @expectedFailureAll(
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_rw_disable_after_first_stop(self): def test_rw_disable_after_first_stop(self):
"""Test read_write watchpoint but disable it after the first stop.""" """Test read_write watchpoint but disable it after the first stop."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines @expectedFailureAll(
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
# Read-write watchpoints not supported on SystemZ # Read-write watchpoints not supported on SystemZ
@expectedFailureAll(archs=['s390x']) @expectedFailureAll(archs=['s390x'])
def test_rw_disable_then_enable(self): def test_rw_disable_then_enable(self):
"""Test read_write watchpoint, disable initially, then enable it.""" """Test read_write watchpoint, disable initially, then enable it."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line2, num_expected_locations=1) self, None, self.line2, num_expected_locations=1)
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

Show All 39 Linesclass WatchpointLLDBCommandTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
def test_watchpoint_command(self): def test_watchpoint_command(self):
"""Test 'watchpoint command'.""" """Test 'watchpoint command'."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Linesclass WatchpointLLDBCommandTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
def test_watchpoint_command_can_disable_a_watchpoint(self): def test_watchpoint_command_can_disable_a_watchpoint(self):
"""Test that 'watchpoint command' action can disable a watchpoint after it is triggered.""" """Test that 'watchpoint command' action can disable a watchpoint after it is triggered."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

Show All 40 Lines @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
archs=["aarch64"], archs=["aarch64"],
bugnumber="llvm.org/pr27710") bugnumber="llvm.org/pr27710")
def test_watchpoint_command(self): def test_watchpoint_command(self):
"""Test 'watchpoint command'.""" """Test 'watchpoint command'."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
archs=["aarch64"], archs=["aarch64"],
bugnumber="llvm.org/pr27710") bugnumber="llvm.org/pr27710")
def test_continue_in_watchpoint_command(self): def test_continue_in_watchpoint_command(self):
"""Test continue in a watchpoint command.""" """Test continue in a watchpoint command."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 11 Lines def test_continue_in_watchpoint_command(self):
substrs=[ substrs=[
'Watchpoint created', 'Watchpoint created',
'size = 4', 'size = 4',
'type = w', 'type = w',
'%s:%d' % '%s:%d' %
(self.source, (self.source,
self.decl)]) 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("command script import '%s'" % (cmd_script_file))
self.runCmd( self.runCmd(
'watchpoint command add -F watchpoint_command.watchpoint_command') 'watchpoint command add -F watchpoint_command.watchpoint_command')
# List the watchpoint command we just added. # List the watchpoint command we just added.
self.expect("watchpoint command list 1", self.expect("watchpoint command list 1",
substrs=['watchpoint_command.watchpoint_command']) substrs=['watchpoint_command.watchpoint_command'])
Show All 13 Lines

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

Show All 39 Linesclass WatchpointConditionCmdTestCase(TestBase):
@expectedFailureAll( @expectedFailureAll(
oslist=["windows"], oslist=["windows"],
bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows") bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
def test_watchpoint_cond(self): def test_watchpoint_cond(self):
"""Test watchpoint condition.""" """Test watchpoint condition."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add a breakpoint to set a watchpoint when stopped on the breakpoint. # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, None, self.line, num_expected_locations=1) self, None, self.line, num_expected_locations=1)
# Run the program. # Run the program.
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
Show All 40 Lines

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

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

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

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Linesclass WatchpointSizeTestCase(TestBase):
def test_four_byte_watchpoints_with_dword_selection(self): def test_four_byte_watchpoints_with_dword_selection(self):
"""Test to selectively watch two double words in an 8-byte dword array.""" """Test to selectively watch two double words in an 8-byte dword array."""
self.run_watchpoint_size_test('dwordArray', 2, '4') self.run_watchpoint_size_test('dwordArray', 2, '4')
def run_watchpoint_size_test(self, arrayName, array_size, watchsize): def run_watchpoint_size_test(self, arrayName, array_size, watchsize):
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Detect line number after which we are going to increment arrayName. # Detect line number after which we are going to increment arrayName.
loc_line = line_number('main.c', '// About to write ' + arrayName) loc_line = line_number('main.c', '// About to write ' + arrayName)
# Set a breakpoint on the line detected above. # Set a breakpoint on the line detected above.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, "main.c", loc_line, num_expected_locations=1, loc_exact=True) self, "main.c", loc_line, num_expected_locations=1, loc_exact=True)
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

LEVEL := ../../../make 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 C_SOURCES := main.c
main.o : CFLAGS_EXTRAS += -g -O0
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules
.PHONY: .PHONY:
a.out: lib_One lib_Two a.out: lib_One lib_Two
lib_%: lib_%:
$(MAKE) -f $*.mk $(MAKE) VPATH=$(SRCDIR)/$* -I $(SRCDIR) -f $(SRCDIR)/$*.mk
clean:: clean::
$(MAKE) -f One.mk clean $(MAKE) -f $(SRCDIR)/One.mk clean
$(MAKE) -f Two.mk clean $(MAKE) -f $(SRCDIR)/Two.mk clean

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

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

lldb/trunk/packages/Python/lldbsuite/test/lang/c/conflicting-symbol/TestConflictingSymbol.py

Show All 10 Lines
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
class TestConflictingSymbols(TestBase): class TestConflictingSymbols(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def setUp(self):
TestBase.setUp(self)
lldbutil.mkdir_p(self.getBuildArtifact("One"))
lldbutil.mkdir_p(self.getBuildArtifact("Two"))
def test_conflicting_symbols(self): def test_conflicting_symbols(self):
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Register our shared libraries for remote targets so they get # Register our shared libraries for remote targets so they get
# automatically uploaded # automatically uploaded
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines def setUp(self):
self.d_virtual = { self.d_virtual = {
'CXX_SOURCES': self.source, 'CXX_SOURCES': self.source,
'EXE': self.exe_name, 'EXE': self.exe_name,
'CFLAGS_EXTRAS': '-DDO_VIRTUAL_INHERITANCE'} 'CFLAGS_EXTRAS': '-DDO_VIRTUAL_INHERITANCE'}
self.d_regular = {'CXX_SOURCES': self.source, 'EXE': self.exe_name} self.d_regular = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
def do_sbvalue_cast(self, exe_name): def do_sbvalue_cast(self, exe_name):
"""Test SBValue::Cast(SBType) API for C++ types.""" """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. # Create a target from the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Set up our breakpoints: # Set up our breakpoints:
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

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

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

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

import lldb import lldb
import os import os
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
class TestWithGmodulesDebugInfo(TestBase): class TestWithGmodulesDebugInfo(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@skipIf(bugnumber="llvm.org/pr36146", oslist=["linux"], archs=["i386"]) @skipIf(bugnumber="llvm.org/pr36146", oslist=["linux"], archs=["i386"])
@add_test_categories(["gmodules"]) @add_test_categories(["gmodules"])
def test_specialized_typedef_from_pch(self): def test_specialized_typedef_from_pch(self):
self.build() 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) src_file_spec = lldb.SBFileSpec(src_file)
self.assertTrue(src_file_spec.IsValid(), "breakpoint file") self.assertTrue(src_file_spec.IsValid(), "breakpoint file")
# Get the path of the executable # Get the path of the executable
exe_path = self.getBuildArtifact("a.out") exe_path = self.getBuildArtifact("a.out")
# Load the executable # Load the executable
target = self.dbg.CreateTarget(exe_path) target = self.dbg.CreateTarget(exe_path)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

Show All 13 Lines
limit: main.o length_limit.o a.o limit: main.o length_limit.o a.o
$(CXX) main.o length_limit.o a.o -o limit $(LDFLAGS) $(CXX) main.o length_limit.o a.o -o limit $(LDFLAGS)
nolimit: main.o length_nolimit.o a.o nolimit: main.o length_nolimit.o a.o
$(CXX) main.o length_nolimit.o a.o -o nolimit $(LDFLAGS) $(CXX) main.o length_nolimit.o a.o -o nolimit $(LDFLAGS)
main.o: main.cpp 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 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 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 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 clean: OBJECTS += limit nolimit length_limit.o length_nolimit.o length_limit.dwo length_nolimit.dwo
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

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

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linesclass TestCppIncompleteTypes(TestBase):
def get_test_frame(self, exe): def get_test_frame(self, exe):
# Get main source file # Get main source file
src_file = "main.cpp" src_file = "main.cpp"
src_file_spec = lldb.SBFileSpec(src_file) src_file_spec = lldb.SBFileSpec(src_file)
self.assertTrue(src_file_spec.IsValid(), "Main source file") self.assertTrue(src_file_spec.IsValid(), "Main source file")
# Get the path of the executable # Get the path of the executable
cwd = os.getcwd() exe_path = self.getBuildArtifact(exe)
exe_path = os.path.join(cwd, exe)
# Load the executable # Load the executable
target = self.dbg.CreateTarget(exe_path) target = self.dbg.CreateTarget(exe_path)
self.assertTrue(target.IsValid(), VALID_TARGET) self.assertTrue(target.IsValid(), VALID_TARGET)
# Break on main function # Break on main function
main_breakpoint = target.BreakpointCreateBySourceRegex( main_breakpoint = target.BreakpointCreateBySourceRegex(
"break here", src_file_spec) "break here", src_file_spec)
Show All 20 Lines

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

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

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

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

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

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

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

Show All 17 Linesclass TestCppScopes(TestBase):
@expectedFailureAll(oslist=["windows"]) @expectedFailureAll(oslist=["windows"])
def test_c(self): def test_c(self):
self.do_test(True) self.do_test(True)
def do_test(self, test_c): def do_test(self, test_c):
self.build() self.build()
# Get main source file # Get main source file
src_file = "main.cpp" src_file = os.path.join(self.getSourceDir(), "main.cpp")
src_file_spec = lldb.SBFileSpec(src_file) src_file_spec = lldb.SBFileSpec(src_file)
self.assertTrue(src_file_spec.IsValid(), "Main source file") self.assertTrue(src_file_spec.IsValid(), "Main source file")
# Get the path of the executable # Get the path of the executable
cwd = os.getcwd()
exe_path = self.getBuildArtifact("a.out") exe_path = self.getBuildArtifact("a.out")
# Load the executable # Load the executable
target = self.dbg.CreateTarget(exe_path) target = self.dbg.CreateTarget(exe_path)
self.assertTrue(target.IsValid(), VALID_TARGET) self.assertTrue(target.IsValid(), VALID_TARGET)
# Break on main function # Break on main function
main_breakpoint = target.BreakpointCreateBySourceRegex( main_breakpoint = target.BreakpointCreateBySourceRegex(
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

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

lldb/trunk/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

lldb/trunk/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

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

Show First 20 Lines • Show All 290 Lines • ▼ Show 20 Lines def test_expression_lookups_objc(self):
sym_exact=True) sym_exact=True)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
global file_index global file_index
# Log any DWARF lookups # Log any DWARF lookups
++file_index ++file_index
logfile = os.path.join( logfile = os.path.join(
os.getcwd(), self.getBuildDir(),
"dwarf-lookups-" + "dwarf-lookups-" +
self.getArchitecture() + self.getArchitecture() +
"-" + "-" +
str(file_index) + str(file_index) +
".txt") ".txt")
self.runCmd("log enable -f %s dwarf lookups" % (logfile)) self.runCmd("log enable -f %s dwarf lookups" % (logfile))
self.runCmd("expr self") self.runCmd("expr self")
self.runCmd("log disable dwarf lookups") self.runCmd("log disable dwarf lookups")
Show All 20 Lines

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

Show All 28 Linesclass ObjectDescriptionAPITestCase(TestBase):
# rdar://problem/10857337 # rdar://problem/10857337
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_find_global_variables_then_object_description(self): def test_find_global_variables_then_object_description(self):
"""Exercise SBTarget.FindGlobalVariables() API.""" """Exercise SBTarget.FindGlobalVariables() API."""
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(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. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
Show All 33 Lines

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

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

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

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

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

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

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

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

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

Show All 28 Linesclass ObjCDynamicSBTypeTestCase(TestBase):
@skipIf(archs="i[3-6]86") @skipIf(archs="i[3-6]86")
def test_dyn(self): def test_dyn(self):
"""Test that we are able to properly report a usable dynamic type.""" """Test that we are able to properly report a usable dynamic type."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
self.main_source, self.main_source,
self.line, self.line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

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

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

Show All 32 Lines def test_print_obj(self):
Set a breakpoint on the line in my_pthread_routine. Then switch threads 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 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 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. have to switch to running all threads, and that should then succeed.
""" """
d = {'EXE': 'b.out'} d = {'EXE': 'b.out'}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d) self.setTearDownCleanup(dictionary=d)
exe = os.path.join(os.getcwd(), 'b.out') exe = self.getBuildArtifact('b.out')
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
self.runCmd("breakpoint list") self.runCmd("breakpoint list")
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

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

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

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

Show All 27 Lines def setUp(self):
self.line = line_number(self.main_source, '// Set breakpoint here.') self.line = line_number(self.main_source, '// Set breakpoint here.')
def test_cfrange_diff_cfgregoriandate(self): def test_cfrange_diff_cfgregoriandate(self):
"""Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued.""" """Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
self.main_source, self.main_source,
self.line, self.line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
Show All 29 Lines

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

Show All 27 Lines def setUp(self):
self.line = line_number(self.main_source, '// Set breakpoint here.') self.line = line_number(self.main_source, '// Set breakpoint here.')
def test_charstar_dyntype(self): def test_charstar_dyntype(self):
"""Test that we do not attempt to make a dynamic type for a 'const char*'""" """Test that we do not attempt to make a dynamic type for a 'const char*'"""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
self.main_source, self.main_source,
self.line, self.line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
Show All 38 Lines

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

Show All 35 Lines def test_nswindow_count(self):
"""Test that we are able to find out how many children NSWindow has.""" """Test that we are able to find out how many children NSWindow has."""
self.skipTest("Skipping this test due to timeout flakiness") self.skipTest("Skipping this test due to timeout flakiness")
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, self,
self.main_source, self.main_source,
self.line, self.line,
num_expected_locations=1, num_expected_locations=1,
loc_exact=True) loc_exact=True)
Show All 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/lldbinline.py

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines def getRerunArgs(self):
# The test was skipped altogether. # The test was skipped altogether.
return "" return ""
elif self.using_dsym: elif self.using_dsym:
return "-N dwarf %s" % (self.mydir) return "-N dwarf %s" % (self.mydir)
else: else:
return "-N dsym %s" % (self.mydir) return "-N dsym %s" % (self.mydir)
def BuildMakefile(self): def BuildMakefile(self):
if os.path.exists("Makefile"): self.makeBuildDir()
makefilePath = self.getBuildArtifact("Makefile")
if os.path.exists(makefilePath):
return return
categories = {} categories = {}
for f in os.listdir(os.getcwd()): for f in os.listdir(self.getSourceDir()):
t = source_type(f) t = source_type(f)
if t: if t:
if t in list(categories.keys()): if t in list(categories.keys()):
categories[t].append(f) categories[t].append(f)
else: else:
categories[t] = [f] categories[t] = [f]
makefile = open("Makefile", 'w+') makefile = open(makefilePath, 'w+')
level = os.sep.join( level = os.sep.join(
[".."] * len(self.mydir.split(os.sep))) + os.sep + "make" [".."] * len(self.mydir.split(os.sep))) + os.sep + "make"
makefile.write("LEVEL = " + level + "\n") makefile.write("LEVEL = " + level + "\n")
for t in list(categories.keys()): for t in list(categories.keys()):
line = t + " := " + " ".join(categories[t]) line = t + " := " + " ".join(categories[t])
Show All 10 Lines def BuildMakefile(self):
makefile.write("include $(LEVEL)/Makefile.rules\n") makefile.write("include $(LEVEL)/Makefile.rules\n")
makefile.write("\ncleanup:\n\trm -f Makefile *.d\n\n") makefile.write("\ncleanup:\n\trm -f Makefile *.d\n\n")
makefile.flush() makefile.flush()
makefile.close() makefile.close()
@add_test_categories(["dsym"]) @add_test_categories(["dsym"])
def __test_with_dsym(self): def __test_with_dsym(self):
self.using_dsym = True self.using_dsym = True
self.debug_info = "dsym"
self.BuildMakefile() self.BuildMakefile()
self.buildDsym() self.build()
self.do_test() self.do_test()
@add_test_categories(["dwarf"]) @add_test_categories(["dwarf"])
def __test_with_dwarf(self): def __test_with_dwarf(self):
self.using_dsym = False self.using_dsym = False
self.debug_info = "dwarf"
self.BuildMakefile() self.BuildMakefile()
self.buildDwarf() self.build()
self.do_test() self.do_test()
@add_test_categories(["dwo"]) @add_test_categories(["dwo"])
def __test_with_dwo(self): def __test_with_dwo(self):
self.using_dsym = False self.using_dsym = False
self.debug_info = "dwo"
self.BuildMakefile() self.BuildMakefile()
self.buildDwo() self.build()
self.do_test() self.do_test()
@add_test_categories(["gmodules"]) @add_test_categories(["gmodules"])
def __test_with_gmodules(self): def __test_with_gmodules(self):
self.using_dsym = False self.using_dsym = False
self.debug_info = "gmodules"
self.BuildMakefile() self.BuildMakefile()
self.buildGModules() self.build()
self.do_test() self.do_test()
def execute_user_command(self, __command): def execute_user_command(self, __command):
exec(__command, globals(), locals()) exec(__command, globals(), locals())
def do_test(self): def do_test(self):
exe = self.getBuildArtifact("a.out") 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) target = self.dbg.CreateTarget(exe)
parser = CommandParser() parser = CommandParser()
parser.parse_source_files(source_files) parser.parse_source_files(source_files)
parser.set_breakpoints(target) 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): while lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint):
thread = lldbutil.get_stopped_thread( thread = lldbutil.get_stopped_thread(
process, lldb.eStopReasonBreakpoint) process, lldb.eStopReasonBreakpoint)
breakpoint_id = thread.GetStopReasonDataAtIndex(0) breakpoint_id = thread.GetStopReasonDataAtIndex(0)
parser.handle_breakpoint(self, breakpoint_id) parser.handle_breakpoint(self, breakpoint_id)
process.Continue() process.Continue()
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/lldbtest.py

Show First 20 Lines • Show All 548 Lines • ▼ Show 20 Lines def setUpClass(cls):
# Change current working directory if ${LLDB_TEST} is defined. # Change current working directory if ${LLDB_TEST} is defined.
# See also dotest.py which sets up ${LLDB_TEST}. # See also dotest.py which sets up ${LLDB_TEST}.
if ("LLDB_TEST" in os.environ): if ("LLDB_TEST" in os.environ):
full_dir = os.path.join(os.environ["LLDB_TEST"], cls.mydir) full_dir = os.path.join(os.environ["LLDB_TEST"], cls.mydir)
if traceAlways: if traceAlways:
print("Change dir to:", full_dir, file=sys.stderr) print("Change dir to:", full_dir, file=sys.stderr)
os.chdir(os.path.join(os.environ["LLDB_TEST"], cls.mydir)) 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: if debug_confirm_directory_exclusivity:
import lock import lock
cls.dir_lock = lock.Lock(os.path.join(full_dir, ".dirlock")) cls.dir_lock = lock.Lock(os.path.join(full_dir, ".dirlock"))
try: try:
cls.dir_lock.try_acquire() cls.dir_lock.try_acquire()
# write the class that owns the lock into the lock file # write the class that owns the lock into the lock file
cls.dir_lock.handle.write(cls.__name__) cls.dir_lock.handle.write(cls.__name__)
except IOError as ioerror: except IOError as ioerror:
▲ Show 20 Lines • Show All 148 Lines • ▼ Show 20 Lines def setPlatformWorkingDir(self):
# TODO: Make it working on Windows when we need it for remote debugging support # 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 # TODO: Replace the heuristic to remove the files with a logic what collects the
# list of files we have to remove during test runs. # list of files we have to remove during test runs.
shell_cmd = lldb.SBPlatformShellCommand( shell_cmd = lldb.SBPlatformShellCommand(
"rm %s/*" % remote_test_dir) "rm %s/*" % remote_test_dir)
lldb.remote_platform.Run(shell_cmd) lldb.remote_platform.Run(shell_cmd)
self.addTearDownHook(clean_working_directory) 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"): def getBuildArtifact(self, name="a.out"):
"""Return absolute path to an artifact in the test's build directory.""" """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): def setUp(self):
"""Fixture for unittest test case setup. """Fixture for unittest test case setup.
It works with the test driver to conditionally skip tests and does other It works with the test driver to conditionally skip tests and does other
initializations.""" initializations."""
#import traceback #import traceback
# traceback.print_stack() # traceback.print_stack()
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines def setUp(self):
self.dsym = os.path.join(self.framework_dir, 'LLDB.framework', 'LLDB') self.dsym = os.path.join(self.framework_dir, 'LLDB.framework', 'LLDB')
# If the framework binary doesn't exist, assume we didn't actually # If the framework binary doesn't exist, assume we didn't actually
# build a framework, and fallback to standard *nix behavior by # build a framework, and fallback to standard *nix behavior by
# setting framework_dir and dsym to None. # setting framework_dir and dsym to None.
if not os.path.exists(self.dsym): if not os.path.exists(self.dsym):
self.framework_dir = None self.framework_dir = None
self.dsym = None self.dsym = None
self.darwinWithFramework = False self.darwinWithFramework = False
self.makeBuildDir()
def setAsync(self, value): def setAsync(self, value):
""" Sets async mode to True/False and ensures it is reset after the testcase completes.""" """ Sets async mode to True/False and ensures it is reset after the testcase completes."""
old_async = self.dbg.GetAsync() old_async = self.dbg.GetAsync()
self.dbg.SetAsync(value) self.dbg.SetAsync(value)
self.addTearDownHook(lambda: self.dbg.SetAsync(old_async)) self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
def cleanupSubprocesses(self): def cleanupSubprocesses(self):
▲ Show 20 Lines • Show All 536 Lines • ▼ Show 20 Lines def getstdFlag(self):
else: else:
stdflag = "-std=c++11" stdflag = "-std=c++11"
return stdflag return stdflag
def buildDriver(self, sources, exe_name): def buildDriver(self, sources, exe_name):
""" Platform-specific way to build a program that links with LLDB (via the liblldb.so """ Platform-specific way to build a program that links with LLDB (via the liblldb.so
or LLDB.framework). or LLDB.framework).
""" """
stdflag = self.getstdFlag() stdflag = self.getstdFlag()
stdlibflag = self.getstdlibFlag() stdlibflag = self.getstdlibFlag()
lib_dir = os.environ["LLDB_LIB_DIR"] lib_dir = os.environ["LLDB_LIB_DIR"]
if self.hasDarwinFramework(): if self.hasDarwinFramework():
d = {'CXX_SOURCES': sources, d = {'CXX_SOURCES': sources,
'EXE': exe_name, 'EXE': exe_name,
'CFLAGS_EXTRAS': "%s %s" % (stdflag, stdlibflag), 'CFLAGS_EXTRAS': "%s %s" % (stdflag, stdlibflag),
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines def buildProgram(self, sources, exe_name):
'EXE': exe_name} 'EXE': exe_name}
self.buildDefault(dictionary=d) self.buildDefault(dictionary=d)
def buildDefault( def buildDefault(
self, self,
architecture=None, architecture=None,
compiler=None, compiler=None,
dictionary=None, dictionary=None,
clean=True): clean=True,
testdir=None):
"""Platform specific way to build the default binaries.""" """Platform specific way to build the default binaries."""
if not testdir:
testdir = self.mydir
if self.debug_info: if self.debug_info:
raise Exception("buildDefault tests must set NO_DEBUG_INFO_TESTCASE") raise Exception("buildDefault tests must set NO_DEBUG_INFO_TESTCASE")
module = builder_module() module = builder_module()
self.makeBuildDir()
dictionary = lldbplatformutil.finalize_build_dictionary(dictionary) dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
if not module.buildDefault( if not module.buildDefault(self, architecture, compiler,
self, dictionary, clean, testdir):
architecture,
compiler,
dictionary,
clean):
raise Exception("Don't know how to build default binary") raise Exception("Don't know how to build default binary")
def buildDsym( def buildDsym(
self, self,
architecture=None, architecture=None,
compiler=None, compiler=None,
dictionary=None, dictionary=None,
clean=True): clean=True,
testdir=None):
"""Platform specific way to build binaries with dsym info.""" """Platform specific way to build binaries with dsym info."""
if not testdir:
testdir = self.mydir
module = builder_module() module = builder_module()
dictionary = lldbplatformutil.finalize_build_dictionary(dictionary) dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
if not module.buildDsym( if not module.buildDsym(self, architecture, compiler,
self, dictionary, clean, testdir):
architecture,
compiler,
dictionary,
clean):
raise Exception("Don't know how to build binary with dsym") raise Exception("Don't know how to build binary with dsym")
def buildDwarf( def buildDwarf(
self, self,
architecture=None, architecture=None,
compiler=None, compiler=None,
dictionary=None, dictionary=None,
clean=True): clean=True,
testdir=None):
"""Platform specific way to build binaries with dwarf maps.""" """Platform specific way to build binaries with dwarf maps."""
if not testdir:
testdir = self.mydir
module = builder_module() module = builder_module()
dictionary = lldbplatformutil.finalize_build_dictionary(dictionary) dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
if not module.buildDwarf( if not module.buildDwarf(self, architecture, compiler,
self, dictionary, clean, testdir):
architecture,
compiler,
dictionary,
clean):
raise Exception("Don't know how to build binary with dwarf") raise Exception("Don't know how to build binary with dwarf")
def buildDwo( def buildDwo(
self, self,
architecture=None, architecture=None,
compiler=None, compiler=None,
dictionary=None, dictionary=None,
clean=True): clean=True,
testdir=None):
"""Platform specific way to build binaries with dwarf maps.""" """Platform specific way to build binaries with dwarf maps."""
if not testdir:
testdir = self.mydir
module = builder_module() module = builder_module()
dictionary = lldbplatformutil.finalize_build_dictionary(dictionary) dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
if not module.buildDwo( if not module.buildDwo(self, architecture, compiler,
self, dictionary, clean, testdir):
architecture,
compiler,
dictionary,
clean):
raise Exception("Don't know how to build binary with dwo") raise Exception("Don't know how to build binary with dwo")
def buildGModules( def buildGModules(
self, self,
architecture=None, architecture=None,
compiler=None, compiler=None,
dictionary=None, dictionary=None,
clean=True): clean=True,
testdir=None):
"""Platform specific way to build binaries with gmodules info.""" """Platform specific way to build binaries with gmodules info."""
if not testdir:
testdir = self.mydir
module = builder_module() module = builder_module()
dictionary = lldbplatformutil.finalize_build_dictionary(dictionary) dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
if not module.buildGModules( if not module.buildGModules(self, architecture, compiler,
self, dictionary, clean, testdir):
architecture,
compiler,
dictionary,
clean):
raise Exception("Don't know how to build binary with gmodules") raise Exception("Don't know how to build binary with gmodules")
def buildGo(self): def buildGo(self):
"""Build the default go binary. """Build the default go binary.
""" """
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
system([[which('go'), 'build -gcflags "-N -l" -o %s main.go' % exe]]) system([[which('go'), 'build -gcflags "-N -l" -o %s main.go' % exe]])
▲ Show 20 Lines • Show All 278 Lines • ▼ Show 20 Linesclass TestBase(Base):
# Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable. # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
maxLaunchCount = 3 maxLaunchCount = 3
# Time to wait before the next launching attempt in second(s). # Time to wait before the next launching attempt in second(s).
# Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable. # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
timeWaitNextLaunch = 1.0 timeWaitNextLaunch = 1.0
def generateSource(self, source): def generateSource(self, source):
self.makeBuildDir()
template = source + '.template' template = source + '.template'
temp = os.path.join(os.getcwd(), template) temp = os.path.join(self.getSourceDir(), template)
with open(temp, 'r') as f: with open(temp, 'r') as f:
content = f.read() content = f.read()
public_api_dir = os.path.join( public_api_dir = os.path.join(
os.environ["LLDB_SRC"], "include", "lldb", "API") os.environ["LLDB_SRC"], "include", "lldb", "API")
# Look under the include/lldb/API directory and add #include statements # Look under the include/lldb/API directory and add #include statements
# for all the SB API headers. # for all the SB API headers.
public_headers = os.listdir(public_api_dir) public_headers = os.listdir(public_api_dir)
# For different platforms, the include statement can vary. # For different platforms, the include statement can vary.
if self.hasDarwinFramework(): if self.hasDarwinFramework():
include_stmt = "'#include <%s>' % os.path.join('LLDB', header)" include_stmt = "'#include <%s>' % os.path.join('LLDB', header)"
else: else:
include_stmt = "'#include <%s>' % os.path.join('" + public_api_dir + "', header)" include_stmt = "'#include <%s>' % os.path.join('" + public_api_dir + "', header)"
list = [eval(include_stmt) for header in public_headers if ( list = [eval(include_stmt) for header in public_headers if (
header.startswith("SB") and header.endswith(".h"))] header.startswith("SB") and header.endswith(".h"))]
includes = '\n'.join(list) includes = '\n'.join(list)
new_content = content.replace('%include_SB_APIs%', includes) 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: with open(src, 'w') as f:
f.write(new_content) f.write(new_content)
self.addTearDownHook(lambda: os.remove(src)) self.addTearDownHook(lambda: os.remove(src))
def setUp(self): def setUp(self):
#import traceback #import traceback
# traceback.print_stack() # traceback.print_stack()
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines def registerSharedLibrariesWithTarget(self, target, shlibs):
# "libFoo.dylib" or "libFoo.so", or "Foo.so" for "Foo.so" or "libFoo.so", or just a # "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 # basename like "libFoo.so". So figure out which one it is and resolve the local copy
# of the shared library accordingly # of the shared library accordingly
if os.path.isfile(name): if os.path.isfile(name):
local_shlib_path = name # name is the full path to the local shared library local_shlib_path = name # name is the full path to the local shared library
else: else:
# Check relative names # Check relative names
local_shlib_path = os.path.join( 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): if not os.path.exists(local_shlib_path):
local_shlib_path = os.path.join( local_shlib_path = os.path.join(
os.getcwd(), name + shlib_extension) self.getBuildDir(), name + shlib_extension)
if not os.path.exists(local_shlib_path): 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 # Make sure we found the local shared library in the above code
self.assertTrue(os.path.exists(local_shlib_path)) self.assertTrue(os.path.exists(local_shlib_path))
# Add the shared library to our target # Add the shared library to our target
shlib_module = target.AddModule(local_shlib_path, None, None, None) shlib_module = target.AddModule(local_shlib_path, None, None, None)
if lldb.remote_platform: if lldb.remote_platform:
# We must set the remote install location if we want the shared library # We must set the remote install location if we want the shared library
Show All 30 Linesclass TestBase(Base):
def get_process_working_directory(self): def get_process_working_directory(self):
'''Get the working directory that should be used when launching processes for local or remote processes.''' '''Get the working directory that should be used when launching processes for local or remote processes.'''
if lldb.remote_platform: if lldb.remote_platform:
# Remote tests set the platform working directory up in # Remote tests set the platform working directory up in
# TestBase.setUp() # TestBase.setUp()
return lldb.remote_platform.GetWorkingDirectory() return lldb.remote_platform.GetWorkingDirectory()
else: else:
# local tests change directory into each test subdirectory # local tests change directory into each test subdirectory
return os.getcwd() return self.getBuildDir()
def tearDown(self): def tearDown(self):
#import traceback #import traceback
# traceback.print_stack() # traceback.print_stack()
# Ensure all the references to SB objects have gone away so that we can # 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 # be sure that all test-specific resources have been freed before we
# attempt to delete the targets. # attempt to delete the targets.
▲ Show 20 Lines • Show All 268 Lines • ▼ Show 20 Linesclass TestBase(Base):
def build( def build(
self, self,
architecture=None, architecture=None,
compiler=None, compiler=None,
dictionary=None, dictionary=None,
clean=True): clean=True):
"""Platform specific way to build the default binaries.""" """Platform specific way to build the default binaries."""
module = builder_module() module = builder_module()
self.makeBuildDir()
dictionary = lldbplatformutil.finalize_build_dictionary(dictionary) dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
if self.debug_info is None: 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": 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": 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": 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": elif self.debug_info == "gmodules":
return self.buildGModules( return self.buildGModules(architecture, compiler, dictionary,
architecture, compiler, dictionary, clean) clean, self.mydir)
else: else:
self.fail("Can't build for debug info: %s" % self.debug_info) self.fail("Can't build for debug info: %s" % self.debug_info)
def run_platform_command(self, cmd): def run_platform_command(self, cmd):
platform = self.dbg.GetSelectedPlatform() platform = self.dbg.GetSelectedPlatform()
shell_command = lldb.SBPlatformShellCommand(cmd) shell_command = lldb.SBPlatformShellCommand(cmd)
err = platform.Run(shell_command) err = platform.Run(shell_command)
return (err, shell_command.GetStatus(), shell_command.GetOutput()) return (err, shell_command.GetStatus(), shell_command.GetOutput())
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

lldb/trunk/packages/Python/lldbsuite/test/lldbutil.py

""" """
This LLDB module contains miscellaneous utilities. This LLDB module contains miscellaneous utilities.
Some of the test suite takes advantage of the utility functions defined here. Some of the test suite takes advantage of the utility functions defined here.
They can also be useful for general purpose lldb scripting. They can also be useful for general purpose lldb scripting.
""" """
from __future__ import print_function from __future__ import print_function
from __future__ import absolute_import from __future__ import absolute_import
# System modules # System modules
import collections import collections
import errno
import os import os
import re import re
import sys import sys
import time import time
# Third-party modules # Third-party modules
from six import StringIO as SixStringIO from six import StringIO as SixStringIO
import six import six
Show All 19 Lines if fpath:
return program return program
else: else:
for path in os.environ["PATH"].split(os.pathsep): for path in os.environ["PATH"].split(os.pathsep):
exe_file = os.path.join(path, program) exe_file = os.path.join(path, program)
if is_exe(exe_file): if is_exe(exe_file):
return exe_file return exe_file
return None return None
def mkdir_p(path):
try:
os.makedirs(path)
except OSError as e:
if e.errno != errno.EEXIST:
raise
if not os.path.isdir(path):
raise OSError(errno.ENOTDIR, "%s is not a directory"%path)
# =================================================== # ===================================================
# Disassembly for an SBFunction or an SBSymbol object # Disassembly for an SBFunction or an SBSymbol object
# =================================================== # ===================================================
def disassemble(target, function_or_symbol): def disassemble(target, function_or_symbol):
"""Disassemble the function or symbol given a target. """Disassemble the function or symbol given a target.
▲ Show 20 Lines • Show All 1,244 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

SRCDIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))/
CC ?= clang CC ?= clang
ifeq "$(ARCH)" "" ifeq "$(ARCH)" ""
ARCH = x86_64 ARCH = x86_64
endif endif
CFLAGS ?= -g -O0 -arch $(ARCH) CFLAGS ?= -g -O0 -arch $(ARCH)
all: clean 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 mkdir com.apple.sbd.xpc
mv com.apple.sbd com.apple.sbd.xpc/ mv com.apple.sbd com.apple.sbd.xpc/
mkdir -p com.apple.sbd.xpc.dSYM/Contents/Resources/DWARF 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/ 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 rm -rf com.apple.sbd.dSYM
mkdir hide.app mkdir hide.app
tar cf - com.apple.sbd.xpc com.apple.sbd.xpc.dSYM | ( cd hide.app;tar xBpf -) 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: 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 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

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

Show All 31 Lines def tearDown(self):
# Destroy process before TestBase.tearDown() # Destroy process before TestBase.tearDown()
self.dbg.GetSelectedTarget().GetProcess().Destroy() self.dbg.GetSelectedTarget().GetProcess().Destroy()
# Call super's tearDown(). # Call super's tearDown().
TestBase.tearDown(self) TestBase.tearDown(self)
def test_attach_and_check_dsyms(self): def test_attach_and_check_dsyms(self):
"""Test attach to binary, see if the bundle dSYM is found""" """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() self.build()
os.chdir(self.getBuildDir());
popen = self.spawnSubprocess(exe) popen = self.spawnSubprocess(exe)
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
# Give the inferior time to start up, dlopen a bundle, remove the bundle it linked in # Give the inferior time to start up, dlopen a bundle, remove the bundle it linked in
sleep(5) sleep(5)
# Since the library that was dlopen()'ed is now removed, lldb will need to find the # Since the library that was dlopen()'ed is now removed, lldb will need to find the
# binary & dSYM via target.exec-search-paths # binary & dSYM via target.exec-search-paths
Show All 11 Lines def test_attach_and_check_dsyms(self):
# Find the bundle module, see if we found the dSYM too (they're both in "hide.app") # Find the bundle module, see if we found the dSYM too (they're both in "hide.app")
i = 0 i = 0
while i < target.GetNumModules(): while i < target.GetNumModules():
mod = target.GetModuleAtIndex(i) mod = target.GetModuleAtIndex(i)
if mod.GetFileSpec().GetFilename() == 'com.apple.sbd': if mod.GetFileSpec().GetFilename() == 'com.apple.sbd':
dsym_name = mod.GetSymbolFileSpec().GetFilename() dsym_name = mod.GetSymbolFileSpec().GetFilename()
self.assertTrue (dsym_name == 'com.apple.sbd', "Check that we found the dSYM for the bundle that was loaded") self.assertTrue (dsym_name == 'com.apple.sbd', "Check that we found the dSYM for the bundle that was loaded")
i=i+1 i=i+1
os.chdir(self.getSourceDir());
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

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

SRCDIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))/
CC ?= clang CC ?= clang
ifeq "$(ARCH)" "" ifeq "$(ARCH)" ""
ARCH = x86_64 ARCH = x86_64
endif endif
CFLAGS ?= -g -O0 -arch $(ARCH) CFLAGS ?= -g -O0 -arch $(ARCH)
all: clean 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/Headers
mkdir -p MyFramework.framework/Versions/A/Resources mkdir -p MyFramework.framework/Versions/A/Resources
cp MyFramework MyFramework.framework/Versions/A cp MyFramework MyFramework.framework/Versions/A
cp MyFramework.h MyFramework.framework/Versions/A/Headers cp $(SRCDIR)/MyFramework.h MyFramework.framework/Versions/A/Headers
cp Info.plist MyFramework.framework/Versions/A/Resources cp $(SRCDIR)/Info.plist MyFramework.framework/Versions/A/Resources
( cd MyFramework.framework/Versions ; ln -s A Current ) ( cd MyFramework.framework/Versions ; ln -s A Current )
( cd MyFramework.framework/ ; ln -s Versions/Current/Headers . ) ( cd MyFramework.framework/ ; ln -s Versions/Current/Headers . )
( cd MyFramework.framework/ ; ln -s Versions/Current/MyFramework . ) ( cd MyFramework.framework/ ; ln -s Versions/Current/MyFramework . )
( cd MyFramework.framework/ ; ln -s Versions/Current/Resources . ) ( cd MyFramework.framework/ ; ln -s Versions/Current/Resources . )
mv MyFramework.dSYM MyFramework.framework.dSYM mv MyFramework.dSYM MyFramework.framework.dSYM
mkdir hide.app mkdir hide.app
rm -f MyFramework rm -f MyFramework
tar cf - MyFramework.framework MyFramework.framework.dSYM | ( cd hide.app;tar xBpf -) 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: clean:
rm -rf a.out a.out.dSYM deep-bundle deep-bundle.dSYM MyFramework.framework MyFramework.framework.dSYM MyFramework MyFramework.dSYM hide.app rm -rf a.out a.out.dSYM deep-bundle deep-bundle.dSYM MyFramework.framework MyFramework.framework.dSYM MyFramework MyFramework.dSYM hide.app

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

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

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

#include <MyFramework/MyFramework.h> #include <MyFramework/MyFramework.h>
#include <unistd.h> #include <unistd.h>
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int setup_is_complete = 0; 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; setup_is_complete = 1;
// At this point we want lldb to attach to the process. If lldb attaches // 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 // 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, // easy for lldb to find the binary & dSYM without using target.exec-search-paths,
// which is the point of this test. // which is the point of this test.
for (int loop_limiter = 0; loop_limiter < 100; loop_limiter++) for (int loop_limiter = 0; loop_limiter < 100; loop_limiter++)
sleep (1); sleep (1);
return foo(); return foo();
} }

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

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

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

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

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

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines def expect(self, pattern, exactly=False, *args, **kwargs):
return self.child.expect_exact(pattern, *args, **kwargs) return self.child.expect_exact(pattern, *args, **kwargs)
return self.child.expect(pattern, *args, **kwargs) return self.child.expect(pattern, *args, **kwargs)
def do_test(self, expect_regexes=None, settings_commands=None): def do_test(self, expect_regexes=None, settings_commands=None):
""" Run a test. """ """ Run a test. """
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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, self.run_lldb_to_breakpoint(exe, self.source, self.line,
settings_commands=settings_commands) settings_commands=settings_commands)
self.expect_prompt() self.expect_prompt()
# Now go. # Now go.
self.runCmd("process continue") self.runCmd("process continue")
self.expect(expect_regexes) self.expect(expect_regexes)
Show All 31 Lines

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

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

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

CC ?= clang LEVEL = ../../make
ifeq "$(ARCH)" ""
ARCH = x86_64
endif
ifeq "$(OS)" "" C_SOURCES := main.c
OS = $(shell uname -s)
endif
CFLAGS ?= -g -O0 include $(LEVEL)/Makefile.rules
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)

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

CC ?= clang LEVEL = ../../make
ifeq "$(ARCH)" ""
ARCH = x86_64
endif
ifeq "$(OS)" "" C_SOURCES := main.c
OS = $(shell uname -s)
endif
CFLAGS ?= -g -O0 include $(LEVEL)/Makefile.rules
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)

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

CC ?= clang LEVEL = ../../make
ifeq "$(ARCH)" ""
ARCH = x86_64
endif
ifeq "$(OS)" "" C_SOURCES := main.c
OS = $(shell uname -s)
endif
CFLAGS ?= -g -O0 include $(LEVEL)/Makefile.rules
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)

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

CC ?= clang CC ?= clang
all: testit
testit: testit.i386 testit.x86_64 testit: testit.i386 testit.x86_64
lipo -create -o testit testit.i386 testit.x86_64 lipo -create -o testit $^
testit.i386: testit.i386.o 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 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 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 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: clean:
rm -rf $(wildcard testit* *~) rm -rf $(wildcard testit* *~)

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

Show All 27 Lines @unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in [
'i386', 'x86_64'], "requires i386 or x86_64") 'i386', 'x86_64'], "requires i386 or x86_64")
@skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system @skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system
def test_sbdebugger_create_target_with_file_and_target_triple(self): def test_sbdebugger_create_target_with_file_and_target_triple(self):
"""Test the SBDebugger.CreateTargetWithFileAndTargetTriple() API.""" """Test the SBDebugger.CreateTargetWithFileAndTargetTriple() API."""
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
# Note that "testit" is a universal binary. # Note that "testit" is a universal binary.
exe = os.path.join(os.getcwd(), "testit") exe = self.getBuildArtifact("testit")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTargetWithFileAndTargetTriple( target = self.dbg.CreateTargetWithFileAndTargetTriple(
exe, "i386-apple-macosx") exe, "i386-apple-macosx")
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Now launch the process, and do not stop at entry point. # Now launch the process, and do not stop at entry point.
process = target.LaunchSimple( process = target.LaunchSimple(
None, None, self.get_process_working_directory()) None, None, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID) self.assertTrue(process, PROCESS_IS_VALID)
@skipUnlessDarwin @skipUnlessDarwin
@unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in [ @unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in [
'i386', 'x86_64'], "requires i386 or x86_64") 'i386', 'x86_64'], "requires i386 or x86_64")
@skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system @skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system
def test_process_launch_for_universal(self): def test_process_launch_for_universal(self):
"""Test process launch of a universal binary.""" """Test process launch of a universal binary."""
from lldbsuite.test.lldbutil import print_registers from lldbsuite.test.lldbutil import print_registers
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
# Note that "testit" is a universal binary. # 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. # By default, x86_64 is assumed if no architecture is specified.
self.expect("file " + exe, CURRENT_EXECUTABLE_SET, self.expect("file " + exe, CURRENT_EXECUTABLE_SET,
startstr="Current executable set to ", startstr="Current executable set to ",
substrs=["testit' (x86_64)."]) substrs=["testit' (x86_64)."])
# Break inside the main. # Break inside the main.
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines def test_process_attach_with_wrong_arch(self):
# Now keep the architecture at 32 bit, but switch the binary we launch to # 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 # 64 bit, and make sure on attach we switch to the correct
# architecture. # architecture.
# Invoke the default build rule. # Invoke the default build rule.
self.build() self.build()
# Note that "testit" is a universal binary. # Note that "testit" is a universal binary.
exe = os.path.join(os.getcwd(), "testit") exe = self.getBuildArtifact("testit")
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTargetWithFileAndTargetTriple( target = self.dbg.CreateTargetWithFileAndTargetTriple(
exe, "i386-apple-macosx") exe, "i386-apple-macosx")
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
pointer_size = target.GetAddressByteSize() pointer_size = target.GetAddressByteSize()
self.assertTrue(pointer_size == 4, "Initially we were 32 bit.") self.assertTrue(pointer_size == 4, "Initially we were 32 bit.")
Show All 31 Lines

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

#---------------------------------------------------------------------- #----------------------------------------------------------------------
# Clients fill in the source files to build # Clients fill in the source files to build
#---------------------------------------------------------------------- #----------------------------------------------------------------------
# C_SOURCES := main.c # C_SOURCES := main.c
# CXX_SOURCES := # CXX_SOURCES :=
# OBJC_SOURCES := # OBJC_SOURCES :=
# OBJCXX_SOURCES := # OBJCXX_SOURCES :=
# DYLIB_C_SOURCES := # DYLIB_C_SOURCES :=
# DYLIB_OBJC_SOURCES :=
# DYLIB_CXX_SOURCES := # DYLIB_CXX_SOURCES :=
# #
# Specifying DYLIB_ONLY has the effect of building dylib only, skipping # Specifying DYLIB_ONLY has the effect of building dylib only, skipping
# the building of the a.out executable program. For example, # the building of the a.out executable program. For example,
# DYLIB_ONLY := YES # DYLIB_ONLY := YES
# #
# Also might be of interest: # Also might be of interest:
# FRAMEWORK_INCLUDES (Darwin only) := # FRAMEWORK_INCLUDES (Darwin only) :=
# CFLAGS_EXTRAS := # CFLAGS_EXTRAS :=
# LD_EXTRAS := # LD_EXTRAS :=
# SPLIT_DEBUG_SYMBOLS := YES # SPLIT_DEBUG_SYMBOLS := YES
# CROSS_COMPILE := # CROSS_COMPILE :=
# #
# And test/functionalities/archives/Makefile: # And test/functionalities/archives/Makefile:
# MAKE_DSYM := NO # MAKE_DSYM := NO
# ARCHIVE_NAME := libfoo.a # ARCHIVE_NAME := libfoo.a
# ARCHIVE_C_SOURCES := a.c b.c # ARCHIVE_C_SOURCES := a.c b.c
# Uncomment line below for debugging shell commands # Uncomment line below for debugging shell commands
# SHELL = /bin/sh -x # SHELL = /bin/sh -x
THIS_FILE_DIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))/ SRCDIR := $(shell dirname $(firstword $(MAKEFILE_LIST)))/
THIS_FILE_DIR := $(shell dirname $(lastword $(MAKEFILE_LIST)))/
LLDB_BASE_DIR := $(THIS_FILE_DIR)../../../../../ LLDB_BASE_DIR := $(THIS_FILE_DIR)../../../../../
#---------------------------------------------------------------------- #----------------------------------------------------------------------
# If OS is not defined, use 'uname -s' to determine the OS name. # If OS is not defined, use 'uname -s' to determine the OS name.
# #
# uname on Windows gives "windows32", but most environments standardize # uname on Windows gives "windows32", but most environments standardize
# on "Windows_NT", so we'll make it consistent here. When running # on "Windows_NT", so we'll make it consistent here. When running
▲ Show 20 Lines • Show All 179 Lines • ▼ Show 20 Lines
CFLAGS ?= $(DEBUG_INFO_FLAG) -O0 -fno-builtin CFLAGS ?= $(DEBUG_INFO_FLAG) -O0 -fno-builtin
ifeq "$(OS)" "Darwin" ifeq "$(OS)" "Darwin"
CFLAGS += $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) -I$(LLDB_BASE_DIR)include CFLAGS += $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) -I$(LLDB_BASE_DIR)include
else else
CFLAGS += $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) -I$(LLDB_BASE_DIR)include CFLAGS += $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) -I$(LLDB_BASE_DIR)include
endif 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) 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: # Use this one if you want to build one part of the result without debug information:
ifeq "$(OS)" "Darwin" ifeq "$(OS)" "Darwin"
CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) $(ARCH_CFLAGS) $(CFLAGS_EXTRAS) CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) $(ARCH_CFLAGS) $(CFLAGS_EXTRAS)
else else
CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(ARCH_CFLAGS) $(CFLAGS_EXTRAS) CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(ARCH_CFLAGS) $(CFLAGS_EXTRAS)
endif endif
▲ Show 20 Lines • Show All 254 Lines • ▼ Show 20 Lines
#---------------------------------------------------------------------- #----------------------------------------------------------------------
# DYLIB_ONLY variable can be used to skip the building of a.out. # 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 # See the sections below regarding dSYM file as well as the building of
# EXE from all the objects. # 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. # Compile the executable from all the objects.
#---------------------------------------------------------------------- #----------------------------------------------------------------------
ifneq "$(DYLIB_NAME)" "" ifneq "$(DYLIB_NAME)" ""
ifeq "$(DYLIB_ONLY)" "" ifeq "$(DYLIB_ONLY)" ""
$(EXE) : $(OBJECTS) $(ARCHIVE_NAME) $(DYLIB_FILENAME) $(EXE) : $(OBJECTS) $(ARCHIVE_NAME) $(DYLIB_FILENAME)
$(LD) $(OBJECTS) $(ARCHIVE_NAME) -L. -l$(DYLIB_NAME) $(LDFLAGS) -o "$(EXE)" $(LD) $(OBJECTS) $(ARCHIVE_NAME) -L. -l$(DYLIB_NAME) $(LDFLAGS) -o "$(EXE)"
else else
EXE = $(DYLIB_FILENAME) EXE = $(DYLIB_FILENAME)
endif endif
else else
$(EXE) : $(OBJECTS) $(ARCHIVE_NAME) $(EXE) : $(OBJECTS) $(ARCHIVE_NAME)
$(LD) $(OBJECTS) $(LDFLAGS) $(ARCHIVE_NAME) -o "$(EXE)" $(LD) $(OBJECTS) $(LDFLAGS) $(ARCHIVE_NAME) -o "$(EXE)"
endif 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 # Make the archive
#---------------------------------------------------------------------- #----------------------------------------------------------------------
ifneq "$(ARCHIVE_NAME)" "" ifneq "$(ARCHIVE_NAME)" ""
ifeq "$(OS)" "Darwin" ifeq "$(OS)" "Darwin"
$(ARCHIVE_NAME) : $(ARCHIVE_OBJECTS) $(ARCHIVE_NAME) : $(ARCHIVE_OBJECTS)
$(AR) $(ARFLAGS) $(ARCHIVE_NAME) $(ARCHIVE_OBJECTS) $(AR) $(ARFLAGS) $(ARCHIVE_NAME) $(ARCHIVE_OBJECTS)
$(RM) $(ARCHIVE_OBJECTS) $(RM) $(ARCHIVE_OBJECTS)
else else
Show All 23 Lines
endif endif
#---------------------------------------------------------------------- #----------------------------------------------------------------------
# Make the precompiled header and compile C++ sources against it # Make the precompiled header and compile C++ sources against it
#---------------------------------------------------------------------- #----------------------------------------------------------------------
#ifneq "$(PCH_OUTPUT)" "" #ifneq "$(PCH_OUTPUT)" ""
$(PCH_OUTPUT) : $(PCH_CXX_SOURCE) $(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) %.o : %.cpp $(PCH_OUTPUT)
$(CXX) $(PCHFLAGS) $(CXXFLAGS) -c -o $@ $< $(CXX) $(PCHFLAGS) $(CXXFLAGS) -c -o $@ $<
#endif #endif
#---------------------------------------------------------------------- #----------------------------------------------------------------------
# Automatic variables based on items already entered. Below we create # Automatic variables based on items already entered. Below we create
# an object's lists from the list of sources by replacing all entries # 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 # that end with .c with .o, and we also create a list of prerequisite
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines elif "gcc" in compiler:
archflag = "-m" archflag = "-m"
elif "clang" in compiler: elif "clang" in compiler:
archflag = "-arch" archflag = "-arch"
else: else:
archflag = None archflag = None
return ("ARCHFLAG=" + archflag) if archflag else "" return ("ARCHFLAG=" + archflag) if archflag else ""
def getMake(test_subdir):
def getMake(): """Returns the invocation for GNU make.
"""Returns the name for GNU make""" The argument test_subdir is the relative path to the testcase."""
if platform.system() == "FreeBSD" or platform.system() == "NetBSD": if platform.system() == "FreeBSD" or platform.system() == "NetBSD":
return "gmake" make = "gmake"
else: 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): def getArchSpec(architecture):
""" """
Helper function to return the key-value string to specify the architecture Helper function to return the key-value string to specify the architecture
used for the make system. used for the make system.
""" """
arch = architecture if architecture else None arch = architecture if architecture else None
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines except subprocess.CalledProcessError as called_process_error:
raise build_exception.BuildError(called_process_error) raise build_exception.BuildError(called_process_error)
def buildDefault( def buildDefault(
sender=None, sender=None,
architecture=None, architecture=None,
compiler=None, compiler=None,
dictionary=None, dictionary=None,
clean=True): clean=True,
testdir=None):
"""Build the binaries the default way.""" """Build the binaries the default way."""
commands = [] commands = []
if clean: if clean:
commands.append([getMake(), "clean", getCmdLine(dictionary)]) commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
commands.append([getMake(), getArchSpec(architecture), commands.append(getMake(testdir) + [getArchSpec(architecture),
getCCSpec(compiler), getCmdLine(dictionary)]) getCCSpec(compiler), getCmdLine(dictionary)])
runBuildCommands(commands, sender=sender) runBuildCommands(commands, sender=sender)
# True signifies that we can handle building default. # True signifies that we can handle building default.
return True return True
def buildDwarf( def buildDwarf(
sender=None, sender=None,
architecture=None, architecture=None,
compiler=None, compiler=None,
dictionary=None, dictionary=None,
clean=True): clean=True,
testdir=None):
"""Build the binaries with dwarf debug info.""" """Build the binaries with dwarf debug info."""
commands = [] commands = []
if clean: if clean:
commands.append([getMake(), "clean", getCmdLine(dictionary)]) commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
commands.append([getMake(), "MAKE_DSYM=NO", getArchSpec( commands.append(getMake(testdir) + ["MAKE_DSYM=NO", getArchSpec(
architecture), getCCSpec(compiler), getCmdLine(dictionary)]) architecture), getCCSpec(compiler), getCmdLine(dictionary)])
runBuildCommands(commands, sender=sender) runBuildCommands(commands, sender=sender)
# True signifies that we can handle building dwarf. # True signifies that we can handle building dwarf.
return True return True
def buildDwo( def buildDwo(
sender=None, sender=None,
architecture=None, architecture=None,
compiler=None, compiler=None,
dictionary=None, dictionary=None,
clean=True): clean=True,
testdir=None):
"""Build the binaries with dwarf debug info.""" """Build the binaries with dwarf debug info."""
commands = [] commands = []
if clean: if clean:
commands.append([getMake(), "clean", getCmdLine(dictionary)]) commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
commands.append([getMake(), "MAKE_DSYM=NO", "MAKE_DWO=YES", getArchSpec( commands.append(getMake(testdir) +
architecture), getCCSpec(compiler), getCmdLine(dictionary)]) ["MAKE_DSYM=NO", "MAKE_DWO=YES",
getArchSpec(architecture),
getCCSpec(compiler),
getCmdLine(dictionary)])
runBuildCommands(commands, sender=sender) runBuildCommands(commands, sender=sender)
# True signifies that we can handle building dwo. # True signifies that we can handle building dwo.
return True return True
def buildGModules( def buildGModules(
sender=None, sender=None,
architecture=None, architecture=None,
compiler=None, compiler=None,
dictionary=None, dictionary=None,
clean=True): clean=True,
testdir=None):
"""Build the binaries with dwarf debug info.""" """Build the binaries with dwarf debug info."""
commands = [] commands = []
if clean: if clean:
commands.append([getMake(), "clean", getCmdLine(dictionary)]) commands.append(getMake(testdir) + ["clean", getCmdLine(dictionary)])
commands.append([getMake(), commands.append(getMake(testdir) +
"MAKE_DSYM=NO", ["MAKE_DSYM=NO",
"MAKE_GMODULES=YES", "MAKE_GMODULES=YES",
getArchSpec(architecture), getArchSpec(architecture),
getCCSpec(compiler), getCCSpec(compiler),
getCmdLine(dictionary)]) getCmdLine(dictionary)])
lldbtest.system(commands, sender=sender) lldbtest.system(commands, sender=sender)
# True signifies that we can handle building with gmodules. # True signifies that we can handle building with gmodules.
return True return True
def cleanup(sender=None, dictionary=None): def cleanup(sender=None, dictionary=None):
"""Perform a platform-specific cleanup after the test.""" """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 return True

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

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

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

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

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

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

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

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

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

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

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

Show All 28 Linesclass SBTypeMemberFunctionsTest(TestBase):
@skipUnlessDarwin @skipUnlessDarwin
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
"""Test SBType APIs to fetch member function types.""" """Test SBType APIs to fetch member function types."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(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. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

Show All 22 Linesclass SBFormattersAPITestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_formatters_api(self): def test_formatters_api(self):
"""Test Python APIs for working with formatters""" """Test Python APIs for working with formatters"""
self.build() self.build()
self.setTearDownCleanup() self.setTearDownCleanup()
"""Test Python APIs for working with formatters""" """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( 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) self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', substrs=['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
▲ Show 20 Lines • Show All 391 Lines • ▼ Show 20 Lines def test_formatters_api(self):
"ObjC category is None") "ObjC category is None")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_force_synth_off(self): def test_force_synth_off(self):
"""Test that one can have the public API return non-synthetic SBValues if desired""" """Test that one can have the public API return non-synthetic SBValues if desired"""
self.build(dictionary={'EXE': 'no_synth'}) self.build(dictionary={'EXE': 'no_synth'})
self.setTearDownCleanup() 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( 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) self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

Show All 15 Lines
class HelloWorldTestCase(TestBase): class HelloWorldTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Get the full path to our executable to be attached/debugged. # 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} self.d = {'EXE': self.testMethodName}
# Find a couple of the line numbers within main.c. # Find a couple of the line numbers within main.c.
self.line1 = line_number('main.c', '// Set break point at this line.') self.line1 = line_number('main.c', '// Set break point at this line.')
self.line2 = line_number('main.c', '// Waiting to be attached...') self.line2 = line_number('main.c', '// Waiting to be attached...')
def tearDown(self): def tearDown(self):
# Destroy process before TestBase.tearDown() # Destroy process before TestBase.tearDown()
self.dbg.GetSelectedTarget().GetProcess().Destroy() self.dbg.GetSelectedTarget().GetProcess().Destroy()
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

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

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

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

Show All 14 Linesclass TestReadMemCString(TestBase):
NO_DEBUG_INFO_TESTCASE = True NO_DEBUG_INFO_TESTCASE = True
def test_read_memory_c_string(self): def test_read_memory_c_string(self):
"""Test corner case behavior of SBProcess::ReadCStringFromMemory""" """Test corner case behavior of SBProcess::ReadCStringFromMemory"""
self.build() self.build()
self.dbg.SetAsync(False) self.dbg.SetAsync(False)
self.main_source = "main.c" self.main_source = "main.c"
self.main_source_spec = lldb.SBFileSpec(self.main_source) self.main_source_path = os.path.join(self.getSourceDir(),
self.exe = os.path.join(os.getcwd(), "read-mem-cstring") 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( (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
self, 'breakpoint here', self.main_source_spec, None, self.exe) self, 'breakpoint here', self.main_source_spec, None, self.exe)
frame = thread.GetFrameAtIndex(0) frame = thread.GetFrameAtIndex(0)
err = lldb.SBError() err = lldb.SBError()
Show All 25 Lines

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

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

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

Show First 20 Lines • Show All 143 Lines • ▼ Show 20 Lines def test_read_memory(self):
data_section = self.find_data_section(target) data_section = self.find_data_section(target)
sb_addr = lldb.SBAddress(data_section, 0) sb_addr = lldb.SBAddress(data_section, 0)
error = lldb.SBError() error = lldb.SBError()
content = target.ReadMemory(sb_addr, 1, error) content = target.ReadMemory(sb_addr, 1, error)
self.assertTrue(error.Success(), "Make sure memory read succeeded") self.assertTrue(error.Success(), "Make sure memory read succeeded")
self.assertEqual(len(content), 1) self.assertEqual(len(content), 1)
def create_simple_target(self, fn): def create_simple_target(self, fn):
exe = os.path.join(os.getcwd(), fn) exe = self.getBuildArtifact(fn)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
return target return target
def find_data_section(self, target): def find_data_section(self, target):
mod = target.GetModuleAtIndex(0) mod = target.GetModuleAtIndex(0)
data_section = None data_section = None
for s in mod.sections: for s in mod.sections:
Show All 9 Lines def find_data_section(self, target):
data_section = ss data_section = ss
break break
self.assertIsNotNone(data_section) self.assertIsNotNone(data_section)
return data_section return data_section
def find_global_variables(self, exe_name): def find_global_variables(self, exe_name):
"""Exercise SBTaget.FindGlobalVariables() API.""" """Exercise SBTaget.FindGlobalVariables() API."""
exe = os.path.join(os.getcwd(), exe_name) exe = self.getBuildArtifact(exe_name)
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# rdar://problem/9700873 # rdar://problem/9700873
# Find global variable value fails for dwarf if inferior not started # 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) # (Was CrashTracer: [USER] 1 crash in Python at _lldb.so: lldb_private::MemoryCache::Read + 94)
Show All 24 Lines def find_global_variables(self, exe_name):
self.expect(my_global_var.GetTypeName(), exe=False, self.expect(my_global_var.GetTypeName(), exe=False,
startstr="char") startstr="char")
self.expect(my_global_var.GetValue(), exe=False, self.expect(my_global_var.GetValue(), exe=False,
startstr="'X'") startstr="'X'")
# While we are at it, let's also exercise the similar # While we are at it, let's also exercise the similar
# SBModule.FindGlobalVariables() API. # SBModule.FindGlobalVariables() API.
for m in target.module_iter(): for m in target.module_iter():
if os.path.normpath(m.GetFileSpec().GetDirectory()) == os.getcwd( if os.path.normpath(m.GetFileSpec().GetDirectory()) == self.getBuildDir() and m.GetFileSpec().GetFilename() == exe_name:
) and m.GetFileSpec().GetFilename() == exe_name:
value_list = m.FindGlobalVariables( value_list = m.FindGlobalVariables(
target, 'my_global_var_of_char_type', 3) target, 'my_global_var_of_char_type', 3)
self.assertTrue(value_list.GetSize() == 1) self.assertTrue(value_list.GetSize() == 1)
self.assertTrue( self.assertTrue(
value_list.GetValueAtIndex(0).GetValue() == "'X'") value_list.GetValueAtIndex(0).GetValue() == "'X'")
break break
def find_functions(self, exe_name): def find_functions(self, exe_name):
"""Exercise SBTaget.FindFunctions() API.""" """Exercise SBTaget.FindFunctions() API."""
exe = os.path.join(os.getcwd(), exe_name) exe = self.getBuildArtifact(exe_name)
# Create a target by the debugger. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
list = target.FindFunctions('c', lldb.eFunctionNameTypeAuto) list = target.FindFunctions('c', lldb.eFunctionNameTypeAuto)
self.assertTrue(list.GetSize() == 1) self.assertTrue(list.GetSize() == 1)
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Lines def get_stop_description(self):
# and expect to get a Python string as the return object! # and expect to get a Python string as the return object!
# The 100 is just an arbitrary number specifying the buffer size. # The 100 is just an arbitrary number specifying the buffer size.
stop_description = thread.GetStopDescription(100) stop_description = thread.GetStopDescription(100)
self.expect(stop_description, exe=False, self.expect(stop_description, exe=False,
startstr='breakpoint') startstr='breakpoint')
def step_out_of_malloc_into_function_b(self, exe_name): 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().""" """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) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByName('malloc') breakpoint = target.BreakpointCreateByName('malloc')
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
# Launch the process, and do not stop at the entry point. # Launch the process, and do not stop at the entry point.
Show All 30 Lines def step_out_of_malloc_into_function_b(self, exe_name):
thread.StepOut() thread.StepOut()
self.runCmd("thread backtrace") self.runCmd("thread backtrace")
self.assertTrue( self.assertTrue(
thread.GetFrameAtIndex(0).GetLineEntry().GetLine() == self.step_out_of_malloc, thread.GetFrameAtIndex(0).GetLineEntry().GetLine() == self.step_out_of_malloc,
"step out of malloc into function b is successful") "step out of malloc into function b is successful")
def step_over_3_times(self, exe_name): def step_over_3_times(self, exe_name):
"""Test Python SBThread.StepOver() API.""" """Test Python SBThread.StepOver() API."""
exe = os.path.join(os.getcwd(), exe_name) exe = self.getBuildArtifact(exe_name)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation( breakpoint = target.BreakpointCreateByLocation(
'main2.cpp', self.step_out_of_malloc) 'main2.cpp', self.step_out_of_malloc)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
self.runCmd("breakpoint list") self.runCmd("breakpoint list")
Show All 29 Lines def step_over_3_times(self, exe_name):
# rdar://problem/9223880 # rdar://problem/9223880
# #
# Which has been fixed on the lldb by compensating for inaccurate line # Which has been fixed on the lldb by compensating for inaccurate line
# table information with r140416. # table information with r140416.
self.assertTrue(lineEntry.GetLine() == self.after_3_step_overs) self.assertTrue(lineEntry.GetLine() == self.after_3_step_overs)
def run_to_address(self, exe_name): def run_to_address(self, exe_name):
"""Test Python SBThread.RunToAddress() API.""" """Test Python SBThread.RunToAddress() API."""
exe = os.path.join(os.getcwd(), exe_name) exe = self.getBuildArtifact(exe_name)
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
breakpoint = target.BreakpointCreateByLocation( breakpoint = target.BreakpointCreateByLocation(
'main2.cpp', self.step_out_of_malloc) 'main2.cpp', self.step_out_of_malloc)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
self.runCmd("breakpoint list") self.runCmd("breakpoint list")
Show All 39 Lines

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

Show All 28 Lines def setUp(self):
self.line = line_number(self.source, '// Break at this line') self.line = line_number(self.source, '// Break at this line')
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
"""Exercise SBType and SBTypeList API.""" """Exercise SBType and SBTypeList API."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(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. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

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

Show All 27 Linesclass ValueAPITestCase(TestBase):
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
"""Exercise some SBValue APIs.""" """Exercise some SBValue APIs."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(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. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation('main.c', self.line) breakpoint = target.BreakpointCreateByLocation('main.c', self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

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

Show All 32 Linesclass ChangeValueAPITestCase(TestBase):
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
@expectedFlakeyLinux("llvm.org/pr25652") @expectedFlakeyLinux("llvm.org/pr25652")
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
def test_change_value(self): def test_change_value(self):
"""Exercise the SBValue::SetValueFromCString API.""" """Exercise the SBValue::SetValueFromCString API."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(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. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation('main.c', self.line) breakpoint = target.BreakpointCreateByLocation('main.c', self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

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

Show All 30 Linesclass ValueAsLinkedListTestCase(TestBase):
# SWIG 3.0.8. # SWIG 3.0.8.
@skipIf(py_version=['>=', (3, 0)], swig_version=['<', (3, 0, 8)]) @skipIf(py_version=['>=', (3, 0)], swig_version=['<', (3, 0, 8)])
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test(self): def test(self):
"""Exercise SBValue API linked_list_iter.""" """Exercise SBValue API linked_list_iter."""
d = {'EXE': self.exe_name} d = {'EXE': self.exe_name}
self.build(dictionary=d) self.build(dictionary=d)
self.setTearDownCleanup(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. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Create the breakpoint inside function 'main'. # Create the breakpoint inside function 'main'.
breakpoint = target.BreakpointCreateByLocation('main.cpp', self.line) breakpoint = target.BreakpointCreateByLocation('main.cpp', self.line)
self.assertTrue(breakpoint, VALID_BREAKPOINT) self.assertTrue(breakpoint, VALID_BREAKPOINT)
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

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

Show All 15 Lines
class HelloWorldTestCase(TestBase): class HelloWorldTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# Get the full path to our executable to be attached/debugged. # 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} self.d = {'EXE': self.testMethodName}
@add_test_categories(['pyapi']) @add_test_categories(['pyapi'])
def test_with_process_launch_api(self): def test_with_process_launch_api(self):
"""Test SBValue::GetValueDidChange""" """Test SBValue::GetValueDidChange"""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(dictionary=self.d) self.setTearDownCleanup(dictionary=self.d)
target = self.dbg.CreateTarget(self.exe) target = self.dbg.CreateTarget(self.exe)
Show All 39 Lines

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

Show All 36 Lines @expectedFailureAll(
oslist=["linux"], oslist=["linux"],
archs=["aarch64"], archs=["aarch64"],
bugnumber="llvm.org/pr27710") bugnumber="llvm.org/pr27710")
@skipIfWindows # Watchpoints not supported on Windows, and this test hangs @skipIfWindows # Watchpoints not supported on Windows, and this test hangs
def test_watchpoint_cond_api(self): def test_watchpoint_cond_api(self):
"""Test watchpoint condition API.""" """Test watchpoint condition API."""
self.build(dictionary=self.d) self.build(dictionary=self.d)
self.setTearDownCleanup(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. # Create a target by the debugger.
target = self.dbg.CreateTarget(exe) target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET) self.assertTrue(target, VALID_TARGET)
# Now create a breakpoint on main.c. # Now create a breakpoint on main.c.
breakpoint = target.BreakpointCreateByLocation(self.source, self.line) breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
self.assertTrue(breakpoint and self.assertTrue(breakpoint and
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 149 Lines • ▼ Show 20 Lines def test_set_frame_format(self):
# Immediately test the setting. # Immediately test the setting.
self.expect("settings show frame-format", SETTING_MSG("frame-format"), self.expect("settings show frame-format", SETTING_MSG("frame-format"),
substrs=[format_string]) substrs=[format_string])
self.runCmd("breakpoint set -n main") self.runCmd("breakpoint set -n main")
self.runCmd("run") self.runCmd("run")
self.expect("thread backtrace", self.expect("thread backtrace",
substrs=["`main", os.getcwd()]) substrs=["`main", self.getSourceDir()])
def test_set_auto_confirm(self): def test_set_auto_confirm(self):
"""Test that after 'set auto-confirm true', manual confirmation should not kick in.""" """Test that after 'set auto-confirm true', manual confirmation should not kick in."""
self.build() self.build()
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
▲ Show 20 Lines • Show All 249 Lines • ▼ Show 20 Lines def test_settings_with_trailing_whitespace(self):
# string # string
self.runCmd("settings set target.arg0 abc") # Set to known value self.runCmd("settings set target.arg0 abc") # Set to known value
# Set to new value with trailing whitespaces # Set to new value with trailing whitespaces
self.runCmd("settings set target.arg0 cde\t ") self.runCmd("settings set target.arg0 cde\t ")
self.expect("settings show target.arg0", SETTING_MSG("target.arg0"), self.expect("settings show target.arg0", SETTING_MSG("target.arg0"),
startstr='target.arg0 (string) = "cde"') startstr='target.arg0 (string) = "cde"')
self.runCmd("settings clear target.arg0", check=False) self.runCmd("settings clear target.arg0", check=False)
# file # file
path1 = os.path.join(os.getcwd(), "path1.txt") path1 = self.getBuildArtifact("path1.txt")
path2 = os.path.join(os.getcwd(), "path2.txt") path2 = self.getBuildArtifact("path2.txt")
self.runCmd( self.runCmd(
"settings set target.output-path %s" % "settings set target.output-path %s" %
path1) # Set to known value path1) # Set to known value
self.expect( self.expect(
"settings show target.output-path", "settings show target.output-path",
SETTING_MSG("target.output-path"), SETTING_MSG("target.output-path"),
startstr='target.output-path (file) = ', startstr='target.output-path (file) = ',
substrs=[path1]) substrs=[path1])
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

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

Show All 16 Lines
class SettingsCommandTestCase(TestBase): class SettingsCommandTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
@classmethod @classmethod
def classCleanup(cls): def classCleanup(cls):
"""Cleanup the test byproducts.""" """Cleanup the test byproducts."""
cls.RemoveTempFile("stdout.txt") cls.RemoveTempFile(self.getBuildArtifact("stdout.txt"))
@no_debug_info_test @no_debug_info_test
def test_no_quote(self): def test_no_quote(self):
self.do_test_args("a b c", "a\0b\0c\0") self.do_test_args("a b c", "a\0b\0c\0")
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24557") @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24557")
@no_debug_info_test @no_debug_info_test
def test_single_quote(self): def test_single_quote(self):
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linesclass SettingsCommandTestCase(TestBase):
def do_test_args(self, args_in, args_out): def do_test_args(self, args_in, args_out):
"""Test argument parsing. Run the program with args_in. The program dumps its arguments """Test argument parsing. Run the program with args_in. The program dumps its arguments
to stdout. Compare the stdout with args_out.""" to stdout. Compare the stdout with args_out."""
self.buildDefault() self.buildDefault()
exe = self.getBuildArtifact("a.out") exe = self.getBuildArtifact("a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
self.runCmd("process launch -- " + args_in) local_outfile = self.getBuildArtifact("output.txt")
if lldb.remote_platform:
remote_outfile = "output.txt" # Relative to platform's PWD
else:
remote_outfile = local_outfile
self.runCmd("process launch -- %s %s" %(remote_outfile, args_in))
if lldb.remote_platform: if lldb.remote_platform:
src_file_spec = lldb.SBFileSpec('output.txt', False) src_file_spec = lldb.SBFileSpec(remote_outfile, False)
dst_file_spec = lldb.SBFileSpec('output.txt', True) dst_file_spec = lldb.SBFileSpec(local_outfile, True)
lldb.remote_platform.Get(src_file_spec, dst_file_spec) lldb.remote_platform.Get(src_file_spec, dst_file_spec)
with open('output.txt', 'r') as f: with open(local_outfile, 'r') as f:
output = f.read() output = f.read()
self.RemoveTempFile("output.txt") self.RemoveTempFile(local_outfile)
self.assertEqual(output, args_out) self.assertEqual(output, args_out)

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

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

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

Show First 20 Lines • Show All 134 Lines • ▼ Show 20 Lines def test_move_and_then_display_source(self):
# error # error
self.expect( self.expect(
"settings set target.source-map /a/b/c/d/e /q/r/s/t/u", "settings set target.source-map /a/b/c/d/e /q/r/s/t/u",
error=True, error=True,
substrs=['''error: the replacement path doesn't exist: "/q/r/s/t/u"''']) substrs=['''error: the replacement path doesn't exist: "/q/r/s/t/u"'''])
# Set target.source-map settings. # Set target.source-map settings.
self.runCmd("settings set target.source-map %s %s" % 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. # And verify that the settings work.
self.expect("settings show target.source-map", 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. # Display main() and verify that the source mapping has been kicked in.
self.expect("source list -n main", SOURCE_DISPLAYED_CORRECTLY, self.expect("source list -n main", SOURCE_DISPLAYED_CORRECTLY,
substrs=['Hello world']) substrs=['Hello world'])
def test_modify_source_file_while_debugging(self): def test_modify_source_file_while_debugging(self):
"""Modify a source file while debugging the executable.""" """Modify a source file while debugging the executable."""
self.build() self.build()
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines def test_modify_source_file_while_debugging(self):
"source list -f main.c -l %d" % "source list -f main.c -l %d" %
self.line, self.line,
SOURCE_DISPLAYED_CORRECTLY, SOURCE_DISPLAYED_CORRECTLY,
substrs=['Hello lldb']) substrs=['Hello lldb'])
def test_set_breakpoint_with_absolute_path(self): def test_set_breakpoint_with_absolute_path(self):
self.build() self.build()
self.runCmd("settings set target.source-map %s %s" % 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") 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) self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line( lldbutil.run_break_set_by_file_and_line(
self, main, self.line, num_expected_locations=1, loc_exact=False) self, main, self.line, num_expected_locations=1, loc_exact=False)
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', substrs=['stopped',
'main.c:%d' % self.line, 'main.c:%d' % self.line,
'stop reason = breakpoint']) 'stop reason = breakpoint'])

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

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

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

Show First 20 Lines • Show All 194 Lines • ▼ Show 20 Lines def test_lldbmi_break_insert_file_line_absolute_path(self):
self.runCmd("-break-insert -f main") self.runCmd("-break-insert -f main")
self.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
self.runCmd("-exec-run") self.runCmd("-exec-run")
self.expect("\^running") self.expect("\^running")
self.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
import os 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') line = line_number('main.cpp', '// BP_return')
self.runCmd("-break-insert %s:%d" % (path, line)) self.runCmd("-break-insert %s:%d" % (path, line))
self.expect("\^done,bkpt={number=\"2\"") self.expect("\^done,bkpt={number=\"2\"")
self.runCmd("-exec-continue") self.runCmd("-exec-continue")
self.expect("\^running") self.expect("\^running")
self.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

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

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

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

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines def test_lldbmi_symbol_list_lines_file(self):
# relative path # relative path
self.runCmd("-symbol-list-lines ./main.cpp") self.runCmd("-symbol-list-lines ./main.cpp")
self.expect( self.expect(
"\^error,message=\"error: No source filenames matched '\./main\.cpp'\. \"") "\^error,message=\"error: No source filenames matched '\./main\.cpp'\. \"")
# Test that -symbol-list-lines works when file is specified using # Test that -symbol-list-lines works when file is specified using
# absolute path # absolute path
import os 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.runCmd("-symbol-list-lines \"%s\"" % path)
self.expect( self.expect(
"\^done,lines=\[\{pc=\"0x0*%x\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"\d+\"\})+\]" % "\^done,lines=\[\{pc=\"0x0*%x\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"\d+\"\})+\]" %
(addr, line)) (addr, line))
# Test that -symbol-list-lines fails when file doesn't exist # Test that -symbol-list-lines fails when file doesn't exist
self.runCmd("-symbol-list-lines unknown_dir/main.cpp") self.runCmd("-symbol-list-lines unknown_dir/main.cpp")
self.expect( self.expect(
"\^error,message=\"error: No source filenames matched 'unknown_dir/main\.cpp'\. \"") "\^error,message=\"error: No source filenames matched 'unknown_dir/main\.cpp'\. \"")

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

Show All 26 Lines def test_lldbmi_target_attach_wait_for(self):
self.buildProgram("test_attach.cpp", exeName) self.buildProgram("test_attach.cpp", exeName)
self.addTearDownCleanup(dictionary=d) self.addTearDownCleanup(dictionary=d)
self.spawnLldbMi(args=None) self.spawnLldbMi(args=None)
# Load executable # Load executable
# FIXME: -file-exec-and-sybmols is not required for target attach, but # FIXME: -file-exec-and-sybmols is not required for target attach, but
# the test will not pass without this # 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") self.expect("\^done")
# Set up attach # Set up attach
self.runCmd("-target-attach -n %s --waitfor" % exeName) self.runCmd("-target-attach -n %s --waitfor" % exeName)
time.sleep(4) # Give attach time to setup time.sleep(4) # Give attach time to setup
# Start target process # Start target process
self.spawnSubprocess(os.path.join(os.path.dirname(__file__), exeName)) self.spawnSubprocess(self.getBuildArtifact(exeName))
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
self.expect("\^done") self.expect("\^done")
# Set breakpoint on printf # Set breakpoint on printf
line = line_number('test_attach.cpp', '// BP_i++') line = line_number('test_attach.cpp', '// BP_i++')
self.runCmd("-break-insert -f test_attach.cpp:%d" % line) self.runCmd("-break-insert -f test_attach.cpp:%d" % line)
self.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
Show All 14 Lines def test_lldbmi_target_attach_name(self):
# Build target executable with unique name # Build target executable with unique name
exeName = self.testMethodName exeName = self.testMethodName
d = {'EXE': exeName} d = {'EXE': exeName}
self.buildProgram("test_attach.cpp", exeName) self.buildProgram("test_attach.cpp", exeName)
self.addTearDownCleanup(dictionary=d) self.addTearDownCleanup(dictionary=d)
# Start target process # Start target process
targetProcess = self.spawnSubprocess( targetProcess = self.spawnSubprocess(self.getBuildArtifact(exeName))
os.path.join(os.path.dirname(__file__), exeName))
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
self.spawnLldbMi(args=None) self.spawnLldbMi(args=None)
# Set up atatch # Set up atatch
self.runCmd("-target-attach -n %s" % exeName) self.runCmd("-target-attach -n %s" % exeName)
self.expect("\^done") self.expect("\^done")
Show All 20 Lines def test_lldbmi_target_attach_pid(self):
# Build target executable with unique name # Build target executable with unique name
exeName = self.testMethodName exeName = self.testMethodName
d = {'EXE': exeName} d = {'EXE': exeName}
self.buildProgram("test_attach.cpp", exeName) self.buildProgram("test_attach.cpp", exeName)
self.addTearDownCleanup(dictionary=d) self.addTearDownCleanup(dictionary=d)
# Start target process # Start target process
targetProcess = self.spawnSubprocess( targetProcess = self.spawnSubprocess(
os.path.join(os.path.dirname(__file__), exeName)) self.getBuildArtifact(exeName))
self.addTearDownHook(self.cleanupSubprocesses) self.addTearDownHook(self.cleanupSubprocesses)
self.spawnLldbMi(args=None) self.spawnLldbMi(args=None)
# Set up atatch # Set up atatch
self.runCmd("-target-attach %d" % targetProcess.pid) self.runCmd("-target-attach %d" % targetProcess.pid)
self.expect("\^done") self.expect("\^done")
Show All 12 Lines

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

Show All 28 Linesclass GenericTester(TestBase):
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
# We'll use the test method name as the exe_name. # 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 # 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" # module cacheing subsystem to be confused with executable name "a.out"
# used for all the test cases. # used for all the test cases.
self.exe_name = self.testMethodName 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): def tearDown(self):
"""Cleanup the test byproducts.""" """Cleanup the test byproducts."""
#print("Removing golden-output.txt...") #print("Removing golden-output.txt...")
if os.path.exists(self.golden_filename): if os.path.exists(self.golden_filename):
os.remove(self.golden_filename) os.remove(self.golden_filename)
TestBase.tearDown(self) TestBase.tearDown(self)
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Linesclass GenericTester(TestBase):
def generic_type_tester( def generic_type_tester(
self, self,
exe_name, exe_name,
atoms, atoms,
quotedDisplay=False, quotedDisplay=False,
blockCaptured=False): blockCaptured=False):
"""Test that variables with basic types are displayed correctly.""" """Test that variables with basic types are displayed correctly."""
self.runCmd("file %s" % self.getBuildArtifact(exe_name),
self.runCmd("file %s" % exe_name, CURRENT_EXECUTABLE_SET) CURRENT_EXECUTABLE_SET)
# First, capture the golden output emitted by the oracle, i.e., the # First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements. # series of printf statements.
self.process_launch_o(self.golden_filename) self.process_launch_o(self.golden_filename)
with open(self.golden_filename) as f: with open(self.golden_filename) as f:
go = f.read() go = f.read()
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Linesclass GenericTester(TestBase):
def generic_type_expr_tester( def generic_type_expr_tester(
self, self,
exe_name, exe_name,
atoms, atoms,
quotedDisplay=False, quotedDisplay=False,
blockCaptured=False): blockCaptured=False):
"""Test that variable expressions with basic types are evaluated correctly.""" """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 # First, capture the golden output emitted by the oracle, i.e., the
# series of printf statements. # series of printf statements.
self.process_launch_o(self.golden_filename) self.process_launch_o(self.golden_filename)
with open(self.golden_filename) as f: with open(self.golden_filename) as f:
go = f.read() go = f.read()
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

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

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

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

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,130 Lines • ▼ Show 20 Lines if (module_sp) {
// get back to the actual executable otherwise, so we won't get the right // get back to the actual executable otherwise, so we won't get the right
// path. // path.
if (!at_exec_relative_paths.empty() && CalculateType() == eTypeExecutable) { if (!at_exec_relative_paths.empty() && CalculateType() == eTypeExecutable) {
FileSpec exec_dir = this_file_spec.CopyByRemovingLastPathComponent(); FileSpec exec_dir = this_file_spec.CopyByRemovingLastPathComponent();
for (const auto &at_exec_relative_path : at_exec_relative_paths) { for (const auto &at_exec_relative_path : at_exec_relative_paths) {
FileSpec file_spec = FileSpec file_spec =
exec_dir.CopyByAppendingPathComponent(at_exec_relative_path); exec_dir.CopyByAppendingPathComponent(at_exec_relative_path);
file_spec = file_spec.GetNormalizedPath(); file_spec = file_spec.GetNormalizedPath();
if (file_spec.Exists() && files.AppendIfUnique(file_spec)) { if (file_spec.Exists() && files.AppendIfUnique(file_spec))
count++; count++;
break;
}
} }
} }
} }
return count; return count;
} }
lldb_private::Address ObjectFileMachO::GetEntryPointAddress() { lldb_private::Address ObjectFileMachO::GetEntryPointAddress() {
// If the object file is not an executable it can't hold the entry point. // If the object file is not an executable it can't hold the entry point.
▲ Show 20 Lines • Show All 1,109 Lines • Show Last 20 Lines

lldb/trunk/test/CMakeLists.txt

function(add_python_test_target name test_script args comment) function(add_python_test_target name test_script args comment)
set(PYTHON_TEST_COMMAND set(PYTHON_TEST_COMMAND
${PYTHON_EXECUTABLE} ${PYTHON_EXECUTABLE}
${test_script} ${test_script}
${args} ${args}
) )
add_custom_target(${name} 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} COMMAND ${PYTHON_TEST_COMMAND} ${ARG_DEFAULT_ARGS}
COMMENT "${comment}" COMMENT "${comment}"
DEPENDS ${LLDB_TEST_DEPS} DEPENDS ${LLDB_TEST_DEPS}
USES_TERMINAL USES_TERMINAL
) )
endfunction() endfunction()
set(LLDB_TEST_DEPS lldb) set(LLDB_TEST_DEPS lldb)
Show All 38 Linesset(LLDB_TEST_USER_ARGS
"" ""
CACHE STRING "Specify additional arguments to pass to test runner. For example: '-C gcc -C clang -A i386 -A x86_64'") 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 set(LLDB_TEST_COMMON_ARGS
--arch=${LLDB_TEST_ARCH} --arch=${LLDB_TEST_ARCH}
--executable $<TARGET_FILE:lldb> --executable $<TARGET_FILE:lldb>
-s -s
${CMAKE_BINARY_DIR}/lldb-test-traces ${CMAKE_BINARY_DIR}/lldb-test-traces
--build-dir
${CMAKE_BINARY_DIR}/lldb-test-build
-S nm -S nm
-u CXXFLAGS -u CXXFLAGS
-u CFLAGS -u CFLAGS
-C ${LLDB_TEST_C_COMPILER} -C ${LLDB_TEST_C_COMPILER}
) )
if ( CMAKE_SYSTEM_NAME MATCHES "Windows" ) if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
# All tests are currently flaky on Windows, so rerun them all once when they fail. # All tests are currently flaky on Windows, so rerun them all once when they fail.
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines