name string | code string | asm string | file string |
|---|---|---|---|
OpenMD::DataStorage::reserve(unsigned long) | void DataStorage::reserve(std::size_t size) {
if (storageLayout_ & dslPosition) { position.reserve(size); }
if (storageLayout_ & dslVelocity) { velocity.reserve(size); }
if (storageLayout_ & dslForce) { force.reserve(size); }
if (storageLayout_ & dslAmat) { aMat.reserve(size); }
if (storageLayou... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x1b8(%rdi), %eax
testb $0x1, %al
je 0xbfa06
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc02c6
movl 0x1b8(%r14), %eax
testb $0x2, %al
je 0xbfa1d
leaq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0xc02c6
movl 0x1b8(%r14), %eax
testb $0x4, %al
je 0xbfa34
leaq 0x... | /OpenMD[P]OpenMD/src/brains/DataStorage.cpp |
OpenMD::SectionParser::isEndSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool SectionParser::isEndSection(const std::string& line) {
StringTokenizer tokenizer(line);
if (tokenizer.countTokens() >= 2) {
std::string keyword = tokenizer.nextToken();
if (keyword != "end") { return false; }
std::string section = tokenizer.nextToken();
if (section == sectionName... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x332e(%rip), %rsi # 0xc5085
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x1a8b4
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq 0xb9030
movq %rsp, %rdi
callq 0x13a98
leaq 0x40(%rsp), %rdi
callq 0xb912e
cmpl $0x2, %eax
jl 0xc1d... | /OpenMD[P]OpenMD/src/io/SectionParser.cpp |
OpenMD::SectionParser::stripComments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string SectionParser::stripComments(const std::string& line) {
unsigned int n = line.length();
std::string res;
// Flags to indicate that single line and multpile line comments
// have started or not.
bool s_cmt = false;
bool m_cmt = false;
// Traverse the line
for (unsigned int i... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdx), %ebp
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %esi, %esi
xorl %r15d, %r15d
xorl %ecx, %ecx
cmpl %ebp, %r15d
jae 0xc1f16
movl %r15d, %eax
testb $0x1, %cl
je 0xc1e9c
movq (... | /OpenMD[P]OpenMD/src/io/SectionParser.cpp |
OpenMD::CubicSpline::getValueAt(double const&, double&) | void CubicSpline::getValueAt(const RealType& t, RealType& v) {
// Evaluate the spline at t using coefficients
//
// Input parameters
// t = point where spline is to be evaluated.
// Output:
// value of spline at t.
if (!generated) generate();
// Find the interval ( x[j], x[j+1] ) ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x0, 0x9(%rdi)
jne 0xc274c
movq %r14, %rdi
callq 0xc2026
cmpb $0x1, 0x8(%r14)
jne 0xc2777
movsd (%r15), %xmm0
movq 0x28(%r14), %rax
movapd %xmm0, %xmm1
subsd (%rax), %xmm1
mulsd 0x10(%r14), %xmm1
cvttsd2si %xmm1, %esi
movl 0x20(%r14)... | /OpenMD[P]OpenMD/src/math/CubicSpline.cpp |
OpenMD::ImproperCosineInversionType::ImproperCosineInversionType(std::vector<OpenMD::ImproperCosineInversionParameter, std::allocator<OpenMD::ImproperCosineInversionParameter>>&) | ImproperCosineInversionType::ImproperCosineInversionType(
std::vector<ImproperCosineInversionParameter>& parameters) {
std::vector<ImproperCosineInversionParameter>::iterator i;
i = std::max_element(parameters.begin(), parameters.end(),
LessThanPeriodicityFunctor());
if (i != ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
andl $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x5a950(%rip), %rax # 0x11dc40
movq %r... | /OpenMD[P]OpenMD/src/types/ImproperCosineInversionType.cpp |
OpenMD::ChebyshevT::GeneratePolynomials(int) | void ChebyshevT::GeneratePolynomials(int maxPower) {
GenerateFirstTwoTerms();
DoublePolynomial twoX;
twoX.setCoefficient(1, 2.0);
// recursive generate the high order term of Chebyshev Polynomials
// Cn+1(x) = Cn(x) * 2x - Cn-1(x)
for (int i = 2; i <= maxPower; ++i) {
DoublePolynomial cn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0xc37b8
leaq 0x40(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
le... | /OpenMD[P]OpenMD/src/math/ChebyshevT.cpp |
OpenMD::ChebyshevU::GeneratePolynomials(int) | void ChebyshevU::GeneratePolynomials(int maxPower) {
GenerateFirstTwoTerms();
DoublePolynomial twoX;
twoX.setCoefficient(1, 2.0);
// recursive generate the high order term of Chebyshev Polynomials
// Cn+1(x) = Cn(x) * 2x - Cn-1(x)
for (int i = 2; i <= maxPower; ++i) {
DoublePolynomial cn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0xc3d80
leaq 0x40(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
le... | /OpenMD[P]OpenMD/src/math/ChebyshevU.cpp |
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, %r15
movq %rdi, 0x28(%rsp)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x25e24
cmpq $0x0, 0x8(%r15)
movq (%rbx), %rbx
je 0x2e3a3
leaq 0x10(%rbx), %r12
xorl %r13d, %r13d
movq (%r15), %rax
movb (%rax,%r13), %al
m... | /langelog[P]CppEnv_vscode/thirdparty/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x44e86
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2e488
movq (%r14), %rcx
movl $0x2600, %ebp # imm = 0x2600
movq... | /langelog[P]CppEnv_vscode/thirdparty/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rsi, %r14
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %rsi, %rax
imulq %rcx
movq %rdx, %r15
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %r15
addq %rax, %r15
leaq 0xe8(... | /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest.cc |
testing::UnitTest::GetTestCase(int) const | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
: v[static_cast<size_t>(i)];
} | testl %esi, %esi
js 0x364cf
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x364cf
movl %esi, %edx
cmpl $0x0, (%rcx,%rdx,4)
js 0x364cf
movq 0xb8(%rax), %rax
movq (%rax,%rdx,8), %rax
retq
xorl %eax, %eax
retq
| /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::ParseInt32Flag(char const*, char const*, int*) | bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag, false);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Sets *value to the value of the flag.
return Parse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x3873d
testq %rax, %rax
je 0x38713
movq %rax, %r15
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x25e24
movq (%rbx), %rbx
leaq 0x10(%rbx), %r13
leaq 0x192e2(%rip), %rsi # 0x51... | /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest.cc |
testing::TempDir[abi:cxx11]() | std::string TempDir() {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#elif GTEST_OS_WINDOWS_MOBILE
return "\\temp\\";
#elif GTEST_OS_WINDOWS
const char* temp_dir = internal::posix::GetEnv("TEMP");
if (temp_dir == nullptr || temp_dir[0] == '\0') {
return "\\temp\\";
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1906b(%rip), %rdi # 0x519bc
callq 0x205d0
testq %rax, %rax
je 0x38980
movq %rax, %r14
cmpb $0x0, (%rax)
je 0x38980
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x201a0
movq %r14, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x38998... | /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest.cc |
testing::internal::DeathTestImpl::ReadAndInterpretStatusByte() | void DeathTestImpl::ReadAndInterpretStatusByte() {
char flag;
int bytes_read;
// The read() here blocks until data is available (signifying the
// failure of the death test) or until the pipe is closed (signifying
// its success), so it's okay to call this in the parent before
// the child process has exit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %rbx
leaq 0x7(%rsp), %r14
movl 0x34(%rbx), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x20710
cmpl $-0x1, %eax
jne 0x38cd8
callq 0x20060
cmpl $0x4, (%rax)
je 0x38cb7
jmp 0x38d15
testl %eax, %eax
je 0x... | /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest-death-test.cc |
testing::internal::StreamingListener::Start() | void Start() { SendLn("gtest_streaming_protocol_version=1.0"); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9380(%rip), %rsi # 0x525a6
leaq 0x939d(%rip), %rdx # 0x525ca
movq %rsp, %r14
movq %r14, %rdi
callq 0x4b2a0
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x4aa24
movq (%rsp), %rdi
cmpq %r15, %rdi
... | /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestStart(testing::TestInfo const&) | void OnTestStart(const TestInfo& test_info) override {
SendLn(std::string("event=TestStart&name=") + test_info.name());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x9098(%rip), %rsi # 0x52620
leaq 0x90a6(%rip), %rdx # 0x52635
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x4b2a0
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x4830e
... | /langelog[P]CppEnv_vscode/thirdparty/googletest/googletest/src/gtest-internal-inl.h |
socket | int socket(int domain, int type, int protocol)
{
HOOK_SYS_FUNC( socket );
if( !co_is_enable_sys_hook() )
{
return g_sys_socket_func( domain,type,protocol );
}
int fd = g_sys_socket_func(domain,type,protocol);
if( fd < 0 )
{
return fd;
}
rpchook_t *lp = alloc_by_fd( fd );
lp->domain = domain;
fcntl( f... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
cmpq $0x0, 0x6a0e(%rip) # 0xb330
jne 0x493a
leaq 0x36fd(%rip), %rsi # 0x8028
pushq $-0x1
popq %rdi
callq 0x42c0
movq %rax, 0x69f6(%rip) # 0xb330
callq 0x4490
movq 0x69ea(%rip), %rcx # 0xb330
testb %al, %al
je 0x4982
mo... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
co_accept(int, sockaddr*, unsigned int*) | int co_accept( int fd, struct sockaddr *addr, socklen_t *len )
{
HOOK_SYS_FUNC( fcntl );
int cli = accept( fd,addr,len );
if( cli < 0 )
{
return cli;
}
rpchook_t *lp = alloc_by_fd( cli );
int current_flags = g_sys_fcntl_func( cli ,F_GETFL, 0 );
int flag = current_flags;
flag |= O_NONBLOCK;
int ret = g_s... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
cmpq $0x0, 0x66af(%rip) # 0xb388
jne 0x4cf1
leaq 0x338b(%rip), %rsi # 0x806d
pushq $-0x1
popq %rdi
callq 0x42c0
movq %rax, 0x6697(%rip) # 0xb388
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x40c0
movl %eax, %ebx
te... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
close | int close(int fd)
{
HOOK_SYS_FUNC( close );
if( !co_is_enable_sys_hook() )
{
return g_sys_close_func( fd );
}
free_by_fd( fd );
int ret = g_sys_close_func(fd);
return ret;
} | pushq %rbx
movl %edi, %ebx
cmpq $0x0, 0x62b0(%rip) # 0xb340
jne 0x50a8
leaq 0x2f9e(%rip), %rsi # 0x8037
pushq $-0x1
popq %rdi
callq 0x42c0
movq %rax, 0x6298(%rip) # 0xb340
callq 0x4490
xorb $0x1, %al
cmpl $0xf4240, %ebx # imm = 0xF4240
setae %cl
orb %al, %cl
jne 0x50d8
movl %ebx, %eax
leaq 0x631... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
gethostbyname | struct hostent *gethostbyname(const char *name)
{
HOOK_SYS_FUNC( gethostbyname );
#if defined( __APPLE__ ) || defined( __FreeBSD__ )
return g_sys_gethostbyname_func( name );
#else
if (!co_is_enable_sys_hook())
{
return g_sys_gethostbyname_func(name);
}
return co_gethostbyname(name);
#endif
} | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x56f6(%rip) # 0xb3b0
jne 0x5cd2
leaq 0x23cc(%rip), %rsi # 0x808f
pushq $-0x1
popq %rdi
callq 0x42c0
movq %rax, 0x56de(%rip) # 0xb3b0
callq 0x4490
movq %rbx, %rdi
testb %al, %al
je 0x5ce4
popq %rbx
jmp 0x44c0
popq %rbx
jmpq *0x56c5(%rip) # 0xb3b0
| /abhinavabcd[P]libco/co_hook_sys_call.cpp |
co_gethostbyname(char const*) | struct hostent *co_gethostbyname(const char *name)
{
if (!name)
{
return NULL;
}
if (__co_hostbuf_wrap->buffer && __co_hostbuf_wrap->iBufferSize > 1024)
{
free(__co_hostbuf_wrap->buffer);
__co_hostbuf_wrap->buffer = NULL;
}
if (!__co_hostbuf_wrap->buffer)
{
__co_hostbuf_wrap->buffer = (char*)malloc(102... | testq %rdi, %rdi
je 0x5e5e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x56c8(%rip), %rdi # 0xb3d1
callq 0x40a0
cmpq $0x0, 0x20(%rax)
je 0x5d50
leaq 0x56b5(%rip), %rdi # 0xb3d1
callq 0x40a0
cmpq $0x401, 0x28(%rax) # imm = 0x401
jb 0x5d50
leaq 0x569f(%... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
clsRoutineData_routine_hostbuf_wrap<hostbuf_wrap>::operator->() | struct hostent *co_gethostbyname(const char *name)
{
if (!name)
{
return NULL;
}
if (__co_hostbuf_wrap->buffer && __co_hostbuf_wrap->iBufferSize > 1024)
{
free(__co_hostbuf_wrap->buffer);
__co_hostbuf_wrap->buffer = NULL;
}
if (!__co_hostbuf_wrap->buffer)
{
__co_hostbuf_wrap->buffer = (char*)malloc(102... | pushq %rbx
cmpb $0x0, 0x7a6648(%rip) # 0x7ac5ec
jne 0x5fc0
leaq 0x7a6643(%rip), %rdi # 0x7ac5f0
leaq -0xee(%rip), %rsi # 0x5ec6
callq 0x42b0
movb $0x1, 0x7a662c(%rip) # 0x7ac5ec
movl 0x7a662e(%rip), %edi # 0x7ac5f4
callq 0x43d0
movq %rax, %rbx
testq %rax, %rax
jne 0x6002
pushq $0x1
popq %rdi
pushq $0x... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
AllocTimeout(int) | stTimeout_t *AllocTimeout( int iSize )
{
stTimeout_t *lp = (stTimeout_t*)calloc( 1,sizeof(stTimeout_t) );
lp->iItemSize = iSize;
lp->pItems = (stTimeoutItemLink_t*)calloc( 1,sizeof(stTimeoutItemLink_t) * lp->iItemSize );
lp->ullStart = GetTickMS();
lp->llStartIdx = 0;
return lp;
} | pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
pushq $0x1
popq %r14
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x41f0
movq %rax, %r15
movl %ebx, 0x8(%rax)
movslq %ebx, %rsi
shlq $0x4, %rsi
movq %r14, %rdi
callq 0x41f0
movq %rax, (%r15)
callq 0x63e6
movq %rax, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
... | /abhinavabcd[P]libco/co_routine.cpp |
co_create_env(stCoRoutineEnv_t*, stCoRoutineAttr_t const*, void* (*)(void*), void*) | struct stCoRoutine_t *co_create_env( stCoRoutineEnv_t * env, const stCoRoutineAttr_t* attr,
pfn_co_routine_t pfn,void *arg )
{
stCoRoutineAttr_t at;
if( attr )
{
memcpy( &at,attr,sizeof(at) );
}
if( at.stack_size <= 0 )
{
at.stack_size = 128 * 1024;
}
else if( at.stack_size > 1024 * 1024 * 8 )
{
at.st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movl $0x20000, %ebx # imm = 0x20000
testq %rsi, %rsi
je 0x64d9
movl (%rsi), %eax
movq 0x4(%rsi), %rbp
testl %eax, %eax
jle 0x64db
movl $0x800000, %ebx # imm = 0x800000
cmpl $0x80... | /abhinavabcd[P]libco/co_routine.cpp |
co_free(stCoRoutine_t*) | void co_free( stCoRoutine_t *co )
{
if (!co->cIsShareStack)
{
free(co->stack_mem->stack_buffer);
free(co->stack_mem);
}
//walkerdu fix at 2018-01-20
//存在内存泄漏
else
{
if(co->save_buffer)
free(co->save_buffer);
if(co->stack_mem->occupy_co ==... | pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x9c(%rdi)
je 0x6686
movq 0xc0(%rbx), %rdi
callq 0x4390
movq 0xa8(%rbx), %rax
cmpq %rbx, (%rax)
jne 0x66a2
andq $0x0, (%rax)
jmp 0x66a2
movq 0xa8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x4390
movq 0xa8(%rbx), %rdi
callq 0x4390
movq %rbx, %rdi
popq %rbx
jmp 0x4390
| /abhinavabcd[P]libco/co_routine.cpp |
co_cond_timedwait(stCoCond_t*, int) | int co_cond_timedwait( stCoCond_t *link,int ms )
{
stCoCondItem_t* psi = (stCoCondItem_t*)calloc(1, sizeof(stCoCondItem_t));
psi->timeout.pArg = GetCurrThreadCo();
psi->timeout.pfnProcess = OnSignalProcessEvent;
if( ms > 0 )
{
unsigned long long now = GetTickMS();
psi->timeout.ullExpireTime = now + ms;
int... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x58
popq %rsi
callq 0x41f0
movq %rax, %rbx
callq 0x44e0
movq %rax, 0x48(%rbx)
leaq 0x7c(%rip), %rax # 0x707f
movq %rax, 0x40(%rbx)
testl %ebp, %ebp
jle 0x7052
movq %rbx, %r15
addq $0x18, %r15
callq... | /abhinavabcd[P]libco/co_routine.cpp |
void nlohmann::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double) | JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
"internal error: not enough precision");
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// If ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x1c595
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1c5b4
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rd... | /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::dtoa_impl::format_buffer(char*, int, int, int, int) | inline char* format_buffer(char* buf, int len, int decimal_exponent,
int min_exp, int max_exp)
{
JSON_ASSERT(min_exp < 0);
JSON_ASSERT(max_exp > 0);
const int k = len;
const int n = len + decimal_exponent;
// v = buf * 10^(n-k)
// k is the length of the buffer (numbe... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %ecx, %ecx
jns 0x1c713
testl %r8d, %r8d
jle 0x1c732
movq %rdi, %rbx
leal (%rdx,%rsi), %r14d
testl %edx, %edx
sets %al
cmpl %r8d, %r14d
setg %dil
orb %al, %dil
je 0x1c662
cmpl %r8d, %r14d
setg %al
testl %r14d, %r14d
setle %dil
orb %al, %dil
je 0x1c68b
testl %r... | /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::dtoa_impl::boundaries nlohmann::detail::dtoa_impl::compute_boundaries<double>(double) | boundaries compute_boundaries(FloatType value)
{
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// Convert the IEEE representation into a diyfp.
//
// If v is denormal:
// value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
// If v is normalized:
// v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jge 0x1c87b
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1c89a
movq %rdi, %rbx
movabsq $0x10000000000000, %rc... | /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::dtoa_impl::grisu2(char*, int&, int&, nlohmann::detail::dtoa_impl::diyfp, nlohmann::detail::dtoa_impl::diyfp, nlohmann::detail::dtoa_impl::diyfp) | inline void grisu2(char* buf, int& len, int& decimal_exponent,
diyfp m_minus, diyfp v, diyfp m_plus)
{
JSON_ASSERT(m_plus.e == m_minus.e);
JSON_ASSERT(m_plus.e == v.e);
// --------(-----------------------+-----------------------)-------- (A)
// m- v ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x58(%rsp)
movl %r8d, 0x60(%rsp)
cmpl %r8d, 0xc8(%rsp)
jne 0x1c9aa
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0xb0(%rsp), %r13
cmpl %r8d, 0x8(%r13)
jne 0x1c9c9
movl %r8d, %edi
callq 0x1ca7c
movq %rd... | /coin-au-carre[P]slacking/include/slacking/json.hpp |
slack::_detail::Slacking::setParameters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void setParameters(const std::string& method, const std::string& data = "") {
auto complete_url = base_url+ method;
session_.SetUrl(complete_url);
session_.SetBody(data);
#if SLACKING_VERBOSE_OUTPUT
std::cout << ">> sending: "<< complete_url << " " << data << '\n';
#endif
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d58e
leaq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x184a0
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d5c6
movq 0x15e22(%rip), %rdi # 0x32fc0
leaq 0... | /coin-au-carre[P]slacking/include/slacking/slacking.hpp |
nlohmann::detail::parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::iterator_input_a... | void parse(const bool strict, BasicJsonType& result)
{
if (callback)
{
json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
sax_parse_internal(&sdp);
result.assert_invariant();
// in strict mode, input must be completel... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
cmpq $0x0, 0x10(%rdi)
je 0x1dbed
leaq 0xc8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1da3e
movzbl 0xc0(%r15), %ecx
leaq 0x108(%rsp), %rdi
movq %rbx, %rsi
movq %r14,... | /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::iterator_input_ad... | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false)
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movb %dl, 0x10(%rdi)
orl $-0x1, 0x14(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
movb %al, 0... | /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::iterator_input_ad... | token_type scan_string()
{
// reset token_buffer (ignore opening quote)
reset();
// we entered the function by reading an open quote
JSON_ASSERT(current == '\"');
while (true)
{
// get next character
switch (get())
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x1ebb4
cmpl $0x22, 0x14(%rbx)
jne 0x1e634
leaq 0x50(%rbx), %r14
leaq 0x6f07(%rip), %r12 # 0x25144
pushq $0xe
popq %rbp
movq %rbx, %rdi
callq 0x1e9a4
incl %eax
cmpl $0xf5, %eax
ja 0x1e606
movslq (%r12,%rax,4), ... | /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::iterator_input_ad... | void unget()
{
next_unget = true;
--position.chars_read_total;
// in case we "unget" a newline, we have to also decrement the lines_read
if (position.chars_read_current_line == 0)
{
if (position.lines_read > 0)
{
--position.lines_read... | movb $0x1, 0x18(%rdi)
decq 0x20(%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1ea31
leaq 0x28(%rdi), %rcx
jmp 0x1ea3e
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x1ea44
leaq 0x30(%rdi), %rcx
decq %rax
movq %rax, (%rcx)
cmpl $-0x1, 0x14(%rdi)
je 0x1ea5b
movq 0x40(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x1ea5c
decq %rax... | /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>> nlohmann::basic_json<std::map, ... | IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
}
IteratorType result = end();
switch ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpq %rsi, (%rdx)
jne 0x21b58
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2194e
movzbl (%r14), %eax
leal -0x3(%rax), %ecx
cmpl $0x6, %ecx
jae 0x21af1
cmpq $0x0, 0x18(%r15)
jne 0x21bab
cmpl $0x8, %eax
je 0x21b12
cmpl $0x3, %eax
jne 0x21b2b
leaq 0x8... | /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::operator++() | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
... | pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x21ce3
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x21cd3
cmpl $0x1, %eax
jne 0x21cda
leaq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x22089
jmp 0x21cde
addq $0x10, 0x10(%rbx)
jmp 0x21cde
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x6ec0(%rip), %rd... | /coin-au-carre[P]slacking/include/slacking/json.hpp |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::set_end() | void set_end() noexcept
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
m_it.object_iterator = m_object->m_value.object->end();
break;
}
case value_t::array:
... | movq (%rdi), %rax
testq %rax, %rax
je 0x21f5c
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x21f46
cmpl $0x1, %ecx
jne 0x21f53
movq 0x8(%rax), %rax
addq $0x8, %rax
movq %rax, 0x8(%rdi)
retq
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rdi)
retq
movq $0x1, 0x18(%rdi)
retq
pushq %rax
leaq 0x6c46(%rip), %rdi ... | /coin-au-carre[P]slacking/include/slacking/json.hpp |
CommandReader::args() const | std::unique_ptr<char *[]> args() const {
// same
if (!this->enclosed) {
auto empty = std::unique_ptr<char *[]>();
return empty;
}
auto args = std::make_unique<char *[]>(this->arguments.size() + 1);
for (size_t i = 0; i < this->arguments.size(); i++) {
args[i] = (char *)this->argu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x2(%rsi)
je 0x4f42
movq %rsi, %r15
movq 0x30(%rsi), %rax
subq 0x28(%rsi), %rax
sarq $0x5, %rax
leaq 0x1(%rax), %rcx
shrq $0x3d, %rcx
leaq 0x8(,%rax,8), %rax
xorl %r12d, %r12d
negq %rcx
sbbq %r12, %r12
orq %rax, %r12
movq %r12, %rdi
callq... | /tongyuantongyu[P]BasicSH/main.cpp |
mzd_addmul_v_uint64_30_128 | void mzd_addmul_v_uint64_30_128(mzd_local_t* c, mzd_local_t const* v, mzd_local_t const* A) {
block_t* cblock = BLOCK(c, 0);
const block_t* Ablock = CONST_BLOCK(A, 0);
word idx = CONST_BLOCK(v, 0)->w64[1] >> 34;
for (unsigned int i = 15; i; --i, idx >>= 2, ++Ablock) {
const word mask1 = -(idx & 1);
... | pushq %rbx
movq 0x8(%rsi), %rax
movl $0xf, %ecx
shrq $0x22, %rax
movl %eax, %r9d
movq %rax, %r8
shlq $0x3e, %r8
andl $0x1, %r9d
movb $0x1, %sil
xorl %r10d, %r10d
sarq $0x3f, %r8
negq %r9
movq (%rdx,%r10,8), %r11
movq 0x10(%rdx,%r10,8), %rbx
andq %r9, %r11
andq %r8, %rbx
xorq %r11, %rbx
xorq %rbx, (%rdi,%r10,8)
movl $0x... | /IAIK[P]Picnic/mzd_additional.c |
mzd_addmul_v_uint64_30_256 | void mzd_addmul_v_uint64_30_256(mzd_local_t* c, mzd_local_t const* v, mzd_local_t const* A) {
block_t* cblock = BLOCK(c, 0);
const block_t* Ablock = CONST_BLOCK(A, 0);
word idx = CONST_BLOCK(v, 0)->w64[3] >> 34;
for (unsigned int i = 30; i; --i, idx >>= 1, ++Ablock) {
const word mask = -(idx & 1);
... | movq 0x18(%rsi), %rax
movl $0x1e, %ecx
shrq $0x22, %rax
movl %eax, %esi
andl $0x1, %esi
xorl %r8d, %r8d
negq %rsi
movq (%rdx,%r8,8), %r9
andq %rsi, %r9
xorq %r9, (%rdi,%r8,8)
incq %r8
cmpq $0x4, %r8
jne 0x51fb
shrq %rax
addq $0x20, %rdx
decl %ecx
jne 0x51f0
retq
| /IAIK[P]Picnic/mzd_additional.c |
mzd_addmul_v_s256_30_192 | ATTR_TARGET_AVX2
void mzd_addmul_v_s256_30_192(mzd_local_t* c, mzd_local_t const* v, mzd_local_t const* A) {
mzd_addmul_v_s256_30_256_idx(c, A, CONST_BLOCK(v, 0)->w64[2] >> 34);
} | movq 0x10(%rsi), %rax
vmovdqa (%rdx), %ymm1
btq $0x22, %rax
movq %rax, %rsi
sbbq %rcx, %rcx
shlq $0x1c, %rsi
shrq $0x24, %rax
sarq $0x3f, %rsi
vpbroadcastq %rcx, %ymm0
movl $0x40, %ecx
vpternlogq $0x6a, (%rdi), %ymm1, %ymm0
vpbroadcastq %rsi, %ymm1
vpand 0x20(%rdx), %ymm1, %ymm1
movq %rax, %r8
shlq $0x3e, %r8
movl %eax... | /IAIK[P]Picnic/mzd_additional.c |
mzd_addmul_v_s256_30_256 | ATTR_TARGET_AVX2
void mzd_addmul_v_s256_30_256(mzd_local_t* c, mzd_local_t const* v, mzd_local_t const* A) {
mzd_addmul_v_s256_30_256_idx(c, A, CONST_BLOCK(v, 0)->w64[3] >> 34);
} | movq 0x18(%rsi), %rax
vmovdqa (%rdx), %ymm1
btq $0x22, %rax
movq %rax, %rsi
sbbq %rcx, %rcx
shlq $0x1c, %rsi
shrq $0x24, %rax
sarq $0x3f, %rsi
vpbroadcastq %rcx, %ymm0
movl $0x40, %ecx
vpternlogq $0x6a, (%rdi), %ymm1, %ymm0
vpbroadcastq %rsi, %ymm1
vpand 0x20(%rdx), %ymm1, %ymm1
movq %rax, %r8
shlq $0x3e, %r8
movl %eax... | /IAIK[P]Picnic/mzd_additional.c |
mzd_mul_v_parity_s256_256_30 | ATTR_TARGET_AVX2
void mzd_mul_v_parity_s256_256_30(mzd_local_t* c, mzd_local_t const* v, mzd_local_t const* At) {
const word256 vblock = mm256_load(v->w64);
word256 res = mm256_zero;
// process 3 rows at a time
for (unsigned int i = 30; i; i -= 3) {
const word256 Ablock1 = mm256_and(vblock, mm256_l... | vmovdqa (%rsi), %ymm1
vpbroadcastb 0xe6b(%rip), %ymm2 # 0x6612
vbroadcasti128 0xf20(%rip), %ymm3 # ymm3 = mem[0,1,0,1]
vpbroadcastq 0xe67(%rip), %ymm4 # 0x6620
vpbroadcastq 0xe66(%rip), %ymm5 # 0x6628
vpbroadcastq 0xe9d(%rip), %ymm6 # 0x6668
addq $0x40, %rdx
vpxor %xmm0, %xmm0, %xmm0
movl $0x22, %eax
vpand -0x40(%rdx),... | /IAIK[P]Picnic/mzd_additional.c |
JlGetObjectNumberF64 | JL_STATUS
JlGetObjectNumberF64
(
JlDataObject const* NumberObject,
double* pNumberF64
)
{
JL_STATUS jlStatus;
if( NULL != NumberObject
&& NULL != pNumberF64 )
{
if( JL_DATA_TYPE_NUMBER == NumberObject->Type
&& JL_NUM_TYPE_FLOAT =... | testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0x1ef4
movl $0xfffffffc, %eax # imm = 0xFFFFFFFC
xorpd %xmm0, %xmm0
cmpl $0x2, (%rdi)
jne 0x1ef0
movl 0x10(%rdi), %ecx
cmpl $0xa, %ecx
je 0x1ece
cmpl $0xb, %ecx
je 0x1ec3
cmpl $0xc, %ecx
jne 0x1ef0... | /WaterJuice[P]JsonLib/lib/JsonLib/Source/JlDataModel.c |
select_wrapper | int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset... | testl %edi, %edi
jns 0x10b0
pushq %rax
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
| /macressler[P]curl/tests/libtest/first.c |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xae2(%rip), %rsi # 0x20d4
movl $0x6, %edi
callq 0x10a0
cmpl $0x1, %ebp
jg 0x1625
movq 0x29d0(%rip), %rax # 0x3fd8
movq (%rax), %rdi
leaq 0xac9(%rip), %rsi # 0x20db
xorl %eax, %eax
callq 0x10f0
movl $0x1, %eax
addq $0x8, %rsp
popq %r... | /macressler[P]curl/tests/libtest/first.c |
bsplib::TicToc::push(bsplib::TicToc::Category) | static unsigned push(Category c ) {
s_pos += s_pow * c;
s_pow *= N_CATEGORIES;
assert( s_pow < 1000000 );
if (s_timers.size() <= s_pos)
s_timers.resize( s_pos + 1);
return s_pos;
} | pushq %rbx
movl %edi, %eax
leaq 0xf92c(%rip), %rcx # 0x192d0
movl (%rcx), %edx
imull %edx, %eax
leaq 0xf978(%rip), %rbx # 0x19328
addl (%rbx), %eax
movl %eax, (%rbx)
leal (%rdx,%rdx,4), %edx
leal (%rdx,%rdx,2), %edx
movl %edx, (%rcx)
cmpl $0xf4240, %edx # imm = 0xF4240
jae 0x99f2
leaq 0xf945(%rip), %... | /wijnand-suijlen[P]bsponmpi/src/tictoc.h |
void bsplib::serial<unsigned long>(bsplib::A2A&, int, unsigned long) | void serial( A2A & a2a, int pid, UInt x ) {
typedef UIntSerialize< UInt > S;
typename S::Buffer buf;
{ const int n = S::write(x, buf );
a2a.send( pid, buf, n );
}
} | subq $0x18, %rsp
xorl %ecx, %ecx
movq %rdx, %rax
movl %edx, %r8d
andb $0x7f, %r8b
shrq $0x7, %rax
cmpq $0x7f, %rdx
seta %r9b
shlb $0x7, %r9b
orb %r8b, %r9b
movb %r9b, 0xe(%rsp,%rcx)
incq %rcx
cmpq $0x7f, %rdx
movq %rax, %rdx
ja 0x9c4b
leaq 0xe(%rsp), %rdx
callq 0xa360
addq $0x18, %rsp
retq
nop
| /wijnand-suijlen[P]bsponmpi/src/a2a.h |
bsplib::Spmd::Spmd(int) | Spmd :: Spmd( int nprocs )
{
int mpi_init;
int world_pid = -1;
MPI_Initialized(&mpi_init);
assert( mpi_init );
MPI_Bcast( &nprocs, 1, MPI_INT, 0, MPI_COMM_WORLD );
MPI_Comm_rank( MPI_COMM_WORLD, & world_pid );
m_closed = false;
m_active = world_pid < nprocs;
MPI_Comm_split( MP... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %esi, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp) # imm = 0xFFFFFFFF
leaq 0x14(%rsp), %r14
movq %r14, %rdi
callq 0x6160
cmpl $0x0, (%r14)
je 0x9dd7
movq 0xf264(%rip), %rdx # 0x18fb8
movq 0xf225(%rip), %r14 # 0x18f80
leaq 0x10(%rsp),... | /wijnand-suijlen[P]bsponmpi/src/spmd.cc |
bsplib::A2A::send(int, void const*, unsigned long) | void * A2A::send( int dst_pid, const void * data, std::size_t size )
{
assert( dst_pid >= 0 );
assert( dst_pid < m_nprocs );
assert( m_send_cap == m_send_bufs.size() / m_nprocs );
std::size_t offset = m_send_sizes[ dst_pid ];
if ( m_send_cap < offset + size ) {
std::size_t new_cap =
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0xa47b
movq %rcx, %rbx
movl %esi, %ecx
movq %rdi, %r15
movl 0x8(%rdi), %esi
cmpl %ecx, %esi
jle 0xa49a
movq %rdx, %r8
movq 0x20(%r15), %r14
movq 0xa8(%r15), %rdi
movq 0xb0(%r15), %rax
subq %rdi, %rax
xorl %edx, %edx
divq %r... | /wijnand-suijlen[P]bsponmpi/src/a2a.cc |
bsplib::A2A::exchange() | void A2A::exchange( )
{
std::size_t max_recv = 0, max_bruck_vol = 0;
std::size_t new_cap = m_send_cap;
{
#ifdef PROFILE
TicToc t( TicToc::MPI_META_A2A, 4*sizeof(std::size_t)*m_nprocs );
#endif
// exchange data sizes.
MPI_Alltoall( m_send_sizes.data(), sizeof(std::size_t), MPI_BY... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movslq 0x8(%rdi), %r15
shlq $0x5, %r15
movl $0x8, %edi
callq 0x999a
movl %eax, 0x10(%rsp)
leaq 0x30(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x6290
movaps (%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq %r15, 0x28(%r... | /wijnand-suijlen[P]bsponmpi/src/a2a.cc |
bsplib::Unbuf::Unbuf(unsigned long, ompi_communicator_t*) | Unbuf::Unbuf( size_t max_msg_size, MPI_Comm comm)
: m_pid(-1), m_nprocs(-1)
, m_comm(MPI_COMM_NULL)
, m_max_msg_size( max_msg_size )
{
MPI_Comm_dup( comm, &m_comm );
MPI_Comm_size( m_comm, &m_nprocs );
MPI_Comm_rank( m_comm, &m_pid );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq $-0x1, (%rdi)
leaq 0x8(%rdi), %r13
movq 0xd6de(%rip), %rax # 0x18fb0
movq %rax, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x30(%rdi), %r15
leaq 0x48(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x2... | /wijnand-suijlen[P]bsponmpi/src/unbuf.cc |
bsplib::Rdma::get(int, unsigned long, unsigned long, void*, unsigned long) | void Rdma::get( int src_pid, Memslot src_slot, size_t src_offset,
void * dst, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::GET );
#endif
assert( !( slot( m_pid, src_slot ).status & Memblock::PUSHED) );
Memslot dst_slot = m_local_slots.size();
m_local_slots.push_back( dst );
Action acti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, (%rsp)
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movq %r8, 0x8(%rsp)
movl $0x4, %edi
callq 0x999a
movl %eax, 0x10(%rsp)
leaq 0x30(%rsp), %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x6290
mov... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
runOneSimulation(QTable const&, PlanningUnitDecPOMDPDiscrete const*, SimulationDecPOMDPDiscrete const&) | double runOneSimulation( const QTable & q,
const PlanningUnitDecPOMDPDiscrete *np,
const SimulationDecPOMDPDiscrete &sim
)
{
AgentMDP agent(np, 0, q);
AgentFullyObservable *newAgent;
vector<AgentFullyObservable*> agents;
for... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x118(%rsp), %rsi
movq 0x120(%rsp), %rcx
leaq 0xb8(%rsp), %rdi
xorl %edx, %edx
callq 0x61d0
leaq 0x98(%rsp), %rdi
callq 0x8640
movl $0x0, 0x94(%rsp)
movl 0x94(%rsp), %eax
movq %rax, 0x30(%rsp)
movq 0x118... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/MMDP_Solver.cpp |
main | int main(int argc, char **argv)
{
ArgumentHandlers::Arguments args;
argp_parse (&ArgumentHandlers::theArgpStruc, argc, argv, 0, 0, &args);
try
{
Timing Time;
cout << "Instantiating the problem..."<<endl;
DecPOMDPDiscreteInterface* decpomdp = GetDecPOMDPDiscreteInterfaceFromArgs(... | subq $0x758, %rsp # imm = 0x758
movl $0x0, 0x754(%rsp)
movl %edi, 0x750(%rsp)
movq %rsi, 0x748(%rsp)
leaq 0x510(%rsp), %rdi
movq %rdi, 0x110(%rsp)
callq 0x8e60
movq 0x110(%rsp), %r9
movl 0x750(%rsp), %esi
movq 0x748(%rsp), %rdx
leaq 0x8ce4(%rip), %rdi # 0x10268
xorl %ecx, %ecx
movl %ecx, %r8d
callq 0x62... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/MMDP_Solver.cpp |
ArgumentHandlers::parse_main(int, char*, argp_state*) | static error_t
parse_main (int key, char *arg, struct argp_state *state)
{
struct arguments *theArgumentsStruc = (struct arguments*) state->input;
switch (key)
{
case ARGP_KEY_INIT:
//give child_parsers access to the arguments structure on
//initialization.
for(u... | subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x20(%rsp), %eax
subl $0x1000003, %eax # imm = 0x1000003
jne 0x8436
jmp 0x83ed
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
leaq 0x81fd(%rip), %r... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/../../src/planning/argumentHandlersPostChild.h |
ArgumentHandlers::Arguments::Arguments() | Arguments()
{
// general
verbose = 0;
testMode = false;
// problem file
dpf = 0;
problem_type = PARSE;
nrAgents = 2;
nrHouses = 3;
nrFLs = 3;
islandConf = ProblemAloha::InLine;
alohaVariation = ProblemAloha::NoNewPacket;
... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x1e8, %rdi # imm = 0x1E8
movq %rdi, (%rsp)
callq 0x61b0
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq $0x2, 0x18(%rax)
movq $0x3, 0x20(%rax)
movq $0x3, 0x28(%... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/../../src/planning/argumentHandlers.h |
boost::numeric::ublas::matrix<double, boost::numeric::ublas::basic_row_major<unsigned long, long>, boost::numeric::ublas::unbounded_array<double, std::allocator<double>>>::~matrix() | class matrix:
public matrix_container<matrix<T, L, A> > {
typedef T *pointer;
typedef L layout_type;
typedef matrix<T, L, A> self_type;
public:
#ifdef BOOST_UBLAS_ENABLE_PROXY_SHORTCUTS
using matrix_container<self_type>::operator ();
#endif
typedef typename A::size_t... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
callq 0x9640
movq 0x8(%rsp), %rdi
callq 0x96a0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/../../src/boost/boost/numeric/ublas/matrix.hpp |
boost::numeric::ublas::unbounded_array<double, std::allocator<double>>::~unbounded_array() | BOOST_UBLAS_INLINE
~unbounded_array () {
if (size_) {
if (! detail::has_trivial_destructor<T>::value) {
// std::_Destroy (begin(), end(), alloc_);
const iterator i_end = end();
for (iterator i = begin (); i != i_end; ++i) {
... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x9670
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
callq 0x96b0
jmp 0x966e
jmp 0x9670
movq 0x8(%rsp), %rdi
callq 0x96e0
movq 0x8(%rsp), %rdi
callq 0x96f0
addq $0x18, %rsp
retq
movq %rax, %rdi
ca... | /laurimi[P]npgi/build_O0/third-party/ExternalProject/madp/src/project_madp/src/solvers/../../src/boost/boost/numeric/ublas/storage.hpp |
Kraken::KAPI::public_method(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string... | std::string KAPI::public_method(const std::string& method,
const KAPI::Input& input) const
{
// build method URL
std::string path = "/" + version_ + "/public/" + method;
std::string method_url = url_ + path + "?" + build_query(input);
curl_easy_setopt(curl_, CURLOPT_URL, method_url.c_str());
// res... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsi), %rdx
leaq 0x1df0(%rip), %rsi # 0x7148
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x5d2c
leaq 0x1dd5(%rip), %rdx # 0x714... | /voidloop[P]krakenapi/kapi.cpp |
ads2_checkFact3_Test::TestBody() | TEST(ads2, checkFact3) {
EXPECT_EQ(3628800, fact(10));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movl $0x375f00, (%rbx) # imm = 0x375F00
movl $0xa, %edi
callq 0x9120
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
leaq 0x2f94b(%rip), %rsi # 0x3b146
leaq 0x2f94c(%rip), %rdx # 0x3b14e
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
callq 0xce71
cm... | /NNTU-CS[P]ADS-2/test/tests.cpp |
ads2_checkSinn2_Test::TestBody() | TEST(ads2, checkSinn2) {
EXPECT_DOUBLE_EQ(0.9999996829318345, sinn(3.14/2, 10));
} | pushq %rbx
subq $0x20, %rsp
movsd 0x2f04f(%rip), %xmm0 # 0x3b060
movl $0xa, %edi
callq 0x9520
movaps %xmm0, %xmm1
leaq 0x2f242(%rip), %rsi # 0x3b267
leaq 0x2f24e(%rip), %rdx # 0x3b27a
leaq 0x10(%rsp), %rbx
movsd 0x2f02f(%rip), %xmm0 # 0x3b068
movq %rbx, %rdi
callq 0xc500
cmpb $0x0, (%rbx)
jne 0xc0a5
movq ... | /NNTU-CS[P]ADS-2/test/tests.cpp |
testing::internal::SuiteApiResolver<testing::Test>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x10142
testb %al, %al
jne 0xc4df
leaq 0x2eecc(%rip), %rdx # 0x3b2fb
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x223, %ecx # imm = 0x223
callq 0x161ce
movq 0x46ba6(%rip), %rdi # 0x52ff0
leaq 0x2ef... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::StringFromGTestEnv(char const*, char const*) | const char* StringFromGTestEnv(const char* flag, const char* default_value) {
#if defined(GTEST_GET_STRING_FROM_ENV_)
return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const value = posix::GetEnv(env_var.c_str());
return value == nullptr ? ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x16901
movq (%r14), %r15
movq %r15, %rdi
callq 0x96b0
movq %rax, %r14
leaq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0xd210
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x9500
testq %r14, %r14
cmo... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::internal::DeathTestAbort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void DeathTestAbort(const std::string& message) {
// On a POSIX system, this function may be called from a threadsafe-style
// death test child process, which operates on a very small stack. Use
// the heap for any additional non-minuscule memory requirements.
const InternalRunDeathTestFlag* const flag ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1832e
movq 0x46430(%rip), %rax # 0x537f0
movq 0x238(%rax), %rax
testq %rax, %rax
jne 0xd3eb
movq 0x45bfd(%rip), %r14 # 0x52fd0
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x95c0
movq (%r14), %rdi
callq 0x9640
callq 0x3073b
movl 0x28(%rax), %edi
leaq 0x3123d... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::DefaultDeathTestFactory::Create(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const*, int, testing::internal::DeathTest**) | bool DefaultDeathTestFactory::Create(const char* statement,
Matcher<const std::string&> matcher,
const char* file, int line,
DeathTest** test) {
UnitTestImpl* const impl = GetUnitTestImpl();
const Internal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
callq 0x1832e
movq 0x4079a(%rip), %rax # 0x537f0
movq 0x238(%rax), %r14
movq 0x170(%rax), %rcx
movl 0xf8(%rcx), %eax
leal 0x1(%r... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::FilePath::RemoveDirectoryName() const | FilePath FilePath::RemoveDirectoryName() const {
const char* const last_sep = FindLastPathSeparator();
return last_sep ? FilePath(last_sep + 1) : *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0x95a0
movq %rax, %r14
testq %rax, %rax
setne %bpl
je 0x13c84
leaq 0x1(%r14), %r15
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r15, %rdi
callq 0x9230
le... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-filepath.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3db42(%rip), %r14 # 0x52738
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(char const*) | Matcher<const internal::StringView&>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3d6f0(%rip), %r14 # 0x52768
movq %r14, (%rdi)
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30290
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rs... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(std::basic_string_view<char, std::char_traits<char>>) | Matcher<const internal::StringView&>::Matcher(internal::StringView s) {
*this = Eq(std::string(s));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3d572(%rip), %r14 # 0x52768
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq (%rsi,%rdx), %rax
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x37c48
leaq 0x... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3d420(%rip), %r14 # 0x52798
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-matchers.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x15ab1
movq (%rax), %r13
jmp 0x15ab8
leaq 0x284f1(%rip), %r13 # 0x3dfa9
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1bce0... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*) | std::string ReadEntireFile(FILE* file) {
const size_t file_size = GetFileSize(file);
char* const buffer = new char[file_size];
size_t bytes_last_read = 0; // # of bytes read in the last fread()
size_t bytes_read = 0; // # of bytes read so far
fseek(file, 0, SEEK_SET);
// Keeps reading the file unt... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x95b0
movq %r14, %rdi
callq 0x9030
movq %rax, %r12
movq %rax, %rdi
callq 0x9050
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x95b0
lea... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::internal::FlagToEnvVar[abi:cxx11](char const*) | static std::string FlagToEnvVar(const char* flag) {
const std::string full_flag =
(Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
Message env_var;
for (size_t i = 0; i != full_flag.length(); i++) {
env_var << ToUpper(full_flag.c_str()[i]);
}
return env_var.GetString();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1bce0
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x265d9(%rip), %rsi # 0x3cf08
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
callq 0x95f0
testq %r15, %r15
je 0x16... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-port.cc |
testing::internal::PrintBytesInObjectTo(unsigned char const*, unsigned long, std::ostream*) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
ostream* os) {
PrintBytesInObjectToImpl(obj_bytes, count, os);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x9340
leaq 0x27e3f(%rip), %rsi # 0x3eb9f
movl $0xe, %edx
movq %rax, %rdi
callq 0x95f0
cmpq $0x83, %r14
ja 0x16d7d
movq %r15, %rdi
xorl %esi, %esi
jmp 0x16db1
movl $0x40, %edx
movq %r15, %rdi
xorl %esi, %esi
movq ... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char32_t, std::ostream*) | void PrintTo(char32_t c, ::std::ostream* os) {
*os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
<< static_cast<uint32_t>(c);
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rsi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rsi,%rax)
leaq 0x26399(%rip), %rsi # 0x3d1a2
movl $0x2, %edx
movq %rbx, %rdi
callq 0x95f0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
or... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char32_t const*, std::ostream*) | void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x171b9
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x93e0
leaq 0x28207(%rip), %rsi # 0x3f38e
movl $0xd, %edx
movq %rax, %rdi
callq 0x95f0
movq $-0x1, %rsi
cmpl $0x0, 0x4(%r14,%rsi,4)
leaq 0x1(%rsi), %rsi
jne 0x1719b
movq %r14, %rdi
movq... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(wchar_t const*, std::ostream*) | void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1721f
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x93e0
leaq 0x28199(%rip), %rsi # 0x3f38e
movl $0xd, %edx
movq %rax, %rdi
callq 0x95f0
movq %r14, %rdi
callq 0x9430
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq ... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::operator<<(std::ostream&, testing::TestPartResult const&) | std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
return os << internal::FormatFileLocation(result.file_name(),
result.line_number())
<< " "
<< (result.type() == TestPartResult::kSuccess ? "Success"
: result.t... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x178a6
movq 0x8(%r14), %rsi
movl 0x28(%r14), %edx
movq %rsp, %r15
movq %r15, %rdi
callq 0x15d01
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x95f0
movq %rax, %rbx
leaq 0x25efb(%r... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-test-part.cc |
testing::internal::HasNewFatalFailureHelper::~HasNewFatalFailureHelper() | HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
original_reporter_);
} | pushq %rbx
movq %rdi, %rbx
leaq 0x3a313(%rip), %rax # 0x51dd8
movq %rax, (%rdi)
callq 0x1832e
movq 0x10(%rbx), %rbx
movl $0x90, %edi
addq 0x3bd13(%rip), %rdi # 0x537f0
callq 0x38e58
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x30730
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest-test-part.cc |
testing::internal::AssertHelper::~AssertHelper() | AssertHelper::~AssertHelper() { delete data_; } | pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x1832b
movq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x1831d
movq (%rax), %rsi
incq %rsi
callq 0x9500
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x9500
popq %rbx
retq
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.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_GET(stack_trace_depth)), skip_count + 1
// Skips the user-specified number of frames plus this function
// itself.
); // NOLINT
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x210(%rsi)
jne 0x188d7
movl $0x8, %edi
callq 0x94d0
leaq 0x39833(%rip), %rcx # 0x52100
movq %rcx, (%rax)
movq %rax, 0x210(%r14)
movq 0x210(%r14), %rsi
movl 0x3ae5c(%rip), %edx # 0x53740
incl %ebp
movq (%rsi), %rax
movq ... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.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_str,
const char* filter) {
return UnitTestFilter(filter).MatchesName(name_str);
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x30290
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x1a786
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x1a894
movl %eax, %ebx
leaq 0x40(%rsp), %rdi
callq 0x35678
leaq 0x28(%rsp), %rdi
callq 0x30492
l... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestSuite::successful_test_count() const | void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
TestPartResultReporterInterface* reporter) {
per_thread_test_part_result_reporter_.set(reporter);
} | pushq %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %r14
cmpq 0x38(%rdi), %r14
je 0x1b858
movq %rdi, %rbx
xorl %ebp, %ebp
movq (%r14), %rdi
callq 0x32bea
movzbl %al, %eax
addl %eax, %ebp
addq $0x8, %r14
cmpq 0x38(%rbx), %r14
jne 0x1b83f
jmp 0x1b85a
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestSuite::failed_test_count() const | void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
TestPartResultReporterInterface* reporter) {
per_thread_test_part_result_reporter_.set(reporter);
} | pushq %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %r14
cmpq 0x38(%rdi), %r14
je 0x1b98d
movq %rdi, %rbx
xorl %ebp, %ebp
movq (%r14), %rdi
cmpb $0x1, 0x80(%rdi)
movl $0x0, %eax
jne 0x1b97f
addq $0x90, %rdi
callq 0x1f248
movzbl %al, %eax
addl %eax, %ebp
addq $0x8, %r14
cmpq 0x38(%rbx), %r14
jne 0x1b95f
jmp 0x1b98f
xorl %... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::edit_distance::CreateUnifiedDiff(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... | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
const std::vector<std::string>& right,
size_t context) {
const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
size_t l_i = 0, r_i = 0, edit_i = 0;
std::stringstream s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rcx, 0x8(%rsp)
movq %rdi, 0xa0(%rsp)
leaq 0x10(%rsp), %rdi
movq %rsi, 0x98(%rsp)
movq %rdx, 0xa8(%rsp)
callq 0x1c48a
leaq 0xb0(%rsp), %rdi
callq 0x9370
leaq 0x50(%rsp), %r12
leaq 0x68(%rsp), %rbp
xorl %ebx... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::vector<std::string> SplitEscapedString(const std::string& str) {
std::vector<std::string> lines;
size_t start = 0, end = str.size();
if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
++start;
--end;
}
bool escaped = false;
for (size_t i = start; i + 1 < end; ++i) {
if (escaped) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
cmpq $0x3, %r15
jb 0x1d079
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x1d079
xorl %edx, %edx
cmpb $0x22, -0x1(%rax,%r15)
le... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<wchar_t const*>(bool, char const*, char const*, wchar_t const* const&, wchar_t const* const&) | AssertionResult IsSubstringImpl(bool expected_to_be_substring,
const char* needle_expr,
const char* haystack_expr,
const StringType& needle,
const StringType& haystack) {
if (IsSubstringPred... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r15
movq %r8, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0x1dc3a
cmpq %rdi, %rsi
sete %al
jm... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestResult::GetTestPartResult(int) const | const TestPartResult& TestResult::GetTestPartResult(int i) const {
if (i < 0 || i >= total_part_count()) internal::posix::Abort();
return test_part_results_.at(static_cast<size_t>(i));
} | pushq %rax
testl %esi, %esi
js 0x1eb63
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x1eb63
movl %esi, %esi
movq 0x40(%rdi), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6D... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestResult::Clear() | void TestResult::Clear() {
test_part_results_.clear();
test_properties_.clear();
death_test_count_ = 0;
elapsed_time_ = 0;
} | pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x38(%rbx), %rsi
callq 0x3971c
leaq 0x50(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x39c5c
movl $0x0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
popq %rbx
retq
nop
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ReportFailureInUnknownLocation(testing::TestPartResult::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
const std::string& message) {
// This function is a friend of UnitTest and as such has access to
// AddTestPartResult.
UnitTest::GetInstance()->AddTestPartResult(
result_type,
nullptr, // No info... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
callq 0x1832e
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ea6d(%rip), %rdx # 0x3dfa9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x37c48
leaq 0x3425d(%rip), %rdi # 0x537b0
movl %ebp, %esi
xorl %e... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void PrettyUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this... | cmpl $0x0, (%rsi)
je 0x21e58
pushq %rax
movq %rsi, %rdi
callq 0x21e59
movq 0x31141(%rip), %rax # 0x52f90
movq (%rax), %rdi
popq %rax
jmp 0x9640
retq
| /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Passed()) {
ColoredPrintf(GTestColor::kGreen, "[ OK ] ");
} else if (test_info.result()->Skipped()) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
} else {
ColoredPrintf(GTestColor::kRed, "[ ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %r14
movq %r14, %rdi
callq 0x1f20c
testb %al, %al
jne 0x21ecd
movq %r14, %rdi
callq 0x1f248
testb %al, %al
je 0x21ef0
movq %r14, %rdi
callq 0x1f20c
testb %al, %al
je 0x21ee2
leaq 0x1c089(%rip), %rsi # 0x3df69
jmp 0x21ef7
leaq 0x1c08e(%rip), %rs... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::~TestEventRepeater() | TestEventRepeater::~TestEventRepeater() {
ForEach(listeners_, Delete<TestEventListener>);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2f201(%rip), %rax # 0x51ed8
movq %rax, (%rdi)
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x22cfb
movq (%r14), %rdi
testq %rdi, %rdi
je 0x22cf5
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x22ce2
movq 0x10(%rbx), %rdi
testq %rdi, ... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::ListTestsMatchingFilter(std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
const std::vector<TestSuite*>& test_suites) {
FILE* xmlout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintXmlTestsList(&stream, test_suites);
fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
fclose(xmlout);
} | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x23380
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9370
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x23c2e
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x1bf43
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestsList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void XmlUnitTestResultPrinter::PrintXmlTestsList(
std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
int total_tests = 0;
for (auto test_suite : test_s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a628(%rip), %rsi # 0x3e279
leaq 0x1a62b(%rip), %rdx # 0x3e283
leaq 0x50(%rsp), %rdi
callq 0x37c48
leaq 0x1a61b(%rip), %rsi # 0x3e284
movl $0x27, %edx
m... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestProperties(std::ostream*, testing::TestResult const&) | void XmlUnitTestResultPrinter::OutputXmlTestProperties(
std::ostream* stream, const TestResult& result) {
const std::string kProperties = "properties";
const std::string kProperty = "property";
if (result.test_property_count() <= 0) {
return;
}
*stream << " <" << kProperties << ">\n";
for (in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1774a(%rip), %rsi # 0x3e2b5
leaq 0x1774d(%rip), %rdx # 0x3e2bf
leaq 0x48(%rsp), %rdi
callq 0x37c48
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
l... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&) | std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
const TestResult& result) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << " " << property.key() << "="
<< "\"" << Esc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x1bce0
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
testl %eax, %eax
jle 0x2764f
movq 0x8(%rsp), %r15
addq $0x10, %r15
xorl %ebp, %ebp
leaq 0x38(%rsp), %r12... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* jsonout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintJsonUnitTest(&stream, unit_test);
fprintf(jsonout, "%s", StringStreamToString(&st... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x23380
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9370
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x27866
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x1bf43
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx... | /NNTU-CS[P]ADS-2/build_O1/_deps/googletest-src/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.