name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
Catch::makeCommandLineParser()
|
inline Clara::CommandLine<ConfigData> makeCommandLineParser() {
using namespace Clara;
CommandLine<ConfigData> cli;
cli.bindProcessName( &ConfigData::processName );
cli["-?"]["-h"]["--help"]
.describe( "display usage information" )
.bind( &ConfigData::showHelp );
cli["-l"]["--list-tests"]
.describe( "list all/matching test cases" )
.bind( &ConfigData::listTests );
cli["-t"]["--list-tags"]
.describe( "list all/matching tags" )
.bind( &ConfigData::listTags );
cli["-s"]["--success"]
.describe( "include successful tests in output" )
.bind( &ConfigData::showSuccessfulTests );
cli["-b"]["--break"]
.describe( "break into debugger on failure" )
.bind( &ConfigData::shouldDebugBreak );
cli["-e"]["--nothrow"]
.describe( "skip exception tests" )
.bind( &ConfigData::noThrow );
cli["-i"]["--invisibles"]
.describe( "show invisibles (tabs, newlines)" )
.bind( &ConfigData::showInvisibles );
cli["-o"]["--out"]
.describe( "output filename" )
.bind( &ConfigData::outputFilename, "filename" );
cli["-r"]["--reporter"]
// .placeholder( "name[:filename]" )
.describe( "reporter to use (defaults to console)" )
.bind( &addReporterName, "name" );
cli["-n"]["--name"]
.describe( "suite name" )
.bind( &ConfigData::name, "name" );
cli["-a"]["--abort"]
.describe( "abort at first failure" )
.bind( &abortAfterFirst );
cli["-x"]["--abortx"]
.describe( "abort after x failures" )
.bind( &abortAfterX, "no. failures" );
cli["-w"]["--warn"]
.describe( "enable warnings" )
.bind( &addWarning, "warning name" );
// - needs updating if reinstated
// cli.into( &setVerbosity )
// .describe( "level of verbosity (0=no output)" )
// .shortOpt( "v")
// .longOpt( "verbosity" )
// .placeholder( "level" );
cli[_]
.describe( "which test or tests to use" )
.bind( &addTestOrTags, "test name, pattern or tags" );
cli["-d"]["--durations"]
.describe( "show test durations" )
.bind( &setShowDurations, "yes/no" );
cli["-f"]["--input-file"]
.describe( "load test names to run from a file" )
.bind( &loadTestNamesFromFile, "filename" );
cli["-#"]["--filenames-as-tags"]
.describe( "adds a tag for the filename" )
.bind( &ConfigData::filenamesAsTags );
// Less common commands which don't have a short form
cli["--list-test-names-only"]
.describe( "list all/matching test cases names only" )
.bind( &ConfigData::listTestNamesOnly );
cli["--list-reporters"]
.describe( "list all reporters" )
.bind( &ConfigData::listReporters );
cli["--order"]
.describe( "test case order (defaults to decl)" )
.bind( &setOrder, "decl|lex|rand" );
cli["--rng-seed"]
.describe( "set a specific seed for random numbers" )
.bind( &setRngSeed, "'time'|number" );
cli["--force-colour"]
.describe( "force colourised output" )
.bind( &ConfigData::forceColour );
return cli;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movl $0x8, %edi
callq 0x2d3a0
leaq 0x2cdef(%rip), %rcx # 0x81698
movq %rcx, (%rax)
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
leaq 0x28(%rbx), %rcx
movl $0x0, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movq %rcx, 0x40(%rbx)
movq %rax, 0x55(%rbx)
movups %xmm0, 0x48(%rbx)
movl $0x68, %esi
movq %rbx, %rdi
callq 0x55d5e
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x14c4b(%rip), %rsi # 0x69543
leaq 0x14c46(%rip), %rdx # 0x69545
leaq 0x28(%rsp), %rdi
callq 0x3ef3e
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x14c1c(%rip), %rsi # 0x69546
leaq 0x14c17(%rip), %rdx # 0x69548
leaq 0x8(%rsp), %rdi
callq 0x3ef3e
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x14bf0(%rip), %rsi # 0x69549
leaq 0x14bef(%rip), %rdx # 0x6954f
leaq 0x48(%rsp), %rdi
callq 0x3ef3e
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x56bbc
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x14bc8(%rip), %rsi # 0x69550
leaq 0x14bda(%rip), %rdx # 0x69569
leaq 0x68(%rsp), %rdi
callq 0x3ef3e
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x68(%rsp), %rsi
callq 0x2d1e0
movq %rsp, %rdi
movl $0x7, %esi
callq 0x55efc
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x549c7
callq 0x2d360
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x549d6
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x549e5
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x549f4
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14b67(%rip), %rsi # 0x6956a
leaq 0x14b62(%rip), %rdx # 0x6956c
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x14b3d(%rip), %rsi # 0x6956d
leaq 0x14b42(%rip), %rdx # 0x69579
callq 0x3ef3e
movq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x14b20(%rip), %rsi # 0x6957a
leaq 0x14b35(%rip), %rdx # 0x69596
callq 0x3ef3e
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x55efc
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x54a94
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x54aa3
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x54ab2
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14ad6(%rip), %rsi # 0x69597
leaq 0x14ad1(%rip), %rdx # 0x69599
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x14aac(%rip), %rsi # 0x6959a
leaq 0x14ab0(%rip), %rdx # 0x695a5
callq 0x3ef3e
movq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x14a8e(%rip), %rsi # 0x695a6
leaq 0x14a9d(%rip), %rdx # 0x695bc
callq 0x3ef3e
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movl $0x1, %esi
callq 0x55efc
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x54b55
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x54b64
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x54b73
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14a3b(%rip), %rsi # 0x695bd
leaq 0x14a36(%rip), %rdx # 0x695bf
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x14a11(%rip), %rsi # 0x695c0
leaq 0x14a13(%rip), %rdx # 0x695c9
callq 0x3ef3e
movq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x149f1(%rip), %rsi # 0x695ca
leaq 0x14a0c(%rip), %rdx # 0x695ec
callq 0x3ef3e
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movl $0x4, %esi
callq 0x55efc
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x54c16
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x54c25
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x54c34
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x149aa(%rip), %rsi # 0x695ed
leaq 0x149a5(%rip), %rdx # 0x695ef
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x14980(%rip), %rsi # 0x695f0
leaq 0x14980(%rip), %rdx # 0x695f7
callq 0x3ef3e
movq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x1495e(%rip), %rsi # 0x695f8
leaq 0x14975(%rip), %rdx # 0x69616
callq 0x3ef3e
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movl $0x5, %esi
callq 0x55efc
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x54cd7
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x54ce6
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x54cf5
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14913(%rip), %rsi # 0x69617
leaq 0x1490e(%rip), %rdx # 0x69619
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x148e9(%rip), %rsi # 0x6961a
leaq 0x148eb(%rip), %rdx # 0x69623
callq 0x3ef3e
movq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x148c9(%rip), %rsi # 0x69624
leaq 0x148d6(%rip), %rdx # 0x69638
callq 0x3ef3e
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movl $0x6, %esi
callq 0x55efc
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x54d98
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x54da7
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x54db6
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14874(%rip), %rsi # 0x69639
leaq 0x1486f(%rip), %rdx # 0x6963b
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x1484a(%rip), %rsi # 0x6963c
leaq 0x1484f(%rip), %rdx # 0x69648
callq 0x3ef3e
movq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x1482d(%rip), %rsi # 0x69649
leaq 0x14846(%rip), %rdx # 0x69669
callq 0x3ef3e
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movl $0x8, %esi
callq 0x55efc
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x54e59
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x54e68
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x54e77
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x147e4(%rip), %rsi # 0x6966a
leaq 0x147df(%rip), %rdx # 0x6966c
callq 0x3ef3e
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x147bc(%rip), %rsi # 0x6966d
leaq 0x147ba(%rip), %rdx # 0x69672
callq 0x3ef3e
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x14799(%rip), %rsi # 0x69673
leaq 0x147a1(%rip), %rdx # 0x69682
callq 0x3ef3e
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x148fb(%rip), %rsi # 0x69802
leaq 0x148fc(%rip), %rdx # 0x6980a
callq 0x3ef3e
movq %rsp, %rdi
leaq 0x68(%rsp), %rdx
movl $0x28, %esi
callq 0x55f76
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x54f34
callq 0x2d360
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x54f43
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x54f52
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x54f61
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14713(%rip), %rsi # 0x69683
leaq 0x1470e(%rip), %rdx # 0x69685
callq 0x3ef3e
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x146eb(%rip), %rsi # 0x69686
leaq 0x146ee(%rip), %rdx # 0x69690
callq 0x3ef3e
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x146cd(%rip), %rsi # 0x69691
leaq 0x146eb(%rip), %rdx # 0x696b6
callq 0x3ef3e
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x146d6(%rip), %rsi # 0x696c7
leaq 0x146d3(%rip), %rdx # 0x696cb
callq 0x3ef3e
leaq 0x109a(%rip), %rsi # 0x5609e
movq %rsp, %rdi
leaq 0x68(%rsp), %rdx
callq 0x5600a
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x55020
callq 0x2d360
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x5502f
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5503e
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x5504d
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x1465b(%rip), %rsi # 0x696b7
leaq 0x14656(%rip), %rdx # 0x696b9
callq 0x3ef3e
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x14633(%rip), %rsi # 0x696ba
leaq 0x14632(%rip), %rdx # 0x696c0
callq 0x3ef3e
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x14611(%rip), %rsi # 0x696c1
leaq 0x14614(%rip), %rdx # 0x696cb
callq 0x3ef3e
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x145ea(%rip), %rsi # 0x696c7
leaq 0x145e7(%rip), %rdx # 0x696cb
callq 0x3ef3e
movq %rsp, %rdi
leaq 0x68(%rsp), %rdx
movl $0x48, %esi
callq 0x55f76
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5510a
callq 0x2d360
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x55119
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x55128
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x55137
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14586(%rip), %rsi # 0x696cc
leaq 0x14581(%rip), %rdx # 0x696ce
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x1455c(%rip), %rsi # 0x696cf
leaq 0x1455c(%rip), %rdx # 0x696d6
callq 0x3ef3e
movq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x1453a(%rip), %rsi # 0x696d7
leaq 0x14549(%rip), %rdx # 0x696ed
callq 0x3ef3e
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0xf60(%rip), %rsi # 0x56123
leaq 0x68(%rsp), %rdi
callq 0x560aa
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x551dc
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x551eb
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x551fa
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x144e5(%rip), %rsi # 0x696ee
leaq 0x144e0(%rip), %rdx # 0x696f0
callq 0x3ef3e
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x144bd(%rip), %rsi # 0x696f1
leaq 0x144be(%rip), %rdx # 0x696f9
callq 0x3ef3e
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x1449d(%rip), %rsi # 0x696fa
leaq 0x144ac(%rip), %rdx # 0x69710
callq 0x3ef3e
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x14487(%rip), %rsi # 0x69711
leaq 0x1448c(%rip), %rdx # 0x6971d
callq 0x3ef3e
leaq 0xf23(%rip), %rsi # 0x561c0
movq %rsp, %rdi
leaq 0x68(%rsp), %rdx
callq 0x5612c
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x552b9
callq 0x2d360
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x552c8
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x552d7
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x552e6
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14429(%rip), %rsi # 0x6971e
leaq 0x14424(%rip), %rdx # 0x69720
callq 0x3ef3e
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x14401(%rip), %rsi # 0x69721
leaq 0x14400(%rip), %rdx # 0x69727
callq 0x3ef3e
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x143df(%rip), %rsi # 0x69728
leaq 0x143e7(%rip), %rdx # 0x69737
callq 0x3ef3e
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x143c2(%rip), %rsi # 0x69738
leaq 0x143c7(%rip), %rdx # 0x69744
callq 0x3ef3e
leaq 0xe8f(%rip), %rsi # 0x56218
movq %rsp, %rdi
leaq 0x68(%rsp), %rdx
callq 0x5600a
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x553a5
callq 0x2d360
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x553b4
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x553c3
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x553d2
callq 0x2d360
movq %rbx, %rdi
callq 0x56334
movq %rax, 0x48(%rsp)
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14357(%rip), %rsi # 0x69745
leaq 0x1436a(%rip), %rdx # 0x6975f
callq 0x3ef3e
movq 0x48(%rsp), %rdi
addq $0x8, %rdi
leaq 0x28(%rsp), %rsi
callq 0x2d1e0
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x14344(%rip), %rsi # 0x69760
leaq 0x14357(%rip), %rdx # 0x6977a
callq 0x3ef3e
leaq 0xfd0(%rip), %rsi # 0x563ff
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5600a
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5544d
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x5545c
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14310(%rip), %rsi # 0x6977b
leaq 0x1430b(%rip), %rdx # 0x6977d
callq 0x3ef3e
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x142e8(%rip), %rsi # 0x6977e
leaq 0x142ec(%rip), %rdx # 0x69789
callq 0x3ef3e
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x142cb(%rip), %rsi # 0x6978a
leaq 0x142d7(%rip), %rdx # 0x6979d
callq 0x3ef3e
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x142b2(%rip), %rsi # 0x6979e
leaq 0x142b1(%rip), %rdx # 0x697a4
callq 0x3ef3e
leaq 0xfa1(%rip), %rsi # 0x564a0
movq %rsp, %rdi
leaq 0x68(%rsp), %rdx
callq 0x5640c
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5551b
callq 0x2d360
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x5552a
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x55539
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x55548
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x1424e(%rip), %rsi # 0x697a5
leaq 0x14249(%rip), %rdx # 0x697a7
callq 0x3ef3e
movq %rsp, %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x14226(%rip), %rsi # 0x697a8
leaq 0x1422b(%rip), %rdx # 0x697b4
callq 0x3ef3e
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x1420a(%rip), %rsi # 0x697b5
leaq 0x14225(%rip), %rdx # 0x697d7
callq 0x3ef3e
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x1422a(%rip), %rsi # 0x69802
leaq 0x1422b(%rip), %rdx # 0x6980a
callq 0x3ef3e
leaq 0xec0(%rip), %rsi # 0x564ab
movq %rsp, %rdi
leaq 0x68(%rsp), %rdx
callq 0x5600a
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x55607
callq 0x2d360
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x55616
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x55625
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x55634
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14195(%rip), %rsi # 0x697d8
leaq 0x14190(%rip), %rdx # 0x697da
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x1416b(%rip), %rsi # 0x697db
leaq 0x14177(%rip), %rdx # 0x697ee
callq 0x3ef3e
movq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56bbc
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x14155(%rip), %rsi # 0x697ef
leaq 0x14169(%rip), %rdx # 0x6980a
callq 0x3ef3e
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d1e0
leaq 0x68(%rsp), %rdi
movl $0xa, %esi
callq 0x55efc
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x556d7
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x556e6
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x556f5
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x14107(%rip), %rsi # 0x6980b
leaq 0x14116(%rip), %rdx # 0x69821
callq 0x3ef3e
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x140f1(%rip), %rsi # 0x69822
leaq 0x14111(%rip), %rdx # 0x69849
callq 0x3ef3e
movq 0x48(%rsp), %rdi
addq $0x8, %rdi
leaq 0x8(%rsp), %rsi
callq 0x2d1e0
leaq 0x48(%rsp), %rdi
movl $0x3, %esi
callq 0x55efc
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5576e
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x5577d
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x140be(%rip), %rsi # 0x6984a
leaq 0x140c7(%rip), %rdx # 0x6985a
callq 0x3ef3e
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x140a2(%rip), %rsi # 0x6985b
leaq 0x140ad(%rip), %rdx # 0x6986d
callq 0x3ef3e
movq 0x48(%rsp), %rdi
addq $0x8, %rdi
leaq 0x8(%rsp), %rsi
callq 0x2d1e0
leaq 0x48(%rsp), %rdi
movl $0x2, %esi
callq 0x55efc
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x557f6
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x55805
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x1405a(%rip), %rsi # 0x6986e
leaq 0x1405a(%rip), %rdx # 0x69875
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x14035(%rip), %rsi # 0x69876
leaq 0x14050(%rip), %rdx # 0x69898
callq 0x3ef3e
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
leaq 0x8(%rsp), %rsi
callq 0x2d1e0
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x1402a(%rip), %rsi # 0x69899
leaq 0x14030(%rip), %rdx # 0x698a6
callq 0x3ef3e
leaq 0xf27(%rip), %rsi # 0x567a9
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x5600a
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x558a0
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x558af
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x558be
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x13fda(%rip), %rsi # 0x698a7
leaq 0x13fdd(%rip), %rdx # 0x698b1
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x13fb8(%rip), %rsi # 0x698b2
leaq 0x13fd7(%rip), %rdx # 0x698d8
callq 0x3ef3e
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
leaq 0x8(%rsp), %rsi
callq 0x2d1e0
leaq 0x48(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x13fb1(%rip), %rsi # 0x698d9
leaq 0x13fb7(%rip), %rdx # 0x698e6
callq 0x3ef3e
leaq 0x1063(%rip), %rsi # 0x5699e
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x5600a
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x55959
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x55968
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x55977
callq 0x2d360
leaq 0x28(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x13f61(%rip), %rsi # 0x698e7
leaq 0x13f68(%rip), %rdx # 0x698f5
callq 0x3ef3e
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x55dd2
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x13f43(%rip), %rsi # 0x698f6
leaq 0x13f53(%rip), %rdx # 0x6990d
callq 0x3ef3e
movq 0x48(%rsp), %rdi
addq $0x8, %rdi
leaq 0x8(%rsp), %rsi
callq 0x2d1e0
leaq 0x48(%rsp), %rdi
movl $0x9, %esi
callq 0x55efc
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x559f0
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x559ff
callq 0x2d360
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c1c
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c1c
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c5c
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c5c
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c00
jmp 0x55c5c
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c5c
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c5c
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c5c
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c5c
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
jmp 0x55bf9
jmp 0x55c00
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c09
jmp 0x55c09
jmp 0x55bf9
movq %rax, %r14
jmp 0x55c3d
jmp 0x55c00
movq %rax, %r14
jmp 0x55c4c
jmp 0x55c09
jmp 0x55c09
movq %rax, %r14
jmp 0x55c2e
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c1c
jmp 0x55c1c
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x55c2e
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x55c3d
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x55c4c
callq 0x2d360
movq %rbx, %rdi
callq 0x55d0a
movq %r14, %rdi
callq 0x2d690
movq %rax, %r14
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x55c1f
callq 0x2d360
jmp 0x55c1f
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConfigData::~ConfigData()
|
ConfigData()
: listTests( false ),
listTags( false ),
listReporters( false ),
listTestNamesOnly( false ),
showSuccessfulTests( false ),
shouldDebugBreak( false ),
noThrow( false ),
showHelp( false ),
showInvisibles( false ),
forceColour( false ),
filenamesAsTags( false ),
abortAfter( -1 ),
rngSeed( 0 ),
verbosity( Verbosity::Normal ),
warnings( WarnAbout::Nothing ),
showDurations( ShowDurations::DefaultForReporter ),
runOrder( RunTests::InDeclarationOrder )
{}
|
pushq %rbx
movq %rdi, %rbx
addq $0xa0, %rdi
callq 0x48df4
leaq 0x88(%rbx), %rdi
callq 0x48df4
movq 0x68(%rbx), %rdi
leaq 0x78(%rbx), %rax
cmpq %rax, %rdi
je 0x55c9e
callq 0x2d360
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x55cb0
callq 0x2d360
movq 0x28(%rbx), %rdi
addq $0x38, %rbx
cmpq %rbx, %rdi
je 0x55cc3
popq %rbx
jmp 0x2d360
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Clara::CommandLine<Catch::ConfigData>::~CommandLine()
|
Arg() {}
|
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rsi
testq %rsi, %rsi
je 0x55d20
leaq 0x50(%rbx), %rdi
callq 0x57f40
movq $0x0, 0x50(%rbx)
leaq 0x20(%rbx), %rdi
callq 0x5805c
leaq 0x8(%rbx), %rdi
callq 0x58034
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x55d49
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
void Catch::Clara::CommandLine<Catch::ConfigData>::bindProcessName<Catch::ConfigData, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::ConfigData::*)
|
void bindProcessName( M C::* field ) {
m_boundProcessName = new Detail::BoundDataMember<C,M>( field );
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %rbx
leaq 0x2b97f(%rip), %r13 # 0x81700
movq %r13, (%rax)
movq %r15, 0x8(%rax)
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r12
movq %r13, (%rax)
movq %r15, 0x8(%rax)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x55daa
movq (%rdi), %rax
callq *0x8(%rax)
movq %r12, (%r14)
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x8(%rax)
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Clara::CommandLine<Catch::ConfigData>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
OptBuilder operator[]( std::string const& optName ) {
m_options.push_back( Arg() );
addOptName( m_options.back(), optName );
OptBuilder builder( &m_options.back() );
return builder;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x8(%rsi), %rdi
xorl %eax, %eax
leaq 0x28(%rsp), %r13
movq %rax, -0x18(%r13)
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
leaq 0x48(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
leaq 0x68(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq 0xa0(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq %rax, -0x8(%rbx)
movb %al, (%rbx)
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %rsi
callq 0x5704c
leaq 0x78(%rsp), %r12
movq 0x18(%r12), %rdi
cmpq %rbx, %rdi
je 0x55e6d
callq 0x2d360
movq %r12, %rdi
callq 0x48df4
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x55e84
callq 0x2d360
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x55e93
callq 0x2d360
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x55ea2
callq 0x2d360
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x55eb2
movq (%rdi), %rax
callq *0x8(%rax)
movq $-0xa8, %rbx
movq 0x10(%r14), %rdi
addq %rbx, %rdi
movq (%rsp), %rsi
callq 0x56bbc
addq 0x10(%r14), %rbx
movq 0x8(%rsp), %rax
movq %rbx, (%rax)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x56b3e
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData>(bool Catch::ConfigData::*)
|
void bind( bool C::* field ) {
m_arg->boundField = new Detail::BoundDataMember<C,bool>( field );
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %rbx
leaq 0x2b839(%rip), %r13 # 0x81758
movq %r13, (%rax)
movq %r14, 0x8(%rax)
movq (%r15), %r12
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r15
movq %r13, (%rax)
movq %r14, 0x8(%rax)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x55f4c
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, (%r12)
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x8(%rax)
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::ConfigData::*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void bind( M C::* field, std::string const& placeholder ) {
m_arg->boundField = new Detail::BoundDataMember<C,M>( field );
m_arg->placeholder = placeholder;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r15
leaq 0x2b761(%rip), %rbx # 0x81700
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%r14), %rbp
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r13
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x55fcc
movq (%rdi), %rax
callq *0x8(%rax)
movq %r13, (%rbp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq (%r14), %rdi
addq $0x48, %rdi
movq (%rsp), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d1e0
movq %rax, %rbx
movq %r15, %rdi
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(void (*)(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
m_arg->boundField = new Detail::BoundBinaryFunction<C, T>( binaryFunction );
m_arg->placeholder = placeholder;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r15
leaq 0x2b77d(%rip), %rbx # 0x817b0
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%r14), %rbp
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r13
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x56060
movq (%rdi), %rax
callq *0x8(%rax)
movq %r13, (%rbp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq (%r14), %rdi
addq $0x48, %rdi
movq (%rsp), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d1e0
movq %rax, %rbx
movq %r15, %rdi
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData>(void (*)(Catch::ConfigData&))
|
void bind( void (* unaryFunction)( C& ) ) {
m_arg->boundField = new Detail::BoundUnaryFunction<C>( unaryFunction );
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %rbx
leaq 0x2b73b(%rip), %r13 # 0x81808
movq %r13, (%rax)
movq %r14, 0x8(%rax)
movq (%r15), %r12
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r15
movq %r13, (%rax)
movq %r14, 0x8(%rax)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x560fa
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, (%r12)
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x8(%rax)
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData, int>(void (*)(Catch::ConfigData&, int), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
m_arg->boundField = new Detail::BoundBinaryFunction<C, T>( binaryFunction );
m_arg->placeholder = placeholder;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r15
leaq 0x2b70b(%rip), %rbx # 0x81860
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%r14), %rbp
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r13
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x56182
movq (%rdi), %rax
callq *0x8(%rax)
movq %r13, (%rbp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq (%r14), %rdi
addq $0x48, %rdi
movq (%rsp), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d1e0
movq %rax, %rbx
movq %r15, %rdi
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::addWarning(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
inline void addWarning( ConfigData& config, std::string const& _warning ) {
if( _warning == "NoAssertions" )
config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
else
throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x13813(%rip), %rsi # 0x69a42
movq %r14, %rdi
callq 0x2d0f0
testl %eax, %eax
jne 0x5624a
orb $0x1, 0x18(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2d1b0
movq %rax, %rbx
leaq 0x137f1(%rip), %rsi # 0x69a4f
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x49917
leaq 0x1376d(%rip), %rsi # 0x699df
leaq 0x28(%rsp), %rdi
callq 0x2d700
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x5629d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x562aa
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x2d5d0
xorl %ebp, %ebp
movq 0x2bd16(%rip), %rsi # 0x81ff0
movq 0x2bcc7(%rip), %rdx # 0x81fa8
movq %rbx, %rdi
callq 0x2d640
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x56303
callq 0x2d360
jmp 0x56303
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5631e
callq 0x2d360
jmp 0x5631e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5632b
movq %rbx, %rdi
callq 0x2d2d0
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Clara::CommandLine<Catch::ConfigData>::operator[](Catch::Clara::UnpositionalTag)
|
ArgBuilder operator[]( UnpositionalTag ) {
if( m_floatingArg.get() )
throw std::logic_error( "Only one unpositional argument can be added" );
m_floatingArg.reset( new Arg() );
ArgBuilder builder( m_floatingArg.get() );
return builder;
}
|
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x50(%rdi)
jne 0x563ba
movq %rdi, %rbx
movl $0xa8, %edi
callq 0x2d3a0
xorl %ecx, %ecx
movq %rcx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb %cl, 0x18(%rax)
leaq 0x38(%rax), %rdx
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movb %cl, 0x38(%rax)
leaq 0x58(%rax), %rdx
movq %rdx, 0x48(%rax)
movq %rcx, 0x50(%rax)
movb %cl, 0x58(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rax)
movq %rcx, 0x78(%rax)
leaq 0x90(%rax), %rdx
movq %rdx, 0x80(%rax)
movq %rcx, 0x88(%rax)
movb %cl, 0x90(%rax)
movl $0xffffffff, 0xa0(%rax) # imm = 0xFFFFFFFF
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2d1b0
movq %rax, %rbx
leaq 0x13699(%rip), %rsi # 0x69a67
movq %rax, %rdi
callq 0x2d4f0
movq 0x2bbf3(%rip), %rsi # 0x81fd0
movq 0x2bbd4(%rip), %rdx # 0x81fb8
movq %rbx, %rdi
callq 0x2d640
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d2d0
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData, bool>(void (*)(Catch::ConfigData&, bool), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
m_arg->boundField = new Detail::BoundBinaryFunction<C, T>( binaryFunction );
m_arg->placeholder = placeholder;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r15
leaq 0x2b483(%rip), %rbx # 0x818b8
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%r14), %rbp
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r13
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x56462
movq (%rdi), %rax
callq *0x8(%rax)
movq %r13, (%rbp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq (%r14), %rdi
addq $0x48, %rdi
movq (%rsp), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d1e0
movq %rax, %rbx
movq %r15, %rdi
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::setOrder(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
inline void setOrder( ConfigData& config, std::string const& order ) {
if( startsWith( "declared", order ) )
config.runOrder = RunTests::InDeclarationOrder;
else if( startsWith( "lexical", order ) )
config.runOrder = RunTests::InLexicographicalOrder;
else if( startsWith( "random", order ) )
config.runOrder = RunTests::InRandomOrder;
else
throw std::runtime_error( "Unrecognised ordering: '" + order + "'" );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x132e9(%rip), %rsi # 0x69ab2
leaq 0x132ea(%rip), %rdx # 0x69aba
leaq 0x8(%rsp), %rdi
callq 0x3ef3e
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x43f5c
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x567f8
callq 0x2d360
xorl %eax, %eax
testb %bpl, %bpl
jne 0x56889
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x132a9(%rip), %rsi # 0x69abb
leaq 0x132a9(%rip), %rdx # 0x69ac2
callq 0x3ef3e
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x43f5c
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5683c
callq 0x2d360
movl $0x1, %eax
testb %bpl, %bpl
jne 0x56889
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x1326e(%rip), %rsi # 0x69ac3
leaq 0x1326d(%rip), %rdx # 0x69ac9
callq 0x3ef3e
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x43f5c
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5687f
callq 0x2d360
movl $0x2, %eax
testb %bpl, %bpl
je 0x56898
movl %eax, 0x20(%r14)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2d1b0
movq %rax, %r14
leaq 0x1321e(%rip), %rsi # 0x69aca
leaq 0x28(%rsp), %rdi
movq %rbx, %rdx
callq 0x49917
leaq 0x1311f(%rip), %rsi # 0x699df
leaq 0x28(%rsp), %rdi
callq 0x2d700
movq %r15, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x568e7
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x568f4
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x2d5d0
xorl %ebp, %ebp
movq 0x2b6cc(%rip), %rsi # 0x81ff0
movq 0x2b67d(%rip), %rdx # 0x81fa8
movq %r14, %rdi
callq 0x2d640
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5694d
callq 0x2d360
jmp 0x5694d
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56968
callq 0x2d360
jmp 0x56968
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x56996
movq %r14, %rdi
callq 0x2d2d0
jmp 0x56996
jmp 0x5697f
jmp 0x56993
jmp 0x5697f
jmp 0x56993
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x56996
callq 0x2d360
jmp 0x56996
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Clara::CommonArgProperties<Catch::ConfigData>::CommonArgProperties(Catch::Clara::CommonArgProperties<Catch::ConfigData> const&)
|
CommonArgProperties( Detail::BoundArgFunction<ConfigT> const& _boundField ) : boundField( _boundField ) {}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x5749b
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x5749d
xorl %eax, %eax
movq %rax, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x18(%rbx), %r13
movq %r13, 0x8(%rbx)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4042a
leaq 0x28(%rbx), %r12
leaq 0x38(%rbx), %rbp
movq %rbp, 0x28(%rbx)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4042a
leaq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
movq %rax, 0x48(%rbx)
movq 0x48(%r15), %rsi
movq 0x50(%r15), %rdx
addq %rsi, %rdx
callq 0x4042a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x5751f
callq 0x2d360
jmp 0x5751f
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x57531
callq 0x2d360
jmp 0x57531
movq %rax, %r15
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5753f
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Clara::CommonArgProperties<Catch::ConfigData>::~CommonArgProperties()
|
CommonArgProperties() {}
|
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x5755e
callq 0x2d360
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x57570
callq 0x2d360
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x57582
callq 0x2d360
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x57591
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
void Catch::Clara::Detail::convertInto<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&)
|
void convertInto( std::string const& _source, T& _dest ) {
std::stringstream ss;
ss << _source;
ss >> _dest;
if( ss.fail() )
throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rdi
callq 0x2d2a0
leaq 0x50(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x2d420
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x2d210
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x60(%rsp,%rax)
jne 0x57e37
movq 0x2a156(%rip), %rsi # 0x81f68
leaq 0x40(%rsp), %rdi
callq 0x2d2e0
leaq 0xc0(%rsp), %rdi
callq 0x2d110
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2d1b0
movq %rax, %rbx
leaq 0x11b96(%rip), %rsi # 0x699e1
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x49917
leaq 0x11b95(%rip), %rsi # 0x699f4
leaq 0x20(%rsp), %rdi
callq 0x2d700
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x57e8a
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x57e96
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x2d5d0
xorl %ebp, %ebp
movq 0x2a12c(%rip), %rsi # 0x81ff0
movq 0x2a0dd(%rip), %rdx # 0x81fa8
movq %rbx, %rdi
callq 0x2d640
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x57eec
callq 0x2d360
jmp 0x57eec
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57f07
callq 0x2d360
jmp 0x57f07
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x57f19
movq %rbx, %rdi
callq 0x2d2d0
jmp 0x57f19
movq %rax, %r14
movq 0x2a048(%rip), %rsi # 0x81f68
leaq 0x40(%rsp), %rdi
callq 0x2d2e0
leaq 0xc0(%rsp), %rdi
callq 0x2d110
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Session::applyCommandLine(int, char const* const*, Catch::Session::OnUnusedOptions::DoWhat)
|
int applyCommandLine( int argc, char const* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
try {
m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
m_unusedTokens = m_cli.parseInto( argc, argv, m_configData );
if( m_configData.showHelp )
showHelp( m_configData.processName );
m_config.reset();
}
catch( std::exception& ex ) {
{
Colour colourGuard( Colour::Red );
Catch::cerr()
<< "\nError(s) in input:\n"
<< Text( ex.what(), TextAttributes().setIndent(2) )
<< "\n\n";
}
m_cli.usage( Catch::cout(), m_configData.processName );
return (std::numeric_limits<int>::max)();
}
return 0;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %rax
movl %esi, %edx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpl $0x1, %ecx
sete 0x64(%rdi)
leaq 0x80(%rdi), %r8
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x584e8
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movups 0x68(%rbx), %xmm0
movq 0x78(%rbx), %rax
leaq 0x10(%rsp), %r15
movaps (%r15), %xmm1
movups %xmm1, 0x68(%rbx)
movq 0x10(%r15), %rcx
movq %rcx, 0x78(%rbx)
movq 0x10(%rdi), %rcx
movq %rax, 0x10(%rdi)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movaps %xmm1, (%r15)
movq %rcx, 0x10(%r15)
callq 0x55cc6
movq %r15, %rdi
callq 0x55cc6
cmpb $0x1, 0x87(%rbx)
jne 0x581d3
leaq 0xe8(%rbx), %rsi
movq %rbx, %rdi
callq 0x58652
movq 0x138(%rbx), %rdi
testq %rdi, %rdi
je 0x581e5
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x138(%rbx)
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x58201
movq %rax, %r15
cmpl $0x1, %edx
jne 0x58342
movq %r15, %rdi
callq 0x2d170
movq %rax, %r15
movb $0x0, 0xe(%rsp)
movl $0x2, %edi
callq 0x437d0
movq 0x29dba(%rip), %rdi # 0x81fe8
leaq 0x118ef(%rip), %rsi # 0x69b24
movl $0x14, %edx
callq 0x2d420
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x2d160
leaq 0x90(%rsp), %rdx
movq $-0x1, (%rdx)
movq $0x4f, 0x10(%rdx)
movb $0x9, 0x18(%rdx)
movq $0x2, 0x8(%rdx)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5874e
movq 0x29d55(%rip), %rdi # 0x81fe8
leaq 0x30(%rsp), %rsi
callq 0x586ed
leaq 0x11efa(%rip), %rsi # 0x6a19e
movl $0x2, %edx
movq %rax, %rdi
callq 0x2d420
leaq 0x30(%rsp), %rdi
callq 0x58c60
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x582ce
callq 0x2d360
leaq 0xe(%rsp), %rdi
callq 0x4383a
addq $0xe8, %rbx
movq 0x29cda(%rip), %rsi # 0x81fc0
movq %r14, %rdi
movq %rbx, %rdx
callq 0x58c82
callq 0x2d600
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jmp 0x581f2
jmp 0x5830e
movq %rax, %r15
jmp 0x58320
jmp 0x58309
movq %rax, %r15
jmp 0x58333
movq %rax, %r15
jmp 0x5833d
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0x58c60
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58333
callq 0x2d360
leaq 0xe(%rsp), %rdi
callq 0x4383a
callq 0x2d600
movq %r15, %rdi
callq 0x2d690
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Session::run()
|
int run() {
if( m_configData.showHelp )
return 0;
try
{
config(); // Force config to be constructed
seedRng( *m_config );
if( m_configData.filenamesAsTags )
applyFilenamesAsTags( *m_config );
// Handle list request
if( Option<std::size_t> listed = list( config() ) )
return static_cast<int>( *listed );
return static_cast<int>( runTests( m_config ).assertions.failed );
}
catch( std::exception& ex ) {
Catch::cerr() << ex.what() << std::endl;
return (std::numeric_limits<int>::max)();
}
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
xorl %eax, %eax
cmpb $0x0, 0x87(%rdi)
jne 0x58472
movq %rdi, %r14
callq 0x5b0fe
movq 0x138(%r14), %rdi
callq 0x45552
leaq 0x138(%r14), %rbx
cmpb $0x1, 0x8a(%r14)
jne 0x58397
movq (%rbx), %rdi
callq 0x4257f
movq %r14, %rdi
callq 0x5b0fe
movq %rax, %r14
movq $0x0, (%rsp)
cmpb $0x1, 0x10(%rax)
jne 0x583c4
movq %r14, %rdi
callq 0x5b5df
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, -0x8(%rcx)
cmpb $0x1, 0x13(%r14)
jne 0x583f3
movq (%rsp), %rax
testq %rax, %rax
je 0x583d9
movq (%rax), %r15
jmp 0x583dc
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x5bbfe
addq %r15, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, -0x8(%rcx)
cmpb $0x1, 0x11(%r14)
jne 0x58422
movq (%rsp), %rax
testq %rax, %rax
je 0x58408
movq (%rax), %r15
jmp 0x5840b
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x5be4e
addq %r15, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, -0x8(%rcx)
cmpb $0x1, 0x12(%r14)
jne 0x58451
movq (%rsp), %rax
testq %rax, %rax
je 0x58437
movq (%rax), %r15
jmp 0x5843a
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x5c727
addq %r15, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, -0x8(%rcx)
movq (%rsp), %rcx
testq %rcx, %rcx
je 0x5845e
movl (%rcx), %eax
jmp 0x5845e
testq %rcx, %rcx
jne 0x58472
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x42036
movl 0x8(%rsp), %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x58493
jmp 0x58484
jmp 0x58484
jmp 0x58484
movq %rax, %rbx
movq $0x0, (%rsp)
jmp 0x58496
jmp 0x58493
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x584d7
movq %rbx, %rdi
callq 0x2d170
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x29b35(%rip), %rdi # 0x81fe8
movq %rax, %rsi
callq 0x2d390
movq %rax, %rdi
callq 0x2d1a0
callq 0x2d600
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jmp 0x58472
movq %rax, %rbx
callq 0x2d600
movq %rbx, %rdi
callq 0x2d690
movq %rax, %rdi
callq 0x3ed5c
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Clara::CommandLine<Catch::ConfigData>::parseInto(int, char const* const*, Catch::ConfigData&) const
|
std::vector<Parser::Token> parseInto( int argc, char const * const * argv, ConfigT& config ) const {
std::string processName = argv[0];
std::size_t lastSlash = processName.find_last_of( "/\\" );
if( lastSlash != std::string::npos )
processName = processName.substr( lastSlash+1 );
m_boundProcessName.set( config, processName );
std::vector<Parser::Token> tokens;
Parser parser;
parser.parseIntoTokens( argc, argv, tokens );
return populate( tokens, config );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rcx), %rsi
leaq 0x20(%rsp), %r13
movq %rsp, %rdx
movq %r13, %rdi
callq 0x2d160
leaq 0x1161b(%rip), %rsi # 0x69b39
movl $0x2, %ecx
movq %r13, %rdi
movq $-0x1, %rdx
callq 0x2d740
cmpq $-0x1, %rax
je 0x58575
incq %rax
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x2d3e0
leaq 0x20(%rsp), %rdi
movq %rsp, %r13
movq %r13, %rsi
callq 0x2d480
movq (%r13), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x58575
callq 0x2d360
movq (%r15), %rdi
movq (%rdi), %rax
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq *0x10(%rax)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movl $0x3a3d0920, (%r13) # imm = 0x3A3D0920
movq $0x4, -0x8(%r13)
movb $0x0, 0x4(%r13)
movq %rsp, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x58d24
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x58e18
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x585e5
callq 0x2d360
leaq 0x40(%rsp), %rdi
callq 0x55cc6
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58602
callq 0x2d360
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x58616
movq %rax, %rbx
jmp 0x58636
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x5862c
callq 0x2d360
leaq 0x40(%rsp), %rdi
callq 0x55cc6
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58649
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Session::showHelp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void showHelp( std::string const& processName ) {
Catch::cout() << "\nCatch v" << libraryVersion << "\n";
m_cli.usage( Catch::cout(), processName );
Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2995c(%rip), %rbx # 0x81fc0
leaq 0x1154f(%rip), %rsi # 0x69bba
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2d420
leaq 0x29e11(%rip), %rsi # 0x82490
movq %rbx, %rdi
callq 0x446e7
leaq 0x11b11(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2d420
addq $0x8, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x58c82
leaq 0x1150f(%rip), %rsi # 0x69bc3
movl $0x32, %edx
movq %rbx, %rdi
callq 0x2d420
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2d030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2d280
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Tbc::operator<<(std::ostream&, Catch::Tbc::Text const&)
|
inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
it != itEnd; ++it ) {
if( it != _text.begin() )
_stream << "\n";
_stream << *it;
}
return _stream;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rsi), %r12
movq 0x48(%rsi), %r13
cmpq %r13, %r12
je 0x58740
movq %rsi, %r14
leaq 0x11a8f(%rip), %r15 # 0x6a19f
cmpq 0x40(%r14), %r12
je 0x58726
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d420
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2d420
addq $0x20, %r12
cmpq %r13, %r12
jne 0x58710
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Tbc::Text::Text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Tbc::TextAttributes const&)
|
Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
: attr( _attr )
{
std::string wrappableChars = " [({.,/|\\-";
std::size_t indent = _attr.initialIndent != std::string::npos
? _attr.initialIndent
: _attr.indent;
std::string remainder = _str;
while( !remainder.empty() ) {
if( lines.size() >= 1000 ) {
lines.push_back( "... message truncated due to excessive size" );
return;
}
std::size_t tabPos = std::string::npos;
std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
std::size_t pos = remainder.find_first_of( '\n' );
if( pos <= width ) {
width = pos;
}
pos = remainder.find_last_of( _attr.tabChar, width );
if( pos != std::string::npos ) {
tabPos = pos;
if( remainder[width] == '\n' )
width--;
remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
}
if( width == remainder.size() ) {
spliceLine( indent, remainder, width );
}
else if( remainder[width] == '\n' ) {
spliceLine( indent, remainder, width );
if( width <= 1 || remainder.size() != 1 )
remainder = remainder.substr( 1 );
indent = _attr.indent;
}
else {
pos = remainder.find_last_of( wrappableChars, width );
if( pos != std::string::npos && pos > 0 ) {
spliceLine( indent, remainder, pos );
if( remainder[0] == ' ' )
remainder = remainder.substr( 1 );
}
else {
spliceLine( indent, remainder, width-1 );
lines.back() += "-";
}
if( lines.size() == 1 )
indent = _attr.indent;
if( tabPos != std::string::npos )
indent += tabPos;
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x90(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm0, 0x20(%rdi)
movups %xmm1, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq %rax, 0x50(%rdi)
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1143f(%rip), %rsi # 0x69bf6
leaq 0x11442(%rip), %rdx # 0x69c00
leaq 0xa8(%rsp), %rdi
movq %rbx, 0x48(%rsp)
callq 0x3ef3e
movq (%r15), %rbp
cmpq $-0x1, %rbp
jne 0x587dd
movq 0x8(%r15), %rbp
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x4042a
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x58b70
leaq 0x20(%rsp), %r12
movq %r15, 0x98(%rsp)
movq 0x48(%rbx), %rcx
subq 0x40(%rbx), %rcx
cmpq $0x7ce1, %rcx # imm = 0x7CE1
jae 0x58b37
movq 0x10(%r15), %r14
subq %rbp, %r14
cmpq %rax, %r14
cmovaeq %rax, %r14
movq %r12, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x2d4a0
cmpq %r14, %rax
cmovbq %rax, %r14
movsbl 0x18(%r15), %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x2d720
cmpq $-0x1, %rax
je 0x58913
movq %rax, %r13
movq %rbp, 0xa0(%rsp)
movq 0x20(%rsp), %rax
xorl %r15d, %r15d
cmpb $0xa, (%rax,%r14)
sete %bl
leaq 0x70(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x2d3e0
movq %r13, %rdx
incq %rdx
leaq 0x50(%rsp), %rdi
movq %r12, %rbp
movq %r12, %rsi
movq $-0x1, %rcx
callq 0x2d3e0
movq 0x70(%rsp), %rcx
movl $0xf, %esi
leaq 0x80(%rsp), %rax
cmpq %rax, %rcx
movq %rsp, %r12
je 0x588d4
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %r8
movq 0x58(%rsp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rsi, %rax
jbe 0x58902
movl $0xf, %esi
leaq 0x60(%rsp), %rdi
cmpq %rdi, 0x50(%rsp)
je 0x588fd
movq 0x60(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x5891f
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x2d100
jmp 0x5892d
movq $-0x1, %r13
jmp 0x589da
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d400
leaq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x58950
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x58956
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2d480
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x58991
callq 0x2d360
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x589a5
callq 0x2d360
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x589bc
callq 0x2d360
movb %bl, %r15b
subq %r15, %r14
movq 0x98(%rsp), %r15
movq 0x48(%rsp), %rbx
movq %rbp, %r12
movq 0xa0(%rsp), %rbp
cmpq 0x28(%rsp), %r14
jne 0x589f7
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x5a2da
jmp 0x58b27
movq 0x20(%rsp), %rax
cmpb $0xa, (%rax,%r14)
jne 0x58a63
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x5a2da
cmpq $0x2, %r14
jb 0x58a22
cmpq $0x1, 0x28(%rsp)
je 0x58a5a
movl $0x1, %edx
movq %rsp, %r14
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rcx
callq 0x2d3e0
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d480
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x58a5a
callq 0x2d360
movq 0x8(%r15), %rbp
jmp 0x58b27
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rcx
movq %r12, %rdi
movq %r14, %rdx
callq 0x2d740
leaq -0x1(%rax), %rcx
cmpq $-0x3, %rcx
ja 0x58add
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x5a2da
movq 0x20(%rsp), %rax
cmpb $0x20, (%rax)
jne 0x58b05
movl $0x1, %edx
movq %rsp, %r14
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rcx
callq 0x2d3e0
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d480
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x58b05
callq 0x2d360
jmp 0x58b05
decq %r14
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x5a2da
movq 0x48(%rbx), %rdi
addq $-0x20, %rdi
leaq 0x118c5(%rip), %rsi # 0x6a3c5
callq 0x2d700
movq 0x48(%rbx), %rax
subq 0x40(%rbx), %rax
cmpq $0x20, %rax
jne 0x58b17
movq 0x8(%r15), %rbp
cmpq $-0x1, %r13
movl $0x0, %eax
cmovneq %r13, %rax
addq %rax, %rbp
movq 0x28(%rsp), %rax
testq %rax, %rax
jne 0x58815
jmp 0x58b70
movq %rsp, %rdi
leaq 0x10(%rsp), %rbx
movq %rbx, (%rdi)
leaq 0x110b8(%rip), %rsi # 0x69c01
leaq 0x110dc(%rip), %rdx # 0x69c2c
callq 0x3ef3e
movq %rsp, %rsi
movq 0x40(%rsp), %rdi
callq 0x64a8a
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x58b70
callq 0x2d360
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x58b84
callq 0x2d360
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x58b9e
callq 0x2d360
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
jne 0x58bfc
jmp 0x58c08
jmp 0x58c05
jmp 0x58c05
movq %rax, %r14
jmp 0x58c1c
movq %rax, %r14
jmp 0x58c36
jmp 0x58c05
movq %rax, %r14
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x58bea
callq 0x2d360
jmp 0x58bea
movq %rax, %r14
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x58c08
callq 0x2d360
jmp 0x58c08
jmp 0x58c05
movq %rax, %r14
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x58c1c
callq 0x2d360
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x58c36
callq 0x2d360
movq 0x40(%rsp), %rdi
callq 0x48df4
movq 0x48(%rsp), %rax
movq (%rax), %rdi
cmpq 0x90(%rsp), %rdi
je 0x58c57
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Tbc::Text::~Text()
|
Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
: attr( _attr )
{
std::string wrappableChars = " [({.,/|\\-";
std::size_t indent = _attr.initialIndent != std::string::npos
? _attr.initialIndent
: _attr.indent;
std::string remainder = _str;
while( !remainder.empty() ) {
if( lines.size() >= 1000 ) {
lines.push_back( "... message truncated due to excessive size" );
return;
}
std::size_t tabPos = std::string::npos;
std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
std::size_t pos = remainder.find_first_of( '\n' );
if( pos <= width ) {
width = pos;
}
pos = remainder.find_last_of( _attr.tabChar, width );
if( pos != std::string::npos ) {
tabPos = pos;
if( remainder[width] == '\n' )
width--;
remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
}
if( width == remainder.size() ) {
spliceLine( indent, remainder, width );
}
else if( remainder[width] == '\n' ) {
spliceLine( indent, remainder, width );
if( width <= 1 || remainder.size() != 1 )
remainder = remainder.substr( 1 );
indent = _attr.indent;
}
else {
pos = remainder.find_last_of( wrappableChars, width );
if( pos != std::string::npos && pos > 0 ) {
spliceLine( indent, remainder, pos );
if( remainder[0] == ' ' )
remainder = remainder.substr( 1 );
}
else {
spliceLine( indent, remainder, width-1 );
lines.back() += "-";
}
if( lines.size() == 1 )
indent = _attr.indent;
if( tabPos != std::string::npos )
indent += tabPos;
}
}
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x40, %rdi
callq 0x48df4
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x58c7f
popq %rbx
jmp 0x2d360
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Clara::CommandLine<Catch::ConfigData>::populateFixedArgs(std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>> const&, Catch::ConfigData&) const
|
std::vector<Parser::Token> populateFixedArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
std::vector<Parser::Token> unusedTokens;
int position = 1;
for( std::size_t i = 0; i < tokens.size(); ++i ) {
Parser::Token const& token = tokens[i];
typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( position );
if( it != m_positionalArgs.end() )
it->second.boundField.set( config, token.data );
else
unusedTokens.push_back( token );
if( token.type == Parser::Token::Positional )
position++;
}
return unusedTokens;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x59d3b
movq %rdx, %r15
movq %rsi, %r12
leaq 0x28(%rsi), %rbp
movl $0x1, %ebx
xorl %r14d, %r14d
movq 0x30(%r12), %rdx
movq %rbp, %rcx
testq %rdx, %rdx
je 0x59cca
movq %rbp, %rcx
xorl %esi, %esi
cmpl %ebx, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x59cb3
movq %rbp, %rsi
cmpq %rbp, %rcx
je 0x59cdc
cmpl 0x20(%rcx), %ebx
cmovlq %rbp, %rcx
movq %rcx, %rsi
leaq (%r14,%r14,4), %rcx
leaq (%rax,%rcx,8), %r13
cmpq %rbp, %rsi
je 0x59cfe
leaq 0x8(%r13), %rdx
movq 0x28(%rsi), %rdi
movq (%rdi), %rax
movq 0x10(%rsp), %rsi
callq *0x10(%rax)
jmp 0x59d0b
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x592ea
cmpl $0x1, (%r13)
adcl $0x0, %ebx
incq %r14
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
cmpq %rcx, %r14
jb 0x59ca3
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x55cc6
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Clara::CommandLine<Catch::ConfigData>::populateFloatingArgs(std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>> const&, Catch::ConfigData&) const
|
std::vector<Parser::Token> populateFloatingArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
if( !m_floatingArg.get() )
return tokens;
std::vector<Parser::Token> unusedTokens;
for( std::size_t i = 0; i < tokens.size(); ++i ) {
Parser::Token const& token = tokens[i];
if( token.type == Parser::Token::Positional )
m_floatingArg->boundField.set( config, token.data );
else
unusedTokens.push_back( token );
}
return unusedTokens;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x50(%rsi)
je 0x59df8
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x59e03
xorl %r13d, %r13d
movabsq $-0x3333333333333333, %rbp # imm = 0xCCCCCCCCCCCCCCCD
xorl %r15d, %r15d
cmpl $0x0, (%rsi,%r13)
je 0x59dbe
addq %r13, %rsi
movq %rbx, %rdi
callq 0x592ea
jmp 0x59dd8
movq 0x50(%r12), %rax
leaq (%rsi,%r13), %rdx
addq $0x8, %rdx
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rsp), %rsi
callq *0x10(%rax)
incq %r15
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %rbp, %rax
addq $0x28, %r13
cmpq %rax, %r15
jb 0x59daa
jmp 0x59e03
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a18c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x55cc6
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Clara::CommandLine<Catch::ConfigData>::Arg::commands[abi:cxx11]() const
|
std::string commands() const {
std::ostringstream oss;
bool first = true;
std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
for(; it != itEnd; ++it ) {
if( first )
first = false;
else
oss << ", ";
oss << "-" << *it;
}
if( !longName.empty() ) {
if( !first )
oss << ", ";
oss << "--" << longName;
}
if( !placeholder.empty() )
oss << " <" << placeholder << ">";
return oss.str();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r12
movq %rdi, %r15
leaq 0x10(%rsp), %rdi
callq 0x2d4b0
movq 0x68(%r12), %rbx
movq 0x70(%r12), %r14
cmpq %r14, %rbx
je 0x59f4c
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movb $0x1, %bpl
leaq 0x104d2(%rip), %r15 # 0x6a3c5
leaq 0x10(%rsp), %r12
leaq 0xf23b(%rip), %r13 # 0x6913a
testb $0x1, %bpl
je 0x59f09
xorl %ebp, %ebp
jmp 0x59f19
movl $0x2, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2d420
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2d420
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r12, %rdi
callq 0x2d420
addq $0x20, %rbx
cmpq %r14, %rbx
jne 0x59eff
movq 0x8(%rsp), %r15
movq (%rsp), %r12
jmp 0x59f4f
movb $0x1, %bpl
cmpq $0x0, 0x88(%r12)
je 0x59fa6
testb $0x1, %bpl
jne 0x59f76
leaq 0xf1d3(%rip), %rsi # 0x6913a
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
callq 0x2d420
leaq 0xf9a4(%rip), %rsi # 0x69921
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
callq 0x2d420
movq 0x80(%r12), %rsi
movq 0x88(%r12), %rdx
leaq 0x10(%rsp), %rdi
callq 0x2d420
cmpq $0x0, 0x50(%r12)
je 0x59fec
leaq 0xfc02(%rip), %rsi # 0x69bb7
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
callq 0x2d420
movq 0x48(%r12), %rsi
movq 0x50(%r12), %rdx
leaq 0x10(%rsp), %rdi
callq 0x2d420
leaq 0xf431(%rip), %rsi # 0x69410
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x2d5a0
movq 0x27fb0(%rip), %rsi # 0x81fb0
leaq 0x10(%rsp), %rdi
callq 0x2d1d0
leaq 0x80(%rsp), %rdi
callq 0x2d110
movq %r15, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5a02e
movq %rax, %rbx
movq 0x27f78(%rip), %rsi # 0x81fb0
leaq 0x10(%rsp), %rdi
callq 0x2d1d0
leaq 0x80(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Tbc::Text::spliceLine(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long)
|
void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
_remainder = _remainder.substr( _pos );
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x40(%rsp), %rdi
movl $0x20, %edx
callq 0x2d440
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x2d3e0
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x28(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x5a33d
movq 0x50(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x5a35c
leaq 0x30(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x5a357
movq 0x30(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x5a36d
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x2d100
jmp 0x5a37b
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d400
leaq 0x10(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x5a39e
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x5a3a4
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rsp)
movq %rcx, (%rax)
addq $0x40, %r15
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq %rsp, %rsi
movq %r15, %rdi
callq 0x64a8a
leaq 0x10(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x5a3e3
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a3f6
callq 0x2d360
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x5a405
callq 0x2d360
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq 0x2d3e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d480
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x5a435
callq 0x2d360
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a45e
callq 0x2d360
jmp 0x5a45e
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a476
callq 0x2d360
jmp 0x5a476
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x5a485
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Clara::CommandLine<Catch::ConfigData>::argSynopsis(std::ostream&) const
|
void argSynopsis( std::ostream& os ) const {
for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
if( i > 1 )
os << " ";
typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( i );
if( it != m_positionalArgs.end() )
os << "<" << it->second.placeholder << ">";
else if( m_floatingArg.get() )
os << "<" << m_floatingArg->placeholder << ">";
else
throw std::logic_error( "non consecutive positional arguments with no floating args" );
}
// !TBD No indication of mandatory args
if( m_floatingArg.get() ) {
if( m_highestSpecifiedArgPosition > 1 )
os << " ";
os << "[<" << m_floatingArg->placeholder << "> ...]";
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x58(%rdi)
jle 0x5a596
leaq 0x28(%r14), %r12
movl $0x1, %r15d
leaq 0xef56(%rip), %r13 # 0x69410
cmpl $0x2, %r15d
jb 0x5a4d4
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xec22(%rip), %rsi # 0x690f1
callq 0x2d420
movq 0x30(%r14), %rcx
movq %r12, %rax
testq %rcx, %rcx
je 0x5a4fa
movq %r12, %rax
xorl %edx, %edx
cmpl %r15d, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x5a4e3
movq %r12, %rbp
cmpq %r12, %rax
je 0x5a50d
cmpl 0x20(%rax), %r15d
cmovlq %r12, %rax
movq %rax, %rbp
cmpq %r12, %rbp
je 0x5a530
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xf697(%rip), %rsi # 0x69bb8
callq 0x2d420
leaq 0x70(%rbp), %rax
addq $0x78, %rbp
jmp 0x5a55b
cmpq $0x0, 0x50(%r14)
je 0x5a610
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xf66e(%rip), %rsi # 0x69bb8
callq 0x2d420
movq 0x50(%r14), %rbp
leaq 0x48(%rbp), %rax
addq $0x50, %rbp
movq (%rax), %rsi
movq (%rbp), %rdx
movq %rbx, %rdi
callq 0x2d420
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2d420
leal 0x1(%r15), %ecx
movl 0x58(%r14), %eax
cmpl %eax, %r15d
movl %ecx, %r15d
jl 0x5a4ba
cmpl $0x2, %eax
setge %al
jmp 0x5a598
xorl %eax, %eax
cmpq $0x0, 0x50(%r14)
je 0x5a601
testb %al, %al
je 0x5a5b7
leaq 0xeb47(%rip), %rsi # 0x690f1
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2d420
leaq 0xf6d5(%rip), %rsi # 0x69c93
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2d420
movq 0x50(%r14), %rax
movq 0x48(%rax), %rsi
movq 0x50(%rax), %rdx
movq %rbx, %rdi
callq 0x2d420
leaq 0xf6b0(%rip), %rsi # 0x69c96
movl $0x6, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d420
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2d1b0
movq %rax, %rbx
leaq 0xf634(%rip), %rsi # 0x69c58
movq %rax, %rdi
callq 0x2d4f0
movq 0x2799d(%rip), %rsi # 0x81fd0
movq 0x2797e(%rip), %rdx # 0x81fb8
movq %rbx, %rdi
callq 0x2d640
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d2d0
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Clara::CommandLine<Catch::ConfigData>::optUsage(std::ostream&, unsigned long, unsigned long) const
|
void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const {
typename std::vector<Arg>::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
std::size_t maxWidth = 0;
for( it = itBegin; it != itEnd; ++it )
maxWidth = (std::max)( maxWidth, it->commands().size() );
for( it = itBegin; it != itEnd; ++it ) {
Detail::Text usageText( it->commands(), Detail::TextAttributes()
.setWidth( maxWidth+indent )
.setIndent( indent ) );
Detail::Text desc( it->description, Detail::TextAttributes()
.setWidth( width - maxWidth - 3 ) );
for( std::size_t i = 0; i < (std::max)( usageText.size(), desc.size() ); ++i ) {
std::string usageCol = i < usageText.size() ? usageText[i] : "";
os << usageCol;
if( i < desc.size() && !desc[i].empty() )
os << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' )
<< desc[i];
os << "\n";
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, 0x28(%rsp)
movq %rdx, 0x40(%rsp)
movq %rsi, %r15
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %rax
movq %rax, 0x38(%rsp)
cmpq %rax, %r14
movq %r14, 0x30(%rsp)
je 0x5a6dd
leaq 0xe0(%rsp), %r13
xorl %r12d, %r12d
leaq 0xd0(%rsp), %rbx
movq %r12, %rbp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x59eb0
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %r12
cmpq %r12, %rbp
cmovaq %rbp, %r12
cmpq %r13, %rdi
je 0x5a6cd
callq 0x2d360
addq $0xa8, %r14
cmpq 0x38(%rsp), %r14
jne 0x5a69e
jmp 0x5a6e0
xorl %r12d, %r12d
movq 0x30(%rsp), %rbx
cmpq 0x38(%rsp), %rbx
je 0x5a990
movq 0x40(%rsp), %rcx
leaq (%r12,%rcx), %rax
movq %rax, 0x68(%rsp)
movq 0x28(%rsp), %rax
subq %r12, %rax
addq $-0x3, %rax
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %r14
leaq (%r12,%rcx), %rax
addq $0x2, %rax
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %r12
leaq 0x8(%rsp), %rbp
leaq 0xfa6e(%rip), %r13 # 0x6a1a0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x59eb0
movq $-0x1, 0x8(%rsp)
movb $0x9, 0x20(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xd0(%rsp), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x5aa16
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x5a789
callq 0x2d360
movq %rbx, 0x30(%rsp)
leaq 0x8(%rbx), %rsi
movq $-0x1, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x9, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %r12, %rdi
movq %rbp, %rdx
callq 0x5aa16
movq 0x110(%rsp), %rax
movq 0x118(%rsp), %rcx
subq %rax, %rcx
movq 0xc0(%rsp), %rdx
subq 0xb8(%rsp), %rdx
orq %rcx, %rdx
cmpq $0x20, %rdx
jb 0x5a929
sarq $0x5, %rcx
movl $0x8, %r12d
xorl %ebx, %ebx
cmpq %rcx, %rbx
jae 0x5a81a
movq %r14, 0x8(%rsp)
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x4042a
jmp 0x5a82d
movq %r14, 0x8(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x3ef3e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x2d420
movq 0xb8(%rsp), %rax
movq 0xc0(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rcx, %rbx
jae 0x5a8c4
cmpq $0x0, (%rax,%r12)
je 0x5a8c4
movq 0x70(%rsp), %rsi
subq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x20, %edx
callq 0x2d440
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r15, %rdi
callq 0x2d420
movq 0xb8(%rsp), %rcx
movq -0x8(%rcx,%r12), %rsi
movq (%rcx,%r12), %rdx
movq %rax, %rdi
callq 0x2d420
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x5a8c4
callq 0x2d360
movl $0x1, %edx
movq %r15, %rdi
leaq 0xf8cc(%rip), %rsi # 0x6a19f
callq 0x2d420
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5a8e7
callq 0x2d360
incq %rbx
movq 0x110(%rsp), %rax
movq 0x118(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
movq 0xc0(%rsp), %rdx
subq 0xb8(%rsp), %rdx
sarq $0x5, %rdx
cmpq %rdx, %rcx
cmovaq %rcx, %rdx
addq $0x20, %r12
cmpq %rdx, %rbx
jb 0x5a7fa
leaq 0xb8(%rsp), %rdi
callq 0x48df4
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x5a94d
callq 0x2d360
leaq 0x110(%rsp), %rdi
callq 0x48df4
movq 0xd0(%rsp), %rdi
leaq 0xe0(%rsp), %rax
cmpq %rax, %rdi
movq 0x30(%rsp), %rbx
leaq 0x78(%rsp), %r12
je 0x5a97e
callq 0x2d360
addq $0xa8, %rbx
cmpq 0x38(%rsp), %rbx
jne 0x5a732
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x5aa0e
callq 0x2d360
jmp 0x5aa0e
movq %rax, %rbx
jmp 0x5aa01
jmp 0x5a9e5
jmp 0x5a9c7
movq %rax, %rbx
jmp 0x5a9f7
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x5a9e8
callq 0x2d360
jmp 0x5a9e8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5a9f7
callq 0x2d360
leaq 0x78(%rsp), %rdi
callq 0x5af28
leaq 0xd0(%rsp), %rdi
callq 0x5af28
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Tbc::Text::Text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Tbc::TextAttributes const&)
|
Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
: attr( _attr )
{
std::string wrappableChars = " [({.,/|\\-";
std::size_t indent = _attr.initialIndent != std::string::npos
? _attr.initialIndent
: _attr.indent;
std::string remainder = _str;
while( !remainder.empty() ) {
if( lines.size() >= 1000 ) {
lines.push_back( "... message truncated due to excessive size" );
return;
}
std::size_t tabPos = std::string::npos;
std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
std::size_t pos = remainder.find_first_of( '\n' );
if( pos <= width ) {
width = pos;
}
pos = remainder.find_last_of( _attr.tabChar, width );
if( pos != std::string::npos ) {
tabPos = pos;
if( remainder[width] == '\n' )
width--;
remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
}
if( width == remainder.size() ) {
spliceLine( indent, remainder, width );
}
else if( remainder[width] == '\n' ) {
spliceLine( indent, remainder, width );
if( width <= 1 || remainder.size() != 1 )
remainder = remainder.substr( 1 );
indent = _attr.indent;
}
else {
pos = remainder.find_last_of( wrappableChars, width );
if( pos != std::string::npos && pos > 0 ) {
spliceLine( indent, remainder, pos );
if( remainder[0] == ' ' )
remainder = remainder.substr( 1 );
}
else {
spliceLine( indent, remainder, width-1 );
lines.back() += "-";
}
if( lines.size() == 1 )
indent = _attr.indent;
if( tabPos != std::string::npos )
indent += tabPos;
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x90(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm0, 0x20(%rdi)
movups %xmm1, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq %rax, 0x50(%rdi)
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xf177(%rip), %rsi # 0x69bf6
leaq 0xf17a(%rip), %rdx # 0x69c00
leaq 0xa8(%rsp), %rdi
movq %rbx, 0x48(%rsp)
callq 0x3ef3e
movq (%r15), %rbp
cmpq $-0x1, %rbp
jne 0x5aaa5
movq 0x8(%r15), %rbp
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x4042a
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x5ae38
leaq 0x20(%rsp), %r12
movq %r15, 0x98(%rsp)
movq 0x48(%rbx), %rcx
subq 0x40(%rbx), %rcx
cmpq $0x7ce1, %rcx # imm = 0x7CE1
jae 0x5adff
movq 0x10(%r15), %r14
subq %rbp, %r14
cmpq %rax, %r14
cmovaeq %rax, %r14
movq %r12, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x2d4a0
cmpq %r14, %rax
cmovbq %rax, %r14
movsbl 0x18(%r15), %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x2d720
cmpq $-0x1, %rax
je 0x5abdb
movq %rax, %r13
movq %rbp, 0xa0(%rsp)
movq 0x20(%rsp), %rax
xorl %r15d, %r15d
cmpb $0xa, (%rax,%r14)
sete %bl
leaq 0x70(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x2d3e0
movq %r13, %rdx
incq %rdx
leaq 0x50(%rsp), %rdi
movq %r12, %rbp
movq %r12, %rsi
movq $-0x1, %rcx
callq 0x2d3e0
movq 0x70(%rsp), %rcx
movl $0xf, %esi
leaq 0x80(%rsp), %rax
cmpq %rax, %rcx
movq %rsp, %r12
je 0x5ab9c
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %r8
movq 0x58(%rsp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rsi, %rax
jbe 0x5abca
movl $0xf, %esi
leaq 0x60(%rsp), %rdi
cmpq %rdi, 0x50(%rsp)
je 0x5abc5
movq 0x60(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x5abe7
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x2d100
jmp 0x5abf5
movq $-0x1, %r13
jmp 0x5aca2
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d400
leaq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x5ac18
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x5ac1e
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2d480
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5ac59
callq 0x2d360
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x5ac6d
callq 0x2d360
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x5ac84
callq 0x2d360
movb %bl, %r15b
subq %r15, %r14
movq 0x98(%rsp), %r15
movq 0x48(%rsp), %rbx
movq %rbp, %r12
movq 0xa0(%rsp), %rbp
cmpq 0x28(%rsp), %r14
jne 0x5acbf
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x5af4a
jmp 0x5adef
movq 0x20(%rsp), %rax
cmpb $0xa, (%rax,%r14)
jne 0x5ad2b
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x5af4a
cmpq $0x2, %r14
jb 0x5acea
cmpq $0x1, 0x28(%rsp)
je 0x5ad22
movl $0x1, %edx
movq %rsp, %r14
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rcx
callq 0x2d3e0
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d480
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5ad22
callq 0x2d360
movq 0x8(%r15), %rbp
jmp 0x5adef
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rcx
movq %r12, %rdi
movq %r14, %rdx
callq 0x2d740
leaq -0x1(%rax), %rcx
cmpq $-0x3, %rcx
ja 0x5ada5
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x5af4a
movq 0x20(%rsp), %rax
cmpb $0x20, (%rax)
jne 0x5adcd
movl $0x1, %edx
movq %rsp, %r14
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rcx
callq 0x2d3e0
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d480
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5adcd
callq 0x2d360
jmp 0x5adcd
decq %r14
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x5af4a
movq 0x48(%rbx), %rdi
addq $-0x20, %rdi
leaq 0xf5fd(%rip), %rsi # 0x6a3c5
callq 0x2d700
movq 0x48(%rbx), %rax
subq 0x40(%rbx), %rax
cmpq $0x20, %rax
jne 0x5addf
movq 0x8(%r15), %rbp
cmpq $-0x1, %r13
movl $0x0, %eax
cmovneq %r13, %rax
addq %rax, %rbp
movq 0x28(%rsp), %rax
testq %rax, %rax
jne 0x5aadd
jmp 0x5ae38
movq %rsp, %rdi
leaq 0x10(%rsp), %rbx
movq %rbx, (%rdi)
leaq 0xedf0(%rip), %rsi # 0x69c01
leaq 0xee14(%rip), %rdx # 0x69c2c
callq 0x3ef3e
movq %rsp, %rsi
movq 0x40(%rsp), %rdi
callq 0x64a8a
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x5ae38
callq 0x2d360
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x5ae4c
callq 0x2d360
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x5ae66
callq 0x2d360
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
jne 0x5aec4
jmp 0x5aed0
jmp 0x5aecd
jmp 0x5aecd
movq %rax, %r14
jmp 0x5aee4
movq %rax, %r14
jmp 0x5aefe
jmp 0x5aecd
movq %rax, %r14
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x5aeb2
callq 0x2d360
jmp 0x5aeb2
movq %rax, %r14
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x5aed0
callq 0x2d360
jmp 0x5aed0
jmp 0x5aecd
movq %rax, %r14
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x5aee4
callq 0x2d360
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x5aefe
callq 0x2d360
movq 0x40(%rsp), %rdi
callq 0x48df4
movq 0x48(%rsp), %rax
movq (%rax), %rdi
cmpq 0x90(%rsp), %rdi
je 0x5af1f
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Tbc::Text::~Text()
|
Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
: attr( _attr )
{
std::string wrappableChars = " [({.,/|\\-";
std::size_t indent = _attr.initialIndent != std::string::npos
? _attr.initialIndent
: _attr.indent;
std::string remainder = _str;
while( !remainder.empty() ) {
if( lines.size() >= 1000 ) {
lines.push_back( "... message truncated due to excessive size" );
return;
}
std::size_t tabPos = std::string::npos;
std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
std::size_t pos = remainder.find_first_of( '\n' );
if( pos <= width ) {
width = pos;
}
pos = remainder.find_last_of( _attr.tabChar, width );
if( pos != std::string::npos ) {
tabPos = pos;
if( remainder[width] == '\n' )
width--;
remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
}
if( width == remainder.size() ) {
spliceLine( indent, remainder, width );
}
else if( remainder[width] == '\n' ) {
spliceLine( indent, remainder, width );
if( width <= 1 || remainder.size() != 1 )
remainder = remainder.substr( 1 );
indent = _attr.indent;
}
else {
pos = remainder.find_last_of( wrappableChars, width );
if( pos != std::string::npos && pos > 0 ) {
spliceLine( indent, remainder, pos );
if( remainder[0] == ' ' )
remainder = remainder.substr( 1 );
}
else {
spliceLine( indent, remainder, width-1 );
lines.back() += "-";
}
if( lines.size() == 1 )
indent = _attr.indent;
if( tabPos != std::string::npos )
indent += tabPos;
}
}
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x40, %rdi
callq 0x48df4
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x5af47
popq %rbx
jmp 0x2d360
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Tbc::Text::spliceLine(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long)
|
void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
_remainder = _remainder.substr( _pos );
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x40(%rsp), %rdi
movl $0x20, %edx
callq 0x2d440
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x2d3e0
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x28(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x5afad
movq 0x50(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x5afcc
leaq 0x30(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x5afc7
movq 0x30(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x5afdd
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x2d100
jmp 0x5afeb
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d400
leaq 0x10(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x5b00e
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x5b014
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rsp)
movq %rcx, (%rax)
addq $0x40, %r15
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq %rsp, %rsi
movq %r15, %rdi
callq 0x64a8a
leaq 0x10(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x5b053
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5b066
callq 0x2d360
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x5b075
callq 0x2d360
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq 0x2d3e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d480
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x5b0a5
callq 0x2d360
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5b0ce
callq 0x2d360
jmp 0x5b0ce
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5b0e6
callq 0x2d360
jmp 0x5b0e6
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x5b0f5
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Config::Config(Catch::ConfigData const&)
|
Config( ConfigData const& data )
: m_data( data ),
m_stream( openStream() )
{
if( !data.testsOrTags.empty() ) {
TestSpecParser parser( ITagAliasRegistry::get() );
for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
parser.parse( data.testsOrTags[i] );
m_testSpec = parser.testSpec();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x0, 0x8(%rdi)
leaq 0x250f9(%rip), %rax # 0x80278
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x5b38e
movq %r14, %rdi
callq 0x5b4b2
movq %rax, 0xc8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%r14)
movq $0x0, 0xe0(%r14)
movq 0xa0(%r15), %rax
cmpq 0xa8(%r15), %rax
je 0x5b2f3
movq %rbx, 0x8(%rsp)
callq 0x48044
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, 0x20(%r13)
movups %xmm0, 0x30(%r13)
leaq 0x272f0(%rip), %rax # 0x824f0
movq %rax, 0x40(%r13)
movq 0xa0(%r15), %rsi
cmpq %rsi, 0xa8(%r15)
je 0x5b249
xorl %ebp, %ebp
leaq 0x30(%rsp), %r12
xorl %ebx, %ebx
addq %rbp, %rsi
movq %r12, %rdi
callq 0x49278
incq %rbx
movq 0xa0(%r15), %rsi
movq 0xa8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %rbp
cmpq %rax, %rbx
jb 0x5b21d
leaq 0x30(%rsp), %rdi
callq 0x50fdc
leaq 0x80(%rsp), %r15
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x50a00
leaq 0x68(%rsp), %rbx
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movups 0xd0(%r14), %xmm0
movq 0xe0(%r14), %rax
leaq 0x10(%rsp), %r12
movaps (%r12), %xmm1
movups %xmm1, 0xd0(%r14)
movq 0x10(%r12), %rcx
movq %rcx, 0xe0(%r14)
movq 0x10(%rdi), %rcx
movq %rax, 0x10(%rdi)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movaps %xmm1, (%r12)
movq %rcx, 0x10(%r12)
callq 0x518b0
movq %r12, %rdi
callq 0x518b0
movq %r15, %rdi
callq 0x518b0
movq %rbx, %rdi
callq 0x50c8c
movq -0x20(%rbx), %rdi
cmpq %r13, %rdi
je 0x5b2f3
callq 0x2d360
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, 0x8(%rsp)
movq %rax, %r15
jmp 0x5b33f
jmp 0x5b311
movq %rax, %r15
leaq 0xd0(%r14), %r12
leaq 0x30(%rsp), %rdi
callq 0x49312
movq %r12, %rdi
callq 0x518b0
movq 0xc8(%r14), %rdi
testq %rdi, %rdi
je 0x5b33f
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rdi
callq 0x55c70
movq %r15, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Ptr<Catch::Config>::operator=(Catch::Config*)
|
Ptr& operator = ( T* p ){
Ptr temp( p );
swap( temp );
return *this;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x5b36a
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x5b37b
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConfigData::ConfigData(Catch::ConfigData const&)
|
ConfigData()
: listTests( false ),
listTags( false ),
listReporters( false ),
listTestNamesOnly( false ),
showSuccessfulTests( false ),
shouldDebugBreak( false ),
noThrow( false ),
showHelp( false ),
showInvisibles( false ),
forceColour( false ),
filenamesAsTags( false ),
abortAfter( -1 ),
rngSeed( 0 ),
verbosity( Verbosity::Normal ),
warnings( WarnAbout::Nothing ),
showDurations( ShowDurations::DefaultForReporter ),
runOrder( RunTests::InDeclarationOrder )
{}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r12
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $0x28, %rdi
leaq 0x38(%r12), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x28(%r12)
movq 0x28(%rsi), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
movq %rdi, 0x10(%rsp)
callq 0x4042a
leaq 0x48(%r12), %r14
leaq 0x58(%r12), %rbx
movq %rbx, 0x48(%r12)
movq 0x48(%r15), %rsi
movq 0x50(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4042a
movq %rbx, (%rsp)
leaq 0x68(%r12), %r13
leaq 0x78(%r12), %rbx
movq %rbx, 0x68(%r12)
movq 0x68(%r15), %rsi
movq 0x70(%r15), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x4042a
movl $0x88, %esi
leaq (%r12,%rsi), %rbp
addq %r15, %rsi
movq %rbp, %rdi
callq 0x4e87c
movl $0xa0, %eax
addq %rax, %r12
addq %rax, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x4e87c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %rbp, %rdi
callq 0x48df4
jmp 0x5b46f
movq %rax, %r15
movq (%r13), %rdi
cmpq %rbx, %rdi
je 0x5b482
callq 0x2d360
jmp 0x5b482
movq %rax, %r15
movq (%r14), %rdi
cmpq (%rsp), %rdi
je 0x5b495
callq 0x2d360
jmp 0x5b495
movq %rax, %r15
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0x5b4a9
callq 0x2d360
movq %r15, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::listTests(Catch::Config const&)
|
inline std::size_t listTests( Config const& config ) {
TestSpec testSpec = config.testSpec();
if( config.testSpec().hasFilters() )
Catch::cout() << "Matching test cases:\n";
else {
Catch::cout() << "All available test cases:\n";
testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
}
std::size_t matchedTests = 0;
TextAttributes nameAttr, tagsAttr;
nameAttr.setInitialIndent( 2 ).setIndent( 4 );
tagsAttr.setIndent( 6 );
std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
it != itEnd;
++it ) {
matchedTests++;
TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
Colour::Code colour = testCaseInfo.isHidden()
? Colour::SecondaryText
: Colour::None;
Colour colourGuard( colour );
Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl;
if( !testCaseInfo.tags.empty() )
Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
}
if( !config.testSpec().hasFilters() )
Catch::cout() << pluralise( matchedTests, "test case" ) << "\n" << std::endl;
else
Catch::cout() << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl;
return matchedTests;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %r13
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x50a00
movq (%r13), %rax
movq %r13, %rdi
callq *0x68(%rax)
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x5b636
movq 0x269a0(%rip), %rdi # 0x81fc0
leaq 0xe693(%rip), %rsi # 0x69cba
movl $0x15, %edx
callq 0x2d420
jmp 0x5b760
movq 0x26983(%rip), %rdi # 0x81fc0
leaq 0xe68c(%rip), %rsi # 0x69cd0
movl $0x1a, %edx
callq 0x2d420
callq 0x48044
leaq 0x80(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x30(%r15)
leaq 0x26e6c(%rip), %rax # 0x824f0
movq %rax, 0x40(%r15)
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xec56(%rip), %rsi # 0x6a2ef
leaq 0xec50(%rip), %rdx # 0x6a2f0
leaq 0x20(%rsp), %rdi
callq 0x3ef3e
leaq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x49278
movq %rax, %rbx
movq %rax, %rdi
callq 0x50fdc
addq $0x50, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x50a00
leaq 0x90(%rsp), %rbx
xorps %xmm0, %xmm0
leaq 0xf0(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps 0x40(%rsp), %xmm0
movq 0x50(%rsp), %rax
movq %rsp, %r14
movaps (%r14), %xmm1
movaps %xmm1, 0x40(%rsp)
movq 0x10(%r14), %rcx
movq %rcx, 0x50(%rsp)
movq %rax, 0x10(%rdi)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movaps %xmm1, (%r14)
movq $0x0, 0x10(%r14)
callq 0x518b0
movq %r14, %rdi
callq 0x518b0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5b73a
callq 0x2d360
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0x518b0
movq %rbx, %rdi
callq 0x50c8c
movq -0x38(%r14), %rdi
cmpq %r15, %rdi
je 0x5b760
callq 0x2d360
movq $-0x1, %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movl $0x4f, %ecx
movq %rcx, 0x30(%rsp)
movb $0x9, %dl
movb %dl, 0x38(%rsp)
movq %rax, 0xf0(%rsp)
movq %rcx, 0x100(%rsp)
movb %dl, 0x108(%rsp)
movq $0x2, 0x20(%rsp)
movq $0x4, 0x28(%rsp)
movq $0x6, 0xf8(%rsp)
callq 0x41b5a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
movq %r13, %rsi
callq *0x18(%rcx)
leaq 0xd8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %rax, %rsi
movq %r13, %rcx
callq 0x42b00
movq %r13, 0xc8(%rsp)
movq 0xd8(%rsp), %r15
movq 0xe0(%rsp), %rax
movq %rax, 0xd0(%rsp)
xorl %ebx, %ebx
cmpq %rax, %r15
je 0x5b9b8
movq 0x267a2(%rip), %r13 # 0x81fc0
leaq 0xe97a(%rip), %r12 # 0x6a19f
movl 0x108(%r15), %edi
shll $0x1e, %edi
sarl $0x1f, %edi
andl $0x17, %edi
movb $0x0, (%rsp)
callq 0x437d0
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
leaq 0x20(%rsp), %rdx
callq 0x5874e
movq 0x98(%rsp), %rbp
movq 0xa0(%rsp), %r14
cmpq %r14, %rbp
je 0x5b895
cmpq 0x98(%rsp), %rbp
je 0x5b87f
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2d420
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %r13, %rdi
callq 0x2d420
addq $0x20, %rbp
jmp 0x5b860
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %r13, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
leaq 0x98(%rsp), %rdi
callq 0x48df4
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x5b8de
callq 0x2d360
cmpq $0x0, 0x88(%r15)
je 0x5b993
leaq 0xc0(%r15), %rsi
leaq 0x58(%rsp), %rdi
leaq 0xf0(%rsp), %rdx
callq 0x5874e
movq 0x98(%rsp), %rbp
movq 0xa0(%rsp), %r14
cmpq %r14, %rbp
je 0x5b94a
cmpq 0x98(%rsp), %rbp
je 0x5b934
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2d420
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %r13, %rdi
callq 0x2d420
addq $0x20, %rbp
jmp 0x5b915
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %r13, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
leaq 0x98(%rsp), %rdi
callq 0x48df4
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x5b993
callq 0x2d360
cmpb $0x0, (%rsp)
jne 0x5b9a0
xorl %edi, %edi
callq 0x437d0
incq %rbx
addq $0x118, %r15 # imm = 0x118
cmpq 0xd0(%rsp), %r15
jne 0x5b825
movq 0xc8(%rsp), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x5ba72
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe308(%rip), %rsi # 0x69ceb
leaq 0xe313(%rip), %rdx # 0x69cfd
movq %rsp, %rdi
callq 0x3ef3e
leaq 0x60(%rsp), %rdi
movq %rbx, -0x8(%rdi)
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x265a3(%rip), %rdi # 0x81fc0
leaq 0x58(%rsp), %rsi
callq 0x4542d
movq 0x26592(%rip), %r14 # 0x81fc0
leaq 0xe76a(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq 0x26560(%rip), %rdi # 0x81fc0
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
jmp 0x5bb0c
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe272(%rip), %rsi # 0x69cf4
leaq 0xe274(%rip), %rdx # 0x69cfd
movq %rsp, %rdi
callq 0x3ef3e
leaq 0x60(%rsp), %rdi
movq %rbx, -0x8(%rdi)
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x26504(%rip), %rdi # 0x81fc0
leaq 0x58(%rsp), %rsi
callq 0x4542d
movq 0x264f3(%rip), %r14 # 0x81fc0
leaq 0xe6cb(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq 0x264c1(%rip), %rdi # 0x81fc0
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x5bb1b
callq 0x2d360
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5bb29
callq 0x2d360
leaq 0xd8(%rsp), %rdi
callq 0x49b18
leaq 0x40(%rsp), %rdi
callq 0x518b0
movq %rbx, %rax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5bb5e
jmp 0x5bbba
movq %rax, %rbx
jmp 0x5bb79
movq %rax, %rbx
jmp 0x5bb9b
jmp 0x5bbba
jmp 0x5bbba
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5bb79
callq 0x2d360
leaq 0x58(%rsp), %rdi
callq 0x49312
jmp 0x5bbec
jmp 0x5bb89
jmp 0x5bbab
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x5bb9b
callq 0x2d360
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5bbdf
callq 0x2d360
jmp 0x5bbdf
movq %rax, %rbx
jmp 0x5bbec
movq %rax, %rdi
callq 0x3ed5c
jmp 0x5bbbf
movq %rax, %rbx
jmp 0x5bbdf
movq %rax, %rbx
jmp 0x5bbd7
jmp 0x5bbca
jmp 0x5bbca
jmp 0x5bbca
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x58c60
movq %rsp, %rdi
callq 0x4383a
leaq 0xd8(%rsp), %rdi
callq 0x49b18
leaq 0x40(%rsp), %rdi
callq 0x518b0
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::listTestsNamesOnly(Catch::Config const&)
|
inline std::size_t listTestsNamesOnly( Config const& config ) {
TestSpec testSpec = config.testSpec();
if( !config.testSpec().hasFilters() )
testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
std::size_t matchedTests = 0;
std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
it != itEnd;
++it ) {
matchedTests++;
TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
Catch::cout() << testCaseInfo.name << std::endl;
}
return matchedTests;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x50a00
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jne 0x5bd52
callq 0x48044
leaq 0x68(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x30(%r12)
leaq 0x2687f(%rip), %rax # 0x824f0
movq %rax, 0x40(%r12)
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xe669(%rip), %rsi # 0x6a2ef
leaq 0xe663(%rip), %rdx # 0x6a2f0
leaq 0x20(%rsp), %rdi
callq 0x3ef3e
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x49278
movq %rax, %r14
movq %rax, %rdi
callq 0x50fdc
addq $0x50, %r14
leaq 0xb0(%rsp), %rdi
movq %r14, %rsi
callq 0x50a00
leaq 0x78(%rsp), %r14
xorps %xmm0, %xmm0
leaq 0xd0(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps (%rsp), %xmm0
movq 0x10(%rsp), %rax
leaq 0xb0(%rsp), %r15
movaps (%r15), %xmm1
movaps %xmm1, (%rsp)
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x10(%rdi)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movaps %xmm1, (%r15)
movq $0x0, 0x10(%r15)
callq 0x518b0
movq %r15, %rdi
callq 0x518b0
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x5bd2c
callq 0x2d360
leaq 0x90(%rsp), %r15
movq %r15, %rdi
callq 0x518b0
movq %r14, %rdi
callq 0x50c8c
movq -0x38(%r15), %rdi
cmpq %r12, %rdi
je 0x5bd52
callq 0x2d360
callq 0x41b5a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x18(%rcx)
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
movq %rax, %rsi
movq %rbx, %rcx
callq 0x42b00
movq 0x40(%rsp), %r12
movq 0x48(%rsp), %r13
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x5bde1
movq 0x26229(%rip), %r14 # 0x81fc0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x2d420
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %r15, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
addq $0x118, %r12 # imm = 0x118
incq %rbx
cmpq %r13, %r12
jne 0x5bd97
leaq 0x40(%rsp), %rdi
callq 0x49b18
movq %rsp, %rdi
callq 0x518b0
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x5be20
jmp 0x5be2c
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x5be20
callq 0x2d360
leaq 0x40(%rsp), %rdi
callq 0x49312
jmp 0x5be3e
movq %rax, %rbx
jmp 0x5be3e
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x49b18
movq %rsp, %rdi
callq 0x518b0
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::listTags(Catch::Config const&)
|
inline std::size_t listTags( Config const& config ) {
TestSpec testSpec = config.testSpec();
if( config.testSpec().hasFilters() )
Catch::cout() << "Tags for matching test cases:\n";
else {
Catch::cout() << "All available tags:\n";
testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
}
std::map<std::string, TagInfo> tagCounts;
std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
it != itEnd;
++it ) {
for( std::set<std::string>::const_iterator tagIt = it->getTestCaseInfo().tags.begin(),
tagItEnd = it->getTestCaseInfo().tags.end();
tagIt != tagItEnd;
++tagIt ) {
std::string tagName = *tagIt;
std::string lcaseTagName = toLower( tagName );
std::map<std::string, TagInfo>::iterator countIt = tagCounts.find( lcaseTagName );
if( countIt == tagCounts.end() )
countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
countIt->second.add( tagName );
}
}
for( std::map<std::string, TagInfo>::const_iterator countIt = tagCounts.begin(),
countItEnd = tagCounts.end();
countIt != countItEnd;
++countIt ) {
std::ostringstream oss;
oss << " " << std::setw(2) << countIt->second.count << " ";
Text wrapper( countIt->second.all(), TextAttributes()
.setInitialIndent( 0 )
.setIndent( oss.str().size() )
.setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) );
Catch::cout() << oss.str() << wrapper << "\n";
}
Catch::cout() << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl;
return tagCounts.size();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0xa0(%rsp), %rdi
movq %rax, %rsi
callq 0x50a00
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x5bea7
movq 0x2612f(%rip), %rdi # 0x81fc0
leaq 0xde66(%rip), %rsi # 0x69cfe
movl $0x1e, %edx
callq 0x2d420
jmp 0x5bfe6
movq 0x26112(%rip), %rdi # 0x81fc0
leaq 0xde68(%rip), %rsi # 0x69d1d
movl $0x14, %edx
callq 0x2d420
callq 0x48044
leaq 0x168(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x30(%r12)
leaq 0x265f5(%rip), %rax # 0x824f0
movq %rax, 0x40(%r12)
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xe3df(%rip), %rsi # 0x6a2ef
leaq 0xe3d9(%rip), %rdx # 0x6a2f0
leaq 0x28(%rsp), %rdi
callq 0x3ef3e
leaq 0x140(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x49278
movq %rax, %r14
movq %rax, %rdi
callq 0x50fdc
addq $0x50, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x50a00
leaq 0x178(%rsp), %r14
xorps %xmm0, %xmm0
leaq 0xd0(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps 0xa0(%rsp), %xmm0
movq 0xb0(%rsp), %rax
movq %rsp, %r15
movaps (%r15), %xmm1
movaps %xmm1, 0xa0(%rsp)
movq 0x10(%r15), %rcx
movq %rcx, 0xb0(%rsp)
movq %rax, 0x10(%rdi)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movaps %xmm1, (%r15)
movq $0x0, 0x10(%r15)
callq 0x518b0
movq %r15, %rdi
callq 0x518b0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x5bfc0
callq 0x2d360
leaq 0x190(%rsp), %r15
movq %r15, %rdi
callq 0x518b0
movq %r14, %rdi
callq 0x50c8c
movq -0x38(%r15), %rdi
cmpq %r12, %rdi
je 0x5bfe6
callq 0x2d360
leaq 0xd8(%rsp), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
callq 0x41b5a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x18(%rcx)
leaq 0x108(%rsp), %rdi
leaq 0xa0(%rsp), %rdx
movq %rax, %rsi
movq %rbx, %rcx
callq 0x42b00
movq 0x108(%rsp), %rax
movq 0x110(%rsp), %rcx
movq %rcx, 0xc0(%rsp)
cmpq %rcx, %rax
je 0x5c287
leaq 0x10(%rsp), %r13
movq %rsp, %r14
leaq 0x80(%rsp), %r15
movq 0x78(%rax), %rbx
movq %rax, 0xc8(%rsp)
leaq 0x68(%rax), %r12
cmpq %r12, %rbx
je 0x5c26b
movq %r13, (%rsp)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4042a
movq %r15, %rdi
movq %r14, %rsi
callq 0x43fe4
leaq 0xd0(%rsp), %rdi
movq %r15, %rsi
callq 0x5cb4c
movq %rax, %rbp
leaq 0xd8(%rsp), %rax
cmpq %rax, %rbp
jne 0x5c21c
movl $0x0, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x150(%rsp), %rax
movq %rax, 0x140(%rsp)
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
addq %rsi, %rdx
leaq 0x140(%rsp), %rdi
callq 0x4042a
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x5c188
movl 0x30(%rsp), %ecx
movl %ecx, 0x168(%rsp)
movq %rax, 0x170(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, 0x178(%rsp)
leaq 0x168(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x188(%rsp)
movq $0x0, 0x38(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rax
jmp 0x5c1bf
movl $0x0, 0x168(%rsp)
movq $0x0, 0x170(%rsp)
leaq 0x168(%rsp), %rax
movq %rax, 0x178(%rsp)
movq %rax, 0x180(%rsp)
leaq 0x188(%rsp), %rax
movq $0x0, (%rax)
movq 0x58(%rsp), %rax
movq %rax, 0x190(%rsp)
leaq 0xd0(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0x5cbb4
movq %rax, %rbp
leaq 0x160(%rsp), %rdi
callq 0x5242a
movq 0x140(%rsp), %rdi
leaq 0x150(%rsp), %rax
cmpq %rax, %rdi
je 0x5c212
callq 0x2d360
leaq 0x28(%rsp), %rdi
callq 0x5242a
incq 0x70(%rbp)
addq $0x40, %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x64c8c
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x5c249
callq 0x2d360
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x5c257
callq 0x2d360
movq %rbx, %rdi
callq 0x2d430
movq %rax, %rbx
cmpq %r12, %rax
jne 0x5c085
movq 0xc8(%rsp), %rax
addq $0x118, %rax # imm = 0x118
cmpq 0xc0(%rsp), %rax
jne 0x5c06c
movq 0xe8(%rsp), %rbx
leaq 0xd8(%rsp), %rax
cmpq %rax, %rbx
je 0x5c49c
leaq 0x148(%rsp), %r15
leaq 0x140(%rsp), %r14
leaq 0xd97d(%rip), %r13 # 0x69c34
movq %rsp, %r12
movq %r14, %rdi
callq 0x2d4b0
movl $0x2, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2d420
movq 0x140(%rsp), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x150(%rsp,%rax)
movq 0x70(%rbx), %rsi
movq %r14, %rdi
callq 0x2d270
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2d420
leaq 0x40(%rbx), %rsi
movq %r12, %rdi
callq 0x5ca00
movq $0x4f, 0x90(%rsp)
movb $0x9, 0x98(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rsp)
leaq 0x120(%rsp), %rdi
movq %r15, %rsi
callq 0x2d5a0
movq 0x128(%rsp), %rax
movq %rax, 0x88(%rsp)
movq $0x46, 0x90(%rsp)
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
leaq 0x80(%rsp), %rdx
callq 0x5874e
movq 0x120(%rsp), %rdi
leaq 0x130(%rsp), %rax
cmpq %rax, %rdi
je 0x5c38c
callq 0x2d360
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5c39f
callq 0x2d360
movq %r12, %rdi
movq %r15, %rsi
callq 0x2d5a0
movq %rbx, %r12
movq %r13, %rbx
movq %r14, %r13
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x25bfd(%rip), %rdi # 0x81fc0
callq 0x2d420
movq %rax, %r14
movq 0x68(%rsp), %rbp
movq 0x70(%rsp), %r15
cmpq %r15, %rbp
je 0x5c40b
cmpq 0x68(%rsp), %rbp
je 0x5c3f5
movl $0x1, %edx
movq %r14, %rdi
leaq 0xddaf(%rip), %rsi # 0x6a19f
callq 0x2d420
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %r14, %rdi
callq 0x2d420
addq $0x20, %rbp
jmp 0x5c3d5
movl $0x1, %edx
movq %r14, %rdi
leaq 0xdd85(%rip), %rsi # 0x6a19f
callq 0x2d420
leaq 0x148(%rsp), %r15
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
movq %r13, %r14
movq %rbx, %r13
movq %r12, %rbx
movq %rsp, %r12
je 0x5c446
callq 0x2d360
leaq 0x68(%rsp), %rdi
callq 0x48df4
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5c464
callq 0x2d360
movq %r14, %rdi
movq 0x25b42(%rip), %rsi # 0x81fb0
callq 0x2d1d0
leaq 0x1b0(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d430
movq %rax, %rbx
leaq 0xd8(%rsp), %rax
cmpq %rax, %rbx
jne 0x5c2ba
movq 0xf8(%rsp), %rbx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xd87e(%rip), %rsi # 0x69d32
leaq 0xd87a(%rip), %rdx # 0x69d35
leaq 0x28(%rsp), %rdi
callq 0x3ef3e
leaq 0x148(%rsp), %rdi
movq %rbx, -0x8(%rdi)
leaq 0x158(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x25aca(%rip), %rdi # 0x81fc0
leaq 0x140(%rsp), %rsi
callq 0x4542d
movq 0x25ab6(%rip), %rbx # 0x81fc0
leaq 0xdc8e(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2d420
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq 0x25a84(%rip), %rdi # 0x81fc0
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
movq 0x148(%rsp), %rdi
cmpq %r15, %rdi
je 0x5c55b
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x5c56a
callq 0x2d360
leaq 0xd0(%rsp), %rbx
movq 0x28(%rbx), %r14
leaq 0x108(%rsp), %rdi
callq 0x49b18
movq %rbx, %rdi
callq 0x5ce2c
leaq 0xa0(%rsp), %rdi
callq 0x518b0
movq %r14, %rax
addq $0x2b8, %rsp # imm = 0x2B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5c5ce
movq %rax, %rbx
jmp 0x5c605
jmp 0x5c680
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x5c5ce
callq 0x2d360
leaq 0x140(%rsp), %rdi
callq 0x49312
jmp 0x5c712
movq %rax, %rbx
jmp 0x5c712
movq %rax, %rbx
jmp 0x5c705
movq %rax, %rbx
movq 0x148(%rsp), %rdi
cmpq %r15, %rdi
je 0x5c605
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
jne 0x5c6f3
jmp 0x5c6f8
jmp 0x5c680
jmp 0x5c65a
movq %rax, %rbx
jmp 0x5c63e
movq %rax, %rbx
movq 0x120(%rsp), %rdi
leaq 0x130(%rsp), %rax
cmpq %rax, %rdi
je 0x5c63e
callq 0x2d360
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5c6aa
callq 0x2d360
jmp 0x5c6aa
movq %rax, %rbx
jmp 0x5c6a0
jmp 0x5c68a
movq %rax, %rbx
jmp 0x5c6aa
movq %rax, %rbx
leaq 0x140(%rsp), %rdi
callq 0x5c9de
jmp 0x5c674
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5242a
jmp 0x5c6d0
movq %rax, %rbx
jmp 0x5c6f8
movq %rax, %rbx
jmp 0x5c6ea
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5c6a0
callq 0x2d360
leaq 0x28(%rsp), %rdi
callq 0x58c60
movq 0x258ff(%rip), %rsi # 0x81fb0
leaq 0x140(%rsp), %rdi
callq 0x2d1d0
leaq 0x1b0(%rsp), %rdi
callq 0x2d110
jmp 0x5c6f8
movq %rax, %rbx
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x5c6ea
callq 0x2d360
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x5c6f8
callq 0x2d360
leaq 0x108(%rsp), %rdi
callq 0x49b18
leaq 0xd0(%rsp), %rdi
callq 0x5ce2c
leaq 0xa0(%rsp), %rdi
callq 0x518b0
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::listReporters(Catch::Config const&)
|
virtual void invoke() const {
C obj;
(obj.*m_method)();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x25881(%rip), %rdi # 0x81fc0
leaq 0xd5f0(%rip), %rsi # 0x69d36
movl $0x15, %edx
callq 0x2d420
callq 0x41b5a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq 0x18(%rax), %r15
leaq 0x8(%rax), %r13
cmpq %r13, %r15
movq %rax, 0x20(%rsp)
je 0x5c79b
xorl %ecx, %ecx
movq %r15, %rax
movq 0x28(%rax), %r14
cmpq %r14, %rcx
cmovaq %rcx, %r14
movq %rax, %rdi
callq 0x2d430
movq %r14, %rcx
cmpq %r13, %rax
jne 0x5c77e
jmp 0x5c79e
xorl %r14d, %r14d
cmpq %r13, %r15
je 0x5c94c
leaq 0x7(%r14), %rax
movq %rax, 0x30(%rsp)
movl $0x48, %eax
subq %r14, %rax
movq %rax, 0x28(%rsp)
addq $0x2, %r14
movq %rsp, %rbx
movq 0x257f5(%rip), %r12 # 0x81fc0
movq 0x40(%r15), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movb $0x9, 0x58(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
leaq 0x40(%rsp), %rdx
callq 0x5874e
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5c81e
callq 0x2d360
movl $0x2, %edx
movq %r12, %rdi
leaq 0xd407(%rip), %rsi # 0x69c34
callq 0x2d420
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %r12, %rdi
callq 0x2d420
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0xcbc1(%rip), %rsi # 0x69415
callq 0x2d420
movq %r14, %rsi
subq 0x28(%r15), %rsi
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movl $0x20, %edx
callq 0x2d440
movq %r15, 0x38(%rsp)
movq %rbx, %r15
movq %r13, %rbx
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x2d420
movq %rax, %r12
movq 0xa0(%rsp), %r13
movq 0xa8(%rsp), %rbp
cmpq %rbp, %r13
je 0x5c8de
cmpq 0xa0(%rsp), %r13
je 0x5c8c8
movl $0x1, %edx
movq %r12, %rdi
leaq 0xd8dc(%rip), %rsi # 0x6a19f
callq 0x2d420
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r12, %rdi
callq 0x2d420
addq $0x20, %r13
jmp 0x5c8a5
movl $0x1, %edx
movq %r12, %rdi
leaq 0xd8b2(%rip), %rsi # 0x6a19f
callq 0x2d420
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
movq %rbx, %r13
movq %r15, %rbx
movq 0x38(%rsp), %r15
movq 0x256b0(%rip), %r12 # 0x81fc0
je 0x5c917
callq 0x2d360
leaq 0xa0(%rsp), %rdi
callq 0x48df4
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x5c938
callq 0x2d360
movq %r15, %rdi
callq 0x2d430
movq %rax, %r15
cmpq %r13, %rax
jne 0x5c7cb
movq 0x2566d(%rip), %rbx # 0x81fc0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5c9d6
callq 0x2d360
jmp 0x5c9d6
jmp 0x5c9b1
jmp 0x5c9b6
movq %rax, %rbx
jmp 0x5c9cc
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5c9cc
callq 0x2d360
leaq 0x60(%rsp), %rdi
callq 0x58c60
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TagInfo::all[abi:cxx11]() const
|
std::string all() const {
std::string out;
for( std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
it != itEnd;
++it )
out += "[" + *it + "]";
return out;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x18(%rsi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x5caf4
leaq 0x10(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0xd24d(%rip), %rbp # 0x69c9b
leaq 0x20(%r15), %rdx
movq %r13, %rdi
leaq 0xca50(%rip), %rsi # 0x694ac
callq 0x49917
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2d700
movq %r12, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5ca8d
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x5ca95
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2d100
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5cacc
callq 0x2d360
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5cae0
callq 0x2d360
movq %r15, %rdi
callq 0x2d430
movq %rax, %r15
cmpq %r14, %rax
jne 0x5ca4e
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x5cb35
movq %rax, %r14
jmp 0x5cb21
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5cb21
callq 0x2d360
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5cb35
callq 0x2d360
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x5cb44
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestCaseTracking::TrackerBase::TrackerHasName::operator()(Catch::Ptr<Catch::TestCaseTracking::ITracker> const&)
|
bool operator ()( Ptr<ITracker> const& tracker ) {
return tracker->name() == m_name;
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x20(%rax)
movq 0x8(%r14), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x5d3c8
testq %rdx, %rdx
je 0x5d3cc
movq (%rbx), %rsi
movq 0x8(%rsp), %rdi
callq 0x2d3d0
testl %eax, %eax
sete %bl
jmp 0x5d3ce
xorl %ebx, %ebx
jmp 0x5d3ce
movb $0x1, %bl
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d3e1
callq 0x2d360
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Option<Catch::TestRunInfo>::operator=(Catch::TestRunInfo const&)
|
Option& operator = ( T const& _value ) {
reset();
nullableValue = new( storage ) T( _value );
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x5e0c8
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x5e0c8
callq 0x2d360
movq $0x0, (%rbx)
leaq 0x8(%rbx), %r15
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4042a
movq %r15, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Option<Catch::GroupInfo>::operator=(Catch::GroupInfo const&)
|
Option& operator = ( T const& _value ) {
reset();
nullableValue = new( storage ) T( _value );
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x5e11e
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x5e11e
callq 0x2d360
movq $0x0, (%rbx)
leaq 0x8(%rbx), %r15
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4042a
movups 0x20(%r14), %xmm0
movups %xmm0, 0x28(%rbx)
movq %r15, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Ptr<Catch::CumulativeReporterBase::SectionNode>::operator=(Catch::CumulativeReporterBase::SectionNode*)
|
Ptr& operator = ( T* p ){
Ptr temp( p );
swap( temp );
return *this;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x5e56c
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x5e57d
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Ptr<Catch::CumulativeReporterBase::SectionNode>::operator=(Catch::Ptr<Catch::CumulativeReporterBase::SectionNode> const&)
|
Ptr& operator = ( Ptr const& other ){
Ptr temp( other );
swap( temp );
return *this;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x5e5a8
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x5e5b9
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::SectionStats::SectionStats(Catch::SectionStats const&)
|
SectionStats( SectionStats const& ) = default;
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x21522(%rip), %rax # 0x7fb38
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq 0x8(%rsi), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4042a
leaq 0x28(%r14), %r12
leaq 0x38(%r14), %rbp
movq %rbp, 0x28(%r14)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4042a
leaq 0x48(%r14), %rdi
leaq 0x58(%r14), %rax
movq %rax, 0x48(%r14)
movq 0x48(%r15), %rsi
movq 0x50(%r15), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x68(%r15), %rax
movq %rax, 0x68(%r14)
movups 0x70(%r15), %xmm0
movups 0x80(%r15), %xmm1
movups %xmm0, 0x70(%r14)
movups %xmm1, 0x80(%r14)
movb 0x90(%r15), %al
movb %al, 0x90(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x5e6c8
callq 0x2d360
jmp 0x5e6c8
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x5e6d5
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestCaseStats::TestCaseStats(Catch::TestCaseStats const&)
|
TestCaseStats( TestCaseStats const& ) = default;
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20b98(%rip), %rax # 0x7fb58
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x4420a
movups 0x118(%r15), %xmm0
movups 0x128(%r15), %xmm1
movups 0x138(%r15), %xmm2
movups %xmm2, 0x138(%r14)
movups %xmm1, 0x128(%r14)
movups %xmm0, 0x118(%r14)
leaq 0x148(%r14), %r12
leaq 0x158(%r14), %r13
movq %r13, 0x148(%r14)
movq 0x148(%r15), %rsi
movq 0x150(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4042a
leaq 0x168(%r14), %rdi
leaq 0x178(%r14), %rax
movq %rax, 0x168(%r14)
movq 0x168(%r15), %rsi
movq 0x170(%r15), %rdx
addq %rsi, %rdx
callq 0x4042a
movb 0x188(%r15), %al
movb %al, 0x188(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x5f08a
callq 0x2d360
jmp 0x5f08a
movq %rax, %r14
movq %rbx, %rdi
callq 0x4a020
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::CumulativeReporterBase::Node<Catch::TestGroupStats, Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode>>::~Node()
|
virtual ~Node() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x22683(%rip), %rax # 0x819f0
movq %rax, (%rdi)
addq $0x80, %rdi
callq 0x4a94e
leaq 0x207f5(%rip), %rax # 0x7fb78
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x5f39a
popq %rbx
jmp 0x2d360
popq %rbx
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::CumulativeReporterBase::Node<Catch::TestRunStats, Catch::CumulativeReporterBase::Node<Catch::TestGroupStats, Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode>>>::~Node()
|
virtual ~Node() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x2240b(%rip), %rax # 0x81a38
movq %rax, (%rdi)
addq $0x70, %rdi
callq 0x4a926
leaq 0x20558(%rip), %rax # 0x7fb98
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x5f657
popq %rbx
jmp 0x2d360
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::XmlWriter::startElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
XmlWriter& startElement( std::string const& name ) {
ensureTagClosed();
newlineIfNecessary();
stream() << m_indent << "<" << name;
m_tags.push_back( name );
m_indent += " ";
m_tagIsOpen = true;
return *this;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x5f8d9
movq 0x40(%rbx), %rdi
leaq 0x9c3c(%rip), %rsi # 0x69508
movl $0x2, %edx
callq 0x2d420
movb $0x0, (%rbx)
cmpb $0x1, 0x1(%rbx)
jne 0x5f8f8
movq 0x40(%rbx), %rdi
leaq 0xa8b5(%rip), %rsi # 0x6a19f
movl $0x1, %edx
callq 0x2d420
movb $0x0, 0x1(%rbx)
movq 0x40(%rbx), %rdi
leaq 0x20(%rbx), %r15
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x2d420
movq %rax, %r12
leaq 0xa2a1(%rip), %rsi # 0x69bb8
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x2d420
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x57a4a
leaq 0xa2ee(%rip), %rsi # 0x69c34
movq %r15, %rdi
callq 0x2d700
movb $0x1, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::XmlWriter::writeAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
if( !name.empty() && !attribute.empty() )
stream() << " " << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << "\"";
return *this;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x5fa1c
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x5fa1c
movq %rsi, %r15
movq 0x40(%rbx), %r12
leaq 0x975c(%rip), %rsi # 0x690f1
movl $0x1, %edx
movq %r12, %rdi
callq 0x2d420
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x2d420
movq %rax, %r15
leaq 0xa5db(%rip), %rsi # 0x69f96
movl $0x2, %edx
movq %rax, %rdi
callq 0x2d420
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4042a
movl $0x1, 0x20(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5fa44
leaq 0x967b(%rip), %rsi # 0x6907c
movl $0x1, %edx
movq %r15, %rdi
callq 0x2d420
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5fa1c
callq 0x2d360
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5fa3c
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::XmlEncode::encodeTo(std::ostream&) const
|
void encodeTo( std::ostream& os ) const {
// Apostrophe escaping not necessary if we always use " to write attributes
// (see: http://www.w3.org/TR/xml/#syntax)
for( std::size_t i = 0; i < m_str.size(); ++ i ) {
char c = m_str[i];
switch( c ) {
case '<': os << "<"; break;
case '&': os << "&"; break;
case '>':
// See: http://www.w3.org/TR/xml/#syntax
if( i > 2 && m_str[i-1] == ']' && m_str[i-2] == ']' )
os << ">";
else
os << c;
break;
case '\"':
if( m_forWhat == ForAttributes )
os << """;
else
os << c;
break;
default:
// Escape control chars - based on contribution by @espenalb in PR #465
if ( ( c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c=='\x7F' )
os << "&#x" << std::uppercase << std::hex << static_cast<int>( c );
else
os << c;
}
}
}
|
cmpq $0x0, 0x8(%rdi)
je 0x5fbb3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0xa534(%rip), %r13 # 0x69f9e
leaq 0xa528(%rip), %r12 # 0x69f99
movq (%r14), %rcx
movb (%rcx,%r15), %al
movzbl %al, %edx
cmpl $0x3b, %edx
jg 0x5fa9e
cmpl $0x22, %edx
je 0x5fb1d
cmpl $0x26, %edx
jne 0x5fabc
movl $0x5, %edx
movq %rbx, %rdi
movq %r13, %rsi
jmp 0x5fb93
cmpl $0x3e, %edx
je 0x5fb35
cmpl $0x3c, %edx
jne 0x5fabc
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x5fb93
cmpb $0x9, %al
jl 0x5fad6
leal -0xe(%rax), %ecx
cmpb $0x12, %cl
setae %cl
cmpb $0x7f, %al
setne %dl
testb %cl, %dl
jne 0x5fb82
movsbl %al, %ebp
movl $0x3, %edx
movq %rbx, %rdi
leaq 0xa4c8(%rip), %rsi # 0x69fb0
callq 0x2d420
movq (%rbx), %rax
movq -0x18(%rax), %rax
orl $0x4000, 0x18(%rbx,%rax) # imm = 0x4000
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2d650
jmp 0x5fb98
cmpl $0x1, 0x20(%r14)
jne 0x5fb6f
movl $0x6, %edx
movq %rbx, %rdi
leaq 0xa476(%rip), %rsi # 0x69fa9
jmp 0x5fb93
cmpq $0x3, %r15
jb 0x5fb5c
cmpb $0x5d, -0x1(%rcx,%r15)
jne 0x5fb5c
cmpb $0x5d, -0x2(%rcx,%r15)
jne 0x5fb5c
movl $0x4, %edx
movq %rbx, %rdi
leaq 0xa44a(%rip), %rsi # 0x69fa4
jmp 0x5fb93
movb %al, 0x5(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x5(%rsp), %rsi
jmp 0x5fb93
movb %al, 0x6(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x6(%rsp), %rsi
jmp 0x5fb93
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x7(%rsp), %rsi
callq 0x2d420
incq %r15
cmpq 0x8(%r14), %r15
jb 0x5fa71
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::XmlWriter::writeAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
|
XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\"";
return *this;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rdi), %r15
leaq 0x950b(%rip), %rsi # 0x690f1
movl $0x1, %edx
movq %r15, %rdi
callq 0x2d420
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x2d420
movq %rax, %r14
leaq 0xa38a(%rip), %rsi # 0x69f96
movl $0x2, %edx
movq %rax, %rdi
callq 0x2d420
leaq 0x950a(%rip), %rax # 0x6912a
leaq 0x9534(%rip), %rsi # 0x6915b
testl %ebp, %ebp
cmovneq %rax, %rsi
movl %ebp, %edx
xorq $0x5, %rdx
movq %r14, %rdi
callq 0x2d420
leaq 0x943a(%rip), %rsi # 0x6907c
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<unsigned long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long const&)
|
XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
std::ostringstream oss;
oss << attribute;
return writeAttribute( name, oss.str() );
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2d4b0
movq (%r15), %rsi
movq %r12, %rdi
callq 0x2d270
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x2d5a0
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f960
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5fcbe
callq 0x2d360
movq 0x222eb(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5fd0b
callq 0x2d360
jmp 0x5fd0b
jmp 0x5fd08
movq %rax, %rbx
movq 0x2229e(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::XmlWriter::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
|
XmlWriter& writeText( std::string const& text, bool indent = true ) {
if( !text.empty() ){
bool tagWasOpen = m_tagIsOpen;
ensureTagClosed();
if( tagWasOpen && indent )
stream() << m_indent;
stream() << XmlEncode( text );
m_needsNewline = true;
}
return *this;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x5fdd7
movl %edx, %ebp
movq %rsi, %r14
movb (%rbx), %r15b
cmpb $0x1, %r15b
jne 0x5fd72
movq 0x40(%rbx), %rdi
leaq 0x97a3(%rip), %rsi # 0x69508
movl $0x2, %edx
callq 0x2d420
movb $0x0, (%rbx)
andb %bpl, %r15b
cmpb $0x1, %r15b
jne 0x5fd8c
movq 0x40(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x2d420
movq 0x40(%rbx), %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4042a
movl $0x0, 0x20(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5fa44
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5fdd3
callq 0x2d360
movb $0x1, 0x1(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5fdf9
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::JunitReporter::writeGroup(Catch::CumulativeReporterBase::Node<Catch::TestGroupStats, Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode>> const&, double)
|
void writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
TestGroupStats const& stats = groupNode.value;
xml.writeAttribute( "name", stats.groupInfo.name );
xml.writeAttribute( "errors", unexpectedExceptions );
xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
xml.writeAttribute( "tests", stats.totals.assertions.total() );
xml.writeAttribute( "hostname", "tbd" ); // !TBD
if( m_config->showDurations() == ShowDurations::Never )
xml.writeAttribute( "time", "" );
else
xml.writeAttribute( "time", suiteTime );
xml.writeAttribute( "timestamp", "tbd" ); // !TBD
// Write test cases
for( TestGroupNode::ChildNodes::const_iterator
it = groupNode.children.begin(), itEnd = groupNode.children.end();
it != itEnd;
++it )
writeTestCase( **it );
xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false );
xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false );
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movsd %xmm0, 0x78(%rsp)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xa177(%rip), %rsi # 0x6a07b
leaq 0xa179(%rip), %rdx # 0x6a084
leaq 0x8(%rsp), %rdi
callq 0x3ef3e
leaq 0xc8(%rbx), %r14
movq %r14, 0x30(%rsp)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5f8ae
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5ff3d
callq 0x2d360
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x977b(%rip), %rsi # 0x696c7
leaq 0x9778(%rip), %rdx # 0x696cb
callq 0x3ef3e
leaq 0x18(%r15), %rdx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5f960
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5ff78
callq 0x2d360
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0xa0fe(%rip), %rsi # 0x6a085
leaq 0xa0fd(%rip), %rdx # 0x6a08b
callq 0x3ef3e
leaq 0x408(%rbx), %r12
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x6039e
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5ffb9
callq 0x2d360
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x974d(%rip), %rsi # 0x69715
leaq 0x974e(%rip), %rdx # 0x6971d
callq 0x3ef3e
movq 0x50(%r15), %rax
movl (%r12), %ecx
subq %rcx, %rax
leaq 0x38(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5fc5e
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x60003
callq 0x2d360
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x9621(%rip), %rsi # 0x69633
leaq 0x961f(%rip), %rdx # 0x69638
callq 0x3ef3e
movq 0x50(%r15), %rax
addq 0x48(%r15), %rax
addq 0x58(%r15), %rax
leaq 0x38(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5fc5e
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6004e
callq 0x2d360
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0xa02f(%rip), %rsi # 0x6a08c
leaq 0xa030(%rip), %rdx # 0x6a094
callq 0x3ef3e
leaq 0xa025(%rip), %rdx # 0x6a095
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x60472
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6008c
callq 0x2d360
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
leaq 0x8(%rsp), %rdi
cmpl $0x2, %eax
jne 0x600cc
movq %r13, (%rdi)
leaq 0x9a39(%rip), %rsi # 0x69ae3
leaq 0x9a36(%rip), %rdx # 0x69ae7
callq 0x3ef3e
leaq 0xa0e3(%rip), %rdx # 0x6a1a0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x60550
jmp 0x600f4
movq %r13, (%rdi)
leaq 0x9a0d(%rip), %rsi # 0x69ae3
leaq 0x9a0a(%rip), %rdx # 0x69ae7
callq 0x3ef3e
leaq 0x8(%rsp), %rsi
leaq 0x78(%rsp), %rdx
movq %r14, %rdi
callq 0x5fe02
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x60103
callq 0x2d360
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x9f87(%rip), %rsi # 0x6a099
leaq 0x9f89(%rip), %rdx # 0x6a0a2
callq 0x3ef3e
leaq 0x9f70(%rip), %rdx # 0x6a095
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x60472
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x60141
callq 0x2d360
movq 0x80(%r15), %r12
movq 0x88(%r15), %r15
cmpq %r15, %r12
je 0x60166
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x6062e
addq $0x8, %r12
jmp 0x6014f
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x9f2e(%rip), %rsi # 0x6a0a3
leaq 0x9f31(%rip), %rdx # 0x6a0ad
callq 0x3ef3e
movq %r14, 0x28(%rsp)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5f8ae
leaq 0x120(%rbx), %rsi
leaq 0x58(%rsp), %rdi
callq 0x2d5a0
leaq 0x38(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x45105
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
xorl %edx, %edx
callq 0x5fd32
leaq 0x48(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x601d8
callq 0x2d360
leaq 0x68(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x601eb
callq 0x2d360
leaq 0x28(%rsp), %rdi
callq 0x5fbb4
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x60204
callq 0x2d360
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x9e9b(%rip), %rsi # 0x6a0ae
leaq 0x9e9e(%rip), %rdx # 0x6a0b8
callq 0x3ef3e
movq %r14, 0x28(%rsp)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5f8ae
addq $0x298, %rbx # imm = 0x298
leaq 0x58(%rsp), %rdi
movq %rbx, %rsi
callq 0x2d5a0
leaq 0x38(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x45105
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
xorl %edx, %edx
callq 0x5fd32
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x60274
callq 0x2d360
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x60283
callq 0x2d360
leaq 0x28(%rsp), %rdi
callq 0x5fbb4
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6029c
callq 0x2d360
leaq 0x30(%rsp), %rdi
callq 0x5fbb4
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x60350
jmp 0x60350
jmp 0x60389
jmp 0x60389
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x602e2
callq 0x2d360
jmp 0x602e2
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
jne 0x60320
jmp 0x6032c
jmp 0x60329
jmp 0x60329
jmp 0x60389
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60312
callq 0x2d360
jmp 0x60312
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6032c
callq 0x2d360
jmp 0x6032c
jmp 0x60329
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5fbb4
jmp 0x60353
jmp 0x60389
jmp 0x60350
jmp 0x60389
jmp 0x60389
jmp 0x60350
jmp 0x60389
jmp 0x60350
jmp 0x60389
jmp 0x60350
jmp 0x60389
jmp 0x60350
jmp 0x60389
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6038c
callq 0x2d360
jmp 0x6038c
jmp 0x60389
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5fbb4
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x60396
callq 0x2d360
jmp 0x60396
movq %rax, %rbx
jmp 0x60396
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5fbb4
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<unsigned int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int const&)
|
XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
std::ostringstream oss;
oss << attribute;
return writeAttribute( name, oss.str() );
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2d4b0
movl (%r15), %esi
movq %r12, %rdi
callq 0x2d270
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x2d5a0
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f960
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x603fe
callq 0x2d360
movq 0x21bab(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6044b
callq 0x2d360
jmp 0x6044b
jmp 0x60448
movq %rax, %rbx
movq 0x21b5e(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<char [4]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [4])
|
XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
std::ostringstream oss;
oss << attribute;
return writeAttribute( name, oss.str() );
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2d4b0
movq %r15, %rdi
callq 0x2d180
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2d420
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x2d5a0
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f960
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x604dd
callq 0x2d360
movq 0x21acc(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6052a
callq 0x2d360
jmp 0x6052a
jmp 0x60527
movq %rax, %rbx
movq 0x21a7f(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::JunitReporter::writeSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CumulativeReporterBase::SectionNode const&)
|
void writeSection( std::string const& className,
std::string const& rootName,
SectionNode const& sectionNode ) {
std::string name = trim( sectionNode.stats.sectionInfo.name );
if( !rootName.empty() )
name = rootName + "/" + name;
if( !sectionNode.assertions.empty() ||
!sectionNode.stdOut.empty() ||
!sectionNode.stdErr.empty() ) {
XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
if( className.empty() ) {
xml.writeAttribute( "classname", name );
xml.writeAttribute( "name", "root" );
}
else {
xml.writeAttribute( "classname", className );
xml.writeAttribute( "name", name );
}
xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) );
writeAssertions( sectionNode );
if( !sectionNode.stdOut.empty() )
xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
if( !sectionNode.stdErr.empty() )
xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
}
for( SectionNode::ChildSections::const_iterator
it = sectionNode.childSections.begin(),
itEnd = sectionNode.childSections.end();
it != itEnd;
++it )
if( className.empty() )
writeSection( name, "", **it );
else
writeSection( className, name, **it );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x30(%rsp)
movq %rdi, 0x38(%rsp)
leaq 0x18(%rcx), %rsi
leaq 0x68(%rsp), %rdi
callq 0x45105
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0x6084c
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
addq %rsi, %rdx
leaq 0x40(%rsp), %rdi
callq 0x4042a
leaq 0x8932(%rip), %rsi # 0x690ec
leaq 0x40(%rsp), %rdi
callq 0x2d700
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x2d100
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x607ff
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x60805
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %r12
movq %rdx, 0x8(%r12)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x68(%rsp), %rdi
movq %r12, %rsi
callq 0x2d480
movq (%r12), %rdi
cmpq %rbx, %rdi
je 0x6083d
callq 0x2d360
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x6084c
callq 0x2d360
movq 0xc0(%r15), %rax
cmpq 0xc8(%r15), %rax
jne 0x60874
cmpq $0x0, 0xe0(%r15)
jne 0x60874
cmpq $0x0, 0x100(%r15)
je 0x60b4f
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x989d(%rip), %rsi # 0x6a121
leaq 0x989e(%rip), %rdx # 0x6a129
leaq 0x8(%rsp), %rdi
callq 0x3ef3e
movq 0x38(%rsp), %rax
leaq 0xc8(%rax), %r12
movq %r12, 0x60(%rsp)
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x5f8ae
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x608c2
callq 0x2d360
movq 0x30(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x60939
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x984d(%rip), %rsi # 0x6a12a
leaq 0x984f(%rip), %rdx # 0x6a133
callq 0x3ef3e
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movq 0x30(%rsp), %rdx
callq 0x5f960
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x6090a
callq 0x2d360
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x8dae(%rip), %rsi # 0x696c7
leaq 0x8dab(%rip), %rdx # 0x696cb
callq 0x3ef3e
leaq 0x8(%rsp), %rsi
leaq 0x68(%rsp), %rdx
movq %r12, %rdi
callq 0x5f960
jmp 0x609a4
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x97e2(%rip), %rsi # 0x6a12a
leaq 0x97e4(%rip), %rdx # 0x6a133
callq 0x3ef3e
leaq 0x8(%rsp), %rsi
leaq 0x68(%rsp), %rdx
movq %r12, %rdi
callq 0x5f960
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x60975
callq 0x2d360
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x8d43(%rip), %rsi # 0x696c7
leaq 0x8d40(%rip), %rdx # 0x696cb
callq 0x3ef3e
leaq 0x979d(%rip), %rdx # 0x6a134
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x60cde
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x609b3
callq 0x2d360
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x9121(%rip), %rsi # 0x69ae3
leaq 0x911e(%rip), %rdx # 0x69ae7
callq 0x3ef3e
movsd 0x98(%r15), %xmm0
leaq 0x40(%rsp), %rdi
movl $0xa, %esi
callq 0x4a265
leaq 0x8(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %r12, %rdi
callq 0x5f960
leaq 0x50(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x60a0b
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x60a1a
callq 0x2d360
movq 0xc0(%r15), %r13
movq 0xc8(%r15), %rbx
cmpq %rbx, %r13
je 0x60a43
movq 0x38(%rsp), %rdi
movq %r13, %rsi
callq 0x60dbc
addq $0x108, %r13 # imm = 0x108
jmp 0x60a28
cmpq $0x0, 0xe0(%r15)
je 0x60ac4
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x9647(%rip), %rsi # 0x6a0a3
leaq 0x964a(%rip), %rdx # 0x6a0ad
callq 0x3ef3e
movq %r12, 0x28(%rsp)
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x5f8ae
leaq 0xd8(%r15), %rsi
leaq 0x40(%rsp), %rdi
callq 0x45105
movq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
xorl %edx, %edx
callq 0x5fd32
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x60aab
callq 0x2d360
leaq 0x28(%rsp), %rdi
callq 0x5fbb4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x60ac4
callq 0x2d360
cmpq $0x0, 0x100(%r15)
je 0x60b45
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x95d1(%rip), %rsi # 0x6a0ae
leaq 0x95d4(%rip), %rdx # 0x6a0b8
callq 0x3ef3e
movq %r12, 0x28(%rsp)
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x5f8ae
leaq 0xf8(%r15), %rsi
leaq 0x40(%rsp), %rdi
callq 0x45105
movq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
xorl %edx, %edx
callq 0x5fd32
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x60b2c
callq 0x2d360
leaq 0x28(%rsp), %rdi
callq 0x5fbb4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x60b45
callq 0x2d360
leaq 0x60(%rsp), %rdi
callq 0x5fbb4
movq 0xa8(%r15), %rbp
movq 0xb0(%r15), %rbx
cmpq %rbx, %rbp
movq 0x30(%rsp), %rsi
je 0x60bdb
leaq 0x18(%rsp), %r14
leaq 0x962d(%rip), %r15 # 0x6a1a0
leaq 0x8(%rsp), %r12
leaq 0x68(%rsp), %r13
cmpq $0x0, 0x8(%rsi)
je 0x60b97
movq (%rbp), %rcx
movq 0x38(%rsp), %rdi
movq %r13, %rdx
callq 0x6075c
jmp 0x60bcd
movq %r14, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x3ef3e
movq (%rbp), %rcx
movq 0x38(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6075c
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x60bcd
callq 0x2d360
addq $0x8, %rbp
cmpq %rbx, %rbp
movq 0x30(%rsp), %rsi
jne 0x60b7d
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60bee
callq 0x2d360
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x60c60
jmp 0x60cb0
jmp 0x60c60
jmp 0x60cb0
jmp 0x60c14
jmp 0x60c2f
jmp 0x60c2f
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x60c32
callq 0x2d360
jmp 0x60c32
jmp 0x60cb0
jmp 0x60c2f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5fbb4
jmp 0x60c63
jmp 0x60cb0
jmp 0x60c60
jmp 0x60cb0
jmp 0x60c60
jmp 0x60cb0
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60c63
callq 0x2d360
jmp 0x60c63
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x60cb3
callq 0x2d360
jmp 0x60cb3
jmp 0x60cb0
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x5fbb4
jmp 0x60c9f
jmp 0x60cbf
jmp 0x60c89
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
jne 0x60ca9
jmp 0x60cc2
jmp 0x60cbf
jmp 0x60cbf
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x60cc2
callq 0x2d360
jmp 0x60cc2
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x5fbb4
jmp 0x60cc2
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60cd5
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<char [5]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [5])
|
XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
std::ostringstream oss;
oss << attribute;
return writeAttribute( name, oss.str() );
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2d4b0
movq %r15, %rdi
callq 0x2d180
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2d420
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x2d5a0
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f960
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60d49
callq 0x2d360
movq 0x21260(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60d96
callq 0x2d360
jmp 0x60d96
jmp 0x60d93
movq %rax, %rbx
movq 0x21213(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::JunitReporter::writeAssertion(Catch::AssertionStats const&)
|
bool AssertionResult::isOk() const {
return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movl 0xb8(%rsi), %eax
testb $0x10, %al
je 0x610fc
movq %rsi, %r14
movl 0x70(%rsi), %ecx
andl $0x8, %ecx
jne 0x610fc
movq %rdi, %rbx
leaq 0x40(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
movl $0x7, %r8d
leaq 0x8801(%rip), %rcx # 0x6960f
cmpl $0x10f, %eax # imm = 0x10F
jg 0x60e35
incl %eax
cmpl $0x13, %eax
ja 0x60e81
movl $0x2000f, %edx # imm = 0x2000F
btl %eax, %edx
jae 0x60e69
movl $0xd, %r8d
leaq 0x930c(%rip), %rcx # 0x6a13f
jmp 0x60e73
cmpl $0x111, %eax # imm = 0x111
jg 0x60e4c
cmpl $0x110, %eax # imm = 0x110
je 0x60e26
cmpl $0x111, %eax # imm = 0x111
je 0x60e5a
jmp 0x60e81
cmpl $0x112, %eax # imm = 0x112
je 0x60e73
cmpl $0x210, %eax # imm = 0x210
jne 0x60e81
movl $0x5, %r8d
leaq 0x92d2(%rip), %rcx # 0x6a139
jmp 0x60e73
movl $0xc0000, %edx # imm = 0xC0000
btl %eax, %edx
jae 0x60e81
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d580
addq $0xc8, %rbx
movq %rbx, 0x28(%rsp)
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x5f8ae
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9396(%rip), %rsi # 0x6a240
leaq 0x9396(%rip), %rdx # 0x6a247
leaq 0x50(%rsp), %rdi
callq 0x3ef3e
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x78(%r14), %rsi
movq 0x80(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x4042a
leaq 0x50(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x5f960
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x60ef9
callq 0x2d360
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x60f08
callq 0x2d360
leaq 0x50(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x8aed(%rip), %rsi # 0x69a04
leaq 0x8aea(%rip), %rdx # 0x69a08
callq 0x3ef3e
movq %rsp, %rdi
movq %r12, (%rdi)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x50(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x5f960
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x60f57
callq 0x2d360
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x60f66
callq 0x2d360
leaq 0x50(%rsp), %rdi
callq 0x2d4b0
movq %rsp, %rdi
movq %r12, (%rdi)
movq 0x98(%r14), %rsi
movq 0xa0(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
movq (%rsp), %rdi
movq 0x8(%rsp), %r15
cmpq %r12, %rdi
je 0x60f9f
callq 0x2d360
testq %r15, %r15
je 0x60ff5
movq %rsp, %rdi
movq %r12, (%rdi)
movq 0x98(%r14), %rsi
movq 0xa0(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x2d420
leaq 0x91c5(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x60ff5
callq 0x2d360
movq 0xc0(%r14), %r13
movq 0xc8(%r14), %rbp
cmpq %rbp, %r13
je 0x61044
leaq 0x50(%rsp), %r15
leaq 0x918b(%rip), %r12 # 0x6a19f
cmpl $0x1, 0x48(%r13)
jne 0x6103b
movq 0x50(%r13), %rsi
movq 0x58(%r13), %rdx
movq %r15, %rdi
callq 0x2d420
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2d420
addq $0x78, %r13
cmpq %rbp, %r13
jne 0x61014
leaq 0x8064(%rip), %rsi # 0x690af
leaq 0x50(%rsp), %rdi
movl $0x3, %edx
callq 0x2d420
movq %rsp, %rdi
leaq 0x10(%rsp), %r15
movq %r15, (%rdi)
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x48(%r14), %rax
movq %rsp, %rsi
movq %rax, 0x20(%rsi)
leaq 0x50(%rsp), %rdi
callq 0x42ab1
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x61098
callq 0x2d360
leaq 0x58(%rsp), %rsi
movq %rsp, %rdi
callq 0x2d5a0
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5fd32
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x610c0
callq 0x2d360
movq 0x20ee9(%rip), %rsi # 0x81fb0
leaq 0x50(%rsp), %rdi
callq 0x2d1d0
leaq 0xc0(%rsp), %rdi
callq 0x2d110
leaq 0x28(%rsp), %rdi
callq 0x5fbb4
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x610fc
callq 0x2d360
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x61179
movq %rax, %rbx
jmp 0x611a4
jmp 0x6111c
jmp 0x61179
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x61172
jmp 0x6117c
jmp 0x61179
jmp 0x61179
jmp 0x61179
jmp 0x61161
jmp 0x61138
jmp 0x6114b
jmp 0x61161
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6114e
callq 0x2d360
jmp 0x6114e
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x6119a
callq 0x2d360
jmp 0x6119a
jmp 0x61161
movq %rax, %rbx
jmp 0x6119a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6117c
callq 0x2d360
jmp 0x6117c
movq %rax, %rbx
movq 0x20e2d(%rip), %rsi # 0x81fb0
leaq 0x50(%rsp), %rdi
callq 0x2d1d0
leaq 0xc0(%rsp), %rdi
callq 0x2d110
leaq 0x28(%rsp), %rdi
callq 0x5fbb4
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x611b8
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::lazyPrint()
|
void lazyPrint() {
if( !currentTestRunInfo.used )
lazyPrintRunInfo();
if( !currentGroupInfo.used )
lazyPrintGroupInfo();
if( !m_headerPrinted ) {
printTestCaseAndSectionHeader();
m_headerPrinted = true;
}
}
|
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x48(%rdi)
jne 0x611d2
movq %rbx, %rdi
callq 0x6170c
cmpb $0x0, 0x88(%rbx)
jne 0x611e3
movq %rbx, %rdi
callq 0x6188c
cmpb $0x0, 0x1c9(%rbx)
jne 0x611fb
movq %rbx, %rdi
callq 0x61908
movb $0x1, 0x1c9(%rbx)
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::AssertionPrinter::AssertionPrinter(std::ostream&, Catch::AssertionStats const&, bool)
|
AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
: stream( _stream ),
stats( _stats ),
result( _stats.assertionResult ),
colour( Colour::None ),
message( result.getMessage() ),
messages( _stats.infoMessages ),
printInfoMessages( _printInfoMessages )
{
switch( result.getResultType() ) {
case ResultWas::Ok:
colour = Colour::Success;
passOrFail = "PASSED";
//if( result.hasMessage() )
if( _stats.infoMessages.size() == 1 )
messageLabel = "with message";
if( _stats.infoMessages.size() > 1 )
messageLabel = "with messages";
break;
case ResultWas::ExpressionFailed:
if( result.isOk() ) {
colour = Colour::Success;
passOrFail = "FAILED - but was ok";
}
else {
colour = Colour::Error;
passOrFail = "FAILED";
}
if( _stats.infoMessages.size() == 1 )
messageLabel = "with message";
if( _stats.infoMessages.size() > 1 )
messageLabel = "with messages";
break;
case ResultWas::ThrewException:
colour = Colour::Error;
passOrFail = "FAILED";
messageLabel = "due to unexpected exception with message";
break;
case ResultWas::FatalErrorCondition:
colour = Colour::Error;
passOrFail = "FAILED";
messageLabel = "due to a fatal error condition";
break;
case ResultWas::DidntThrowException:
colour = Colour::Error;
passOrFail = "FAILED";
messageLabel = "because no exception was thrown where one was expected";
break;
case ResultWas::Info:
messageLabel = "info";
break;
case ResultWas::Warning:
messageLabel = "warning";
break;
case ResultWas::ExplicitFailure:
passOrFail = "FAILED";
colour = Colour::Error;
if( _stats.infoMessages.size() == 1 )
messageLabel = "explicitly with message";
if( _stats.infoMessages.size() > 1 )
messageLabel = "explicitly with messages";
break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
passOrFail = "** internal error **";
colour = Colour::Error;
break;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movq %rdx, %rbp
movq %rdi, %r12
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x8(%rdx), %rax
movq %rax, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x20(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x18(%rsp)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r15
leaq 0x70(%rdi), %rbx
movq %rbx, 0x60(%rdi)
movq 0x98(%rdx), %rsi
movq 0xa0(%rdx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4042a
leaq 0x80(%r12), %r13
leaq 0xc0(%rbp), %rsi
movq %r13, %rdi
callq 0x4f83a
movb %r14b, 0x98(%r12)
movq 0x10(%r12), %rcx
movl 0xb0(%rcx), %eax
cmpl $0x11, %eax
jg 0x61339
leal 0x1(%rax), %edx
cmpl $0x3, %edx
ja 0x6139e
leaq 0x7c46(%rip), %rax # 0x68f14
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x3, 0x18(%r12)
movq 0x28(%r12), %rdx
leaq 0x8f11(%rip), %rcx # 0x6a1fd
movl $0x6, %r8d
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2d580
movq 0xc8(%rbp), %rax
subq 0xc0(%rbp), %rax
cmpq $0x78, %rax
jne 0x61436
movq 0x48(%r12), %rdx
leaq 0x8f19(%rip), %rcx # 0x6a23b
movl $0xc, %r8d
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x2d580
jmp 0x61436
cmpl $0x110, %eax # imm = 0x110
jle 0x61472
cmpl $0x111, %eax # imm = 0x111
je 0x61579
cmpl $0x112, %eax # imm = 0x112
je 0x61543
cmpl $0x210, %eax # imm = 0x210
jne 0x615dc
movl $0x12, 0x18(%r12)
movq 0x28(%r12), %rdx
leaq 0x8e9e(%rip), %rcx # 0x6a218
movl $0x6, %r8d
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2d580
movl $0x1e, %r8d
leaq 0x8eaf(%rip), %rcx # 0x6a248
jmp 0x615cb
cmpl $0x10, %eax
je 0x61482
cmpl $0x11, %eax
jne 0x615dc
testb $0x10, %al
sete %al
movl 0x68(%rcx), %ecx
andl $0x8, %ecx
shrl $0x3, %ecx
orb %al, %cl
movl $0x3, %eax
movl $0x12, %edx
cmovnel %eax, %edx
leaq 0x8e30(%rip), %rax # 0x6a204
leaq 0x8e3d(%rip), %rcx # 0x6a218
cmovneq %rax, %rcx
movl $0x13, %eax
movl $0x6, %r8d
cmovneq %rax, %r8
movl %edx, 0x18(%r12)
movq 0x28(%r12), %rdx
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2d580
movq 0xc8(%rbp), %rax
subq 0xc0(%rbp), %rax
cmpq $0x78, %rax
jne 0x61436
movq 0x48(%r12), %rdx
leaq 0x8e17(%rip), %rcx # 0x6a23b
movl $0xc, %r8d
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x2d580
movq 0xc8(%rbp), %rax
subq 0xc0(%rbp), %rax
sarq $0x3, %rax
movabsq $-0x1111111111111111, %rcx # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %rcx
cmpq $0x1, %rcx
jbe 0x615dc
movl $0xd, %r8d
leaq 0x8e61(%rip), %rcx # 0x6a2ce
jmp 0x615cb
cmpl $0x12, %eax
je 0x614ae
cmpl $0x110, %eax # imm = 0x110
jne 0x615dc
movq 0x28(%r12), %rdx
leaq 0x8e4e(%rip), %rcx # 0x6a2dc
movl $0x14, %r8d
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2d580
movl $0x12, 0x18(%r12)
jmp 0x615dc
movq 0x28(%r12), %rdx
leaq 0x8d5e(%rip), %rcx # 0x6a218
movl $0x6, %r8d
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2d580
movl $0x12, 0x18(%r12)
movq 0xc8(%rbp), %rax
subq 0xc0(%rbp), %rax
cmpq $0x78, %rax
jne 0x61507
movq 0x48(%r12), %rdx
leaq 0x8db6(%rip), %rcx # 0x6a2ab
movl $0x17, %r8d
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x2d580
movq 0xc8(%rbp), %rax
subq 0xc0(%rbp), %rax
sarq $0x3, %rax
movabsq $-0x1111111111111111, %rcx # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %rcx
cmpq $0x2, %rcx
jb 0x615dc
movl $0x18, %r8d
leaq 0x8d85(%rip), %rcx # 0x6a2c3
jmp 0x615cb
movl $0x12, 0x18(%r12)
movq 0x28(%r12), %rdx
leaq 0x8cc0(%rip), %rcx # 0x6a218
movl $0x6, %r8d
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2d580
movl $0x36, %r8d
leaq 0x8cf0(%rip), %rcx # 0x6a267
jmp 0x615cb
movl $0x12, 0x18(%r12)
movq 0x28(%r12), %rdx
leaq 0x8c8a(%rip), %rcx # 0x6a218
movl $0x6, %r8d
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2d580
movl $0x28, %r8d
leaq 0x8c72(%rip), %rcx # 0x6a21f
jmp 0x615cb
movl $0x4, %r8d
leaq 0x8ce2(%rip), %rcx # 0x6a29e
jmp 0x615cb
movl $0x7, %r8d
leaq 0x8cd8(%rip), %rcx # 0x6a2a3
movq 0x48(%r12), %rdx
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x2d580
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x61600
movq %rax, %r12
jmp 0x6160d
movq %rax, %r12
movq %r13, %rdi
callq 0x4a870
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0x6160d
callq 0x2d360
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq 0x18(%rsp), %rdi
je 0x61621
callq 0x2d360
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq 0x20(%rsp), %rdi
je 0x61635
callq 0x2d360
movq %r12, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::AssertionPrinter::print() const
|
void print() const {
printSourceInfo();
if( stats.totals.assertions.total() > 0 ) {
if( result.isOk() )
stream << "\n";
printResultType();
printOriginalExpression();
printReconstructedExpression();
}
else {
stream << "\n";
}
printMessage();
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x61de6
movq 0x8(%rbx), %rax
movq 0xe0(%rax), %rcx
addq 0xd8(%rax), %rcx
addq 0xe8(%rax), %rcx
jne 0x61678
movq (%rbx), %rdi
leaq 0x8b33(%rip), %rsi # 0x6a19f
movl $0x1, %edx
callq 0x2d420
jmp 0x616b9
movq 0x10(%rbx), %rax
testb $0x10, 0xb0(%rax)
je 0x6168d
movl 0x68(%rax), %eax
andl $0x8, %eax
je 0x616a1
movq (%rbx), %rdi
leaq 0x8b08(%rip), %rsi # 0x6a19f
movl $0x1, %edx
callq 0x2d420
movq %rbx, %rdi
callq 0x61ea0
movq %rbx, %rdi
callq 0x61f0a
movq %rbx, %rdi
callq 0x61fd2
movq %rbx, %rdi
popq %rbx
jmp 0x62154
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::AssertionPrinter::~AssertionPrinter()
|
AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
: stream( _stream ),
stats( _stats ),
result( _stats.assertionResult ),
colour( Colour::None ),
message( result.getMessage() ),
messages( _stats.infoMessages ),
printInfoMessages( _printInfoMessages )
{
switch( result.getResultType() ) {
case ResultWas::Ok:
colour = Colour::Success;
passOrFail = "PASSED";
//if( result.hasMessage() )
if( _stats.infoMessages.size() == 1 )
messageLabel = "with message";
if( _stats.infoMessages.size() > 1 )
messageLabel = "with messages";
break;
case ResultWas::ExpressionFailed:
if( result.isOk() ) {
colour = Colour::Success;
passOrFail = "FAILED - but was ok";
}
else {
colour = Colour::Error;
passOrFail = "FAILED";
}
if( _stats.infoMessages.size() == 1 )
messageLabel = "with message";
if( _stats.infoMessages.size() > 1 )
messageLabel = "with messages";
break;
case ResultWas::ThrewException:
colour = Colour::Error;
passOrFail = "FAILED";
messageLabel = "due to unexpected exception with message";
break;
case ResultWas::FatalErrorCondition:
colour = Colour::Error;
passOrFail = "FAILED";
messageLabel = "due to a fatal error condition";
break;
case ResultWas::DidntThrowException:
colour = Colour::Error;
passOrFail = "FAILED";
messageLabel = "because no exception was thrown where one was expected";
break;
case ResultWas::Info:
messageLabel = "info";
break;
case ResultWas::Warning:
messageLabel = "warning";
break;
case ResultWas::ExplicitFailure:
passOrFail = "FAILED";
colour = Colour::Error;
if( _stats.infoMessages.size() == 1 )
messageLabel = "explicitly with message";
if( _stats.infoMessages.size() > 1 )
messageLabel = "explicitly with messages";
break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
passOrFail = "** internal error **";
colour = Colour::Error;
break;
}
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x80, %rdi
callq 0x4a870
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x616e4
callq 0x2d360
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x616f6
callq 0x2d360
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x61709
popq %rbx
jmp 0x2d360
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::lazyPrintRunInfo()
|
void lazyPrintRunInfo() {
stream << "\n" << getLineOfChars<'~'>() << "\n";
Colour colour( Colour::SecondaryText );
stream << currentTestRunInfo->name
<< " is a Catch v" << libraryVersion << " host application.\n"
<< "Run with -? for options\n\n";
if( m_config->rngSeed() != 0 )
stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
currentTestRunInfo.used = true;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x8a7c(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
cmpb $0x0, 0x20e19(%rip) # 0x82550
jne 0x6176a
movaps 0x7050(%rip), %xmm0 # 0x68790
movups %xmm0, 0x20e48(%rip) # 0x8258f
movaps %xmm0, 0x20e32(%rip) # 0x82580
movaps %xmm0, 0x20e1b(%rip) # 0x82570
movaps %xmm0, 0x20e04(%rip) # 0x82560
movaps %xmm0, 0x20ded(%rip) # 0x82550
movb $0x0, 0x20e35(%rip) # 0x8259f
leaq 0x20ddf(%rip), %r15 # 0x82550
movq %r15, %rdi
callq 0x2d180
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2d420
leaq 0x8a11(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
movb $0x0, 0xf(%rsp)
movl $0x17, %edi
callq 0x437d0
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x2d420
movq %rax, %r14
leaq 0x899d(%rip), %rsi # 0x6a165
movl $0xd, %edx
movq %rax, %rdi
callq 0x2d420
leaq 0x20cb4(%rip), %rsi # 0x82490
movq %r14, %rdi
callq 0x446e7
leaq 0x8988(%rip), %rsi # 0x6a173
movl $0x13, %edx
movq %r14, %rdi
callq 0x2d420
leaq 0x8988(%rip), %rsi # 0x6a187
movl $0x19, %edx
movq %r14, %rdi
callq 0x2d420
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testl %eax, %eax
je 0x6185a
movq 0x18(%rbx), %r14
leaq 0x897c(%rip), %rsi # 0x6a1a1
movl $0x16, %edx
movq %r14, %rdi
callq 0x2d420
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movl %eax, %esi
movq %r14, %rdi
callq 0x2d270
leaq 0x8951(%rip), %rsi # 0x6a19e
movl $0x2, %edx
movq %rax, %rdi
callq 0x2d420
movb $0x1, 0x48(%rbx)
xorl %edi, %edi
callq 0x437d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x4383a
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::lazyPrintGroupInfo()
|
T* operator->() { return nullableValue; }
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x50(%rdi), %rdx
cmpq $0x0, 0x8(%rdx)
je 0x618e1
cmpq $0x2, 0x28(%rdx)
jb 0x618e1
movq %rdi, %rbx
leaq 0x8909(%rip), %rsi # 0x6a1b8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x49917
movq %rbx, %rdi
movq %r14, %rsi
callq 0x61b9a
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x618da
callq 0x2d360
movb $0x1, 0x88(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x618ff
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::printTestCaseAndSectionHeader()
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x1b0(%rdi), %rax
cmpq 0x1b8(%rdi), %rax
je 0x61b36
movq %rdi, %rbx
movq 0x90(%rdi), %rsi
callq 0x61c1c
movq 0x1b8(%rbx), %rax
subq 0x1b0(%rbx), %rax
sarq $0x3, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %rcx # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %rcx
cmpq $0x2, %rcx
jb 0x6199f
movb $0x0, 0x10(%rsp)
movl $0x1, %edi
callq 0x437d0
movq 0x1b0(%rbx), %rsi
movq 0x1b8(%rbx), %r14
addq $0x68, %rsi
cmpq %r14, %rsi
je 0x61998
leaq 0x68(%rsi), %r15
movl $0x2, %edx
movq %rbx, %rdi
callq 0x61ce6
movq %r15, %rsi
jmp 0x6197d
xorl %edi, %edi
callq 0x437d0
movq 0x1b0(%rbx), %r15
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x4042a
movq 0x60(%r15), %rax
movq %rax, 0x20(%r14)
cmpq $0x0, 0x8(%r14)
je 0x61a85
movq 0x18(%rbx), %r14
cmpb $0x0, 0x20bba(%rip) # 0x825a0
jne 0x61a19
movaps 0x6db1(%rip), %xmm0 # 0x687a0
movups %xmm0, 0x20be9(%rip) # 0x825df
movaps %xmm0, 0x20bd3(%rip) # 0x825d0
movaps %xmm0, 0x20bbc(%rip) # 0x825c0
movaps %xmm0, 0x20ba5(%rip) # 0x825b0
movaps %xmm0, 0x20b8e(%rip) # 0x825a0
movb $0x0, 0x20bd6(%rip) # 0x825ef
leaq 0x20b80(%rip), %r15 # 0x825a0
movq %r15, %rdi
callq 0x2d180
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2d420
leaq 0x8762(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
movb $0x0, 0xf(%rsp)
movl $0x17, %edi
callq 0x437d0
movq 0x18(%rbx), %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x42ab1
leaq 0x872e(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
xorl %edi, %edi
callq 0x437d0
movq 0x18(%rbx), %rbx
cmpb $0x0, 0x20b60(%rip) # 0x825f0
jne 0x61ac3
movaps 0x6d17(%rip), %xmm0 # 0x687b0
movups %xmm0, 0x20b8f(%rip) # 0x8262f
movaps %xmm0, 0x20b79(%rip) # 0x82620
movaps %xmm0, 0x20b62(%rip) # 0x82610
movaps %xmm0, 0x20b4b(%rip) # 0x82600
movaps %xmm0, 0x20b34(%rip) # 0x825f0
movb $0x0, 0x20b7c(%rip) # 0x8263f
leaq 0x20b26(%rip), %r14 # 0x825f0
movq %r14, %rdi
callq 0x2d180
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2d420
leaq 0x86b8(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2d420
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x61b2a
callq 0x2d360
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x831c(%rip), %rdi # 0x69e59
leaq 0x761d(%rip), %rsi # 0x69161
leaq 0x8675(%rip), %rcx # 0x6a1c0
movl $0x2513, %edx # imm = 0x2513
callq 0x2d250
jmp 0x61b57
movq %rax, %rdi
callq 0x3ed5c
jmp 0x61b70
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x4383a
jmp 0x61b73
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x61b91
callq 0x2d360
jmp 0x61b91
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4383a
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::printClosedHeader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void printClosedHeader( std::string const& _name ) {
printOpenHeader( _name );
stream << getLineOfChars<'.'>() << "\n";
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x61c1c
movq 0x18(%rbx), %rbx
cmpb $0x0, 0x20a3f(%rip) # 0x825f0
jne 0x61be4
movaps 0x6bf6(%rip), %xmm0 # 0x687b0
movups %xmm0, 0x20a6e(%rip) # 0x8262f
movaps %xmm0, 0x20a58(%rip) # 0x82620
movaps %xmm0, 0x20a41(%rip) # 0x82610
movaps %xmm0, 0x20a2a(%rip) # 0x82600
movaps %xmm0, 0x20a13(%rip) # 0x825f0
movb $0x0, 0x20a5b(%rip) # 0x8263f
leaq 0x20a05(%rip), %r14 # 0x825f0
movq %r14, %rdi
callq 0x2d180
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2d420
leaq 0x8597(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d420
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::printOpenHeader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void printOpenHeader( std::string const& _name ) {
stream << getLineOfChars<'-'>() << "\n";
{
Colour colourGuard( Colour::Headers );
printHeaderString( _name );
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
cmpb $0x0, 0x2096b(%rip) # 0x825a0
jne 0x61c68
movaps 0x6b62(%rip), %xmm0 # 0x687a0
movups %xmm0, 0x2099a(%rip) # 0x825df
movaps %xmm0, 0x20984(%rip) # 0x825d0
movaps %xmm0, 0x2096d(%rip) # 0x825c0
movaps %xmm0, 0x20956(%rip) # 0x825b0
movaps %xmm0, 0x2093f(%rip) # 0x825a0
movb $0x0, 0x20987(%rip) # 0x825ef
leaq 0x20931(%rip), %r12 # 0x825a0
movq %r12, %rdi
callq 0x2d180
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2d420
leaq 0x8513(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %r15, %rdi
callq 0x2d420
movb $0x0, 0x7(%rsp)
movl $0x1, %edi
callq 0x437d0
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x61ce6
xorl %edi, %edi
callq 0x437d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0x4383a
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::printHeaderString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
|
void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
std::size_t i = _string.find( ": " );
if( i != std::string::npos )
i+=2;
else
i = 0;
stream << Text( _string, TextAttributes()
.setIndent( indent+i)
.setInitialIndent( indent ) ) << "\n";
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7dab(%rip), %rsi # 0x69aac
xorl %r12d, %r12d
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2d660
leaq 0x2(%rax), %rcx
cmpq $-0x1, %rax
cmoveq %r12, %rcx
movq 0x18(%rbx), %rbx
leaq 0x58(%rsp), %rdx
movq $0x4f, 0x10(%rdx)
movb $0x9, 0x18(%rdx)
addq %r15, %rcx
movq %rcx, 0x8(%rdx)
movq %r15, (%rdx)
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5874e
movq 0x40(%r15), %r12
movq 0x48(%r15), %r15
cmpq %r15, %r12
je 0x61d91
leaq 0x843f(%rip), %r14 # 0x6a19f
cmpq 0x40(%rsp), %r12
je 0x61d77
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d420
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2d420
addq $0x20, %r12
cmpq %r15, %r12
jne 0x61d60
leaq 0x8407(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2d420
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x48df4
movq -0x40(%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x61dc5
callq 0x2d360
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x61dd3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x58c60
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::AssertionPrinter::printOriginalExpression() const
|
void printOriginalExpression() const {
if( result.hasExpression() ) {
Colour colourGuard( Colour::OriginalExpression );
stream << " ";
stream << result.getExpressionInMacro();
stream << "\n";
}
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
cmpq $0x0, 0x50(%rax)
je 0x61f93
movq %rdi, %rbx
movb $0x0, 0x7(%rsp)
movl $0x5, %edi
callq 0x437d0
movq (%rbx), %rdi
leaq 0x7cfc(%rip), %rsi # 0x69c34
movl $0x2, %edx
callq 0x2d420
movq (%rbx), %r14
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x43c96
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x2d420
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61f78
callq 0x2d360
movq (%rbx), %rdi
leaq 0x821d(%rip), %rsi # 0x6a19f
movl $0x1, %edx
callq 0x2d420
xorl %edi, %edi
callq 0x437d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61fc0
callq 0x2d360
jmp 0x61fc0
jmp 0x61fbd
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0x4383a
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::AssertionPrinter::printReconstructedExpression() const
|
void printReconstructedExpression() const {
if( result.hasExpandedExpression() ) {
stream << "with expansion:\n";
Colour colourGuard( Colour::ReconstructedExpression );
stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n";
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x43e00
testb %al, %al
je 0x62101
movq (%r14), %rdi
leaq 0x82f1(%rip), %rsi # 0x6a2f1
movl $0x10, %edx
callq 0x2d420
movb $0x0, 0x7(%rsp)
movl $0x6, %edi
callq 0x437d0
movq (%r14), %rbx
movq 0x10(%r14), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x70(%rax), %rsi
movq 0x78(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x4042a
leaq 0x80(%rsp), %rdx
movq $-0x1, (%rdx)
movq $0x4f, 0x10(%rdx)
movb $0x9, 0x18(%rdx)
movq $0x2, 0x8(%rdx)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5874e
movq 0x68(%rsp), %r12
movq 0x70(%rsp), %r13
cmpq %r13, %r12
je 0x620b7
leaq 0x8119(%rip), %r14 # 0x6a19f
cmpq 0x68(%rsp), %r12
je 0x6209d
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d420
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2d420
addq $0x20, %r12
cmpq %r13, %r12
jne 0x62086
leaq 0x80e1(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2d420
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x48df4
movq -0x40(%rbx), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x620eb
callq 0x2d360
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x620fa
callq 0x2d360
xorl %edi, %edi
callq 0x437d0
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x3ed5c
jmp 0x62126
movq %rax, %rbx
jmp 0x62133
movq %rax, %rbx
jmp 0x62142
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x58c60
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x62142
callq 0x2d360
leaq 0x7(%rsp), %rdi
callq 0x4383a
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::AssertionPrinter::printMessage() const
|
void printMessage() const {
if( !messageLabel.empty() )
stream << messageLabel << ":" << "\n";
for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
it != itEnd;
++it ) {
// If this assertion is a warning ignore any INFO messages
if( printInfoMessages || it->type != ResultWas::Info )
stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n";
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rdx
testq %rdx, %rdx
je 0x621a8
movq (%rbx), %rdi
movq 0x40(%rbx), %rsi
callq 0x2d420
movq %rax, %r14
leaq 0x728e(%rip), %rsi # 0x69415
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
leaq 0x8004(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
movq 0x80(%rbx), %r14
movq 0x88(%rbx), %rax
movq %rax, 0x8(%rsp)
cmpq %rax, %r14
je 0x6228f
leaq 0x7fd4(%rip), %r13 # 0x6a19f
cmpb $0x0, 0x98(%rbx)
jne 0x621df
cmpl $0x1, 0x48(%r14)
je 0x62280
movq (%rbx), %rbp
leaq 0x50(%r14), %rsi
movq $-0x1, 0x10(%rsp)
movq $0x4f, 0x20(%rsp)
movb $0x9, 0x28(%rsp)
movq $0x2, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x5874e
movq 0x70(%rsp), %r12
movq 0x78(%rsp), %r15
cmpq %r15, %r12
je 0x62252
cmpq 0x70(%rsp), %r12
je 0x6223b
movl $0x1, %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2d420
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbp, %rdi
callq 0x2d420
addq $0x20, %r12
jmp 0x6221f
movl $0x1, %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2d420
leaq 0x70(%rsp), %rdi
callq 0x48df4
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x62280
callq 0x2d360
addq $0x78, %r14
cmpq 0x8(%rsp), %r14
jne 0x621cb
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x622a3
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x58c60
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::printSummaryDivider()
|
void printSummaryDivider() {
stream << getLineOfChars<'-'>() << "\n";
}
|
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rbx
cmpb $0x0, 0x202d9(%rip) # 0x825a0
jne 0x622fa
movaps 0x64d0(%rip), %xmm0 # 0x687a0
movups %xmm0, 0x20308(%rip) # 0x825df
movaps %xmm0, 0x202f2(%rip) # 0x825d0
movaps %xmm0, 0x202db(%rip) # 0x825c0
movaps %xmm0, 0x202c4(%rip) # 0x825b0
movaps %xmm0, 0x202ad(%rip) # 0x825a0
movb $0x0, 0x202f5(%rip) # 0x825ef
leaq 0x2029f(%rip), %r14 # 0x825a0
movq %r14, %rdi
callq 0x2d180
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2d420
leaq 0x7e81(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d420
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::printTotals(Catch::Totals const&)
|
void printTotals( Totals const& totals ) {
if( totals.testCases.total() == 0 ) {
stream << Colour( Colour::Warning ) << "No tests ran\n";
}
else if( totals.assertions.total() > 0 && totals.assertions.allPassed() ) {
stream << Colour( Colour::ResultSuccess ) << "All tests passed";
stream << " ("
<< pluralise( totals.assertions.passed, "assertion" ) << " in "
<< pluralise( totals.testCases.passed, "test case" ) << ")"
<< "\n";
}
else {
std::vector<SummaryColumn> columns;
columns.push_back( SummaryColumn( "", Colour::None )
.addRow( totals.testCases.total() )
.addRow( totals.assertions.total() ) );
columns.push_back( SummaryColumn( "passed", Colour::Success )
.addRow( totals.testCases.passed )
.addRow( totals.assertions.passed ) );
columns.push_back( SummaryColumn( "failed", Colour::ResultError )
.addRow( totals.testCases.failed )
.addRow( totals.assertions.failed ) );
columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
.addRow( totals.testCases.failedButOk )
.addRow( totals.assertions.failedButOk ) );
printSummaryRow( "test cases", columns, 0 );
printSummaryRow( "assertions", columns, 1 );
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %rax
addq 0x18(%rsi), %rax
addq 0x28(%rsi), %rax
jne 0x62387
movq 0x18(%rbx), %rbx
movb $0x0, 0x20(%rsp)
movl $0x6, %edi
callq 0x437d0
leaq 0x8002(%rip), %rsi # 0x6a370
movl $0xd, %edx
movq %rbx, %rdi
callq 0x2d420
xorl %edi, %edi
callq 0x437d0
jmp 0x629cd
movq %rsi, %r14
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq (%rsi), %rdx
addq %rax, %rdx
addq %rcx, %rdx
sete %dl
orq %rax, %rcx
setne %al
orb %dl, %al
jne 0x62527
movq 0x18(%rbx), %r15
movb $0x0, 0x20(%rsp)
movl $0x13, %edi
callq 0x437d0
leaq 0x7fb8(%rip), %rsi # 0x6a37e
movl $0x10, %edx
movq %r15, %rdi
callq 0x2d420
xorl %edi, %edi
callq 0x437d0
movq 0x18(%rbx), %rbx
leaq 0x77b9(%rip), %rsi # 0x69b9e
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2d420
movq (%r14), %r12
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7f8a(%rip), %rsi # 0x6a38f
leaq 0x7f8c(%rip), %rdx # 0x6a398
leaq 0x60(%rsp), %rdi
callq 0x3ef3e
leaq 0x28(%rsp), %rdi
movq %r12, -0x8(%rdi)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x4542d
leaq 0x7ef5(%rip), %rsi # 0x6a344
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2d420
movq 0x18(%r14), %r13
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x7884(%rip), %rsi # 0x69cf4
leaq 0x7886(%rip), %rdx # 0x69cfd
movq %rsp, %rdi
callq 0x3ef3e
leaq 0xc0(%rsp), %rdi
movq %r13, -0x8(%rdi)
leaq 0xd0(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0xb8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4542d
leaq 0x6c2a(%rip), %rsi # 0x690e9
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2d420
leaq 0x7ccc(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2d420
movq 0xc0(%rsp), %rdi
cmpq %r13, %rdi
je 0x624f2
callq 0x2d360
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x62500
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x6250f
callq 0x2d360
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x629cd
callq 0x2d360
jmp 0x629cd
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
movq $0x0, 0xb0(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x7c52(%rip), %rdx # 0x6a1a0
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x3ef3e
leaq 0x70(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x4042a
leaq 0x60(%rsp), %rsi
movl $0x0, 0x20(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsi)
movq $0x0, 0x38(%rsi)
movq 0x20(%r14), %rdx
addq 0x18(%r14), %rdx
addq 0x28(%r14), %rdx
leaq 0xb8(%rsp), %rdi
callq 0x62af2
movq 0x8(%r14), %rdx
addq (%r14), %rdx
addq 0x10(%r14), %rdx
leaq 0x20(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x62af2
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x62f04
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x48df4
movq -0x28(%r15), %rdi
leaq 0x30(%rsp), %rbp
cmpq %rbp, %rdi
je 0x625fb
callq 0x2d360
leaq 0x88(%rsp), %r15
leaq 0xe0(%rsp), %r12
movq %r12, %rdi
callq 0x48df4
movq -0x28(%r12), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x6262a
callq 0x2d360
movq %r15, %rdi
callq 0x48df4
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
leaq 0x10(%rsp), %r15
je 0x62646
callq 0x2d360
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x62654
callq 0x2d360
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x7d27(%rip), %rsi # 0x6a388
leaq 0x7d26(%rip), %rdx # 0x6a38e
callq 0x3ef3e
leaq 0x60(%rsp), %rdi
movq %r13, (%rdi)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x60(%rsp), %rsi
movl $0x3, 0x20(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsi)
movq $0x0, 0x38(%rsi)
movq 0x18(%r14), %rdx
leaq 0xb8(%rsp), %rdi
callq 0x62af2
movq (%r14), %rdx
leaq 0x20(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x62af2
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x62f04
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x48df4
movq -0x28(%r15), %rdi
cmpq %rbp, %rdi
je 0x626f4
callq 0x2d360
leaq 0x88(%rsp), %r15
leaq 0xe0(%rsp), %r12
movq %r12, %rdi
callq 0x48df4
movq -0x28(%r12), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x62723
callq 0x2d360
movq %r15, %rdi
callq 0x48df4
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
leaq 0x10(%rsp), %r15
je 0x6273f
callq 0x2d360
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6274d
callq 0x2d360
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x7c3f(%rip), %rsi # 0x6a399
leaq 0x7c3e(%rip), %rdx # 0x6a39f
callq 0x3ef3e
leaq 0x60(%rsp), %rdi
movq %r13, (%rdi)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x60(%rsp), %rsi
movl $0x12, 0x20(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsi)
movq $0x0, 0x38(%rsi)
movq 0x20(%r14), %rdx
leaq 0xb8(%rsp), %rdi
callq 0x62af2
movq 0x8(%r14), %rdx
leaq 0x20(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x62af2
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x62f04
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x48df4
movq -0x28(%r15), %rdi
cmpq %rbp, %rdi
je 0x627ee
callq 0x2d360
leaq 0x88(%rsp), %r15
leaq 0xe0(%rsp), %r12
movq %r12, %rdi
callq 0x48df4
movq -0x28(%r12), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x6281d
callq 0x2d360
movq %r15, %rdi
callq 0x48df4
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
leaq 0x10(%rsp), %r12
je 0x62839
callq 0x2d360
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x62847
callq 0x2d360
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x7b4c(%rip), %rsi # 0x6a3a0
leaq 0x7b57(%rip), %rdx # 0x6a3b2
callq 0x3ef3e
leaq 0x60(%rsp), %rdi
movq %r13, (%rdi)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x60(%rsp), %rsi
movl $0x6, 0x20(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsi)
movq $0x0, 0x38(%rsi)
movq 0x28(%r14), %rdx
leaq 0xb8(%rsp), %rdi
callq 0x62af2
movq 0x10(%r14), %rdx
leaq 0x20(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x62af2
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x62f04
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x48df4
movq -0x28(%r14), %rdi
cmpq %rbp, %rdi
je 0x628e8
callq 0x2d360
leaq 0x88(%rsp), %r14
leaq 0xe0(%rsp), %r15
movq %r15, %rdi
callq 0x48df4
movq -0x28(%r15), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x62916
callq 0x2d360
movq %r14, %rdi
callq 0x48df4
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0x6292d
callq 0x2d360
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6293b
callq 0x2d360
leaq 0x20(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x6c42(%rip), %rsi # 0x6958c
leaq 0x6c45(%rip), %rdx # 0x69596
callq 0x3ef3e
leaq 0x20(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x62cd8
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6297c
callq 0x2d360
leaq 0x20(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x7a28(%rip), %rsi # 0x6a3b3
leaq 0x7a2b(%rip), %rdx # 0x6a3bd
callq 0x3ef3e
leaq 0x20(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
movl $0x1, %ecx
movq %rbx, %rdi
callq 0x62cd8
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x629c0
callq 0x2d360
leaq 0xa0(%rsp), %rdi
callq 0x62edc
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x629e6
jmp 0x62a79
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
jne 0x62a70
jmp 0x62a7c
jmp 0x62a79
jmp 0x62a22
jmp 0x62a31
jmp 0x62a4b
jmp 0x62a5f
jmp 0x62a79
jmp 0x62a22
jmp 0x62a31
jmp 0x62a4b
jmp 0x62a5f
jmp 0x62a79
jmp 0x62a22
jmp 0x62a31
jmp 0x62a4b
movq %rax, %rbx
jmp 0x62ac4
jmp 0x62a5f
jmp 0x62a93
jmp 0x62a79
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x62cb6
jmp 0x62a34
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x62cb6
jmp 0x62a4e
movq %rax, %rbx
jmp 0x62ae1
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x62cb6
jmp 0x62a62
movq %rax, %rbx
jmp 0x62a89
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x62a7c
callq 0x2d360
jmp 0x62a7c
jmp 0x62a98
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x62edc
movq %rbx, %rdi
callq 0x2d690
jmp 0x62aa0
movq %rax, %rbx
jmp 0x62ad2
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4383a
jmp 0x62a89
movq %rax, %rbx
movq 0xc0(%rsp), %rdi
cmpq %r13, %rdi
je 0x62ac4
callq 0x2d360
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x62ad2
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x62ae1
callq 0x2d360
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x62a89
callq 0x2d360
jmp 0x62a89
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::SummaryColumn::addRow(unsigned long)
|
SummaryColumn addRow( std::size_t count ) {
std::ostringstream oss;
oss << count;
std::string row = oss.str();
for( std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it ) {
while( it->size() < row.size() )
*it = " " + *it;
while( it->size() > row.size() )
row = " " + row;
}
rows.push_back( row );
return *this;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x2d4b0
movq %r12, %rdi
movq %r15, %rsi
callq 0x2d270
movq %rbx, 0x28(%rsp)
leaq 0x58(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2d5a0
movq 0x28(%r14), %r15
cmpq 0x30(%r14), %r15
je 0x62bce
leaq 0x40(%rsp), %rbx
leaq 0x659f(%rip), %r12 # 0x690f1
leaq 0x30(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq 0x8(%r15), %rax
cmpq 0x10(%rsp), %rax
jae 0x62bb9
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x49917
movq %r15, %rdi
movq %r13, %rsi
callq 0x2d480
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x62b5c
callq 0x2d360
jmp 0x62b5c
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x49917
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2d480
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x62bb9
callq 0x2d360
movq 0x8(%r15), %rax
cmpq 0x10(%rsp), %rax
ja 0x62b91
addq $0x20, %r15
cmpq 0x30(%r14), %r15
jne 0x62b5c
leaq 0x28(%r14), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x57a4a
movq 0x28(%rsp), %r12
leaq 0x10(%r12), %rbx
movq %rbx, (%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4042a
movl 0x20(%r14), %eax
movl %eax, 0x20(%r12)
leaq 0x28(%r12), %rdi
movq %r15, %rsi
callq 0x4e87c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62c28
callq 0x2d360
movq 0x1f381(%rip), %rsi # 0x81fb0
leaq 0x50(%rsp), %rdi
callq 0x2d1d0
leaq 0xc0(%rsp), %rdi
callq 0x2d110
movq %r12, %rax
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbx, %rdi
je 0x62c7c
callq 0x2d360
jmp 0x62c7c
jmp 0x62c70
movq %rax, %r14
jmp 0x62c8f
jmp 0x62c79
jmp 0x62c79
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62c8f
callq 0x2d360
movq 0x1f31a(%rip), %rsi # 0x81fb0
leaq 0x50(%rsp), %rdi
callq 0x2d1d0
leaq 0xc0(%rsp), %rdi
callq 0x2d110
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::SummaryColumn::~SummaryColumn()
|
SummaryColumn( std::string const& _label, Colour::Code _colour )
: label( _label ),
colour( _colour )
{}
|
pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x48df4
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x62cd5
popq %rbx
jmp 0x2d360
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::printSummaryRow(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::ConsoleReporter::SummaryColumn, std::allocator<Catch::ConsoleReporter::SummaryColumn>> const&, unsigned long)
|
void printSummaryRow( std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row ) {
for( std::vector<SummaryColumn>::const_iterator it = cols.begin(); it != cols.end(); ++it ) {
std::string value = it->rows[row];
if( it->label.empty() ) {
stream << label << ": ";
if( value != "0" )
stream << value;
else
stream << Colour( Colour::Warning ) << "- none -";
}
else if( value != "0" ) {
stream << Colour( Colour::LightGrey ) << " | ";
stream << Colour( it->colour )
<< value << " " << it->label;
}
}
stream << "\n";
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, %r15
movq (%rdx), %r12
cmpq 0x8(%rdx), %r12
je 0x62e74
movq %rcx, %rbx
movq %rdx, %r14
shlq $0x5, %rbx
leaq 0x10(%rsp), %r13
movq 0x28(%r12), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax,%rbx), %rsi
movq 0x8(%rax,%rbx), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x4042a
cmpq $0x0, 0x8(%r12)
je 0x62dd4
movq %r13, %rdi
leaq 0x46b9(%rip), %rsi # 0x673fc
callq 0x2d0f0
testl %eax, %eax
je 0x62e52
movq 0x18(%r15), %rbp
movb $0x0, 0xf(%rsp)
movl $0x17, %edi
callq 0x437d0
movl $0x3, %edx
movq %rbp, %rdi
leaq 0x7655(%rip), %rsi # 0x6a3c7
callq 0x2d420
xorl %edi, %edi
callq 0x437d0
movq 0x18(%r15), %rbp
movl 0x20(%r12), %edi
movb $0x0, 0xf(%rsp)
callq 0x437d0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbp, %rdi
callq 0x2d420
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
leaq 0x633c(%rip), %rsi # 0x690f1
callq 0x2d420
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbp, %rdi
callq 0x2d420
xorl %edi, %edi
callq 0x437d0
jmp 0x62e52
movq 0x18(%r15), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x2d420
movl $0x2, %edx
movq %rax, %rdi
leaq 0x6cb4(%rip), %rsi # 0x69aac
callq 0x2d420
movq %r13, %rdi
leaq 0x45f5(%rip), %rsi # 0x673fc
callq 0x2d0f0
movq 0x18(%r15), %rbp
testl %eax, %eax
je 0x62e28
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbp, %rdi
callq 0x2d420
jmp 0x62e52
movb $0x0, 0xf(%rsp)
movl $0x6, %edi
callq 0x437d0
movl $0x8, %edx
movq %rbp, %rdi
leaq 0x7578(%rip), %rsi # 0x6a3be
callq 0x2d420
xorl %edi, %edi
callq 0x437d0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x62e66
callq 0x2d360
addq $0x40, %r12
cmpq 0x8(%r14), %r12
jne 0x62d0a
movq 0x18(%r15), %rdi
leaq 0x7320(%rip), %rsi # 0x6a19f
movl $0x1, %edx
callq 0x2d420
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x62ea4
jmp 0x62eb3
jmp 0x62eae
jmp 0x62eae
jmp 0x62ea4
jmp 0x62eb3
movq %rax, %rdi
callq 0x3ed5c
jmp 0x62eae
movq %rax, %rbx
jmp 0x62ec0
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0x4383a
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x62ed4
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::printTotalsDivider(Catch::Totals const&)
|
void printTotalsDivider( Totals const& totals ) {
if( totals.testCases.total() > 0 ) {
std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() );
std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() );
std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() );
while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 )
findMax( failedRatio, failedButOkRatio, passedRatio )++;
while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 )
findMax( failedRatio, failedButOkRatio, passedRatio )--;
stream << Colour( Colour::Error ) << std::string( failedRatio, '=' );
stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' );
if( totals.testCases.allPassed() )
stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' );
else
stream << Colour( Colour::Success ) << std::string( passedRatio, '=' );
}
else {
stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
}
stream << "\n";
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbp
movq 0x18(%rsi), %r9
movq 0x20(%rsi), %r10
addq %r9, %r10
addq 0x28(%rsi), %r10
je 0x6325c
movq %rsi, %r14
movq 0x20(%rsi), %r8
movq 0x28(%rsi), %r11
movq %r8, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r10
cmpq %rcx, %r10
movl $0x1, %esi
movq %rax, %rdi
cmovaq %rsi, %rdi
testq %r8, %r8
cmoveq %rax, %rdi
movq %r11, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r10
cmpq %rcx, %r10
movq %rax, %r8
cmovaq %rsi, %r8
testq %r11, %r11
cmoveq %rax, %r8
movq %r9, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r10
cmpq %rcx, %r10
cmovbeq %rax, %rsi
testq %r9, %r9
cmoveq %rax, %rsi
leaq (%r8,%rdi), %rax
addq %rsi, %rax
cmpq $0x4e, %rax
ja 0x632b9
movq %r8, %r12
cmpq %r8, %rdi
seta %al
cmpq %rsi, %rdi
seta %cl
cmpq %rsi, %r8
movq %rsi, %r13
cmovaq %r8, %r13
testb %cl, %al
cmovneq %rdi, %r13
incq %r13
cmpq %rsi, %r8
cmovaq %r13, %r12
movq %r13, %r15
cmovaq %rsi, %r15
testb %cl, %al
cmovneq %r8, %r12
cmovneq %rsi, %r15
cmoveq %rdi, %r13
leaq (%r12,%r13), %rax
addq %r15, %rax
movq %r12, %r8
movq %r15, %rsi
movq %r13, %rdi
cmpq $0x4f, %rax
jb 0x63209
jmp 0x632c2
movq 0x18(%rbp), %r14
movb $0x0, 0x7(%rsp)
movl $0x6, %edi
callq 0x437d0
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x8(%rsp), %rdi
movl $0x4f, %esi
movl $0x3d, %edx
callq 0x2d440
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x2d420
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x632ad
callq 0x2d360
xorl %edi, %edi
callq 0x437d0
jmp 0x63478
movq %r8, %r12
movq %rsi, %r15
movq %rdi, %r13
leaq (%r12,%r13), %rax
addq %r15, %rax
cmpq $0x50, %rax
jb 0x6331a
cmpq %r12, %r13
seta %al
cmpq %r15, %r13
seta %cl
cmpq %r15, %r12
movq %r15, %rdx
cmovaq %r12, %rdx
testb %cl, %al
cmovneq %r13, %rdx
decq %rdx
cmpq %r15, %r12
movq %r12, %rsi
cmovaq %rdx, %rsi
movq %rdx, %rdi
cmovaq %r15, %rdi
testb %cl, %al
cmoveq %rsi, %r12
cmoveq %rdi, %r15
cmovneq %rdx, %r13
leaq (%r12,%r13), %rax
addq %r15, %rax
cmpq $0x4f, %rax
ja 0x632cf
movq %rbp, %rbx
movq 0x18(%rbp), %rbp
movb $0x0, 0x7(%rsp)
movl $0x12, %edi
callq 0x437d0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movl $0x3d, %edx
callq 0x2d440
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbp, %rdi
callq 0x2d420
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
movq %rbx, %rbp
je 0x63374
callq 0x2d360
xorl %edi, %edi
callq 0x437d0
movq 0x18(%rbp), %r13
movb $0x0, 0x7(%rsp)
movl $0x6, %edi
callq 0x437d0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, (%rdi)
movq %r12, %rsi
movl $0x3d, %edx
callq 0x2d440
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x2d420
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x633c9
callq 0x2d360
xorl %edi, %edi
callq 0x437d0
movq 0x28(%r14), %rax
movq 0x18(%rbp), %r12
orq 0x20(%r14), %rax
jne 0x6342c
movb $0x0, 0x7(%rsp)
movl $0x13, %edi
callq 0x437d0
leaq 0x8(%rsp), %rdi
movq %rbx, (%rdi)
movq %r15, %rsi
movl $0x3d, %edx
callq 0x2d440
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x2d420
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x63423
callq 0x2d360
xorl %edi, %edi
callq 0x437d0
jmp 0x63478
movb $0x0, 0x7(%rsp)
movl $0x3, %edi
callq 0x437d0
leaq 0x8(%rsp), %rdi
movq %rbx, (%rdi)
movq %r15, %rsi
movl $0x3d, %edx
callq 0x2d440
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x2d420
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x63471
callq 0x2d360
xorl %edi, %edi
callq 0x437d0
movq 0x18(%rbp), %rdi
leaq 0x6d1c(%rip), %rsi # 0x6a19f
movl $0x1, %edx
callq 0x2d420
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x634c1
jmp 0x634c1
jmp 0x634b0
jmp 0x634b0
jmp 0x634e2
jmp 0x634e2
jmp 0x634c1
jmp 0x634b0
jmp 0x634e2
jmp 0x634c1
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
jne 0x634db
jmp 0x634e5
jmp 0x634e2
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x634e5
callq 0x2d360
jmp 0x634e5
movq %rax, %r14
leaq 0x7(%rsp), %rdi
callq 0x4383a
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::CompactReporter::AssertionPrinter::print()
|
void print() {
printSourceInfo();
itMessage = messages.begin();
switch( result.getResultType() ) {
case ResultWas::Ok:
printResultType( Colour::ResultSuccess, passedString() );
printOriginalExpression();
printReconstructedExpression();
if ( ! result.hasExpression() )
printRemainingMessages( Colour::None );
else
printRemainingMessages();
break;
case ResultWas::ExpressionFailed:
if( result.isOk() )
printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) );
else
printResultType( Colour::Error, failedString() );
printOriginalExpression();
printReconstructedExpression();
printRemainingMessages();
break;
case ResultWas::ThrewException:
printResultType( Colour::Error, failedString() );
printIssue( "unexpected exception with message:" );
printMessage();
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::FatalErrorCondition:
printResultType( Colour::Error, failedString() );
printIssue( "fatal error condition with message:" );
printMessage();
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::DidntThrowException:
printResultType( Colour::Error, failedString() );
printIssue( "expected exception, got none" );
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::Info:
printResultType( Colour::None, "info" );
printMessage();
printRemainingMessages();
break;
case ResultWas::Warning:
printResultType( Colour::None, "warning" );
printMessage();
printRemainingMessages();
break;
case ResultWas::ExplicitFailure:
printResultType( Colour::Error, failedString() );
printIssue( "explicitly" );
printRemainingMessages( Colour::None );
break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
printResultType( Colour::Error, "** internal error **" );
break;
}
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, %rbx
callq 0x63be4
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
movq %rax, 0x30(%rbx)
movl 0xb0(%rcx), %eax
cmpl $0x11, %eax
jg 0x635b3
leal 0x1(%rax), %edx
cmpl $0x3, %edx
ja 0x6367f
leaq 0x59ea(%rip), %rax # 0x68f24
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x1d0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6e32(%rip), %rsi # 0x6a388
leaq 0x6e31(%rip), %rdx # 0x6a38e
leaq 0x1c0(%rsp), %r14
movq %r14, %rdi
callq 0x3ef3e
movq %rbx, %rdi
movl $0x13, %esi
movq %r14, %rdx
callq 0x63c9e
movq 0x1c0(%rsp), %rdi
cmpq %r15, %rdi
je 0x6358f
callq 0x2d360
movq %rbx, %rdi
callq 0x63d32
movq %rbx, %rdi
callq 0x63db8
movq 0x10(%rbx), %rax
cmpq $0x0, 0x50(%rax)
jne 0x63a10
jmp 0x6380c
cmpl $0x110, %eax # imm = 0x110
jle 0x63706
cmpl $0x111, %eax # imm = 0x111
je 0x638c4
cmpl $0x112, %eax # imm = 0x112
je 0x63816
cmpl $0x210, %eax # imm = 0x210
jne 0x63a1d
leaq 0x170(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6da7(%rip), %rsi # 0x6a399
leaq 0x6da6(%rip), %rdx # 0x6a39f
leaq 0x160(%rsp), %r14
movq %r14, %rdi
callq 0x3ef3e
movq %rbx, %rdi
movl $0x12, %esi
movq %r14, %rdx
callq 0x63c9e
movq 0x160(%rsp), %rdi
cmpq %r15, %rdi
je 0x6362b
callq 0x2d360
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6db3(%rip), %rsi # 0x6a3ee
leaq 0x6dcf(%rip), %rdx # 0x6a411
leaq 0x40(%rsp), %rdi
callq 0x3ef3e
movq (%rbx), %r14
leaq 0x5a9b(%rip), %rsi # 0x690f1
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %r14, %rdi
callq 0x2d420
movq 0x40(%rsp), %rdi
jmp 0x6395f
cmpl $0x10, %eax
je 0x63716
cmpl $0x11, %eax
jne 0x63a1d
testb $0x10, %al
je 0x63a2a
movl 0x68(%rcx), %eax
andl $0x8, %eax
jne 0x63a2a
leaq 0x1b0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6ce1(%rip), %rsi # 0x6a399
leaq 0x6ce0(%rip), %rdx # 0x6a39f
leaq 0x1a0(%rsp), %r14
movq %r14, %rdi
callq 0x3ef3e
movq %rbx, %rdi
movl $0x12, %esi
movq %r14, %rdx
callq 0x63c9e
movq 0x1a0(%rsp), %rdi
cmpq %r15, %rdi
je 0x636f1
callq 0x2d360
movq %rbx, %rdi
callq 0x63d32
movq %rbx, %rdi
callq 0x63db8
jmp 0x63a10
cmpl $0x12, %eax
je 0x6376b
cmpl $0x110, %eax # imm = 0x110
jne 0x63a1d
leaq 0xd0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6bb3(%rip), %rsi # 0x6a2dc
leaq 0x6bc0(%rip), %rdx # 0x6a2f0
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
callq 0x3ef3e
movq %rbx, %rdi
movl $0x12, %esi
movq %r14, %rdx
callq 0x63c9e
movq 0xc0(%rsp), %rdi
cmpq %r15, %rdi
je 0x63a1d
callq 0x2d360
jmp 0x63a1d
leaq 0xf0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6c1b(%rip), %rsi # 0x6a399
leaq 0x6c1a(%rip), %rdx # 0x6a39f
leaq 0xe0(%rsp), %r14
movq %r14, %rdi
callq 0x3ef3e
movq %rbx, %rdi
movl $0x12, %esi
movq %r14, %rdx
callq 0x63c9e
movq 0xe0(%rsp), %rdi
cmpq %r15, %rdi
je 0x637b7
callq 0x2d360
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6c68(%rip), %rsi # 0x6a42f
leaq 0x6c6b(%rip), %rdx # 0x6a439
movq %rsp, %rdi
callq 0x3ef3e
movq (%rbx), %r14
leaq 0x5911(%rip), %rsi # 0x690f1
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x2d420
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6380c
callq 0x2d360
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x63a18
leaq 0x150(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6b70(%rip), %rsi # 0x6a399
leaq 0x6b6f(%rip), %rdx # 0x6a39f
leaq 0x140(%rsp), %r14
movq %r14, %rdi
callq 0x3ef3e
movq %rbx, %rdi
movl $0x12, %esi
movq %r14, %rdx
callq 0x63c9e
movq 0x140(%rsp), %rdi
cmpq %r15, %rdi
je 0x63862
callq 0x2d360
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6ba0(%rip), %rsi # 0x6a412
leaq 0x6bb5(%rip), %rdx # 0x6a42e
leaq 0x20(%rsp), %rdi
callq 0x3ef3e
movq (%rbx), %r14
leaq 0x5864(%rip), %rsi # 0x690f1
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r14, %rdi
callq 0x2d420
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x63971
callq 0x2d360
jmp 0x63971
leaq 0x190(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6ac2(%rip), %rsi # 0x6a399
leaq 0x6ac1(%rip), %rdx # 0x6a39f
leaq 0x180(%rsp), %r14
movq %r14, %rdi
callq 0x3ef3e
movq %rbx, %rdi
movl $0x12, %esi
movq %r14, %rdx
callq 0x63c9e
movq 0x180(%rsp), %rdi
cmpq %r15, %rdi
je 0x63910
callq 0x2d360
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6aab(%rip), %rsi # 0x6a3cb
leaq 0x6ac6(%rip), %rdx # 0x6a3ed
leaq 0x60(%rsp), %rdi
callq 0x3ef3e
movq (%rbx), %r14
leaq 0x57b6(%rip), %rsi # 0x690f1
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq %r14, %rdi
callq 0x2d420
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x63969
callq 0x2d360
movq %rbx, %rdi
callq 0x6406a
movq %rbx, %rdi
callq 0x640c8
jmp 0x63a10
leaq 0x130(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x690d(%rip), %rsi # 0x6a29e
leaq 0x690a(%rip), %rdx # 0x6a2a2
leaq 0x120(%rsp), %r14
movq %r14, %rdi
callq 0x3ef3e
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x63c9e
movq 0x120(%rsp), %rdi
jmp 0x639fe
leaq 0x110(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x68d1(%rip), %rsi # 0x6a2a3
leaq 0x68d1(%rip), %rdx # 0x6a2aa
leaq 0x100(%rsp), %r14
movq %r14, %rdi
callq 0x3ef3e
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x63c9e
movq 0x100(%rsp), %rdi
cmpq %r15, %rdi
je 0x63a08
callq 0x2d360
movq %rbx, %rdi
callq 0x6406a
movq %rbx, %rdi
movl $0x17, %esi
callq 0x63e76
addq $0x1e0, %rsp # imm = 0x1E0
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x67cd(%rip), %rsi # 0x6a20a
leaq 0x67d3(%rip), %rdx # 0x6a217
leaq 0xa0(%rsp), %rdi
callq 0x3ef3e
leaq 0x6941(%rip), %rcx # 0x6a399
leaq 0xa0(%rsp), %rdi
movl $0x6, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d400
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x63a9f
movq %rdx, 0x80(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x90(%rsp)
jmp 0x63aa6
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rsi
leaq 0x80(%rsp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movl $0x13, %esi
callq 0x63c9e
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x63ae4
callq 0x2d360
movq 0xa0(%rsp), %rdi
cmpq %r14, %rdi
jne 0x636ec
jmp 0x636f1
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x63b14
callq 0x2d360
jmp 0x63b14
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
cmpq %r14, %rdi
jne 0x63bd7
jmp 0x63bdc
movq %rax, %rbx
movq 0x1a0(%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
jmp 0x63bdc
movq %rax, %rbx
movq 0x1c0(%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
movq 0x100(%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
movq 0x120(%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
movq 0x180(%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
movq 0x160(%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
movq 0x140(%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
movq 0xe0(%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
movq 0x60(%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x63bd2
movq %rax, %rbx
movq 0xc0(%rsp), %rdi
cmpq %r15, %rdi
je 0x63bdc
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ReporterRegistrar<Catch::XmlReporter>::ReporterFactory::getDescription[abi:cxx11]() const
|
virtual std::string getDescription() const {
return T::getDescription();
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %rsp, %r14
movq $0x27, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x2d6a0
movq %rax, (%rbx)
movq (%r14), %rcx
movq %rcx, 0x10(%rbx)
movabsq $0x746e656d75636f64, %rdx # imm = 0x746E656D75636F64
movq %rdx, 0x1f(%rax)
movups 0x4970(%rip), %xmm0 # 0x6a4c3
movups %xmm0, 0x10(%rax)
movups 0x4955(%rip), %xmm0 # 0x6a4b3
movups %xmm0, (%rax)
movq %rcx, 0x8(%rbx)
movb $0x0, (%rax,%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ReporterRegistrar<Catch::JunitReporter>::ReporterFactory::getDescription[abi:cxx11]() const
|
virtual std::string getDescription() const {
return T::getDescription();
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x8(%rsp), %r14
movq $0x4e, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x2d6a0
movq %rax, %r15
movq %rax, (%rbx)
movq (%r14), %r14
movq %r14, 0x10(%rbx)
leaq 0x4878(%rip), %rsi # 0x6a4db
movl $0x4e, %edx
movq %rax, %rdi
callq 0x2d300
movq %r14, 0x8(%rbx)
movb $0x0, (%r15,%r14)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::JunitReporter::JunitReporter(Catch::ReporterConfig const&)
|
JunitReporter( ReporterConfig const& _config )
: CumulativeReporterBase( _config ),
xml( _config.stream() )
{
m_reporterPrefs.shouldRedirectStdOut = true;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
leaq 0x19f49(%rip), %rax # 0x7fbe8
movq %rax, (%rdi)
movq 0x8(%rsi), %rdi
movq %rdi, 0x10(%rbx)
testq %rdi, %rdi
je 0x65cb5
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r14), %rax
movq %rax, 0x18(%rbx)
leaq 0x20(%rbx), %rdi
xorl %r15d, %r15d
movl $0xa1, %edx
xorl %esi, %esi
callq 0x2d1f0
leaq 0x1a0e2(%rip), %rax # 0x7fdb8
movq %rax, (%rbx)
movq (%r14), %rax
movw $0x0, 0xc8(%rbx)
movq %r15, 0xe0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%rbx)
leaq 0xf8(%rbx), %rcx
movq %rcx, 0xe8(%rbx)
movq %r15, 0xf0(%rbx)
movb $0x0, 0xf8(%rbx)
movq %rax, 0x108(%rbx)
movq %r15, 0x110(%rbx)
leaq 0x118(%rbx), %r15
movq %r15, %rdi
callq 0x2d4b0
leaq 0x290(%rbx), %rdi
callq 0x2d4b0
movb $0x1, 0xc0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x1c25e(%rip), %rsi # 0x81fb0
movq %r15, %rdi
callq 0x2d1d0
leaq 0x188(%rbx), %rdi
callq 0x2d110
jmp 0x65d6b
movq %rax, %r14
leaq 0xc8(%rbx), %rdi
callq 0x4a9d8
movq %rbx, %rdi
callq 0x4851a
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ReporterRegistrar<Catch::ConsoleReporter>::ReporterFactory::getDescription[abi:cxx11]() const
|
virtual std::string getDescription() const {
return T::getDescription();
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %rsp, %r14
movq $0x2b, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x2d6a0
movq %rax, (%rbx)
movq (%r14), %rcx
movq %rcx, 0x10(%rbx)
movups 0x4736(%rip), %xmm0 # 0x6a545
movups %xmm0, 0x1b(%rax)
movups 0x4720(%rip), %xmm0 # 0x6a53a
movups %xmm0, 0x10(%rax)
movups 0x4705(%rip), %xmm0 # 0x6a52a
movups %xmm0, (%rax)
movq %rcx, 0x8(%rbx)
movb $0x0, (%rax,%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ReporterRegistrar<Catch::CompactReporter>::ReporterFactory::getDescription[abi:cxx11]() const
|
virtual std::string getDescription() const {
return T::getDescription();
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %rsp, %r14
movq $0x38, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x2d6a0
movq %rax, (%rbx)
movq (%r14), %rcx
movq %rcx, 0x10(%rbx)
movabsq $0x7345444920726f66, %rdx # imm = 0x7345444920726F66
movq %rdx, 0x30(%rax)
movups 0x46ab(%rip), %xmm0 # 0x6a576
movups %xmm0, 0x20(%rax)
movups 0x4690(%rip), %xmm0 # 0x6a566
movups %xmm0, 0x10(%rax)
movups 0x4675(%rip), %xmm0 # 0x6a556
movups %xmm0, (%rax)
movq %rcx, 0x8(%rbx)
movb $0x0, (%rax,%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Matchers::Impl::MatcherImpl<Catch::Matchers::Impl::StdString::Contains, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::clone() const
|
virtual Ptr<Matcher<ExpressionT> > clone() const {
return Ptr<Matcher<ExpressionT> >( new DerivedT( static_cast<DerivedT const&>( *this ) ) );
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x38, %edi
callq 0x2d3a0
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x1a014(%rip), %rax # 0x7ffa8
movq %rax, (%r14)
movl 0x10(%r15), %eax
movl %eax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x28(%r14), %rax
movq %rax, 0x18(%r14)
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdx
addq %rsi, %rdx
callq 0x4042a
movq %r14, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Matchers::Impl::MatcherImpl<Catch::Matchers::Impl::StdString::EndsWith, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::clone() const
|
virtual Ptr<Matcher<ExpressionT> > clone() const {
return Ptr<Matcher<ExpressionT> >( new DerivedT( static_cast<DerivedT const&>( *this ) ) );
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x38, %edi
callq 0x2d3a0
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x19fb8(%rip), %rax # 0x80038
movq %rax, (%r14)
movl 0x10(%r15), %eax
movl %eax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x28(%r14), %rax
movq %rax, 0x18(%r14)
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdx
addq %rsi, %rdx
callq 0x4042a
movq %r14, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
run_tests
|
static void test_encode(void) {
nonce_override(nonce);
uint8_t key[paseto_v2_LOCAL_KEYBYTES];
assert(paseto_v2_local_load_key_base64(key, "gHgVofOGvySsqUnTsAJusgGCJbWFiiqYN1pWzuQGjxw") == true);
const uint8_t message[] = "test";
char *enc = paseto_v2_local_encrypt(message, 4, key, NULL, 0);
if (!enc) perror("paseto_v2_local_encrypt failed");
assert(enc != NULL);
printf("enc: %s\n", enc);
assert(strcmp("v2.local.AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbiP5Pgo9TuVWWC37ZRTtiYgJS9A", enc) == 0);
free(enc);
}
|
pushq %r14
pushq %rbx
subq $0x98, %rsp
leaq 0x4ae3(%rip), %rdi # 0x6160
callq 0x15b1
leaq 0x1b40(%rip), %rsi # 0x31c9
leaq 0x40(%rsp), %rdi
callq 0x11d0
testb %al, %al
je 0x1a10
leaq 0x20(%rsp), %rdi
movb $0x0, 0x4(%rdi)
movl $0x74736574, (%rdi) # imm = 0x74736574
leaq 0x40(%rsp), %rdx
movl $0x4, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
testq %rax, %rax
je 0x1a2f
movq %rax, %rbx
leaq 0x1c1c(%rip), %rdi # 0x32ed
movq %rax, %rsi
xorl %eax, %eax
callq 0x10f0
leaq 0x1c14(%rip), %rdi # 0x32f6
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
jne 0x1a34
movq %rbx, %rdi
callq 0x1040
leaq 0x1ac8(%rip), %rsi # 0x31c9
leaq 0x20(%rsp), %rdi
callq 0x11d0
testb %al, %al
je 0x1a53
leaq 0x1f46(%rip), %rsi # 0x3660
leaq 0x40(%rsp), %rax
movl $0x8, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x44(%rax)
movl $0x77537277, 0x40(%rax) # imm = 0x77537277
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x20(%rsp), %rdx
movq %rax, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1150
testq %rax, %rax
je 0x1a72
movq %rax, %rbx
leaq 0x1c74(%rip), %rdi # 0x33da
movq %rax, %rsi
xorl %eax, %eax
callq 0x10f0
cmpq $0x4, 0x8(%rsp)
jne 0x1a77
cmpl $0x74736574, (%rbx) # imm = 0x74736574
jne 0x1a96
movq %rbx, %rdi
callq 0x1040
leaq 0x1c7d(%rip), %rsi # 0x3414
leaq 0x40(%rsp), %rdi
callq 0x11d0
testb %al, %al
je 0x1ab5
leaq 0x10(%rsp), %rdi
movb $0x0, 0x4(%rdi)
movl $0x74736574, (%rdi) # imm = 0x74736574
leaq 0x1f43(%rip), %rcx # 0x3702
leaq 0x40(%rsp), %rdx
movl $0x4, %esi
movl $0x5, %r8d
callq 0x10a0
testq %rax, %rax
je 0x1ad4
movq %rax, %r14
leaq 0x1b06(%rip), %rdi # 0x32ed
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x10f0
leaq 0x20(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x8(%rsp), %r8
movq %rbx, (%r8)
leaq 0x40(%rsp), %rdx
leaq 0x18(%rsp), %rcx
movq %r14, %rdi
callq 0x1150
testq %rax, %rax
je 0x1ad9
movq %rax, %rbx
movq %r14, %rdi
callq 0x1040
movq 0x18(%rsp), %rdx
leaq 0x1ca5(%rip), %rdi # 0x34da
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10f0
cmpq $0x4, 0x20(%rsp)
jne 0x1ae1
cmpq $0x5, 0x8(%rsp)
jne 0x1b00
movl 0x10(%rsp), %eax
cmpl (%rbx), %eax
jne 0x1b1f
movq 0x18(%rsp), %rax
movl $0x746f6f66, %ecx # imm = 0x746F6F66
xorl (%rax), %ecx
movzbl 0x4(%rax), %eax
orl %ecx, %eax
jne 0x1b3e
movq %rbx, %rdi
callq 0x1040
leaq 0x193f(%rip), %rsi # 0x31c9
leaq 0x40(%rsp), %rdi
callq 0x11d0
testb %al, %al
je 0x1b5d
leaq 0x8(%rsp), %rdi
movw $0x2e, 0x4(%rdi)
movl $0x782e3276, (%rdi) # imm = 0x782E3276
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x40(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1150
movq %rax, %r14
callq 0x1060
cmpl $0x16, (%rax)
jne 0x1b7c
testq %r14, %r14
jne 0x1b9b
movq %rax, %rbx
leaq 0x18dd(%rip), %rsi # 0x31c9
leaq 0x40(%rsp), %rdi
callq 0x11d0
testb %al, %al
je 0x1bba
movabsq $0x6c61636f6c2e3276, %r14 # imm = 0x6C61636F6C2E3276
leaq 0x20(%rsp), %rdi
movq %r14, (%rdi)
movw $0x2e, 0x8(%rdi)
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x40(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1150
cmpl $0x16, (%rbx)
jne 0x1bd9
testq %rax, %rax
jne 0x1bf8
leaq 0x187f(%rip), %rsi # 0x31c9
leaq 0x40(%rsp), %rdi
callq 0x11d0
testb %al, %al
je 0x1c17
movabsq $0x666473612e6c61, %rax # imm = 0x666473612E6C61
leaq 0x20(%rsp), %rdi
movq %rax, 0x6(%rdi)
movq %r14, (%rdi)
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x40(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1150
cmpl $0x16, (%rbx)
jne 0x1c36
testq %rax, %rax
jne 0x1c55
leaq 0x1823(%rip), %rsi # 0x31c9
leaq 0x20(%rsp), %rdi
callq 0x11d0
testb %al, %al
je 0x1c74
leaq 0x1cf1(%rip), %rsi # 0x36b0
leaq 0x40(%rsp), %rax
movl $0xa, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
movw $0x41, 0x50(%rax)
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x20(%rsp), %rdx
movq %rax, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1150
cmpl $0x16, (%rbx)
jne 0x1c93
testq %rax, %rax
jne 0x1cb2
addq $0x98, %rsp
popq %rbx
popq %r14
retq
leaq 0x17de(%rip), %rdi # 0x31f5
leaq 0x1833(%rip), %rsi # 0x3251
leaq 0x1886(%rip), %rcx # 0x32ab
movl $0xf, %edx
callq 0x1100
callq 0x12fd
leaq 0x1900(%rip), %rdi # 0x333b
leaq 0x180f(%rip), %rsi # 0x3251
leaq 0x1862(%rip), %rcx # 0x32ab
movl $0x15, %edx
callq 0x1100
leaq 0x179b(%rip), %rdi # 0x31f5
leaq 0x17f0(%rip), %rsi # 0x3251
leaq 0x192c(%rip), %rcx # 0x3394
movl $0x1b, %edx
callq 0x1100
callq 0x12d3
leaq 0x1965(%rip), %rdi # 0x33e3
leaq 0x17cc(%rip), %rsi # 0x3251
leaq 0x1908(%rip), %rcx # 0x3394
movl $0x22, %edx
callq 0x1100
leaq 0x1957(%rip), %rdi # 0x33f4
leaq 0x17ad(%rip), %rsi # 0x3251
leaq 0x18e9(%rip), %rcx # 0x3394
movl $0x23, %edx
callq 0x1100
leaq 0x1984(%rip), %rdi # 0x3440
leaq 0x178e(%rip), %rsi # 0x3251
leaq 0x19d2(%rip), %rcx # 0x349c
movl $0x29, %edx
callq 0x1100
callq 0x12a9
movq %r14, %rdi
callq 0x1274
leaq 0x1a06(%rip), %rdi # 0x34ee
leaq 0x1762(%rip), %rsi # 0x3251
leaq 0x19a6(%rip), %rcx # 0x349c
movl $0x39, %edx
callq 0x1100
leaq 0x1a06(%rip), %rdi # 0x350d
leaq 0x1743(%rip), %rsi # 0x3251
leaq 0x1987(%rip), %rcx # 0x349c
movl $0x3a, %edx
callq 0x1100
leaq 0x19f7(%rip), %rdi # 0x351d
leaq 0x1724(%rip), %rsi # 0x3251
leaq 0x1968(%rip), %rcx # 0x349c
movl $0x3b, %edx
callq 0x1100
leaq 0x1a0c(%rip), %rdi # 0x3551
leaq 0x1705(%rip), %rsi # 0x3251
leaq 0x1949(%rip), %rcx # 0x349c
movl $0x3c, %edx
callq 0x1100
leaq 0x1691(%rip), %rdi # 0x31f5
leaq 0x16e6(%rip), %rsi # 0x3251
leaq 0x19fe(%rip), %rcx # 0x3570
movl $0x42, %edx
callq 0x1100
leaq 0x1a19(%rip), %rdi # 0x359c
leaq 0x16c7(%rip), %rsi # 0x3251
leaq 0x19df(%rip), %rcx # 0x3570
movl $0x46, %edx
callq 0x1100
leaq 0x1a0a(%rip), %rdi # 0x35ac
leaq 0x16a8(%rip), %rsi # 0x3251
leaq 0x19c0(%rip), %rcx # 0x3570
movl $0x47, %edx
callq 0x1100
leaq 0x1634(%rip), %rdi # 0x31f5
leaq 0x1689(%rip), %rsi # 0x3251
leaq 0x19ed(%rip), %rcx # 0x35bc
movl $0x4c, %edx
callq 0x1100
leaq 0x19bc(%rip), %rdi # 0x359c
leaq 0x166a(%rip), %rsi # 0x3251
leaq 0x19ce(%rip), %rcx # 0x35bc
movl $0x50, %edx
callq 0x1100
leaq 0x19ad(%rip), %rdi # 0x35ac
leaq 0x164b(%rip), %rsi # 0x3251
leaq 0x19af(%rip), %rcx # 0x35bc
movl $0x51, %edx
callq 0x1100
leaq 0x15d7(%rip), %rdi # 0x31f5
leaq 0x162c(%rip), %rsi # 0x3251
leaq 0x19c7(%rip), %rcx # 0x35f3
movl $0x56, %edx
callq 0x1100
leaq 0x195f(%rip), %rdi # 0x359c
leaq 0x160d(%rip), %rsi # 0x3251
leaq 0x19a8(%rip), %rcx # 0x35f3
movl $0x5a, %edx
callq 0x1100
leaq 0x1950(%rip), %rdi # 0x35ac
leaq 0x15ee(%rip), %rsi # 0x3251
leaq 0x1989(%rip), %rcx # 0x35f3
movl $0x5b, %edx
callq 0x1100
leaq 0x157a(%rip), %rdi # 0x31f5
leaq 0x15cf(%rip), %rsi # 0x3251
leaq 0x19a5(%rip), %rcx # 0x362e
movl $0x60, %edx
callq 0x1100
leaq 0x1902(%rip), %rdi # 0x359c
leaq 0x15b0(%rip), %rsi # 0x3251
leaq 0x1986(%rip), %rcx # 0x362e
movl $0x64, %edx
callq 0x1100
leaq 0x18f3(%rip), %rdi # 0x35ac
leaq 0x1591(%rip), %rsi # 0x3251
leaq 0x1967(%rip), %rcx # 0x362e
movl $0x65, %edx
callq 0x1100
nopl (%rax)
|
/authenticvision[P]libpaseto/test/test.c
|
GLOBAL__sub_I_BasicBlock.cpp
|
BasicBlock::const_iterator BasicBlock::getFirstInsertionPt() const {
const Instruction *FirstNonPHI = getFirstNonPHI();
if (!FirstNonPHI)
return end();
const_iterator InsertPt = FirstNonPHI->getIterator();
if (InsertPt->isEHPad()) ++InsertPt;
// Set the head-inclusive bit to indicate that this iterator includes
// any debug-info at the start of the block. This is a no-op unless the
// appropriate CMake flag is set.
InsertPt.setHeadBit(true);
return InsertPt;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x345401(%rip), %rax # 0x399b26
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movq $0x8c, 0x8(%r14)
movb $0x1, %al
leaq 0xc(%rsp), %r13
movb %al, (%r13)
leaq 0x10(%rsp), %r15
movq %r13, (%r15)
leaq 0x4dbc19(%rip), %r12 # 0x530368
leaq 0x33c0e4(%rip), %rsi # 0x39083a
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x30c292
leaq 0xa6ad(%rip), %rdi # 0x5ee18
leaq 0x486bde(%rip), %rbx # 0x4db350
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3c290
movl $0x1, %ebp
movl %ebp, (%r15)
leaq 0x345447(%rip), %rax # 0x399bd3
movq %rax, (%r14)
movq $0x10a, 0x8(%r14) # imm = 0x10A
leaq 0x4dbc8a(%rip), %r14 # 0x530428
leaq 0x34540e(%rip), %rsi # 0x399bb3
leaq 0x10(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
callq 0x30c340
leaq 0x14678(%rip), %rdi # 0x68e3c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3c290
movl %ebp, (%r13)
leaq 0x4dbd0e(%rip), %rax # 0x5304e8
movq %rax, (%r12)
leaq 0xb(%rsp), %rax
movb $0x1, %cl
movb %cl, (%rax)
movq %rax, (%r15)
leaq 0x4dbcff(%rip), %r14 # 0x5304f0
leaq 0x3454e6(%rip), %rsi # 0x399cde
leaq 0xc(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %r14, %rdi
callq 0x30c3f2
leaq 0x7b2e(%rip), %rdi # 0x5c344
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3c290
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/IR/BasicBlock.cpp
|
llvm::DenseMapBase<llvm::DenseMap<void const*, clang::ento::CheckerBase*, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseMapPair<void const*, clang::ento::CheckerBase*>>, void const*, clang::ento::CheckerBase*, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseMapPair<void const*, clang::ento::CheckerBase*>>::FindAndConstruct(void const* const&)
|
value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x5628a
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x56280
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x5631c
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/ADT/DenseMap.h
|
clang::ento::CheckerContext::generateSink(llvm::IntrusiveRefCntPtr<clang::ento::ProgramState const>, clang::ento::ExplodedNode*, clang::ProgramPointTag const*)
|
ExplodedNode *generateSink(ProgramStateRef State, ExplodedNode *Pred,
const ProgramPointTag *Tag = nullptr) {
return addTransitionImpl(State ? State : getState(), true, Pred, Tag);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
addq $0x38, %rax
cmpq $0x0, (%rsi)
cmovneq %rsi, %rax
movq %rdx, %r15
movq (%rax), %rdi
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x56b0a
callq 0x2784c7
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
movq %r15, %rcx
movq %rbx, %r8
callq 0x56b44
movq %rax, %rbx
movq (%r12), %rdi
testq %rdi, %rdi
je 0x56b34
callq 0x2784cb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
|
llvm::raw_ostream::copy_to_buffer(char const*, unsigned long)
|
void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!");
// Handle short strings specially, memcpy isn't very good at very short
// strings.
switch (Size) {
case 4: OutBufCur[3] = Ptr[3]; [[fallthrough]];
case 3: OutBufCur[2] = Ptr[2]; [[fallthrough]];
case 2: OutBufCur[1] = Ptr[1]; [[fallthrough]];
case 1: OutBufCur[0] = Ptr[0]; [[fallthrough]];
case 0: break;
default:
memcpy(OutBufCur, Ptr, Size);
break;
}
OutBufCur += Size;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpq $0x4, %rdx
ja 0x583c8
leaq 0x2c9fef(%rip), %rax # 0x32237c
movslq (%rax,%rbx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb 0x3(%rsi), %al
movq 0x20(%r14), %rcx
movb %al, 0x3(%rcx)
movb 0x2(%rsi), %al
movq 0x20(%r14), %rcx
movb %al, 0x2(%rcx)
movb 0x1(%rsi), %al
movq 0x20(%r14), %rcx
movb %al, 0x1(%rcx)
movb (%rsi), %al
movq 0x20(%r14), %rcx
movb %al, (%rcx)
addq %rbx, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x20(%r14), %rdi
movq %rbx, %rdx
callq 0x3c370
jmp 0x583bc
|
/Support/raw_ostream.cpp
|
llvm::raw_fd_ostream::write_impl(char const*, unsigned long)
|
void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
if (TiedStream)
TiedStream->flush();
assert(FD >= 0 && "File already closed.");
pos += Size;
#if defined(_WIN32)
// If this is a Windows console device, try re-encoding from UTF-8 to UTF-16
// and using WriteConsoleW. If that fails, fall back to plain write().
if (IsWindowsConsole)
if (write_console_impl(FD, StringRef(Ptr, Size)))
return;
#endif
// The maximum write size is limited to INT32_MAX. A write
// greater than SSIZE_MAX is implementation-defined in POSIX,
// and Windows _write requires 32 bit input.
size_t MaxWriteSize = INT32_MAX;
#if defined(__linux__)
// It is observed that Linux returns EINVAL for a very large write (>2G).
// Make it a reasonably small value.
MaxWriteSize = 1024 * 1024 * 1024;
#endif
do {
size_t ChunkSize = std::min(Size, MaxWriteSize);
ssize_t ret = ::write(FD, Ptr, ChunkSize);
if (ret < 0) {
// If it's a recoverable error, swallow it and retry the write.
//
// Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since
// raw_ostream isn't designed to do non-blocking I/O. However, some
// programs, such as old versions of bjam, have mistakenly used
// O_NONBLOCK. For compatibility, emulate blocking semantics by
// spinning until the write succeeds. If you don't want spinning,
// don't use O_NONBLOCK file descriptors with raw_ostream.
if (errno == EINTR || errno == EAGAIN
#ifdef EWOULDBLOCK
|| errno == EWOULDBLOCK
#endif
)
continue;
#ifdef _WIN32
// Windows equivalents of SIGPIPE/EPIPE.
DWORD WinLastError = GetLastError();
if (WinLastError == ERROR_BROKEN_PIPE ||
(WinLastError == ERROR_NO_DATA && errno == EINVAL)) {
llvm::sys::CallOneShotPipeSignalHandler();
errno = EPIPE;
}
#endif
// Otherwise it's a non-recoverable error. Note it and quit.
error_detected(errnoAsErrorCode());
break;
}
// The write may have written some or all of the data. Update the
// size and buffer pointer to reflect the remainder that needs
// to be written. If there are no bytes left, we're done.
Ptr += ret;
Size -= ret;
} while (Size > 0);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x5899f
movq 0x10(%rdi), %rsi
movq 0x20(%rdi), %rdx
subq %rsi, %rdx
je 0x5899f
movq %rsi, 0x20(%rdi)
movq (%rdi), %rax
callq *0x48(%rax)
addq %rbx, 0x58(%r15)
movl $0x40000000, %r12d # imm = 0x40000000
cmpq %r12, %rbx
movl $0x40000000, %edx # imm = 0x40000000
cmovbq %rbx, %rdx
movl 0x30(%r15), %edi
movq %r14, %rsi
callq 0x3c620
testq %rax, %rax
js 0x589d9
addq %rax, %r14
subq %rax, %rbx
xorl %eax, %eax
testb %al, %al
jne 0x589fd
testq %rbx, %rbx
jne 0x589a9
jmp 0x589fd
callq 0x3c650
movl (%rax), %ebp
xorl %eax, %eax
cmpl $0x4, %ebp
je 0x589ce
cmpl $0xb, %ebp
je 0x589ce
callq 0x3c260
movl %ebp, 0x48(%r15)
movq %rax, 0x50(%r15)
movb $0x1, %al
jmp 0x589ce
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/Support/raw_ostream.cpp
|
llvm::raw_fd_ostream::preferred_buffer_size() const
|
size_t raw_fd_ostream::preferred_buffer_size() const {
#if defined(_WIN32)
// Disable buffering for console devices. Console output is re-encoded from
// UTF-8 to UTF-16 on Windows, and buffering it would require us to split the
// buffer on a valid UTF-8 codepoint boundary. Terminal buffering is disabled
// below on most other OSs, so do the same thing on Windows and avoid that
// complexity.
if (IsWindowsConsole)
return 0;
return raw_ostream::preferred_buffer_size();
#else
assert(FD >= 0 && "File not yet open!");
struct stat statbuf;
if (fstat(FD, &statbuf) != 0)
return 0;
// If this is a terminal, don't use buffering. Line buffering
// would be a more traditional thing to do, but it's not worth
// the complexity.
if (S_ISCHR(statbuf.st_mode) && is_displayed())
return 0;
// Return the preferred block size.
return statbuf.st_blksize;
#endif
}
|
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl 0x30(%rdi), %edi
movq %rsp, %rsi
callq 0x3c280
testl %eax, %eax
je 0x58ad4
xorl %eax, %eax
jmp 0x58af6
movl $0xf000, %eax # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x2000, %eax # imm = 0x2000
jne 0x58af1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
testb %al, %al
jne 0x58ad0
movq 0x38(%rsp), %rax
addq $0x90, %rsp
popq %rbx
retq
nop
|
/Support/raw_ostream.cpp
|
llvm::hashing::detail::hash_state::mix(char const*)
|
void mix(const char *s) {
h0 = llvm::rotr<uint64_t>(h0 + h1 + h3 + fetch64(s + 8), 37) * k1;
h1 = llvm::rotr<uint64_t>(h1 + h4 + fetch64(s + 48), 42) * k1;
h0 ^= h6;
h1 += h3 + fetch64(s + 40);
h2 = llvm::rotr<uint64_t>(h2 + h5, 33) * k1;
h3 = h4 * k1;
h4 = h0 + h5;
mix_32_bytes(s, h3, h4);
h5 = h2 + h6;
h6 = h1 + fetch64(s + 16);
mix_32_bytes(s + 32, h5, h6);
std::swap(h2, h0);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x18(%rbx), %r8
movq (%rbx), %rax
addq %rdi, %rax
leaq 0x18(%rbx), %rsi
addq %r8, %rax
addq 0x8(%r14), %rax
rolq $0x1b, %rax
movabsq $-0x4b6d499041670d8d, %rcx # imm = 0xB492B66FBE98F273
imulq %rcx, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rdx
movq 0x20(%rbx), %r9
addq %r9, %rdi
addq 0x30(%r14), %rdi
rolq $0x16, %rdi
imulq %rcx, %rdi
movq %rdi, 0x8(%rbx)
leaq 0x30(%rbx), %r15
xorq 0x30(%rbx), %rax
movq %rax, (%rbx)
addq %r8, %rdi
addq 0x28(%r14), %rdi
movq %rdi, 0x8(%rbx)
leaq 0x28(%rbx), %r12
movq 0x28(%rbx), %rdi
movq 0x10(%rbx), %r8
addq %rdi, %r8
rolq $0x1f, %r8
imulq %rcx, %r8
movq %r8, 0x10(%rbx)
imulq %rcx, %r9
movq %r9, 0x18(%rbx)
addq %rdi, %rax
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0x5baba
movq 0x30(%rbx), %rax
addq 0x10(%rbx), %rax
movq %rax, 0x28(%rbx)
movq 0x10(%r14), %rax
addq 0x8(%rbx), %rax
movq %rax, 0x30(%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x5baba
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rax, 0x10(%rbx)
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/Hashing.h
|
llvm::cl::basic_parser_impl::getOptionWidth(llvm::cl::Option const&) const
|
size_t basic_parser_impl::getOptionWidth(const Option &O) const {
size_t Len = argPlusPrefixesSize(O.ArgStr);
auto ValName = getValueName();
if (!ValName.empty()) {
size_t FormattingLen = 3;
if (O.getMiscFlags() & PositionalEatsArgs)
FormattingLen = 6;
Len += getValueStr(O, ValName).size() + FormattingLen;
}
return Len;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x18(%rsi), %rax
leaq 0x7(%rax), %rcx
cmpq $0x1, %rax
movl $0x7, %ebx
cmovneq %rcx, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testq %rdx, %rdx
je 0x5c7eb
movb 0xb(%r14), %al
andb $0x4, %al
shrb $0x2, %al
movzbl %al, %eax
leaq (%rax,%rax,2), %rax
addq %rbx, %rax
movq 0x38(%r14), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rdx
leaq (%rdx,%rax), %rbx
addq $0x3, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/Support/CommandLine.cpp
|
llvm::cl::opt<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, false, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef)
|
bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this->setPosition(pos);
Callback(Val);
return false;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
addq $0xd0, %rdi
leaq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rsi
callq 0x5c5f6
movl %eax, %ebp
testb %al, %al
jne 0x5cd27
leaq 0x80(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3c340
movw %r14w, 0xc(%rbx)
cmpq $0x0, 0xe8(%rbx)
je 0x5cd4b
leaq 0xd8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq *0xf0(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5cd3e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3c080
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3c310
|
/llvm/Support/CommandLine.h
|
llvm::cl::parser<unsigned long>::parse(llvm::cl::Option&, llvm::StringRef, llvm::StringRef, unsigned long&)
|
bool parser<unsigned long>::parse(Option &O, StringRef ArgName, StringRef Arg,
unsigned long &Value) {
if (Arg.getAsInteger(0, Value))
return O.error("'" + Arg + "' value invalid for ulong argument!");
return false;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rsi, %r14
leaq 0x8(%rsp), %rcx
movq %r8, %rdi
movq %r9, %rsi
xorl %edx, %edx
callq 0x65d05
movl %eax, %ebx
testb %al, %al
je 0x5dbb0
leaq 0x30(%rsp), %rax
movw $0x503, 0x20(%rax) # imm = 0x503
leaq 0x2c533f(%rip), %rcx # 0x322eb1
movq %rcx, (%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x2c515d(%rip), %rax # 0x322ce9
movq %rax, 0x10(%r15)
movw $0x302, 0x20(%r15) # imm = 0x302
callq 0x58b65
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x5d4fa
jmp 0x5dbc0
movq 0x80(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/Support/CommandLine.cpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.