This is an archive of the discontinued LLVM Phabricator instance.

Differential D151465

[Dexter] Remove builder from Dexter
ClosedPublic

Authored by StephenTozer on May 25 2023, 9:39 AM.

Details

Reviewers
jmorse
Orlando
CarlosAlbertoEnciso
Commits
rG262520a3c545: [Dexter] Remove builder from Dexter
Summary

See "discussion": https://discourse.llvm.org/t/rfc-dexter-feature-removals/60462

With Dexter's inclusion in LLVM, test discovery and building is no longer required and is an active maintenance burden; this patch removes the builder and all associated features from Dexter. This does also mean removing the clang-opt-bisect feature; this is unfortunate collateral damage, as that tool does add functionality that is not otherwise available from a combination of Dexter and existing LLVM tools, but to my knowledge this tool has not seen much use in recent years and nobody yet has expressed a use-case for it. If it is in use, then it could either be reimplemented to take a build script as an argument (as with tools such as git-bisect and llvm-reduce), or implemented as a separate program with general support for "repeatedly run clang with opt-bisect-limit and run a script at each bisection" with a Dexter option.

For the most part this patch deletes builder-related folders completely, and removes other builder-related code from the rest of Dexter. No further functional changes are expected to appear in this patch. Tests have been updated to directly invoke clang (either with %clang or with %dexter_regression_test_build, which substitutes to clang++ -O0 -glldb or clang-cl /Zi /Od depending on platform) to build a temporary executable file and then run Dexter on that file.

Diff Detail

Event Timeline

StephenTozer created this revision.May 25 2023, 9:39 AM
Herald added a project: Restricted Project. · View Herald TranscriptMay 25 2023, 9:39 AM
Herald added a subscriber: ormris. · View Herald Transcript
StephenTozer requested review of this revision.May 25 2023, 9:39 AM
Herald added a project: Restricted Project. · View Herald TranscriptMay 25 2023, 9:39 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B234554: Diff 525664.May 25 2023, 9:42 AM
StephenTozer added a comment.EditedMay 25 2023, 9:42 AM

Small comment for reviewers; I ran black on the dexter folder to format code afterwards, and it looks like it removed a few blank lines that were untouched by my changes. I've left the newline removals in this patch, because in theory black should be essentially unconfigurable and therefore I assume the formatting it has done is correct and that the previous invocation of black on dexter either missed committing those changes for some reason or used an older version of black that used a slightly different rule for blank lines. The lines in question were the blank lines following def __init__(...): in the command files (dex/command/commands/Dex*.py).

jmorse accepted this revision.Jul 3 2023, 9:05 AM

I approve of the amount of red in this patch, LGTM. There are some files where there are only whitespace changes (deleted blank lines?), which would more ideally be in a cleanup patch instead.

Focusing Dexter more on what it does well, i.e. driving a debugging session and comparing against expectations, should make all our lives easier.

This revision is now accepted and ready to land.Jul 3 2023, 9:05 AM
Closed by commit rG262520a3c545: [Dexter] Remove builder from Dexter (authored by StephenTozer). · Explain WhyAug 21 2023, 7:19 AM
This revision was automatically updated to reflect the committed changes.
StephenTozer added a commit: rG262520a3c545: [Dexter] Remove builder from Dexter.
Michael137 added a subscriber: Michael137.Aug 21 2023, 8:29 AM

FYI, looks like debug-info tests started failing on the public x86_64 bot after this patch: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/59089/console

Exit Code: 1

Command Output (stderr):
--
/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_check_json_step_count.cpp:8:19: error: CHECK-COUNT: expected string not found in input (1 out of 3)
// CHECK-COUNT-3: json_step_count.cpp",
                  ^
<stdin>:3:12: note: scanning from here
## BEGIN ##
           ^
<stdin>:7:20: note: possible intended match here
 limit_steps_check_json_step_count.cpp:14 [index] ExpectValue [18/21]
                   ^

Input file: <stdin>
Check file: /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_check_json_step_count.cpp

Mind taking a look?

StephenTozer added a comment.Aug 21 2023, 8:43 AM
In D151465#4603767, @Michael137 wrote:

FYI, looks like debug-info tests started failing on the public x86_64 bot after this patch: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/59089/console

Exit Code: 1

Command Output (stderr):
--
/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_check_json_step_count.cpp:8:19: error: CHECK-COUNT: expected string not found in input (1 out of 3)
// CHECK-COUNT-3: json_step_count.cpp",
                  ^
<stdin>:3:12: note: scanning from here
## BEGIN ##
           ^
<stdin>:7:20: note: possible intended match here
 limit_steps_check_json_step_count.cpp:14 [index] ExpectValue [18/21]
                   ^

Input file: <stdin>
Check file: /Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_check_json_step_count.cpp

Mind taking a look?

Errors look odd, I'll take a look - if you think this needs a revert I'll take care of that too.

StephenTozer added a comment.Aug 21 2023, 9:26 AM

Looking further at the failing tests on the green dragon bot: I can't see any obvious causes for the errors; also all but one of the errors disappear after the first failed build. I can't see any clear reason for that test alone to fail in the way that it did, but it was updated inconsistently with another test that was otherwise changed identically (using %clang instead of %clang++), where the other test isn't failed. For now I've pushed up a patch that brings it in line with the remaining test, and if that doesn't fix it then I'll look a little further and revert if necessary.

StephenTozer added a reverting change: rG8df9eff90ff8: Revert "[Dexter] Remove builder from Dexter".Aug 21 2023, 10:07 AM
StephenTozer added a comment.Aug 21 2023, 10:08 AM

End of day for me, so reverting now - still seeing some tool substitution errors on the SIE buildbot that don't reproduce locally, and the optnone-vectors-and-functions failure seems quite opaque - I might have the solution, but it'll wait until tomorrow to go up.

StephenTozer added a comment.Sep 6 2023, 7:16 AM

Applying this patch again - if there are green dragon errors, at this point I suspect there may some opaque configuration issue on the buildbot (not necessarily an error, but not present on other systems), as the command line should theoretically be identical. Since this patch is large and touches a lot of files, I'd prefer to mark any subsequently failing tests as XFAILs and investigate post-commit to prevent the patch from repeatedly landing and reverting. Open to any principled or practical objections to this!

aprantl added a subscriber: aprantl.Sep 8 2023, 2:48 PM

@StephenTozer Yes, there are green dragon errors. It looks like -lstdc++ is hardcoded. On Darwin we usually only have libc++. Could you make that configurable?

https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/59897/consoleFull#12109776838254eaf0-7326-4999-85b0-388101f2d404

rastogishubham mentioned this in rG37a20cc68f54: XFAIL dexter tests that broke greendragon..Sep 8 2023, 3:51 PM
rastogishubham added a subscriber: rastogishubham.Sep 8 2023, 3:52 PM

@StephenTozer Broken greendragon tests temporarily XFAILed with 37a20cc68f545647e614c5ba4ae311dc3fd277e9

StephenTozer added a comment.Sep 11 2023, 3:11 AM
In D151465#4642321, @aprantl wrote:

@StephenTozer Yes, there are green dragon errors. It looks like -lstdc++ is hardcoded. On Darwin we usually only have libc++. Could you make that configurable?

https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/59897/consoleFull#12109776838254eaf0-7326-4999-85b0-388101f2d404

Looking into this, apologies for not catching the failures myself!

I see that one of the tests, aggregate-indirect-arg.cpp, has -lstdc++ hardcoded in the test line; this was present prior to this patch though (specified as an --ldflags argument to Dexter), and none of the other tests should have any new/different flags applied to them. Is that confirmed to be the cause of the errors for the other tests? If so, it shouldn't be too hard to create a lit substitution for the command line that passes the right linker flag, but just want to verify whether there are other errors in place.

Revision Contents

PathSize
cross-project-tests/
debuginfo-tests/
dexter-tests/
4 lines
5 lines
6 lines
3 lines
4 lines
5 lines
4 lines
4 lines
11 lines
memvars/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
8 lines
4 lines
8 lines
4 lines
8 lines
8 lines
8 lines
4 lines
4 lines
4 lines
dexter/
64 lines
dex/
builder/
1 line
scripts/
posix/
windows/
command/
commands/
1 line
1 line
1 line
debugger/
DebuggerControllers/
1 line
1 line
visualstudio/
1 line
dextIR/
3 lines
1 line
tools/
2 lines
67 lines
clang_opt_bisect/
test/
43 lines
utils/
windows/
1 line
feature_tests/
commands/
penalty/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
perfect/
3 lines
dex_declare_address/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
dex_declare_file/
dex_and_source/
3 lines
precompiled_binary/
2 lines
windows_noncanonical_path/
2 lines
dex_finish_test/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
expect_step_kind/
3 lines
3 lines
3 lines
3 lines
3 lines
11 lines
3 lines
3 lines
float_range_watch/
3 lines
3 lines
3 lines
3 lines
limit_steps/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
subtools/
clang-opt-bisect/
help/
1 line
test/
3 lines
5 lines
3 lines
5 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
3 lines
5 lines
3 lines
6 lines
3 lines
3 lines
5 lines
34 lines

Diff 552010

cross-project-tests/debuginfo-tests/dexter-tests/aggregate-indirect-arg.cpp

// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: %clang -O0 -g -lstdc++ %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' --cflags "-O0 -g" \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --ldflags="-lstdc++" -- %s
// Radar 8945514 // Radar 8945514
class SVal { class SVal {
public: public:
~SVal() {} ~SVal() {}
const void* Data; const void* Data;
unsigned Kind; unsigned Kind;
}; };
Show All 30 Lines

cross-project-tests/debuginfo-tests/dexter-tests/asan-deque.cpp

// REQUIRES: !asan, compiler-rt, lldb // REQUIRES: !asan, compiler-rt, lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// Zorg configures the ASAN stage2 bots to not build the asan // Zorg configures the ASAN stage2 bots to not build the asan
// compiler-rt. Only run this test on non-asanified configurations. // compiler-rt. Only run this test on non-asanified configurations.
// UNSUPPORTED: apple-lldb-pre-1000 // UNSUPPORTED: apple-lldb-pre-1000
// XFAIL: lldb // XFAIL: lldb
// lldb-8, even outside of dexter, will sometimes trigger an asan fault in // lldb-8, even outside of dexter, will sometimes trigger an asan fault in
// the debugged process and generally freak out. // the debugged process and generally freak out.
// RUN: %clang -O1 -glldb -fsanitize=address -arch x86_64 %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "-O1 -glldb -fsanitize=address -arch x86_64" \
// RUN: --ldflags="-fsanitize=address" -- %s
#include <deque> #include <deque>
struct A { struct A {
int a; int a;
A(int a) : a(a) {} A(int a) : a(a) {}
A() : a(0) {} A() : a(0) {}
}; };
Show All 26 Lines

cross-project-tests/debuginfo-tests/dexter-tests/asan.c

// REQUIRES: !asan, compiler-rt, lldb // REQUIRES: !asan, compiler-rt, lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// Zorg configures the ASAN stage2 bots to not build the asan // Zorg configures the ASAN stage2 bots to not build the asan
// compiler-rt. Only run this test on non-asanified configurations. // compiler-rt. Only run this test on non-asanified configurations.
// //
// RUN: %clang --driver-mode=gcc -O0 -glldb -fblocks -arch x86_64 \
// RUN: -fsanitize=address %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang-c' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "--driver-mode=gcc -O0 -glldb -fblocks -arch x86_64 \
// RUN: -fsanitize=address" --ldflags="-fsanitize=address" -- %s
struct S { struct S {
int a[8]; int a[8];
}; };
int f(struct S s, unsigned i) { int f(struct S s, unsigned i) {
return s.a[i]; // DexLabel('asan') return s.a[i]; // DexLabel('asan')
} }
Show All 12 Lines

cross-project-tests/debuginfo-tests/dexter-tests/ctor.cpp

// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: %clang -O0 -glldb %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' --cflags "-O0 -glldb" -- %s // RUN: --binary %t --debugger 'lldb' -- %s
class A { class A {
public: public:
A() : zero(0), data(42) { // DexLabel('ctor_start') A() : zero(0), data(42) { // DexLabel('ctor_start')
} }
private: private:
int zero; int zero;
int data; int data;
Show All 23 Lines

cross-project-tests/debuginfo-tests/dexter-tests/dbg-arg.c

// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// This test case checks debug info during register moves for an argument. // This test case checks debug info during register moves for an argument.
// RUN: %clang -m64 -mllvm -fast-isel=false -g %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder clang-c --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "-m64 -mllvm -fast-isel=false -g" -- %s
// //
// Radar 8412415 // Radar 8412415
struct _mtx struct _mtx
{ {
long unsigned int ptr; long unsigned int ptr;
int waiters; int waiters;
struct { struct {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter-tests/deferred_globals.cpp

// Purpose: // Purpose:
// Ensure that debug information for a local variable does not hide // Ensure that debug information for a local variable does not hide
// a global definition that has the same name. // a global definition that has the same name.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %clang -O0 -g %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -v -- %s
// RUN: --cflags "-g -O0" -v -- %s
const int d = 100; const int d = 100;
extern int foo(); extern int foo();
int main() { int main() {
const int d = 4; const int d = 4;
const float e = 4; // DexLabel("main") const float e = 4; // DexLabel("main")
Show All 11 Lines

cross-project-tests/debuginfo-tests/dexter-tests/global-constant.cpp

// REQUIRES: system-windows // REQUIRES: system-windows
// //
// RUN: %dexter --fail-lt 1.0 -w --builder 'clang-cl_vs2015' \ // RUN: %clang-cl /Z7 /Zi %s -o %t
// RUN: --debugger 'dbgeng' --cflags '/Z7 /Zi' --ldflags '/Z7 /Zi' -- %s // RUN: %dexter --fail-lt 1.0 -w --binary %t --debugger 'dbgeng' -- %s
// Check that global constants have debug info. // Check that global constants have debug info.
const float TestPi = 3.14; const float TestPi = 3.14;
struct S { struct S {
static const char TestCharA = 'a'; static const char TestCharA = 'a';
}; };
enum TestEnum : int { enum TestEnum : int {
Show All 18 Lines

cross-project-tests/debuginfo-tests/dexter-tests/hello.c

// REQUIRES: system-windows // REQUIRES: system-windows
// //
// RUN: %dexter --fail-lt 1.0 -w --builder 'clang-cl_vs2015' \ // RUN: %clang-cl /Z7 /Zi %s -o %t
// RUN: --debugger 'dbgeng' --cflags '/Z7 /Zi' --ldflags '/Z7 /Zi' -- %s // RUN: %dexter --fail-lt 1.0 -w --binary %t --debugger 'dbgeng' -- %s
#include <stdio.h> #include <stdio.h>
int main() { int main() {
printf("hello world\n"); printf("hello world\n");
int x = 42; int x = 42;
__debugbreak(); // DexLabel('stop') __debugbreak(); // DexLabel('stop')
} }
// DexExpectWatchValue('x', 42, on_line=ref('stop')) // DexExpectWatchValue('x', 42, on_line=ref('stop'))

cross-project-tests/debuginfo-tests/dexter-tests/inline-line-gap.cpp

// REQUIRES: system-windows // REQUIRES: system-windows
// //
// RUN: %dexter --fail-lt 1.0 -w --builder 'clang-cl_vs2015' \ // RUN: %clang-cl /Od /Z7 /Zi %s -o %t
// RUN: --debugger 'dbgeng' --cflags '/Od /Z7 /Zi' \ // RUN: %dexter --fail-lt 1.0 -w --binary %t --debugger 'dbgeng' -- %s
// RUN: --ldflags '/Od /Z7 /Zi' -- %s
// //
// RUN: %dexter --fail-lt 1.0 -w --builder 'clang-cl_vs2015' \ // RUN: %clang-cl /O2 /Z7 /Zi %s -o %t
// RUN: --debugger 'dbgeng' --cflags '/O2 /Z7 /Zi' \ // RUN: %dexter --fail-lt 1.0 -w --binary %t \
// RUN: --ldflags '/O2 /Z7 /Zi' -- %s // RUN: --debugger 'dbgeng' -- %s
// This code is structured to have an early exit with an epilogue in the middle // This code is structured to have an early exit with an epilogue in the middle
// of the function, which creates a gap between the beginning of the inlined // of the function, which creates a gap between the beginning of the inlined
// code region and the end. Previously, this confused cdb. // code region and the end. Previously, this confused cdb.
volatile bool shutting_down_ = true; volatile bool shutting_down_ = true;
volatile bool tearing_down_ = true; volatile bool tearing_down_ = true;
Show All 30 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/bitcast.c

// XFAIL:* // XFAIL:*
//// Suboptimal coverage, see description below. //// Suboptimal coverage, see description below.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 1.0 -w --debugger lldb \ // RUN: %clang -O3 -glldb %s -o %t
// RUN: --builder 'clang-c' --cflags "-O3 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --debugger lldb --binary %t -- %s
//// Adapted from https://bugs.llvm.org/show_bug.cgi?id=34136#c1 //// Adapted from https://bugs.llvm.org/show_bug.cgi?id=34136#c1
//// LowerDbgDeclare has since been updated to look through bitcasts. We still //// LowerDbgDeclare has since been updated to look through bitcasts. We still
//// get suboptimal coverage at the beginning of 'main' though. For each local, //// get suboptimal coverage at the beginning of 'main' though. For each local,
//// LowerDbgDeclare inserts a dbg.value and a dbg.value+DW_OP_deref before the //// LowerDbgDeclare inserts a dbg.value and a dbg.value+DW_OP_deref before the
//// store (after the call to 'getint') and the call to 'alias' respectively. //// store (after the call to 'getint') and the call to 'alias' respectively.
//// The first dbg.value describes the result of the 'getint' call, eventually //// The first dbg.value describes the result of the 'getint' call, eventually
//// becoming a register location. The second points back into the stack //// becoming a register location. The second points back into the stack
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/const-branch.c

// XFAIL: !system-darwin || !target-aarch64 // XFAIL: !system-darwin || !target-aarch64
//// Suboptimal coverage, see inlined comments. //// Suboptimal coverage, see inlined comments.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 1.0 -w --debugger lldb \ // RUN: %clang -O3 -glldb %s -o %t
// RUN: --builder 'clang-c' --cflags "-O3 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --debugger lldb --binary %t -- %s
//// Adapted from https://bugs.llvm.org/show_bug.cgi?id=34136#c4 //// Adapted from https://bugs.llvm.org/show_bug.cgi?id=34136#c4
int g; int g;
__attribute__((__noinline__)) __attribute__((__noinline__))
void esc(int* p) { void esc(int* p) {
g = *p; g = *p;
Show All 37 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/ctrl-flow.c

// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 1.0 -w --debugger lldb \ // RUN: %clang -O2 -glldb %s -o %t
// RUN: --builder clang-c --cflags "-O2 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --debugger lldb --binary %t -- %s
//// Check that we give good locations to a variable ('local') which is escaped //// Check that we give good locations to a variable ('local') which is escaped
//// down some control paths and not others. This example is handled well currently. //// down some control paths and not others. This example is handled well currently.
int g; int g;
__attribute__((__noinline__)) __attribute__((__noinline__))
void leak(int *ptr) { void leak(int *ptr) {
g = *ptr; g = *ptr;
Show All 22 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/implicit-ptr.c

// XFAIL:* // XFAIL:*
//// We don't yet support DW_OP_implicit_pointer in llvm. //// We don't yet support DW_OP_implicit_pointer in llvm.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 1.0 -w --debugger lldb \ // RUN: %clang -O3 -glldb %s -o %t
// RUN: --builder 'clang-c' --cflags "-O3 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --debugger lldb --binary %t -- %s
//// Check that 'param' in 'fun' can be read throughout, and that 'pa' and 'pb' //// Check that 'param' in 'fun' can be read throughout, and that 'pa' and 'pb'
//// can be dereferenced in the debugger even if we can't provide the pointer //// can be dereferenced in the debugger even if we can't provide the pointer
//// value itself. //// value itself.
int globa; int globa;
int globb; int globb;
Show All 30 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/inline-escaping-function.c

// XFAIL: * // XFAIL: *
// Incorrect location for variable "param", see PR48719. // Incorrect location for variable "param", see PR48719.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 1.0 -w --debugger lldb \ // RUN: %clang -O3 -glldb %s -o %t
// RUN: --builder 'clang-c' --cflags "-O3 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --debugger lldb --binary %t -- %s
// 1. param is escaped by inlineme(&param) so it is not promoted by // 1. param is escaped by inlineme(&param) so it is not promoted by
// SROA/mem2reg. // SROA/mem2reg.
// 2. InstCombine's LowerDbgDeclare converts the dbg.declare to a set of // 2. InstCombine's LowerDbgDeclare converts the dbg.declare to a set of
// dbg.values. // dbg.values.
// 3. inlineme(&param) is inlined. // 3. inlineme(&param) is inlined.
// 4. SROA/mem2reg fully promotes param. It does not insert a dbg.value after the // 4. SROA/mem2reg fully promotes param. It does not insert a dbg.value after the
// PHI it inserts which merges the values out of entry and if.then in the // PHI it inserts which merges the values out of entry and if.then in the
Show All 30 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/inlining-dse.c

// XFAIL:* // XFAIL:*
//// See PR47946. //// See PR47946.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 1.0 -w --debugger lldb \ // RUN: %clang -O2 -glldb %s -o %t
// RUN: --builder clang-c --cflags "-O2 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --debugger lldb --binary %t -- %s
// //
//// Check that once-escaped variable 'param' can still be read after we //// Check that once-escaped variable 'param' can still be read after we
//// perform inlining + mem2reg, and that we see the DSE'd value 255. //// perform inlining + mem2reg, and that we see the DSE'd value 255.
int g; int g;
__attribute__((__always_inline__)) __attribute__((__always_inline__))
static void use(int* p) { static void use(int* p) {
Show All 37 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/inlining.c

// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 1.0 -w --debugger lldb \ // RUN: %clang -O2 -glldb %s -o %t
// RUN: --builder clang-c --cflags "-O2 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --debugger lldb --binary %t -- %s
// //
//// Check that the once-escaped variable 'param' can still be read after //// Check that the once-escaped variable 'param' can still be read after
//// we perform inlining + mem2reg. See D89810 and D85555. //// we perform inlining + mem2reg. See D89810 and D85555.
int g; int g;
__attribute__((__always_inline__)) __attribute__((__always_inline__))
static void use(int* p) { static void use(int* p) {
g = *p; g = *p;
Show All 14 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/loop.c

// XFAIL: * // XFAIL: *
//// Suboptimal coverage, see below. //// Suboptimal coverage, see below.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 1.0 -w --debugger lldb \ // RUN: %clang -O3 -glldb %s -o %t
// RUN: --builder 'clang-c' --cflags "-O3 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --debugger lldb --binary %t -- %s
//// Check that escaped local 'param' in function 'fun' has sensible debug info //// Check that escaped local 'param' in function 'fun' has sensible debug info
//// after the escaping function 'use' gets arg promotion (int* -> int). Currently //// after the escaping function 'use' gets arg promotion (int* -> int). Currently
//// we lose track of param after the loop header. //// we lose track of param after the loop header.
int g = 0; int g = 0;
//// A no-inline, read-only function with internal linkage is a good candidate //// A no-inline, read-only function with internal linkage is a good candidate
//// for arg promotion. //// for arg promotion.
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/merged-store.c

// XFAIL: * // XFAIL: *
// Incorrect location for variable "parama", see PR48719. // Incorrect location for variable "parama", see PR48719.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 1.0 -w --debugger lldb \ // RUN: %clang -O3 -glldb %s -o %t
// RUN: --builder 'clang-c' --cflags "-O3 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --debugger lldb --binary %t -- %s
// 1. parama is escaped by esc(&parama) so it is not promoted by // 1. parama is escaped by esc(&parama) so it is not promoted by
// SROA/mem2reg. // SROA/mem2reg.
// 2. InstCombine's LowerDbgDeclare converts the dbg.declare to a set of // 2. InstCombine's LowerDbgDeclare converts the dbg.declare to a set of
// dbg.values (tracking the stored SSA values). // dbg.values (tracking the stored SSA values).
// 3. InstCombine replaces the two stores to parama's alloca (the initial // 3. InstCombine replaces the two stores to parama's alloca (the initial
// parameter register store in entry and the assignment in if.then) with a // parameter register store in entry and the assignment in if.then) with a
// PHI+store in the common sucessor. // PHI+store in the common sucessor.
Show All 28 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/ptr-to.c

// XFAIL:* // XFAIL:*
//// Currently debug info for 'local' behaves, but 'plocal' dereferences to //// Currently debug info for 'local' behaves, but 'plocal' dereferences to
//// the incorrect value 0xFF after the call to esc. //// the incorrect value 0xFF after the call to esc.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 1.0 -w --debugger lldb \ // RUN: %clang -O2 -glldb %s -o %t
// RUN: --builder clang-c --cflags "-O2 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --debugger lldb --binary %t -- %s
// //
//// Check that a pointer to a variable living on the stack dereferences to the //// Check that a pointer to a variable living on the stack dereferences to the
//// variable value. //// variable value.
int glob; int glob;
__attribute__((__noinline__)) __attribute__((__noinline__))
void esc(int* p) { void esc(int* p) {
glob = *p; glob = *p;
Show All 19 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/struct-dse.c

// XFAIL:* // XFAIL:*
//// Currently, LowerDbgDeclare doesn't lower dbg.declares pointing at allocas //// Currently, LowerDbgDeclare doesn't lower dbg.declares pointing at allocas
//// for structs. //// for structs.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 1.0 -w --debugger lldb \ // RUN: %clang -O2 -glldb %s -o %t
// RUN: --builder clang-c --cflags "-O2 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --debugger lldb --binary %t -- %s
// //
//// Check debug-info for the escaped struct variable num is reasonable. //// Check debug-info for the escaped struct variable num is reasonable.
#include <stdio.h> #include <stdio.h>
struct Nums { int a, b, c; }; struct Nums { int a, b, c; };
struct Nums glob; struct Nums glob;
__attribute__((__noinline__)) __attribute__((__noinline__))
void esc(struct Nums* nums) { void esc(struct Nums* nums) {
Show All 17 Lines

cross-project-tests/debuginfo-tests/dexter-tests/memvars/unused-merged-value.c

// Location for variable "parama" optimized out. // Location for variable "parama" optimized out.
// Previously it would carry incorrect location // Previously it would carry incorrect location
// information in debug-info, see PR48719. // information in debug-info, see PR48719.
// Now, the location is simply not emitted. // Now, the location is simply not emitted.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %dexter --fail-lt 0.1 -w --debugger lldb \ // RUN: %clang -O3 -glldb %s -o %t
// RUN: --builder 'clang-c' --cflags "-O3 -glldb" -- %s // RUN: %dexter --fail-lt 0.1 -w --debugger lldb --binary %t -- %s
// See NOTE at end for more info about the RUN command. // See NOTE at end for more info about the RUN command.
// 1. SROA/mem2reg fully promotes parama. // 1. SROA/mem2reg fully promotes parama.
// 2. parama's value in the final block is the merge of values for it coming // 2. parama's value in the final block is the merge of values for it coming
// out of entry and if.then. If the variable were used later in the function // out of entry and if.then. If the variable were used later in the function
// mem2reg would insert a PHI here and add a dbg.value to track the merged // mem2reg would insert a PHI here and add a dbg.value to track the merged
// value in debug info. Because it is not used there is no PHI (the merged // value in debug info. Because it is not used there is no PHI (the merged
// value is implicit) and subsequently no dbg.value. // value is implicit) and subsequently no dbg.value.
Show All 29 Lines

cross-project-tests/debuginfo-tests/dexter-tests/namespace.cpp

// Purpose: // Purpose:
// Ensure that the debug information for a global variable includes // Ensure that the debug information for a global variable includes
// namespace information. // namespace information.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// RUN: %clang -g -O0 %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -v -- %s
// RUN: --cflags "-g -O0" -v -- %s
#include <stdio.h> #include <stdio.h>
namespace monkey { namespace monkey {
const int ape = 32; const int ape = 32;
} }
int main() { int main() {
printf("hello %d\n", monkey::ape); // DexLabel('main') printf("hello %d\n", monkey::ape); // DexLabel('main')
return 0; return 0;
} }
// DexExpectWatchValue('monkey::ape', 32, on_line=ref('main')) // DexExpectWatchValue('monkey::ape', 32, on_line=ref('main'))

cross-project-tests/debuginfo-tests/dexter-tests/nrvo-string.cpp

// Purpose: // Purpose:
// This ensures that DW_OP_deref is inserted when necessary, such as when // This ensures that DW_OP_deref is inserted when necessary, such as when
// NRVO of a string object occurs in C++. // NRVO of a string object occurs in C++.
// //
// REQUIRES: !asan, compiler-rt, lldb // REQUIRES: !asan, compiler-rt, lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// Zorg configures the ASAN stage2 bots to not build the asan // Zorg configures the ASAN stage2 bots to not build the asan
// compiler-rt. Only run this test on non-asanified configurations. // compiler-rt. Only run this test on non-asanified configurations.
// //
// RUN: %clang -O0 -glldb -fno-exceptions %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "-O0 -glldb -fno-exceptions" -- %s
// //
// RUN: %clang -O1 -glldb -fno-exceptions %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "-O1 -glldb -fno-exceptions" -- %s
// //
// PR34513 // PR34513
volatile int sideeffect = 0; volatile int sideeffect = 0;
void __attribute__((noinline)) stop() { sideeffect++; } void __attribute__((noinline)) stop() { sideeffect++; }
struct string { struct string {
string() {} string() {}
string(int i) : i(i) {} string(int i) : i(i) {}
Show All 32 Lines

cross-project-tests/debuginfo-tests/dexter-tests/nrvo.cpp

// This ensures that DW_OP_deref is inserted when necessary, such as when NRVO // This ensures that DW_OP_deref is inserted when necessary, such as when NRVO
// of a string object occurs in C++. // of a string object occurs in C++.
// //
// REQUIRES: system-windows // REQUIRES: system-windows
// //
// RUN: %dexter --fail-lt 1.0 -w --builder 'clang-cl_vs2015' \ // RUN: %clang-cl /Z7 /Zi %s -o %t
// RUN: --debugger 'dbgeng' --cflags '/Z7 /Zi' --ldflags '/Z7 /Zi' -- %s // RUN: %dexter --fail-lt 1.0 -w --binary %t --debugger 'dbgeng' -- %s
struct string { struct string {
string() {} string() {}
string(int i) : i(i) {} string(int i) : i(i) {}
~string() {} ~string() {}
int i = 0; int i = 0;
}; };
string get_string() { string get_string() {
Show All 25 Lines

cross-project-tests/debuginfo-tests/dexter-tests/optnone-fastmath.cpp

// RUN: %clang -O2 -ffast-math -g %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "-ffast-math -O2 -g" -- %s // RUN: %clang -O0 -ffast-math -g %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "-ffast-math -O0 -g" -- %s
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
//// Check that the debugging experience with __attribute__((optnone)) at O2 //// Check that the debugging experience with __attribute__((optnone)) at O2
//// matches O0. Test scalar floating point arithmetic with -ffast-math. //// matches O0. Test scalar floating point arithmetic with -ffast-math.
//// Example of strength reduction. //// Example of strength reduction.
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter-tests/optnone-loops.cpp

// Purpose: // Purpose:
// Verifies that the debugging experience of loops marked optnone is as expected. // Verifies that the debugging experience of loops marked optnone is as expected.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// RUN: %clang -O2 -g %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "-O2 -g" -- %s
// A simple loop of assignments. // A simple loop of assignments.
// With optimization level > 0 the compiler reorders basic blocks // With optimization level > 0 the compiler reorders basic blocks
// based on the basic block frequency analysis information. // based on the basic block frequency analysis information.
// This also happens with optnone and it shouldn't. // This also happens with optnone and it shouldn't.
// This is not affecting debug info so it is a minor limitation. // This is not affecting debug info so it is a minor limitation.
// Basic block placement based on the block frequency analysis // Basic block placement based on the block frequency analysis
// is normally done to improve i-Cache performances. // is normally done to improve i-Cache performances.
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter-tests/optnone-simple-functions.cpp

// RUN: %clang -O2 -g %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "-O2 -g" -- %s // RUN: %clang -O0 -g %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "-O0 -g" -- %s
// REQUIRES: lldb, D136396 // REQUIRES: lldb, D136396
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
//// Check that the debugging experience with __attribute__((optnone)) at O2 //// Check that the debugging experience with __attribute__((optnone)) at O2
//// matches O0. Test simple functions performing simple arithmetic //// matches O0. Test simple functions performing simple arithmetic
//// operations and small loops. //// operations and small loops.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter-tests/optnone-struct-and-methods.cpp

// RUN: %clang++ -O2 -g %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -v -- %s
// RUN: --cflags "-g -O2" -v -- %s // RUN: %clang++ -O0 -g %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "-g -O0" -- %s
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
//// Check that the debugging experience with __attribute__((optnone)) at O2 //// Check that the debugging experience with __attribute__((optnone)) at O2
//// matches O0. Test simple structs and methods. //// matches O0. Test simple structs and methods.
long a_global_ptr[] = { 0xCAFEBABEL, 0xFEEDBEEFL }; long a_global_ptr[] = { 0xCAFEBABEL, 0xFEEDBEEFL };
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter-tests/optnone-vectors-and-functions.cpp

// RUN: %clang -O2 -g %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -v -- %s
// RUN: --cflags "-g -O2" -v -- %s // RUN: %clang -O0 -g %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder 'clang' --debugger 'lldb' \ // RUN: --binary %t --debugger 'lldb' -- %s
// RUN: --cflags "-g -O0" -- %s
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
//// Check that the debugging experience with __attribute__((optnone)) at O2 //// Check that the debugging experience with __attribute__((optnone)) at O2
//// matches O0. Test simple template functions performing simple arithmetic //// matches O0. Test simple template functions performing simple arithmetic
//// vector operations and trivial loops. //// vector operations and trivial loops.
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter-tests/realigned-frame.cpp

// REQUIRES: system-windows // REQUIRES: system-windows
// //
// RUN: %dexter --fail-lt 1.0 -w --builder 'clang-cl_vs2015' \ // RUN: %clang-cl /Z7 /Zi %s -o %t
// RUN: --debugger 'dbgeng' --cflags '/Z7 /Zi' --ldflags '/Z7 /Zi' -- %s // RUN: %dexter --fail-lt 1.0 -w --binary %t --debugger 'dbgeng' -- %s
// From https://llvm.org/pr38857, where we had issues with stack realignment. // From https://llvm.org/pr38857, where we had issues with stack realignment.
struct Foo { struct Foo {
int x = 42; int x = 42;
int __declspec(noinline) foo(); int __declspec(noinline) foo();
void __declspec(noinline) bar(int *a, int *b, double *c); void __declspec(noinline) bar(int *a, int *b, double *c);
}; };
Show All 27 Lines

cross-project-tests/debuginfo-tests/dexter-tests/stack-var.c

// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %clang -O -glldb %s -o %t
// RUN: --builder clang-c --debugger 'lldb' --cflags "-O -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --binary %t --debugger 'lldb' -- %s
void __attribute__((noinline, optnone)) bar(int *test) {} void __attribute__((noinline, optnone)) bar(int *test) {}
int main() { int main() {
int test; int test;
test = 23; test = 23;
bar(&test); // DexLabel('before_bar') bar(&test); // DexLabel('before_bar')
return test; // DexLabel('after_bar') return test; // DexLabel('after_bar')
} }
// DexExpectWatchValue('test', '23', on_line=ref('before_bar')) // DexExpectWatchValue('test', '23', on_line=ref('before_bar'))
// DexExpectWatchValue('test', '23', on_line=ref('after_bar')) // DexExpectWatchValue('test', '23', on_line=ref('after_bar'))

cross-project-tests/debuginfo-tests/dexter-tests/vla.c

// This test case verifies the debug location for variable-length arrays. // This test case verifies the debug location for variable-length arrays.
// REQUIRES: lldb // REQUIRES: lldb
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %clang -O0 -glldb %s -o %t
// RUN: --builder clang-c --debugger 'lldb' --cflags "-O0 -glldb" -- %s // RUN: %dexter --fail-lt 1.0 -w --binary %t --debugger 'lldb' -- %s
void init_vla(int size) { void init_vla(int size) {
int i; int i;
int vla[size]; int vla[size];
for (i = 0; i < size; i++) for (i = 0; i < size; i++)
vla[i] = size-i; vla[i] = size-i;
vla[0] = size; // DexLabel('end_init') vla[0] = size; // DexLabel('end_init')
} }
Show All 9 Lines

cross-project-tests/debuginfo-tests/dexter/README.md

Show All 27 Lines
### clang ### clang
DExTer is current compatible with 'clang' and 'clang-cl' compiler drivers. The compiler must be available for DExTer, for example the following command should successfully build a runnable executable. DExTer is current compatible with 'clang' and 'clang-cl' compiler drivers. The compiler must be available for DExTer, for example the following command should successfully build a runnable executable.
<compiler-executable> tests/nostdlib/fibonacci/test.cpp <compiler-executable> tests/nostdlib/fibonacci/test.cpp
## Running a test case ## Running a test case
The following DExTer commands build the test.cpp from the tests/nostdlib/fibonacci directory and quietly runs it on the Visual Studio debugger, reporting the debug experience heuristic. The first command builds with no optimizations (/Od) and scores 1.0000. The second command builds with optimizations (/Ox) and scores 0.2832 which suggests a worse debugging experience. The following commands build fibonacci.cpp from the tests/nostdlib directory and run it in LLDB, reporting the debug experience heuristic. The first pair of commands build with no optimizations (-O0) and score 1.0000. The second pair of commands build with optimizations (-O2) and score 0.2832 which suggests a worse debugging experience.
dexter.py test --builder clang-cl_vs2015 --debugger vs2017 --cflags="/Od /Zi" --ldflags="/Zi" -- tests/nostdlib/fibonacci clang -O0 -g tests/nostdlib/fibonacci.cpp -o tests/nostdlib/fibonacci/test
fibonacci = (1.0000) dexter.py test --binary tests/nostdlib/fibonacci/test --debugger lldb -- tests/nostdlib/fibonacci/test.cpp
test.cpp = (1.0000)
dexter.py test --builder clang-cl_vs2015 --debugger vs2017 --cflags="/Ox /Zi" --ldflags="/Zi" -- tests/nostdlib/fibonacci
fibonacci = (0.2832) clang -O2 -g tests/nostdlib/fibonacci/test.cpp -o tests/nostdlib/fibonacci/test
dexter.py test --binary tests/nostdlib/fibonacci/test --debugger lldb -- tests/nostdlib/fibonacci/test.cpp
test.cpp = (0.2832)
## An example test case ## An example test case
The sample test case (tests/nostdlib/fibonacci) looks like this: The sample test case (tests/nostdlib/fibonacci) looks like this:
1. #ifdef _MSC_VER 1. #ifdef _MSC_VER
2. # define DEX_NOINLINE __declspec(noinline) 2. # define DEX_NOINLINE __declspec(noinline)
3. #else 3. #else
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
to step into a file outside of the test directory. to step into a file outside of the test directory.
[1]: Commands.md#DexLabel [1]: Commands.md#DexLabel
[2]: Commands.md#DexExpectWatchValue [2]: Commands.md#DexExpectWatchValue
[3]: Commands.md#DexExpectStepKind [3]: Commands.md#DexExpectStepKind
## Detailed DExTer reports ## Detailed DExTer reports
Running the command below launches the tests/nostdlib/fibonacci test case in DExTer, using clang-cl as the compiler, Visual Studio 2017 as the debugger, and producing a detailed report: Running the command below launches the tests/nostdlib/fibonacci test case in DExTer, using LLDB as the debugger and producing a detailed report:
$ dexter.py test --builder clang-cl_vs2015 --debugger vs2017 --cflags="/Ox /Zi" --ldflags="/Zi" -v -- tests/nostdlib/fibonacci $ dexter.py test --vs-solution clang-cl_vs2015 --debugger vs2017 --cflags="/Ox /Zi" --ldflags="/Zi" -v -- tests/nostdlib/fibonacci
The detailed report is enabled by `-v` and shows a breakdown of the information from each debugger step. For example: The detailed report is enabled by `-v` and shows a breakdown of the information from each debugger step. For example:
fibonacci = (0.2832) fibonacci = (0.2832)
## BEGIN ## ## BEGIN ##
[1, "main", "c:\\dexter\\tests\\nostdlib\\fibonacci\\test.cpp", 23, 1, "BREAKPOINT", "FUNC", {}] [1, "main", "c:\\dexter\\tests\\nostdlib\\fibonacci\\test.cpp", 23, 1, "BREAKPOINT", "FUNC", {}]
[2, "main", "c:\\dexter\\tests\\nostdlib\\fibonacci\\test.cpp", 24, 1, "BREAKPOINT", "VERTICAL_FORWARD", {}] [2, "main", "c:\\dexter\\tests\\nostdlib\\fibonacci\\test.cpp", 24, 1, "BREAKPOINT", "VERTICAL_FORWARD", {}]
▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Lines test.cpp:15-18 [first] [9/21]
step 17 (Variable is optimized away and not available.) step 17 (Variable is optimized away and not available.)
step 20 (Variable is optimized away and not available.) step 20 (Variable is optimized away and not available.)
step 23 (Variable is optimized away and not available.) step 23 (Variable is optimized away and not available.)
shows that for `first` the expected values 0, 1, 2 and 3 were seen, 5 was not. On some steps the variable was reported as being optimized away. shows that for `first` the expected values 0, 1, 2 and 3 were seen, 5 was not. On some steps the variable was reported as being optimized away.
## Writing new test cases ## Writing new test cases
Each test requires a `test.cfg` file. Currently the contents of this file are not read, but its presence is used to determine the root directory of a test. In the future, configuration variables for the test such as supported language modes may be stored in this file. Use the various [commands](Commands.md) to encode debugging expectations. Each test can be either embedded within the source file using comments or included as a separate file with the .dex extension. Dexter does not include support for building test cases, although if a Visual Studio Solution (.sln) is used as the test file, VS will build the program as part of launching a debugger session if it has not already been built.
## Additional tools
For clang-based compilers, the `clang-opt-bisect` tool can be used to get a breakdown of which LLVM passes may be contributing to debugging experience issues. For example:
$ dexter.py clang-opt-bisect tests/nostdlib/fibonacci --builder clang-cl --debugger vs2017 --cflags="/Ox /Zi" --ldflags="/Zi"
pass 1/211 = (1.0000) (0.0000) [Simplify the CFG on function (?Fibonacci@@YAXHAEAH@Z)]
pass 2/211 = (0.7611) (-0.2389) [SROA on function (?Fibonacci@@YAXHAEAH@Z)]
pass 3/211 = (0.7611) (0.0000) [Early CSE on function (?Fibonacci@@YAXHAEAH@Z)]
pass 4/211 = (0.7611) (0.0000) [Simplify the CFG on function (main)]
pass 5/211 = (0.7611) (0.0000) [SROA on function (main)]
pass 6/211 = (0.7611) (0.0000) [Early CSE on function (main)]
pass 7/211 = (0.7611) (0.0000) [Infer set function attributes on module (c:\dexter\tests\fibonacci\test.cpp)]
pass 8/211 = (0.7611) (0.0000) [Interprocedural Sparse Conditional Constant Propagation on module (c:\dexter\tests\fibonacci\test.cpp)]
pass 9/211 = (0.7611) (0.0000) [Called Value Propagation on module (c:\dexter\tests\fibonacci\test.cpp)]
pass 10/211 = (0.7611) (0.0000) [Global Variable Optimizer on module (c:\dexter\tests\fibonacci\test.cpp)]
pass 11/211 = (0.7611) (0.0000) [Promote Memory to Register on function (?Fibonacci@@YAXHAEAH@Z)]
pass 12/211 = (0.7611) (0.0000) [Promote Memory to Register on function (main)]
pass 13/211 = (0.7611) (0.0000) [Dead Argument Elimination on module (c:\dexter\tests\fibonacci\test.cpp)]
pass 14/211 = (0.7611) (0.0000) [Combine redundant instructions on function (?Fibonacci@@YAXHAEAH@Z)]
pass 15/211 = (0.7611) (0.0000) [Simplify the CFG on function (?Fibonacci@@YAXHAEAH@Z)]a
pass 16/211 = (0.7345) (-0.0265) [Combine redundant instructions on function (main)]
pass 17/211 = (0.7345) (0.0000) [Simplify the CFG on function (main)]
pass 18/211 = (0.7345) (0.0000) [Remove unused exception handling info on SCC (?Fibonacci@@YAXHAEAH@Z)]
pass 19/211 = (0.7345) (0.0000) [Function Integration/Inlining on SCC (?Fibonacci@@YAXHAEAH@Z)]
pass 20/211 = (0.7345) (0.0000) [Deduce function attributes on SCC (?Fibonacci@@YAXHAEAH@Z)]
pass 21/211 = (0.7345) (0.0000) [SROA on function (?Fibonacci@@YAXHAEAH@Z)]
pass 22/211 = (0.7345) (0.0000) [Early CSE w/ MemorySSA on function (?Fibonacci@@YAXHAEAH@Z)]
pass 23/211 = (0.7345) (0.0000) [Speculatively execute instructions if target has divergent branches on function (?Fibonacci@@YAXHAEAH@Z)]
pass 24/211 = (0.7345) (0.0000) [Jump Threading on function (?Fibonacci@@YAXHAEAH@Z)]
pass 25/211 = (0.7345) (0.0000) [Value Propagation on function (?Fibonacci@@YAXHAEAH@Z)]
pass 26/211 = (0.7345) (0.0000) [Simplify the CFG on function (?Fibonacci@@YAXHAEAH@Z)]
pass 27/211 = (0.7345) (0.0000) [Combine redundant instructions on function (?Fibonacci@@YAXHAEAH@Z)]
pass 28/211 = (0.7345) (0.0000) [Tail Call Elimination on function (?Fibonacci@@YAXHAEAH@Z)]
pass 29/211 = (0.7345) (0.0000) [Simplify the CFG on function (?Fibonacci@@YAXHAEAH@Z)]
pass 30/211 = (0.7345) (0.0000) [Reassociate expressions on function (?Fibonacci@@YAXHAEAH@Z)]
pass 31/211 = (0.8673) (0.1327) [Rotate Loops on loop]
pass 32/211 = (0.5575) (-0.3097) [Loop Invariant Code Motion on loop]
pass 33/211 = (0.5575) (0.0000) [Unswitch loops on loop]
pass 34/211 = (0.5575) (0.0000) [Simplify the CFG on function (?Fibonacci@@YAXHAEAH@Z)]
pass 35/211 = (0.5575) (0.0000) [Combine redundant instructions on function (?Fibonacci@@YAXHAEAH@Z)]
pass 36/211 = (0.5575) (0.0000) [Induction Variable Simplification on loop]
pass 37/211 = (0.5575) (0.0000) [Recognize loop idioms on loop]
<output-snipped>

cross-project-tests/debuginfo-tests/dexter/dex/builder/Builder.py

Show All 18 Linesdef _quotify(text):
if '"' in text or " " not in text: if '"' in text or " " not in text:
return text return text
return '"{}"'.format(text) return '"{}"'.format(text)
def _get_script_environment( def _get_script_environment(
source_files, compiler_options, linker_options, executable_file source_files, compiler_options, linker_options, executable_file
): ):
source_files = [_quotify(f) for f in source_files] source_files = [_quotify(f) for f in source_files]
object_files = [_quotify("{}.o".format(os.path.basename(f))) for f in source_files] object_files = [_quotify("{}.o".format(os.path.basename(f))) for f in source_files]
source_indexes = ["{:02d}".format(i + 1) for i in range(len(source_files))] source_indexes = ["{:02d}".format(i + 1) for i in range(len(source_files))]
env_variables = {} env_variables = {}
env_variables["SOURCE_INDEXES"] = " ".join(source_indexes) env_variables["SOURCE_INDEXES"] = " ".join(source_indexes)
env_variables["SOURCE_FILES"] = " ".join(source_files) env_variables["SOURCE_FILES"] = " ".join(source_files)
env_variables["OBJECT_FILES"] = " ".join(object_files) env_variables["OBJECT_FILES"] = " ".join(object_files)
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter/dex/builder/__init__.py

  • This file was deleted.
# DExTer : Debugging Experience Tester
# ~~~~~~ ~ ~~ ~ ~~
#
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
from dex.builder.Builder import run_external_build_script
from dex.builder.ParserOptions import add_builder_tool_arguments
from dex.builder.ParserOptions import handle_builder_tool_options

cross-project-tests/debuginfo-tests/dexter/dex/builder/scripts/posix/clang-c.sh

  • This file was deleted.
PropertyOld ValueNew Value
File Mode100755null
#!/usr/bin/env bash
set -e
if test -z "$PATHTOCLANG"; then
PATHTOCLANG=clang
fi
for INDEX in $SOURCE_INDEXES
do
CFLAGS=$(eval echo "\$COMPILER_OPTIONS_$INDEX")
SRCFILE=$(eval echo "\$SOURCE_FILE_$INDEX")
OBJFILE=$(eval echo "\$OBJECT_FILE_$INDEX")
$PATHTOCLANG -std=gnu11 -c $CFLAGS $SRCFILE -o $OBJFILE
done
$PATHTOCLANG $LINKER_OPTIONS $OBJECT_FILES -o $EXECUTABLE_FILE

cross-project-tests/debuginfo-tests/dexter/dex/builder/scripts/posix/clang.sh

  • This file was deleted.
PropertyOld ValueNew Value
File Mode100755null
#!/usr/bin/env bash
set -e
if test -z "$PATHTOCLANGPP"; then
PATHTOCLANGPP=clang++
fi
for INDEX in $SOURCE_INDEXES
do
CFLAGS=$(eval echo "\$COMPILER_OPTIONS_$INDEX")
SRCFILE=$(eval echo "\$SOURCE_FILE_$INDEX")
OBJFILE=$(eval echo "\$OBJECT_FILE_$INDEX")
$PATHTOCLANGPP -std=gnu++11 -c $CFLAGS $SRCFILE -o $OBJFILE
done
$PATHTOCLANGPP $LINKER_OPTIONS $OBJECT_FILES -o $EXECUTABLE_FILE

cross-project-tests/debuginfo-tests/dexter/dex/builder/scripts/posix/gcc.sh

  • This file was deleted.
PropertyOld ValueNew Value
File Mode100755null
#!/usr/bin/env bash
set -e
if test -z "$PATHTOGCC"; then
PATHTOGCC=gcc
fi
for INDEX in $SOURCE_INDEXES
do
CFLAGS=$(eval echo "\$COMPILER_OPTIONS_$INDEX")
SRCFILE=$(eval echo "\$SOURCE_FILE_$INDEX")
OBJFILE=$(eval echo "\$OBJECT_FILE_$INDEX")
$PATHTOGCC -std=gnu++11 -c $CFLAGS $SRCFILE -o $OBJFILE
done
$PATHTOGCC $LINKER_OPTIONS $OBJECT_FILES -o $EXECUTABLE_FILE

cross-project-tests/debuginfo-tests/dexter/dex/builder/scripts/windows/clang-cl_vs2015.bat

  • This file was deleted.
@echo OFF
setlocal EnableDelayedExpansion
call "%VS140COMNTOOLS%..\..\VC\bin\amd64\vcvars64.bat"
@echo OFF
setlocal EnableDelayedExpansion
for %%I in (%SOURCE_INDEXES%) do (
%PATHTOCLANGCL% /c !COMPILER_OPTIONS_%%I! !SOURCE_FILE_%%I! /Fo!OBJECT_FILE_%%I!
if errorlevel 1 goto :FAIL
)
%PATHTOCLANGCL% %LINKER_OPTIONS% %OBJECT_FILES% /Fe%EXECUTABLE_FILE%
if errorlevel 1 goto :FAIL
goto :END
:FAIL
echo FAILED
exit /B 1
:END
exit /B 0

cross-project-tests/debuginfo-tests/dexter/dex/builder/scripts/windows/clang.bat

  • This file was deleted.
@setlocal EnableDelayedExpansion
for %%I in (%SOURCE_INDEXES%) do (
%PATHTOCLANGPP% -fuse-ld=lld -c !COMPILER_OPTIONS_%%I! !SOURCE_FILE_%%I! -o !OBJECT_FILE_%%I!
if errorlevel 1 goto :FAIL
)
%PATHTOCLANGPP% -fuse-ld=lld %LINKER_OPTIONS% %OBJECT_FILES% -o %EXECUTABLE_FILE%
if errorlevel 1 goto :FAIL
goto :END
:FAIL
echo FAILED
exit /B 1
:END
exit /B 0

cross-project-tests/debuginfo-tests/dexter/dex/command/commands/DexDeclareAddress.py

Show All 9 Lines
import os import os
from pathlib import PurePath from pathlib import PurePath
from dex.command.CommandBase import CommandBase, StepExpectInfo from dex.command.CommandBase import CommandBase, StepExpectInfo
class DexDeclareAddress(CommandBase): class DexDeclareAddress(CommandBase):
def __init__(self, addr_name, expression, **kwargs): def __init__(self, addr_name, expression, **kwargs):
if not isinstance(addr_name, str): if not isinstance(addr_name, str):
raise TypeError("invalid argument type") raise TypeError("invalid argument type")
self.addr_name = addr_name self.addr_name = addr_name
self.expression = expression self.expression = expression
self.on_line = kwargs.pop("on_line") self.on_line = kwargs.pop("on_line")
self.hit_count = kwargs.pop("hit_count", 0) self.hit_count = kwargs.pop("hit_count", 0)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter/dex/command/commands/DexDeclareFile.py

# DExTer : Debugging Experience Tester # DExTer : Debugging Experience Tester
# ~~~~~~ ~ ~~ ~ ~~ # ~~~~~~ ~ ~~ ~ ~~
# #
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
"""Commmand sets the path for all following commands to 'declared_file'. """Commmand sets the path for all following commands to 'declared_file'.
""" """
from pathlib import PurePath from pathlib import PurePath
from dex.command.CommandBase import CommandBase from dex.command.CommandBase import CommandBase
class DexDeclareFile(CommandBase): class DexDeclareFile(CommandBase):
def __init__(self, declared_file): def __init__(self, declared_file):
if not isinstance(declared_file, str): if not isinstance(declared_file, str):
raise TypeError("invalid argument type") raise TypeError("invalid argument type")
# Use PurePath to create a cannonical platform path. # Use PurePath to create a cannonical platform path.
# TODO: keep paths as PurePath objects for 'longer' # TODO: keep paths as PurePath objects for 'longer'
self.declared_file = str(PurePath(declared_file)) self.declared_file = str(PurePath(declared_file))
super(DexDeclareFile, self).__init__() super(DexDeclareFile, self).__init__()
@staticmethod @staticmethod
def get_name(): def get_name():
return __class__.__name__ return __class__.__name__
def eval(self): def eval(self):
return self.declared_file return self.declared_file

cross-project-tests/debuginfo-tests/dexter/dex/command/commands/DexLabel.py

# DExTer : Debugging Experience Tester # DExTer : Debugging Experience Tester
# ~~~~~~ ~ ~~ ~ ~~ # ~~~~~~ ~ ~~ ~ ~~
# #
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
"""Command used to give a line in a test a named psuedonym. Every DexLabel has """Command used to give a line in a test a named psuedonym. Every DexLabel has
a line number and Label string component. a line number and Label string component.
""" """
from dex.command.CommandBase import CommandBase from dex.command.CommandBase import CommandBase
class DexLabel(CommandBase): class DexLabel(CommandBase):
def __init__(self, label, **kwargs): def __init__(self, label, **kwargs):
if not isinstance(label, str): if not isinstance(label, str):
raise TypeError("invalid argument type") raise TypeError("invalid argument type")
try: try:
self.on_line = kwargs.pop("on_line") self.on_line = kwargs.pop("on_line")
except KeyError: except KeyError:
# We cannot use self.lineno because it hasn't been set yet. # We cannot use self.lineno because it hasn't been set yet.
pass pass
Show All 18 Lines

cross-project-tests/debuginfo-tests/dexter/dex/debugger/DebuggerControllers/ConditionalController.py

Show First 20 Lines • Show All 158 Lines • ▼ Show 20 Lines def _run_debugger_custom(self, cmdline):
self.debugger.launch(cmdline) self.debugger.launch(cmdline)
time.sleep(self._pause_between_steps) time.sleep(self._pause_between_steps)
exit_desired = False exit_desired = False
timed_out = False timed_out = False
total_timeout = Timeout(self.context.options.timeout_total) total_timeout = Timeout(self.context.options.timeout_total)
while not self.debugger.is_finished: while not self.debugger.is_finished:
breakpoint_timeout = Timeout(self.context.options.timeout_breakpoint) breakpoint_timeout = Timeout(self.context.options.timeout_breakpoint)
while self.debugger.is_running and not timed_out: while self.debugger.is_running and not timed_out:
# Check to see whether we've timed out while we're waiting. # Check to see whether we've timed out while we're waiting.
if total_timeout.timed_out(): if total_timeout.timed_out():
self.context.logger.error( self.context.logger.error(
"Debugger session has been " "Debugger session has been "
f"running for {total_timeout.elapsed}s, timeout reached!" f"running for {total_timeout.elapsed}s, timeout reached!"
) )
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter/dex/debugger/DebuggerControllers/DefaultController.py

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines def _run_debugger_custom(self, cmdline):
for command_obj in chain.from_iterable(self.step_collection.commands.values()): for command_obj in chain.from_iterable(self.step_collection.commands.values()):
self.watches.update(command_obj.get_watches()) self.watches.update(command_obj.get_watches())
early_exit_conditions = self._get_early_exit_conditions() early_exit_conditions = self._get_early_exit_conditions()
timed_out = False timed_out = False
total_timeout = Timeout(self.context.options.timeout_total) total_timeout = Timeout(self.context.options.timeout_total)
max_steps = self.context.options.max_steps max_steps = self.context.options.max_steps
for _ in range(max_steps): for _ in range(max_steps):
breakpoint_timeout = Timeout(self.context.options.timeout_breakpoint) breakpoint_timeout = Timeout(self.context.options.timeout_breakpoint)
while self.debugger.is_running and not timed_out: while self.debugger.is_running and not timed_out:
# Check to see whether we've timed out while we're waiting. # Check to see whether we've timed out while we're waiting.
if total_timeout.timed_out(): if total_timeout.timed_out():
self.context.logger.error( self.context.logger.error(
"Debugger session has been " "Debugger session has been "
f"running for {total_timeout.elapsed}s, timeout reached!" f"running for {total_timeout.elapsed}s, timeout reached!"
) )
Show All 35 Lines

cross-project-tests/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio.py

Show All 34 Lines
# info to identify breakpoint equivalence in visual studio based on the # info to identify breakpoint equivalence in visual studio based on the
# properties we set through dexter currently. # properties we set through dexter currently.
VSBreakpoint = namedtuple("VSBreakpoint", "path, line, col, cond") VSBreakpoint = namedtuple("VSBreakpoint", "path, line, col, cond")
class VisualStudio( class VisualStudio(
DebuggerBase, metaclass=abc.ABCMeta DebuggerBase, metaclass=abc.ABCMeta
): # pylint: disable=abstract-method ): # pylint: disable=abstract-method
# Constants for results of Debugger.CurrentMode # Constants for results of Debugger.CurrentMode
# (https://msdn.microsoft.com/en-us/library/envdte.debugger.currentmode.aspx) # (https://msdn.microsoft.com/en-us/library/envdte.debugger.currentmode.aspx)
dbgDesignMode = 1 dbgDesignMode = 1
dbgBreakMode = 2 dbgBreakMode = 2
dbgRunMode = 3 dbgRunMode = 3
def __init__(self, *args): def __init__(self, *args):
self.com_module = None self.com_module = None
▲ Show 20 Lines • Show All 359 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter/dex/dextIR/DextIR.py

# DExTer : Debugging Experience Tester # DExTer : Debugging Experience Tester
# ~~~~~~ ~ ~~ ~ ~~ # ~~~~~~ ~ ~~ ~ ~~
# #
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
from collections import OrderedDict from collections import OrderedDict
import os import os
from typing import List from typing import List
from dex.dextIR.BuilderIR import BuilderIR
from dex.dextIR.DebuggerIR import DebuggerIR from dex.dextIR.DebuggerIR import DebuggerIR
from dex.dextIR.StepIR import StepIR, StepKind from dex.dextIR.StepIR import StepIR, StepKind
def _step_kind_func(context, step): def _step_kind_func(context, step):
if step.current_location.path is None or not os.path.exists( if step.current_location.path is None or not os.path.exists(
step.current_location.path step.current_location.path
): ):
Show All 22 Lines Args:
commands: { name (str), commands (list[CommandIR]) commands: { name (str), commands (list[CommandIR])
""" """
def __init__( def __init__(
self, self,
dexter_version: str, dexter_version: str,
executable_path: str, executable_path: str,
source_paths: List[str], source_paths: List[str],
builder: BuilderIR = None,
debugger: DebuggerIR = None, debugger: DebuggerIR = None,
commands: OrderedDict = None, commands: OrderedDict = None,
): ):
self.dexter_version = dexter_version self.dexter_version = dexter_version
self.executable_path = executable_path self.executable_path = executable_path
self.source_paths = source_paths self.source_paths = source_paths
self.builder = builder
self.debugger = debugger self.debugger = debugger
self.commands = commands self.commands = commands
self.steps: List[StepIR] = [] self.steps: List[StepIR] = []
def __str__(self): def __str__(self):
colors = "rgby" colors = "rgby"
st = "## BEGIN ##\n" st = "## BEGIN ##\n"
color_idx = 0 color_idx = 0
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter/dex/dextIR/__init__.py

# DExTer : Debugging Experience Tester # DExTer : Debugging Experience Tester
# ~~~~~~ ~ ~~ ~ ~~ # ~~~~~~ ~ ~~ ~ ~~
# #
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
"""dextIR: DExTer Intermediate Representation of DExTer's debugger trace output. """dextIR: DExTer Intermediate Representation of DExTer's debugger trace output.
""" """
from dex.dextIR.BuilderIR import BuilderIR
from dex.dextIR.DextIR import DextIR from dex.dextIR.DextIR import DextIR
from dex.dextIR.DebuggerIR import DebuggerIR from dex.dextIR.DebuggerIR import DebuggerIR
from dex.dextIR.FrameIR import FrameIR from dex.dextIR.FrameIR import FrameIR
from dex.dextIR.LocIR import LocIR from dex.dextIR.LocIR import LocIR
from dex.dextIR.StepIR import StepIR, StepKind, StopReason from dex.dextIR.StepIR import StepIR, StepKind, StopReason
from dex.dextIR.ValueIR import ValueIR from dex.dextIR.ValueIR import ValueIR
from dex.dextIR.ProgramState import ProgramState, SourceLocation, StackFrame from dex.dextIR.ProgramState import ProgramState, SourceLocation, StackFrame

cross-project-tests/debuginfo-tests/dexter/dex/tools/Main.py

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linesdef get_tools_directory():
tools_directory = os.path.join(get_root_directory(), "tools") tools_directory = os.path.join(get_root_directory(), "tools")
assert os.path.isdir(tools_directory), tools_directory assert os.path.isdir(tools_directory), tools_directory
return tools_directory return tools_directory
def get_tool_names(): def get_tool_names():
"""Returns a list of expected DExTer Tools""" """Returns a list of expected DExTer Tools"""
return [ return [
"clang-opt-bisect",
"help", "help",
"list-debuggers", "list-debuggers",
"no-tool-", "no-tool-",
"run-debugger-internal-", "run-debugger-internal-",
"test", "test",
"view", "view",
] ]
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines def __init__(self):
self.logger: Logger = None self.logger: Logger = None
self.working_directory: str = None self.working_directory: str = None
self.options: dict = None self.options: dict = None
self.version: str = None self.version: str = None
self.root_directory: str = None self.root_directory: str = None
def main() -> ReturnCode: def main() -> ReturnCode:
context = Context() context = Context()
with PrettyOutput() as context.o: with PrettyOutput() as context.o:
context.logger = Logger(context.o) context.logger = Logger(context.o)
try: try:
context.root_directory = get_root_directory() context.root_directory = get_root_directory()
# Flag some strings for auto-highlighting. # Flag some strings for auto-highlighting.
_set_auto_highlights(context) _set_auto_highlights(context)
Show All 18 Lines

cross-project-tests/debuginfo-tests/dexter/dex/tools/TestToolBase.py

# DExTer : Debugging Experience Tester # DExTer : Debugging Experience Tester
# ~~~~~~ ~ ~~ ~ ~~ # ~~~~~~ ~ ~~ ~ ~~
# #
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
"""Base class for subtools that do build/run tests.""" """Base class for subtools that run tests."""
import abc import abc
from datetime import datetime from datetime import datetime
import os import os
import sys import sys
from dex.builder import add_builder_tool_arguments
from dex.builder import handle_builder_tool_options
from dex.debugger.Debuggers import add_debugger_tool_arguments from dex.debugger.Debuggers import add_debugger_tool_arguments
from dex.debugger.Debuggers import handle_debugger_tool_options from dex.debugger.Debuggers import handle_debugger_tool_options
from dex.heuristic.Heuristic import add_heuristic_tool_arguments from dex.heuristic.Heuristic import add_heuristic_tool_arguments
from dex.tools.ToolBase import ToolBase from dex.tools.ToolBase import ToolBase
from dex.utils import get_root_directory from dex.utils import get_root_directory
from dex.utils.Exceptions import Error, ToolArgumentError from dex.utils.Exceptions import Error, ToolArgumentError
from dex.utils.ReturnCode import ReturnCode from dex.utils.ReturnCode import ReturnCode
def add_executable_arguments(parser):
executable_group = parser.add_mutually_exclusive_group(required=True)
executable_group.add_argument(
"--binary", metavar="<file>", help="provide binary file to debug"
)
executable_group.add_argument(
"--vs-solution",
metavar="<file>",
help="provide a path to an already existing visual studio solution.",
)
class TestToolBase(ToolBase): class TestToolBase(ToolBase):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super(TestToolBase, self).__init__(*args, **kwargs) super(TestToolBase, self).__init__(*args, **kwargs)
self.build_script: str = None
def add_tool_arguments(self, parser, defaults): def add_tool_arguments(self, parser, defaults):
parser.description = self.__doc__ parser.description = self.__doc__
add_builder_tool_arguments(parser)
add_debugger_tool_arguments(parser, self.context, defaults) add_debugger_tool_arguments(parser, self.context, defaults)
add_executable_arguments(parser)
add_heuristic_tool_arguments(parser) add_heuristic_tool_arguments(parser)
parser.add_argument( parser.add_argument(
"test_path", "test_path",
type=str, type=str,
metavar="<test-path>", metavar="<test-path>",
nargs="?", nargs="?",
default=os.path.abspath(os.path.join(get_root_directory(), "..", "tests")), default=os.path.abspath(os.path.join(get_root_directory(), "..", "tests")),
help="directory containing test(s)", help="directory containing test(s)",
) )
parser.add_argument( parser.add_argument(
"--results-directory", "--results-directory",
type=str, type=str,
metavar="<directory>", metavar="<directory>",
default=None, default=None,
help="directory to save results (default: none)", help="directory to save results (default: none)",
) )
def handle_options(self, defaults): def handle_options(self, defaults):
options = self.context.options options = self.context.options
if not options.builder and (options.cflags or options.ldflags):
self.context.logger.warning(
"--cflags and --ldflags will be ignored when not using --builder",
enable_prefix=True,
)
if options.vs_solution: if options.vs_solution:
options.vs_solution = os.path.abspath(options.vs_solution) options.vs_solution = os.path.abspath(options.vs_solution)
if not os.path.isfile(options.vs_solution): if not os.path.isfile(options.vs_solution):
raise Error( raise Error(
'<d>could not find VS solution file</> <r>"{}"</>'.format( '<d>could not find VS solution file</> <r>"{}"</>'.format(
options.vs_solution options.vs_solution
) )
) )
elif options.binary: elif options.binary:
options.binary = os.path.abspath(options.binary) options.binary = os.path.abspath(options.binary)
if not os.path.isfile(options.binary): if not os.path.isfile(options.binary):
raise Error( raise Error(
'<d>could not find binary file</> <r>"{}"</>'.format(options.binary) '<d>could not find binary file</> <r>"{}"</>'.format(options.binary)
) )
else:
try:
self.build_script = handle_builder_tool_options(self.context)
except ToolArgumentError as e:
raise Error(e)
try: try:
handle_debugger_tool_options(self.context, defaults) handle_debugger_tool_options(self.context, defaults)
except ToolArgumentError as e: except ToolArgumentError as e:
raise Error(e) raise Error(e)
options.test_path = os.path.abspath(options.test_path) options.test_path = os.path.abspath(options.test_path)
options.test_path = os.path.normcase(options.test_path) options.test_path = os.path.normcase(options.test_path)
Show All 19 Linesclass TestToolBase(ToolBase):
def go(self) -> ReturnCode: # noqa def go(self) -> ReturnCode: # noqa
options = self.context.options options = self.context.options
options.executable = os.path.join( options.executable = os.path.join(
self.context.working_directory.path, "tmp.exe" self.context.working_directory.path, "tmp.exe"
) )
# Test files contain dexter commands. # Test files contain dexter commands.
options.test_files = [] options.test_files = [options.test_path]
# Source files are to be compiled by the builder script and may also # Source files are the files that the program was built from, and are
# contains dexter commands. # used to determine whether a breakpoint is external to the program
# (e.g. into a system header) or not.
options.source_files = [] options.source_files = []
if os.path.isdir(options.test_path):
subdirs = sorted(
[r for r, _, f in os.walk(options.test_path) if "test.cfg" in f]
)
for subdir in subdirs:
for f in os.listdir(subdir):
# TODO: read file extensions from the test.cfg file instead so
# that this isn't just limited to C and C++.
file_path = os.path.normcase(os.path.join(subdir, f))
if f.endswith(".cpp"):
options.source_files.append(file_path)
elif f.endswith(".c"):
options.source_files.append(file_path)
elif f.endswith(".dex"):
options.test_files.append(file_path)
# Source files can contain dexter commands too.
options.test_files = options.test_files + options.source_files
self._run_test(self._get_test_name(subdir))
else:
# We're dealing with a direct file path to a test file. If the file is non
# .dex, then it must be a source file.
if not options.test_path.endswith(".dex"): if not options.test_path.endswith(".dex"):
options.source_files = [options.test_path] options.source_files = [options.test_path]
options.test_files = [options.test_path]
self._run_test(self._get_test_name(options.test_path)) self._run_test(self._get_test_name(options.test_path))
return self._handle_results() return self._handle_results()
@staticmethod @staticmethod
def _is_current_directory(test_directory): def _is_current_directory(test_directory):
return test_directory == "." return test_directory == "."
def _get_test_name(self, test_path): def _get_test_name(self, test_path):
Show All 17 Lines

cross-project-tests/debuginfo-tests/dexter/dex/tools/clang_opt_bisect/__init__.py

  • This file was deleted.
# DExTer : Debugging Experience Tester
# ~~~~~~ ~ ~~ ~ ~~
#
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
from dex.tools.clang_opt_bisect.Tool import Tool

cross-project-tests/debuginfo-tests/dexter/dex/tools/test/Tool.py

# DExTer : Debugging Experience Tester # DExTer : Debugging Experience Tester
# ~~~~~~ ~ ~~ ~ ~~ # ~~~~~~ ~ ~~ ~ ~~
# #
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
"""Test tool.""" """Test tool."""
import math import math
import os import os
import csv import csv
import pickle import pickle
import shutil import shutil
from dex.builder import run_external_build_script
from dex.command.ParseCommand import get_command_infos from dex.command.ParseCommand import get_command_infos
from dex.debugger.Debuggers import run_debugger_subprocess from dex.debugger.Debuggers import run_debugger_subprocess
from dex.debugger.DebuggerControllers.DefaultController import DefaultController from dex.debugger.DebuggerControllers.DefaultController import DefaultController
from dex.debugger.DebuggerControllers.ConditionalController import ConditionalController from dex.debugger.DebuggerControllers.ConditionalController import ConditionalController
from dex.dextIR.DextIR import DextIR from dex.dextIR.DextIR import DextIR
from dex.heuristic import Heuristic from dex.heuristic import Heuristic
from dex.tools import TestToolBase from dex.tools import TestToolBase
from dex.utils.Exceptions import DebuggerException from dex.utils.Exceptions import DebuggerException
from dex.utils.Exceptions import BuildScriptException, HeuristicException from dex.utils.Exceptions import BuildScriptException, HeuristicException
from dex.utils.PrettyOutputBase import Stream from dex.utils.PrettyOutputBase import Stream
from dex.utils.ReturnCode import ReturnCode from dex.utils.ReturnCode import ReturnCode
from dex.dextIR import BuilderIR
class TestCase(object): class TestCase(object):
def __init__(self, context, name, heuristic, error): def __init__(self, context, name, heuristic, error):
self.context = context self.context = context
self.name = name self.name = name
self.heuristic = heuristic self.heuristic = heuristic
self.error = error self.error = error
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines def add_tool_arguments(self, parser, defaults):
) )
parser.add_argument( parser.add_argument(
"--calculate-average", "--calculate-average",
action="store_true", action="store_true",
help="calculate the average score of every test run", help="calculate the average score of every test run",
) )
super(Tool, self).add_tool_arguments(parser, defaults) super(Tool, self).add_tool_arguments(parser, defaults)
def _build_test_case(self):
"""Build an executable from the test source with the given --builder
script and flags (--cflags, --ldflags) in the working directory.
Or, if the --binary option has been given, copy the executable provided
into the working directory and rename it to match the --builder output
or skip if --vs-solution was passed on the command line.
"""
if self.context.options.vs_solution:
return
options = self.context.options
if options.binary:
# Copy user's binary into the tmp working directory
shutil.copy(options.binary, options.executable)
builderIR = BuilderIR(name="binary", cflags=[options.binary], ldflags="")
else:
options = self.context.options
compiler_options = [options.cflags for _ in options.source_files]
linker_options = options.ldflags
_, _, builderIR = run_external_build_script(
self.context,
script_path=self.build_script,
source_files=options.source_files,
compiler_options=compiler_options,
linker_options=linker_options,
executable_file=options.executable,
)
return builderIR
def _init_debugger_controller(self): def _init_debugger_controller(self):
step_collection = DextIR( step_collection = DextIR(
executable_path=self.context.options.executable, executable_path=self.context.options.executable,
source_paths=self.context.options.source_files, source_paths=self.context.options.source_files,
dexter_version=self.context.version, dexter_version=self.context.version,
) )
step_collection.commands, new_source_files = get_command_infos( step_collection.commands, new_source_files = get_command_infos(
self.context.options.test_files, self.context.options.source_root_dir self.context.options.test_files, self.context.options.source_root_dir
) )
self.context.options.source_files.extend(list(new_source_files)) self.context.options.source_files.extend(list(new_source_files))
if "DexLimitSteps" in step_collection.commands: if "DexLimitSteps" in step_collection.commands:
debugger_controller = ConditionalController(self.context, step_collection) debugger_controller = ConditionalController(self.context, step_collection)
else: else:
debugger_controller = DefaultController(self.context, step_collection) debugger_controller = DefaultController(self.context, step_collection)
return debugger_controller return debugger_controller
def _get_steps(self, builderIR): def _get_steps(self):
"""Generate a list of debugger steps from a test case.""" """Generate a list of debugger steps from a test case."""
debugger_controller = self._init_debugger_controller() debugger_controller = self._init_debugger_controller()
debugger_controller = run_debugger_subprocess( debugger_controller = run_debugger_subprocess(
debugger_controller, self.context.working_directory.path debugger_controller, self.context.working_directory.path
) )
steps = debugger_controller.step_collection steps = debugger_controller.step_collection
steps.builder = builderIR
return steps return steps
def _get_results_basename(self, test_name): def _get_results_basename(self, test_name):
def splitall(x): def splitall(x):
while len(x) > 0: while len(x) > 0:
x, y = os.path.split(x) x, y = os.path.split(x)
yield y yield y
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines def _record_successful_test(self, test_name, steps, heuristic):
self.context.o.auto("\n{}\n".format(steps)) self.context.o.auto("\n{}\n".format(steps))
self.context.o.auto(heuristic.verbose_output) self.context.o.auto(heuristic.verbose_output)
def _run_test(self, test_name): def _run_test(self, test_name):
"""Attempt to run test files specified in options.source_files. Store """Attempt to run test files specified in options.source_files. Store
result internally in self._test_cases. result internally in self._test_cases.
""" """
try: try:
builderIR = self._build_test_case() if self.context.options.binary:
steps = self._get_steps(builderIR) # Copy user's binary into the tmp working directory.
shutil.copy(
self.context.options.binary, self.context.options.executable
)
steps = self._get_steps()
self._record_steps(test_name, steps) self._record_steps(test_name, steps)
heuristic_score = Heuristic(self.context, steps) heuristic_score = Heuristic(self.context, steps)
self._record_score(test_name, heuristic_score) self._record_score(test_name, heuristic_score)
except (BuildScriptException, DebuggerException, HeuristicException) as e: except (BuildScriptException, DebuggerException, HeuristicException) as e:
self._record_failed_test(test_name, e) self._record_failed_test(test_name, e)
return return
self._record_successful_test(test_name, steps, heuristic_score) self._record_successful_test(test_name, steps, heuristic_score)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter/dex/utils/windows/PrettyOutput.py

Show All 21 Lines _fields_ = [
("wAttributes", ctypes.c_ushort), ("wAttributes", ctypes.c_ushort),
("srWindow", ctypes.wintypes._SMALL_RECT), ("srWindow", ctypes.wintypes._SMALL_RECT),
("dwMaximumWindowSize", ctypes.wintypes._COORD), ("dwMaximumWindowSize", ctypes.wintypes._COORD),
] ]
# pylint: enable=protected-access # pylint: enable=protected-access
class PrettyOutput(PrettyOutputBase): class PrettyOutput(PrettyOutputBase):
stdout = Stream(sys.stdout, ctypes.windll.kernel32.GetStdHandle(-11)) stdout = Stream(sys.stdout, ctypes.windll.kernel32.GetStdHandle(-11))
stderr = Stream(sys.stderr, ctypes.windll.kernel32.GetStdHandle(-12)) stderr = Stream(sys.stderr, ctypes.windll.kernel32.GetStdHandle(-12))
def __enter__(self): def __enter__(self):
info = _CONSOLE_SCREEN_BUFFER_INFO() info = _CONSOLE_SCREEN_BUFFER_INFO()
for s in (PrettyOutput.stdout, PrettyOutput.stderr): for s in (PrettyOutput.stdout, PrettyOutput.stderr):
ctypes.windll.kernel32.GetConsoleScreenBufferInfo(s.os, ctypes.byref(info)) ctypes.windll.kernel32.GetConsoleScreenBufferInfo(s.os, ctypes.byref(info))
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/dex_declare_file.cpp

// Purpose: // Purpose:
// Check that \DexDeclareFile causes a DexExpectWatchValue's to generate a // Check that \DexDeclareFile causes a DexExpectWatchValue's to generate a
// missing value penalty when the declared path is incorrect. // missing value penalty when the declared path is incorrect.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: dex_declare_file.cpp // CHECK: dex_declare_file.cpp
int main() { int main() {
int result = 0; int result = 0;
return result; //DexLabel('return') return result; //DexLabel('return')
} }
// DexDeclareFile('this_file_does_not_exist.cpp') // DexDeclareFile('this_file_does_not_exist.cpp')
// DexExpectWatchValue('result', 0, on_line='return') // DexExpectWatchValue('result', 0, on_line='return')

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/expect_program_state.cpp

// Purpose: // Purpose:
// Check that \DexExpectProgramState correctly applies a penalty when // Check that \DexExpectProgramState correctly applies a penalty when
// an expected program state is never found. // an expected program state is never found.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: expect_program_state.cpp: // CHECK: expect_program_state.cpp:
int GCD(int lhs, int rhs) int GCD(int lhs, int rhs)
{ {
if (rhs == 0) // DexLabel('check') if (rhs == 0) // DexLabel('check')
return lhs; return lhs;
return GCD(rhs, lhs % rhs); return GCD(rhs, lhs % rhs);
} }
Show All 20 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/expect_step_kinds.cpp

// Purpose: // Purpose:
// Check that \DexExpectStepKind correctly applies a penalty when // Check that \DexExpectStepKind correctly applies a penalty when
// unexpected step kinds are encountered. // unexpected step kinds are encountered.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: expect_step_kinds.cpp: // CHECK: expect_step_kinds.cpp:
int abs(int i){ int abs(int i){
return i < 0? i * -1: i; return i < 0? i * -1: i;
} }
int main() int main()
{ {
Show All 10 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/expect_step_order.cpp

// Purpose: // Purpose:
// Check that \DexExpectStepOrder correctly applies a penalty for steps // Check that \DexExpectStepOrder correctly applies a penalty for steps
// found out of expected order. // found out of expected order.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: expect_step_order.cpp: // CHECK: expect_step_order.cpp:
int main() int main()
{ {
volatile int x = 1; // DexExpectStepOrder(3) volatile int x = 1; // DexExpectStepOrder(3)
volatile int y = 1; // DexExpectStepOrder(1) volatile int y = 1; // DexExpectStepOrder(1)
volatile int z = 1; // DexExpectStepOrder(2) volatile int z = 1; // DexExpectStepOrder(2)
return 0; return 0;
} }

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/expect_watch_type.cpp

// Purpose: // Purpose:
// Check that \DexExpectWatchType applies penalties when expected // Check that \DexExpectWatchType applies penalties when expected
// types are not found and unexpected types are. // types are not found and unexpected types are.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// //
// NOTE: This test passes but not in the expected way on Windows. // NOTE: This test passes but not in the expected way on Windows.
// TODO: Reduce this test's coverage and be more specific about // TODO: Reduce this test's coverage and be more specific about
// expected behaviour. // expected behaviour.
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: expect_watch_type.cpp: // CHECK: expect_watch_type.cpp:
template<class T> template<class T>
class Doubled { class Doubled {
public: public:
Doubled(const T & to_double) Doubled(const T & to_double)
: m_member(to_double * 2) {} : m_member(to_double * 2) {}
Show All 37 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/expect_watch_value.cpp

// Purpose: // Purpose:
// Check that \DexExpectWatchValue correctly applies a penalty when // Check that \DexExpectWatchValue correctly applies a penalty when
// expected values are not found. // expected values are not found.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: expect_watch_value.cpp: // CHECK: expect_watch_value.cpp:
int main() int main()
{ {
for (int i = 0; i < 3; ++i) for (int i = 0; i < 3; ++i)
int a = i; // DexLabel('loop') int a = i; // DexLabel('loop')
return 0; // DexLabel('ret') return 0; // DexLabel('ret')
} }
// DexExpectWatchValue('i', '0', '1', '2', on_line=ref('loop')) // DexExpectWatchValue('i', '0', '1', '2', on_line=ref('loop'))
// DexExpectWatchValue('i', '3', on_line=ref('ret')) // DexExpectWatchValue('i', '3', on_line=ref('ret'))
// ---------------------^ out of scope // ---------------------^ out of scope

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/float_range_out_range.cpp

// Purpose: // Purpose:
// Check that a \DexExpectWatchValue float_range that is not large enough // Check that a \DexExpectWatchValue float_range that is not large enough
// detects unexpected watch values. // detects unexpected watch values.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: float_range_out_range.cpp: // CHECK: float_range_out_range.cpp:
int main() { int main() {
float a = 1.0f; float a = 1.0f;
a = a - 0.5f; a = a - 0.5f;
return a; //DexLabel('check') return a; //DexLabel('check')
} }
// DexExpectWatchValue('a', '1.00000', from_line=ref('check1'), to_line=ref('check2'), float_range=0.4) // DexExpectWatchValue('a', '1.00000', from_line=ref('check1'), to_line=ref('check2'), float_range=0.4)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/float_range_zero_nonmatch.cpp

// Purpose: // Purpose:
// Check that \DexExpectWatchValue float_range=0.0 matches only exact // Check that \DexExpectWatchValue float_range=0.0 matches only exact
// values. // values.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: float_range_zero_nonmatch.cpp: // CHECK: float_range_zero_nonmatch.cpp:
int main() { int main() {
float a = 1.0f; float a = 1.0f;
return a; //DexLabel('check') return a; //DexLabel('check')
} }
// DexExpectWatchValue('a', '1.0000001', on_line=ref('check'), float_range=0.0) // DexExpectWatchValue('a', '1.0000001', on_line=ref('check'), float_range=0.0)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/missing_dex_address.cpp

// Purpose: // Purpose:
// Test that when a \DexDeclareAddress never resolves to a value, it is // Test that when a \DexDeclareAddress never resolves to a value, it is
// counted as a missing value in any \DexExpectWatchValues. // counted as a missing value in any \DexExpectWatchValues.
// //
// The dbgeng driver doesn't support \DexDeclareAddress yet. // The dbgeng driver doesn't support \DexDeclareAddress yet.
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: missing_dex_address.cpp // CHECK: missing_dex_address.cpp
int main() { int main() {
int *x = nullptr; int *x = nullptr;
x = new int(5); // DexLabel('start_line') x = new int(5); // DexLabel('start_line')
if (false) { if (false) {
(void)0; // DexLabel('unreachable') (void)0; // DexLabel('unreachable')
} }
delete x; // DexLabel('end_line') delete x; // DexLabel('end_line')
} }
// DexDeclareAddress('x', 'x', on_line=ref('unreachable')) // DexDeclareAddress('x', 'x', on_line=ref('unreachable'))
// DexExpectWatchValue('x', 0, address('x'), from_line=ref('start_line'), to_line=ref('end_line')) // DexExpectWatchValue('x', 0, address('x'), from_line=ref('start_line'), to_line=ref('end_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/unreachable.cpp

// Purpose: // Purpose:
// Check that \DexUnreachable correctly applies a penalty if the command // Check that \DexUnreachable correctly applies a penalty if the command
// line is stepped on. // line is stepped on.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: unreachable.cpp: // CHECK: unreachable.cpp:
int int
main() main()
{ {
return 1; // DexUnreachable() return 1; // DexUnreachable()
} }

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/unreachable_line_range.cpp

// Purpose: // Purpose:
// Check that \DexUnreachable correctly applies a penalty if the command // Check that \DexUnreachable correctly applies a penalty if the command
// line is stepped on. // line is stepped on.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: unreachable_line_range.cpp: // CHECK: unreachable_line_range.cpp:
int int
main() main()
{ // DexLabel('begin') { // DexLabel('begin')
return 1; return 1;
} // DexLabel('end') } // DexLabel('end')
// DexUnreachable(from_line=ref('begin'), to_line=ref('end')) // DexUnreachable(from_line=ref('begin'), to_line=ref('end'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/penalty/unreachable_on_line.cpp

// Purpose: // Purpose:
// Check that \DexUnreachable correctly applies a penalty if the command // Check that \DexUnreachable correctly applies a penalty if the command
// line is stepped on. // line is stepped on.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// //
// RUN: not %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: unreachable_on_line.cpp: // CHECK: unreachable_on_line.cpp:
int int
main() main()
{ {
return 1; // DexLabel('this_one') return 1; // DexLabel('this_one')
} }
// DexUnreachable(on_line=ref('this_one')) // DexUnreachable(on_line=ref('this_one'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/command_line.c

// The dbgeng driver doesn't support \DexCommandLine yet. // The dbgeng driver doesn't support \DexCommandLine yet.
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: command_line.c: // CHECK: command_line.c:
int main(int argc, const char **argv) { int main(int argc, const char **argv) {
if (argc == 4) if (argc == 4)
return 0; // DexLabel('retline') return 0; // DexLabel('retline')
return 1; // DexUnreachable() return 1; // DexUnreachable()
} }
// DexExpectWatchValue('argc', '4', on_line=ref('retline')) // DexExpectWatchValue('argc', '4', on_line=ref('retline'))
// Three args will be appended to the 'default' argument. // Three args will be appended to the 'default' argument.
// DexCommandLine(['a', 'b', 'c']) // DexCommandLine(['a', 'b', 'c'])

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_declare_address/address_after_ref.cpp

// Purpose: // Purpose:
// Test that a \DexDeclareAddress value can have its value defined after // Test that a \DexDeclareAddress value can have its value defined after
// the first reference to that value. // the first reference to that value.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: address_after_ref.cpp // CHECK: address_after_ref.cpp
int main() { int main() {
int *x = new int(5); int *x = new int(5);
int *y = x; // DexLabel('first_line') int *y = x; // DexLabel('first_line')
delete x; // DexLabel('last_line') delete x; // DexLabel('last_line')
} }
// DexDeclareAddress('y', 'y', on_line=ref('last_line')) // DexDeclareAddress('y', 'y', on_line=ref('last_line'))
// DexExpectWatchValue('x', address('y'), on_line=ref('first_line')) // DexExpectWatchValue('x', address('y'), on_line=ref('first_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_declare_address/address_hit_count.cpp

// Purpose: // Purpose:
// Test that a \DexDeclareAddress command can be passed 'hit_count' as an // Test that a \DexDeclareAddress command can be passed 'hit_count' as an
// optional keyword argument that captures the value of the given // optional keyword argument that captures the value of the given
// expression after the target line has been stepped on a given number of // expression after the target line has been stepped on a given number of
// times. // times.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: address_hit_count.cpp // CHECK: address_hit_count.cpp
int main() { int main() {
int *x = new int[3]; int *x = new int[3];
for (int *y = x; y < x + 3; ++y) for (int *y = x; y < x + 3; ++y)
*y = 0; // DexLabel('test_line') *y = 0; // DexLabel('test_line')
delete x; delete x;
} }
// DexDeclareAddress('y', 'y', on_line=ref('test_line'), hit_count=2) // DexDeclareAddress('y', 'y', on_line=ref('test_line'), hit_count=2)
// DexExpectWatchValue('y', address('y', -8), address('y', -4), address('y'), on_line=ref('test_line')) // DexExpectWatchValue('y', address('y', -8), address('y', -4), address('y'), on_line=ref('test_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_declare_address/expression_address.cpp

// Purpose: // Purpose:
// Test that a \DexDeclareAddress value can be used to compare the // Test that a \DexDeclareAddress value can be used to compare the
// addresses of two local variables that refer to the same address. // addresses of two local variables that refer to the same address.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: expression_address.cpp // CHECK: expression_address.cpp
int main() { int main() {
int x = 5; int x = 5;
int &y = x; int &y = x;
x = 3; // DexLabel('test_line') x = 3; // DexLabel('test_line')
} }
// DexDeclareAddress('x_addr', '&x', on_line=ref('test_line')) // DexDeclareAddress('x_addr', '&x', on_line=ref('test_line'))
// DexExpectWatchValue('&x', address('x_addr'), on_line=ref('test_line')) // DexExpectWatchValue('&x', address('x_addr'), on_line=ref('test_line'))
// DexExpectWatchValue('&y', address('x_addr'), on_line=ref('test_line')) // DexExpectWatchValue('&y', address('x_addr'), on_line=ref('test_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_declare_address/identical_address.cpp

// Purpose: // Purpose:
// Test that a \DexDeclareAddress value can be used to compare two equal // Test that a \DexDeclareAddress value can be used to compare two equal
// pointer variables. // pointer variables.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: identical_address.cpp // CHECK: identical_address.cpp
int main() { int main() {
int *x = new int(5); int *x = new int(5);
int *y = x; int *y = x;
delete x; // DexLabel('test_line') delete x; // DexLabel('test_line')
} }
// DexDeclareAddress('x', 'x', on_line=ref('test_line')) // DexDeclareAddress('x', 'x', on_line=ref('test_line'))
// DexExpectWatchValue('x', address('x'), on_line=ref('test_line')) // DexExpectWatchValue('x', address('x'), on_line=ref('test_line'))
// DexExpectWatchValue('y', address('x'), on_line=ref('test_line')) // DexExpectWatchValue('y', address('x'), on_line=ref('test_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_declare_address/multiple_address.cpp

// Purpose: // Purpose:
// Test that multiple \DexDeclareAddress references that point to different // Test that multiple \DexDeclareAddress references that point to different
// addresses can be used within a single \DexExpectWatchValue. // addresses can be used within a single \DexExpectWatchValue.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: multiple_address.cpp // CHECK: multiple_address.cpp
int main() { int main() {
int *x = new int(5); int *x = new int(5);
int *y = new int(4); int *y = new int(4);
int *z = x; int *z = x;
*z = 0; // DexLabel('start_line') *z = 0; // DexLabel('start_line')
z = y; z = y;
Show All 9 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_declare_address/offset_address.cpp

// Purpose: // Purpose:
// Test that a \DexDeclareAddress value can be used to compare two pointer // Test that a \DexDeclareAddress value can be used to compare two pointer
// variables that have a fixed offset between them. // variables that have a fixed offset between them.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: offset_address.cpp // CHECK: offset_address.cpp
int main() { int main() {
int *x = new int[5]; int *x = new int[5];
int *y = x + 3; int *y = x + 3;
delete x; // DexLabel('test_line') delete x; // DexLabel('test_line')
} }
// DexDeclareAddress('x', 'x', on_line=ref('test_line')) // DexDeclareAddress('x', 'x', on_line=ref('test_line'))
// DexExpectWatchValue('x', address('x'), on_line=ref('test_line')) // DexExpectWatchValue('x', address('x'), on_line=ref('test_line'))
// DexExpectWatchValue('y', address('x', 12), on_line=ref('test_line')) // DexExpectWatchValue('y', address('x', 12), on_line=ref('test_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_declare_address/self_comparison.cpp

// Purpose: // Purpose:
// Test that a \DexDeclareAddress value can be used to check the change in // Test that a \DexDeclareAddress value can be used to check the change in
// value of a variable over time, relative to its initial value. // value of a variable over time, relative to its initial value.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: self_comparison.cpp // CHECK: self_comparison.cpp
int main() { int main() {
int *x = new int[3]; int *x = new int[3];
for (int *y = x; y < x + 3; ++y) for (int *y = x; y < x + 3; ++y)
*y = 0; // DexLabel('test_line') *y = 0; // DexLabel('test_line')
delete x; delete x;
} }
// DexDeclareAddress('y', 'y', on_line=ref('test_line')) // DexDeclareAddress('y', 'y', on_line=ref('test_line'))
// DexExpectWatchValue('y', address('y'), address('y', 4), address('y', 8), on_line=ref('test_line')) // DexExpectWatchValue('y', address('y'), address('y', 4), address('y', 8), on_line=ref('test_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_declare_file/dex_and_source/test.cpp

// Purpose: // Purpose:
// Check that \DexDeclareFile changes the path of all succeeding commands // Check that \DexDeclareFile changes the path of all succeeding commands
// to the file path it declares. Also check that dexter correctly accepts // to the file path it declares. Also check that dexter correctly accepts
// files with .dex extensions. // files with .dex extensions.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// //
// RUN: %dexter_regression_test -- %S | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: dex_and_source // CHECK: dex_and_source
int main() { int main() {
int result = 0; int result = 0;
return result; return result;
} }

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_declare_file/precompiled_binary/commands.dex

# Purpose: # Purpose:
# Check that \DexDeclareFile's file declaration can reference source files # Check that \DexDeclareFile's file declaration can reference source files
# in a precompiled binary. # in a precompiled binary.
# #
# UNSUPPORTED: system-darwin # UNSUPPORTED: system-darwin
# #
# RUN: %clang %S/test.cpp -O0 -g -o %t # RUN: %dexter_regression_test_build %S/test.cpp -o %t
# RUN: %dexter_regression_base --binary %t %s | FileCheck %s # RUN: %dexter_regression_base --binary %t %s | FileCheck %s
# CHECK: commands.dex # CHECK: commands.dex
# #
# test.cpp # test.cpp
# 1. int main() { # 1. int main() {
# 2. int result = 0; # 2. int result = 0;
# 3. return result; # 3. return result;
# 4. } # 4. }
DexDeclareFile('test.cpp') DexDeclareFile('test.cpp')
DexExpectWatchValue('result', 0, on_line=3) DexExpectWatchValue('result', 0, on_line=3)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_declare_file/windows_noncanonical_path/test.dex

# Purpose: # Purpose:
# Check that non-canonical paths resolve correctly on Windows. # Check that non-canonical paths resolve correctly on Windows.
# #
# REQUIRES: system-windows # REQUIRES: system-windows
# #
# RUN: %clang "%S/source/test file.cpp" -O0 -g -o %t # RUN: %dexter_regression_test_build "%S/source/test file.cpp" -o %t
# RUN: %dexter_regression_base --binary %t %s | FileCheck %s # RUN: %dexter_regression_base --binary %t %s | FileCheck %s
# CHECK: test.dex # CHECK: test.dex
# #
# ./source/test file.cpp # ./source/test file.cpp
# 1 int main(const int argc, const char * argv[]) { # 1 int main(const int argc, const char * argv[]) {
# 2 int result = argc; # 2 int result = argc;
# 3 return result; # 3 return result;
# 4 } # 4 }
DexDeclareFile('./sOuRce\\test filE.cpp') DexDeclareFile('./sOuRce\\test filE.cpp')
DexExpectWatchValue('result', 1, on_line=3) DexExpectWatchValue('result', 1, on_line=3)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_finish_test/default_conditional.cpp

// FIXME: Feature appears to be broken on Windows with dbgeng. // FIXME: Feature appears to be broken on Windows with dbgeng.
// XFAIL: system-windows // XFAIL: system-windows
// Purpose: // Purpose:
// Test that \DexFinishTest can be used with a condition, so the test exits // Test that \DexFinishTest can be used with a condition, so the test exits
// when the line referenced by \DexFinishTest is stepped on and the given // when the line referenced by \DexFinishTest is stepped on and the given
// condition (x == 5) is satisfied. // condition (x == 5) is satisfied.
// Tests using the default controller (no \DexLimitSteps). // Tests using the default controller (no \DexLimitSteps).
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: default_conditional.cpp // CHECK: default_conditional.cpp
int main() { int main() {
for (int x = 0; x < 10; ++x) for (int x = 0; x < 10; ++x)
(void)0; // DexLabel('finish_line') (void)0; // DexLabel('finish_line')
} }
// DexFinishTest('x', 5, on_line=ref('finish_line')) // DexFinishTest('x', 5, on_line=ref('finish_line'))
// DexExpectWatchValue('x', 0, 1, 2, 3, 4, 5, on_line=ref('finish_line')) // DexExpectWatchValue('x', 0, 1, 2, 3, 4, 5, on_line=ref('finish_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_finish_test/default_conditional_hit_count.cpp

// FIXME: Feature appears to be broken on Windows with dbgeng. // FIXME: Feature appears to be broken on Windows with dbgeng.
// XFAIL: system-windows // XFAIL: system-windows
// Purpose: // Purpose:
// Test that \DexFinishTest can be used with a combination of a hit_count // Test that \DexFinishTest can be used with a combination of a hit_count
// and a condition, so that the test exits after the line referenced // and a condition, so that the test exits after the line referenced
// by \DexFinishTest is stepped on while the condition (x == 2) is true a // by \DexFinishTest is stepped on while the condition (x == 2) is true a
// given number of times. // given number of times.
// Tests using the default controller (no \DexLimitSteps). // Tests using the default controller (no \DexLimitSteps).
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: default_conditional_hit_count.cpp // CHECK: default_conditional_hit_count.cpp
int main() { int main() {
for (int y = 0; y < 4; ++y) for (int y = 0; y < 4; ++y)
for (int x = 0; x < 4; ++x) for (int x = 0; x < 4; ++x)
(void)0; // DexLabel('finish_line') (void)0; // DexLabel('finish_line')
} }
// DexFinishTest('x', 2, on_line=ref('finish_line'), hit_count=2) // DexFinishTest('x', 2, on_line=ref('finish_line'), hit_count=2)
// DexExpectWatchValue('x', 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, on_line=ref('finish_line')) // DexExpectWatchValue('x', 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, on_line=ref('finish_line'))
// DexExpectWatchValue('y', 0, 1, 2, on_line=ref('finish_line')) // DexExpectWatchValue('y', 0, 1, 2, on_line=ref('finish_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_finish_test/default_hit_count.cpp

// Purpose: // Purpose:
// Test that \DexFinishTest can be used with a hit_count, so the test exits // Test that \DexFinishTest can be used with a hit_count, so the test exits
// after the line referenced by \DexFinishTest has been stepped on a // after the line referenced by \DexFinishTest has been stepped on a
// specific number of times. // specific number of times.
// Tests using the default controller (no \DexLimitSteps). // Tests using the default controller (no \DexLimitSteps).
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: default_hit_count.cpp // CHECK: default_hit_count.cpp
int main() { int main() {
for (int x = 0; x < 10; ++x) for (int x = 0; x < 10; ++x)
(void)0; // DexLabel('finish_line') (void)0; // DexLabel('finish_line')
} }
// DexFinishTest(on_line=ref('finish_line'), hit_count=5) // DexFinishTest(on_line=ref('finish_line'), hit_count=5)
// DexExpectWatchValue('x', 0, 1, 2, 3, 4, 5, on_line=ref('finish_line')) // DexExpectWatchValue('x', 0, 1, 2, 3, 4, 5, on_line=ref('finish_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_finish_test/default_simple.cpp

// Purpose: // Purpose:
// Test that \DexFinishTest can be used without a condition or hit_count, // Test that \DexFinishTest can be used without a condition or hit_count,
// so the test simply exits as soon as the line referenced by \DexFinishTest // so the test simply exits as soon as the line referenced by \DexFinishTest
// is stepped on. // is stepped on.
// Tests using the default controller (no \DexLimitSteps). // Tests using the default controller (no \DexLimitSteps).
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: default_simple.cpp // CHECK: default_simple.cpp
int main() { int main() {
int x = 0; int x = 0;
x = 1; // DexLabel('start_line') x = 1; // DexLabel('start_line')
x = 2; // DexLabel('finish_line') x = 2; // DexLabel('finish_line')
} }
// DexFinishTest(on_line=ref('finish_line')) // DexFinishTest(on_line=ref('finish_line'))
// DexExpectWatchValue('x', 0, 1, from_line=ref('start_line'), to_line=ref('finish_line')) // DexExpectWatchValue('x', 0, 1, from_line=ref('start_line'), to_line=ref('finish_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_finish_test/limit_steps_conditional.cpp

// Purpose: // Purpose:
// Test that \DexFinishTest can be used with a condition, so the test exits // Test that \DexFinishTest can be used with a condition, so the test exits
// when the line referenced by \DexFinishTest is stepped on and the given // when the line referenced by \DexFinishTest is stepped on and the given
// condition (x == 5) is satisfied. // condition (x == 5) is satisfied.
// Test using the conditional controller (using \DexLimitSteps). // Test using the conditional controller (using \DexLimitSteps).
// //
// The dbgeng driver doesn't support \DexLimitSteps yet. // The dbgeng driver doesn't support \DexLimitSteps yet.
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: limit_steps_conditional.cpp // CHECK: limit_steps_conditional.cpp
int main() { int main() {
for (int x = 0; x < 10; ++x) for (int x = 0; x < 10; ++x)
(void)0; // DexLabel('finish_line') (void)0; // DexLabel('finish_line')
} }
// DexLimitSteps(on_line=ref('finish_line')) // DexLimitSteps(on_line=ref('finish_line'))
// DexFinishTest('x', 5, on_line=ref('finish_line')) // DexFinishTest('x', 5, on_line=ref('finish_line'))
// DexExpectWatchValue('x', 0, 1, 2, 3, 4, 5) // DexExpectWatchValue('x', 0, 1, 2, 3, 4, 5)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_finish_test/limit_steps_conditional_hit_count.cpp

// Purpose: // Purpose:
// Test that \DexFinishTest can be used with a combination of a hit_count // Test that \DexFinishTest can be used with a combination of a hit_count
// and a condition, so that the test exits after the line referenced // and a condition, so that the test exits after the line referenced
// by \DexFinishTest is stepped on while the condition (x == 2) is true a // by \DexFinishTest is stepped on while the condition (x == 2) is true a
// given number of times. // given number of times.
// Test using the conditional controller (using \DexLimitSteps). // Test using the conditional controller (using \DexLimitSteps).
// //
// The dbgeng driver doesn't support \DexLimitSteps yet. // The dbgeng driver doesn't support \DexLimitSteps yet.
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: limit_steps_conditional_hit_count.cpp // CHECK: limit_steps_conditional_hit_count.cpp
int main() { int main() {
for (int y = 0; y < 4; ++y) for (int y = 0; y < 4; ++y)
for (int x = 0; x < 4; ++x) for (int x = 0; x < 4; ++x)
(void)0; // DexLabel('finish_line') (void)0; // DexLabel('finish_line')
} }
// DexLimitSteps(on_line=ref('finish_line')) // DexLimitSteps(on_line=ref('finish_line'))
// DexFinishTest('x', 2, on_line=ref('finish_line'), hit_count=2) // DexFinishTest('x', 2, on_line=ref('finish_line'), hit_count=2)
// DexExpectWatchValue('x', 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, on_line=ref('finish_line')) // DexExpectWatchValue('x', 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, on_line=ref('finish_line'))
// DexExpectWatchValue('y', 0, 1, 2, on_line=ref('finish_line')) // DexExpectWatchValue('y', 0, 1, 2, on_line=ref('finish_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_finish_test/limit_steps_hit_count.cpp

// Purpose: // Purpose:
// Test that \DexFinishTest can be used with a hit_count, so the test exits // Test that \DexFinishTest can be used with a hit_count, so the test exits
// after the line referenced by \DexFinishTest has been stepped on a // after the line referenced by \DexFinishTest has been stepped on a
// specific number of times. // specific number of times.
// Test using the conditional controller (using \DexLimitSteps). // Test using the conditional controller (using \DexLimitSteps).
// //
// The dbgeng driver doesn't support \DexLimitSteps yet. // The dbgeng driver doesn't support \DexLimitSteps yet.
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: limit_steps_hit_count.cpp // CHECK: limit_steps_hit_count.cpp
int main() { int main() {
for (int x = 0; x < 10; ++x) for (int x = 0; x < 10; ++x)
(void)0; // DexLabel('finish_line') (void)0; // DexLabel('finish_line')
} }
// DexLimitSteps(on_line=ref('finish_line')) // DexLimitSteps(on_line=ref('finish_line'))
// DexFinishTest(on_line=ref('finish_line'), hit_count=5) // DexFinishTest(on_line=ref('finish_line'), hit_count=5)
// DexExpectWatchValue('x', 0, 1, 2, 3, 4, 5) // DexExpectWatchValue('x', 0, 1, 2, 3, 4, 5)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/dex_finish_test/limit_steps_simple.cpp

// Purpose: // Purpose:
// Test that \DexFinishTest can be used without a condition or hit_count, // Test that \DexFinishTest can be used without a condition or hit_count,
// so the test simply exits as soon as the line referenced by \DexFinishTest // so the test simply exits as soon as the line referenced by \DexFinishTest
// is stepped on. // is stepped on.
// Test using the conditional controller (using \DexLimitSteps). // Test using the conditional controller (using \DexLimitSteps).
// //
// The dbgeng driver doesn't support \DexLimitSteps yet. // The dbgeng driver doesn't support \DexLimitSteps yet.
// UNSUPPORTED: system-windows, system-darwin // UNSUPPORTED: system-windows, system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: limit_steps_simple.cpp // CHECK: limit_steps_simple.cpp
int main() { int main() {
int x = 0; // DexLabel('start') int x = 0; // DexLabel('start')
x = 1; x = 1;
x = 2; // DexLabel('finish_line') x = 2; // DexLabel('finish_line')
} // DexLabel('finish') } // DexLabel('finish')
// DexLimitSteps(from_line=ref('start'), to_line=ref('finish')) // DexLimitSteps(from_line=ref('start'), to_line=ref('finish'))
// DexFinishTest(on_line=ref('finish_line')) // DexFinishTest(on_line=ref('finish_line'))
// DexExpectWatchValue('x', 0, 1) // DexExpectWatchValue('x', 0, 1)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/expect_program_state.cpp

// Purpose: // Purpose:
// Check that \DexExpectWatchValue applies no penalties when expected // Check that \DexExpectWatchValue applies no penalties when expected
// program states are found. // program states are found.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: expect_program_state.cpp: // CHECK: expect_program_state.cpp:
int GCD(int lhs, int rhs) int GCD(int lhs, int rhs)
{ {
if (rhs == 0) if (rhs == 0)
return lhs; // DexLabel('check') return lhs; // DexLabel('check')
return GCD(rhs, lhs % rhs); return GCD(rhs, lhs % rhs);
} }
Show All 35 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/expect_step_kind/direction.cpp

// Purpose: // Purpose:
// Check that \DexExpectStepKind correctly counts 'VERTICAL_BACKWARD' steps // Check that \DexExpectStepKind correctly counts 'VERTICAL_BACKWARD' steps
// for a trivial test. Expect one 'VERTICAL_BACKWARD' for every step onto // for a trivial test. Expect one 'VERTICAL_BACKWARD' for every step onto
// a lesser source line number in the same function. Expect one // a lesser source line number in the same function. Expect one
// 'VERTICAL_FORWARD' for every step onto a greater source line number in // 'VERTICAL_FORWARD' for every step onto a greater source line number in
// the same function. // the same function.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// TODO: The dbgeng debugger does not support column step reporting at present. // TODO: The dbgeng debugger does not support column step reporting at present.
// XFAIL: system-windows // XFAIL: system-windows
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: direction.cpp: // CHECK: direction.cpp:
int func(int i) { int func(int i) {
return i; // step 7, 9, 11 return i; // step 7, 9, 11
} }
int main() int main()
{ {
Show All 13 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/expect_step_kind/func.cpp

// Purpose: // Purpose:
// Check that \DexExpectStepKind correctly counts 'FUNC' steps for a // Check that \DexExpectStepKind correctly counts 'FUNC' steps for a
// trivial test. Expect one 'FUNC' per call to a function which is defined // trivial test. Expect one 'FUNC' per call to a function which is defined
// in one of the source files in the test directory. // in one of the source files in the test directory.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: func.cpp: // CHECK: func.cpp:
int func(int i) { int func(int i) {
return i; return i;
} }
int main() int main()
{ {
func(0); func(0);
func(1); func(1);
return 0; return 0;
} }
// main, func, func // main, func, func
// DexExpectStepKind('FUNC', 3) // DexExpectStepKind('FUNC', 3)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/expect_step_kind/func_external.cpp

// Purpose: // Purpose:
// Check that \DexExpectStepKind correctly counts 'FUNC_EXTERNAL' steps // Check that \DexExpectStepKind correctly counts 'FUNC_EXTERNAL' steps
// for a trivial test. Expect one 'FUNC_EXTERNAL' per external call. // for a trivial test. Expect one 'FUNC_EXTERNAL' per external call.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// XFAIL:* // XFAIL:*
// This fails right now on my linux and windows machine, needs examining as to // This fails right now on my linux and windows machine, needs examining as to
// why. // why.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: func_external.cpp: // CHECK: func_external.cpp:
#include <cstdlib> #include <cstdlib>
int func(int i){ int func(int i){
return abs(i); return abs(i);
} }
int main() int main()
{ {
func(0); func(0);
func(1); func(1);
return 0; return 0;
} }
// DexExpectStepKind('FUNC_EXTERNAL', 2) // DexExpectStepKind('FUNC_EXTERNAL', 2)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/expect_step_kind/recursive.cpp

// Purpose: // Purpose:
// Check that \DexExpectStepKind correctly handles recursive calls. // Check that \DexExpectStepKind correctly handles recursive calls.
// Specifically, ensure recursive calls count towards 'FUNC' and not // Specifically, ensure recursive calls count towards 'FUNC' and not
// 'VERTICAL_BACKWARD'. // 'VERTICAL_BACKWARD'.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: recursive.cpp: // CHECK: recursive.cpp:
int func(int i) { int func(int i) {
if (i > 1) if (i > 1)
return i + func(i - 1); return i + func(i - 1);
return i; return i;
} }
int main() int main()
{ {
return func(3); return func(3);
} }
// main, func, func, func // main, func, func, func
// DexExpectStepKind('FUNC', 4) // DexExpectStepKind('FUNC', 4)
// DexExpectStepKind('VERTICAL_BACKWARD', 0) // DexExpectStepKind('VERTICAL_BACKWARD', 0)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/expect_step_kind/small_loop.cpp

// Purpose: // Purpose:
// Check that \DexExpectStepKind correctly counts function calls in loops // Check that \DexExpectStepKind correctly counts function calls in loops
// where the last source line in the loop is a call. Expect steps out // where the last source line in the loop is a call. Expect steps out
// of a function to a line before the call to count as 'VERTICAL_BACKWARD'. // of a function to a line before the call to count as 'VERTICAL_BACKWARD'.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: small_loop.cpp: // CHECK: small_loop.cpp:
int func(int i){ int func(int i){
return i; return i;
} }
int main() int main()
{ {
for (int i = 0; i < 2; ++i) { for (int i = 0; i < 2; ++i) {
func(i); func(i);
} }
return 0; return 0;
} }
// DexExpectStepKind('VERTICAL_BACKWARD', 2) // DexExpectStepKind('VERTICAL_BACKWARD', 2)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/expect_step_order.cpp

// Purpose: // Purpose:
// Check that \DexExpectStepOrder applies no penalty when the expected // Check that \DexExpectStepOrder applies no penalty when the expected
// order is found. // order is found.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: expect_step_order.cpp: // CHECK: expect_step_order.cpp:
int main() int main() // DexLabel('main')
{ {
volatile int a = 1; // DexExpectStepOrder(1) volatile int a = 1; // DexExpectStepOrder(1)
volatile int b = 1; // DexExpectStepOrder(2) volatile int b = 1; // DexExpectStepOrder(2)
volatile int c = 1; // DexExpectStepOrder(3) volatile int c = 1; // DexExpectStepOrder(3)
volatile int x = 1; volatile int x = 1;
volatile int y = 1; volatile int y = 1;
volatile int z = 1; volatile int z = 1;
return 0; return 0;
} }
// DexExpectStepOrder(4, on_line=16); // DexExpectStepOrder(4, on_line=ref('main')+6);
// DexExpectStepOrder(5, on_line=17); // DexExpectStepOrder(5, on_line=ref('main')+7);
// DexExpectStepOrder(6, on_line=18); // DexExpectStepOrder(6, on_line=ref('main')+8);

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/expect_watch_type.cpp

// Purpose: // Purpose:
// Check that \DexExpectWatchType applies no penalties when expected // Check that \DexExpectWatchType applies no penalties when expected
// types are found. // types are found.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// TODO: On Windows WITH dbgeng, This test takes a long time to run and doesn't evaluate type values // TODO: On Windows WITH dbgeng, This test takes a long time to run and doesn't evaluate type values
// in the same manner as LLDB. // in the same manner as LLDB.
// XFAIL: system-windows // XFAIL: system-windows
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: expect_watch_type.cpp: // CHECK: expect_watch_type.cpp:
template<class T> template<class T>
class Doubled { class Doubled {
public: public:
Doubled(const T & to_double) Doubled(const T & to_double)
: m_member(to_double * 2) {} : m_member(to_double * 2) {}
Show All 35 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/expect_watch_value.cpp

// Purpose: // Purpose:
// Check that \DexExpectWatchValue applies no penalties when expected // Check that \DexExpectWatchValue applies no penalties when expected
// values are found. // values are found.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: expect_watch_value.cpp: // CHECK: expect_watch_value.cpp:
unsigned long Factorial(int n) { unsigned long Factorial(int n) {
volatile unsigned long fac = 1; // DexLabel('entry') volatile unsigned long fac = 1; // DexLabel('entry')
for (int i = 1; i <= n; ++i) for (int i = 1; i <= n; ++i)
fac *= i; // DexLabel('loop') fac *= i; // DexLabel('loop')
Show All 22 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/float_range_watch/float_range_multiple.cpp

// Purpose: // Purpose:
// Check that \DexExpectWatchValue float_range=0.5 considers a range // Check that \DexExpectWatchValue float_range=0.5 considers a range
// difference of 0.49999 to be an expected watch value for multple values. // difference of 0.49999 to be an expected watch value for multple values.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: float_range_multiple.cpp: // CHECK: float_range_multiple.cpp:
int main() { int main() {
float a = 1.0f; float a = 1.0f;
float b = 100.f; float b = 100.f;
a = a + 0.4999f; a = a + 0.4999f;
a = a + b; // DexLabel('check1') a = a + b; // DexLabel('check1')
return a; //DexLabel('check2') return a; //DexLabel('check2')
} }
// DexExpectWatchValue('a', '1.0', '101.0', from_line=ref('check1'), to_line=ref('check2'), float_range=0.5) // DexExpectWatchValue('a', '1.0', '101.0', from_line=ref('check1'), to_line=ref('check2'), float_range=0.5)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/float_range_watch/float_range_no_arg.cpp

// Purpose: // Purpose:
// Check that omitted float_range from \DexExpectWatchValue turns off // Check that omitted float_range from \DexExpectWatchValue turns off
// the floating point range evalution and defaults back to // the floating point range evalution and defaults back to
// pre-float evalution. // pre-float evalution.
// //
// Since this test involves string comparison to the debugger output, it cannot // Since this test involves string comparison to the debugger output, it cannot
// work for both dbgeng and lldb, which output floats differently. // work for both dbgeng and lldb, which output floats differently.
// UNSUPPORTED: system-darwin, system-windows // UNSUPPORTED: system-darwin, system-windows
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: float_range_no_arg.cpp: // CHECK: float_range_no_arg.cpp:
int main() { int main() {
float a = 1.0f; float a = 1.0f;
return a; //DexLabel('check') return a; //DexLabel('check')
} }
// DexExpectWatchValue('a', '1', on_line=ref('check')) // DexExpectWatchValue('a', '1', on_line=ref('check'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/float_range_watch/float_range_small.cpp

// Purpose: // Purpose:
// Check that \DexExpectWatchValue float_range=0.5 considers a range // Check that \DexExpectWatchValue float_range=0.5 considers a range
// difference of 0.49999 to be an expected watch value. // difference of 0.49999 to be an expected watch value.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: float_range_small.cpp: // CHECK: float_range_small.cpp:
int main() { int main() {
float a = 1.0f; float a = 1.0f;
a = a - 0.49999f; a = a - 0.49999f;
return a; //DexLabel('check') return a; //DexLabel('check')
} }
// DexExpectWatchValue('a', '1.0', on_line=ref('check'), float_range=0.5) // DexExpectWatchValue('a', '1.0', on_line=ref('check'), float_range=0.5)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/float_range_watch/float_range_zero_match.cpp

// Purpose: // Purpose:
// Check that \DexExpectWatchValue float_range=0.0 matches exact values. // Check that \DexExpectWatchValue float_range=0.0 matches exact values.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: float_range_zero_match.cpp: // CHECK: float_range_zero_match.cpp:
int main() { int main() {
float a = 1.0f; float a = 1.0f;
return a; //DexLabel('check') return a; //DexLabel('check')
} }
// DexExpectWatchValue('a', '1.0000000', on_line=ref('check'), float_range=0.0) // DexExpectWatchValue('a', '1.0000000', on_line=ref('check'), float_range=0.0)

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/hit_count.cpp

// Purpose: // Purpose:
// Test that \DexLimitSteps keyword argument hit_count correctly limits // Test that \DexLimitSteps keyword argument hit_count correctly limits
// the number of times the command can trigger. // the number of times the command can trigger.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: hit_count.cpp // CHECK: hit_count.cpp
int a; int a;
int main() { int main() {
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
a = i; // DexLabel('check') a = i; // DexLabel('check')
} }
return 0; return 0;
} }
//// Unconditionally limit dexter's view of the program to 'on_line' and check //// Unconditionally limit dexter's view of the program to 'on_line' and check
//// for i=0, i=1. The test will fail if dexter sees any other value for test. //// for i=0, i=1. The test will fail if dexter sees any other value for test.
// DexLimitSteps(hit_count=2, on_line=ref('check')) // DexLimitSteps(hit_count=2, on_line=ref('check'))
// DexExpectWatchValue('i', '0', '1') // DexExpectWatchValue('i', '0', '1')

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_check_json_step_count.cpp

// Purpose: // Purpose:
// Check number of step lines are correctly reported in json output. // Check number of step lines are correctly reported in json output.
// //
// RUN: %dexter_regression_test --verbose -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t --verbose -- %s | FileCheck %s
// CHECK: limit_steps_check_json_step_count.cpp // CHECK: limit_steps_check_json_step_count.cpp
// CHECK: ## BEGIN ## // CHECK: ## BEGIN ##
// CHECK-COUNT-3: json_step_count.cpp", // CHECK-COUNT-3: json_step_count.cpp",
int main() { int main() {
int result = 0; int result = 0;
for(int ix = 0; ix != 10; ++ix) { for(int ix = 0; ix != 10; ++ix) {
int index = ix; int index = ix;
result += index; // DexLabel('check') result += index; // DexLabel('check')
} }
} }
// DexExpectWatchValue('index', 2, 7, 9, on_line=ref('check')) // DexExpectWatchValue('index', 2, 7, 9, on_line=ref('check'))
// DexLimitSteps('ix', 2, 7, 9, on_line=ref('check')) // DexLimitSteps('ix', 2, 7, 9, on_line=ref('check'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_expect_loop.cpp

// Purpose: // Purpose:
// Check the DexLimit steps only gathers step info for 2 iterations of a // Check the DexLimit steps only gathers step info for 2 iterations of a
// for loop. // for loop.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: limit_steps_expect_loop.cpp: // CHECK: limit_steps_expect_loop.cpp:
int main(const int argc, const char * argv[]) { int main(const int argc, const char * argv[]) {
unsigned int sum = 1; unsigned int sum = 1;
for(unsigned int ix = 0; ix != 5; ++ix) { for(unsigned int ix = 0; ix != 5; ++ix) {
unsigned thing_to_add = ix + ix - ix; // DexLabel('start') unsigned thing_to_add = ix + ix - ix; // DexLabel('start')
sum += ix; // DexLabel('end') sum += ix; // DexLabel('end')
} }
return sum; return sum;
} }
// DexLimitSteps('ix', 0, 3, from_line=ref('start'), to_line=ref('end')) // DexLimitSteps('ix', 0, 3, from_line=ref('start'), to_line=ref('end'))
// DexExpectWatchValue('ix', 0, 3, from_line=ref('start'), to_line=ref('end')) // DexExpectWatchValue('ix', 0, 3, from_line=ref('start'), to_line=ref('end'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_expect_value.cpp

// Purpose: // Purpose:
// Ensure that limited stepping breaks for all expected values. // Ensure that limited stepping breaks for all expected values.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: limit_steps_expect_value.cpp // CHECK: limit_steps_expect_value.cpp
int main() { int main() {
int i = 0; int i = 0;
i = 1; // DexLabel('from') i = 1; // DexLabel('from')
i = 2; i = 2;
i = 3; i = 3;
return 0; // DexLabel('long_range') return 0; // DexLabel('long_range')
} }
// DexLimitSteps('i', '0', from_line=ref('from'), to_line=ref('long_range')) // DexLimitSteps('i', '0', from_line=ref('from'), to_line=ref('long_range'))
// DexExpectWatchValue('i', 0, 1, 2, 3, from_line=ref('from'), to_line=ref('long_range')) // DexExpectWatchValue('i', 0, 1, 2, 3, from_line=ref('from'), to_line=ref('long_range'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_line_mismatch.cpp

// Purpose: // Purpose:
// Check that \DexLimitSteps works even if the opening breakpoint line // Check that \DexLimitSteps works even if the opening breakpoint line
// doesn't exist. This can happen due to optimisations or label is on an // doesn't exist. This can happen due to optimisations or label is on an
// empty line. // empty line.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: limit_steps_line_mismatch.cpp // CHECK: limit_steps_line_mismatch.cpp
int main() { int main() {
int i = 0; int i = 0;
for (; i < 2; i++) { for (; i < 2; i++) {
// DexLabel('from') // DexLabel('from')
int x = i; int x = i;
} }
int ret = 0; int ret = 0;
return ret; // DexLabel('to') return ret; // DexLabel('to')
} }
// DexLimitSteps('1', '1', from_line=ref('from'), to_line=ref('to')) // DexLimitSteps('1', '1', from_line=ref('from'), to_line=ref('to'))
// DexExpectWatchValue('i', 0, 1, 2, from_line=ref('from'), to_line=ref('to')) // DexExpectWatchValue('i', 0, 1, 2, from_line=ref('from'), to_line=ref('to'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_overlapping_ranges.cpp

// Purpose: // Purpose:
// Ensure that multiple overlapping \DexLimitSteps ranges do not interfere. // Ensure that multiple overlapping \DexLimitSteps ranges do not interfere.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: limit_steps_overlapping_ranges.cpp // CHECK: limit_steps_overlapping_ranges.cpp
int main() { int main() {
int val1; int val1;
int val2; int val2;
int placeholder; int placeholder;
for (int ix = 0; ix != 10; ++ix) { for (int ix = 0; ix != 10; ++ix) {
placeholder=val1+val2; // DexLabel('from') placeholder=val1+val2; // DexLabel('from')
Show All 22 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_same_line_conditional.cpp

// Purpose: // Purpose:
// Test that LimitStep commands can exist on the same from line. // Test that LimitStep commands can exist on the same from line.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: limit_steps_same_line_conditional.cpp // CHECK: limit_steps_same_line_conditional.cpp
int main() { int main() {
int val1 = 0; int val1 = 0;
int placeholder; int placeholder;
for(int ix = 0; ix != 4; ++ix) { for(int ix = 0; ix != 4; ++ix) {
val1 = ix; val1 = ix;
Show All 12 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/unconditional.cpp

// Purpose: // Purpose:
// Test that \DexLimitSteps can be used without a condition (i.e. the // Test that \DexLimitSteps can be used without a condition (i.e. the
// breakpoint range is set any time from_line is stepped on). // breakpoint range is set any time from_line is stepped on).
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: unconditional.cpp // CHECK: unconditional.cpp
int glob; int glob;
int main() { int main() {
int test = 0; int test = 0;
for (test = 1; test < 4; test++) { for (test = 1; test < 4; test++) {
glob += test; // DexLabel('from') glob += test; // DexLabel('from')
glob += test; // DexLabel('to') glob += test; // DexLabel('to')
Show All 10 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/unreachable.cpp

// Purpose: // Purpose:
// Check that \DexUnreachable has no effect if the command line is never // Check that \DexUnreachable has no effect if the command line is never
// stepped on. // stepped on.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: unreachable.cpp: // CHECK: unreachable.cpp:
int main() int main()
{ {
return 0; return 0;
return 1; // DexUnreachable() return 1; // DexUnreachable()
} }

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/unreachable_not_cmd_lineno.cpp

// Purpose: // Purpose:
// Check that \DexUnreachable doesn't trigger on the line it's specified // Check that \DexUnreachable doesn't trigger on the line it's specified
// on, if it has a specifier indicating which lines should be unreachable. // on, if it has a specifier indicating which lines should be unreachable.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: unreachable_not_cmd_lineno.cpp: // CHECK: unreachable_not_cmd_lineno.cpp:
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
if (argc != 1) if (argc != 1)
return 1; // DexLabel('this_one') return 1; // DexLabel('this_one')
else else
return 0; // DexUnreachable(on_line=ref('this_one')) DexUnreachable(from_line=ref('this_one'), to_line=ref('this_one')) return 0; // DexUnreachable(on_line=ref('this_one')) DexUnreachable(from_line=ref('this_one'), to_line=ref('this_one'))
} }

cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/unreachable_on_line.cpp

// Purpose: // Purpose:
// Check that \DexUnreachable has no effect if the command line is never // Check that \DexUnreachable has no effect if the command line is never
// stepped on. // stepped on.
// //
// UNSUPPORTED: system-darwin // UNSUPPORTED: system-darwin
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: unreachable_on_line.cpp: // CHECK: unreachable_on_line.cpp:
int main() int main()
{ {
return 0; return 0;
return 1; // DexLabel('this_one') return 1; // DexLabel('this_one')
} }
// DexUnreachable(on_line=ref('this_one')) // DexUnreachable(on_line=ref('this_one'))
// DexUnreachable(from_line=ref('this_one'), to_line=ref('this_one')) // DexUnreachable(from_line=ref('this_one'), to_line=ref('this_one'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/clang-opt-bisect/clang-opt-bisect-results.cpp

  • This file was deleted.
// Purpose:
// Check the `clang-opt-bisect` tool runs with --results-directory.
//
// RUN: true
// RUN: %dexter_base clang-opt-bisect \
// RUN: --debugger %dexter_regression_test_debugger \
// RUN: --builder %dexter_regression_test_builder \
// RUN: --cflags "%dexter_regression_test_cflags" \
// RUN: --ldflags "%dexter_regression_test_ldflags" \
// RUN: --results-directory=%t \
// RUN: -- %s \
// RUN: | FileCheck %s
//// Clean up those results files.
// RUN: rm %t/clang-opt-bisect-results.cpp-pass-summary.csv
// RUN: rm %t/clang-opt-bisect-results.cpp-per_pass_score.csv
// RUN: rm %t/overall-pass-summary.csv
// RUN: rm %t/*.dextIR
// RUN: rm %t/*.txt
// RUN: rmdir %t
// CHECK: running pass 0
// CHECK: wrote{{.*}}per_pass_score
// CHECK: wrote{{.*}}pass-summary
// CHECK: wrote{{.*}}overall-pass-summary
int main() {
return 0;
}

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/clang-opt-bisect/clang-opt-bisect.cpp

  • This file was deleted.
// Purpose:
// Check the `clang-opt-bisect` tool runs with typical input.
//
// RUN: true
// RUN: %dexter_base clang-opt-bisect \
// RUN: --debugger %dexter_regression_test_debugger \
// RUN: --builder %dexter_regression_test_builder \
// RUN: --cflags "%dexter_regression_test_cflags" \
// RUN: --ldflags "%dexter_regression_test_ldflags" \
// RUN: -- %s \
// RUN: | FileCheck %s
// CHECK: running pass 0
int main() {
return 0;
}

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/help/help.test

Purpose: Purpose:
Check the `help` subtool runs. Check the `help` subtool runs.
RUN: %dexter_base help | FileCheck %s RUN: %dexter_base help | FileCheck %s
CHECK: The following subtools are available: CHECK: The following subtools are available:
CHECK: clang-opt-bisect
CHECK: help CHECK: help
CHECK: list-debuggers CHECK: list-debuggers
CHECK: test CHECK: test
CHECK: view CHECK: view

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/address_printing.cpp

// Purpose: // Purpose:
// Test that address values in a \DexExpectWatchValue are printed with // Test that address values in a \DexExpectWatchValue are printed with
// their address name along with the address' resolved value (if any), and // their address name along with the address' resolved value (if any), and
// that when verbose output is enabled the complete map of resolved // that when verbose output is enabled the complete map of resolved
// addresses and list of unresolved addresses will also be printed. // addresses and list of unresolved addresses will also be printed.
// //
// Note: Currently "misordered result" is the only penalty that does not // Note: Currently "misordered result" is the only penalty that does not
// display the address properly; if it is implemented, this test should be // display the address properly; if it is implemented, this test should be
// updated. // updated.
// //
// The dbgeng driver doesn't support \DexLimitSteps yet. // The dbgeng driver doesn't support \DexLimitSteps yet.
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: not %dexter_regression_test -v -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -v -- %s | FileCheck %s
// CHECK: Resolved Addresses: // CHECK: Resolved Addresses:
// CHECK-NEXT: 'x_2': 0x[[X2_VAL:[0-9a-f]+]] // CHECK-NEXT: 'x_2': 0x[[X2_VAL:[0-9a-f]+]]
// CHECK-NEXT: 'y': 0x[[Y_VAL:[0-9a-f]+]] // CHECK-NEXT: 'y': 0x[[Y_VAL:[0-9a-f]+]]
// CHECK: Unresolved Addresses: // CHECK: Unresolved Addresses:
// CHECK-NEXT: ['x_1'] // CHECK-NEXT: ['x_1']
// CHECK-LABEL: [x] ExpectValue // CHECK-LABEL: [x] ExpectValue
Show All 30 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/err_bad_label_ref.cpp

// Purpose: // Purpose:
// Check that referencing an undefined label gives a useful error message. // Check that referencing an undefined label gives a useful error message.
// //
// RUN: not %dexter_regression_test -v -- %s | FileCheck %s --match-full-lines // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -v -- %s | FileCheck %s --match-full-lines
// //
// CHECK: parser error:{{.*}}err_bad_label_ref.cpp(14): Unresolved label: 'label_does_not_exist' // CHECK: parser error:{{.*}}err_bad_label_ref.cpp(15): Unresolved label: 'label_does_not_exist'
// CHECK-NEXT: {{Dex}}ExpectWatchValue('result', '0', on_line=ref('label_does_not_exist')) // CHECK-NEXT: {{Dex}}ExpectWatchValue('result', '0', on_line=ref('label_does_not_exist'))
int main() { int main() {
int result = 0; int result = 0;
return result; return result;
} }
// DexExpectWatchValue('result', '0', on_line=ref('label_does_not_exist')) // DexExpectWatchValue('result', '0', on_line=ref('label_does_not_exist'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/err_duplicate_address.cpp

// Purpose: // Purpose:
// Check that declaring duplicate addresses gives a useful error message. // Check that declaring duplicate addresses gives a useful error message.
// //
// RUN: not %dexter_regression_test -v -- %s | FileCheck %s --match-full-lines // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -v -- %s | FileCheck %s --match-full-lines
int main() { int main() {
int *result = new int(0); int *result = new int(0);
delete result; // DexLabel('test_line') delete result; // DexLabel('test_line')
} }
// CHECK: parser error:{{.*}}err_duplicate_address.cpp([[# @LINE + 4]]): Found duplicate address: 'oops' // CHECK: parser error:{{.*}}err_duplicate_address.cpp([[# @LINE + 4]]): Found duplicate address: 'oops'
// CHECK-NEXT: {{Dex}}DeclareAddress('oops', 'result', on_line=ref('test_line')) // CHECK-NEXT: {{Dex}}DeclareAddress('oops', 'result', on_line=ref('test_line'))
// DexDeclareAddress('oops', 'result', on_line=ref('test_line')) // DexDeclareAddress('oops', 'result', on_line=ref('test_line'))
// DexDeclareAddress('oops', 'result', on_line=ref('test_line')) // DexDeclareAddress('oops', 'result', on_line=ref('test_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/err_duplicate_label.cpp

// Purpose: // Purpose:
// Check that defining duplicate labels gives a useful error message. // Check that defining duplicate labels gives a useful error message.
// //
// RUN: not %dexter_regression_test -v -- %s | FileCheck %s --match-full-lines // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -v -- %s | FileCheck %s --match-full-lines
// //
// CHECK: parser error:{{.*}}err_duplicate_label.cpp(11): Found duplicate line label: 'oops' // CHECK: parser error:{{.*}}err_duplicate_label.cpp(12): Found duplicate line label: 'oops'
// CHECK-NEXT: {{Dex}}Label('oops') // CHECK-NEXT: {{Dex}}Label('oops')
int main() { int main() {
int result = 0; // DexLabel('oops') int result = 0; // DexLabel('oops')
return result; // DexLabel('oops') return result; // DexLabel('oops')
} }

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/err_paren.cpp

// Purpose: // Purpose:
// Check that parsing bad commands gives a useful error. // Check that parsing bad commands gives a useful error.
// - Unbalanced parenthesis // - Unbalanced parenthesis
// Check directives are in check.txt to prevent dexter reading any embedded // Check directives are in check.txt to prevent dexter reading any embedded
// commands. // commands.
// //
// Note: Despite using 'lldb' as the debugger, lldb is not actually required // Note: Despite using 'lldb' as the debugger, lldb is not actually required
// as the test should finish before lldb would be invoked. // as the test should finish before lldb would be invoked.
// //
// RUN: not %dexter_base test --builder 'clang' --debugger 'lldb' \ // RUN: %dexter_regression_test_build %s -o %t
// RUN: --cflags "-O0 -g" -v -- %s \ // RUN: not %dexter_base test --binary %t --debugger 'lldb' \
// RUN: | FileCheck %s --match-full-lines --strict-whitespace // RUN: -v -- %s | FileCheck %s --match-full-lines --strict-whitespace
// //
// CHECK:parser error:{{.*}}err_paren.cpp(22): Unbalanced parenthesis starting here // CHECK:parser error:{{.*}}err_paren.cpp(22): Unbalanced parenthesis starting here
// CHECK:// {{Dex}}ExpectWatchValue( // CHECK:// {{Dex}}ExpectWatchValue(
// CHECK: ^ // CHECK: ^
int main(){ int main(){
return 0; return 0;
} }
// DexExpectWatchValue( // DexExpectWatchValue(

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/err_paren_mline.cpp

// Purpose: // Purpose:
// Check that parsing bad commands gives a useful error. // Check that parsing bad commands gives a useful error.
// - Unbalanced parenthesis over multiple lines // - Unbalanced parenthesis over multiple lines
// Check directives are in check.txt to prevent dexter reading any embedded // Check directives are in check.txt to prevent dexter reading any embedded
// commands. // commands.
// //
// Note: Despite using 'lldb' as the debugger, lldb is not actually required // Note: Despite using 'lldb' as the debugger, lldb is not actually required
// as the test should finish before lldb would be invoked. // as the test should finish before lldb would be invoked.
// //
// RUN: not %dexter_base test --builder 'clang' --debugger "lldb" \ // RUN: %dexter_regression_test_build %s -o %t
// RUN: --cflags "-O0 -g" -v -- %s \ // RUN: not %dexter_base test --binary %t --debugger "lldb" \
// RUN: | FileCheck %s --match-full-lines --strict-whitespace // RUN: -v -- %s | FileCheck %s --match-full-lines --strict-whitespace
// //
// CHECK:parser error:{{.*}}err_paren_mline.cpp(23): Unbalanced parenthesis starting here // CHECK:parser error:{{.*}}err_paren_mline.cpp(23): Unbalanced parenthesis starting here
// CHECK:{{Dex}}ExpectWatchValue( // CHECK:{{Dex}}ExpectWatchValue(
// CHECK: ^ // CHECK: ^
int main(){ int main(){
return 0; return 0;
} }
/* /*
DexExpectWatchValue( DexExpectWatchValue(
1 1
*/ */

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/err_syntax.cpp

// Purpose: // Purpose:
// Check that parsing bad commands gives a useful error. // Check that parsing bad commands gives a useful error.
// - Syntax error (misplaced ',') // - Syntax error (misplaced ',')
// Check directives are in check.txt to prevent dexter reading any embedded // Check directives are in check.txt to prevent dexter reading any embedded
// commands. // commands.
// //
// Note: Despite using 'lldb' as the debugger, lldb is not actually required // Note: Despite using 'lldb' as the debugger, lldb is not actually required
// as the test should finish before lldb would be invoked. // as the test should finish before lldb would be invoked.
// //
// RUN: not %dexter_base test --builder 'clang' --debugger "lldb" \ // RUN: %dexter_regression_test_build %s -o %t
// RUN: --cflags "-O0 -g" -v -- %s \ // RUN: not %dexter_base test --binary %t --debugger "lldb" \
// RUN: | FileCheck %s --match-full-lines --strict-whitespace // RUN: -v -- %s | FileCheck %s --match-full-lines --strict-whitespace
// //
// CHECK:parser error:{{.*}}err_syntax.cpp(21): invalid syntax // CHECK:parser error:{{.*}}err_syntax.cpp(21): invalid syntax
// CHECK:// {{Dex}}ExpectWatchValue(,'a', 3, 3, 3, 3, on_line=0) // CHECK:// {{Dex}}ExpectWatchValue(,'a', 3, 3, 3, 3, on_line=0)
// CHECK: ^ // CHECK: ^
int main(){ int main(){
return 0; return 0;
} }
// DexExpectWatchValue(,'a', 3, 3, 3, 3, on_line=0) // DexExpectWatchValue(,'a', 3, 3, 3, 3, on_line=0)

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/err_syntax_mline.cpp

// Purpose: // Purpose:
// Check that parsing bad commands gives a useful error. // Check that parsing bad commands gives a useful error.
// - Syntax error (misplaced ',') over multiple lines // - Syntax error (misplaced ',') over multiple lines
// Check directives are in check.txt to prevent dexter reading any embedded // Check directives are in check.txt to prevent dexter reading any embedded
// commands. // commands.
// //
// Note: Despite using 'lldb' as the debugger, lldb is not actually required // Note: Despite using 'lldb' as the debugger, lldb is not actually required
// as the test should finish before lldb would be invoked. // as the test should finish before lldb would be invoked.
// //
// RUN: not %dexter_base test --builder 'clang' --debugger "lldb" \ // RUN: %dexter_regression_test_build %s -o %t
// RUN: --cflags "-O0 -g" -v -- %s \ // RUN: not %dexter_base test --binary %t --debugger "lldb" \
// RUN: | FileCheck %s --match-full-lines --strict-whitespace // RUN: -v -- %s | FileCheck %s --match-full-lines --strict-whitespace
// //
// CHECK:parser error:{{.*}}err_syntax_mline.cpp(24): invalid syntax // CHECK:parser error:{{.*}}err_syntax_mline.cpp(24): invalid syntax
// CHECK: ,'a', 3, 3, 3, 3, on_line=0) // CHECK: ,'a', 3, 3, 3, 3, on_line=0)
// CHECK: ^ // CHECK: ^
int main(){ int main(){
return 0; return 0;
} }
/* /*
DexExpectWatchValue( DexExpectWatchValue(
,'a', 3, 3, 3, 3, on_line=0) ,'a', 3, 3, 3, 3, on_line=0)
*/ */

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/err_type.cpp

// Purpose: // Purpose:
// Check that parsing bad commands gives a useful error. // Check that parsing bad commands gives a useful error.
// - Type error (missing args) // - Type error (missing args)
// Check directives are in check.txt to prevent dexter reading any embedded // Check directives are in check.txt to prevent dexter reading any embedded
// commands. // commands.
// //
// Note: Despite using 'lldb' as the debugger, lldb is not actually required // Note: Despite using 'lldb' as the debugger, lldb is not actually required
// as the test should finish before lldb would be invoked. // as the test should finish before lldb would be invoked.
// //
// RUN: not %dexter_base test --builder 'clang' --debugger "lldb" \ // RUN: %dexter_regression_test_build %s -o %t
// RUN: --cflags "-O0 -g" -v -- %s \ // RUN: not %dexter_base test --binary %t --debugger "lldb" \
// RUN: | FileCheck %s --match-full-lines --strict-whitespace // RUN: -v -- %s | FileCheck %s --match-full-lines --strict-whitespace
// //
// CHECK:parser error:{{.*}}err_type.cpp(21): expected at least two args // CHECK:parser error:{{.*}}err_type.cpp(21): expected at least two args
// CHECK:// {{Dex}}ExpectWatchValue() // CHECK:// {{Dex}}ExpectWatchValue()
// CHECK: ^ // CHECK: ^
int main(){ int main(){
return 0; return 0;
} }
// DexExpectWatchValue() // DexExpectWatchValue()

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/err_type_mline.cpp

// Purpose: // Purpose:
// Check that parsing bad commands gives a useful error. // Check that parsing bad commands gives a useful error.
// - Type error (missing args) over multple lines // - Type error (missing args) over multple lines
// Check directives are in check.txt to prevent dexter reading any embedded // Check directives are in check.txt to prevent dexter reading any embedded
// commands. // commands.
// //
// Note: Despite using 'lldb' as the debugger, lldb is not actually required // Note: Despite using 'lldb' as the debugger, lldb is not actually required
// as the test should finish before lldb would be invoked. // as the test should finish before lldb would be invoked.
// //
// RUN: not %dexter_base test --builder 'clang' --debugger "lldb" \ // RUN: %dexter_regression_test_build %s -o %t
// RUN: --cflags "-O0 -g" -v -- %s \ // RUN: not %dexter_base test --binary %t --debugger "lldb" \
// RUN: | FileCheck %s --match-full-lines --strict-whitespace // RUN: -v -- %s | FileCheck %s --match-full-lines --strict-whitespace
// //
// CHECK:parser error:{{.*}}err_type_mline.cpp(22): expected at least two args // CHECK:parser error:{{.*}}err_type_mline.cpp(22): expected at least two args
// CHECK:{{Dex}}ExpectWatchValue( // CHECK:{{Dex}}ExpectWatchValue(
// CHECK: ^ // CHECK: ^
int main(){ int main(){
return 0; return 0;
} }
/* /*
DexExpectWatchValue( DexExpectWatchValue(
'a' 'a'
) )
*/ */

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/err_undeclared_addr.cpp

// Purpose: // Purpose:
// Check that using an undeclared address gives a useful error message. // Check that using an undeclared address gives a useful error message.
// //
// RUN: not %dexter_regression_test -v -- %s | FileCheck %s --match-full-lines // RUN: %dexter_regression_test_build %s -o %t
// RUN: not %dexter_regression_test_run --binary %t -v -- %s | FileCheck %s --match-full-lines
int main() { int main() {
int *result = new int(0); int *result = new int(0);
delete result; // DexLabel('test_line') delete result; // DexLabel('test_line')
} }
// CHECK: parser error:{{.*}}err_undeclared_addr.cpp([[# @LINE + 3]]): Undeclared address: 'result' // CHECK: parser error:{{.*}}err_undeclared_addr.cpp([[# @LINE + 3]]): Undeclared address: 'result'
// CHECK-NEXT: {{Dex}}ExpectWatchValue('result', address('result'), on_line=ref('test_line')) // CHECK-NEXT: {{Dex}}ExpectWatchValue('result', address('result'), on_line=ref('test_line'))
// DexExpectWatchValue('result', address('result'), on_line=ref('test_line')) // DexExpectWatchValue('result', address('result'), on_line=ref('test_line'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/label_another_line.cpp

// Purpose: // Purpose:
// Check that the optional keyword argument 'on_line' makes a \DexLabel label // Check that the optional keyword argument 'on_line' makes a \DexLabel label
// that line instead of the line the command is found on. // that line instead of the line the command is found on.
// //
// RUN: %dexter_regression_test -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -- %s | FileCheck %s
// CHECK: label_another_line.cpp: (1.0000) // CHECK: label_another_line.cpp: (1.0000)
int main() { int main() {
int result = 0; int result = 0;
return result; return result;
} }
// DexLabel('test', on_line=10) // DexLabel('test', on_line=11)
// DexExpectWatchValue('result', '0', on_line=ref('test')) // DexExpectWatchValue('result', '0', on_line=ref('test'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/label_offset.cpp

// Purpose: // Purpose:
// Check that we can use label-relative line numbers. // Check that we can use label-relative line numbers.
// //
// RUN: %dexter_regression_test -v -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t -v -- %s | FileCheck %s
// //
// CHECK: label_offset.cpp: (1.0000) // CHECK: label_offset.cpp: (1.0000)
int main() { // DexLabel('main') int main() { // DexLabel('main')
int var = 0; int var = 0;
var = var; var = var;
return 0; return 0;
} }
Show All 12 Lines

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/source-root-dir.cpp

// This test started failing recently for unknown reasons. // This test started failing recently for unknown reasons.
// XFAIL:* // XFAIL:*
// RUN: %dexter_regression_test_build \
// RUN: -fdebug-prefix-map=%S=/changed %s -o %t
// RUN: %dexter --fail-lt 1.0 -w \ // RUN: %dexter --fail-lt 1.0 -w \
// RUN: --builder %dexter_regression_test_builder \ // RUN: --binary %t \
// RUN: --debugger %dexter_regression_test_debugger \ // RUN: --debugger %dexter_regression_test_debugger \
// RUN: --cflags "%dexter_regression_test_cflags -fdebug-prefix-map=%S=/changed" \
// RUN: --ldflags "%dexter_regression_test_ldflags" \
// RUN: --source-root-dir=%S --debugger-use-relative-paths -- %s // RUN: --source-root-dir=%S --debugger-use-relative-paths -- %s
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int x = 42; int x = 42;
printf("hello world: %d\n", x); // DexLabel('check') printf("hello world: %d\n", x); // DexLabel('check')
} }
// DexExpectWatchValue('x', 42, on_line=ref('check')) // DexExpectWatchValue('x', 42, on_line=ref('check'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/target_run_args.c

// The dbgeng driver doesn't support --target-run-args yet. // The dbgeng driver doesn't support --target-run-args yet.
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: %dexter_regression_test --target-run-args "a b 'c d'" -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t --target-run-args "a b 'c d'" -- %s | FileCheck %s
// CHECK: target_run_args.c: // CHECK: target_run_args.c:
int main(int argc, const char **argv) { int main(int argc, const char **argv) {
if (argc == 4) if (argc == 4)
return 0; // DexLabel('retline') return 0; // DexLabel('retline')
return 1; // DexUnreachable() return 1; // DexUnreachable()
} }
// DexExpectWatchValue('argc', '4', on_line=ref('retline')) // DexExpectWatchValue('argc', '4', on_line=ref('retline'))
// DexExpectWatchValue('argv[1][0]', "'a'", on_line=ref('retline')) // DexExpectWatchValue('argv[1][0]', "'a'", on_line=ref('retline'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/test/target_run_args_with_command.c

// The dbgeng driver doesn't support --target-run-args yet. // The dbgeng driver doesn't support --target-run-args yet.
// UNSUPPORTED: system-windows // UNSUPPORTED: system-windows
// //
// RUN: %dexter_regression_test --target-run-args "a b 'c d'" -- %s | FileCheck %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t --target-run-args "a b 'c d'" -- %s | FileCheck %s
// CHECK: target_run_args_with_command.c: // CHECK: target_run_args_with_command.c:
int main(int argc, const char **argv) { int main(int argc, const char **argv) {
if (argc == 6) if (argc == 6)
return 0; // DexLabel('retline') return 0; // DexLabel('retline')
return 1; // DexUnreachable() return 1; // DexUnreachable()
} }
// DexCommandLine(['e', 'f']) // DexCommandLine(['e', 'f'])
// DexExpectWatchValue('argc', '6', on_line=ref('retline')) // DexExpectWatchValue('argc', '6', on_line=ref('retline'))
// DexExpectWatchValue('argv[1][0]', "'e'", on_line=ref('retline')) // DexExpectWatchValue('argv[1][0]', "'e'", on_line=ref('retline'))

cross-project-tests/debuginfo-tests/dexter/feature_tests/subtools/view.cpp

// Purpose: // Purpose:
// Check the `view` subtool works with typical inputs. // Check the `view` subtool works with typical inputs.
// //
// RUN: %dexter_regression_test --results %t -- %s // RUN: %dexter_regression_test_build %s -o %t
// RUN: %dexter_regression_test_run --binary %t --results %t.results -- %s
// //
// RUN: %dexter_base view %t/view.cpp.dextIR | FileCheck %s // RUN: %dexter_base view %t.results/view.cpp.dextIR | FileCheck %s
// CHECK: ## BEGIN // CHECK: ## BEGIN
// CHECK: ## END // CHECK: ## END
// //
// # [TODO] This doesn't run if FileCheck fails! // # [TODO] This doesn't run if FileCheck fails!
// RUN: rm -rf %t // RUN: rm -rf %t
int main() { int main() {
int a = 0; int a = 0;
return 0; //DexLabel('ret') return 0; //DexLabel('ret')
} }
// DexExpectWatchValue('a', '0', on_line=ref('ret')) // DexExpectWatchValue('a', '0', on_line=ref('ret'))

cross-project-tests/lit.cfg.py

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Linesdef configure_dexter_substitutions():
tools.append(ToolSubst("%dexter_base", dexter_base_cmd)) tools.append(ToolSubst("%dexter_base", dexter_base_cmd))
# Set up commands for DexTer regression tests. # Set up commands for DexTer regression tests.
# Builder, debugger, optimisation level and several other flags differ # Builder, debugger, optimisation level and several other flags differ
# depending on whether we're running a unix like or windows os. # depending on whether we're running a unix like or windows os.
if platform.system() == "Windows": if platform.system() == "Windows":
# The Windows builder script uses lld. # The Windows builder script uses lld.
dependencies = ["clang", "lld-link"] dependencies = ["clang", "lld-link"]
dexter_regression_test_builder = "clang-cl_vs2015" dexter_regression_test_builder = "clang-cl"
dexter_regression_test_debugger = "dbgeng" dexter_regression_test_debugger = "dbgeng"
dexter_regression_test_cflags = "/Zi /Od" dexter_regression_test_flags = "/Zi /Od"
dexter_regression_test_ldflags = "/Zi"
else: else:
# Use lldb as the debugger on non-Windows platforms. # Use lldb as the debugger on non-Windows platforms.
dependencies = ["clang", "lldb"] dependencies = ["clang", "lldb"]
dexter_regression_test_builder = "clang" dexter_regression_test_builder = "clang++"
dexter_regression_test_debugger = "lldb" dexter_regression_test_debugger = "lldb"
dexter_regression_test_cflags = "-O0 -glldb" dexter_regression_test_flags = "-O0 -glldb"
dexter_regression_test_ldflags = ""
tools.append( tools.append(
ToolSubst("%dexter_regression_test_builder", dexter_regression_test_builder) ToolSubst("%dexter_regression_test_builder", dexter_regression_test_builder)
) )
tools.append( tools.append(
ToolSubst("%dexter_regression_test_debugger", dexter_regression_test_debugger) ToolSubst("%dexter_regression_test_debugger", dexter_regression_test_debugger)
) )
# We don't need to distinguish cflags and ldflags because for Dexter
# regression tests we use clang to drive the linker, and so all flags will be
# passed in a single command.
tools.append( tools.append(
ToolSubst("%dexter_regression_test_cflags", dexter_regression_test_cflags) ToolSubst("%dexter_regression_test_flags", dexter_regression_test_flags)
)
tools.append(
ToolSubst("%dexter_regression_test_ldflags", dexter_regression_test_cflags)
) )
# Typical command would take the form: # Typical command would take the form:
# ./path_to_py/python.exe ./path_to_dex/dexter.py test --fail-lt 1.0 -w --builder clang --debugger lldb --cflags '-O0 -g' # ./path_to_py/python.exe ./path_to_dex/dexter.py test --fail-lt 1.0 -w --binary %t --debugger lldb --cflags '-O0 -g'
# Exclude build flags for %dexter_regression_base. dexter_regression_test_run = " ".join(
dexter_regression_test_base = " ".join(
# "python", "dexter.py", test, fail_mode, builder, debugger, cflags, ldflags # "python", "dexter.py", test, fail_mode, builder, debugger, cflags, ldflags
[ [
'"{}"'.format(sys.executable), '"{}"'.format(sys.executable),
'"{}"'.format(dexter_path), '"{}"'.format(dexter_path),
"test", "test",
"--fail-lt 1.0 -w", "--fail-lt 1.0 -w",
"--debugger", "--debugger",
dexter_regression_test_debugger, dexter_regression_test_debugger,
] ]
) )
tools.append(ToolSubst("%dexter_regression_base", dexter_regression_test_base)) tools.append(ToolSubst("%dexter_regression_test_run", dexter_regression_test_run))
# Include build flags for %dexter_regression_test. # Include build flags for %dexter_regression_test.
dexter_regression_test_build = " ".join( dexter_regression_test_build = " ".join(
[ [
dexter_regression_test_base,
"--builder",
dexter_regression_test_builder, dexter_regression_test_builder,
'--cflags "', dexter_regression_test_flags,
dexter_regression_test_cflags + '"',
'--ldflags "',
dexter_regression_test_ldflags + '"',
] ]
) )
tools.append(ToolSubst("%dexter_regression_test", dexter_regression_test_build)) tools.append(ToolSubst("%dexter_regression_test_build", dexter_regression_test_build))
return dependencies return dependencies
def add_host_triple(clang): def add_host_triple(clang):
return "{} --target={}".format(clang, config.host_triple) return "{} --target={}".format(clang, config.host_triple)
# The set of arches we can build. # The set of arches we can build.
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines
cross-project-tests/debuginfo-tests/dexter/feature_tests/commands/perfect/unreachable_on_line.cpp