idx int64 0 2.11M | name stringlengths 1 118k | code stringlengths 6 516k | asm stringlengths 21 4.64M | file stringlengths 39 143 | opt stringclasses 1 value | path stringlengths 20 133 |
|---|---|---|---|---|---|---|
11,800 | (anonymous namespace)::XmlTestReporterFixtureSingleSuccessfulTestReportSummaryFormatHelper::~XmlTestReporterFixtureSingleSuccessfulTestReportSummaryFormatHelper() | TEST_FIXTURE(XmlTestReporterFixture, SingleSuccessfulTestReportSummaryFormat)
{
TestDetails const details("TestName", "DefaultSuite", "", 0);
reporter.ReportTestStart(details);
reporter.ReportSummary(1, 0, 0, 0.1f);
const char *expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"0\" failures=\"0\" time=\"0.1\">"
"<test suite=\"DefaultSuite\" name=\"TestName\" time=\"0\"/>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x56600
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,801 | (anonymous namespace)::XmlTestReporterFixtureSingleSuccessfulTestReportSummaryFormatHelper::RunImpl() | TEST_FIXTURE(XmlTestReporterFixture, SingleSuccessfulTestReportSummaryFormat)
{
TestDetails const details("TestName", "DefaultSuite", "", 0);
reporter.ReportTestStart(details);
reporter.ReportSummary(1, 0, 0, 0.1f);
const char *expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"0\" failures=\"0\" time=\"0.1\">"
"<test suite=\"DefaultSuite\" name=\"TestName\" time=\"0\"/>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x28(%rbp), %rdi
leaq 0xba0a(%rip), %rsi # 0x63d0f
leaq 0xf420(%rip), %rdx # 0x6772c
leaq 0x11b45(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
callq 0x5d780
movq -0xa8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
callq 0x5b080
movq -0xa8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
movl $0x1, %esi
xorl %ecx, %ecx
movss 0xa681(%rip), %xmm0 # 0x629d0
movl %ecx, %edx
callq 0x5e1b0
leaq 0x110b0(%rip), %rax # 0x6940d
movq %rax, -0x30(%rbp)
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x5836f
movq -0xa8(%rbp), %rsi
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x15280
jmp 0x58392
callq 0x5b070
movq %rax, -0xc0(%rbp)
jmp 0x583a0
movq -0xc0(%rbp), %rax
movq (%rax), %rsi
leaq -0x80(%rbp), %rdi
movl $0x5d, %edx
callq 0x5d7c0
jmp 0x583ba
movq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x373d0
jmp 0x583d4
leaq -0x60(%rbp), %rdi
callq 0x15150
jmp 0x58479
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x58405
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x15150
movq -0x38(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xc8(%rbp)
jmp 0x5841c
movq -0xc8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
callq 0x5b070
movq %rax, -0xd0(%rbp)
jmp 0x5843b
movq -0xd0(%rbp), %rax
movq (%rax), %rsi
leaq -0xa0(%rbp), %rdi
movl $0x5d, %edx
callq 0x5d7c0
jmp 0x58458
movq -0xd8(%rbp), %rdi
leaq 0x10e18(%rip), %rdx # 0x6927e
leaq -0xa0(%rbp), %rsi
callq 0x5d9a0
jmp 0x58474
callq 0x153e0
jmp 0x5847b
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x153e0
jmp 0x58497
jmp 0x58499
movq -0x38(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,802 | (anonymous namespace)::TestXmlTestReporterFixtureSingleFailedTestReportSummaryFormat::~TestXmlTestReporterFixtureSingleFailedTestReportSummaryFormat() | TEST_FIXTURE(XmlTestReporterFixture, SingleFailedTestReportSummaryFormat)
{
TestDetails const details("A Test", "suite", "A File", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "A Failure");
reporter.ReportSummary(1, 1, 1, 0.1f);
const char *expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"1\" time=\"0.1\">"
"<test suite=\"suite\" name=\"A Test\" time=\"0\">"
"<failure message=\"A File(4321) : A Failure\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x55a20
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,803 | (anonymous namespace)::TestXmlTestReporterFixtureSingleFailedTestReportSummaryFormat::RunImpl() const | TEST_FIXTURE(XmlTestReporterFixture, SingleFailedTestReportSummaryFormat)
{
TestDetails const details("A Test", "suite", "A File", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "A Failure");
reporter.ReportSummary(1, 1, 1, 0.1f);
const char *expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"1\" time=\"0.1\">"
"<test suite=\"suite\" name=\"A Test\" time=\"0\">"
"<failure message=\"A File(4321) : A Failure\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x3d8(%rbp)
movb $0x0, -0x9(%rbp)
addq $0x8, %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x588b0
jmp 0x58510
movq -0x3d8(%rbp), %rsi
movb $0x1, -0x9(%rbp)
addq $0x8, %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x588f0
jmp 0x5852d
leaq -0x1b8(%rbp), %rdi
callq 0x58c60
jmp 0x58658
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x58570
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x58c60
movl -0x1c4(%rbp), %eax
movl %eax, -0x3dc(%rbp)
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0x58661
movq -0x1c0(%rbp), %rdi
callq 0x150d0
movq %rax, -0x3b0(%rbp)
callq 0x5b060
movq %rax, -0x3e8(%rbp)
jmp 0x585aa
movq -0x3d8(%rbp), %rax
movq -0x3e8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x408(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x400(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x3f8(%rbp)
movq -0x3b0(%rbp), %rdi
callq 0x5adc0
movq %rax, -0x3f0(%rbp)
jmp 0x585ed
movq -0x3b0(%rbp), %rdi
callq 0x5ade0
movl %eax, -0x40c(%rbp)
jmp 0x58601
movl -0x40c(%rbp), %r8d
movq -0x3f0(%rbp), %rcx
movq -0x400(%rbp), %rdx
movq -0x3f8(%rbp), %rsi
leaq -0x3d0(%rbp), %rdi
callq 0x5d780
jmp 0x5862b
movq -0x3b0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x408(%rbp), %rdi
movq %rax, %rdx
leaq -0x3d0(%rbp), %rsi
callq 0x5d9a0
jmp 0x58653
callq 0x153e0
addq $0x460, %rsp # imm = 0x460
popq %rbp
retq
movl -0x3dc(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x5874a
movq -0x1c0(%rbp), %rdi
callq 0x150d0
movq %rax, -0x210(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x1ab50
jmp 0x58695
leaq 0xb657(%rip), %rsi # 0x63cf3
leaq -0x3a8(%rbp), %rdi
callq 0x15250
movq %rax, -0x418(%rbp)
jmp 0x586b1
movq -0x210(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x418(%rbp), %rdi
movq %rax, %rsi
callq 0x15250
jmp 0x586d2
callq 0x5b060
movq %rax, -0x420(%rbp)
jmp 0x586e0
movq -0x3d8(%rbp), %rax
movq -0x420(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x438(%rbp)
addq $0x8, %rax
movq %rax, -0x430(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x428(%rbp)
jmp 0x58718
movq -0x428(%rbp), %rdx
movq -0x430(%rbp), %rsi
movq -0x438(%rbp), %rdi
callq 0x5d9a0
jmp 0x58734
leaq -0x3a8(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x58658
movq -0x1c0(%rbp), %rdi
callq 0x150d0
testb $0x1, -0x9(%rbp)
je 0x587d0
callq 0x5b060
movq %rax, -0x440(%rbp)
jmp 0x5876a
movq -0x3d8(%rbp), %rsi
movq -0x440(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x448(%rbp)
addq $0x8, %rsi
leaq -0x1e8(%rbp), %rdi
movl $0x60, %edx
callq 0x5d7c0
jmp 0x58799
movq -0x448(%rbp), %rdi
leaq 0x10945(%rip), %rdx # 0x690ec
leaq -0x1e8(%rbp), %rsi
callq 0x5d9a0
jmp 0x587b5
jmp 0x5882b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
callq 0x153e0
jmp 0x58835
callq 0x5b060
movq %rax, -0x450(%rbp)
jmp 0x587de
movq -0x3d8(%rbp), %rsi
movq -0x450(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x458(%rbp)
addq $0x8, %rsi
leaq -0x208(%rbp), %rdi
movl $0x60, %edx
callq 0x5d7c0
jmp 0x5880d
movq -0x458(%rbp), %rdi
leaq 0x10915(%rip), %rdx # 0x69130
leaq -0x208(%rbp), %rsi
callq 0x5d9a0
jmp 0x58829
jmp 0x5882b
callq 0x153e0
jmp 0x58658
jmp 0x5888d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x58869
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x58870
jmp 0x5888d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
callq 0x153e0
jmp 0x5888b
jmp 0x5888d
movq -0x1c0(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,804 | (anonymous namespace)::XmlTestReporterFixtureSingleFailedTestReportSummaryFormatHelper::XmlTestReporterFixtureSingleFailedTestReportSummaryFormatHelper(UnitTest::TestDetails const&) | TEST_FIXTURE(XmlTestReporterFixture, SingleFailedTestReportSummaryFormat)
{
TestDetails const details("A Test", "suite", "A File", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "A Failure");
reporter.ReportSummary(1, 1, 1, 0.1f);
const char *expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"1\" time=\"0.1\">"
"<test suite=\"suite\" name=\"A Test\" time=\"0\">"
"<failure message=\"A File(4321) : A Failure\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x56390
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x1a0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,805 | void UnitTest::ExecuteTest<(anonymous namespace)::XmlTestReporterFixtureSingleFailedTestReportSummaryFormatHelper>((anonymous namespace)::XmlTestReporterFixtureSingleFailedTestReportSummaryFormatHelper&, UnitTest::TestDetails const&) | void ExecuteTest(T& testObject, TestDetails const& details)
{
CurrentTest::Details() = &details;
try
{
#ifdef UNITTEST_POSIX
UNITTEST_THROW_SIGNALS
#endif
testObject.RunImpl();
}
catch (AssertException const& e)
{
CurrentTest::Results()->OnTestFailure(
TestDetails(details.testName, details.suiteName, e.Filename(), e.LineNumber()), e.what());
}
catch (std::exception const& e)
{
MemoryOutStream stream;
stream << "Unhandled exception: " << e.what();
CurrentTest::Results()->OnTestFailure(details, stream.GetText());
}
catch (...)
{
CurrentTest::Results()->OnTestFailure(details, "Unhandled exception: Crash!");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x6c0, %rsp # imm = 0x6C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x650(%rbp)
callq 0x5b070
movq -0x650(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x470(%rbp), %rdi
callq 0x5ed70
jmp 0x5892b
leaq 0x307d6(%rip), %rax # 0x89108
movq (%rax), %rdi
movl $0x1, %esi
callq 0x15390
cmpl $0x0, %eax
je 0x58bb5
movl $0x8, %edi
callq 0x15110
movq %rax, %rdi
leaq 0xb401(%rip), %rax # 0x63d5d
movq %rax, (%rdi)
movq 0x2d65a(%rip), %rsi # 0x85fc0
xorl %eax, %eax
movl %eax, %edx
callq 0x15400
jmp 0x58c56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
jmp 0x589a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x470(%rbp), %rdi
callq 0x5ee90
movl -0x47c(%rbp), %eax
movl %eax, -0x654(%rbp)
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0x58a93
movq -0x478(%rbp), %rdi
callq 0x150d0
movq %rax, -0x628(%rbp)
callq 0x5b060
movq %rax, -0x660(%rbp)
jmp 0x589e0
movq -0x660(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x680(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x678(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x670(%rbp)
movq -0x628(%rbp), %rdi
callq 0x5adc0
movq %rax, -0x668(%rbp)
jmp 0x58a1f
movq -0x628(%rbp), %rdi
callq 0x5ade0
movl %eax, -0x684(%rbp)
jmp 0x58a33
movl -0x684(%rbp), %r8d
movq -0x668(%rbp), %rcx
movq -0x678(%rbp), %rdx
movq -0x670(%rbp), %rsi
leaq -0x648(%rbp), %rdi
callq 0x5d780
jmp 0x58a5d
movq -0x628(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x680(%rbp), %rdi
movq %rax, %rdx
leaq -0x648(%rbp), %rsi
callq 0x5d9a0
jmp 0x58a85
callq 0x153e0
addq $0x6c0, %rsp # imm = 0x6C0
popq %rbp
retq
movl -0x654(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x58b75
movq -0x478(%rbp), %rdi
callq 0x150d0
movq %rax, -0x488(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x1ab50
jmp 0x58ac7
leaq 0xb225(%rip), %rsi # 0x63cf3
leaq -0x620(%rbp), %rdi
callq 0x15250
movq %rax, -0x690(%rbp)
jmp 0x58ae3
movq -0x488(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x690(%rbp), %rdi
movq %rax, %rsi
callq 0x15250
jmp 0x58b04
callq 0x5b060
movq %rax, -0x698(%rbp)
jmp 0x58b12
movq -0x698(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x6b0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x6a8(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x6a0(%rbp)
jmp 0x58b43
movq -0x6a0(%rbp), %rdx
movq -0x6a8(%rbp), %rsi
movq -0x6b0(%rbp), %rdi
callq 0x5d9a0
jmp 0x58b5f
leaq -0x620(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x58a8a
movq -0x478(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x6b8(%rbp)
jmp 0x58b8f
movq -0x6b8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq 0xb1d4(%rip), %rdx # 0x63d78
callq 0x5d9a0
jmp 0x58bab
callq 0x153e0
jmp 0x58a8a
movq -0x8(%rbp), %rdi
callq 0x58c80
jmp 0x58bc0
leaq -0x470(%rbp), %rdi
callq 0x5ee90
jmp 0x58a8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
callq 0x153e0
jmp 0x58bea
jmp 0x58c42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
jmp 0x58c1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x58c25
jmp 0x58c42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
callq 0x153e0
jmp 0x58c40
jmp 0x58c42
movq -0x478(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../ExecuteTest.h |
11,806 | (anonymous namespace)::XmlTestReporterFixtureSingleFailedTestReportSummaryFormatHelper::~XmlTestReporterFixtureSingleFailedTestReportSummaryFormatHelper() | TEST_FIXTURE(XmlTestReporterFixture, SingleFailedTestReportSummaryFormat)
{
TestDetails const details("A Test", "suite", "A File", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "A Failure");
reporter.ReportSummary(1, 1, 1, 0.1f);
const char *expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"1\" time=\"0.1\">"
"<test suite=\"suite\" name=\"A Test\" time=\"0\">"
"<failure message=\"A File(4321) : A Failure\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x56600
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,807 | (anonymous namespace)::XmlTestReporterFixtureSingleFailedTestReportSummaryFormatHelper::RunImpl() | TEST_FIXTURE(XmlTestReporterFixture, SingleFailedTestReportSummaryFormat)
{
TestDetails const details("A Test", "suite", "A File", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "A Failure");
reporter.ReportSummary(1, 1, 1, 0.1f);
const char *expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"1\" time=\"0.1\">"
"<test suite=\"suite\" name=\"A Test\" time=\"0\">"
"<failure message=\"A File(4321) : A Failure\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x28(%rbp), %rdi
leaq 0x1082e(%rip), %rsi # 0x694d3
leaq 0xe46d(%rip), %rdx # 0x67119
leaq 0x10827(%rip), %rcx # 0x694da
movl $0x10e1, %r8d # imm = 0x10E1
callq 0x5d780
movq -0xa8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
callq 0x5b080
movq -0xa8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
leaq 0x107f3(%rip), %rdx # 0x694e1
callq 0x5b120
movq -0xa8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
movl $0x1, %ecx
movss 0x9cc2(%rip), %xmm0 # 0x629d0
movl %ecx, %esi
movl %ecx, %edx
callq 0x5e1b0
leaq 0x107cd(%rip), %rax # 0x694eb
movq %rax, -0x30(%rbp)
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x58d30
movq -0xa8(%rbp), %rsi
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x15280
jmp 0x58d53
callq 0x5b070
movq %rax, -0xc0(%rbp)
jmp 0x58d61
movq -0xc0(%rbp), %rax
movq (%rax), %rsi
leaq -0x80(%rbp), %rdi
movl $0x70, %edx
callq 0x5d7c0
jmp 0x58d7b
movq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x373d0
jmp 0x58d95
leaq -0x60(%rbp), %rdi
callq 0x15150
jmp 0x58e3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x58dc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x15150
movq -0x38(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xc8(%rbp)
jmp 0x58ddd
movq -0xc8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
callq 0x5b070
movq %rax, -0xd0(%rbp)
jmp 0x58dfc
movq -0xd0(%rbp), %rax
movq (%rax), %rsi
leaq -0xa0(%rbp), %rdi
movl $0x70, %edx
callq 0x5d7c0
jmp 0x58e19
movq -0xd8(%rbp), %rdi
leaq 0x10457(%rip), %rdx # 0x6927e
leaq -0xa0(%rbp), %rsi
callq 0x5d9a0
jmp 0x58e35
callq 0x153e0
jmp 0x58e3c
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x153e0
jmp 0x58e58
jmp 0x58e5a
movq -0x38(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,808 | (anonymous namespace)::TestXmlTestReporterFixtureFailureMessageIsXMLEscaped::~TestXmlTestReporterFixtureFailureMessageIsXMLEscaped() | TEST_FIXTURE(XmlTestReporterFixture, FailureMessageIsXMLEscaped)
{
TestDetails const details("TestName", "suite", "filename.h", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "\"\'&<>");
reporter.ReportTestFinish(details, 0.1f);
reporter.ReportSummary(1, 1, 1, 0.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"1\" time=\"0.1\">"
"<test suite=\"suite\" name=\"TestName\" time=\"0.1\">"
"<failure message=\"filename.h(4321) : "'&<>\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x55aa0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,809 | (anonymous namespace)::TestXmlTestReporterFixtureFailureMessageIsXMLEscaped::RunImpl() const | TEST_FIXTURE(XmlTestReporterFixture, FailureMessageIsXMLEscaped)
{
TestDetails const details("TestName", "suite", "filename.h", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "\"\'&<>");
reporter.ReportTestFinish(details, 0.1f);
reporter.ReportSummary(1, 1, 1, 0.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"1\" time=\"0.1\">"
"<test suite=\"suite\" name=\"TestName\" time=\"0.1\">"
"<failure message=\"filename.h(4321) : "'&<>\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x3d8(%rbp)
movb $0x0, -0x9(%rbp)
addq $0x8, %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x59270
jmp 0x58ed0
movq -0x3d8(%rbp), %rsi
movb $0x1, -0x9(%rbp)
addq $0x8, %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x592b0
jmp 0x58eed
leaq -0x1b8(%rbp), %rdi
callq 0x59620
jmp 0x59018
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x58f30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x59620
movl -0x1c4(%rbp), %eax
movl %eax, -0x3dc(%rbp)
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0x59021
movq -0x1c0(%rbp), %rdi
callq 0x150d0
movq %rax, -0x3b0(%rbp)
callq 0x5b060
movq %rax, -0x3e8(%rbp)
jmp 0x58f6a
movq -0x3d8(%rbp), %rax
movq -0x3e8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x408(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x400(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x3f8(%rbp)
movq -0x3b0(%rbp), %rdi
callq 0x5adc0
movq %rax, -0x3f0(%rbp)
jmp 0x58fad
movq -0x3b0(%rbp), %rdi
callq 0x5ade0
movl %eax, -0x40c(%rbp)
jmp 0x58fc1
movl -0x40c(%rbp), %r8d
movq -0x3f0(%rbp), %rcx
movq -0x400(%rbp), %rdx
movq -0x3f8(%rbp), %rsi
leaq -0x3d0(%rbp), %rdi
callq 0x5d780
jmp 0x58feb
movq -0x3b0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x408(%rbp), %rdi
movq %rax, %rdx
leaq -0x3d0(%rbp), %rsi
callq 0x5d9a0
jmp 0x59013
callq 0x153e0
addq $0x460, %rsp # imm = 0x460
popq %rbp
retq
movl -0x3dc(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x5910a
movq -0x1c0(%rbp), %rdi
callq 0x150d0
movq %rax, -0x210(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x1ab50
jmp 0x59055
leaq 0xac97(%rip), %rsi # 0x63cf3
leaq -0x3a8(%rbp), %rdi
callq 0x15250
movq %rax, -0x418(%rbp)
jmp 0x59071
movq -0x210(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x418(%rbp), %rdi
movq %rax, %rsi
callq 0x15250
jmp 0x59092
callq 0x5b060
movq %rax, -0x420(%rbp)
jmp 0x590a0
movq -0x3d8(%rbp), %rax
movq -0x420(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x438(%rbp)
addq $0x8, %rax
movq %rax, -0x430(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x428(%rbp)
jmp 0x590d8
movq -0x428(%rbp), %rdx
movq -0x430(%rbp), %rsi
movq -0x438(%rbp), %rdi
callq 0x5d9a0
jmp 0x590f4
leaq -0x3a8(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x59018
movq -0x1c0(%rbp), %rdi
callq 0x150d0
testb $0x1, -0x9(%rbp)
je 0x59190
callq 0x5b060
movq %rax, -0x440(%rbp)
jmp 0x5912a
movq -0x3d8(%rbp), %rsi
movq -0x440(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x448(%rbp)
addq $0x8, %rsi
leaq -0x1e8(%rbp), %rdi
movl $0x73, %edx
callq 0x5d7c0
jmp 0x59159
movq -0x448(%rbp), %rdi
leaq 0xff85(%rip), %rdx # 0x690ec
leaq -0x1e8(%rbp), %rsi
callq 0x5d9a0
jmp 0x59175
jmp 0x591eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
callq 0x153e0
jmp 0x591f5
callq 0x5b060
movq %rax, -0x450(%rbp)
jmp 0x5919e
movq -0x3d8(%rbp), %rsi
movq -0x450(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x458(%rbp)
addq $0x8, %rsi
leaq -0x208(%rbp), %rdi
movl $0x73, %edx
callq 0x5d7c0
jmp 0x591cd
movq -0x458(%rbp), %rdi
leaq 0xff55(%rip), %rdx # 0x69130
leaq -0x208(%rbp), %rsi
callq 0x5d9a0
jmp 0x591e9
jmp 0x591eb
callq 0x153e0
jmp 0x59018
jmp 0x5924d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x59229
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x59230
jmp 0x5924d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
callq 0x153e0
jmp 0x5924b
jmp 0x5924d
movq -0x1c0(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,810 | (anonymous namespace)::XmlTestReporterFixtureFailureMessageIsXMLEscapedHelper::XmlTestReporterFixtureFailureMessageIsXMLEscapedHelper(UnitTest::TestDetails const&) | TEST_FIXTURE(XmlTestReporterFixture, FailureMessageIsXMLEscaped)
{
TestDetails const details("TestName", "suite", "filename.h", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "\"\'&<>");
reporter.ReportTestFinish(details, 0.1f);
reporter.ReportSummary(1, 1, 1, 0.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"1\" time=\"0.1\">"
"<test suite=\"suite\" name=\"TestName\" time=\"0.1\">"
"<failure message=\"filename.h(4321) : "'&<>\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x56390
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x1a0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,811 | void UnitTest::ExecuteTest<(anonymous namespace)::XmlTestReporterFixtureFailureMessageIsXMLEscapedHelper>((anonymous namespace)::XmlTestReporterFixtureFailureMessageIsXMLEscapedHelper&, UnitTest::TestDetails const&) | void ExecuteTest(T& testObject, TestDetails const& details)
{
CurrentTest::Details() = &details;
try
{
#ifdef UNITTEST_POSIX
UNITTEST_THROW_SIGNALS
#endif
testObject.RunImpl();
}
catch (AssertException const& e)
{
CurrentTest::Results()->OnTestFailure(
TestDetails(details.testName, details.suiteName, e.Filename(), e.LineNumber()), e.what());
}
catch (std::exception const& e)
{
MemoryOutStream stream;
stream << "Unhandled exception: " << e.what();
CurrentTest::Results()->OnTestFailure(details, stream.GetText());
}
catch (...)
{
CurrentTest::Results()->OnTestFailure(details, "Unhandled exception: Crash!");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x6c0, %rsp # imm = 0x6C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x650(%rbp)
callq 0x5b070
movq -0x650(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x470(%rbp), %rdi
callq 0x5ed70
jmp 0x592eb
leaq 0x2fe16(%rip), %rax # 0x89108
movq (%rax), %rdi
movl $0x1, %esi
callq 0x15390
cmpl $0x0, %eax
je 0x59575
movl $0x8, %edi
callq 0x15110
movq %rax, %rdi
leaq 0xaa41(%rip), %rax # 0x63d5d
movq %rax, (%rdi)
movq 0x2cc9a(%rip), %rsi # 0x85fc0
xorl %eax, %eax
movl %eax, %edx
callq 0x15400
jmp 0x59616
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
jmp 0x59366
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x470(%rbp), %rdi
callq 0x5ee90
movl -0x47c(%rbp), %eax
movl %eax, -0x654(%rbp)
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0x59453
movq -0x478(%rbp), %rdi
callq 0x150d0
movq %rax, -0x628(%rbp)
callq 0x5b060
movq %rax, -0x660(%rbp)
jmp 0x593a0
movq -0x660(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x680(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x678(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x670(%rbp)
movq -0x628(%rbp), %rdi
callq 0x5adc0
movq %rax, -0x668(%rbp)
jmp 0x593df
movq -0x628(%rbp), %rdi
callq 0x5ade0
movl %eax, -0x684(%rbp)
jmp 0x593f3
movl -0x684(%rbp), %r8d
movq -0x668(%rbp), %rcx
movq -0x678(%rbp), %rdx
movq -0x670(%rbp), %rsi
leaq -0x648(%rbp), %rdi
callq 0x5d780
jmp 0x5941d
movq -0x628(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x680(%rbp), %rdi
movq %rax, %rdx
leaq -0x648(%rbp), %rsi
callq 0x5d9a0
jmp 0x59445
callq 0x153e0
addq $0x6c0, %rsp # imm = 0x6C0
popq %rbp
retq
movl -0x654(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x59535
movq -0x478(%rbp), %rdi
callq 0x150d0
movq %rax, -0x488(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x1ab50
jmp 0x59487
leaq 0xa865(%rip), %rsi # 0x63cf3
leaq -0x620(%rbp), %rdi
callq 0x15250
movq %rax, -0x690(%rbp)
jmp 0x594a3
movq -0x488(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x690(%rbp), %rdi
movq %rax, %rsi
callq 0x15250
jmp 0x594c4
callq 0x5b060
movq %rax, -0x698(%rbp)
jmp 0x594d2
movq -0x698(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x6b0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x6a8(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x6a0(%rbp)
jmp 0x59503
movq -0x6a0(%rbp), %rdx
movq -0x6a8(%rbp), %rsi
movq -0x6b0(%rbp), %rdi
callq 0x5d9a0
jmp 0x5951f
leaq -0x620(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x5944a
movq -0x478(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x6b8(%rbp)
jmp 0x5954f
movq -0x6b8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq 0xa814(%rip), %rdx # 0x63d78
callq 0x5d9a0
jmp 0x5956b
callq 0x153e0
jmp 0x5944a
movq -0x8(%rbp), %rdi
callq 0x59640
jmp 0x59580
leaq -0x470(%rbp), %rdi
callq 0x5ee90
jmp 0x5944a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
callq 0x153e0
jmp 0x595aa
jmp 0x59602
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
jmp 0x595de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x595e5
jmp 0x59602
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
callq 0x153e0
jmp 0x59600
jmp 0x59602
movq -0x478(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../ExecuteTest.h |
11,812 | (anonymous namespace)::XmlTestReporterFixtureFailureMessageIsXMLEscapedHelper::~XmlTestReporterFixtureFailureMessageIsXMLEscapedHelper() | TEST_FIXTURE(XmlTestReporterFixture, FailureMessageIsXMLEscaped)
{
TestDetails const details("TestName", "suite", "filename.h", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "\"\'&<>");
reporter.ReportTestFinish(details, 0.1f);
reporter.ReportSummary(1, 1, 1, 0.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"1\" time=\"0.1\">"
"<test suite=\"suite\" name=\"TestName\" time=\"0.1\">"
"<failure message=\"filename.h(4321) : "'&<>\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x56600
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,813 | (anonymous namespace)::XmlTestReporterFixtureFailureMessageIsXMLEscapedHelper::RunImpl() | TEST_FIXTURE(XmlTestReporterFixture, FailureMessageIsXMLEscaped)
{
TestDetails const details("TestName", "suite", "filename.h", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "\"\'&<>");
reporter.ReportTestFinish(details, 0.1f);
reporter.ReportSummary(1, 1, 1, 0.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"1\" time=\"0.1\">"
"<test suite=\"suite\" name=\"TestName\" time=\"0.1\">"
"<failure message=\"filename.h(4321) : "'&<>\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x28(%rbp), %rdi
leaq 0xa6aa(%rip), %rsi # 0x63d0f
leaq 0xdaad(%rip), %rdx # 0x67119
leaq 0xa6b5(%rip), %rcx # 0x63d28
movl $0x10e1, %r8d # imm = 0x10E1
callq 0x5d780
movq -0xa8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
callq 0x5b080
movq -0xa8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
leaq 0xff24(%rip), %rdx # 0x695d2
callq 0x5b120
movq -0xa8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
movss 0x9303(%rip), %xmm0 # 0x629d0
callq 0x5b1d0
movq -0xa8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
movl $0x1, %ecx
movss 0x92e3(%rip), %xmm0 # 0x629d0
movl %ecx, %esi
movl %ecx, %edx
callq 0x5e1b0
leaq 0xfedb(%rip), %rax # 0x695d8
movq %rax, -0x30(%rbp)
callq 0x5b060
movq %rax, -0xb0(%rbp)
jmp 0x5970f
movq -0xa8(%rbp), %rsi
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x15280
jmp 0x59732
callq 0x5b070
movq %rax, -0xc0(%rbp)
jmp 0x59740
movq -0xc0(%rbp), %rax
movq (%rax), %rsi
leaq -0x80(%rbp), %rdi
movl $0x84, %edx
callq 0x5d7c0
jmp 0x5975a
movq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x373d0
jmp 0x59774
leaq -0x60(%rbp), %rdi
callq 0x15150
jmp 0x59819
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x597a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x15150
movq -0x38(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xc8(%rbp)
jmp 0x597bc
movq -0xc8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
callq 0x5b070
movq %rax, -0xd0(%rbp)
jmp 0x597db
movq -0xd0(%rbp), %rax
movq (%rax), %rsi
leaq -0xa0(%rbp), %rdi
movl $0x84, %edx
callq 0x5d7c0
jmp 0x597f8
movq -0xd8(%rbp), %rdi
leaq 0xfa78(%rip), %rdx # 0x6927e
leaq -0xa0(%rbp), %rsi
callq 0x5d9a0
jmp 0x59814
callq 0x153e0
jmp 0x5981b
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x153e0
jmp 0x59837
jmp 0x59839
movq -0x38(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,814 | (anonymous namespace)::TestXmlTestReporterFixtureOneFailureAndOneSuccess::~TestXmlTestReporterFixtureOneFailureAndOneSuccess() | TEST_FIXTURE(XmlTestReporterFixture, OneFailureAndOneSuccess)
{
TestDetails const failedDetails("FailedTest", "suite", "fail.h", 1);
reporter.ReportTestStart(failedDetails);
reporter.ReportFailure(failedDetails, "expected 1 but was 2");
reporter.ReportTestFinish(failedDetails, 0.1f);
TestDetails const succeededDetails("SucceededTest", "suite", "", 0);
reporter.ReportTestStart(succeededDetails);
reporter.ReportTestFinish(succeededDetails, 1.0f);
reporter.ReportSummary(2, 1, 1, 1.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"2\" failedtests=\"1\" failures=\"1\" time=\"1.1\">"
"<test suite=\"suite\" name=\"FailedTest\" time=\"0.1\">"
"<failure message=\"fail.h(1) : expected 1 but was 2\"/>"
"</test>"
"<test suite=\"suite\" name=\"SucceededTest\" time=\"1\"/>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x55b20
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,815 | (anonymous namespace)::TestXmlTestReporterFixtureOneFailureAndOneSuccess::RunImpl() const | TEST_FIXTURE(XmlTestReporterFixture, OneFailureAndOneSuccess)
{
TestDetails const failedDetails("FailedTest", "suite", "fail.h", 1);
reporter.ReportTestStart(failedDetails);
reporter.ReportFailure(failedDetails, "expected 1 but was 2");
reporter.ReportTestFinish(failedDetails, 0.1f);
TestDetails const succeededDetails("SucceededTest", "suite", "", 0);
reporter.ReportTestStart(succeededDetails);
reporter.ReportTestFinish(succeededDetails, 1.0f);
reporter.ReportSummary(2, 1, 1, 1.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"2\" failedtests=\"1\" failures=\"1\" time=\"1.1\">"
"<test suite=\"suite\" name=\"FailedTest\" time=\"0.1\">"
"<failure message=\"fail.h(1) : expected 1 but was 2\"/>"
"</test>"
"<test suite=\"suite\" name=\"SucceededTest\" time=\"1\"/>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x3d8(%rbp)
movb $0x0, -0x9(%rbp)
addq $0x8, %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x59c50
jmp 0x598b0
movq -0x3d8(%rbp), %rsi
movb $0x1, -0x9(%rbp)
addq $0x8, %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x59c90
jmp 0x598cd
leaq -0x1b8(%rbp), %rdi
callq 0x5a000
jmp 0x599f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x59910
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x5a000
movl -0x1c4(%rbp), %eax
movl %eax, -0x3dc(%rbp)
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0x59a01
movq -0x1c0(%rbp), %rdi
callq 0x150d0
movq %rax, -0x3b0(%rbp)
callq 0x5b060
movq %rax, -0x3e8(%rbp)
jmp 0x5994a
movq -0x3d8(%rbp), %rax
movq -0x3e8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x408(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x400(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x3f8(%rbp)
movq -0x3b0(%rbp), %rdi
callq 0x5adc0
movq %rax, -0x3f0(%rbp)
jmp 0x5998d
movq -0x3b0(%rbp), %rdi
callq 0x5ade0
movl %eax, -0x40c(%rbp)
jmp 0x599a1
movl -0x40c(%rbp), %r8d
movq -0x3f0(%rbp), %rcx
movq -0x400(%rbp), %rdx
movq -0x3f8(%rbp), %rsi
leaq -0x3d0(%rbp), %rdi
callq 0x5d780
jmp 0x599cb
movq -0x3b0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x408(%rbp), %rdi
movq %rax, %rdx
leaq -0x3d0(%rbp), %rsi
callq 0x5d9a0
jmp 0x599f3
callq 0x153e0
addq $0x460, %rsp # imm = 0x460
popq %rbp
retq
movl -0x3dc(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x59aea
movq -0x1c0(%rbp), %rdi
callq 0x150d0
movq %rax, -0x210(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x1ab50
jmp 0x59a35
leaq 0xa2b7(%rip), %rsi # 0x63cf3
leaq -0x3a8(%rbp), %rdi
callq 0x15250
movq %rax, -0x418(%rbp)
jmp 0x59a51
movq -0x210(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x418(%rbp), %rdi
movq %rax, %rsi
callq 0x15250
jmp 0x59a72
callq 0x5b060
movq %rax, -0x420(%rbp)
jmp 0x59a80
movq -0x3d8(%rbp), %rax
movq -0x420(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x438(%rbp)
addq $0x8, %rax
movq %rax, -0x430(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x428(%rbp)
jmp 0x59ab8
movq -0x428(%rbp), %rdx
movq -0x430(%rbp), %rsi
movq -0x438(%rbp), %rdi
callq 0x5d9a0
jmp 0x59ad4
leaq -0x3a8(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x599f8
movq -0x1c0(%rbp), %rdi
callq 0x150d0
testb $0x1, -0x9(%rbp)
je 0x59b70
callq 0x5b060
movq %rax, -0x440(%rbp)
jmp 0x59b0a
movq -0x3d8(%rbp), %rsi
movq -0x440(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x448(%rbp)
addq $0x8, %rsi
leaq -0x1e8(%rbp), %rdi
movl $0x87, %edx
callq 0x5d7c0
jmp 0x59b39
movq -0x448(%rbp), %rdi
leaq 0xf5a5(%rip), %rdx # 0x690ec
leaq -0x1e8(%rbp), %rsi
callq 0x5d9a0
jmp 0x59b55
jmp 0x59bcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
callq 0x153e0
jmp 0x59bd5
callq 0x5b060
movq %rax, -0x450(%rbp)
jmp 0x59b7e
movq -0x3d8(%rbp), %rsi
movq -0x450(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x458(%rbp)
addq $0x8, %rsi
leaq -0x208(%rbp), %rdi
movl $0x87, %edx
callq 0x5d7c0
jmp 0x59bad
movq -0x458(%rbp), %rdi
leaq 0xf575(%rip), %rdx # 0x69130
leaq -0x208(%rbp), %rsi
callq 0x5d9a0
jmp 0x59bc9
jmp 0x59bcb
callq 0x153e0
jmp 0x599f8
jmp 0x59c2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x59c09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x59c10
jmp 0x59c2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
callq 0x153e0
jmp 0x59c2b
jmp 0x59c2d
movq -0x1c0(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,816 | (anonymous namespace)::XmlTestReporterFixtureOneFailureAndOneSuccessHelper::XmlTestReporterFixtureOneFailureAndOneSuccessHelper(UnitTest::TestDetails const&) | TEST_FIXTURE(XmlTestReporterFixture, OneFailureAndOneSuccess)
{
TestDetails const failedDetails("FailedTest", "suite", "fail.h", 1);
reporter.ReportTestStart(failedDetails);
reporter.ReportFailure(failedDetails, "expected 1 but was 2");
reporter.ReportTestFinish(failedDetails, 0.1f);
TestDetails const succeededDetails("SucceededTest", "suite", "", 0);
reporter.ReportTestStart(succeededDetails);
reporter.ReportTestFinish(succeededDetails, 1.0f);
reporter.ReportSummary(2, 1, 1, 1.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"2\" failedtests=\"1\" failures=\"1\" time=\"1.1\">"
"<test suite=\"suite\" name=\"FailedTest\" time=\"0.1\">"
"<failure message=\"fail.h(1) : expected 1 but was 2\"/>"
"</test>"
"<test suite=\"suite\" name=\"SucceededTest\" time=\"1\"/>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x56390
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x1a0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,817 | void UnitTest::ExecuteTest<(anonymous namespace)::XmlTestReporterFixtureOneFailureAndOneSuccessHelper>((anonymous namespace)::XmlTestReporterFixtureOneFailureAndOneSuccessHelper&, UnitTest::TestDetails const&) | void ExecuteTest(T& testObject, TestDetails const& details)
{
CurrentTest::Details() = &details;
try
{
#ifdef UNITTEST_POSIX
UNITTEST_THROW_SIGNALS
#endif
testObject.RunImpl();
}
catch (AssertException const& e)
{
CurrentTest::Results()->OnTestFailure(
TestDetails(details.testName, details.suiteName, e.Filename(), e.LineNumber()), e.what());
}
catch (std::exception const& e)
{
MemoryOutStream stream;
stream << "Unhandled exception: " << e.what();
CurrentTest::Results()->OnTestFailure(details, stream.GetText());
}
catch (...)
{
CurrentTest::Results()->OnTestFailure(details, "Unhandled exception: Crash!");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x6c0, %rsp # imm = 0x6C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x650(%rbp)
callq 0x5b070
movq -0x650(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x470(%rbp), %rdi
callq 0x5ed70
jmp 0x59ccb
leaq 0x2f436(%rip), %rax # 0x89108
movq (%rax), %rdi
movl $0x1, %esi
callq 0x15390
cmpl $0x0, %eax
je 0x59f55
movl $0x8, %edi
callq 0x15110
movq %rax, %rdi
leaq 0xa061(%rip), %rax # 0x63d5d
movq %rax, (%rdi)
movq 0x2c2ba(%rip), %rsi # 0x85fc0
xorl %eax, %eax
movl %eax, %edx
callq 0x15400
jmp 0x59ff6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
jmp 0x59d46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x470(%rbp), %rdi
callq 0x5ee90
movl -0x47c(%rbp), %eax
movl %eax, -0x654(%rbp)
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0x59e33
movq -0x478(%rbp), %rdi
callq 0x150d0
movq %rax, -0x628(%rbp)
callq 0x5b060
movq %rax, -0x660(%rbp)
jmp 0x59d80
movq -0x660(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x680(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x678(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x670(%rbp)
movq -0x628(%rbp), %rdi
callq 0x5adc0
movq %rax, -0x668(%rbp)
jmp 0x59dbf
movq -0x628(%rbp), %rdi
callq 0x5ade0
movl %eax, -0x684(%rbp)
jmp 0x59dd3
movl -0x684(%rbp), %r8d
movq -0x668(%rbp), %rcx
movq -0x678(%rbp), %rdx
movq -0x670(%rbp), %rsi
leaq -0x648(%rbp), %rdi
callq 0x5d780
jmp 0x59dfd
movq -0x628(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x680(%rbp), %rdi
movq %rax, %rdx
leaq -0x648(%rbp), %rsi
callq 0x5d9a0
jmp 0x59e25
callq 0x153e0
addq $0x6c0, %rsp # imm = 0x6C0
popq %rbp
retq
movl -0x654(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x59f15
movq -0x478(%rbp), %rdi
callq 0x150d0
movq %rax, -0x488(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x1ab50
jmp 0x59e67
leaq 0x9e85(%rip), %rsi # 0x63cf3
leaq -0x620(%rbp), %rdi
callq 0x15250
movq %rax, -0x690(%rbp)
jmp 0x59e83
movq -0x488(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x690(%rbp), %rdi
movq %rax, %rsi
callq 0x15250
jmp 0x59ea4
callq 0x5b060
movq %rax, -0x698(%rbp)
jmp 0x59eb2
movq -0x698(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x6b0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x6a8(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x6a0(%rbp)
jmp 0x59ee3
movq -0x6a0(%rbp), %rdx
movq -0x6a8(%rbp), %rsi
movq -0x6b0(%rbp), %rdi
callq 0x5d9a0
jmp 0x59eff
leaq -0x620(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x59e2a
movq -0x478(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x6b8(%rbp)
jmp 0x59f2f
movq -0x6b8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq 0x9e34(%rip), %rdx # 0x63d78
callq 0x5d9a0
jmp 0x59f4b
callq 0x153e0
jmp 0x59e2a
movq -0x8(%rbp), %rdi
callq 0x5a020
jmp 0x59f60
leaq -0x470(%rbp), %rdi
callq 0x5ee90
jmp 0x59e2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
callq 0x153e0
jmp 0x59f8a
jmp 0x59fe2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
jmp 0x59fbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x59fc5
jmp 0x59fe2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
callq 0x153e0
jmp 0x59fe0
jmp 0x59fe2
movq -0x478(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../ExecuteTest.h |
11,818 | (anonymous namespace)::XmlTestReporterFixtureOneFailureAndOneSuccessHelper::~XmlTestReporterFixtureOneFailureAndOneSuccessHelper() | TEST_FIXTURE(XmlTestReporterFixture, OneFailureAndOneSuccess)
{
TestDetails const failedDetails("FailedTest", "suite", "fail.h", 1);
reporter.ReportTestStart(failedDetails);
reporter.ReportFailure(failedDetails, "expected 1 but was 2");
reporter.ReportTestFinish(failedDetails, 0.1f);
TestDetails const succeededDetails("SucceededTest", "suite", "", 0);
reporter.ReportTestStart(succeededDetails);
reporter.ReportTestFinish(succeededDetails, 1.0f);
reporter.ReportSummary(2, 1, 1, 1.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"2\" failedtests=\"1\" failures=\"1\" time=\"1.1\">"
"<test suite=\"suite\" name=\"FailedTest\" time=\"0.1\">"
"<failure message=\"fail.h(1) : expected 1 but was 2\"/>"
"</test>"
"<test suite=\"suite\" name=\"SucceededTest\" time=\"1\"/>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x56600
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,819 | (anonymous namespace)::XmlTestReporterFixtureOneFailureAndOneSuccessHelper::RunImpl() | TEST_FIXTURE(XmlTestReporterFixture, OneFailureAndOneSuccess)
{
TestDetails const failedDetails("FailedTest", "suite", "fail.h", 1);
reporter.ReportTestStart(failedDetails);
reporter.ReportFailure(failedDetails, "expected 1 but was 2");
reporter.ReportTestFinish(failedDetails, 0.1f);
TestDetails const succeededDetails("SucceededTest", "suite", "", 0);
reporter.ReportTestStart(succeededDetails);
reporter.ReportTestFinish(succeededDetails, 1.0f);
reporter.ReportSummary(2, 1, 1, 1.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"2\" failedtests=\"1\" failures=\"1\" time=\"1.1\">"
"<test suite=\"suite\" name=\"FailedTest\" time=\"0.1\">"
"<failure message=\"fail.h(1) : expected 1 but was 2\"/>"
"</test>"
"<test suite=\"suite\" name=\"SucceededTest\" time=\"1\"/>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x28(%rbp), %rdi
leaq 0xf68f(%rip), %rsi # 0x696d4
leaq 0xd0cd(%rip), %rdx # 0x67119
leaq 0xf68c(%rip), %rcx # 0x696df
movl $0x1, %r8d
callq 0x5d780
movq -0xc8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
callq 0x5b080
movq -0xc8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
leaq 0xf658(%rip), %rdx # 0x696e6
callq 0x5b120
movq -0xc8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
movss 0x8923(%rip), %xmm0 # 0x629d0
callq 0x5b1d0
leaq -0x48(%rbp), %rdi
leaq 0xf63e(%rip), %rsi # 0x696fb
leaq 0xd055(%rip), %rdx # 0x67119
leaq 0xfd8d(%rip), %rcx # 0x69e58
xorl %r8d, %r8d
callq 0x5d780
movq -0xc8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x48(%rbp), %rsi
callq 0x5b080
movq -0xc8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x48(%rbp), %rsi
movss 0xef4c(%rip), %xmm0 # 0x69050
callq 0x5b1d0
movq -0xc8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
movl $0x2, %esi
movl $0x1, %ecx
movss 0xef2b(%rip), %xmm0 # 0x69054
movl %ecx, %edx
callq 0x5e1b0
leaq 0xf5d2(%rip), %rax # 0x69709
movq %rax, -0x50(%rbp)
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x5a149
movq -0xc8(%rbp), %rsi
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x15280
jmp 0x5a16c
callq 0x5b070
movq %rax, -0xe0(%rbp)
jmp 0x5a17a
movq -0xe0(%rbp), %rax
movq (%rax), %rsi
leaq -0xa0(%rbp), %rdi
movl $0x9c, %edx
callq 0x5d7c0
jmp 0x5a197
movq -0xd8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x80(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
callq 0x373d0
jmp 0x5a1b4
leaq -0x80(%rbp), %rdi
callq 0x15150
jmp 0x5a259
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5a1e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x15150
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xe8(%rbp)
jmp 0x5a1fc
movq -0xe8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
callq 0x5b070
movq %rax, -0xf0(%rbp)
jmp 0x5a21b
movq -0xf0(%rbp), %rax
movq (%rax), %rsi
leaq -0xc0(%rbp), %rdi
movl $0x9c, %edx
callq 0x5d7c0
jmp 0x5a238
movq -0xf8(%rbp), %rdi
leaq 0xf038(%rip), %rdx # 0x6927e
leaq -0xc0(%rbp), %rsi
callq 0x5d9a0
jmp 0x5a254
callq 0x153e0
jmp 0x5a25b
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x5a277
jmp 0x5a279
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,820 | (anonymous namespace)::TestXmlTestReporterFixtureMultipleFailures::~TestXmlTestReporterFixtureMultipleFailures() | TEST_FIXTURE(XmlTestReporterFixture, MultipleFailures)
{
TestDetails const failedDetails1("FailedTest", "suite", "fail.h", 1);
TestDetails const failedDetails2("FailedTest", "suite", "fail.h", 31);
reporter.ReportTestStart(failedDetails1);
reporter.ReportFailure(failedDetails1, "expected 1 but was 2");
reporter.ReportFailure(failedDetails2, "expected one but was two");
reporter.ReportTestFinish(failedDetails1, 0.1f);
reporter.ReportSummary(1, 1, 2, 1.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"2\" time=\"1.1\">"
"<test suite=\"suite\" name=\"FailedTest\" time=\"0.1\">"
"<failure message=\"fail.h(1) : expected 1 but was 2\"/>"
"<failure message=\"fail.h(31) : expected one but was two\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x55ba0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,821 | (anonymous namespace)::TestXmlTestReporterFixtureMultipleFailures::RunImpl() const | TEST_FIXTURE(XmlTestReporterFixture, MultipleFailures)
{
TestDetails const failedDetails1("FailedTest", "suite", "fail.h", 1);
TestDetails const failedDetails2("FailedTest", "suite", "fail.h", 31);
reporter.ReportTestStart(failedDetails1);
reporter.ReportFailure(failedDetails1, "expected 1 but was 2");
reporter.ReportFailure(failedDetails2, "expected one but was two");
reporter.ReportTestFinish(failedDetails1, 0.1f);
reporter.ReportSummary(1, 1, 2, 1.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"2\" time=\"1.1\">"
"<test suite=\"suite\" name=\"FailedTest\" time=\"0.1\">"
"<failure message=\"fail.h(1) : expected 1 but was 2\"/>"
"<failure message=\"fail.h(31) : expected one but was two\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x3d8(%rbp)
movb $0x0, -0x9(%rbp)
addq $0x8, %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x5a690
jmp 0x5a2f0
movq -0x3d8(%rbp), %rsi
movb $0x1, -0x9(%rbp)
addq $0x8, %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x5a6d0
jmp 0x5a30d
leaq -0x1b8(%rbp), %rdi
callq 0x5aa40
jmp 0x5a438
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x5a350
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x5aa40
movl -0x1c4(%rbp), %eax
movl %eax, -0x3dc(%rbp)
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0x5a441
movq -0x1c0(%rbp), %rdi
callq 0x150d0
movq %rax, -0x3b0(%rbp)
callq 0x5b060
movq %rax, -0x3e8(%rbp)
jmp 0x5a38a
movq -0x3d8(%rbp), %rax
movq -0x3e8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x408(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x400(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x3f8(%rbp)
movq -0x3b0(%rbp), %rdi
callq 0x5adc0
movq %rax, -0x3f0(%rbp)
jmp 0x5a3cd
movq -0x3b0(%rbp), %rdi
callq 0x5ade0
movl %eax, -0x40c(%rbp)
jmp 0x5a3e1
movl -0x40c(%rbp), %r8d
movq -0x3f0(%rbp), %rcx
movq -0x400(%rbp), %rdx
movq -0x3f8(%rbp), %rsi
leaq -0x3d0(%rbp), %rdi
callq 0x5d780
jmp 0x5a40b
movq -0x3b0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x408(%rbp), %rdi
movq %rax, %rdx
leaq -0x3d0(%rbp), %rsi
callq 0x5d9a0
jmp 0x5a433
callq 0x153e0
addq $0x460, %rsp # imm = 0x460
popq %rbp
retq
movl -0x3dc(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x5a52a
movq -0x1c0(%rbp), %rdi
callq 0x150d0
movq %rax, -0x210(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x1ab50
jmp 0x5a475
leaq 0x9877(%rip), %rsi # 0x63cf3
leaq -0x3a8(%rbp), %rdi
callq 0x15250
movq %rax, -0x418(%rbp)
jmp 0x5a491
movq -0x210(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x418(%rbp), %rdi
movq %rax, %rsi
callq 0x15250
jmp 0x5a4b2
callq 0x5b060
movq %rax, -0x420(%rbp)
jmp 0x5a4c0
movq -0x3d8(%rbp), %rax
movq -0x420(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x438(%rbp)
addq $0x8, %rax
movq %rax, -0x430(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x428(%rbp)
jmp 0x5a4f8
movq -0x428(%rbp), %rdx
movq -0x430(%rbp), %rsi
movq -0x438(%rbp), %rdi
callq 0x5d9a0
jmp 0x5a514
leaq -0x3a8(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x5a438
movq -0x1c0(%rbp), %rdi
callq 0x150d0
testb $0x1, -0x9(%rbp)
je 0x5a5b0
callq 0x5b060
movq %rax, -0x440(%rbp)
jmp 0x5a54a
movq -0x3d8(%rbp), %rsi
movq -0x440(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x448(%rbp)
addq $0x8, %rsi
leaq -0x1e8(%rbp), %rdi
movl $0x9f, %edx
callq 0x5d7c0
jmp 0x5a579
movq -0x448(%rbp), %rdi
leaq 0xeb65(%rip), %rdx # 0x690ec
leaq -0x1e8(%rbp), %rsi
callq 0x5d9a0
jmp 0x5a595
jmp 0x5a60b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
callq 0x153e0
jmp 0x5a615
callq 0x5b060
movq %rax, -0x450(%rbp)
jmp 0x5a5be
movq -0x3d8(%rbp), %rsi
movq -0x450(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x458(%rbp)
addq $0x8, %rsi
leaq -0x208(%rbp), %rdi
movl $0x9f, %edx
callq 0x5d7c0
jmp 0x5a5ed
movq -0x458(%rbp), %rdi
leaq 0xeb35(%rip), %rdx # 0x69130
leaq -0x208(%rbp), %rsi
callq 0x5d9a0
jmp 0x5a609
jmp 0x5a60b
callq 0x153e0
jmp 0x5a438
jmp 0x5a66d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x5a649
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x5a650
jmp 0x5a66d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
callq 0x153e0
jmp 0x5a66b
jmp 0x5a66d
movq -0x1c0(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,822 | (anonymous namespace)::XmlTestReporterFixtureMultipleFailuresHelper::XmlTestReporterFixtureMultipleFailuresHelper(UnitTest::TestDetails const&) | TEST_FIXTURE(XmlTestReporterFixture, MultipleFailures)
{
TestDetails const failedDetails1("FailedTest", "suite", "fail.h", 1);
TestDetails const failedDetails2("FailedTest", "suite", "fail.h", 31);
reporter.ReportTestStart(failedDetails1);
reporter.ReportFailure(failedDetails1, "expected 1 but was 2");
reporter.ReportFailure(failedDetails2, "expected one but was two");
reporter.ReportTestFinish(failedDetails1, 0.1f);
reporter.ReportSummary(1, 1, 2, 1.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"2\" time=\"1.1\">"
"<test suite=\"suite\" name=\"FailedTest\" time=\"0.1\">"
"<failure message=\"fail.h(1) : expected 1 but was 2\"/>"
"<failure message=\"fail.h(31) : expected one but was two\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x56390
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x1a0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,823 | void UnitTest::ExecuteTest<(anonymous namespace)::XmlTestReporterFixtureMultipleFailuresHelper>((anonymous namespace)::XmlTestReporterFixtureMultipleFailuresHelper&, UnitTest::TestDetails const&) | void ExecuteTest(T& testObject, TestDetails const& details)
{
CurrentTest::Details() = &details;
try
{
#ifdef UNITTEST_POSIX
UNITTEST_THROW_SIGNALS
#endif
testObject.RunImpl();
}
catch (AssertException const& e)
{
CurrentTest::Results()->OnTestFailure(
TestDetails(details.testName, details.suiteName, e.Filename(), e.LineNumber()), e.what());
}
catch (std::exception const& e)
{
MemoryOutStream stream;
stream << "Unhandled exception: " << e.what();
CurrentTest::Results()->OnTestFailure(details, stream.GetText());
}
catch (...)
{
CurrentTest::Results()->OnTestFailure(details, "Unhandled exception: Crash!");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x6c0, %rsp # imm = 0x6C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x650(%rbp)
callq 0x5b070
movq -0x650(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x470(%rbp), %rdi
callq 0x5ed70
jmp 0x5a70b
leaq 0x2e9f6(%rip), %rax # 0x89108
movq (%rax), %rdi
movl $0x1, %esi
callq 0x15390
cmpl $0x0, %eax
je 0x5a995
movl $0x8, %edi
callq 0x15110
movq %rax, %rdi
leaq 0x9621(%rip), %rax # 0x63d5d
movq %rax, (%rdi)
movq 0x2b87a(%rip), %rsi # 0x85fc0
xorl %eax, %eax
movl %eax, %edx
callq 0x15400
jmp 0x5aa36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
jmp 0x5a786
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x470(%rbp), %rdi
callq 0x5ee90
movl -0x47c(%rbp), %eax
movl %eax, -0x654(%rbp)
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0x5a873
movq -0x478(%rbp), %rdi
callq 0x150d0
movq %rax, -0x628(%rbp)
callq 0x5b060
movq %rax, -0x660(%rbp)
jmp 0x5a7c0
movq -0x660(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x680(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x678(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x670(%rbp)
movq -0x628(%rbp), %rdi
callq 0x5adc0
movq %rax, -0x668(%rbp)
jmp 0x5a7ff
movq -0x628(%rbp), %rdi
callq 0x5ade0
movl %eax, -0x684(%rbp)
jmp 0x5a813
movl -0x684(%rbp), %r8d
movq -0x668(%rbp), %rcx
movq -0x678(%rbp), %rdx
movq -0x670(%rbp), %rsi
leaq -0x648(%rbp), %rdi
callq 0x5d780
jmp 0x5a83d
movq -0x628(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x680(%rbp), %rdi
movq %rax, %rdx
leaq -0x648(%rbp), %rsi
callq 0x5d9a0
jmp 0x5a865
callq 0x153e0
addq $0x6c0, %rsp # imm = 0x6C0
popq %rbp
retq
movl -0x654(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x5a955
movq -0x478(%rbp), %rdi
callq 0x150d0
movq %rax, -0x488(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x1ab50
jmp 0x5a8a7
leaq 0x9445(%rip), %rsi # 0x63cf3
leaq -0x620(%rbp), %rdi
callq 0x15250
movq %rax, -0x690(%rbp)
jmp 0x5a8c3
movq -0x488(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x690(%rbp), %rdi
movq %rax, %rsi
callq 0x15250
jmp 0x5a8e4
callq 0x5b060
movq %rax, -0x698(%rbp)
jmp 0x5a8f2
movq -0x698(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x6b0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x6a8(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x6a0(%rbp)
jmp 0x5a923
movq -0x6a0(%rbp), %rdx
movq -0x6a8(%rbp), %rsi
movq -0x6b0(%rbp), %rdi
callq 0x5d9a0
jmp 0x5a93f
leaq -0x620(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x5a86a
movq -0x478(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x6b8(%rbp)
jmp 0x5a96f
movq -0x6b8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq 0x93f4(%rip), %rdx # 0x63d78
callq 0x5d9a0
jmp 0x5a98b
callq 0x153e0
jmp 0x5a86a
movq -0x8(%rbp), %rdi
callq 0x5aa60
jmp 0x5a9a0
leaq -0x470(%rbp), %rdi
callq 0x5ee90
jmp 0x5a86a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
callq 0x153e0
jmp 0x5a9ca
jmp 0x5aa22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
jmp 0x5a9fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x5aa05
jmp 0x5aa22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
callq 0x153e0
jmp 0x5aa20
jmp 0x5aa22
movq -0x478(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../ExecuteTest.h |
11,824 | (anonymous namespace)::XmlTestReporterFixtureMultipleFailuresHelper::~XmlTestReporterFixtureMultipleFailuresHelper() | TEST_FIXTURE(XmlTestReporterFixture, MultipleFailures)
{
TestDetails const failedDetails1("FailedTest", "suite", "fail.h", 1);
TestDetails const failedDetails2("FailedTest", "suite", "fail.h", 31);
reporter.ReportTestStart(failedDetails1);
reporter.ReportFailure(failedDetails1, "expected 1 but was 2");
reporter.ReportFailure(failedDetails2, "expected one but was two");
reporter.ReportTestFinish(failedDetails1, 0.1f);
reporter.ReportSummary(1, 1, 2, 1.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"2\" time=\"1.1\">"
"<test suite=\"suite\" name=\"FailedTest\" time=\"0.1\">"
"<failure message=\"fail.h(1) : expected 1 but was 2\"/>"
"<failure message=\"fail.h(31) : expected one but was two\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x56600
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,825 | (anonymous namespace)::XmlTestReporterFixtureMultipleFailuresHelper::RunImpl() | TEST_FIXTURE(XmlTestReporterFixture, MultipleFailures)
{
TestDetails const failedDetails1("FailedTest", "suite", "fail.h", 1);
TestDetails const failedDetails2("FailedTest", "suite", "fail.h", 31);
reporter.ReportTestStart(failedDetails1);
reporter.ReportFailure(failedDetails1, "expected 1 but was 2");
reporter.ReportFailure(failedDetails2, "expected one but was two");
reporter.ReportTestFinish(failedDetails1, 0.1f);
reporter.ReportSummary(1, 1, 2, 1.1f);
char const* expected =
"<?xml version=\"1.0\"?>"
"<unittest-results tests=\"1\" failedtests=\"1\" failures=\"2\" time=\"1.1\">"
"<test suite=\"suite\" name=\"FailedTest\" time=\"0.1\">"
"<failure message=\"fail.h(1) : expected 1 but was 2\"/>"
"<failure message=\"fail.h(31) : expected one but was two\"/>"
"</test>"
"</unittest-results>";
CHECK_EQUAL(expected, output.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x28(%rbp), %rdi
leaq 0xec4f(%rip), %rsi # 0x696d4
leaq 0xc68d(%rip), %rdx # 0x67119
leaq 0xec4c(%rip), %rcx # 0x696df
movl $0x1, %r8d
callq 0x5d780
leaq -0x48(%rbp), %rdi
leaq 0xec2b(%rip), %rsi # 0x696d4
leaq 0xc669(%rip), %rdx # 0x67119
leaq 0xec28(%rip), %rcx # 0x696df
movl $0x1f, %r8d
callq 0x5d780
movq -0xc8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
callq 0x5b080
movq -0xc8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
leaq 0xebf4(%rip), %rdx # 0x696e6
callq 0x5b120
movq -0xc8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x48(%rbp), %rsi
leaq 0xed06(%rip), %rdx # 0x69816
callq 0x5b120
movq -0xc8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
leaq -0x28(%rbp), %rsi
movss 0x7ea1(%rip), %xmm0 # 0x629d0
callq 0x5b1d0
movq -0xc8(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
movl $0x1, %edx
movl $0x2, %ecx
movss 0xe500(%rip), %xmm0 # 0x69054
movl %edx, %esi
callq 0x5e1b0
leaq 0xeccd(%rip), %rax # 0x6982f
movq %rax, -0x50(%rbp)
callq 0x5b060
movq %rax, -0xd0(%rbp)
jmp 0x5ab74
movq -0xc8(%rbp), %rsi
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x15280
jmp 0x5ab97
callq 0x5b070
movq %rax, -0xe0(%rbp)
jmp 0x5aba5
movq -0xe0(%rbp), %rax
movq (%rax), %rsi
leaq -0xa0(%rbp), %rdi
movl $0xb4, %edx
callq 0x5d7c0
jmp 0x5abc2
movq -0xd8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x80(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
callq 0x373d0
jmp 0x5abdf
leaq -0x80(%rbp), %rdi
callq 0x15150
jmp 0x5ac84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5ac10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x15150
movq -0x58(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0xe8(%rbp)
jmp 0x5ac27
movq -0xe8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
callq 0x5b070
movq %rax, -0xf0(%rbp)
jmp 0x5ac46
movq -0xf0(%rbp), %rax
movq (%rax), %rsi
leaq -0xc0(%rbp), %rdi
movl $0xb4, %edx
callq 0x5d7c0
jmp 0x5ac63
movq -0xf8(%rbp), %rdi
leaq 0xe60d(%rip), %rdx # 0x6927e
leaq -0xc0(%rbp), %rsi
callq 0x5d9a0
jmp 0x5ac7f
callq 0x153e0
jmp 0x5ac86
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x5aca2
jmp 0x5aca4
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
11,826 | UnitTest::AssertException::AssertException(char const*, char const*, int) | AssertException::AssertException(char const* description, char const* filename, int lineNumber)
: m_lineNumber(lineNumber)
{
using namespace std;
strcpy(m_description, description);
strcpy(m_filename, filename);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x5ae00
movq -0x28(%rbp), %rdi
leaq 0x2aec9(%rip), %rax # 0x85bd8
addq $0x10, %rax
movq %rax, (%rdi)
movl -0x1c(%rbp), %eax
movl %eax, 0x308(%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x15240
movq -0x28(%rbp), %rdi
addq $0x208, %rdi # imm = 0x208
movq -0x18(%rbp), %rsi
callq 0x15240
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/AssertException.cpp |
11,827 | UnitTest::AssertException::~AssertException() | AssertException::~AssertException() throw()
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15490
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/AssertException.cpp |
11,828 | UnitTest::AssertException::~AssertException() | AssertException::~AssertException() throw()
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x5ad50
movq -0x10(%rbp), %rdi
movl $0x310, %esi # imm = 0x310
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/AssertException.cpp |
11,829 | UnitTest::AssertException::what() const | char const* AssertException::what() const throw()
{
return m_description;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/AssertException.cpp |
11,830 | UnitTest::AssertException::Filename() const | char const* AssertException::Filename() const
{
return m_filename;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x208, %rax # imm = 0x208
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/AssertException.cpp |
11,831 | UnitTest::AssertException::LineNumber() const | int AssertException::LineNumber() const
{
return m_lineNumber;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x308(%rax), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/AssertException.cpp |
11,832 | std::exception::exception() | exception() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x2b1bd(%rip), %rcx # 0x85fd0
addq $0x10, %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/exception.h |
11,833 | UnitTest::CheckEqual(UnitTest::TestResults&, char const*, char const*, UnitTest::TestDetails const&) | void CheckEqual(TestResults& results, char const* expected, char const* actual,
TestDetails const& details)
{
CheckStringsEqual(results, expected, actual, details);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5ae60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Checks.cpp |
11,834 | UnitTest::(anonymous namespace)::CheckStringsEqual(UnitTest::TestResults&, char const*, char const*, UnitTest::TestDetails const&) | void CheckStringsEqual(TestResults& results, char const* expected, char const* actual,
TestDetails const& details)
{
using namespace std;
if (strcmp(expected, actual))
{
UnitTest::MemoryOutStream stream;
stream << "Expected " << expected << " but was " << actual;
results.OnTestFailure(details, stream.GetText());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15370
cmpl $0x0, %eax
je 0x5af7c
leaq -0x1b8(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x1ab50
movq -0x1d8(%rbp), %rdi
leaq 0x5315(%rip), %rsi # 0x601c7
callq 0x15250
movq %rax, -0x1d0(%rbp)
jmp 0x5aec0
movq -0x1d0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15250
movq %rax, -0x1e0(%rbp)
jmp 0x5aed9
movq -0x1e0(%rbp), %rdi
leaq 0x52ea(%rip), %rsi # 0x601d1
callq 0x15250
movq %rax, -0x1e8(%rbp)
jmp 0x5aef5
movq -0x1e8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15250
jmp 0x5af07
movq -0x8(%rbp), %rax
movq %rax, -0x200(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x1f0(%rbp)
jmp 0x5af32
movq -0x1f0(%rbp), %rdx
movq -0x1f8(%rbp), %rsi
movq -0x200(%rbp), %rdi
callq 0x5d9a0
jmp 0x5af4e
leaq -0x1b8(%rbp), %rdi
callq 0x1abe0
jmp 0x5af7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1abe0
jmp 0x5af85
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x15420
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Checks.cpp |
11,835 | UnitTest::CheckEqual(UnitTest::TestResults&, char*, char*, UnitTest::TestDetails const&) | void CheckEqual(TestResults& results, char* expected, char* actual,
TestDetails const& details)
{
CheckStringsEqual(results, expected, actual, details);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5ae60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Checks.cpp |
11,836 | UnitTest::CheckEqual(UnitTest::TestResults&, char*, char const*, UnitTest::TestDetails const&) | void CheckEqual(TestResults& results, char* expected, char const* actual,
TestDetails const& details)
{
CheckStringsEqual(results, expected, actual, details);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5ae60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Checks.cpp |
11,837 | UnitTest::CheckEqual(UnitTest::TestResults&, char const*, char*, UnitTest::TestDetails const&) | void CheckEqual(TestResults& results, char const* expected, char* actual,
TestDetails const& details)
{
CheckStringsEqual(results, expected, actual, details);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5ae60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Checks.cpp |
11,838 | UnitTest::CurrentTest::Results() | TestResults*& CurrentTest::Results()
{
static TestResults* testResults = NULL;
return testResults;
} | pushq %rbp
movq %rsp, %rbp
leaq 0x2e06d(%rip), %rax # 0x890d8
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/CurrentTest.cpp |
11,839 | UnitTest::CurrentTest::Details() | const TestDetails*& CurrentTest::Details()
{
static const TestDetails* testDetails = NULL;
return testDetails;
} | pushq %rbp
movq %rsp, %rbp
leaq 0x2e065(%rip), %rax # 0x890e0
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/CurrentTest.cpp |
11,840 | UnitTest::DeferredTestReporter::ReportTestStart(UnitTest::TestDetails const&) | void DeferredTestReporter::ReportTestStart(TestDetails const& details)
{
m_results.push_back(DeferredTestResult(details.suiteName, details.testName));
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq -0x90(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5cf20
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x5b230
jmp 0x5b0d5
leaq -0x90(%rbp), %rdi
callq 0x5d070
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x5d070
movq -0x98(%rbp), %rdi
callq 0x15420
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/DeferredTestReporter.cpp |
11,841 | UnitTest::DeferredTestReporter::ReportFailure(UnitTest::TestDetails const&, char const*) | void DeferredTestReporter::ReportFailure(TestDetails const& details, char const* failure)
{
DeferredTestResult& r = m_results.back();
r.failed = true;
r.failures.push_back(DeferredTestResult::Failure(details.lineNumber, failure));
r.failureFile = details.filename;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x5b260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x7c(%rax)
movq -0x20(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x5b2d0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x5b2a0
jmp 0x5b181
leaq -0x48(%rbp), %rdi
callq 0x5b350
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x15350
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5b350
movq -0x50(%rbp), %rdi
callq 0x15420
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/DeferredTestReporter.cpp |
11,842 | UnitTest::DeferredTestReporter::ReportTestFinish(UnitTest::TestDetails const&, float) | void DeferredTestReporter::ReportTestFinish(TestDetails const&, float secondsElapsed)
{
DeferredTestResult& r = m_results.back();
r.timeElapsed = secondsElapsed;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x5b260
movq %rax, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x78(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/DeferredTestReporter.cpp |
11,843 | UnitTest::DeferredTestReporter::GetResults() | DeferredTestReporter::DeferredTestResultList& DeferredTestReporter::GetResults()
{
return m_results;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/DeferredTestReporter.cpp |
11,844 | std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::push_back(UnitTest::DeferredTestResult&&) | void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5b380
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,845 | std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::back() | reference
back() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
return *(end() - 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5b6d0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5c5f0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x5c630
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,846 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::push_back(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&) | void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c650
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,847 | std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::pair<char const*&, true>(int const&, char const*&) | constexpr pair(const _T1& __x, _U2&& __y)
: first(__x), second(std::forward<_U2>(__y)) { } | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x15430
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x36c80
jmp 0x5b323
leaq -0x19(%rbp), %rdi
callq 0x152a0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x152a0
movq -0x28(%rbp), %rdi
callq 0x15420
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h |
11,848 | UnitTest::DeferredTestResult& std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::emplace_back<UnitTest::DeferredTestResult>(UnitTest::DeferredTestResult&&) | vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0x5b3c8
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x5b400
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x80, %rcx
movq %rcx, 0x8(%rax)
jmp 0x5b3e6
movq -0x20(%rbp), %rdi
callq 0x5b6d0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x5b430
movq -0x20(%rbp), %rdi
callq 0x5b260
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
11,849 | void std::allocator_traits<std::allocator<UnitTest::DeferredTestResult>>::construct<UnitTest::DeferredTestResult, UnitTest::DeferredTestResult>(std::allocator<UnitTest::DeferredTestResult>&, UnitTest::DeferredTestResult*, UnitTest::DeferredTestResult&&) | static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
std::construct_at(__p, std::forward<_Args>(__args)...);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5b700
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
11,850 | void std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::_M_realloc_insert<UnitTest::DeferredTestResult>(__gnu_cxx::__normal_iterator<UnitTest::DeferredTestResult*, std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>>, UnitTest::DeferredTestResult&&) | void
vector<_Tp, _Alloc>::
_M_realloc_insert(iterator __position, const _Tp& __x)
#endif
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_realloc_insert");
pointer __old_start = this->_M_impl._M_start;
pointer __old_finish = this->_M_impl._M_finish;
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
__try
{
// The order of the three operations is dictated by the C++11
// case, where the moves could alter a new element belonging
// to the existing vector. This is an issue only for callers
// taking the element by lvalue ref (see last bullet of C++11
// [res.on.arguments]).
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#if __cplusplus >= 201103L
std::forward<_Args>(__args)...);
#else
__x);
#endif
__new_finish = pointer();
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
{
__new_finish = _S_relocate(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish = _S_relocate(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
else
#endif
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
}
__catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_REINIT;
_M_deallocate(__old_start,
this->_M_impl._M_end_of_storage - __old_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq 0xe77b(%rip), %rdx # 0x69bd1
movl $0x1, %esi
callq 0x5c070
movq -0x68(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x5c190
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5c150
movq -0x68(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x5c1c0
movq -0x68(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
shlq $0x7, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x5b400
jmp 0x5b4c8
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x5c260
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x371a0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
callq 0x5c210
movq %rax, -0x70(%rbp)
jmp 0x5b519
movq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
subq $-0x80, %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x5c260
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x371a0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq %rax, %rcx
callq 0x5c210
movq %rax, -0x90(%rbp)
jmp 0x5b585
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x5b639
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x150d0
cmpq $0x0, -0x50(%rbp)
jne 0x5b5cb
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
shlq $0x7, %rax
addq %rax, %rsi
callq 0x5c270
jmp 0x5b617
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x371a0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq %rax, %rdx
callq 0x37170
jmp 0x5b602
jmp 0x5b617
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x153e0
jmp 0x5b634
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x37280
jmp 0x5b62a
callq 0x153a0
jmp 0x5b6ca
jmp 0x5b6b9
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x371a0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq %rax, %rdx
callq 0x37170
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq 0x10(%rdi), %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
sarq $0x7, %rdx
callq 0x37280
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rdx
shlq $0x7, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
11,851 | std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x5c3d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,852 | void __gnu_cxx::new_allocator<UnitTest::DeferredTestResult>::construct<UnitTest::DeferredTestResult, UnitTest::DeferredTestResult>(UnitTest::DeferredTestResult*, UnitTest::DeferredTestResult&&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5b730
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
11,853 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::vector(std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&) | vector(const vector& __x)
: _Base(__x.size(),
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
{
this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x375c0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b930
movq %rax, %rsi
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x5b900
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x5b940
jmp 0x5b861
leaq -0x11(%rbp), %rdi
callq 0x5b9a0
movq -0x10(%rbp), %rdi
callq 0x5ba00
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5ba30
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq (%rdi), %rax
movq %rax, -0x60(%rbp)
callq 0x5ba60
movq -0x60(%rbp), %rdx
movq %rax, %rcx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5b9c0
movq %rax, -0x58(%rbp)
jmp 0x5b8ae
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x5b9a0
jmp 0x5b8ec
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5ba70
movq -0x20(%rbp), %rdi
callq 0x15420
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,854 | _gnu_cxx::__alloc_traits<std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::_S_select_on_copy(std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | static constexpr _Alloc _S_select_on_copy(const _Alloc& __a)
{ return _Base_type::select_on_container_copy_construction(__a); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5bac0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/alloc_traits.h |
11,855 | std::_Vector_base<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_M_get_Tp_allocator() const | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,856 | std::_Vector_base<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_Vector_base(unsigned long, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | _Vector_base(size_t __n, const allocator_type& __a)
: _M_impl(__a)
{ _M_create_storage(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x5bb30
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5bb60
jmp 0x5b974
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5bbb0
movq -0x20(%rbp), %rdi
callq 0x15420
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,857 | std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5bd00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
11,858 | std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>* std::__uninitialized_copy_a<__gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, __gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | inline _ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, allocator<_Tp>&)
{ return std::uninitialized_copy(__first, __last, __result); } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5bd10
addq $0x30, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
11,859 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::begin() const | const_iterator
begin() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x5bfb0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,860 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::end() const | const_iterator
end() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x5bfb0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,861 | std::_Vector_base<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_M_get_Tp_allocator() | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,862 | std::_Vector_base<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::~_Vector_base() | ~_Vector_base() _GLIBCXX_NOEXCEPT
{
_M_deallocate(_M_impl._M_start,
_M_impl._M_end_of_storage - _M_impl._M_start);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rsi
movq 0x10(%rdi), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
callq 0x5bfd0
jmp 0x5baa7
movq -0x10(%rbp), %rdi
callq 0x5bbb0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1aa00
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,863 | std::allocator_traits<std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::select_on_container_copy_construction(std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | select_on_container_copy_construction(const allocator_type& __rhs)
{ return __rhs; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5baf0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
11,864 | _gnu_cxx::new_allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::new_allocator(__gnu_cxx::new_allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | _GLIBCXX20_CONSTEXPR
new_allocator(const new_allocator&) _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
11,865 | std::_Vector_base<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_Vector_impl::_Vector_impl(std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | _Vector_impl(_Tp_alloc_type const& __a) _GLIBCXX_NOEXCEPT
: _Tp_alloc_type(__a)
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5baf0
movq -0x18(%rbp), %rdi
callq 0x5bbd0
addq $0x20, %rsp
popq %rbp
retq
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,866 | std::_Vector_base<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_Vector_impl::~_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5b9a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,867 | std::_Vector_base<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_Vector_impl_data::_Vector_impl_data() | _Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,868 | std::_Vector_base<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_M_allocate(unsigned long) | pointer
_M_allocate(size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5bc32
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5bc50
movq %rax, -0x20(%rbp)
jmp 0x5bc3a
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x5bc3a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,869 | std::allocator_traits<std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::allocate(std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5bc80
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
11,870 | _gnu_cxx::new_allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x5bce0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x5bccb
movabsq $0x666666666666666, %rax # imm = 0x666666666666666
cmpq %rax, -0x10(%rbp)
jbe 0x5bcc6
callq 0x151d0
callq 0x150a0
imulq $0x28, -0x10(%rbp), %rdi
callq 0x15260
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
11,871 | _gnu_cxx::new_allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
11,872 | std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>* std::uninitialized_copy<__gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*>(__gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, __gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*) | inline _ForwardIterator
uninitialized_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
{
typedef typename iterator_traits<_InputIterator>::value_type
_ValueType1;
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType2;
#if __cplusplus < 201103L
const bool __assignable = true;
#else
// Trivial types can have deleted copy constructor, but the std::copy
// optimization that uses memmove would happily "copy" them anyway.
static_assert(is_constructible<_ValueType2, decltype(*__first)>::value,
"result type must be constructible from value type of input range");
typedef typename iterator_traits<_InputIterator>::reference _RefType1;
typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
// Trivial types can have deleted assignment, so using std::copy
// would be ill-formed. Require assignability before using std::copy:
const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
#endif
return std::__uninitialized_copy<__is_trivial(_ValueType1)
&& __is_trivial(_ValueType2)
&& __assignable>::
__uninit_copy(__first, __last, __result);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5bd50
addq $0x30, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
11,873 | _gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
11,874 | void std::_Destroy<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*>(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*) | _GLIBCXX20_CONSTEXPR inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_Value_type;
#if __cplusplus >= 201103L
// A deleted destructor is trivial, this ensures we reject such types:
static_assert(is_destructible<_Value_type>::value,
"value type is destructible");
#endif
#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return _Destroy_aux<false>::__destroy(__first, __last);
#endif
std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
__destroy(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5bf50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
11,875 | std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::pair(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&) | constexpr pair(const pair&) = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x150f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h |
11,876 | void std::_Destroy_aux<false>::__destroy<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*>(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*) | static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x5bf81
movq -0x8(%rbp), %rdi
callq 0x5bf90
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x8(%rbp)
jmp 0x5bf60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
11,877 | void std::_Destroy<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*) | _GLIBCXX14_CONSTEXPR inline void
_Destroy(_Tp* __pointer)
{
#if __cplusplus > 201703L
std::destroy_at(__pointer);
#else
__pointer->~_Tp();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5b350
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
11,878 | _gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::__normal_iterator(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
11,879 | std::_Vector_base<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_M_deallocate(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, unsigned long) | void
_M_deallocate(pointer __p, size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
if (__p)
_Tr::deallocate(_M_impl, __p, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5c004
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5c010
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,880 | std::allocator_traits<std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::deallocate(std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5c040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
11,881 | std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::_M_check_len(unsigned long, char const*) const | size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x5c2a0
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x37370
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jae 0x5c0b7
movq -0x18(%rbp), %rdi
callq 0x15120
movq -0x38(%rbp), %rdi
callq 0x37370
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x37370
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x5c2d0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x37370
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x5c126
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x5c2a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0x5c135
movq -0x38(%rbp), %rdi
callq 0x5c2a0
movq %rax, -0x58(%rbp)
jmp 0x5c13d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,882 | std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x5c3d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,883 | std::_Vector_base<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::_M_allocate(unsigned long) | pointer
_M_allocate(size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5c1f2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c3f0
movq %rax, -0x20(%rbp)
jmp 0x5c1fa
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x5c1fa
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,884 | UnitTest::DeferredTestResult* std::__uninitialized_move_if_noexcept_a<UnitTest::DeferredTestResult*, UnitTest::DeferredTestResult*, std::allocator<UnitTest::DeferredTestResult>>(UnitTest::DeferredTestResult*, UnitTest::DeferredTestResult*, UnitTest::DeferredTestResult*, std::allocator<UnitTest::DeferredTestResult>&) | inline _ForwardIterator
__uninitialized_move_if_noexcept_a(_InputIterator __first,
_InputIterator __last,
_ForwardIterator __result,
_Allocator& __alloc)
{
return std::__uninitialized_copy_a
(_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first),
_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5c4b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5c4b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5c480
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
11,885 | void std::allocator_traits<std::allocator<UnitTest::DeferredTestResult>>::destroy<UnitTest::DeferredTestResult>(std::allocator<UnitTest::DeferredTestResult>&, UnitTest::DeferredTestResult*) | static _GLIBCXX20_CONSTEXPR void
destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{
#if __cplusplus <= 201703L
__a.destroy(__p);
#else
std::destroy_at(__p);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c5d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
11,886 | std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5c360
movq %rax, %rdi
callq 0x5c310
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,887 | std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::_S_max_size(std::allocator<UnitTest::DeferredTestResult> const&) | static size_type
_S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
{
// std::distance(begin(), end()) cannot be greater than PTRDIFF_MAX,
// and realistically we can't store more than PTRDIFF_MAX/sizeof(T)
// (even if std::allocator_traits::max_size says we can).
const size_t __diffmax
= __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
const size_t __allocmax = _Alloc_traits::max_size(__a);
return (std::min)(__diffmax, __allocmax);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0xffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5c370
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x55160
movq %rax, -0x20(%rbp)
jmp 0x5c34a
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1aa00
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,888 | std::_Vector_base<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::_M_get_Tp_allocator() const | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,889 | std::allocator_traits<std::allocator<UnitTest::DeferredTestResult>>::max_size(std::allocator<UnitTest::DeferredTestResult> const&) | static _GLIBCXX20_CONSTEXPR size_type
max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
{
#if __cplusplus <= 201703L
return __a.max_size();
#else
return size_t(-1) / sizeof(value_type);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5c390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
11,890 | _gnu_cxx::new_allocator<UnitTest::DeferredTestResult>::max_size() const | size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_max_size(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5c3b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
11,891 | _gnu_cxx::__normal_iterator<UnitTest::DeferredTestResult*, std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>>::__normal_iterator(UnitTest::DeferredTestResult* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
11,892 | std::allocator_traits<std::allocator<UnitTest::DeferredTestResult>>::allocate(std::allocator<UnitTest::DeferredTestResult>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5c420
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
11,893 | _gnu_cxx::new_allocator<UnitTest::DeferredTestResult>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x5c3b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x5c46b
movabsq $0x1ffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFF
cmpq %rax, -0x10(%rbp)
jbe 0x5c466
callq 0x151d0
callq 0x150a0
movq -0x10(%rbp), %rdi
shlq $0x7, %rdi
callq 0x15260
addq $0x20, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
11,894 | UnitTest::DeferredTestResult* std::__uninitialized_copy_a<UnitTest::DeferredTestResult const*, UnitTest::DeferredTestResult*, UnitTest::DeferredTestResult>(UnitTest::DeferredTestResult const*, UnitTest::DeferredTestResult const*, UnitTest::DeferredTestResult*, std::allocator<UnitTest::DeferredTestResult>&) | inline _ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, allocator<_Tp>&)
{ return std::uninitialized_copy(__first, __last, __result); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5c4c0
addq $0x20, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
11,895 | UnitTest::DeferredTestResult const* std::__make_move_if_noexcept_iterator<UnitTest::DeferredTestResult, UnitTest::DeferredTestResult const*>(UnitTest::DeferredTestResult*) | inline _GLIBCXX17_CONSTEXPR _ReturnType
__make_move_if_noexcept_iterator(_Tp* __i)
{ return _ReturnType(__i); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
11,896 | UnitTest::DeferredTestResult* std::uninitialized_copy<UnitTest::DeferredTestResult const*, UnitTest::DeferredTestResult*>(UnitTest::DeferredTestResult const*, UnitTest::DeferredTestResult const*, UnitTest::DeferredTestResult*) | inline _ForwardIterator
uninitialized_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
{
typedef typename iterator_traits<_InputIterator>::value_type
_ValueType1;
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType2;
#if __cplusplus < 201103L
const bool __assignable = true;
#else
// Trivial types can have deleted copy constructor, but the std::copy
// optimization that uses memmove would happily "copy" them anyway.
static_assert(is_constructible<_ValueType2, decltype(*__first)>::value,
"result type must be constructible from value type of input range");
typedef typename iterator_traits<_InputIterator>::reference _RefType1;
typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
// Trivial types can have deleted assignment, so using std::copy
// would be ill-formed. Require assignability before using std::copy:
const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
#endif
return std::__uninitialized_copy<__is_trivial(_ValueType1)
&& __is_trivial(_ValueType2)
&& __assignable>::
__uninit_copy(__first, __last, __result);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5c4f0
addq $0x20, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
11,897 | void __gnu_cxx::new_allocator<UnitTest::DeferredTestResult>::destroy<UnitTest::DeferredTestResult>(UnitTest::DeferredTestResult*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d070
addq $0x10, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
11,898 | _gnu_cxx::__normal_iterator<UnitTest::DeferredTestResult*, std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>>::operator-(long) const | _GLIBCXX20_CONSTEXPR
const _Iterator&
base() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
subq -0x18(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5c3d0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
11,899 | _gnu_cxx::__normal_iterator<UnitTest::DeferredTestResult*, std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.