name string | code string | asm string | file string |
|---|---|---|---|
secp256k1_ecdsa_adaptor_sign | int secp256k1_ecdsa_adaptor_sign(const secp256k1_context* ctx, unsigned char *adaptor_sig65, unsigned char *adaptor_proof97, unsigned char *seckey32, const secp256k1_pubkey *adaptor, const unsigned char *msg32) {
unsigned char nonce32[32];
unsigned char buf33[33];
secp256k1_sha256 sha;
secp256k1_scalar ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6d8, %rsp # imm = 0x6D8
movq %rcx, 0x8(%rsp)
movq %rdi, %r13
cmpq $0x0, 0x10(%rdi)
je 0x31b736
movq %rsi, %r14
testq %rsi, %rsi
je 0x31b746
movq %rdx, %r12
testq %rdx, %rdx
je 0x31b756
movq %r8, %rbx
testq %r8, %r8
je 0x31b766
movq %r9... | /p2pderivatives[P]cfd/external/libwally-core/src/secp256k1/src/modules/ecdsa_adaptor/main_impl.h |
secp256k1_fe_inv | static void secp256k1_fe_inv(secp256k1_fe *r, const secp256k1_fe *a) {
secp256k1_fe x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
int j;
/** The binary representation of (p - 2) has 5 blocks of 1s, with lengths in
* { 1, 2, 22, 223 }. Use an addition chain to calculate 2^n - 1 for each bl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x108(%rsp), %r15
movq %r15, %rdi
callq 0x31c8c2
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x31c526
leaq 0x88(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x31c8c2
movq... | /p2pderivatives[P]cfd/external/libwally-core/src/secp256k1/src/field_impl.h |
secp256k1_hmac_sha256_initialize | static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256 *hash, const unsigned char *key, size_t keylen) {
size_t n;
unsigned char rkey[64];
if (keylen <= sizeof(rkey)) {
memcpy(rkey, key, keylen);
memset(rkey + keylen, 0, sizeof(rkey) - keylen);
} else {
secp256k1_sha2... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
leaq 0x68(%rdi), %r14
movq %r14, %rdi
callq 0x316988
xorl %eax, %eax
cmpq $0x40, %rax
je 0x31d853
xorb $... | /p2pderivatives[P]cfd/external/libwally-core/src/secp256k1/src/hash_impl.h |
secp256k1_gej_rescale | static void secp256k1_gej_rescale(secp256k1_gej *r, const secp256k1_fe *s) {
/* Operations: 4 mul, 1 sqr */
secp256k1_fe zz;
VERIFY_CHECK(!secp256k1_fe_is_zero(s));
secp256k1_fe_sqr(&zz, s);
secp256k1_fe_mul(&r->x, &r->x, &zz); /* r->x *= s^2 */
secp256k1_fe_mul(&r->y, &r->y, &zz)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x31c8c2
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x31c526
leaq 0x28(%r14), %r12
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x31c526
movq %r12, %rdi
movq %r12, %rsi
... | /p2pderivatives[P]cfd/external/libwally-core/src/secp256k1/src/group_impl.h |
secp256k1_rangeproof_genrand | SECP256K1_INLINE static int secp256k1_rangeproof_genrand(secp256k1_scalar *sec, secp256k1_scalar *s, unsigned char *message,
size_t *rsizes, size_t rings, const unsigned char *nonce, const secp256k1_ge *commit, const unsigned char *proof, size_t len, const secp256k1_ge* genp) {
unsigned char tmp[32];
unsigned ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %r8, %r14
movq %rcx, 0x40(%rsp)
movq %rdx, %rbp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x198(%rsp), %r15
movq 0x1a0(%rsp), %rbx
movq 0x1a8(%rsp), %r12
movq 0x190(%rsp), %rsi
movups (%r9), %xmm0
mo... | /p2pderivatives[P]cfd/external/libwally-core/src/secp256k1/src/modules/rangeproof/rangeproof_impl.h |
secp256k1_whitelist_hash_pubkey | static int secp256k1_whitelist_hash_pubkey(secp256k1_scalar* output, secp256k1_gej* pubkey) {
unsigned char h[32];
unsigned char c[33];
secp256k1_sha256 sha;
int overflow = 0;
size_t size = 33;
secp256k1_ge ge;
secp256k1_ge_set_gej(&ge, pubkey);
secp256k1_sha256_initialize(&sha);
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp # imm = 0x128
andl $0x0, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x21, (%r14)
leaq 0xd0(%rsp), %r15
movq %r15, %rdi
callq 0x31029e
movaps 0xfdfd0(%rip), %xmm0 # 0x41db00
movaps %xmm0, 0x40(%rsp)
movaps 0xfdfd4(%rip), %xmm0 # 0x4... | /p2pderivatives[P]cfd/external/libwally-core/src/secp256k1/src/modules/whitelist/whitelist_impl.h |
base64_decode_using_maps | ssize_t base64_decode_using_maps(const base64_maps_t *maps,
char *dest, const size_t destlen,
const char *src, const size_t srclen)
{
ssize_t dest_offset = 0;
ssize_t i;
size_t more;
if (destlen < base64_decoded_length(srclen)) {
errno = EOVERFLOW;
return -1;
}
for(i=0; srclen - i > 4; i+=4) {
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x3(%r8), %rax
shrq $0x2, %rax
leaq (%rax,%rax,2), %rax
cmpq %rdx, %rax
jbe 0x320349
callq 0x88060
movl $0x4b, (%rax)
pushq $-0x1
popq %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
m... | /p2pderivatives[P]cfd/external/libwally-core/src/ccan/ccan/base64/base64.c |
UniValue::clear() | void UniValue::clear()
{
typ = VNULL;
val.clear();
keys.clear();
values.clear();
} | pushq %rbx
movq %rdi, %rbx
andl $0x0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x8(%rdi), %rax
movb $0x0, (%rax)
addq $0x28, %rdi
callq 0x2af016
addq $0x40, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x320a58
nop
| /p2pderivatives[P]cfd/external/cfd-core/src/univalue/lib/univalue.cpp |
uvTypeName(UniValue::VType) | const char *uvTypeName(UniValue::VType t)
{
switch (t) {
case UniValue::VNULL: return "null";
case UniValue::VBOOL: return "bool";
case UniValue::VOBJ: return "object";
case UniValue::VARR: return "array";
case UniValue::VSTR: return "string";
case UniValue::VNUM: return "number";
}
... | cmpl $0x5, %edi
ja 0x3209f5
movl %edi, %eax
leaq 0x10e127(%rip), %rcx # 0x42eb14
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
xorl %eax, %eax
retq
| /p2pderivatives[P]cfd/external/cfd-core/src/univalue/lib/univalue.cpp |
json_escape(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::string json_escape(const std::string& inS)
{
std::string outS;
outS.reserve(inS.size() * 2);
for (unsigned int i = 0; i < inS.size(); i++) {
unsigned char ch = inS[i];
const char *escStr = escapes[ch];
if (escStr)
outS += escStr;
else
out... | pushq %r15
pushq %r14
pushq %r12
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
addq %rsi, %rsi
callq 0x88ad0
xorl %r15d, %r15d
leaq 0x234f20(%rip), %r12 # 0x557b20
movl %r15d, %r15d
cmpq %r15, 0x8(%r14)
jb... | /p2pderivatives[P]cfd/external/cfd-core/src/univalue/lib/univalue_write.cpp |
testing::internal::BoolFromGTestEnv(char const*, bool) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const string_value = posix::GetEnv(env_var.c_str());
return string_value == NULL ?
def... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x33315d
movq (%r14), %rdi
callq 0x887d0
testq %rax, %rax
je 0x322ca8
movb $0x1, %bl
cmpb $0x30, (%rax)
jne 0x322ca8
cmpb $0x0, 0x1(%rax)
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x88db0
movl %ebx, %eax
addq $0... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest-port.cc |
testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop[abi:cxx11](int) | std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
return os_stack_trace_getter()->CurrentStackTrace(
static_cast<int>(GTEST_FLAG(stack_trace_depth)),
skip_count + 1
// Skips the user-specified number of frames plus this function
// itself.
); // NOLINT
} | pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3247e0
movl 0x25e183(%rip), %edx # 0x5816a8
incl %ebx
movq (%rax), %r8
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %ecx
callq *0x10(%r8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::FilePath::ConcatPaths(testing::internal::FilePath const&, testing::internal::FilePath const&) | FilePath FilePath::ConcatPaths(const FilePath& directory,
const FilePath& relative_path) {
if (directory.IsEmpty())
return relative_path;
const FilePath dir(directory.RemoveTrailingPathSeparator());
return FilePath(dir.string() + kPathSeparator + relative_path.string());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x323ce8
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x33299e
movq %rsp, %rdi
pushq $0x2f
popq %rdx
movq %r15, %rsi
callq 0x337049
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x1106bb
leaq 0x20(%rsp... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest-filepath.cc |
testing::internal::UnitTestOptions::MatchesFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*) | bool UnitTestOptions::MatchesFilter(
const std::string& name, const char* filter) {
const char *cur_pattern = filter;
for (;;) {
if (PatternMatchesString(cur_pattern, name.c_str())) {
return true;
}
// Finds the next pattern in the filter.
cur_pattern = strchr(cur_pattern, ':');
// R... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rbx
pushq $0x3a
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x323dd8
movl %eax, %r15d
testb %al, %al
jne 0x323e77
movq %r14, %rdi
movl %ebp, %esi
callq 0x88230
leaq 0x1(%rax), %r14
testq %rax, %rax
jne 0x323e52
movl %r15d, %eax
add... | /p2pderivatives[P]cfd/external/googletest/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 0x3347cd
movq %rax, %r14
cmpl $0x1, 0x8(%rbx)
jne 0x324073
movq %r14, %rdi
callq 0x3240b0
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3240de
movq %r14, %rdi
callq 0x324114
movq %rax, 0x10(%rbx)
addq $0x90, %r14
mo... | /p2pderivatives[P]cfd/external/googletest/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 0x2341e9(%rip), %rax # 0x558330
movq %rax, (%rdi)
callq 0x3347cd
cmpl $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rbx
jne 0x324166
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3240de
jmp 0x324177
addq $0x90, %rax
movq %rax, %rdi
callq 0x33941e
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::SingleFailureChecker::~SingleFailureChecker() | SingleFailureChecker::~SingleFailureChecker() {
EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movl 0x8(%rdi), %ebp
cmpl $0x2, %ebp
leaq 0x10d254(%rip), %rax # 0x431435
leaq 0x10d25d(%rip), %rsi # 0x431445
cmoveq %rax, %rsi
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x334730
leaq 0x8(%rsp), %rdi... | /p2pderivatives[P]cfd/external/googletest/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 0x110(%rax), %rdi
testq %rdi, %rdi
je 0x32454b
addq $0x90, %rdi
jmp 0x324566
movq 0x108(%rax), %rdi
testq %rdi, %rdi
je 0x32455d
subq $-0x80, %rdi
jmp 0x324566
addq $0x118, %rax # imm = 0x118
movq %rax, %rdi
addq $0x38... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::os_stack_trace_getter() | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == NULL) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
os_stack_trace_getter_ = new OsStackTraceGetter;
#endif // GTEST_OS_STACK_TRACE_GETTER_
}
return... | movq 0x1a8(%rdi), %rax
testq %rax, %rax
je 0x3247ed
retq
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %rdi
callq 0x88600
leaq 0x233e50(%rip), %rcx # 0x558650
movq %rcx, (%rax)
movq %rax, 0x1a8(%rbx)
popq %rbx
retq
| /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::GetTimeInMillis() | TimeInMillis GetTimeInMillis() {
#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)
// Difference between 1970-01-01 and 1601-01-01 in milliseconds.
// http://analogous.blogspot.com/2005/04/epoch.html
const TimeInMillis kJavaEpochToWinFileTimeDelta =
static_cast<TimeInMillis>(116444736UL) * 100000UL;
cons... | pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x88b40
imulq $0x3e8, (%rbx), %rcx # imm = 0x3E8
movq 0x8(%rbx), %rax
movl $0x3e8, %esi # imm = 0x3E8
cqto
idivq %rsi
addq %rcx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | Message& Message::operator <<(const ::std::wstring& wstr) {
internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
return *this;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
xorl %r13d, %r13d
movq %rsp, %r14
cmpq %r13, %r12
je 0x324b10
cmpl $0x0, (%r15,%r13,4)
je 0x324af7
leaq (%r15,%r13,4), %rsi
movl %r12d, %edx
subl %r13d, %edx
movq %r14, %rdi
callq 0x3270d8
movq... | /p2pderivatives[P]cfd/external/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(2 * (end - start));
for (const char* ch = start; ch != end; ++ch) {
if (*ch == '\0') ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x18, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x88b00
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movq (%r14), %r15
movq 0x8(%r14), %r12
movb $0x0, 0x10(%rbx)
leaq (%r12,%r12), %rsi
movq %rbx, %rdi
callq 0x... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::AssertionResult::AssertionResult(testing::AssertionResult const&) | AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_),
message_(other.message_.get() != NULL ?
new ::std::string(*other.message_) :
static_cast< ::std::string*>(NULL)) {
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rsi), %al
movb %al, (%rdi)
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x324c1f
pushq $0x20
popq %rdi
callq 0x88600
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x88930
jmp 0x324c22
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
mo... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::AssertionResult::operator!() const | AssertionResult AssertionResult::operator!() const {
AssertionResult negation(!success_);
if (message_.get() != NULL)
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 0x324c83
leaq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x1384b8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x9e... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationStart(
const UnitTest& unit_test, int iteration) {
if (GTEST_FLAG(repeat) != 1)
printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
const char* const filter = GTEST_FLAG(filter).c_str();
// Prints the filter if it's not *. This remin... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
cmpl $0x1, 0x2588b4(%rip) # 0x5816a0
je 0x328e00
incl %edx
leaq 0x10778b(%rip), %rdi # 0x430582
movl %edx, %esi
xorl %eax, %eax
callq 0x88070
movq 0x258849(%rip), %r14 # 0x581650
leaq 0x1061e8(%rip), %rsi # 0x42eff6
movq %r14, %rdi
callq 0x32... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::ColoredPrintf(testing::internal::GTestColor, char const*, ...) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || \
GTEST_OS_IOS || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
const bool use_color = AlwaysFalse();
#else
static const bool in_color_mo... | pushq %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x328f95
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, ... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::ShouldShard(char const*, char const*, bool) | bool ShouldShard(const char* total_shards_env,
const char* shard_index_env,
bool in_subprocess_for_death_test) {
if (in_subprocess_for_death_test) {
return false;
}
const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1);
const Int32 shard_index = Int32FromEnvOr... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
testl %edx, %edx
jne 0x3290d0
movq %rsi, %r14
pushq $-0x1
popq %rbp
movl %ebp, %esi
callq 0x3293f1
movl %eax, %ebx
movq %r14, %rdi
movl %ebp, %esi
callq 0x3293f1
movl %eax, %ebp
andl %ebx, %eax
cmpl $-0x1, %eax
je 0x3290d0
cmpl $-0x1, %ebx
setne %al
cmpl $-0x1, %ebp
set... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::Int32FromEnvOrDie(char const*, int) | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
const char* str_val = posix::GetEnv(var);
if (str_val == NULL) {
return default_val;
}
Int32 result;
if (!ParseInt32(Message() << "The value of environment variable " << var,
str_val, &result)) {
exit(EXIT_FAILURE);
}
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, 0x18(%rsp)
callq 0x887d0
testq %rax, %rax
je 0x329460
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x324970
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x107905(%rip), %rsi # 0x430d2d
callq 0x885e0
leaq 0x8(%rsp), %rdi
leaq 0x18(%... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestCase const&) | void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(COLOR_GREEN, "[----------] ");
printf("%s from %s", counts.c_str(), test_case.name());
if (test_case.type_param() == ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x3247be
leaq 0x107b2c(%rip), %rdx # 0x431053
leaq 0x10712c(%rip), %rcx # 0x43065a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x3295b4
leaq 0x107108(%rip), %rsi # 0x43064c
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x3... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::FormatCountableNoun[abi:cxx11](int, char const*, char const*) | static std::string FormatCountableNoun(int count,
const char * singular_form,
const char * plural_form) {
return internal::StreamableToString(count) + " " +
(count == 1 ? singular_form : plural_form);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x335f70
leaq 0x106a10(%rip), %rdx # 0x42fff6
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xe2e35
cmpl $0x1, 0... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void PrettyUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
// If the test part succeeded, we don't need to do anything.
if (result.type() == TestPartResult::kSuccess)
return;
// Print failure message from the assertion (e.g. expected this and got that).
PrintTestPartResult(resu... | cmpl $0x0, (%rsi)
je 0x3296d5
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x328073
movq (%rbx), %rdi
callq 0x88aa0
movq 0x22f8a2(%rip), %r14 # 0x558f58
movq (%r14), %rdi
callq 0x88770
movq %rbx, %rdi
callq 0x88db0
movq (%r14), %rdi
callq 0x88770
addq $0x28, %rsp
popq %rbx
popq %... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Passed()) {
ColoredPrintf(COLOR_GREEN, "[ OK ] ");
} else {
ColoredPrintf(COLOR_RED, "[ FAILED ] ");
}
PrintTestName(test_info.test_case_name(), test_info.name());
if (test_info.result()->Failed())... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %r14
movq %r14, %rdi
callq 0x335e86
testb %al, %al
je 0x3296fe
leaq 0x106f90(%rip), %rsi # 0x43068a
pushq $0x2
jmp 0x329707
leaq 0x106f93(%rip), %rsi # 0x430698
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x328f37
movq (%rbx), %rdi
movq 0x20(%... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(testing::TestCase const&) | void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
if (!GTEST_FLAG(print_time)) return;
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(COLOR_GREEN, "[----------] ");
printf("%s from %s (%s ms total)\n\n",
co... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, 0x257e62(%rip) # 0x581698
jne 0x3298cf
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x3247be
leaq 0x107805(%rip), %rdx # 0x431053
leaq 0x106e05(%rip), %rcx # 0x43065a
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x3295b4
leaq 0x106de1(%rip), ... | /p2pderivatives[P]cfd/external/googletest/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();
if (failed_test_count == 0) {
return;
}
for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
const TestCase& test_case = *unit_test.GetTestCase(i);
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x329a0c
testl %eax, %eax
je 0x3299fc
pushq $0xa
popq %r12
xorl %r13d, %r13d
movq 0x40(%rbx), %rax
movq 0xc0(%rax), %rcx
subq 0xb8(%rax), %rcx
shrq $0x3, %rcx
cmpl %ecx, %r13d
jge 0x3299fc
movq %rbx, %rdi
movl %r13d, %esi... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::OnTestIterationEnd(testing::UnitTest const&, int) | void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
int iteration) {
if (forwarding_enabled_) {
for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) {
listeners_[i]->OnTestIterationEnd(unit_test, iteration);
}
}
} | cmpb $0x1, 0x8(%rdi)
jne 0x32a070
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rax
subq 0x10(%rdi), %rax
shrq $0x3, %rax
movl %eax, %r12d
testl %r12d, %r12d
jle 0x32a065
movq 0x10(%r15), %rax
movq -0x8(%rax,%r12,8), %rdi
decq %r12
movq (%rdi), ... | /p2pderivatives[P]cfd/external/googletest/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 0x32a183
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x88470
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x32a276
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x324b45
movq %rsp, %r14
movq (%r14), %rdi
movq %rbx, %rsi
... | /p2pderivatives[P]cfd/external/googletest/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 0x10664b(%rip), %rsi # 0x4308d6
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x334730
leaq 0x106640(%rip), %rsi # 0x4308e1
movq %rbx, %rdi
callq 0x885e0
leaq 0x10660f(%rip), %rsi # 0x4308bf
movq %rbx, %rdi
callq 0x885e0... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::EscapeXml(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string XmlUnitTestResultPrinter::EscapeXml(
const std::string& str, bool is_attribute) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '<':
m << "<";
break;
case '>':
m << ">";
break;
case '&'... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x324970
xorl %r12d, %r12d
leaq 0x105e17(%rip), %rbx # 0x430763
leaq 0x18(%rsp), %r13
cmpq 0x8(%r14), %r12
jae 0x32aab1
movq (%r14), %rax
movzbl (%rax,%r... | /p2pderivatives[P]cfd/external/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
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 0x88ad0
movq (%r14), %rax
movl $0x2600, %ebp # imm = 0x2600
movq %rax, %r15
movq 0x8(%r14), %rcx
addq %rax, %rcx
... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsIso8601[abi:cxx11](long 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
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon + 1) +... | pushq %r14
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %rax
movq %rdi, %rbx
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
leaq 0x1d0(%rsp), %rsi
movq %rax, %rdi
callq 0x32af9b
testb %al, %al
je 0x32ae68
movl $0x76c, %eax # imm = 0x76C
addl 0x1e4(%rsp), %eax
leaq 0xc(%rsp), %... | /p2pderivatives[P]cfd/external/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 != NULL) {
st... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1057ca(%rip), %rsi # 0x430792
callq 0x885e0
leaq 0x1057b1(%rip), %r15 # 0x430785
leaq 0x1057ae(%rip), %r12 # 0x430789
movq %r14, %rdi
movq %r15, %rsi
callq 0x88100
testq %rax, %rax
je 0x32b013
movq %rax, %r13
movq %ra... | /p2pderivatives[P]cfd/external/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 =
GetReservedAttributesForElement(element_name);
GTEST_CHECK_(std::find(allowed_names.be... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x32797e
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
callq 0x1ce487
cmpq 0x30(%rsp), %rax
jne 0x32b0ec
leaq 0x104e12(%rip), %rdx ... | /p2pderivatives[P]cfd/external/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_case_name,
const TestInfo& test_info) {
const TestResult& result = *test_info.result();
const std::string kTestcase = "testcase"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x105673(%rip), %rsi # 0x430830
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x334730
cmpb $0x0, 0x83(%r14)
jne 0x32b703
leaq 0x105647(%rip), %rsi # 0x43082b
movq %rbx, %rdi... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::FormatCompilerIndependentFileLocation[abi:cxx11](char const*, int) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
const char* file, int line) {
const std::string file_name(file == NULL ? kUnknownFile : file);
if (line < 0)
return file_name;
else
return file_name + ":" + StreamableToString(line);
} | pushq %rbp
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testq %rsi, %rsi
leaq 0x103910(%rip), %rax # 0x42f110
cmoveq %rax, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x334730
testl %ebp, %ebp
js 0x32b864
leaq 0xd3d44(%rip), %rdx # 0x3ff562
leaq 0x8(%rsp), %rdi
leaq ... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest-port.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 0x105042(%rip), %rsi # 0x43091c
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x334730
leaq 0x105037(%rip), %rsi # 0x430927
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x334730
m... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream*, testing::TestCase const&) | void XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream,
const TestCase& test_case) {
const std::string kTestsuite = "testsuite";
*stream << " <" << kTestsuite;
OutputXmlAttribute(stream, kTestsuite, "name", test_case.name());
OutputXmlAttribute(stre... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x104d9e(%rip), %rsi # 0x4308b3
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x334730
leaq 0x104d92(%rip), %rsi # 0x4308bd
movq %rbx, %rdi
callq 0x885e0
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x88560
leaq 0x... | /p2pderivatives[P]cfd/external/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 %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x32a183
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x88470
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x32c0f6
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x324b45
movq %rsp, %r14
movq (%r14), %rdi
movq %rbx, %rsi
... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestCase(std::ostream*, testing::TestCase const&) | void JsonUnitTestResultPrinter::PrintJsonTestCase(std::ostream* stream,
const TestCase& test_case) {
const std::string kTestsuite = "testsuite";
const std::string kIndent = Indent(6);
*stream << Indent(4) << "{\n";
OutputJsonKey(stream, kTestsuite, "name", test... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x103163(%rip), %rsi # 0x4308b3
leaq 0x78(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x334730
leaq 0x38(%rsp), %rdi
pushq $0x6
popq %rsi
callq 0x32d534
leaq 0x10(%rsp), %rdi
pushq $0x4
popq %rsi
callq... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestList(std::ostream*, std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&) | void JsonUnitTestResultPrinter::PrintJsonTestList(
std::ostream* stream, const std::vector<TestCase*>& test_cases) {
const std::string kTestsuites = "testsuites";
const std::string kIndent = Indent(2);
*stream << "{\n";
int total_tests = 0;
for (size_t i = 0; i < test_cases.size(); ++i) {
total_tests ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x102d7d(%rip), %rsi # 0x4308d6
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x334730
leaq 0x28(%rsp), %rdi
pushq $0x2
popq %rsi
callq 0x32d534
leaq 0x102e21(%rip), %rsi # 0x43099d
movq %rbx, %rdi
callq 0x885e0
... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*) | std::string StreamingListener::UrlEncode(const char* str) {
std::string result;
result.reserve(strlen(str) + 1);
for (char ch = *str; ch != '\0'; ch = *++str) {
switch (ch) {
case '%':
case '=':
case '&':
case '\n':
result.append("%" + String::FormatByte(static_cast<unsigned ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x88290
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x88ad0
movabsq $0x2000006000000400, %rbp # imm =... | /p2pderivatives[P]cfd/external/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
je 0x32dec4
leaq 0x102006(%rip), %rdx # 0x42fe8c
leaq 0x10(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x10a9, %ecx # imm = 0x10A9
callq 0x332de2
movq 0x22b141(%rip), %rdi # 0x558fe0
leaq 0x102b2b(%r... | /p2pderivatives[P]cfd/external/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x102685(%rip), %rsi # 0x4306ca
leaq 0xf(%rsp), %rdx
callq 0x334730
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::OsStackTraceGetter::UponLeavingGTest() | GTEST_LOCK_EXCLUDED_(mutex_) {
#if GTEST_HAS_ABSL
void* caller_frame = nullptr;
if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
caller_frame = nullptr;
}
MutexLock lock(&mutex_);
caller_frame_ = caller_frame;
#endif // GTEST_HAS_ABSL
} | retq
nop
| /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RecordProperty(testing::TestProperty const&) | void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
std::string xml_element;
TestResult* test_result; // TestResult appropriate for property recording.
if (current_test_info_ != NULL) {
xml_element = "testcase";
test_result = &(current_test_info_->result_);
} else if (current_test_c... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
cmpq $0x0, 0x110(%rdi)
je 0x32e221
leaq 0x102627(%rip), %rsi # 0x430830
leaq 0x8(%rsp), %rdi
callq 0x88d20
movl $0x90, %edi
addq 0x110(%r14), %rdi
jmp 0x32e264
c... | /p2pderivatives[P]cfd/external/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_par... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
leaq 0x229e36(%rip), %rax # 0x5585c8
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x33478a
leaq 0x30(%r15), %rax
leaq 0x229ba8(%rip), %rcx # 0x558358
movq %rcx, 0x30(%r15)
movq ... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::~UnitTestImpl() | UnitTestImpl::~UnitTestImpl() {
// Deletes every TestCase.
ForEach(test_cases_, internal::Delete<TestCase>);
// Deletes every Environment.
ForEach(environments_, internal::Delete<Environment>);
delete os_stack_trace_getter_;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x229c0d(%rip), %rax # 0x5585c8
movq %rax, (%rdi)
leaq 0xb8(%rdi), %r14
leaq 0xc8(%rip), %rsi # 0x32ea94
movq %r14, %rdi
callq 0x3365b7
leaq 0xa0(%rbx), %r15
leaq 0xbe(%rip), %rsi # 0x32eaa0
movq %r15, %rdi
callq 0x3365c9
movq 0x1a8(%rbx), %rdi
test... | /p2pderivatives[P]cfd/external/googletest/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 0x32366e
leaq 0x100543(%rip), %rsi # 0x42f03c
movq %r14, %rdi
callq 0xb98e9
testb %al, %al
je 0x32eb3d
pushq $0x28
popq %rdi
callq 0x88600
movq %rax, %r14
movq %rsp, %rdi
callq 0x3236be
movb $0x1, %bpl
movq ... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ConfigureStreamingOutput() | std::string Message::GetString() const {
return internal::StringStreamToString(ss_.get());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x252a54(%rip) # 0x5816b8
je 0x32ed55
movq %rdi, %r14
leaq 0x252a3c(%rip), %rdi # 0x5816b0
pushq $0x3a
popq %rsi
xorl %edx, %edx
callq 0x888c0
cmpq $-0x1, %rax
je 0x32ed01
movq %rax, %r15
pushq $0x10
popq %rdi
callq 0x88600
movq %rax, %rbx
le... | /p2pderivatives[P]cfd/external/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... | cmpb $0x0, 0x1b0(%rdi)
je 0x32edb6
retq
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x1b0(%rdi)
callq 0x336650
cmpq $0x0, 0x1d0(%rbx)
je 0x32eddb
movq 0x190(%rbx), %rax
movb $0x0, 0x8(%rax)
movq %rbx, %rdi
callq 0x3287f2
movq %rbx, %rdi
callq 0x32eada
movq %rbx, %rdi
popq %rbx
jmp 0x32ec52
| /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::GetTestCase(char const*, char const*, void (*)(), void (*)()) | TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
const char* type_param,
Test::SetUpTestCaseFunc set_up_tc,
Test::TearDownTestCaseFunc tear_down_tc) {
// Can we find a TestCase with the given nam... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0xc0(%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0xb8(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x334730
leaq 0x48(%r... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::WriteToShardStatusFileIfNeeded() | bool Test::HasNonfatalFailure() {
return internal::GetUnitTestImpl()->current_test_result()->
HasNonfatalFailure();
} | pushq %rbp
pushq %rbx
pushq %rax
leaq 0x100086(%rip), %rdi # 0x42f060
callq 0x887d0
testq %rax, %rax
je 0x32f009
movq %rax, %rbx
leaq 0x67aa1(%rip), %rsi # 0x396a8f
movq %rax, %rdi
callq 0x88780
testq %rax, %rax
je 0x32f010
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x885f0
addq $0x8, %rsp
popq %rbx... | /p2pderivatives[P]cfd/external/googletest/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 (size_t i = 0; i < test_cases_.size(); i++) {
const TestCase* const test_case = test_cases_[i];
bool printed_test_case_name = false;
for (size_t j ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x50(%rsp)
leaq 0xb8(%rdi), %rax
movq %rax, (%rsp)
leaq 0x101b38(%rip), %r15 # 0x430d5e
pushq $0xa
popq %rbp
leaq 0x101b24(%rip), %r12 # 0x430d54
xorl %edx, %edx
movq 0x50(%rsp), %rcx
movq 0xb8(... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ShuffleTests() | void UnitTestImpl::ShuffleTests() {
// Shuffles the death test cases.
ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);
// Shuffles the non-death test cases.
ShuffleRange(random(), last_death_test_case_ + 1,
static_cast<int>(test_cases_.size()), &test_case_indices_);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b8(%rdi), %r14
movl 0x104(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x336919
movl 0x104(%rbx), %esi
incl %esi
movq 0xc0(%rbx), %rdx
subq 0xb8(%rbx), %rdx
shrq $0x3, %r... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
int testing::internal::CountIf<std::vector<testing::TestCase*, std::allocator<testing::TestCase*>>, bool (*)(testing::TestCase const*)>(std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&, bool (*)(testing::TestCase const*)) | inline int CountIf(const Container& c, Predicate predicate) {
// Implemented as an explicit loop since std::count_if() in libCstd on
// Solaris has a non-standard signature.
int count = 0;
for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
if (predicate(*it))
++count;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
xorl %ebp, %ebp
cmpq 0x8(%r14), %r15
je 0x334817
movq (%r15), %rdi
callq *%rbx
movzbl %al, %eax
addl %eax, %ebp
addq $0x8, %r15
jmp 0x334801
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
re... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest-internal-inl.h |
testing::Message& testing::Message::operator<<<char [2]>(char const (&) [2]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x885e0
movq %rbx, %rax
popq %rbx
retq
nop
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-message.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [24]>(char const (&) [24]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x324970
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x885e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x138580
leaq 0x8(%rsp), %rdi
callq 0x9eb84
movq %rbx, %rax
addq $0x10, %rsp
p... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [17]>(char const (&) [17]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x324970
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x885e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x138580
leaq 0x8(%rsp), %rdi
callq 0x9eb84
movq %rbx, %rax
addq $0x10, %rsp
p... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [15]>(char const (&) [15]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x324970
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x885e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x138580
leaq 0x8(%rsp), %rdi
callq 0x9eb84
movq %rbx, %rax
addq $0x10, %rsp
p... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [7]>(char const (&) [7]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x324970
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x885e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x138580
leaq 0x8(%rsp), %rdi
callq 0x9eb84
movq %rbx, %rax
addq $0x10, %rsp
p... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [2]>(char const (&) [2]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x324970
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x885e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x138580
leaq 0x8(%rsp), %rdi
callq 0x9eb84
movq %rbx, %rax
addq $0x10, %rsp
p... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::FloatingPointLE<float>(char const*, char const*, float, float) | AssertionResult FloatingPointLE(const char* expr1,
const char* expr2,
RawType val1,
RawType val2) {
// Returns success if val1 is less than val2,
if (val1 < val2) {
return AssertionSuccess();
}
// or if val1 is ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x380, %rsp # imm = 0x380
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
ucomiss %xmm0, %xmm1
ja 0x334e32
leaq 0x1c(%rsp), %rdi
movss %xmm0, 0x4(%rsp)
movss %xmm0, (%rdi)
leaq 0x18(%rsp), %rsi
movss %xmm1, (%rsp)
movss %xmm1, (%rsi)
callq 0x339cb4
testb %al,... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [29]>(char const (&) [29]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x324970
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x885e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x138580
leaq 0x8(%rsp), %rdi
callq 0x9eb84
movq %rbx, %rax
addq $0x10, %rsp
p... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [64]>(char const (&) [64]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x885e0
movq %rbx, %rax
popq %rbx
retq
nop
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [6]>(char const (&) [6]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x885e0
movq %rbx, %rax
popq %rbx
retq
nop
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [30]>(char const (&) [30]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x885e0
movq %rbx, %rax
popq %rbx
retq
nop
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [31]>(char const (&) [31]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x885e0
movq %rbx, %rax
popq %rbx
retq
nop
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [18]>(char const (&) [18]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x885e0
movq %rbx, %rax
popq %rbx
retq
nop
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [63]>(char const (&) [63]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x885e0
movq %rbx, %rax
popq %rbx
retq
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-message.h |
void testing::internal::HandleExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. It is technically possible to check the... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x3347cd
addq %r15, %r14
cmpb $0x1, 0x1f0(%rax)
jne 0x3358a9
testb $0x1, %r12b
je 0x335897
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
callq *%r12
addq $0x28, %rsp
popq %rb... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::internal::ParameterizedTestCaseRegistry::RegisterTests() | void RegisterTests() {
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
it != test_case_infos_.end(); ++it) {
(*it)->RegisterTests();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x335af7
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x335ae2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/internal/gtest-param-util.h |
testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
: premature_exit_filepath_(premature_exit_filepath ?
premature_exit_filepath : "") {
// If a path to the premature-exit file is specified...
if (!premature_exit_filepath_.empty()) {
// create the f... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0xfa526(%rip), %rsi # 0x4306ca
cmovneq %rbx, %rsi
leaq 0x7(%rsp), %rdx
callq 0x334730
cmpq $0x0, 0x8(%r14)
je 0x3361de
leaq 0x608cf(%rip), %rsi # 0x396a8f
movq %rbx, %rdi
callq 0x88780
movq %rax, %rbx
pushq $0x30
popq %rdi
mo... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::Message::Message(testing::Message const&) | Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT
*ss_ << msg.GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x188, %edi # imm = 0x188
callq 0x88600
movq %rax, %r14
movq %rax, %rdi
callq 0x88470
movq %r14, (%rbx)
movq %rsp, %rdi
movq %r15, %rsi
callq 0x324b34
addq $0x10, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x88560
movq %r... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-message.h |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int*, char**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
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::ParseBoolFlag;
using internal::ParseInt32Flag;
using internal::ParseStringFlag;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r12
leaq 0x8(%rsp), %r15
cmpl (%r14), %r12d
jge 0x336bb7
movslq %r12d, %r13
leaq (%rbx,%r13,8), %rsi
movq %r15, %rdi
callq 0x33b7e1
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x3340fd
test... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest.cc |
testing::Message& testing::Message::operator<<<char [20]>(char const (&) [20]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x885e0
movq %rbx, %rax
popq %rbx
retq
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testi... | Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif
#if GTEST_HAS_DOWNCAST_
return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
return dynamic_cast<Derived*>(base); // NOLINT
#else
return static_cast<Derived*>(base); // Poor man's ... | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x33816f
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rdi
leaq 0x220a05(%rip), %rsi # 0x558b18
callq 0x1bbfea
testb %al, %al
jne 0x338152
leaq 0xf9359(%rip), %rdx # 0x43147c
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x5f7, %ecx # imm = 0x5F7... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&) | void OnTestPartResult(const TestPartResult& test_part_result) {
const char* file_name = test_part_result.file_name();
if (file_name == NULL)
file_name = "";
SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
"&line=" + StreamableToString(test_part_result.line_number()) +
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x3384b7
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0xf8209(%rip), %rsi # 0x4306ca
cmovneq %rax, %rsi
leaq 0xf0(%rsp), %r15
movq %r15, %rdi
callq 0x32dd74
leaq 0xf946... | /p2pderivatives[P]cfd/external/googletest/googletest/src/gtest-internal-inl.h |
testing::Message& testing::Message::operator<<<long long>(long long const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
movq (%rsi), %rsi
callq 0x88220
movq %rbx, %rax
popq %rbx
retq
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::GetOrCreateValue() const | T* GetOrCreateValue() const {
ThreadLocalValueHolderBase* const holder =
static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
if (holder != NULL) {
return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
}
ValueHolder* const new_holder = default_factory_->MakeN... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0x88a50
testq %rax, %rax
je 0x339442
movq %rax, %rdi
callq 0x3394d4
movq %rax, %rbx
jmp 0x3394af
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0x880f0
testl %eax, ... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::Message& testing::Message::operator<<<double>(double const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
movsd (%rsi), %xmm0
callq 0x88b30
movq %rbx, %rax
popq %rbx
retq
nop
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::FloatingPoint<float>::DistanceBetweenSignAndMagnitudeNumbers(unsigned int const&, unsigned int const&) | static Bits SignAndMagnitudeToBiased(const Bits &sam) {
if (kSignBitMask & sam) {
// sam represents a negative number.
return ~sam + 1;
} else {
// sam represents a positive number.
return kSignBitMask | sam;
}
} | movl (%rdi), %ecx
movl %ecx, %edx
negl %edx
movl $0x80000000, %edi # imm = 0x80000000
movl %ecx, %eax
orl %edi, %eax
testl %ecx, %ecx
cmovsl %edx, %eax
movl (%rsi), %ecx
movl %ecx, %edx
negl %edx
orl %ecx, %edi
testl %ecx, %ecx
cmovsl %edx, %edi
movl %eax, %ecx
subl %edi, %ecx
negl %ecx
subl %edi, %eax
cmovbl %ec... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::FloatingPoint<double>::AlmostEquals(testing::internal::FloatingPoint<double> const&) const | bool AlmostEquals(const FloatingPoint& rhs) const {
// The IEEE standard says that any comparison operation involving
// a NAN must return false.
if (is_nan() || rhs.is_nan()) return false;
return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
<= kMaxUlps;
} | movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq (%rdi), %rcx
movq %rcx, %rdx
notq %rdx
testq %rax, %rdx
sete %dl
shlq $0xc, %rcx
setne %cl
testb %cl, %dl
jne 0x339d73
movabsq $0xfffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFF
movq (%rsi), %rdx
movq %rdx, %r8
notq %r8
testq %r8, %rax
sete %al
testq %rcx, ... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::FloatingPoint<double>::DistanceBetweenSignAndMagnitudeNumbers(unsigned long long const&, unsigned long long const&) | static Bits SignAndMagnitudeToBiased(const Bits &sam) {
if (kSignBitMask & sam) {
// sam represents a negative number.
return ~sam + 1;
} else {
// sam represents a positive number.
return kSignBitMask | sam;
}
} | movq (%rdi), %rcx
movq %rcx, %rdx
negq %rdx
movq %rcx, %rax
btsq $0x3f, %rax
testq %rcx, %rcx
cmovsq %rdx, %rax
movq (%rsi), %rcx
movq %rcx, %rdx
negq %rdx
movq %rcx, %rsi
btsq $0x3f, %rsi
testq %rcx, %rcx
cmovsq %rdx, %rsi
movq %rax, %rcx
subq %rsi, %rcx
negq %rcx
subq %rsi, %rax
cmovbq %rcx, %rax
retq
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/internal/gtest-internal.h |
void testing_internal::DefaultPrintNonContainerTo<long long>(long long const&, std::ostream*) | void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
// With the following statement, during unqualified name lookup,
// testing::internal2::operator<< appears as if it was declared in
// the nearest enclosing namespace that contains both
// ::testing_internal and ::testing::internal2, i.e. the... | movq %rsi, %rax
movq (%rdi), %rsi
movq %rax, %rdi
jmp 0x88220
| /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest-printers.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [16]>(char const (&) [16]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x324970
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x885e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x138580
leaq 0x8(%rsp), %rdi
callq 0x9eb84
movq %rbx, %rax
addq $0x10, %rsp
p... | /p2pderivatives[P]cfd/external/googletest/googletest/include/gtest/gtest.h |
Catch::Totals::delta(Catch::Totals const&) const | Totals Totals::delta( Totals const& prevTotals ) const {
Totals diff = *this - prevTotals;
if( diff.assertions.failed > 0 )
++diff.testCases.failed;
else if( diff.assertions.failedButOk > 0 )
++diff.testCases.failedButOk;
else
++diff.testCases.passed;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x30da0
movq -0x18(%rbp), %rdi
cmpq $0x0, 0x10(%rdi)
jbe 0x26ad5
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::RunContext::assertionEnded(Catch::AssertionResult const&) | void RunContext::assertionEnded(AssertionResult const & result) {
if (result.getResultType() == ResultWas::Ok) {
m_totals.assertions.passed++;
m_lastAssertionPassed = true;
} else if (!result.isOk()) {
m_lastAssertionPassed = false;
if( m_activeTestCase->g... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x10(%rbp), %rdi
callq 0x174d0
cmpl $0x0, %eax
jne 0x26c2e
movq -0x110(%rbp), %rax
movq 0xf8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf8(%rax)
movb $0x1,... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::operator<<(std::ostream&, Catch::Version const&) | std::ostream& operator << ( std::ostream& os, Version const& version ) {
os << version.majorVersion << '.'
<< version.minorVersion << '.'
<< version.patchNumber;
// branchName is never null -> 0th char is \0 if it is empty
if (version.branchName[0]) {
os << '... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x156c0
movq %rax, %rdi
movl $0x2e, %esi
callq 0x15610
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x156c0
movq %rax, %rdi
movl $0x2e, %esi
... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::Session::applyCommandLine(int, char const* const*) | int Session::applyCommandLine( int argc, char const * const * argv ) {
if( m_startupExceptions )
return 1;
auto result = m_cli.parse( clara::Args( argc, argv ) );
if( !result ) {
config();
getCurrentMutableContext().setConfig(m_config);
Catch::cer... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
testb $0x1, 0x188(%rax)
je 0x292b6
movl $0x1, -0x4(%rbp)
jmp 0x295f2
movq -0x140(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x150(%rbp)
m... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::Session::run() | int Session::run() {
if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
static_cast<void>(std::getchar());
}
int exitCode = runInternal();
if( ( m_configData.wa... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xc0(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2969a
callq 0x1dee0
movq %rax, %rdi
leaq 0xb5155(%rip), %rsi # 0xde7d6
callq 0x15510
movq %rax, %rdi
movq 0x1248b8(%rip), %rsi # 0x14df48
callq... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::Session::runInternal() | int Session::runInternal() {
if( m_startupExceptions )
return 1;
if (m_configData.showHelp || m_configData.libIdentify) {
return 0;
}
CATCH_TRY {
config(); // Force config to be constructed
seedRng( *m_config );
if( m_config... | pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2d0(%rbp)
testb $0x1, 0x188(%rax)
je 0x2972f
movl $0x1, -0x4(%rbp)
jmp 0x299ec
movq -0x2d0(%rbp), %rax
testb $0x1, 0x6f(%rax)
jne 0x29749
movq -0x2d0(%rbp), %rax
testb $0x1, 0x72(%rax)
je 0x... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.