name string | code string | asm string | file string |
|---|---|---|---|
XXH3_scrambleAcc_sse2 | XXH_FORCE_INLINE XXH_TARGET_SSE2 void XXH3_scrambleAcc_sse2(
void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret) {
XXH_ASSERT((((size_t)acc) & 15) == 0);
{
XXH_ALIGN(16) __m128i* const xacc = (__m128i*)acc;
/* Unaligned. This is mainly for pointer arithmetic, and because
* _mm_loadu_si128 requ... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x9e3779b1, 0x108(%rsp) # imm = 0x9E3779B1
movl 0x108(%rsp), %eax
movl %eax, 0x164(%rsp)
movl %eax, 0x160(%rsp)
movl %eax, 0x15c(%rsp)
movl... | /arangodb[P]velocypack/src/xxhash.h |
VELOCYPACK_XXH3_64bits_digest | XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest(const XXH3_state_t* state) {
const unsigned char* const secret =
(state->extSecret == NULL) ? state->customSecret : state->extSecret;
if (state->totalLen > XXH3_MIDSIZE_MAX) {
XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB];
XXH3_digest_long(acc, st... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
cmpq $0x0, 0x238(%rax)
jne 0x293d8
movq 0x58(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x8(%rsp)
jmp 0x293e9
movq 0x58(%rsp), %rax
movq 0x238(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
cmpq $0xf0, 0x210(%ra... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_digest_long | XXH_FORCE_INLINE void XXH3_digest_long(XXH64_hash_t* acc,
const XXH3_state_t* state,
const unsigned char* secret) {
/*
* Digest on a local copy. This way, the state remains unaltered, and it can
* continue ingesting more input afterwa... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movl $0x40, %edx
callq 0x3110
movq 0x78(%rsp), %rax
cmpl $0x40, 0x200(%rax)
jb 0x295dc
movq 0x78(%rsp), %rax
movl 0x200(%rax), %eax
subl $0x1, %eax
shrl $0x6, %eax
movl %eax, %eax
movq %rax, 0x... | /arangodb[P]velocypack/src/xxhash.h |
XXH3_mergeAccs | static XXH64_hash_t XXH3_mergeAccs(const xxh_u64* XXH_RESTRICT acc,
const xxh_u8* XXH_RESTRICT secret,
xxh_u64 start) {
xxh_u64 result64 = start;
size_t i = 0;
for (i = 0; i < 4; i++) {
result64 += XXH3_mix2Accs(acc + 2 * i, secret + 16 * ... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq $0x0, (%rsp)
cmpq $0x4, (%rsp)
jae 0x296f4
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
shlq %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movq (%rsp), %rax
shlq $... | /arangodb[P]velocypack/src/xxhash.h |
VELOCYPACK_XXH3_generateSecret | XXH_PUBLIC_API void XXH3_generateSecret(void* secretBuffer,
const void* customSeed,
size_t customSeedSize) {
XXH_ASSERT(secretBuffer != NULL);
if (customSeedSize == 0) {
memcpy(secretBuffer, XXH3_kSecret, XXH_SECRET_DEFAULT_SIZE);
... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
cmpq $0x0, 0xe0(%rsp)
jne 0x29758
movq 0xf0(%rsp), %rdi
leaq 0x4d37(%rip), %rsi # 0x2e480
movl $0xc0, %edx
callq 0x3110
jmp 0x29924
movq $0x10, 0xd8(%rsp)
movq $0xc, 0xd0(%rsp)
movq 0xe8(%rsp), %rdi
movq 0xe0(%rsp), %rsi
xorl %eax, ... | /arangodb[P]velocypack/src/xxhash.h |
rtosc_skip_next_printed_arg | const char* rtosc_skip_next_printed_arg(const char* src, int* skipped,
char* type, const char* llhssrc,
int follow_ellipsis, int inside_bundle)
{
char dummy;
if(!type)
type = &dummy;
assert(skipped);
assert(src);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %r9d, %r14d
movl %r8d, 0x48(%rsp)
movq %rcx, %rbp
movq %rsi, %r12
movq %rdi, %r13
movq %rdi, 0x10(%rsp)
testq %rdx, %rdx
leaq 0x3f(%rsp), %rax
cmovneq %rdx, %rax
movq %rax, 0x18(%rsp)
movl $0x1, (%rsi)
movb $0x0, 0x27(%rsp)
movzbl (... | /fundamental[P]rtosc/src/cpp/pretty-format.c |
skip_word | static const char* skip_word(const char* exp, const char** str)
{
size_t explen = strlen(exp);
const char* cur = *str;
int match = (!strncmp(exp, cur, explen) &&
( !cur[explen]
|| cur[explen] == '/' || cur[explen] == ']'
|| cur[explen] == '.'
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r12
callq 0x3100
movq %rax, %r15
movq (%r14), %rbx
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3130
testl %eax, %eax
je 0xd02e
xorl %ebx, %ebx
jmp 0xd069
movzbl (%rbx,%r15), %eax
leal -0x2e(%rax), %ecx
cmpl $0x2f, %ecx
ja 0xd... | /fundamental[P]rtosc/src/cpp/pretty-format.c |
rtosc_arg_val_to_int | int rtosc_arg_val_to_int(const rtosc_arg_val_t* av, int* res)
{
switch(av->type)
{
case 'd': *res = av->val.d; return true;
case 'f': *res = av->val.f; return true;
case 'h': *res = av->val.h; return true;
case 'c':
case 'i': *res = av->val.i; return true;
case 'T... | movzbl (%rdi), %ecx
xorl %eax, %eax
leal -0x63(%rcx), %edx
cmpl $0x6, %edx
ja 0xe828
leaq 0x35be(%rip), %rcx # 0x11dd8
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movl 0x8(%rdi), %eax
jmp 0xe844
cmpl $0x46, %ecx
je 0xe832
cmpl $0x54, %ecx
jne 0xe849
movsbl 0x8(%rdi), %eax
jmp 0xe844
cvttsd2si 0x8(%rdi), ... | /fundamental[P]rtosc/src/cpp/arg-val-math.c |
rtosc_arg_val_range_arg | rtosc_arg_val_t* rtosc_arg_val_range_arg(const rtosc_arg_val_t *range_arg,
int ith, rtosc_arg_val_t* result)
{
rtosc_arg_val_t n_as_arg_val, mult;
int ok = 1;
if(ok) ok = rtosc_arg_val_from_int(&n_as_arg_val, range_arg[1].type, ith);
if(ok) ok = rtosc_arg_val_mul... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %r14
movsbl 0x18(%rdi), %esi
leaq 0x20(%rsp), %rdi
callq 0xe40c
testl %eax, %eax
je 0xe8a2
leaq 0x18(%r14), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xe6e7
testl %eax, %eax
je 0xe8a2
addq $0x30, %r14
leaq 0x8(%rsp), %rsi
movq... | /fundamental[P]rtosc/src/cpp/arg-val-math.c |
rtosc_arg_vals_cmp | int rtosc_arg_vals_cmp(const rtosc_arg_val_t* lhs, const rtosc_arg_val_t* rhs,
size_t lsize, size_t rsize,
const rtosc_cmp_options* opt)
{
// used if the value of lhs or rhs is range-computed:
rtosc_arg_val_t rlhs, rrhs;
rtosc_arg_val_itr litr, ritr;
rtosc_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xf0ac
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xf0ac
testq %rbp, %rbp
leaq 0x2ec7(%rip), %r13 ... | /fundamental[P]rtosc/src/cpp/arg-val-cmp.c |
rtosc_vmessage | size_t rtosc_vmessage(char *buffer,
size_t len,
const char *address,
const char *arguments,
va_list ap)
{
const unsigned nargs = nreserved(arguments);
if(!nargs)
return rtosc_amessage(buffer,len,addres... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rdi
callq 0xf5ab
testl %eax, %eax
je 0xf320
movq %rsp, -0x38(%rbp)
movl %eax, %esi
movq %r14, -0x30(%rbp)
movq %rsp, %r14
movq %rs... | /fundamental[P]rtosc/src/rtosc.c |
extract_arg | static rtosc_arg_t extract_arg(const uint8_t *arg_pos, char type)
{
rtosc_arg_t result = {0};
//trivial case
if(!has_reserved(type)) {
switch(type)
{
case 'T':
result.T = true;
break;
case 'F':
result.T = false;
... | movl %esi, %eax
addl $-0x53, %eax
cmpl $0x21, %eax
ja 0xfad3
movabsq $0x3846b8001, %rcx # imm = 0x3846B8001
btq %rax, %rcx
jae 0xfad3
movsbl %sil, %r10d
xorl %edx, %edx
xorl %eax, %eax
xorl %ecx, %ecx
leal -0x62(%r10), %esi
cmpl $0x12, %esi
ja 0xfa9d
leaq 0x257f(%rip), %r8 # 0x11fbc
movslq (%r8,%rsi,4), %r10... | /fundamental[P]rtosc/src/rtosc.c |
rtosc_argument | rtosc_arg_t rtosc_argument(const char *msg, unsigned idx)
{
char type = rtosc_type(msg, idx);
uint8_t *arg_mem = (uint8_t*)msg + arg_off(msg, idx);
return extract_arg(arg_mem, type);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0xf1ef
movl %eax, %ebp
movzbl %al, %eax
xorl %r15d, %r15d
addl $-0x53, %eax
cmpl $0x21, %eax
ja 0xfc6d
movabsq $0x3846b8001, %rcx # imm = 0x3846B8001
btq %rax, %rcx
jae 0xfc6d
movq %rbx, %rdi
callq 0xf1ac
movq %rax, %r12
... | /fundamental[P]rtosc/src/rtosc.c |
rtosc_valid_message_p | bool rtosc_valid_message_p(const char *msg, size_t len)
{
//Validate Path Characters (assumes printable characters are sufficient)
if(*msg != '/')
return false;
const char *tmp = msg;
for(unsigned i=0; i<len; ++i) {
if(*tmp == 0)
break;
if(!isprint(*tmp))
... | cmpb $0x2f, (%rdi)
jne 0x10020
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movl %r15d, %eax
cmpq %rbx, %rax
jae 0x10023
movsbq (%r14,%r15), %r12
testq %r12, %r12
je 0x10023
callq 0x32d0
movq (%rax), %rax
testb $0x40, 0x1(%rax,%r12,2)
je 0x1006d
incq %r15
jmp ... | /fundamental[P]rtosc/src/rtosc.c |
rtosc_bundle | size_t rtosc_bundle(char *buffer, size_t len, uint64_t tt, int elms, ...)
{
char *_buffer = buffer;
memset(buffer, 0, len);
strcpy(buffer, "#bundle");
buffer += 8;
emplace_uint64((uint8_t*)buffer, tt);
buffer += 8;
va_list va;
va_start(va, elms);
for(int i=0; i<elms; ++i) {
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rbp
leaq 0x30(%rsp), %r12
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x100e5
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps ... | /fundamental[P]rtosc/src/rtosc.c |
rtosc_bundle_timetag | static uint64_t extract_uint64(const uint8_t *arg_pos)
{
uint64_t arg = 0;
arg |= (((uint64_t)*arg_pos++) << 56);
arg |= (((uint64_t)*arg_pos++) << 48);
arg |= (((uint64_t)*arg_pos++) << 40);
arg |= (((uint64_t)*arg_pos++) << 32);
arg |= (((uint64_t)*arg_pos++) << 24);
arg |= (((uint64_t)*ar... | movq 0x8(%rdi), %rax
bswapq %rax
retq
nopl (%rax)
| /fundamental[P]rtosc/src/rtosc.c |
rtosc_match_options | const char *rtosc_match_options(const char *pattern, const char **msg)
{
const char *preserve = *msg;
assert(*pattern == '{');
pattern++;
retry:
while(1) {
//Check for special characters
if(*pattern == ',' || *pattern == '}') {
goto advance_until_end;
} else if((*pa... | movq %rdi, %rax
movq (%rsi), %rcx
movq %rcx, %rdi
movzbl 0x1(%rax), %edx
incq %rax
cmpl $0x7d, %edx
je 0x1033a
cmpl $0x2c, %edx
je 0x1033a
movb (%rdi), %r8b
cmpb %r8b, %dl
setne %dl
testb %r8b, %r8b
sete %r8b
orb %dl, %r8b
jne 0x1031b
incq %rdi
movq %rdi, (%rsi)
jmp 0x102ed
movq %rcx, (%rsi)
movzbl (%rax), %edx
testl %... | /fundamental[P]rtosc/src/dispatch.c |
ParserClass::readInput() | void ParserClass::readInput()
{
std::string line;
std::string nextLine;
getline(std::cin, line);
bool flag = false;
while(true)
{
if (flag)
break;
getline(std::cin, line);
if (line == ParserClass::SELECT_VAR)
{
getline(std::cin, nextLine);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, (%rsp)
leaq 0x40(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movq 0x13240(%rip), %rdi # 0x16... | /SamNormcoreWayne[P]AdhocQueryProcessing/MFQueryInputParser/src/ParserClass.cc |
ParserClass::parseAggFunc[abi:cxx11]() | std::map<int, std::string> ParserClass::parseAggFunc()
{
std::map<int, std::string> agg_map;
for (auto aggFunc : this->inputs.aggre_funcs)
{
if ('a' <= aggFunc[0] && aggFunc[0] <= 'z')
{
if (agg_map.find(0) == agg_map.end())
{
agg_map[0] = aggFunc;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
movl $0x0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %r12, 0x18(%rdi)
movq %r12, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq 0x38(%rsi), %r13
movq 0x40(%rsi), %r15
cmpq %r15, %r13
je 0x4cb6
leaq ... | /SamNormcoreWayne[P]AdhocQueryProcessing/MFQueryInputParser/src/ParserClass.cc |
ParserClass::splitStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char) | static std::vector<std::string> splitStr(std::string str, char pattern = ',')
{
/**
* TODO: replace std::string.substr() by ParserClass::subStr()
* Split a string by a specific pattern. The default pattern is ','
* PARAMS: str : string, pattern : string
* RETURN: stringLs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsi), %rcx
xorl %r15d, %r15d
testq %rcx, %rcx
je 0x4ebb
movl %edx, %ebp
leaq 0x38(%rsp), %rbx
movq (%r14), %rax
leaq 0x28(%rsp)... | /SamNormcoreWayne[P]AdhocQueryProcessing/MFQueryInputParser/src/ParserClass.hpp |
ParsedStruct::ParsedStruct(ParsedStruct const&) | ParsedStruct(const ParsedStruct&) = default; | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x9b1c
leaq 0x20(%rbx), %r14
leaq 0x30(%rbx), %r15
movq %r15, 0x20(%rbx)
movq 0x20... | /SamNormcoreWayne[P]AdhocQueryProcessing/MFQueryInputParser/src/parsedStruct.hpp |
spdlog::logger::log(spdlog::source_loc, spdlog::level::level_enum, fmt::v9::basic_string_view<char>) | void log(source_loc loc, level::level_enum lvl, string_view_t msg)
{
bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled)
{
return;
}
details::log_msg log_msg(loc, name_, lvl, msg);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl 0x40(%rdi), %r14d
cmpl %esi, %r14d
setg %r13b
addq $0x68, %rdi
callq 0x2e9e2
movl %eax, %r12d
xorb $0x1, %al
testb %al, %r13b
jne 0x2bcc3
leaq 0xc0(%rsp), %rax
xo... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/logger.h |
spdlog::details::short_filename_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
if (msg.source.empty())
{
ScopedPadder p(0, padinfo_, dest);
return;
}
auto filename = basename(msg.source.filename);
size_t text_size = padinfo_.enabled() ? std::... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdi, %r15
cmpl $0x0, 0x40(%rsi)
je 0x38dcb
movq 0x38(%rsi), %r12
movq %r12, %rdi
movl $0x2f, %esi
callq 0x176b0
leaq 0x1(%rax), %r14
testq %rax, %rax
cmoveq %r12, %r14
leaq 0x8(%r15), %r12
cmpb $0x1, 0x15(%r15)
jne 0x38de7
movq %r14, %rd... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::source_filename_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
if (msg.source.empty())
{
ScopedPadder p(0, padinfo_, dest);
return;
}
size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(msg.source.filename) : 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdi, %rdx
cmpl $0x0, 0x40(%rsi)
je 0x38e70
movq %rsi, %r14
leaq 0x8(%rdx), %r15
cmpb $0x1, 0x15(%rdx)
jne 0x38e8b
movq 0x38(%r14), %rdi
callq 0x17250
movq %rax, %rsi
jmp 0x38e8d
addq $0x8, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
m... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::source_linenum_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
if (msg.source.empty())
{
ScopedPadder p(0, padinfo_, dest);
return;
}
auto field_size = ScopedPadder::count_digits(msg.source.line);
ScopedPadder p(field_size, p... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdi, %rdx
cmpl $0x0, 0x40(%rsi)
je 0x38f52
movq %rsi, %r14
movl 0x40(%rsi), %esi
movl %esi, %eax
orl $0x1, %eax
bsrl %eax, %eax
leaq 0x5a32c(%rip), %rcx # 0x93240
addq (%rcx,%rax,8), %rsi
shrq $0x20, %rsi
addq $0x8, %rdx
movq %rsp, %rdi
movq %rbx, %rcx
ca... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::source_funcname_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
if (msg.source.empty())
{
ScopedPadder p(0, padinfo_, dest);
return;
}
size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(msg.source.funcname) : 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdi, %rdx
cmpl $0x0, 0x40(%rsi)
je 0x38fc4
movq %rsi, %r14
leaq 0x8(%rdx), %r15
cmpb $0x1, 0x15(%rdx)
jne 0x38fdf
movq 0x48(%r14), %rdi
callq 0x17250
movq %rax, %rsi
jmp 0x38fe1
addq $0x8, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
m... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
fmt::v9::basic_memory_buffer<wchar_t, 500ul, std::allocator<wchar_t>>::grow(unsigned long) | FMT_CONSTEXPR20 void basic_memory_buffer<T, SIZE, Allocator>::grow(
size_t size) {
detail::abort_fuzzing_if(size > 5000);
const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
size_t old_capacity = this->capacity();
size_t new_capacity = old_capacity + old_capacity / 2;
if (size > ne... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
addq $0x7f0, %rdi # imm = 0x7F0
movq 0x18(%r14), %rbx
movq %rbx, %r15
shrq %r15
addq %rbx, %r15
cmpq %rsi, %r15
jae 0x42c58
movq %rsi, %r15
jmp 0x42c72
movq %r15, %rax
shrq $0x3d, %rax
je 0x42c72
movabsq $0x1fffffffffffffff, %r15 # imm = ... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
sim_combinational_order_correct_Test::TestBody() | TEST(sim, combinational_order_correct) { // NOLINT
Context context;
auto &mod = context.generator("mod");
auto &a = mod.var("a", 4, {2, 2});
auto &b = mod.var("b", 4, {2, 2});
auto &c = mod.var("c", 4);
auto comb = mod.combinational();
comb->add_stmt(a.assign(b));
comb->add_stmt(c.assig... | pushq %rbp
movq %rsp, %rbp
subq $0x610, %rsp # imm = 0x610
movq %rdi, -0x8(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x46db0
leaq -0x151(%rbp), %rdi
movq %rdi, -0x540(%rbp)
callq 0x37190
movq -0x540(%rbp), %rdx
leaq 0x2eeda2(%rip), %rsi # 0x32c43e
leaq -0x150(%rbp), %rdi
callq 0x469d0
jmp 0x3d6aa
leaq -0x128(%r... | /Kuree[P]kratos/tests/test_sim.cc |
sim_array_access_Test::TestBody() | TEST(sim, array_access) { // NOLINT
Context context;
auto &mod = context.generator("mod");
auto &a = mod.var("a", 4, 4);
auto &b = mod.var("b", 2);
Simulator sim(&mod);
uint32_t constexpr value = 5;
sim.set(&b, 2ul);
sim.set(&a[b.shared_from_this()], value);
auto res = sim.get(&a... | pushq %rbp
movq %rsp, %rbp
subq $0x510, %rsp # imm = 0x510
movq %rdi, -0x8(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x46db0
leaq -0x151(%rbp), %rdi
movq %rdi, -0x478(%rbp)
callq 0x37190
movq -0x478(%rbp), %rdx
leaq 0x2ee272(%rip), %rsi # 0x32c43e
leaq -0x150(%rbp), %rdi
callq 0x469d0
jmp 0x3e1da
leaq -0x128(%r... | /Kuree[P]kratos/tests/test_sim.cc |
sim_slicing_bit_Test::~sim_slicing_bit_Test() | TEST(sim, slicing_bit) { // NOLINT
Context context;
auto &mod = context.generator("mod");
auto &a = mod.var("a", 3);
auto [high, low] = compute_var_high_low(&a, {{1, 1}});
EXPECT_EQ(high, 1);
EXPECT_EQ(low, 1);
auto &b = mod.var("b", 4, {2, 2});
std::tie(high, low) = compute_var_high_lo... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x624f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /Kuree[P]kratos/tests/test_sim.cc |
sim_ternary_Test::sim_ternary_Test() | TEST(sim, ternary) { // NOLINT
Context ctx;
auto &gen = ctx.generator("mod");
auto &a = gen.var("a", 1);
auto &b = gen.var("b", 16);
auto &c = gen.var("c", 16);
Simulator sim(&gen);
sim.set(&a, 0);
sim.set(&b, 42);
sim.set(&c, 25);
auto cond = ConditionalExpr(a.shared_from_thi... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x62470
movq -0x10(%rbp), %rax
leaq 0x44f1cc(%rip), %rcx # 0x49ee30
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /Kuree[P]kratos/tests/test_sim.cc |
testing::AssertionResult testing::internal::CmpHelperEQFailure<unsigned long, int>(char const*, char const*, unsigned long const&, int const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x2... | /Kuree[P]kratos/extern/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<unsigned long, unsigned int>(char const*, char const*, unsigned long const&, unsigned int const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x2... | /Kuree[P]kratos/extern/googletest/googletest/include/gtest/gtest.h |
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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpb $0x0, 0x455fe9(%rip) # 0x4af128
jne 0x59186
leaq 0x455fe0(%rip), %rdi # 0x4af128
callq 0x36630
cmpl $0x0, %eax
je 0x59186
leaq 0x455f87(%rip), %rdi # 0x4af0e0
callq 0x740a0
jmp 0x59160
leaq 0x1afd9(%rip), %rdi # 0x74140
leaq 0x455f72(%rip), %rsi # 0x4af0e... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&) | std::string AppendUserMessage(const std::string& gtest_msg,
const Message& user_msg) {
// Appends the user message if it's non-empty.
const std::string user_msg_string = user_msg.GetString();
if (user_msg_string.empty()) {
return gtest_msg;
}
if (gtest_msg.empty()) {
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x5d620
leaq -0x38(%rbp), %rdi
callq 0x36520
testb $0x1, %al
jne 0x5960e
jmp 0x5963a
movq -0x7... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool) | void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
bool has_test_p) {
const auto& ignored = *GetIgnoredParameterizedTestSuites();
if (ignored.find(name) != ignored.end()) return;
const char kMissingInstantiation[] = //
" is defined via TEST_P, but nev... | pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp # imm = 0x480
movq %rsi, -0x450(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
callq 0x59730
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x82e70
movq %rax, -0x28(%rbp)
movq -0x20(... | /Kuree[P]kratos/extern/googletest/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x37190
movq -0xc8(%rbp), %rsi
movq -0xc0(... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::TypeParameterizedTestSuiteRegistry::RegisterInstantiation(char const*) | void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
const char* test_suite_name) {
auto it = suites_.find(std::string(test_suite_name));
if (it != suites_.end()) {
it->second.instantiated = true;
} else {
GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x37190
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x38(... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations() | void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
const auto& ignored = *GetIgnoredParameterizedTestSuites();
for (const auto& testcase : suites_) {
if (testcase.second.instantiated) continue;
if (ignored.find(testcase.first) != ignored.end()) continue;
std::string message =
"... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x188(%rbp)
callq 0x59730
movq %rax, %rcx
movq -0x188(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x83250
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0) | TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
const char* type_param, const char* value_param,
const char* file, int line, Factory factory) {
using TestT = typename std::remove_pointer<decltype(factory())>::type;
class FactoryImpl : public ... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq 0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rax... | /Kuree[P]kratos/extern/googletest/googletest/include/gtest/gtest.h |
testing::internal::HasOneFailure(char const*, char const*, char const*, testing::TestPartResultArray const&, testing::TestPartResult::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static AssertionResult HasOneFailure(const char* /* results_expr */,
const char* /* type_expr */,
const char* /* substr_expr */,
const TestPartResultArray& results,
TestPar... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
subl $0... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::SumOverTestSuiteList(std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&, int (testing::TestSuite::*)() const) | static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list,
int (TestSuite::*method)() const) {
int sum = 0;
for (size_t i = 0; i < case_list.size(); i++) {
sum += (case_list[i]->*method)();
}
return sum;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
ca... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*) | void SplitString(const ::std::string& str, char delimiter,
::std::vector< ::std::string>* dest) {
::std::vector< ::std::string> parsed;
::std::string::size_type pos = 0;
while (::testing::internal::AlwaysTrue()) {
const ::std::string::size_type colon = str.find(delimiter, pos);
if (colon ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x83330
movq $0x0, -0x38(%rbp)
callq 0x5d260
movb %al, -0x91(%rbp)
jmp 0x5d137
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x5d146
jmp 0x5d22e
movq -0x8(%rbp), %rdi
mov... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::Message::Message() | Message::Message() : ss_(new ::std::stringstream) {
// By default, we want there to be enough precision when printing
// a double to a Message.
*ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movl $0x188, %edi # imm = 0x188
callq 0x362a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x36590
jmp 0x5d2d3
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
ca... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*) | std::string StringStreamToString(::std::stringstream* ss) {
const ::std::string& str = ss->str();
const char* const start = str.c_str();
const char* const end = start + str.length();
std::string result;
result.reserve(static_cast<size_t>(2 * (end - start)));
for (const char* ch = start; ch != end; ++ch) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x36cc0
movq -0x80(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x361f0
mov... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::AssertionResult::AssertionResult(testing::AssertionResult const&) | AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_),
message_(other.message_.get() != nullptr
? new ::std::string(*other.message_)
: static_cast< ::std::string*>(nullptr)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x496b0
movb $0x0, -0x19(%rbp)
cmpq $0x0, %rax
je 0x5... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::CalculateOptimalEdits(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>,... | std::vector<EditType> CalculateOptimalEdits(
const std::vector<std::string>& left,
const std::vector<std::string>& right) {
std::vector<size_t> left_ids, right_ids;
{
InternalStrings intern_table;
for (size_t i = 0; i < left.size(); ++i) {
left_ids.push_back(intern_table.GetId(left[i]));
}... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x843b0
leaq -0x48(%rbp), %rdi
callq 0x843b0
leaq -0x78(%rbp), %rdi
callq 0x5e510
movq $0x0, -0x80(%rbp)
movq -0x80(%... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::Hunk::PushLine(char, char const*) | void PushLine(char edit, const char* line) {
switch (edit) {
case ' ':
++common_;
FlushEdits();
hunk_.push_back(std::make_pair(' ', line));
break;
case '-':
++removes_;
hunk_removes_.push_back(std::make_pair('-', line));
break;
case '+':
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movsbl -0x9(%rbp), %eax
movl %eax, -0x60(%rbp)
subl $0x20, %eax
je 0x5ec2a
jmp 0x5ec0f
movl -0x60(%rbp), %eax
subl $0x2b, %eax
je 0x5ecb1
jmp 0x5ec1d
... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::Hunk::PrintTo(std::ostream*) | void PrintTo(std::ostream* os) {
PrintHeader(os);
FlushEdits();
for (std::list<std::pair<char, const char*> >::const_iterator it =
hunk_.begin();
it != hunk_.end(); ++it) {
*os << it->first << it->second << "\n";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x7fd00
movq -0x38(%rbp), %rdi
callq 0x7fc60
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x8fee0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::EqFailure(char const*, char const*, 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&, bool) | AssertionResult EqFailure(const char* lhs_expression,
const char* rhs_expression,
const std::string& lhs_value,
const std::string& rhs_value,
bool ignoring_case) {
Message msg;
msg << "Expected equality of these ... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xc0(%rbp)
movb %r9b, %al
movq %rdi, %r9
movq %r9, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
leaq -0x38(%rbp), %rdi
mo... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::GetBoolAssertionFailureMessage[abi:cxx11](testing::AssertionResult const&, char const*, char const*, char const*) | std::string GetBoolAssertionFailureMessage(
const AssertionResult& assertion_result,
const char* expression_text,
const char* actual_predicate_value,
const char* expected_predicate_value) {
const char* actual_message = assertion_result.message();
Message msg;
msg << "Value of: " << expression_text... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49650
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::CmpHelperSTREQ(char const*, char const*, wchar_t const*, wchar_t const*) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
const char* rhs_expression,
const wchar_t* lhs,
const wchar_t* rhs) {
if (String::WideCStringEquals(lhs, rhs)) {
return AssertionSuccess();
}
return EqFailur... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x612c0
testb $0x1, %al
jne 0x61360
jmp 0x61371
m... | /Kuree[P]kratos/extern/googletest/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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x612c0
testb $0x1, %al
jne 0x61482
movq -0x98(%r... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::String::CaseInsensitiveWideCStringEquals(wchar_t const*, wchar_t const*) | bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
const wchar_t* rhs) {
if (lhs == nullptr) return rhs == nullptr;
if (rhs == nullptr) return false;
#if GTEST_OS_WINDOWS
return _wcsicmp(lhs, rhs) == 0;
#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x61646
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6166b
cmpq $0x0, -0x18(%rbp)
jne 0x61653
movb $0x0, -0x1(%rbp)
jmp 0x6166b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::String::FormatIntWidthN[abi:cxx11](int, int) | std::string String::FormatIntWidthN(int value, int width) {
std::stringstream ss;
ss << std::setfill('0') << std::setw(width) << value;
return ss.str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x36590
leaq -0x188(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movl $0x30, %edi
callq 0x85bd0
mo... | /Kuree[P]kratos/extern/googletest/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
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x1d0(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x36590
leaq -0x188(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movl $0x30, %edi
callq 0x85bd0
movb %al, -... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::TestResult::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&) | void TestResult::RecordProperty(const std::string& xml_element,
const TestProperty& test_property) {
if (!ValidateTestProperty(xml_element, test_property)) {
return;
}
internal::MutexLock lock(&test_properties_mutex_);
const std::vector<TestProperty>::iterator property_with_m... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x61e50
testb $0x1, %al
jne 0x61bd8
jmp 0x61df1
movq -0xc8(%rbp), %rsi
leaq -0x20(%rb... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::ValidateTestPropertyName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | static bool ValidateTestPropertyName(
const std::string& property_name,
const std::vector<std::string>& reserved_names) {
if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
reserved_names.end()) {
ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_n... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x88660
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x88690
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x88610
movq %rax, -0x20(%rbp)
movq... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::GetReservedAttributesForElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::vector<std::string> GetReservedAttributesForElement(
const std::string& xml_element) {
if (xml_element == "testsuites") {
return ArrayAsVector(kReservedTestSuitesAttributes);
} else if (xml_element == "testsuite") {
return ArrayAsVector(kReservedTestSuiteAttributes);
} else if (xml_element... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2cd29a(%rip), %rsi # 0x32f3f0
callq 0x89b90
testb $0x1, %al
jne 0x62161
jmp 0x62176
movq -0x38(%rbp), %rdi
leaq 0x43da84(%rip), %rsi ... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::ReportInvalidTestSuiteType(char const*, testing::internal::CodeLocation) | void ReportInvalidTestSuiteType(const char* test_suite_name,
CodeLocation code_location) {
Message errors;
errors
<< "Attempted redefinition of test suite " << test_suite_name << ".\n"
<< "All tests in the same test suite must use the same test fixture\n"
<< "class.... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5d2a0
movq -0x78(%rbp), %rdi
leaq 0x2cb683(%rip), %rsi # 0x32ed72
callq 0x86ee0
movq %rax, -0x70(%rbp)
jmp 0x636fa
movq -0x70(%rbp), %rdi
leaq -0x8(%rb... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::TestInfo::Run() | void TestInfo::Run() {
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
if (!should_run_) {
if (is_disabled_) repeater->OnTestDisabled(*this);
return;
}
// Tells UnitTest where to store test result.
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x59130
movq %rax, %rdi
callq 0x63d20
movq %rax, %rdi
callq 0x5c9a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x10(%rbp)
testb $0x1, 0x80(%rax)
jne 0x63bdd
movq -0x50(%rbp), %rax
testb $0x1, 0x8... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::ShouldUseColor(bool) | bool ShouldUseColor(bool stdout_is_tty) {
std::string c = GTEST_FLAG_GET(color);
const char* const gtest_color = c.c_str();
if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
// On Windows the TERM variable is usually not set, but the
// conso... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x2(%rbp)
leaq 0x44a911(%rip), %rsi # 0x4aeff8
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x36230
movq -0x60(%rbp), %rdi
callq 0x361f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x2c9cf4(%rip), %rsi # 0x32e400
ca... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::PrintFullTestCommentIfPresent(testing::TestInfo const&) | static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
const char* const type_param = test_info.type_param();
const char* const value_param = test_info.value_param();
if (type_param != nullptr || value_param != nullptr) {
printf(", where ");
if (type_param != nullptr) {
printf("%s =... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x88780
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x88730
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x65b24
cmpq $0x0, -0x18(%rbp)
je 0x65b8b
leaq 0x2ca7c7(%rip), %rdi # 0x3302f2
movb $0x0, %al
callq 0x3611... | /Kuree[P]kratos/extern/googletest/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_GET(print_time)) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x87ce0
movq %rax, %rdi
callq 0x62340
testb $0x1, %al
jne 0x6668a
jmp 0x66755
movl $0x1, %edi
leaq 0x2c8a41(%rip), %rsi # 0x32f0d7
movb $0x0, %al
callq 0x64bf0
movq -0x10(%rbp), %rdi
callq 0x86890
mo... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*) | XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
: output_file_(output_file) {
if (output_file_.empty()) {
GTEST_LOG_(FATAL) << "XML output file may not be null";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x88280
movq -0x48(%rbp), %rax
leaq 0x438170(%rip), %rcx # 0x49f5c8
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -... | /Kuree[P]kratos/extern/googletest/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x83560
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x7c300
jmp 0x676a7
leaq -0x50(%rbp), %rdi
callq 0x7c660
movb %al, -0x69(%rbp)
jmp 0x676b5
movb -... | /Kuree[P]kratos/extern/googletest/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 %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x37190
movq -0x128(%rbp), %rdx
leaq 0x2c6fcf(%rip), %rsi # 0x32f3f0
leaq -0x30(%rbp), %rdi
callq 0x469d0
jmp 0x6842c
leaq -0x31(%rbp), %rdi
callq 0x... | /Kuree[P]kratos/extern/googletest/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x36620
movq -0x10(%rbp), %rdi
callq 0x36570
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x36ef0
jmp 0x68aab
movq -0x10(%rbp), %rdi
callq 0... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsIso8601[abi:cxx11](long) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss.sss
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon + ... | pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp # imm = 0x2D0
movq %rdi, -0x2b8(%rbp)
movq %rdi, %rax
movq %rax, -0x2b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0x691a0
testb ... | /Kuree[P]kratos/extern/googletest/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2c6051(%rip), %rsi # 0x32f244
callq 0x36a60
movq -0x18(%rbp), %rdi
leaq 0x2c6034(%rip), %rsi # 0x32f237
callq 0x36880
movq %rax, -0x20(%rbp)
cmpq $0x0... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlAttribute(std::ostream*, 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::alloc... | void XmlUnitTestResultPrinter::OutputXmlAttribute(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
const std::string& value) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_name);
GTEST_CHECK_(std::find(allowed_na... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x69500
movq -0xa8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(std::ostream*, testing::TestResult const&) | void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(
::std::ostream* stream, const TestResult& result) {
// Output the boilerplate for a minimal test suite with one test.
*stream << " <testsuite";
OutputXmlAttribute(stream, "testsuite", "name", "NonTestSuiteFailure");
OutputXmlAttribute(stream, ... | pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2c5c52(%rip), %rsi # 0x32f2e0
callq 0x36a60
movq -0x8(%rbp), %rax
movq %rax, -0x6a0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x698(%rbp)
callq 0x37190
movq -0x698(%rbp), %rd... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestResult(std::ostream*, testing::TestResult const&) | void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream,
const TestResult& result) {
int failures = 0;
int skips = 0;
for (int i = 0; i < result.total_part_count(); ++i) {
const TestPartResult& part = result.GetTestPartResult(i);
if (par... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x224(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61ae0
movl %eax, %ecx
movl -0x224(%rbp), %eax
cmpl %ecx, %... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(std::ostream*, char const*, testing::TestInfo const&) | void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
const char* test_suite_name,
const TestInfo& test_info) {
const TestResult& result = *test_info.result();
const std::string kTestsuite = "testcas... | pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp # imm = 0x4D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x87ce0
movq %rax, -0x20(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x370(%rbp)
callq 0x37190
movq -0x370(%rbp), %rdx
leaq 0x2c4006(%rip), %rsi # 0x32f3... | /Kuree[P]kratos/extern/googletest/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 (in... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x37190
movq -0x118(%rbp), %rdx
leaq 0x2c324b(%rip), %rsi # 0x32f42c
leaq -0x30(%rbp), %rdi
callq 0x469d0
jmp 0x6c1ec
leaq -0x31(%rbp), %rdi
callq 0x... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream*, testing::TestSuite const&) | void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
const TestSuite& test_suite) {
const std::string kTestsuite = "testsuite";
*stream << " <" << kTestsuite;
OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
OutputXmlAttribute... | pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp # imm = 0x410
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x2e8(%rbp)
callq 0x37190
movq -0x2e8(%rbp), %rdx
leaq 0x2c2ca2(%rip), %rsi # 0x32f2e3
leaq -0x30(%rbp), %rdi
callq 0x469d0
jmp 0x6c64c
leaq -0x31(%rbp), %rdi
callq 0x... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(char const*) | JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file)
: output_file_(output_file) {
if (output_file_.empty()) {
GTEST_LOG_(FATAL) << "JSON output file may not be null";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x88280
movq -0x48(%rbp), %rax
leaq 0x4322c0(%rip), %rcx # 0x49f668
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -... | /Kuree[P]kratos/extern/googletest/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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x67670
movq %rax, -0x20(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x36590
xorl %eax, %eax
leaq -0x1a8(%rbp), %rcx
cmpq $0x0, %rcx
movq %rax, -0... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::EscapeJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '\\':
case '"':
case '/':
m << '\\' << ch;
break;
case '\b':
m << "\\b";
break;... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5d2a0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36570
movq %rax, %rcx
movq -0x70... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(std::ostream*, 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator... | void JsonUnitTestResultPrinter::OutputJsonKey(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
const std::string& value,
const std::string& indent,
bool comma) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x69500
mo... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(std::ostream*, testing::TestResult const&) | void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(
::std::ostream* stream, const TestResult& result) {
// Output the boilerplate for a new test suite.
*stream << Indent(4) << "{\n";
OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6));
OutputJsonKey(stream, "testsuite"... | pushq %rbp
movq %rsp, %rbp
subq $0xa90, %rsp # imm = 0xA90
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x880(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x878(%rbp)
movl $0x4, %esi
callq 0x701d0
movq -0x880(%rbp), %rdi
movq -0x878(%rbp), %rsi
callq 0x36580
movq %rax, -0x870(%r... | /Kuree[P]kratos/extern/googletest/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 %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x278(%rbp)
movq %rdi, %rax
movq %rax, -0x270(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0x691a0
testb ... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::TestPropertiesAsJson(testing::TestResult const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
const TestResult& result, const std::string& indent) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << ",\n" << indent << "\"" << property.key... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5d2a0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq -0x10(%rb... | /Kuree[P]kratos/extern/googletest/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
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movl $0xa, %esi
callq 0x701d0
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0xf4(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61ae0
movl %eax, %ecx
movl -0... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestInfo(std::ostream*, char const*, testing::TestInfo const&) | void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
const char* test_suite_name,
const TestInfo& test_info) {
const TestResult& result = *test_info.result();
const std::string kTestsuite = "t... | pushq %rbp
movq %rsp, %rbp
subq $0x550, %rsp # imm = 0x550
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x87ce0
movq %rax, -0x20(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x3d0(%rbp)
callq 0x37190
movq -0x3d0(%rbp), %rdx
leaq 0x2be406(%rip), %rsi # 0x32f3... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestSuite(std::ostream*, testing::TestSuite const&) | void JsonUnitTestResultPrinter::PrintJsonTestSuite(
std::ostream* stream, const TestSuite& test_suite) {
const std::string kTestsuite = "testsuite";
const std::string kIndent = Indent(6);
*stream << Indent(4) << "{\n";
OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
OutputJsonKey(s... | pushq %rbp
movq %rsp, %rbp
subq $0x390, %rsp # imm = 0x390
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x37190
movq -0x258(%rbp), %rdx
leaq 0x2bd532(%rip), %rsi # 0x32f2e3
leaq -0x30(%rbp), %rdi
callq 0x469d0
jmp 0x71dbc
leaq -0x31(%rbp), %rdi
callq 0x... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::StreamingListener::SocketWriter::MakeConnection() | void StreamingListener::SocketWriter::MakeConnection() {
GTEST_CHECK_(sockfd_ == -1)
<< "MakeConnection() can't be called when there is already a connection.";
addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses.
hints.ai_socktype =... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpl $-0x1, 0x8(%rax)
sete %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x58f50
testb $0x1, %al
jne 0x72dcf
jmp 0x72dd4
jmp 0x72e5a
leaq 0x2bb6e9(%rip), %rdx # 0x32e4c4
leaq -0xc(%rbp), %rdi
movq %rdi, -0x88(... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::OsStackTraceGetter::CurrentStackTrace[abi:cxx11](int, int) | GTEST_LOCK_EXCLUDED_(mutex_) {
#if GTEST_HAS_ABSL
std::string result;
if (max_depth <= 0) {
return result;
}
max_depth = std::min(max_depth, kMaxStackTraceDepth);
std::vector<void*> raw_stack(max_depth);
// Skips the frames requested by the caller, plus this function.
const int raw_stack_size =
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x37190
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x2bbfdc(%ri... | /Kuree[P]kratos/extern/googletest/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x73335
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rsi
callq 0x73260
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x73313
movq -0x20(%rbp), %rdi
... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener*) | void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
if (default_xml_generator_ != listener) {
// It is an error to pass this method a listener that is already in the
// list.
delete Release(default_xml_generator_);
default_xml_generator_ = listener;
if (listener != nullp... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x733a5
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x73260
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x73383
movq -0x20(%rbp), %rd... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::UnitTest::Run() | int UnitTest::Run() {
const bool in_death_test_child_process =
GTEST_FLAG_GET(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 absolut... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x43b9b2(%rip), %rdi # 0x4af130
callq 0x36a50
cmpq $0x0, %rax
seta %al
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x7379d
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x737ad
leaq 0x2b... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RunAllTests() | bool UnitTestImpl::RunAllTests() {
// True if and only if Google Test is initialized before RUN_ALL_TESTS() is
// called.
const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
// Do not run any test if the --help flag was specified.
if (g_help_flag)
return true;
// Repeats the c... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x752b0
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq 0x43b756(%rip), %rax # 0x4aeff1
testb $0x1, (%rax)
je 0x738a9
movb $0x1, -0x1(%rbp)
jmp 0x73f12
movq -0xb0(%rbp), %rdi
callq 0x74e30
callq 0x752f0
m... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::UnitTestImpl(testing::UnitTest*) | UnitTestImpl::UnitTestImpl(UnitTest* parent)
: parent_(parent),
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
default_global_test_part_result_reporter_(this),
default_per_thread_test_part_result_reporter_(this),
GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq 0x42b45e(%rip), %rax # 0x49f730
addq $0x10, %rax
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x40(%rbp)
callq 0x834a0
movq -0x38(%r... | /Kuree[P]kratos/extern/googletest/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... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x218(%rax)
jne 0x74ee4
movq -0x20(%rbp), %rdi
movb $0x1, 0x218(%rdi)
callq 0x89c90
movq -0x20(%rbp), %rdi
callq 0x748d0
movq -0x20(%rbp), %rdi
callq 0x63b30
movq -0x20(%rbp), %rdi
callq 0x74910
le... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::KilledBySignal::operator()(int) const | bool KilledBySignal::operator()(int exit_status) const {
# if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
{
bool result;
if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
return result;
}
}
# endif // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
return WIFSIGNALED(exit_status)... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %ecx
sarl %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
jle 0x76afd
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
andl $0x7f, ... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTest::DeathTest() | DeathTest::DeathTest() {
TestInfo* const info = GetUnitTestImpl()->current_test_info();
if (info == nullptr) {
DeathTestAbort("Cannot run a death test outside of a TEST or "
"TEST_F construct");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x429221(%rip), %rcx # 0x49fe18
addq $0x10, %rcx
movq %rcx, (%rax)
callq 0x830c0
movq %rax, %rdi
callq 0x867b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x76c86
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-death-test.cc |
testing::internal::FailFromInternalError(int) | static void FailFromInternalError(int fd) {
Message error;
char buffer[256];
int num_read;
do {
while ((num_read = posix::Read(fd, buffer, 255)) > 0) {
buffer[num_read] = '\0';
error << buffer;
}
} while (num_read == -1 && errno == EINTR);
if (num_read == 0) {
GTEST_LOG_(FATAL) << ... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movl %edi, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x5d2a0
jmp 0x773f9
movl -0x4(%rbp), %edi
leaq -0x110(%rbp), %rsi
movl $0xff, %edx
callq 0x8b3d0
movl %eax, -0x174(%rbp)
jmp 0x77415
movl -0x174(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x0, %eax
jl... | /Kuree[P]kratos/extern/googletest/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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x140(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x7772d
movb $0x4c, %al
movb %al, -0x141(%rbp)
jmp 0x7775d
movl -0xc(%rbp), %ecx
movb $0x54, %al
movb $0x52, %dl
movb %dl, -0x143(%rbp... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-death-test.cc |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int*, char**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
std::string flagfile_value;
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseFlag;
bool remove_flag = false;
if (ParseGo... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x36620
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x8aee9
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x58(%rbp), %rdi
... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<wchar_t>(int*, wchar_t**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
std::string flagfile_value;
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseFlag;
bool remove_flag = false;
if (ParseGo... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x36620
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x8b0f1
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x58(%rbp), %rdi
... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.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.