name string | code string | asm string | file string |
|---|---|---|---|
spvtools::utils::PrintTimerDescription(std::ostream*, bool) | void PrintTimerDescription(std::ostream* out, bool measure_mem_usage) {
if (out) {
*out << std::setw(30) << "PASS name" << std::setw(12) << "CPU time"
<< std::setw(12) << "WALL time" << std::setw(12) << "USR time"
<< std::setw(12) << "SYS time";
if (measure_mem_usage) {
*out << std::se... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb04c41
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x1e, %edi
callq 0xdc5e0
movq -0x50(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
callq 0xdc980
movq %rax,... | /DiligentGraphics[P]DiligentCore/ThirdParty/SPIRV-Tools/source/util/timer.cpp |
void mserialize::StructSerializer<binlog::ClockSync, std::integral_constant<unsigned long binlog::ClockSync::*, &binlog::ClockSync::clockValue>, std::integral_constant<unsigned long binlog::ClockSync::*, &binlog::ClockSync::clockFrequency>, std::integral_constant<unsigned long binlog::ClockSync::*, &binlog::ClockSync::... | static void serialize(const T& t, OutputStream& ostream)
{
using swallow = int[];
(void)swallow{1, (serialize_member(t, Members::value, ostream), int{})...};
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movl $0x8, %edx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x3e62
movq 0x8(%r14), %rax
movq %rax, (%r15)
leaq 0x8(%rsp), %r15
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3e62... | /morganstanley[P]binlog/include/mserialize/StructSerializer.hpp |
binlog::SessionWriter::replaceChannel(unsigned long) | inline bool SessionWriter::replaceChannel(std::size_t minQueueCapacity) noexcept
{
const std::size_t newCapacity = (std::max)(_qw.capacity(), 2 * minQueueCapacity);
try
{
WriterProp wp{_channel->writerProp.id, _channel->writerProp.name, 0}; // avoid racing on the last field
_channel = _session->createCha... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x10(%rax), %rax
addq %rsi, %r14
cmpq %r14, %rax
cmovaq %rax, %r14
movq 0x8(%rdi), %rax
movq (%rax), %rcx
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0... | /morganstanley[P]binlog/include/binlog/SessionWriter.hpp |
void mserialize::StructSerializer<binlog::WriterProp, std::integral_constant<unsigned long binlog::WriterProp::*, &binlog::WriterProp::id>, std::integral_constant<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> binlog::WriterProp::*, &binlog::WriterProp::name>, std::integral_constant<unsi... | static void serialize(const T& t, OutputStream& ostream)
{
using swallow = int[];
(void)swallow{1, (serialize_member(t, Members::value, ostream), int{})...};
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x10(%rsp), %rcx
movq %rax, -0x8(%rcx)
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3ece
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x5262
movq 0x28(%r14), %rax
movq %rax, (%r15)... | /morganstanley[P]binlog/include/mserialize/StructSerializer.hpp |
doctest::detail::tlssPush() | std::ostream* tlssPush() {
return g_oss.push();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
callq 0x29187
movq %fs:0x0, %rax
leaq -0x1d8(%rax), %r14
leaq -0x1b0(%rax), %rbx
movq %rbx, %rdi
callq 0x7190
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq -0x20(%rbx), %rsi
cmpq -0x18(%rbx), %rsi
je 0xa376
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%r14)
jmp 0... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String::String(doctest::String const&) | String::String(const String& other) { copy(other); } | pushq %rbx
movq %rsi, %rbx
cmpb $0x0, 0x17(%rsi)
js 0xa5ea
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rdi)
movups (%rbx), %xmm0
movups %xmm0, (%rdi)
popq %rbx
retq
movl 0x8(%rbx), %esi
callq 0xa4ae
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
movq %rax, %rdi
popq %rbx
jmp 0x70c0
nop
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String::operator=(doctest::String&&) | String& String::operator=(String&& other) {
if(this != &other) {
if(!isOnStack())
delete[] data.ptr;
memcpy(buf, other.buf, len);
other.buf[0] = '\0';
other.setLast();
}
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xa810
movq %rsi, %r14
cmpb $0x0, 0x17(%rbx)
jns 0xa7f8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa7f8
callq 0x72d0
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movb $0x0, (%r14)
movb $0x17, 0x17(%r14)
movq %rbx, ... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::operator<<(std::ostream&, doctest::String const&) | std::ostream& operator<<(std::ostream& s, const String& in) { return s << in.c_str(); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x17(%rsi)
jns 0xaa2d
movq (%r14), %r14
testq %r14, %r14
je 0xaa4a
movq %r14, %rdi
callq 0x7310
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7780
jmp 0xaa61
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%r... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::assertString(doctest::assertType::Enum) | const char* assertString(assertType::Enum at) {
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4062) // enum 'x' in switch of enum 'y' is not handled
switch(at) { //!OCLINT missing default in switch statements
case assertType::DT_WARN : return "WARN";
case assertType::DT_CHECK ... | cmpl $0x20b, %edi # imm = 0x20B
jg 0xab35
cmpl $0x60, %edi
jg 0xab85
cmpl $0x20, %edi
jg 0xac0d
addl $-0x9, %edi
cmpl $0xb, %edi
ja 0xaecc
leaq 0x3f53c(%rip), %rax # 0x4a060
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x3f6df(%rip), %rax # 0x4a213
retq
cmpl $0x1009, %edi # im... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::skipPathFromFilename(char const*) | const char* skipPathFromFilename(const char* file) {
#ifndef DOCTEST_CONFIG_DISABLE
if(getContextOptions()->no_path_in_filenames) {
auto back = std::strrchr(file, '\\');
auto forward = std::strrchr(file, '/');
if(back || forward) {
if(back > forward)
forward = ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5a5d3(%rip), %rax # 0x654e8
movq (%rax), %rax
cmpb $0x1, 0x7c(%rax)
jne 0xaf50
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x7720
movq %rax, %r14
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x7720
cmpq %rax, %r14
movq %rax, %rcx
cmovaq %r14, %rcx
orq %rax, %r14
je 0xaf5... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::toString(long double) | String toString(double long in) { return fpToString(in, 15); } | pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rbx
fldt 0x1f0(%rsp)
fstpt 0x34(%rsp)
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x7730
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq $0xf, 0x68(%rsp,%rcx)
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx # imm = 0xFFFFFEFB
andl 0x78(%rsp,... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::toString(char) | DOCTEST_TO_STRING_OVERLOAD(char, "%d")
DOCTEST_TO_STRING_OVERLOAD(char signed, "%d")
DOCTEST_TO_STRING_OVERLOAD(char unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int short, "%d")
DOCTEST_TO_STRING_OVERLOAD(int short unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int, "%d")
DOCTEST_TO_STRING_OVERLOAD(unsigned, "%u")
DOCTEST_T... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %edx
movq %rdi, %rbx
leaq 0x3ef8d(%rip), %rsi # 0x4a45e
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x7800
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa554
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::toString(signed char) | DOCTEST_TO_STRING_OVERLOAD(char, "%d")
DOCTEST_TO_STRING_OVERLOAD(char signed, "%d")
DOCTEST_TO_STRING_OVERLOAD(char unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int short, "%d")
DOCTEST_TO_STRING_OVERLOAD(int short unsigned, "%u")
DOCTEST_TO_STRING_OVERLOAD(int, "%d")
DOCTEST_TO_STRING_OVERLOAD(unsigned, "%u")
DOCTEST_T... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %edx
movq %rdi, %rbx
leaq 0x3ef57(%rip), %rsi # 0x4a45e
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x7800
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa554
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::detail::Subcase::Subcase(doctest::String const&, char const*, int) | Subcase::Subcase(const String& name, const char* file, int line)
: m_signature({name, file, line}) {
auto* s = g_cs;
// check subcase filters
if(s->subcasesStack.size() < size_t(s->subcase_filter_levels)) {
if(!matchesAny(m_signature.m_name.c_str(), s->filters[6], true, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
callq 0xa5d0
movq %r14, 0x18(%rbx)
movl %ebp, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
leaq 0x59926(%rip), %rax # 0x654e8
movq (%rax), %r12
movq 0x1118(%r12), %rax
subq 0x1110(%r12), %rax
sarq $0x3, ... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::detail::registerExceptionTranslatorImpl(doctest::detail::IExceptionTranslator const*) | void registerExceptionTranslatorImpl(const IExceptionTranslator* et) {
if(std::find(getExceptionTranslators().begin(), getExceptionTranslators().end(), et) ==
getExceptionTranslators().end())
getExceptionTranslators().push_back(et);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rbx
movq %rdi, (%rbx)
callq 0xc4f6
movq 0x596cf(%rip), %r14 # 0x65b60
callq 0xc4f6
movq 0x596cb(%rip), %rsi # 0x65b68
movq %r14, %rdi
movq %rbx, %rdx
callq 0x47708
movq %rax, %rbx
callq 0xc4f6
cmpq 0x596b1(%rip), %rbx # 0x65b68
jne 0xc4ee
callq 0xc4f6
movq 0x596a... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::detail::toStream(std::ostream*, bool) | void toStream(std::ostream* s, bool in) { *s << std::boolalpha << in << std::noboolalpha; } | pushq %rax
movq (%rdi), %rax
movq -0x18(%rax), %rax
orl $0x1, 0x18(%rdi,%rax)
callq 0x7320
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
andl $-0x2, 0x18(%rax,%rcx)
popq %rax
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::detail::ContextScopeBase::destroy() | void ContextScopeBase::destroy() {
#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
if(std::uncaught_exceptions() > 0) {
#else
if(std::uncaught_exception()) {
#endif
... | pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, %rbx
callq 0x75f0
testl %eax, %eax
jle 0xc704
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x7730
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rax)
leaq 0x58e5a(%rip), %rax # 0x654e8
movl $0x10f8, %ebx # imm = 0x1... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::detail::ResultBuilder::ResultBuilder(doctest::assertType::Enum, char const*, int, char const*, char const*, char const*) | ResultBuilder::ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
const char* exception_type, const char* exception_string) {
m_test_case = g_cs->currentTest;
m_at = at;
m_file = file;
m_line ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r14
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
callq 0xa538
leaq 0x48(%r14), %rdi
callq 0xa538
movq 0x40(%rsp), %rax
leaq 0x58d26(%rip), %rcx # 0x654e8... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::detail::decomp_assert(doctest::assertType::Enum, char const*, int, char const*, doctest::detail::Result) | bool decomp_assert(assertType::Enum at, const char* file, int line, const char* expr,
Result result) {
bool failed = !result.m_passed;
// ###################################################################################
// IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %r8, %r15
movq %rcx, %r8
movl %edx, %ecx
movq %rsi, %rdx
movl %edi, %ebp
movb (%r15), %bl
movl %ebx, %r12d
xorb $0x1, %r12b
leaq 0x58758(%rip), %rax # 0x654e5
cmpb $0x0, (%rax)
je 0xce01
leaq 0x3d79d(%rip), %r9 # 0x4a536
movq %r9, (%r... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::detail::MessageBuilder::MessageBuilder(char const*, int, doctest::assertType::Enum) | MessageBuilder::MessageBuilder(const char* file, int line, assertType::Enum severity) {
m_stream = tlssPush();
m_file = file;
m_line = line;
m_severity = severity;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
callq 0xa538
movb $0x0, 0x30(%rbx)
callq 0xa325
movq %rax, 0x28(%rbx)
movq %r15, 0x18(%rbx)
movl %r14d, 0x20(%rbx)
movl %ebp, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
mo... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::detail::MessageBuilder::log() | bool MessageBuilder::log() {
if (!logged) {
m_string = tlssPop();
logged = true;
}
DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);
const bool isWarn = m_severity & assertType::is_warn;
// warn is just a message in this context so we don't... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x30(%rdi)
jne 0xcfc9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa38e
cmpq %rbx, %r14
je 0xcfbb
cmpb $0x0, 0x17(%rbx)
jns 0xcfa0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xcfa0
callq 0x72d0
movq 0x18(%rsp), %rax
movq %rax,... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::Context::parseArgs(int, char const* const*, bool) | void Context::parseArgs(int argc, const char* const* argv, bool withDefaults) {
using namespace detail;
// clang-format off
parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file=", p->filters[0]);
parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sf=", ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r15d
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10b8(%rax), %rcx
leaq 0x3d249(%rip), %rdx # 0x4a549
movl %esi, %edi
movq %r14, %rsi
callq 0xe77a
movq (%rbx), %rax
movq 0x10b8(%rax), %rcx
leaq... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::Context::~Context() | Context::~Context() {
if(g_cs == p)
g_cs = nullptr;
delete p;
} | pushq %rbx
leaq 0x56e74(%rip), %rax # 0x654e8
movq (%rax), %rcx
cmpq (%rdi), %rcx
jne 0xe683
movq $0x0, (%rax)
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xe6ff
leaq 0x1128(%rbx), %rdi
callq 0x2990e
leaq 0x1110(%rbx), %rdi
callq 0x2988a
leaq 0x10f8(%rbx), %rdi
callq 0x29848
movq 0x10d0(%rbx), %rdi
testq %rdi, %rdi
je 0x... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::parseIntOption(int, char const* const*, char const*, doctest::(anonymous namespace)::optionType, int&) | bool parseIntOption(int argc, const char* const* argv, const char* pattern, optionType type,
int& res) {
String parsedValue;
if(!parseOption(argc, argv, pattern, &parsedValue))
return false;
if(type == 0) {
// boolean
const char positi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %r13d
leaq 0x8(%rsp), %rdi
callq 0xa538
leaq 0x20(%rsp), %rdi
callq 0xa538
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %r8
movl %r13d, %edi
movq %r12, %rsi
movq %r15, %r... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::Context::clearFilters() | void Context::clearFilters() {
for(auto& curr : p->filters)
curr.clear();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rax
movq 0x10b8(%rax), %r14
movq 0x10c0(%rax), %r15
cmpq %r15, %r14
je 0xecc7
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r12, %r13
je 0xecc1
movq %r12, %rbx
movq %rbx, %rdi
callq 0xa540
addq $0x18, %rbx
cmpq %r13, %rbx
jne 0xecac
movq %r12, 0x8(%r14... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::Context::run() | int Context::run() {
using namespace detail;
// save the old context state in case such was setup - for using asserts out of a testing context
auto old_cs = g_cs;
// this is the current contest
g_cs = p;
is_running_in_test = true;
g_no_colors = p->no_colors;
p->resetRunDa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x378, %rsp # imm = 0x378
movq %rdi, %rbx
leaq 0x56739(%rip), %rcx # 0x654e8
movq (%rcx), %r15
movq (%rdi), %rax
movq %rax, (%rcx)
leaq 0x56726(%rip), %rax # 0x654e5
movb $0x1, (%rax)
movq (%rdi), %r14
movb 0x77(%r14), %bpl
movq ... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::detail::registerReporterImpl(char const*, int, doctest::IReporter* (*)(doctest::ContextOptions const&), bool) | void registerReporterImpl(const char* name, int priority, reporterCreatorFunc c, bool isReporter) {
if(isReporter)
getReporters().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
else
getListeners().insert(reporterMap::value_type(reporterMap::key_type(pr... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
testl %ecx, %ecx
je 0xfe8a
callq 0xfc3c
leaq 0x30(%rsp), %rbx
movl %ebp, -0x8(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa554
movl -0x8(%rbx), %eax
leaq 0x8(%rsp), %r15
movl %eax, -0x8(%r15)
movq %r15, %rdi
m... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::parseOptionImpl(int, char const* const*, char const*, doctest::String*) | bool parseOptionImpl(int argc, const char* const* argv, const char* pattern, String* value) {
// going from the end to the beginning and stopping on the first occurrence from the end
for(int i = argc; i > 0; --i) {
auto index = i - 1;
auto temp = std::strstr(argv[index], pattern)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
testl %edi, %edi
setg %bl
jle 0x1dda0
movq %rcx, %r14
movq %rdx, %r15
movl %edi, %r12d
movq %rcx, (%rsp)
movq 0x8(%rsp), %rax
movq -0x8(%rax,%r12,8), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x7360
testq %rax, %rax... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::FatalConditionHandler::handleSignal(int) | static void handleSignal(int sig) {
const char* name = "<unknown signal>";
for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
SignalDefs& def = signalDefs[i];
if(sig == def.id) {
name = def.name;
break;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edi, %ebx
leaq 0x2d3e1(%rip), %r14 # 0x4b202
movl $0x8, %ecx
leaq 0x46233(%rip), %rax # 0x64060
movl -0x8(%rcx,%rax), %edx
cmpl %ebx, %edx
jne 0x1de39
movq (%rcx,%rax), %r14
cmpl %ebx, %edx
je 0x1de4a
leaq 0x10(%rcx), %rdx
... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
cfgfile::string_trait_t::string_t cfgfile::to_cfgfile_format<cfgfile::string_trait_t>(cfgfile::string_trait_t::string_t const&) | static inline typename Trait::string_t to_cfgfile_format(
const typename Trait::string_t & what )
{
if( what.empty() )
return Trait::from_ascii( "\"\"" );
if( what.find( const_t< Trait >::c_begin_tag ) == Trait::string_t::npos &&
what.find( const_t< Trait >::c_end_tag ) == Trait::string_t::npos &&
wha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x1f3a0
movq %rsi, %r14
leaq 0x46fc6(%rip), %rax # 0x65fd0
movsbl (%rax), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x7840
cmpq $-0x1, %rax
jne 0x1f149
leaq 0x46fb8(%rip), %rax # 0x65fe0
m... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/string_format.hpp |
doctest::(anonymous namespace)::XmlReporter::report_query(doctest::QueryData const&) | void report_query(const QueryData& in) override {
test_run_start();
if(opt.list_reporters) {
for(auto& curr : getListeners())
xml.scopedElement("Listener")
.writeAttribute("priority", curr.first.first)
.w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, 0x40(%rsp)
movq 0x78(%rbx), %rax
cmpb $0x1, 0x86(%rax)
jne 0x2143c
callq 0xfc52
movq 0x449f9(%rip), %rbx # 0x65bd8
leaq 0x449e2(%rip), %rax # 0x65bc8
c... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_case_end(doctest::CurrentTestCaseStats const&) | void test_case_end(const CurrentTestCaseStats& st) override {
xml.startElement("OverallResultsAsserts")
.writeAttribute("successes",
st.numAssertsCurrentTest - st.numAssertsFailedCurrentTest)
.writeAttribute("failures", st.numAssert... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2bab3(%rip), %rsi # 0x4e036
leaq 0x2bac1(%rip), %rdx # 0x4e04b
movq %rsp, %rdi
callq 0x29f40
leaq 0x8(%r14), %rbx
movq %rsp, %rsi
movq %rbx, %rdi... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_case_exception(doctest::TestCaseException const&) | void test_case_exception(const TestCaseException& e) override {
std::lock_guard<std::mutex> lock(mutex);
xml.scopedElement("Exception")
.writeAttribute("crash", e.is_crash)
.writeText(e.error_string.c_str());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rdi), %rbx
movq %rbx, %rdi
callq 0x71d0
testl %eax, %eax
jne 0x22919
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2b8ac(%rip), %rsi # 0x4e0d2
leaq 0x2b8ae(%rip), %rdx # 0x4e0db
leaq 0x38(%rsp), %rdi
ca... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlReporter::log_assert(doctest::AssertData const&) | void log_assert(const AssertData& rb) override {
if(!rb.m_failed && !opt.success)
return;
std::lock_guard<std::mutex> lock(mutex);
xml.startElement("Expression")
.writeAttribute("success", !rb.m_failed)
.writeAttribute("type",... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r12
movq %rdi, %r13
cmpb $0x0, 0x28(%rsi)
jne 0x22bc9
movq 0x78(%r13), %rax
cmpb $0x1, 0x6c(%rax)
jne 0x230bc
leaq 0x50(%r13), %rdi
movq %rdi, 0x60(%rsp)
callq 0x71d0
testl %eax, %eax
jne 0x230ce
leaq 0x10(%rsp), %rax
movq %r... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_case_skipped(doctest::TestCaseData const&) | void test_case_skipped(const TestCaseData& in) override {
if(opt.no_skipped_summary == false) {
test_case_start_impl(in);
xml.writeAttribute("skipped", "true");
xml.endElement();
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x78(%rdi), %rax
cmpb $0x0, 0x7f(%rax)
jne 0x2359b
movq %rdi, %rbx
callq 0x24138
addq $0x8, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2bcee(%rip), %rsi # 0x4f247
leaq 0x2bcee(%rip), %rdx # 0x4f24e
movq %rsp, %r14
movq %r14, %rdi
callq 0x29f40... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlWriter& doctest::(anonymous namespace)::XmlWriter::writeAttribute<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
std::stringstream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7210
leaq 0x38(%rsp), %rdi
movl (%r15), %esi
callq 0x7230
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x7300
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlWriter::writeAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
if( !name.empty() && !attribute.empty() )
m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x239f2
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x239f2
movq %rsi, %r15
movq 0x40(%rbx), %rdi
leaq 0x10(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
callq 0x7780
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rax, %rdi
... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::operator<<(std::ostream&, doctest::(anonymous namespace)::XmlEncode const&) | std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
xmlEncode.encodeTo( os );
return os;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x23c80
movq %rsi, %r14
xorl %r15d, %r15d
leaq 0x2a3b3(%rip), %r13 # 0x4de01
movq %rsp, %r12
leaq 0x2a399(%rip), %rbp # 0x4ddf1
movq (%r14), %rax
movb (%rax,%r15), %dl
addq... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::(anonymous namespace)::hexEscapeChar(std::ostream&, unsigned char) | void hexEscapeChar(std::ostream& os, unsigned char c) {
std::ios_base::fmtflags f(os.flags());
os << "\\x"
<< std::uppercase << std::hex << std::setfill('0') << std::setw(2)
<< static_cast<int>(c);
os.flags(f);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %r15d
leaq 0x2a10e(%rip), %rsi # 0x4de08
movl $0x2, %edx
callq 0x7780
movq (%rbx), %rax
movq -0x18(%rax), %rcx
orl $0x4000, 0x18(%rbx,%rcx) # imm = 0x4000
movq -0x18(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlWriter& doctest::(anonymous namespace)::XmlWriter::writeAttribute<doctest::String>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, doctest::String const&) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
std::stringstream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7210
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0xaa1a
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x7300
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
c... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlWriter::writeAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | XmlWriter& XmlWriter::writeAttribute( std::string const& name, const char* attribute ) {
if( !name.empty() && attribute && attribute[0] != '\0' )
m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
return *this;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x23f78
movq %rsi, %r14
cmpq $0x0, 0x8(%rsi)
je 0x23f78
movq %rdx, %r15
cmpb $0x0, (%rdx)
je 0x23f78
movq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
callq 0x7780
movq (%r14), %rsi
mo... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlWriter& doctest::(anonymous namespace)::XmlWriter::writeAttribute<unsigned int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int const&) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
std::stringstream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7210
leaq 0x38(%rsp), %rdi
movl (%r15), %esi
callq 0x73c0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x7300
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::XmlWriter::ScopedElement::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) {
m_writer->writeText( text, indent );
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x24720
movl %edx, %ebp
movq %rsi, %r15
movq (%rbx), %r14
andb (%r14), %bpl
movq %r14, %rdi
callq 0x237b2
cmpb $0x1, %bpl
jne 0x246d0
movq 0x40(%r14), %rdi
movq 0x20(%r14), %rsi
movq 0x28(%r14), %r... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::JUnitReporter::test_run_end(doctest::TestRunStats const&) | void test_run_end(const TestRunStats& p) override {
// remove .exe extension - mainly to have the same output on UNIX and Windows
std::string binary_name = skipPathFromFilename(opt.binary_name.c_str());
#ifdef DOCTEST_PLATFORM_WINDOWS
if(binary_name.rfind(".exe") != std::string::npos... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %r13
movq 0xc0(%rdi), %rdi
cmpb $0x0, 0x1f(%rdi)
jns 0x24a74
movq 0x8(%rdi), %rdi
jmp 0x24a78
addq $0x8, %rdi
callq 0xaf07
leaq 0xd8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rax, %rsi
callq 0x295b6
leaq 0x18(%rsp... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::JUnitReporter::test_case_reenter(doctest::TestCaseData const&) | void test_case_reenter(const TestCaseData& in) override {
testCaseData.addTime(timer.getElapsedSeconds());
testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames);
deepestSubcaseStackNames.clear();
timer.start();
testCaseData.add(skipPathFromF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x98(%rdi), %rbx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x73b0
imulq $0xf4240, (%r12), %rax # imm = 0xF4240
addq 0x8(%r12), %rax
subq 0x78(%r15), %rax
movq %rax, %xmm0
punpckldq ... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::JUnitReporter::test_case_end(doctest::CurrentTestCaseStats const&) | void test_case_end(const CurrentTestCaseStats&) override {
testCaseData.addTime(timer.getElapsedSeconds());
testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames);
deepestSubcaseStackNames.clear();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x98(%rdi), %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x73b0
imulq $0xf4240, (%r15), %rax # imm = 0xF4240
addq 0x8(%r15), %rax
subq 0x78(%rbx), %rax
movq %rax, %xmm0
punpckldq 0x248e0(%rip), %xmm0 # xmm0 = xmm0[0],... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::JUnitReporter::log_assert(doctest::AssertData const&) | void log_assert(const AssertData& rb) override {
if(!rb.m_failed) // report only failures & ignore the `success` option
return;
std::lock_guard<std::mutex> lock(mutex);
std::ostringstream os;
os << skipPathFromFilename(rb.m_file) << (opt.gnu_file_line ? ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
cmpb $0x1, 0x28(%rsi)
jne 0x25e31
movq %rsi, %r15
movq %rdi, %r14
leaq 0x50(%rdi), %rbx
movq %rbx, %rdi
callq 0x71d0
testl %eax, %eax
jne 0x25e43
movq %rbx, 0x10(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x7730
movq 0x1... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::JUnitReporter::JUnitTestCaseData::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void add(const std::string& classname, const std::string& name) {
testcases.emplace_back(classname, name);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x8(%rdi), %r15
cmpq 0x10(%rdi), %r15
je 0x2602b
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2624e
addq $0x78, 0x8(%rbx)
jmp 0x261f0
movq (%rbx), %r14
movq %r15, %rax
subq %r14, %rax
movabsq $0x7fffffffff... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::fulltext_log_assert_to_stream(std::ostream&, doctest::AssertData const&) | void fulltext_log_assert_to_stream(std::ostream& s, const AssertData& rb) {
if((rb.m_at & (assertType::is_throws_as | assertType::is_throws_with)) ==
0) //!OCLINT bitwise operator in conditional
s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << " ) "
<< Co... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testb $0x60, 0x8(%rsi)
jne 0x2683c
movq %rbx, %rdi
movl $0x5, %esi
callq 0xaa6c
movl 0x8(%r14), %edi
callq 0xaafb
movq %rax, %r15
movq %rax, %rdi
callq 0x7310
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7780
leaq 0x23ca8(%rip), %rsi # 0x4a... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::IReporter* doctest::detail::reporterCreator<doctest::(anonymous namespace)::ConsoleReporter>(doctest::ContextOptions const&) | IReporter* reporterCreator(const ContextOptions& o) {
return new Reporter(o);
} | pushq %rbx
movq %rdi, %rbx
movl $0x70, %edi
callq 0x7140
leaq 0x3d3ce(%rip), %rcx # 0x64200
movq %rcx, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
xorl %ecx, %ecx
movq %rcx, 0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movq %rcx, 0x58(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x38(%rax)
movq %rbx, 0x... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::test_run_end(doctest::TestRunStats const&) | void test_run_end(const TestRunStats& p) override {
if(opt.minimal && p.numTestCasesFailed == 0)
return;
separator_to_stream();
s << std::dec;
auto totwidth = int(std::ceil(log10((std::max(p.numTestCasesPassingFilters, static_cast<unsigned>(p.numAsserts)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rax
cmpb $0x1, 0x70(%rax)
jne 0x27d09
cmpl $0x0, 0xc(%rbx)
jne 0x27d09
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %r12
movq %r12, %r... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::test_case_start(doctest::TestCaseData const&) | void test_case_start(const TestCaseData& in) override {
hasLoggedCurrentTestStart = false;
tc = ∈
subcasesStack.clear();
currentSubcaseLevel = 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
movq %rsi, 0x68(%rdi)
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r15, %r12
je 0x281dc
movq %r15, %r14
movq %r14, %rdi
callq 0xa540
addq $0x28, %r14
cmpq %r12, %r14
jne 0x281c7
movq %r15, 0x20(%rbx)
movq $0x0, 0x30(%rbx)
... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::test_case_end(doctest::CurrentTestCaseStats const&) | void test_case_end(const CurrentTestCaseStats& st) override {
if(tc->m_no_output)
return;
// log the preamble of the test case only if there is something
// else to print - something other than that an assert has failed
if(opt.duration ||
(... | movq 0x68(%rdi), %rax
cmpb $0x0, 0x3a(%rax)
je 0x28237
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x60(%rdi), %rax
cmpb $0x0, 0x6f(%rax)
jne 0x28256
cmpl $0x2, 0x10(%r14)
jb 0x2825e
movq %rbx, %rdi
callq 0x28c40
movq 0x60(%rbx), %rax
cmpb $0x1, 0x6f(%rax)
jne 0x2831... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::test_case_exception(doctest::TestCaseException const&) | void test_case_exception(const TestCaseException& e) override {
std::lock_guard<std::mutex> lock(mutex);
if(tc->m_no_output)
return;
logTestStart();
file_line_to_stream(tc->m_file.c_str(), tc->m_line, " ");
successOrFailColoredStringToStream(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x71d0
testl %eax, %eax
jne 0x286ea
movq 0x68(%r14), %rax
cmpb $0x0, 0x3a(%rax)
jne 0x286d4
movq %r14, %rdi
movq %rbx, (%rsp)
callq 0x28c40
movq (%r14), %rax
movq 0x68... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::log_message(doctest::MessageData const&) | void log_message(const MessageData& mb) override {
if(tc->m_no_output)
return;
std::lock_guard<std::mutex> lock(mutex);
logTestStart();
file_line_to_stream(mb.m_file, mb.m_line, " ");
s << getSuccessOrFailColor(false, mb.m_severity)
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x68(%rdi), %rax
cmpb $0x0, 0x3a(%rax)
je 0x287f5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %r15
movq %rdi, %r14
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x71d0
testl %eax, %eax
jne 0x288eb
movq %r14, %rdi
callq 0x28c40
movq 0x18(%r1... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::file_line_to_stream(char const*, int, char const*) | virtual void file_line_to_stream(const char* file, int line,
const char* tail = "") {
s << Color::LightGrey << skipPathFromFilename(file) << (opt.gnu_file_line ? ":" : "(")
<< (opt.no_line_numbers ? 0 : line) // 0 or the real num depending on the option
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq %r15, %rdi
movl $0x17, %esi
callq 0xaa6c
movq %r12, %rdi
callq 0xaf07
testq %rax, %rax
je 0x2898e
movq %rax, %r12
movq %rax, %rdi
callq 0x7310
movq %r15, %rdi
movq %r12, %rsi
... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::logTestStart() | void logTestStart() {
if(hasLoggedCurrentTestStart)
return;
separator_to_stream();
file_line_to_stream(tc->m_file.c_str(), tc->m_line, "\n");
if(tc->m_description)
s << Color::Yellow << "DESCRIPTION: " << Color::None << tc->m_description <... | cmpb $0x0, 0x10(%rdi)
jne 0x28fdd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq %r14, %rdi
movl $0x6, %esi
callq 0xaa6c
leaq 0x26542(%rip), %rsi # 0x4f1b2
movl $0x50, %edx
movq %r14, %rdi
callq 0x7780
movq (%rbx), %rax
movq 0x68(%rbx), %rcx
cm... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::DiscardOStream::DiscardOStream() | DiscardOStream()
: std::ostream(&discardBuf) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x448(%rdi), %r14
movq %r14, %rdi
callq 0x77a0
movq $0x0, 0x520(%rbx)
movw $0x0, 0x528(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x530(%rbx)
movups %xmm0, 0x540(%rbx)
leaq 0x8(%rbx), %rsi
leaq 0x3b0c4(%rip), %rax # 0x64340
leaq 0x18(%rax), %rcx
movq %rcx, (%rbx)
ad... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::detail::ContextState::finalizeTestCaseData() | void finalizeTestCaseData() {
seconds = timer.getElapsedSeconds();
// update the non-atomic counters
numAsserts += numAssertsCurrentTest_atomic;
numAssertsFailed += numAssertsFailedCurrentTest_atomic;
numAssertsCurrentTest = numAssertsCurrentTest_atomic... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x18(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x73b0
imulq $0xf4240, (%r14), %rax # imm = 0xF4240
addq 0x8(%r14), %rax
subq 0x10f0(%rbx), %rax
movq %rax, %xmm0
punpckldq 0x20c7b(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
cfgfile::input_stream_t<cfgfile::string_trait_t>::input_stream_t(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::istream&) | input_stream_t( const typename Trait::string_t & file_name,
typename Trait::istream_t & input )
: m_stream( input )
, m_line_number( 1 )
, m_column_number( 1 )
, m_file_name( file_name )
, m_buf_pos( 0 )
, m_stream_pos( 0 )
{
Trait::noskipws( m_stream );
m_stream_size = Trait::size_of_fil... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, (%rdi)
movl $0x1, %eax
movq %rax, 0x8(%rdi)
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x28(%r15)
movups %xmm0, 0x38(%r15)
movups %xmm0, 0x4... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/input_stream.hpp |
FirstTag::FirstTag() | FirstTag()
: cfgfile::tag_t<>( "firstTag", false )
, m_started( false )
, m_finished( false )
, m_withString( false )
, m_child( *this )
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x215fc(%rip), %rsi # 0x4b33e
leaq 0x215fd(%rip), %rdx # 0x4b346
movq %rsp, %rdi
callq 0x29f40
leaq 0x3a758(%rip), %rax # 0x644b0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0... | /igormironchik[P]cfgfile/tests/auto/Parser/main.cpp |
cfgfile::input_stream_t<cfgfile::string_trait_t>::~input_stream_t() | ~input_stream_t()
{
} | pushq %rbx
movq %rdi, %rbx
movq 0xd8(%rdi), %rdi
testq %rdi, %rdi
je 0x29f0f
movq 0xe8(%rbx), %rsi
subq %rdi, %rsi
callq 0x7100
leaq 0x88(%rbx), %rdi
callq 0x2a61c
movq 0x68(%rbx), %rdi
leaq 0x78(%rbx), %rax
cmpq %rax, %rdi
je 0x29f33
movq (%rax), %rsi
incq %rsi
callq 0x7100
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
j... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/input_stream.hpp |
cfgfile::tag_t<cfgfile::string_trait_t>::tag_t(cfgfile::tag_t<cfgfile::string_trait_t>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | tag_t( tag_t< Trait > & owner, const typename Trait::string_t & name,
bool is_mandatory = false )
: m_name( name )
, m_is_mandatory( is_mandatory )
, m_is_defined( false )
, m_parent( nullptr )
, m_line_number( -1 )
, m_column_number( -1 )
{
owner.add_child( *this );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %r12
movq %rdi, %r15
leaq 0x39c92(%rip), %rax # 0x644b0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r14
movq %r14, 0x8(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
mo... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/tag.hpp |
ThirdTag::ThirdTag(cfgfile::tag_t<cfgfile::string_trait_t>&) | explicit ThirdTag( tag_t<> & owner )
: cfgfile::tag_t<>( owner, "thirdTag", false )
, m_started( false )
, m_finished( false )
, m_withString( false )
{
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x20ab0(%rip), %rsi # 0x4b382
leaq 0x20ab1(%rip), %rdx # 0x4b38a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x29f40
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl ... | /igormironchik[P]cfgfile/tests/auto/Parser/main.cpp |
cfgfile::details::parser_conffile_impl_t<cfgfile::string_trait_t>::start_tag_parsing(cfgfile::tag_t<cfgfile::string_trait_t> const&, std::vector<cfgfile::tag_t<cfgfile::string_trait_t>*, std::allocator<cfgfile::tag_t<cfgfile::string_trait_t>*>> const&) | void start_tag_parsing( const tag_t< Trait > & parent,
const typename tag_t< Trait >::child_tags_list_t & list )
{
lexeme_t< Trait > lexeme = m_lex.next_lexeme();
bool tag_found = false;
for( tag_t< Trait > * tag : list )
{
if( start_tag_parsing( lexeme, *tag ) )
{
tag_found = true;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
leaq 0x60(%rdi), %rsi
leaq 0x130(%rsp), %rdi
movq %rsi, (%rsp)
callq 0x2caa2
movq (%rbx), %r13
movq 0x8(%rbx), %rbp
cmpq %rbp, %r13
je 0x2dbbe
addq $0x8, %r13... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/parser.hpp |
cfgfile::details::parser_base_t<cfgfile::string_trait_t>::check_parser_state_after_parsing() | void check_parser_state_after_parsing()
{
if( !m_stack.empty() )
throw exception_t< Trait >(
Trait::from_ascii( "Unexpected end of file. "
"Still unfinished tag \"" ) + m_stack.top()->name() +
Trait::from_ascii( "\"." ) );
if( m_tag.is_mandatory() && !m_tag.is_defined() )
throw excepti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %r14
movq 0x40(%rdi), %rax
cmpq 0x20(%rdi), %rax
jne 0x2e2a1
movq 0x8(%r14), %rdi
cmpb $0x1, 0x28(%rdi)
jne 0x2e28f
callq 0x2fe22
testb %al, %al
je 0x2e3ac
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
pop... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/parser.hpp |
cfgfile::details::parser_conffile_impl_t<cfgfile::string_trait_t>::start_tag_parsing(cfgfile::lexeme_t<cfgfile::string_trait_t> const&, cfgfile::tag_t<cfgfile::string_trait_t>&) | bool start_tag_parsing( const lexeme_t< Trait > & lexeme,
tag_t< Trait > & tag )
{
if( lexeme.type() == lexeme_type_t::start )
throw exception_t< Trait >(
Trait::from_ascii( "Unexpected start curl brace. "
"We expected tag name, but we've got start curl brace. "
"In file \"" ) + m_lex.input... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, %rbx
movl (%rsi), %eax
testl %eax, %eax
je 0x2e6ab
cmpl $0x2, %eax
je 0x2e83a
cmpl $0x1, %eax
je 0x2e9c9
movq %rdx, %r14
movq 0x10(%rdx), %rdx
cmpq 0x10(%rsi), %rdx
jne 0x2e607
testq %rdx, %rdx
je 0x2... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/parser.hpp |
cfgfile::input_stream_t<cfgfile::string_trait_t>::get() | typename Trait::char_t get()
{
if( !at_end() )
{
m_prev_positions.push( { m_column_number, m_line_number } );
m_column_number += 1;
typename Trait::char_t ch( 0x00 );
if( !m_returned_char.empty() )
{
ch = m_returned_char.top();
m_returned_char.pop();
if( is_new_line(... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x2f078
testb %al, %al
je 0x2f100
xorl %eax, %eax
jmp 0x2f1e1
leaq 0x18(%rbx), %rdi
movdqu 0x8(%rbx), %xmm0
pshufd $0x4e, %xmm0, %xmm0 # xmm0 = xmm0[2,3,0,1]
movq %rsp, %r14
movdqa %xmm0, (%r14)
movq %r14, %rsi
callq 0x2f7b8
incq 0x10(%rbx)
movb $0x0, (%r... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/input_stream.hpp |
cfgfile::lexical_analyzer_t<cfgfile::string_trait_t>::process_back_slash(char&) | bool process_back_slash( typename Trait::char_t & ch )
{
if( m_stream.at_end() )
throw exception_t< Trait >(
Trait::from_ascii( "Unexpected end of file. "
"Unfinished back slash sequence. In file \"" ) +
m_stream.file_name() + Trait::from_ascii( "\" on line " ) +
Trait::to_string( m_stream... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x2f078
testb %al, %al
jne 0x2f30f
movq (%r14), %rdi
callq 0x2f0e6
movb %al, (%rbx)
leaq 0x36daa(%rip), %rcx # 0x66050
cmpb (%rcx), %al
jne 0x2f2b3
lea... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/lex.hpp |
cfgfile::lexical_analyzer_t<cfgfile::string_trait_t>::skip_multi_line_comment() | void skip_multi_line_comment()
{
if( !m_stream.at_end() )
{
typename Trait::char_t ch = m_stream.get();
if( m_stream.at_end() )
return;
typename Trait::char_t next_char = m_stream.get();
if( ch == const_t< Trait >::c_sharp &&
next_char == const_t< Trait >::c_vertical_bar )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2f078
testb %al, %al
jne 0x2f724
movq (%rbx), %rdi
callq 0x2f0e6
movl %eax, %r14d
movq (%rbx), %rdi
callq 0x2f078
testb %al, %al
jne 0x2f724
movq (%rbx), %rdi
callq 0x2f0e6
movl %eax, %ebp
leaq 0x36953(%rip), %r15 # 0x6... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/lex.hpp |
cfgfile::input_stream_t<cfgfile::string_trait_t>::is_new_line(char&) | bool is_new_line( typename Trait::char_t & ch )
{
if( ch == const_t< Trait >::c_carriage_return )
return true;
else if( ch == const_t< Trait >::c_line_feed )
{
typename Trait::char_t next_char( 0x00 );
next_char = simple_get();
if( next_char == const_t< Trait >::c_carriage_return )
{
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movb (%rsi), %al
leaq 0x368d1(%rip), %r12 # 0x66010
movb $0x1, %bl
cmpb (%r12), %al
je 0x2f7aa
leaq 0x368d2(%rip), %rcx # 0x66020
cmpb (%rcx), %al
jne 0x2f771
movq %rsi, %r15
movq %rdi, %r14
movb $0x0, 0x7(%rsp)
callq 0x2fa62
movb %al, 0x7(%rsp)
cmpb (%r12)... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/input_stream.hpp |
doctest::String doctest::detail::stringifyBinaryExpr<bool, bool>(bool const&, char const*, bool const&) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x1baa0(%rip), %r13 # 0x4b9d5
cmpb $0x0, (%rsi)
leaq 0x1b882(%rip), %r15 # 0x4b7c1
movq %r15, %rsi
cmovneq %r13, %rsi
leaq 0x30(%rsp), %rdi
callq 0xa554
leaq 0x18(%rsp), %rdi
movq %r12, %... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
FirstTagWithMandatory::FirstTagWithMandatory() | FirstTagWithMandatory()
: cfgfile::tag_t<>( "firstTag", false )
, m_started( false )
, m_finished( false )
, m_withString( false )
, m_child( *this )
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1b316(%rip), %rsi # 0x4b33e
leaq 0x1b317(%rip), %rdx # 0x4b346
movq %rsp, %rdi
callq 0x29f40
leaq 0x34472(%rip), %rax # 0x644b0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0... | /igormironchik[P]cfgfile/tests/auto/Parser/main.cpp |
doctest::String doctest::detail::StringMakerBase<true>::convert<char [37]>(char const (&) [37]) | static String convert(const DOCTEST_REF_WRAP(T) in) {
/* When parameter "in" is a null terminated const char* it works.
* When parameter "in" is a T arr[N] without '\0' we can fill the
* stringstream with N objects (T=char).If in is char pointer *
* without '\0' , it w... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa325
movq %rax, %r15
movq %rbx, %rdi
callq 0x7310
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7780
movq %r14, %rdi
callq 0xa38e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::detail::Expression_lhs<bool const>::operator doctest::detail::Result() | DOCTEST_NOINLINE operator Result() {
// this is needed only for MSVC 2015
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4800) // 'int': forcing value to bool
bool res = static_cast<bool>(lhs);
DOCTEST_MSVC_SUPPRESS_WARNING_POP
if(m_at & assertType::is_false) //!OCLINT bitwise operator in conditional
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb (%rsi), %al
movb 0x5(%rsi), %bpl
xorb %al, %bpl
testb $0x1, %bpl
je 0x30514
leaq 0x34fdd(%rip), %rcx # 0x654e8
movq (%rcx), %rcx
cmpb $0x1, 0x6c(%rcx)
jne 0x30549
leaq 0x1b4ba(%rip), %rcx # 0x4b9d5
leaq 0x1b29f(%rip), %rsi # 0x4b7c1
test... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [117]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [117]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x308d2
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::StringMakerBase<true>::convert<char [117]>(char const (&) [117]) | static String convert(const DOCTEST_REF_WRAP(T) in) {
/* When parameter "in" is a null terminated const char* it works.
* When parameter "in" is a T arr[N] without '\0' we can fill the
* stringstream with N objects (T=char).If in is char pointer *
* without '\0' , it w... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa325
movq %rax, %r15
movq %rbx, %rdi
callq 0x7310
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7780
movq %r14, %rdi
callq 0xa38e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [137]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [137]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x30a8e
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [57]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [57]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x30c4a
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [32]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [32]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x30e3a
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::StringMakerBase<true>::convert<char [115]>(char const (&) [115]) | static String convert(const DOCTEST_REF_WRAP(T) in) {
/* When parameter "in" is a null terminated const char* it works.
* When parameter "in" is a T arr[N] without '\0' we can fill the
* stringstream with N objects (T=char).If in is char pointer *
* without '\0' , it w... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa325
movq %rax, %r15
movq %rbx, %rdi
callq 0x7310
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7780
movq %r14, %rdi
callq 0xa38e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [92]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [92]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x311b2
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [128]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [128]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3136e
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::StringMakerBase<true>::convert<char [128]>(char const (&) [128]) | static String convert(const DOCTEST_REF_WRAP(T) in) {
/* When parameter "in" is a null terminated const char* it works.
* When parameter "in" is a T arr[N] without '\0' we can fill the
* stringstream with N objects (T=char).If in is char pointer *
* without '\0' , it w... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa325
movq %rax, %r15
movq %rbx, %rdi
callq 0x7310
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7780
movq %r14, %rdi
callq 0xa38e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [109]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [109]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x325c8
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [54]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [54]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x32784
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
cfgfile::tag_scalar_vector_t<int, cfgfile::string_trait_t>::set_value(int const&) | void
set_value( const T & v )
{
if( m_constraint )
{
if( !m_constraint->check( v ) )
throw exception_t< Trait >(
Trait::from_ascii( "Invalid value: \"" ) +
typename Trait::string_t(
format_t< T, Trait >::to_string( v ) ) +
Trait::from_ascii( "\". Value must match to the "
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %r15
movq %rdi, %r14
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x327eb
movq (%rdi), %rax
movq %r15, %rsi
callq *0x10(%rax)
testb %al, %al
je 0x32827
movq 0x68(%r14), %rsi
cmpq 0x70(%r14), %rsi
je 0x32... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/tag_scalar_vector.hpp |
cfgfile::tag_scalar_vector_t<int, cfgfile::string_trait_t>::on_finish(cfgfile::parser_info_t<cfgfile::string_trait_t> const&) | void on_finish( const parser_info_t< Trait > & info ) override
{
for( const tag_t< Trait > * tag : this->children() )
{
if( tag->is_mandatory() && !tag->is_defined() )
throw exception_t< Trait >(
Trait::from_ascii( "Undefined child mandatory tag: \"" ) +
tag->name() +
Trait::from_asci... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rax), %rbx
movq 0x8(%rax), %r13
cmpq %r13, %rbx
je 0x32ed4
movq (%rbx), %r12
cmpb $0x1, 0x28(%r12)
jne 0x32ece
movq %r12, %rdi
callq 0x2... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/tag_scalar_vector.hpp |
doctest::String doctest::detail::StringMakerBase<true>::convert<char [130]>(char const (&) [130]) | static String convert(const DOCTEST_REF_WRAP(T) in) {
/* When parameter "in" is a null terminated const char* it works.
* When parameter "in" is a T arr[N] without '\0' we can fill the
* stringstream with N objects (T=char).If in is char pointer *
* without '\0' , it w... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa325
movq %rax, %r15
movq %rbx, %rdi
callq 0x7310
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7780
movq %r14, %rdi
callq 0xa38e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [78]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [78]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3751e
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::StringMakerBase<true>::convert<char [122]>(char const (&) [122]) | static String convert(const DOCTEST_REF_WRAP(T) in) {
/* When parameter "in" is a null terminated const char* it works.
* When parameter "in" is a T arr[N] without '\0' we can fill the
* stringstream with N objects (T=char).If in is char pointer *
* without '\0' , it w... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa325
movq %rax, %r15
movq %rbx, %rdi
callq 0x7310
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7780
movq %r14, %rdi
callq 0xa38e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::StringMakerBase<true>::convert<char [100]>(char const (&) [100]) | static String convert(const DOCTEST_REF_WRAP(T) in) {
/* When parameter "in" is a null terminated const char* it works.
* When parameter "in" is a T arr[N] without '\0' we can fill the
* stringstream with N objects (T=char).If in is char pointer *
* without '\0' , it w... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa325
movq %rax, %r15
movq %rbx, %rdi
callq 0x7310
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7780
movq %r14, %rdi
callq 0xa38e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
cfgfile::tag_t<cfgfile::string_trait_t>::~tag_t() | virtual ~tag_t()
{
} | pushq %rbx
movq %rdi, %rbx
leaq 0x2cbd5(%rip), %rax # 0x644b0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x378f7
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x7100
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x37910
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x7100
popq... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/tag.hpp |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [83]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [83]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3986a
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::StringMakerBase<true>::convert<char [129]>(char const (&) [129]) | static String convert(const DOCTEST_REF_WRAP(T) in) {
/* When parameter "in" is a null terminated const char* it works.
* When parameter "in" is a T arr[N] without '\0' we can fill the
* stringstream with N objects (T=char).If in is char pointer *
* without '\0' , it w... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa325
movq %rax, %r15
movq %rbx, %rdi
callq 0x7310
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7780
movq %r14, %rdi
callq 0xa38e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [126]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [126]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3bf14
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
cfgfile::tag_vector_of_tags_t<cfgfile::tag_scalar_t<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cfgfile::string_trait_t>, cfgfile::string_trait_t>::on_start(cfgfile::parser_info_t<cfgfile::string_trait_t> const&) | void on_start( const parser_info_t< Trait > & info ) override
{
m_current = std::make_shared< T > ( this->name(), this->is_mandatory() );
m_current->set_parent( this->parent() );
m_current->on_start( info );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rcx
movb 0x28(%rdi), %al
leaq 0xe(%rsp), %r8
movb %al, (%r8)
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x3c192
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
mov... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/tag_vector_of_tags.hpp |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [7]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const (&) [7]) | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return toString(lhs) + op + toString(rhs);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3047e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xa554
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xa902
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3c6c4
leaq 0x48(... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../3rdparty/doctest/doctest.h |
cfgfile::tag_scalar_t<QString, cfgfile::qstring_trait_t>::on_finish(cfgfile::parser_info_t<cfgfile::qstring_trait_t> const&) | void on_finish( const parser_info_t< Trait > & info ) override
{
if( m_constraint )
{
if( !m_constraint->check( m_value ) )
throw exception_t< Trait >(
Trait::from_ascii( "Invalid value: \"" ) +
typename Trait::string_t( m_value ) +
Trait::from_ascii( "\". Value must match to the "
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rsi, %r14
movq %rdi, %r15
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x3d834
leaq 0x58(%r15), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x3dd23
cmpb $0x0, 0x21(%r15)
je 0x3db0c
movq (%r15),... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/tag_scalar.hpp |
cfgfile::lexical_analyzer_t<cfgfile::qstring_trait_t>::next_lexeme() | lexeme_t< Trait > next_lexeme()
{
typename Trait::string_t result;
bool quoted_lexeme = false;
bool first_symbol = true;
bool skip_comment = false;
skip_spaces();
m_line_number = m_stream.line_number();
m_column_number = m_stream.column_number();
if( m_stream.at_end() )
return lexe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movq %rsi, %rdi
callq 0x43bf0
movq (%rbx), %r14
movups 0x8(%r14), %xmm0
movups %xmm0, 0x8(%rbx)
movq 0xb0(%r14), ... | /igormironchik[P]cfgfile/tests/auto/Parser/../../../cfgfile/lex.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.