name string | code string | asm string | file string |
|---|---|---|---|
void spirv_cross::CompilerGLSL::statement<char const (&) [29], unsigned int, char const (&) [2], char const&, char const (&) [20], unsigned int&, char const (&) [3]>(char const (&) [29], unsigned int&&, char const (&) [2], char const&, char const (&) [20], unsigned int&, char const (&) [3]) | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, %r15
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %r14
callq 0x23119e
testb %al, %al
jne 0x12f007
movq %r15, (%rsp)
movq %r14,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
void spirv_cross::CompilerGLSL::statement<char const (&) [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [4], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [2], std::__cxx11::basic_string<char, std::char_traits<char>... | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, %r15
movq %rcx, 0x10(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %r14
callq 0x23119e
testb %al, %al
jne 0x12f727
movq %r15, (%rsp)
movq %r14,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
spirv_cross::SPIRExpression* spirv_cross::ObjectPool<spirv_cross::SPIRExpression>::allocate<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int&, bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, unsigned int&, bool&&) | T *allocate(P &&... p)
{
if (vacants.empty())
{
unsigned num_objects = start_object_count << memory.size();
T *ptr = static_cast<T *>(malloc(num_objects * sizeof(T)));
if (!ptr)
return nullptr;
vacants.reserve(num_objects);
for (unsigned i = 0; i < num_objects; i++)
vacants.push_back(&ptr[i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r15
leaq 0x8(%rdi), %r12
movq 0x10(%rdi), %rax
testq %rax, %rax
jne 0x1305f6
movq %rdi, %r13
movq %rbp, 0x10(%rsp)
movl 0x80(%rdi), %ebp
movb 0x30(%rdi), %cl
shll %cl, %ebp
imulq $0xb8, %rbp, %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross_containers.hpp |
spirv_cross::SPIRExpression::SPIRExpression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, spirv_cross::TypedID<(spirv_cross::Types)1>, bool) | SPIRExpression(std::string expr, TypeID expression_type_, bool immutable_)
: expression(std::move(expr))
, expression_type(expression_type_)
, immutable(immutable_)
{
} | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
andq $0x0, 0x8(%rdi)
leaq 0x2b890d(%rip), %rax # 0x3e9078
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0x297a0
movl %ebp, 0x30(%r14)
andl $0x0, 0x34(%r14)
movb %bl, 0x38(%r14)
xorl %eax, %eax
movb %al, 0x39(%r14)
movb %al, 0x3a(%r14)
movb %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_common.hpp |
spirv_cross::CompilerGLSL::force_temporary_and_recompile(unsigned int) | void CompilerGLSL::force_temporary_and_recompile(uint32_t id)
{
auto res = forced_temporaries.insert(id);
// Forcing new temporaries guarantees forward progress.
if (res.second)
force_recompile_guarantee_forward_progress();
else
force_recompile();
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
addq $0x960, %rdi # imm = 0x960
movq %rax, %rsi
callq 0x7af8e
movq %rbx, %rdi
testb $0x1, %dl
je 0x1d9d1d
callq 0x231194
jmp 0x1d9d22
callq 0x228daa
addq $0x10, %rsp
popq %rbx
retq
| /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.cpp |
spirv_cross::CompilerGLSL::handle_invalid_expression(unsigned int) | void CompilerGLSL::handle_invalid_expression(uint32_t id)
{
// We tried to read an invalidated expression.
// This means we need another pass at compilation, but next time,
// force temporary variables so that they cannot be invalidated.
force_temporary_and_recompile(id);
// If the invalid expression happened as ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl %esi, (%r14)
callq 0x1d9cf0
leaq 0x2550(%rbx), %rdi
movq %r14, %rsi
callq 0x97c16
testq %rax, %rax
je 0x1da0d6
addq $0x2588, %rbx # imm = 0x2588
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x7af8e
addq $0x8, %rsp
popq %rbx
popq %r14
ret... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.cpp |
void spirv_cross::CompilerGLSL::statement<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [4], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>... | inline void statement(Ts &&... ts)
{
if (is_forcing_recompilation())
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
return;
}
if (redirect_statement)
{
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
statement_co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x38(%rsp)
movq %r8, 0x28(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq 0xc0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xb0(%rsp), %r15
movq 0xa8(%rsp)... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_glsl.hpp |
spirv_cross::Compiler::get_variable_element_type(spirv_cross::SPIRVariable const&) const | const SPIRType &Compiler::get_variable_element_type(const SPIRVariable &var) const
{
const SPIRType *type = &get_variable_data_type(var);
if (is_array(*type))
type = &get<SPIRType>(type->parent_type);
return *type;
} | pushq %rbx
movq %rdi, %rbx
callq 0x22a5b4
movl 0xc(%rax), %ecx
andl $-0x2, %ecx
cmpl $0x1c, %ecx
jne 0x22a611
movl 0x114(%rax), %esi
movq %rbx, %rdi
popq %rbx
jmp 0x118090
popq %rbx
retq
nop
| /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
spirv_cross::Compiler::set_extended_member_decoration(unsigned int, unsigned int, spirv_cross::ExtendedDecorations, unsigned int) | void Compiler::set_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration,
uint32_t value)
{
ir.meta[type].members.resize(max(ir.meta[type].members.size(), size_t(index) + 1));
auto &dec = ir.meta[type].members[index];
dec.extended.flags... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x8(%rsp)
movl %ecx, %ebp
movl %edx, %r13d
movl %esi, %r12d
movq %rdi, %r15
movl $0x100, %r14d # imm = 0x100
addq %r14, %r15
leaq 0x14(%rsp), %rsi
movl %r12d, (%rsi)
movq %r15, %rdi
callq 0x1365f4
leaq 0x188(%rax), %... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
spirv_cross::Compiler::has_extended_member_decoration(unsigned int, unsigned int, spirv_cross::ExtendedDecorations) const | bool Compiler::has_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration) const
{
auto *m = ir.find_meta(type);
if (!m)
return false;
if (index >= m->members.size())
return false;
auto &dec = m->members[index];
return dec.extended.flags.get(decoration);
} | pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
addq $0x8, %rdi
callq 0x23e056
testq %rax, %rax
je 0x22a9be
movl %ebp, %ecx
cmpq %rcx, 0x190(%rax)
jbe 0x22a9be
movq 0x188(%rax), %rax
imulq $0x188, %rcx, %rcx # imm = 0x188
leaq (%rax,%rcx), %rdi
addq $0x100, %rdi # imm = 0x100
movl %ebx,... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
spirv_cross::Compiler::unset_extended_member_decoration(unsigned int, unsigned int, spirv_cross::ExtendedDecorations) | void Compiler::unset_extended_member_decoration(uint32_t type, uint32_t index, ExtendedDecorations decoration)
{
ir.meta[type].members.resize(max(ir.meta[type].members.size(), size_t(index) + 1));
auto &dec = ir.meta[type].members[index];
dec.extended.flags.clear(decoration);
dec.extended.values[decoration] = 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r15
movl $0x100, %r14d # imm = 0x100
addq %r14, %r15
leaq 0x14(%rsp), %rsi
movl %ebp, (%rsi)
movq %r15, %rdi
callq 0x1365f4
leaq 0x188(%rax), %r13
leaq 0x10(%rsp), %r... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
spirv_cross::Compiler::block_is_noop(spirv_cross::SPIRBlock const&) const | bool Compiler::block_is_noop(const SPIRBlock &block) const
{
if (block.terminator != SPIRBlock::Direct)
return false;
auto &child = get<SPIRBlock>(block.next_block);
// If this block participates in PHI, the block isn't really noop.
for (auto &phi : block.phi_variables)
if (phi.parent == block.self || phi.par... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1, 0xc(%rsi)
jne 0x22ac5d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rsi), %esi
callq 0x23221c
movq 0xc0(%r14), %rdx
movl 0x8(%r14), %ecx
movl 0x8(%rax), %esi
imulq $0xc, 0xc8(%r14), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x22ac39
movl 0x4(%rdx), %r8d
cmp... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
spirv_cross::Compiler::execution_is_noop(spirv_cross::SPIRBlock const&, spirv_cross::SPIRBlock const&) const | bool Compiler::execution_is_noop(const SPIRBlock &from, const SPIRBlock &to) const
{
if (!execution_is_branchless(from, to))
return false;
auto *start = &from;
for (;;)
{
if (start->self == to.self)
return true;
if (!block_is_noop(*start))
return false;
auto &next = get<SPIRBlock>(start->next_block... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x22b090
testb %al, %al
je 0x22b080
movl 0x8(%r15), %eax
cmpl 0x8(%rbx), %eax
sete %bpl
je 0x22b082
movq %r14, %rdi
movq %r15, %rsi
callq 0x22abe8
testb %al, %al
je 0x22b082
movl 0x18(%r15), %esi
movq %r14, %rdi... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
spirv_cross::Compiler::execution_is_branchless(spirv_cross::SPIRBlock const&, spirv_cross::SPIRBlock const&) const | bool Compiler::execution_is_branchless(const SPIRBlock &from, const SPIRBlock &to) const
{
auto *start = &from;
for (;;)
{
if (start->self == to.self)
return true;
if (start->terminator == SPIRBlock::Direct && start->merge == SPIRBlock::MergeNone)
start = &get<SPIRBlock>(start->next_block);
else
retu... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movl 0x8(%rax), %ecx
movl 0x8(%rbx), %edx
cmpl %edx, %ecx
je 0x22b0c0
cmpl $0x1, 0xc(%rax)
jne 0x22b0c0
cmpl $0x0, 0x10(%rax)
jne 0x22b0c0
movl 0x18(%rax), %esi
movq %r14, %rdi
callq 0x23221c
jmp 0x22b09d
cmpl %edx, %ecx
sete %al
addq $0x8... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
spirv_cross::Compiler::get_case_list(spirv_cross::SPIRBlock const&) const | const SmallVector<SPIRBlock::Case> &Compiler::get_case_list(const SPIRBlock &block) const
{
uint32_t width = 0;
// First we check if we can get the type directly from the block.condition
// since it can be a SPIRConstant or a SPIRVariable.
if (const auto *constant = maybe_get<SPIRConstant>(block.condition))
{
c... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x28(%rsi), %esi
callq 0x204dde
testq %rax, %rax
je 0x22b2cd
movl 0xc(%rax), %esi
jmp 0x22b2e4
leaq 0x28(%rbx), %r15
movl (%r15), %esi
movq %r14, %rdi
callq 0x23224c
testq %rax, %rax
je 0x22b30e
movl 0x48(%rax), %esi
movq %r14, %rdi
callq 0x118090
ad... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
spirv_cross::Compiler::traverse_all_reachable_opcodes(spirv_cross::SPIRBlock const&, spirv_cross::Compiler::OpcodeHandler&) const | bool Compiler::traverse_all_reachable_opcodes(const SPIRBlock &block, OpcodeHandler &handler) const
{
handler.set_current_block(block);
handler.rearm_current_block(block);
// Ideally, perhaps traverse the CFG instead of all blocks in order to eliminate dead blocks,
// but this shouldn't be a problem in practice un... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x28(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq 0x48(%rbx), %r12
movq %rbx, (%rsp)
imulq $0xc, 0x50(%rbx), %rbp
testq ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
spirv_cross::Compiler::type_struct_member_array_stride(spirv_cross::SPIRType const&, unsigned int) const | uint32_t Compiler::type_struct_member_array_stride(const SPIRType &type, uint32_t index) const
{
auto *type_meta = ir.find_meta(type.member_types[index]);
if (type_meta)
{
// Decoration must be set in valid SPIR-V, otherwise throw.
// ArrayStride is part of the array type not OpMemberDecorate.
auto &dec = type... | pushq %r14
pushq %rbx
pushq %rax
addq $0x8, %rdi
movl %edx, %eax
movq 0x88(%rsi), %rcx
movl (%rcx,%rax,4), %esi
callq 0x23e056
testq %rax, %rax
je 0x22b589
testb $0x40, 0x80(%rax)
je 0x22b5a5
movl 0xe4(%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x29290
movq %rax, %rbx
leaq 0x80d0b(... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
spirv_cross::Compiler::evaluate_spec_constant_u32(spirv_cross::SPIRConstantOp const&) const | uint32_t Compiler::evaluate_spec_constant_u32(const SPIRConstantOp &spec) const
{
auto &result_type = get<SPIRType>(spec.basetype);
if (result_type.basetype != SPIRType::UInt && result_type.basetype != SPIRType::Int &&
result_type.basetype != SPIRType::Boolean)
{
SPIRV_CROSS_THROW(
"Only 32-bit integers... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x48(%rsi), %esi
callq 0x118090
movl 0x10(%rax), %ecx
cmpl $0x8, %ecx
ja 0x22bf66
movl $0x184, %edx # imm = 0x184
btl %ecx, %edx
jae 0x22bf66
cmpl $0x1, 0x18(%rax)
jne 0x22bf4a
cmpl $0x1, 0x1c(%rax)
jne 0x22bf4a
movq ... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
spirv_cross::Compiler::get_active_buffer_ranges(spirv_cross::TypedID<(spirv_cross::Types)2>) const | SmallVector<BufferRange> Compiler::get_active_buffer_ranges(VariableID id) const
{
SmallVector<BufferRange> ranges;
BufferAccessHandler handler(*this, ranges, id);
traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), handler);
return ranges;
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x18(%rdi), %rax
movq %rax, (%rdi)
movq $0x8, 0x10(%rdi)
leaq 0x1bdeb8(%rip), %rax # 0x3ea138
leaq 0x50(%rsp), %rcx
movq %rax, -0x50(%rcx)
movq %rsi, -0x48(%rcx)
movq %rdi, -0x40(%rcx)
movl %edx, -0x38(%rcx)
movq %rcx, -... | /ValveSoftware[P]Fossilize/cli/SPIRV-Cross/spirv_cross.cpp |
testing::internal::SuiteApiResolver<testing::Test>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rdi
callq 0xc50e
testb %al, %al
jne 0xba26
leaq 0x2f72e(%rip), %rdx # 0x3b0f2
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x226, %ecx # imm = 0x226
callq 0x1f26c
movq 0x53613(%rip), %rdi # 0x5eff0
leaq 0x2f7a9(%rip)... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::StringFromGTestEnv(char const*, char const*) | const char* StringFromGTestEnv(const char* flag, const char* default_value) {
#if defined(GTEST_GET_STRING_FROM_ENV_)
return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const value = posix::GetEnv(env_var.c_str());
return value == nullptr ? ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x1f5e7
movq (%r14), %rdi
callq 0xa820
movq %rax, %r15
testq %rax, %rax
cmoveq %rbx, %r15
movq %r14, %rdi
callq 0xad38
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::UnitTest::GetInstance() | UnitTest* UnitTest::GetInstance() {
// CodeGear C++Builder insists on a public destructor for the
// default implementation. Use this implementation to keep good OO
// design with private destructor.
#if defined(__BORLANDC__)
static UnitTest* const instance = new UnitTest;
return instance;
#else
static Un... | pushq %rbx
movb 0x53625(%rip), %al # 0x5fc68
testb %al, %al
je 0xc650
leaq 0x535d2(%rip), %rax # 0x5fc20
popq %rbx
retq
leaq 0x53611(%rip), %rdi # 0x5fc68
callq 0xac30
testl %eax, %eax
je 0xc647
leaq 0x535b9(%rip), %rdi # 0x5fc20
callq 0x1a0e8
leaq 0xdadb(%rip), %rdi # 0x1a14e
leaq 0x535a6(%rip), ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::TypeParameterizedTestSuiteRegistry::RegisterTestSuite(char const*, testing::internal::CodeLocation) | void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
const char* test_suite_name, CodeLocation code_location) {
suites_.emplace(std::string(test_suite_name),
TypeParameterizedTestSuiteInfo(code_location));
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xb8ce
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x21382
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x213b0
leaq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x27700
leaq 0x58... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile[abi:cxx11]() | std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
std::string format = GetOutputFormat();
if (format.empty())
format = std::string(kDefaultOutputFormat);
const char* const colon = strchr(gtest_output_flag, ':');
if (colon == nu... | pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
movq 0x526d4(%rip), %r14 # 0x5fb80
leaq 0xd0(%rsp), %r15
movq %r15, %rdi
callq 0xd446
cmpq $0x0, 0x8(%r15)
jne 0xd4f6
leaq 0x2e262(%rip), %rsi # 0x3b72c
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xb8ce
leaq 0xd0(%rsp), %rdi
leaq 0x30(%rsp... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::ScopedFakeTestPartResultReporter::Init() | void ScopedFakeTestPartResultReporter::Init() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
old_reporter_ = impl->GetGlobalTestPartResultReporter();
impl->SetGlobalTestPartResultReporter(this);
} else {
old_reporter_ = impl->GetTest... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x213a0
movq %rax, %r14
cmpl $0x1, 0x8(%rbx)
jne 0xde5b
movq %r14, %rdi
callq 0xde98
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdec6
movq %r14, %rdi
callq 0xdefc
movq %rax, 0x10(%rbx)
addq $0x90, %r14
movq %r14, ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() | ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
impl->SetGlobalTestPartResultReporter(old_reporter_);
} else {
impl->SetTestPartResultReporterForCurrentThread(old_repor... | pushq %rbx
movq %rdi, %rbx
leaq 0x4fb01(%rip), %rax # 0x5da30
movq %rax, (%rdi)
callq 0x213a0
cmpl $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rbx
jne 0xdf4e
movq %rax, %rdi
movq %rbx, %rsi
callq 0xdec6
jmp 0xdf5f
addq $0x90, %rax
movq %rax, %rdi
callq 0x27a26
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x214eb
no... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult(testing::TestPartResult const&) | void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
const TestPartResult& result) {
unit_test_->current_test_result()->AddTestPartResult(result);
unit_test_->listeners()->repeater()->OnTestPartResult(result);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x170(%rax), %rdi
testq %rdi, %rdi
je 0xe325
addq $0x90, %rdi
jmp 0xe343
movq 0x168(%rax), %rdi
testq %rdi, %rdi
je 0xe33a
addq $0x88, %rdi
jmp 0xe343
addq $0x178, %rax # imm = 0x178
movq %rax, %rdi
addq $0x38, %rdi
mo... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::AlwaysTrue() | bool AlwaysTrue() {
#if GTEST_HAS_EXCEPTIONS
// This condition is always false so AlwaysTrue() never actually throws,
// but it makes the compiler think that it may throw.
if (IsTrue(false))
throw ClassUniqueToAlwaysTrue();
#endif // GTEST_HAS_EXCEPTIONS
return true;
} | movb $0x1, %al
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::AssertionResult::operator!() const | AssertionResult AssertionResult::operator!() const {
AssertionResult negation(!success_);
if (message_.get() != nullptr) negation << *message_;
return negation;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rsi), %al
xorb $0x1, %al
movb %al, (%rdi)
andq $0x0, 0x8(%rdi)
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0xea69
leaq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x2156c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xbb14
... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::InternalStrings::GetId(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | size_t GetId(const std::string& str) {
IdMap::iterator it = ids_.find(str);
if (it != ids_.end()) return it->second;
size_t id = ids_.size();
return ids_[str] = id;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2547c
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0xefd3
movq 0x40(%rax), %r15
jmp 0xefe5
movq 0x28(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25416
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::DoubleNearPredFormat(char const*, char const*, char const*, double, double, double) | AssertionResult DoubleNearPredFormat(const char* expr1,
const char* expr2,
const char* abs_error_expr,
double val1,
double val2,
double... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movapd %xmm0, %xmm3
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, 0x18(%rsp)
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x30(%rsp)
subsd %xmm1, %xmm0
andpd 0x2bb53(%rip), %xmm0 # 0x3b520
movsd %xmm2, 0x28(%rsp)
movlpd %xmm0, 0x20(%rsp)
ucomisd %xmm0, %xmm2
jae... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRCASEEQ(char const*, char const*, char const*, char const*) | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
const char* rhs_expression,
const char* lhs,
const char* rhs) {
if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
return AssertionSuccess();
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %rdi
movq %r8, %rsi
callq 0xfeae
testb %al, %al
je 0xfe31
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
jmp 0xfe7d
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x222f1
leaq 0x1... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRCASENE(char const*, char const*, char const*, char const*) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
const char* s2_expression,
const char* s1,
const char* s2) {
if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
return AssertionSuccess();
} el... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %rdi
movq %r8, %rsi
callq 0xfeae
testb %al, %al
je 0x100a9
leaq 0x30(%rsp), %r14
movb $0x0, -0x8(%r14)
andq $0x0, (%r14)
leaq 0x2cd5e(%rip), %rsi # 0x3cd78
leaq 0x2... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(bool, char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_trait... | AssertionResult IsSubstringImpl(
bool expected_to_be_substring,
const char* needle_expr, const char* haystack_expr,
const StringType& needle, const StringType& haystack) {
if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
return AssertionSuccess();
const bool is_wide_string = sizeo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r15
movq %r8, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r9, %rdi
movq %r8, %rsi
xorl %edx, %edx
callq 0xad10
cmpq $-0x1, %rax
setne %al
xorb %bpl, %al
je 0x1065a
leaq 0x2d26f(%rip), %rax # ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRNE(char const*, char const*, wchar_t const*, wchar_t const*) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
const char* s2_expression,
const wchar_t* s1,
const wchar_t* s2) {
if (!String::WideCStringEquals(s1, s2)) {
return AssertionSuccess();
}
return AssertionFail... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %rdi
movq %r8, %rsi
callq 0x10aca
testb %al, %al
je 0x10ca1
leaq 0x68(%rsp), %rbx
movb $0x0, -0x8(%rbx)
andq $0x0, (%rbx)
leaq 0x2c18d(%rip), %rsi # 0x3cd78
... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::String::FormatByte[abi:cxx11](unsigned char) | std::string String::FormatByte(unsigned char value) {
std::stringstream ss;
ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
<< static_cast<unsigned int>(value);
return ss.str();
} | pushq %rbp
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xa430
leaq 0x10(%rsp), %rdi
pushq $0x30
popq %rsi
callq 0xab00
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movq $0x2, 0x10(%rax,%rdx)
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl $-0x4b, %esi
o... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestResult::Skipped() const | bool TestResult::Skipped() const {
return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
} | pushq %rbx
movq %rdi, %rbx
callq 0x11412
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x11410
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rdx
cmpq %rdx, %rcx
je 0x1140b
xorl %esi, %esi
cmpl $0x3, (%rcx)
sete %sil
addl %esi, %eax
addq $0x70, %rcx
jmp 0x113f5
testl %eax, %eax
setne %al
popq %rbx
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::Test::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void Test::RecordProperty(const std::string& key, int value) {
Message value_message;
value_message << value;
RecordProperty(key, value_message.GetString().c_str());
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0xe756
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0xabb0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xe92b
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
call... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::Test::Run() | void Test::Run() {
if (!HasSameFixtureClass()) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
// We will run the test only if SetUp() was successful and ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x116ae
testb %al, %al
je 0x11bc6
callq 0x213a0
movq %rax, %r14
movq %rax, %rdi
callq 0xe5e4
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0x2b4e3(%rip), %rcx # 0x3d039
pushq $0x11
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x22a6d
callq 0x11bce... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::Test::HasNonfatalFailure() | bool Test::HasNonfatalFailure() {
return internal::GetUnitTestImpl()->current_test_result()->
HasNonfatalFailure();
} | pushq %rax
callq 0x213a0
movq 0x170(%rax), %rdi
testq %rdi, %rdi
je 0x11c69
addq $0x90, %rdi
jmp 0x11c87
movq 0x168(%rax), %rdi
testq %rdi, %rdi
je 0x11c7e
addq $0x88, %rdi
jmp 0x11c87
addq $0x178, %rax # imm = 0x178
movq %rax, %rdi
popq %rax
jmp 0x1148c
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::MakeAndRegisterTestInfo(char const*, char const*, char const*, char const*, testing::internal::CodeLocation, void const*, void (*)(), void (*)(), testing::internal::TestFactoryBase*) | TestInfo* MakeAndRegisterTestInfo(
const char* test_suite_name, const char* name, const char* type_param,
const char* value_param, CodeLocation code_location,
TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
TestInfo* const test_inf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r14
movl $0x110, %edi # imm = 0x110
callq 0xa630
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestInfo::Run() | void TestInfo::Run() {
if (!should_run_) return;
// Tells UnitTest where to store test result.
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_info(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Notifies the unit test even... | cmpb $0x1, 0x80(%rdi)
jne 0x12337
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x213a0
movq %rax, %r14
movq %rbx, 0x170(%rax)
callq 0xc63c
movq 0x4d9f3(%rip), %rax # 0x5fc60
movq 0x1f8(%rax), %r15
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
callq 0xe610
movq %... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestSuite::GetTestInfo(int) const | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
: v[static_cast<size_t>(i)];
} | testl %esi, %esi
js 0x125a1
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %esi, %ecx
jle 0x125a1
movl %esi, %ecx
movslq (%rax,%rcx,4), %rax
testq %rax, %rax
js 0x125a1
movq 0x30(%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::TestSuite::GetMutableTestInfo(int) | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
: v[static_cast<size_t>(i)];
} | testl %esi, %esi
js 0x125cf
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %esi, %ecx
jle 0x125cf
movl %esi, %ecx
movslq (%rax,%rcx,4), %rax
testq %rax, %rax
js 0x125cf
movq 0x30(%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::TestSuite::AddTestInfo(testing::TestInfo*) | void TestSuite::AddTestInfo(TestInfo* test_info) {
test_info_list_.push_back(test_info);
test_indices_.push_back(static_cast<int>(test_indices_.size()));
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
addq $0x30, %rdi
movq %rax, %rsi
callq 0x22fc0
movq 0x50(%rbx), %rax
subq 0x48(%rbx), %rax
leaq 0x48(%rbx), %rdi
shrq $0x2, %rax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
callq 0x29436
addq $0x10, %rsp
popq %rbx
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrintTestPartResult(testing::TestPartResult const&) | static void PrintTestPartResult(const TestPartResult& test_part_result) {
const std::string& result =
PrintTestPartResultToString(test_part_result);
printf("%s\n", result.c_str());
fflush(stdout);
// If the test program runs in Visual Studio or a debugger, the
// following statements add the test part r... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x11a23
movq (%rbx), %rdi
callq 0xaae0
movq 0x4bc6d(%rip), %rax # 0x5ef50
movq (%rax), %rdi
callq 0xa7c0
movq %rbx, %rdi
callq 0xad38
addq $0x20, %rsp
popq %rbx
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests(testing::UnitTest const&) | void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
const int failed_test_count = unit_test.failed_test_count();
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
for (int i = 0; i < unit_test.total_test_suit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
callq 0x136a6
movl %eax, %ebp
leaq 0x29e1f(%rip), %rsi # 0x3d396
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x12b41
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, 0x4(%rsp)
movl %ebp, %esi
callq 0x1309f
movq (%rbx), ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void BriefUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this ... | cmpl $0x0, (%rsi)
je 0x13ac0
pushq %rax
movq %rsi, %rdi
callq 0x132c1
movq 0x4b499(%rip), %rax # 0x5ef50
movq (%rax), %rdi
popq %rax
jmp 0xa7c0
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Failed()) {
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
PrintTestName(test_info.test_suite_name(), test_info.name());
PrintFullTestCommentIfPresent(test_info);
if (GTEST_FLAG(print_time)) {
pri... | pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %rdi
callq 0x11412
testb %al, %al
je 0x13b56
leaq 0x298b5(%rip), %rsi # 0x3d396
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x12b41
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x231fa
movq %rbx, %rdi
callq 0x133c5
cmpb $0x1, 0x4c09b(%rip) # 0x5fba1
j... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x297a9(%rip), %rsi # 0x3d319
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x12b41
movq %rbx, %rdi
callq 0x130bc
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x1309f
movq (%r14), %r14
movq %rbx, %rdi
callq 0x130e2
leaq 0x2... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* xmlout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintXmlUnitTest(&stream, unit_test);
fprintf(xmlout, "%s", StringStreamToString(&stream)... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x142b9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xa430
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x143ac
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0xe92b
movq %rsp, %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::OpenFileForWriting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static FILE* OpenFileForWriting(const std::string& output_file) {
FILE* fileout = nullptr;
FilePath output_file_path(output_file);
FilePath output_dir(output_file_path.RemoveFileName());
if (output_dir.CreateDirectoriesRecursively()) {
fileout = posix::FOpen(output_file.c_str(), "w");
}
if (fileout == ... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21484
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1e63c
leaq 0x8(%rsp), %rdi
callq 0x1e7f4
testb %al, %al
je 0x14305
movq (%rbx), %rdi
leaq 0x29751(%rip), %rsi # 0x3da49
callq 0xa7d0
movq %rax, %r14... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream*, testing::UnitTest const&) | void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
const UnitTest& unit_test) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
OutputXmlAttribute(stream, ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x292e5(%rip), %rsi # 0x3d6a6
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xb8ce
leaq 0x292da(%rip), %rsi # 0x3d6b1
movq %rbx, %rdi
callq 0xa610
leaq 0x292b9(%rip), %rsi # 0x3d69f
movq %rbx, %rdi
callq 0xa610
leaq 0... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestsList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void XmlUnitTestResultPrinter::PrintXmlTestsList(
std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
int total_tests = 0;
for (auto test_suite : test_s... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28df8(%rip), %rsi # 0x3d6a6
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xb8ce
leaq 0x28ded(%rip), %rsi # 0x3d6b1
movq %rbx, %rdi
callq 0xa610
leaq 0x28dcc(%rip), %rsi # 0x3d69f
movq %rbx, %rdi
callq 0xa610
leaq 0... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
const std::string& str) {
std::string output;
output.reserve(str.size());
for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
if (IsValidXmlCharacter(*it))
output.push_back(*it);
return output;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0xaaf0
movq (%r14), %rax
movl $0x2600, %ebp # imm = 0x2600
movq %rax, %r15
movq 0x8(%r14), %rcx
addq %rax, %rcx
c... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PortableLocaltime(long, tm*) | static bool PortableLocaltime(time_t seconds, struct tm* out) {
#if defined(_MSC_VER)
return localtime_s(out, &seconds) == 0;
#elif defined(__MINGW32__) || defined(__MINGW64__)
// MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
// Windows' localtime(), which has a thread-local tm buffer.
s... | pushq %rax
movq %rsp, %rax
movq %rdi, (%rax)
movq %rax, %rdi
callq 0xa320
testq %rax, %rax
setne %al
popq %rcx
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*) | void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
const char* data) {
const char* segment = data;
*stream << "<![CDATA[";
for (;;) {
const char* const next_segment = strstr(segment, "]]>");
if (next_segment != nullptr) {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28332(%rip), %rsi # 0x3d4e0
callq 0xa610
leaq 0x28319(%rip), %r15 # 0x3d4d3
leaq 0x28316(%rip), %r12 # 0x3d4d7
movq %r14, %rdi
movq %r15, %rsi
callq 0xa100
testq %rax, %rax
je 0x151f9
movq %rax, %r13
movq %rax, %rd... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::GetReservedOutputAttributesForElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::vector<std::string> GetReservedOutputAttributesForElement(
const std::string& xml_element) {
if (xml_element == "testsuites") {
return ArrayAsVector(kReservedTestSuitesAttributes);
} else if (xml_element == "testsuite") {
return ArrayAsVector(kReservedTestSuiteAttributes);
} else if (xml_e... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28313(%rip), %rsi # 0x3d6a6
movq %r14, %rdi
callq 0x238e5
testb %al, %al
je 0x153a8
leaq 0x48dda(%rip), %rsi # 0x5e180
jmp 0x153c2
leaq 0x281d0(%rip), %rsi # 0x3d57f
movq %r14, %rdi
callq 0x238e5
testb %al, %al
je 0x153d5
leaq 0x48dfe(%... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestProperties(std::ostream*, testing::TestResult const&) | void XmlUnitTestResultPrinter::OutputXmlTestProperties(
std::ostream* stream, const TestResult& result) {
const std::string kProperties = "properties";
const std::string kProperty = "property";
if (result.test_property_count() <= 0) {
return;
}
*stream << "<" << kProperties << ">\n";
for (int i = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x2718e(%rip), %rsi # 0x3d6e2
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xb8ce
leaq 0x27183(%rip), %rsi # 0x3d6ed
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0xb8ce
movq 0x... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&) | std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
const TestResult& result) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << " " << property.key() << "="
<< "\"" << EscapeXmlA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xe756
xorl %ebp, %ebp
leaq 0x28(%rsp), %r12
leaq 0x48(%rsp), %rbx
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jge 0x16c8e
movq %r14, %rdi
... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* jsonout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintJsonUnitTest(&stream, unit_test);
fprintf(jsonout, "%s", StringStreamToString(&str... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x142b9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xa430
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x16e32
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0xe92b
movq %rsp, %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsRFC3339[abi:cxx11](long) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon... | pushq %r14
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rsi, %rax
movq %rdi, %rbx
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
leaq 0x1f0(%rsp), %rsi
movq %rax, %rdi
callq 0x15181
testb %al, %al
je 0x184a8
movl $0x76c, %eax # imm = 0x76C
addl 0x204(%rsp), %eax
leaq 0xc(%rsp), %rs... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestResult(std::ostream*, testing::TestResult const&) | void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
const TestResult& result) {
const std::string kIndent = Indent(10);
int failures = 0;
for (int i = 0; i < result.total_part_count(); ++i) {
const TestPartResult& part = result.Get... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, (%rsp)
leaq 0x10(%rsp), %rdi
pushq $0xa
popq %rsi
callq 0x18184
xorl %ebp, %ebp
leaq 0x70(%rsp), %rbx
xorl %r15d, %r15d
movq 0x40(%r14), %rax
subq 0x38(%r14), %rax
cqto
pushq $0x70
popq %rcx
idivq %rcx
cmpl %eax, %ebp
jge... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestEventListeners::SetDefaultResultPrinter(testing::TestEventListener*) | void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
if (default_result_printer_ != listener) {
// It is an error to pass this method a listener that is already in the
// list.
delete Release(default_result_printer_);
default_result_printer_ = listener;
if (listener != n... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rbx, %rsi
je 0x199e7
movq %rdi, %r14
callq 0x19984
testq %rax, %rax
je 0x199cc
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x8(%r14)
testq %rbx, %rbx
je 0x199e7
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::UnitTest::Run() | int UnitTest::Run() {
const bool in_death_test_child_process =
internal::GTEST_FLAG(internal_run_death_test).length() > 0;
// Google Test implements this protocol for catching that a test
// program exits before returning control to Google Test:
//
// 1. Upon start, Google Test creates a file whose a... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x460ac(%rip) # 0x5fc78
je 0x19bd2
xorl %esi, %esi
jmp 0x19be1
leaq 0x23cd7(%rip), %rdi # 0x3d8b0
callq 0xa820
movq %rax, %rsi
movq %rsp, %rdi
callq 0x23476
movq 0x40(%rbx), %rdi
movb 0x45f42(%rip), %al # 0x5fb35
movb %al, 0x258(%rdi)
leaq 0x36(%rip), ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ConfigureXmlOutput() | void UnitTestImpl::ConfigureXmlOutput() {
const std::string& output_format = UnitTestOptions::GetOutputFormat();
if (output_format == "xml") {
listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
} else if (output_format == "json")... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xd446
leaq 0x210db(%rip), %rsi # 0x3b72c
movq %r14, %rdi
callq 0x238e5
testb %al, %al
je 0x1a695
pushq $0x28
popq %rdi
callq 0xa630
movq %rax, %r14
movq %rsp, %rdi
callq 0xd496
movb $0x1, %bpl
movq (%rsp),... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::PostFlagParsingInit() | void UnitTestImpl::PostFlagParsingInit() {
// Ensures that this function does not execute more than once.
if (!post_flag_parse_init_performed_) {
post_flag_parse_init_performed_ = true;
#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
// Register to send notifications about key process state changes.
lis... | cmpb $0x0, 0x218(%rdi)
je 0x1a90e
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x218(%rdi)
callq 0x23966
cmpq $0x0, 0x238(%rbx)
je 0x1a936
movq 0x1f8(%rbx), %rax
movb $0x0, 0x8(%rax)
movq %rbx, %rdi
callq 0x1220c
movq %rbx, %rdi
callq 0x1a632
cmpb $0x1, 0x45253(%rip) # 0x5fba0
jne 0x1a973
leaq 0... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::GetTestSuite(char const*, char const*, void (*)(), void (*)()) | TestSuite* UnitTestImpl::GetTestSuite(
const char* test_suite_name, const char* type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc) {
// Can we find a TestSuite with the given name?
const auto test_suite =
std::find_if(test_suites_.rbegin(), test_suite... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xc0(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0xb8(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xb8ce
leaq 0x48(%rsp... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ListTestsMatchingFilter() | void UnitTestImpl::ListTestsMatchingFilter() {
// Print at most this many characters for each type/value parameter.
const int kMaxParamLength = 250;
for (auto* test_suite : test_suites_) {
bool printed_test_suite_name = false;
for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
cons... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
leaq 0xb8(%rdi), %rax
movq %rax, (%rsp)
movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
movq %rcx, 0x50(%rsp)
leaq 0x22db1(%rip), %r14 # 0x3db61
pushq $0xa
popq %rbp
leaq 0x22d9d(%rip), %r15 # 0x3db57
cmpq 0... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ShuffleTests() | void UnitTestImpl::ShuffleTests() {
// Shuffles the death test suites.
ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
// Shuffles the non-death test suites.
ShuffleRange(random(), last_death_test_suite_ + 1,
static_cast<int>(test_suites_.size()), &test_suite_indices... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x220(%rdi), %rbx
movl 0x164(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x23c51
movl 0x164(%r14), %esi
incl %esi
movq 0xc0(%r14), %rdx
subq 0xb8(%r14), %rdx
shrq $0x3, %rdx
movq %rbx, %rdi
movq %r15, %rcx
callq ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::ScopedTrace::PushTrace(char const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | static const char* GetDefaultFilter() {
const char* const testbridge_test_only =
internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
if (testbridge_test_only != nullptr) {
return testbridge_test_only;
}
return kUniversalFilter;
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x18(%rsp), %rbx
movb $0x0, (%rax)
movq %rsi, -0x20(%rax)
movl %edx, -0x18(%rax)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xa450
callq 0xc63c
leaq 0x44581(%rip), %rdi # 0x5fc20
leaq 0x8(%rsp), %rsi
callq 0x1a... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::DeathTest::Create(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const*, int, testing::internal::DeathTest**) | bool DeathTest::Create(const char* statement,
Matcher<const std::string&> matcher, const char* file,
int line, DeathTest** test) {
return GetUnitTestImpl()->death_test_factory()->Create(
statement, std::move(matcher), file, line, test);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x213a0
movq 0x240(%rax), %rdi
movq 0x8(%r15), %rax
leaq 0x8(%rsp), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rdx)
andq $0x0, 0x8(%r15)
leaq... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::Abort(testing::internal::DeathTest::AbortReason) | void DeathTestImpl::Abort(AbortReason reason) {
// The parent process considers the death test to be a failure if
// it finds any data in our pipe. So, here we write a single flag byte
// to the pipe, then exit.
const char status_ch =
reason == TEST_DID_NOT_DIE ? kDeathTestLived :
reason == TEST_TH... | pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
cmpl $0x1, %esi
sete %al
addb %al, %al
addb $0x52, %al
cmpl $0x2, %esi
movzbl %al, %eax
pushq $0x4c
popq %rcx
cmovnel %eax, %ecx
movq %rdi, %rbx
leaq 0xb(%rsp), %r14
movb %cl, (%r14)
pushq $0x1
popq %r15
movl 0x38(%rbx), %edi
movq %r14, %rsi
mo... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::Passed(bool) | bool DeathTestImpl::Passed(bool status_ok) {
if (!spawned())
return false;
const std::string error_message = GetErrorLogs();
bool success = false;
Message buffer;
buffer << "Death test: " << statement() << "\n";
switch (outcome()) {
case LIVED:
buffer << " Result: failed to die.\n"
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
cmpb $0x1, 0x28(%rdi)
jne 0x1c10d
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq *0x30(%rax)
leaq 0x8(%rsp), %rdi
callq 0xe756
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x21d5d(%rip), %... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::FormatDeathTestOutput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static ::std::string FormatDeathTestOutput(const ::std::string& output) {
::std::string ret;
for (size_t at = 0; ; ) {
const size_t line_end = output.find('\n', at);
ret += "[ DEATH ] ";
if (line_end == ::std::string::npos) {
ret += output.substr(at);
break;
}
ret += output.substr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %ebp, %ebp
leaq 0x2246e(%rip), %r15 # 0x3e920
leaq 0x8(%rsp), %r12
movq %r14, %rdi
pushq $0xa
popq %rsi
movq %rbp... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::NoExecDeathTest::AssumeRole() | DeathTest::TestRole NoExecDeathTest::AssumeRole() {
const size_t thread_count = GetThreadCount();
if (thread_count != 1) {
GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
}
int pipe_fd[2];
GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
DeathTest::set_last_death_test_message("");
CaptureS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdi, %rbx
callq 0x1cdf4
cmpq $0x1, %rax
je 0x1c8b0
movq %rax, %r12
leaq 0x21431(%rip), %rdx # 0x3dbdc
leaq 0x30(%rsp), %rdi
pushq $0x1
popq %rsi
movl $0x461, %ecx # imm = 0x461
callq 0x1f26c
leaq 0x50(... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::GetThreadCount() | size_t GetThreadCount() {
const std::string filename =
(Message() << "/proc/" << getpid() << "/stat").GetString();
return ReadProcFileField<size_t>(filename, 19);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x250, %rsp # imm = 0x250
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0xe756
movq (%rbx), %rbx
leaq 0x10(%rbx), %r14
leaq 0x21181(%rip), %rsi # 0x3df9b
movq %r14, %rdi
callq 0xa610
callq 0xaa20
movq %r14, %rdi
movl %eax, %esi
callq 0xabb0
leaq 0x2116a(%rip), %rsi ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::internal::DefaultDeathTestFactory::Create(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const*, int, testing::internal::DeathTest**) | bool DefaultDeathTestFactory::Create(const char* statement,
Matcher<const std::string&> matcher,
const char* file, int line,
DeathTest** test) {
UnitTestImpl* const impl = GetUnitTestImpl();
const Internal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
callq 0x213a0
movq 0x238(%rax), %r13
movq 0x170(%rax), %rcx
movl 0xf8(%rcx), %eax
leal 0x1(%rax), %r14d
movl %r14d, 0xf8(%rcx)
... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::FilePath::RemoveExtension(char const*) const | FilePath FilePath::RemoveExtension(const char* extension) const {
const std::string dot_extension = std::string(".") + extension;
if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
return FilePath(pathname_.substr(
0, pathname_.length() - dot_extension.length()));
}
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1f1f5(%rip), %rsi # 0x3d760
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xb8ce
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x212cd
leaq 0x10(%rsp), %rdi
callq 0xad38
leaq 0x30(%rsp), %... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::RemoveFileName() const | FilePath FilePath::RemoveFileName() const {
const char* const last_sep = FindLastPathSeparator();
std::string dir;
if (last_sep) {
dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str()));
} else {
dir = kCurrentDirectoryString;
}
return FilePath(dir);
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1e630
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
testq %rax, %rax
je 0x1e69f
movq (%r14), %rsi
incq %rax
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x28(%rsp), %rdi
movq %rax, ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::FileOrDirectoryExists() const | bool FilePath::FileOrDirectoryExists() const {
#if GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
const DWORD attributes = GetFileAttributes(unicode);
delete [] unicode;
return attributes != kInvalidFileAttributes;
#else
posix::StatStruct file_stat{};
return posix::Stat(pa... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xa360
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xa570
testl %eax, %eax
sete %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::DirectoryExists() const | bool FilePath::DirectoryExists() const {
bool result = false;
#if GTEST_OS_WINDOWS
// Don't strip off trailing separator if path is a root directory on
// Windows (like "C:\\").
const FilePath& path(IsRootDirectory() ? *this :
RemoveTrailingPathSeparator());
#else
co... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xa360
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xa570
movl 0x18(%r14), %ecx
andl $0xf000, %ecx # imm = 0xF000
xorl $0x4000, %ecx # imm = 0x4000
orl %eax, %ecx
sete %al
a... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-filepath.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x3faea(%rip), %rax # 0x5e3f8
movq %rax, (%rdi)
leaq 0x18(%rsp), %rdi
callq 0xa970
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa970
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x24524
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x26d... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x3f9b4(%rip), %rax # 0x5e428
movq %rax, (%rdi)
leaq 0x18(%rsp), %rdi
callq 0xa970
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa970
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x2453a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x26d... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(char const*) | Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); } | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x3f908(%rip), %rax # 0x5e428
movq %rax, (%rdi)
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xb8ce
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa970
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2453a
leaq 0x10(%rsp),... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<const internal::StringView&>::Matcher(const std::string& s) {
*this = Eq(s);
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x3f87e(%rip), %rax # 0x5e458
movq %rax, (%rdi)
leaq 0x18(%rsp), %rdi
callq 0xa970
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa970
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x24550
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x26d... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(char const*) | Matcher<const internal::StringView&>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x3f7d2(%rip), %rax # 0x5e458
movq %rax, (%rdi)
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xb8ce
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa970
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x24550
leaq 0x10(%rsp),... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(std::basic_string_view<char, std::char_traits<char>>) | Matcher<const internal::StringView&>::Matcher(internal::StringView s) {
*this = Eq(std::string(s));
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x68(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
andq $0x0, 0x8(%rdi)
leaq 0x3f70c(%rip), %rcx # 0x5e458
movq %rcx, (%rdi)
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x24566
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x3f680(%rip), %rax # 0x5e488
movq %rax, (%rdi)
leaq 0x18(%rsp), %rdi
callq 0xa970
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa970
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x24580
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x26e... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(char const*) | Matcher<internal::StringView>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x3f5d4(%rip), %rax # 0x5e488
movq %rax, (%rdi)
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xb8ce
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa970
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x24580
leaq 0x10(%rsp),... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int) | GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
: severity_(severity) {
const char* const marker =
severity == GTEST_INFO ? "[ INFO ]" :
severity == GTEST_WARNING ? "[WARNING]" :
severity == GTEST_ERROR ? "[ ERROR ]" : "[ FATAL ]";
GetStream() << ::std::endl << ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, (%rdi)
cmpl $0x2, %esi
leaq 0x1ee19(%rip), %rax # 0x3e0a1
leaq 0x1ee1c(%rip), %rcx # 0x3e0ab
cmoveq %rax, %rcx
cmpl $0x1, %esi
leaq 0x1edfa(%rip), %rax # 0x3e097
cmovneq %rcx, %rax
testl %esi, %esi
leaq 0... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**) | static void CaptureStream(int fd, const char* stream_name,
CapturedStream** stream) {
if (*stream != nullptr) {
GTEST_LOG_(FATAL) << "Only one " << stream_name
<< " capturer can exist at a time.";
}
*stream = new CapturedStream(fd);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %edi, %ebp
cmpq $0x0, (%rdx)
je 0x1f3dc
movq %rsi, %r14
leaq 0x1ec65(%rip), %rdx # 0x3dff8
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x4b0, %ecx # imm = 0x4B0
callq 0x1f26c
movq 0x3fc44(%rip), %rdi # 0x5eff0
leaq 0x1f89a(%ri... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*) | std::string ReadEntireFile(FILE* file) {
const size_t file_size = GetFileSize(file);
char* const buffer = new char[file_size];
size_t bytes_last_read = 0; // # of bytes read in the last fread()
size_t bytes_read = 0; // # of bytes read so far
fseek(file, 0, SEEK_SET);
// Keeps reading the file unt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1f472
movq %rax, %r12
movq %rax, %rdi
callq 0xa040
movq %rax, %r14
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa730
pushq $0x1
popq %r13
leaq (%r14,%rbp), %rdi... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::internal::FlagToEnvVar[abi:cxx11](char const*) | static std::string FlagToEnvVar(const char* flag) {
const std::string full_flag =
(Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
Message env_var;
for (size_t i = 0; i != full_flag.length(); i++) {
env_var << ToUpper(full_flag.c_str()[i]);
}
return env_var.GetString();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xe756
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x1e8f2(%rip), %rsi # 0x3df07
callq 0xa610
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21814
leaq 0x18(%rsp), %rdi
movq ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::internal::PrintBytesInObjectTo(unsigned char const*, unsigned long, std::ostream*) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
ostream* os) {
PrintBytesInObjectToImpl(obj_bytes, count, os);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0xa410
leaq 0x1f60a(%rip), %rsi # 0x3ed1a
movq %rax, %rdi
callq 0xa610
cmpq $0x83, %r14
ja 0x1f728
movq %r15, %rdi
xorl %esi, %esi
jmp 0x1f755
pushq $0x40
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rcx
... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char32_t, std::ostream*) | void PrintTo(char32_t c, ::std::ostream* os) {
*os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
<< static_cast<uint32_t>(c);
} | pushq %rbx
movq %rsi, %rax
movl %edi, %ebx
movq (%rsi), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rsi,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rsi,%rcx)
leaq 0x1e9d5(%rip), %rsi # 0x3e17a
movq %rax, %rdi
callq 0xa610
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
orl $0x4000, 0x18(%rax,%rcx) # imm = 0x4... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(wchar_t const*, std::ostream*) | void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1fa0d
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa4c0
leaq 0x1f653(%rip), %rsi # 0x3f03b
movq %rax, %rdi
callq 0xa610
movq %r14, %rdi
callq 0xa510
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
j... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<char>(char const*, unsigned long, std::ostream*) | static CharFormat PrintCharsAsStringTo(
const CharType* begin, size_t len, ostream* os) {
const char* const quote_prefix = GetCharWidthPrefix(*begin);
*os << quote_prefix << "\"";
bool is_previous_hex = false;
CharFormat print_format = kAsIs;
for (size_t index = 0; index < len; ++index) {
const CharTy... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x204d3(%rip), %rsi # 0x400a8
movq %rdx, %rdi
callq 0xa610
leaq 0x1dbca(%rip), %rsi # 0x3d7ae
movq %rax, %rdi
callq 0xa610
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %ecx, %ecx
cmpq %rbp... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<char16_t>(char16_t const*, unsigned long, std::ostream*) | static CharFormat PrintCharsAsStringTo(
const CharType* begin, size_t len, ostream* os) {
const char* const quote_prefix = GetCharWidthPrefix(*begin);
*os << quote_prefix << "\"";
bool is_previous_hex = false;
CharFormat print_format = kAsIs;
for (size_t index = 0; index < len; ++index) {
const CharTy... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20820(%rip), %rsi # 0x404c1
movq %rdx, %rdi
callq 0xa610
leaq 0x1dafe(%rip), %r13 # 0x3d7ae
movq %rax, %rdi
movq %r13, %rsi
callq 0xa610
xorl %ebp, %ebp
xorl %eax, %eax
cmpq %rbp, ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::TestPartResult::ExtractSummary[abi:cxx11](char const*) | std::string TestPartResult::ExtractSummary(const char* message) {
const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
return stack_trace == nullptr ? message : std::string(message, stack_trace);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1b6ff(%rip), %rsi # 0x3b5c0
movq %r14, %rdi
callq 0xa100
testq %rax, %rax
je 0x1fee5
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xbb62
jmp 0x1fef5
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-test-part.cc |
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.