name string | code string | asm string | file string |
|---|---|---|---|
void Ptex::v2_4::(anonymous namespace)::Apply<Ptex::v2_4::PtexHalf, 4>(Ptex::v2_4::PtexSeparableKernel&, float*, void*, int, int) | int u() const { return 1<<(unsigned)ulog2; } | movb (%rdi), %cl
movl $0x4, %r9d
shll %cl, %r9d
movl 0x8(%rdi), %eax
shll %cl, %eax
movslq 0x10(%rdi), %r8
movslq %r9d, %rcx
imulq %r8, %rcx
testl %ecx, %ecx
je 0x11854
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x4(%rdi), %r8
cltq
addq %r8, %rax
leaq (%rdx,%rax,8), %rax
leaq (%rax,%rcx,2)... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/Ptexture.h |
void Ptex::v2_4::(anonymous namespace)::ApplyS<unsigned char, 2>(Ptex::v2_4::PtexSeparableKernel&, float*, void*, int, int) | int u() const { return 1<<(unsigned)ulog2; } | movb (%rdi), %cl
movl %r8d, %r11d
shll %cl, %r11d
movl 0x8(%rdi), %r9d
shll %cl, %r9d
movslq 0x10(%rdi), %rcx
movslq %r11d, %rax
imulq %rcx, %rax
testl %eax, %eax
je 0x11d14
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
addl 0x4(%rdi), %r9d
imull %r8d, %r9d
movslq %r9d, %rcx
addq %rcx, %rdx
addq %rdx, %rax
movq 0x18(%rdi... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/Ptexture.h |
void Ptex::v2_4::(anonymous namespace)::ApplyS<unsigned short, 3>(Ptex::v2_4::PtexSeparableKernel&, float*, void*, int, int) | int u() const { return 1<<(unsigned)ulog2; } | movb (%rdi), %cl
movl %r8d, %r10d
shll %cl, %r10d
movl 0x8(%rdi), %eax
shll %cl, %eax
movslq 0x10(%rdi), %r9
movslq %r10d, %rcx
imulq %r9, %rcx
testl %ecx, %ecx
je 0x1223f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
addl 0x4(%rdi), %eax
imull %r8d, %eax
cltq
leaq (%rdx,%rax,2), %r15
leaq (%r15,%rc... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/Ptexture.h |
void Ptex::v2_4::(anonymous namespace)::ApplyN<unsigned char>(Ptex::v2_4::PtexTriangleKernelIter&, float*, void*, int, int) | void ApplyN(PtexTriangleKernelIter& k, float* result, void* data, int nChan, int nTxChan)
{
float DDQ = 2.0f*k.A;
for (int vi = k.v1; vi != k.v2; vi++) {
int xw = k.rowlen - vi;
int x1 = PtexUtils::max(k.u1, xw-k.w2);
int x2 = PtexUtils::min(k.u2, xw-k.w1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0x8(%rsp)
movl %ecx, 0x10(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x10(%rdi), %eax
cmpl 0x1c(%rdi), %eax
je 0x13df1
movq %rsi, %r15
movq %rdi, %r12
movss 0x24(%rdi), %xmm5
addss %xmm5, %xmm5
movl 0x10(%rsp), %r14d
movslq 0x8(%rsp), %... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexTriangleKernel.cpp |
void Ptex::v2_4::(anonymous namespace)::Apply<Ptex::v2_4::PtexHalf, 1>(Ptex::v2_4::PtexTriangleKernelIter&, float*, void*, int, int) | void Apply(PtexTriangleKernelIter& k, float* result, void* data, int /*nChan*/, int /*nTxChan*/)
{
int nTxChan = nChan;
float DDQ = 2.0f*k.A;
for (int vi = k.v1; vi != k.v2; vi++) {
int xw = k.rowlen - vi;
int x1 = PtexUtils::max(k.u1, xw-k.w2);
int x2 = P... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movl 0x10(%rdi), %ebp
cmpl 0x1c(%rdi), %ebp
je 0x1488a
movq %rsi, %r14
movq %rdi, %r15
movss 0x24(%rdi), %xmm5
addss %xmm5, %xmm5
movss 0x78bf(%rip), %xmm6 # 0x1c008
leaq 0x10e40(%rip), %r12 # 0x25590
movss ... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexTriangleKernel.cpp |
void Ptex::v2_4::(anonymous namespace)::Apply<unsigned short, 2>(Ptex::v2_4::PtexTriangleKernelIter&, float*, void*, int, int) | void Apply(PtexTriangleKernelIter& k, float* result, void* data, int /*nChan*/, int /*nTxChan*/)
{
int nTxChan = nChan;
float DDQ = 2.0f*k.A;
for (int vi = k.v1; vi != k.v2; vi++) {
int xw = k.rowlen - vi;
int x1 = PtexUtils::max(k.u1, xw-k.w2);
int x2 = P... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x10(%rdi), %ebp
cmpl 0x1c(%rdi), %ebp
je 0x14d2c
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movss 0x24(%rdi), %xmm5
addss %xmm5, %xmm5
movss 0x7426(%rip), %xmm6 # 0x1c008
movss %xmm5, 0xc(%rsp)
movl (%r15), %edx
movl %edx,... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexTriangleKernel.cpp |
void Ptex::v2_4::(anonymous namespace)::Apply<float, 3>(Ptex::v2_4::PtexTriangleKernelIter&, float*, void*, int, int) | void Apply(PtexTriangleKernelIter& k, float* result, void* data, int /*nChan*/, int /*nTxChan*/)
{
int nTxChan = nChan;
float DDQ = 2.0f*k.A;
for (int vi = k.v1; vi != k.v2; vi++) {
int xw = k.rowlen - vi;
int x1 = PtexUtils::max(k.u1, xw-k.w2);
int x2 = P... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x10(%rdi), %ebp
cmpl 0x1c(%rdi), %ebp
je 0x1574e
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movss 0x24(%rdi), %xmm5
addss %xmm5, %xmm5
movss 0x6a25(%rip), %xmm6 # 0x1c008
movss %xmm5, 0xc(%rsp)
movl (%r15), %edx
movl %edx,... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexTriangleKernel.cpp |
void Ptex::v2_4::(anonymous namespace)::ApplyS<unsigned char, 1>(Ptex::v2_4::PtexTriangleKernelIter&, float*, void*, int, int) | void ApplyS(PtexTriangleKernelIter& k, float* result, void* data, int /*nChan*/, int nTxChan)
{
float DDQ = 2.0f*k.A;
for (int vi = k.v1; vi != k.v2; vi++) {
int xw = k.rowlen - vi;
int x1 = PtexUtils::max(k.u1, xw-k.w2);
int x2 = PtexUtils::min(k.u2, xw-k.w1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, (%rsp)
movq %rdx, 0x10(%rsp)
movl 0x10(%rdi), %ebp
cmpl 0x1c(%rdi), %ebp
je 0x15feb
movq %rsi, %r15
movq %rdi, %r12
movss 0x24(%rdi), %xmm5
addss %xmm5, %xmm5
movslq (%rsp), %r13
movss 0x616e(%rip), %xmm6 # 0x1c008
movss %... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexTriangleKernel.cpp |
void Ptex::v2_4::(anonymous namespace)::ApplyS<Ptex::v2_4::PtexHalf, 1>(Ptex::v2_4::PtexTriangleKernelIter&, float*, void*, int, int) | void ApplyS(PtexTriangleKernelIter& k, float* result, void* data, int /*nChan*/, int nTxChan)
{
float DDQ = 2.0f*k.A;
for (int vi = k.v1; vi != k.v2; vi++) {
int xw = k.rowlen - vi;
int x1 = PtexUtils::max(k.u1, xw-k.w2);
int x2 = PtexUtils::min(k.u2, xw-k.w1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x10(%rdi), %ebp
cmpl 0x1c(%rdi), %ebp
je 0x163a6
movq %rsi, %r15
movq %rdi, %r12
movss 0x24(%rdi), %xmm5
addss %xmm5, %xmm5
movslq 0xc(%rsp), %r13
movl %ebp, %eax
negl %eax
movl %eax, 0x10... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexTriangleKernel.cpp |
void Ptex::v2_4::(anonymous namespace)::ApplyS<unsigned short, 3>(Ptex::v2_4::PtexTriangleKernelIter&, float*, void*, int, int) | void ApplyS(PtexTriangleKernelIter& k, float* result, void* data, int /*nChan*/, int nTxChan)
{
float DDQ = 2.0f*k.A;
for (int vi = k.v1; vi != k.v2; vi++) {
int xw = k.rowlen - vi;
int x1 = PtexUtils::max(k.u1, xw-k.w2);
int x2 = PtexUtils::min(k.u2, xw-k.w1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x10(%rdi), %ebp
cmpl 0x1c(%rdi), %ebp
je 0x170e5
movq %rsi, %r15
movq %rdi, %r12
movss 0x24(%rdi), %xmm5
addss %xmm5, %xmm5
movslq 0xc(%rsp), %r13
movl %ebp, %eax
negl %eax
movl %eax, 0x10... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexTriangleKernel.cpp |
void Ptex::v2_4::(anonymous namespace)::ApplyS<unsigned short, 4>(Ptex::v2_4::PtexTriangleKernelIter&, float*, void*, int, int) | void ApplyS(PtexTriangleKernelIter& k, float* result, void* data, int /*nChan*/, int nTxChan)
{
float DDQ = 2.0f*k.A;
for (int vi = k.v1; vi != k.v2; vi++) {
int xw = k.rowlen - vi;
int x1 = PtexUtils::max(k.u1, xw-k.w2);
int x2 = PtexUtils::min(k.u2, xw-k.w1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x10(%rdi), %ebp
cmpl 0x1c(%rdi), %ebp
je 0x178df
movq %rsi, %r15
movq %rdi, %r12
movss 0x24(%rdi), %xmm5
addss %xmm5, %xmm5
movslq 0xc(%rsp), %r13
movl %ebp, %eax
negl %eax
movl %eax, 0x10... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexTriangleKernel.cpp |
void Ptex::v2_4::(anonymous namespace)::ApplyS<Ptex::v2_4::PtexHalf, 4>(Ptex::v2_4::PtexTriangleKernelIter&, float*, void*, int, int) | void ApplyS(PtexTriangleKernelIter& k, float* result, void* data, int /*nChan*/, int nTxChan)
{
float DDQ = 2.0f*k.A;
for (int vi = k.v1; vi != k.v2; vi++) {
int xw = k.rowlen - vi;
int x1 = PtexUtils::max(k.u1, xw-k.w2);
int x2 = PtexUtils::min(k.u2, xw-k.w1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0x8(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x10(%rdi), %edx
cmpl 0x1c(%rdi), %edx
je 0x17af9
movq %rsi, %r15
movq %rdi, %r12
movss 0x24(%rdi), %xmm5
addss %xmm5, %xmm5
movslq 0x8(%rsp), %r13
movl %edx, %eax
negl %eax
movl %eax, 0xc(... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexTriangleKernel.cpp |
void Ptex::v2_4::(anonymous namespace)::ApplyS<float, 4>(Ptex::v2_4::PtexTriangleKernelIter&, float*, void*, int, int) | void ApplyS(PtexTriangleKernelIter& k, float* result, void* data, int /*nChan*/, int nTxChan)
{
float DDQ = 2.0f*k.A;
for (int vi = k.v1; vi != k.v2; vi++) {
int xw = k.rowlen - vi;
int x1 = PtexUtils::max(k.u1, xw-k.w2);
int x2 = PtexUtils::min(k.u2, xw-k.w1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x10(%rdi), %ebp
cmpl 0x1c(%rdi), %ebp
je 0x17d13
movq %rsi, %r15
movq %rdi, %r12
movss 0x24(%rdi), %xmm5
addss %xmm5, %xmm5
movslq 0xc(%rsp), %r13
movl %ebp, %eax
negl %eax
movl %eax, 0x10... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexTriangleKernel.cpp |
Ptex::v2_4::PtexUtils::deinterleave(void const*, int, int, int, void*, int, Ptex::v2_4::DataType, int) | void deinterleave(const void* src, int sstride, int uw, int vw,
void* dst, int dstride, DataType dt, int nchan)
{
switch (dt) {
case dt_uint8: deinterleave((const uint8_t*) src, sstride, uw, vw,
(uint8_t*) dst, dstride, nchan); break;
case dt_half:
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x40(%rsp), %eax
movl 0x38(%rsp), %r10d
leal -0x1(%r10), %r11d
cmpl $0x2, %r11d
jb 0x1849d
cmpl $0x3, %r10d
je 0x18523
testl %r10d, %r10d
jne 0x185ae
testl %eax, %eax
je 0x185ae
cltq
leaq (%rdi,%rax), %r10
imull %esi, %ecx
movslq %ecx, %r11
movslq %... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexUtils.cpp |
Ptex::v2_4::PtexUtils::fill(void const*, void*, int, int, int, int) | void fill(const void* src, void* dst, int dstride,
int ures, int vres, int pixelsize)
{
// fill first row
int rowlen = ures*pixelsize;
char* ptr = (char*) dst;
char* end = ptr + rowlen;
for (; ptr != end; ptr += pixelsize) memcpy(ptr, src, pixelsize);
// fill remaining rows from first... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %edx, 0x4(%rsp)
movq %rsi, %rbx
imull %r9d, %ecx
movslq %ecx, %r14
testl %r14d, %r14d
je 0x1947d
movq %rdi, %r12
movslq %r9d, %r13
xorl %r15d, %r15d
leaq (%rbx,%r15), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x5230
addq ... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexUtils.cpp |
void Ptex::v2_4::PtexUtils::(anonymous namespace)::average<unsigned short>(unsigned short const*, int, int, int, unsigned short*, int) | inline void average(const T* src, int sstride, int uw, int vw,
T* dst, int nchan)
{
float* buff = (float*) alloca(nchan*sizeof(float));
memset(buff, 0, nchan*sizeof(float));
sstride /= (int)sizeof(T);
int rowlen = uw*nchan;
int rowskip = sstride - rowl... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r13d
movq %r8, %rbx
movl %ecx, -0x30(%rbp)
movl %edx, -0x2c(%rbp)
movl %esi, %r15d
movq %rdi, %r12
movslq %r9d, %rdx
movq %rsp, %r14
leaq 0xf(,%rdx,4), %rax
shlq $0x2, %rdx
andq $-0x10, %rax
subq %rax, %r14
movq %r1... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexUtils.cpp |
Ptex::v2_4::PtexUtils::multalpha(void*, int, Ptex::v2_4::DataType, int, int) | void multalpha(void* data, int npixels, DataType dt, int nchannels, int alphachan)
{
float scale = OneValueInv(dt);
switch(dt) {
case dt_uint8: multalpha(static_cast<uint8_t*>(data), npixels, nchannels, alphachan, scale); break;
case dt_uint16: multalpha(static_cast<uint16_t*>(data), npixels, nchan... | cmpl $0x3, %edx
ja 0x19f2f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %eax
leaq 0x2e6d(%rip), %rdx # 0x1cb60
movss (%rdx,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp)
leaq 0x2ccf(%rip), %rdx # 0x1c9d4
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
xorl %eax, %... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexUtils.cpp |
Ptex::v2_4::PtexHalf::fromFloat_except(unsigned int) | uint16_t PtexHalf::fromFloat_except(uint32_t i)
{
uint32_t s = ((i>>16) & 0x8000);
int32_t e = ((i>>13) & 0x3fc00) - 0x1c000;
if (e <= 0) {
// denormalized
union { uint32_t i; float f; } u;
u.i = i;
return (uint16_t)(s|int(fabs(u.f)*1.6777216e7 + .5));
}
if (e == 0x... | movl %edi, %eax
shrl $0x10, %eax
andl $0x8000, %eax # imm = 0x8000
movl %edi, %ecx
shrl $0xd, %ecx
movl %ecx, %edx
andl $0x3fc00, %edx # imm = 0x3FC00
cmpl $0x1c000, %edx # imm = 0x1C000
ja 0x1b3a8
andl $0x7fffffff, %edi # imm = 0x7FFFFFFF
movd %edi, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0... | /mmp[P]pbrt-v4/src/ext/ptex/src/ptex/PtexHalf.cpp |
sptk::Matrix::GetDeterminant(double*) const | bool Matrix::GetDeterminant(double* determinant) const {
if (num_row_ != num_column_ || num_row_ <= 0 || NULL == determinant) {
return false;
}
const int num_dimension(num_row_);
if (1 == num_dimension) {
*determinant = index_[0][0];
return true;
}
const int num_order(num_dimension - 1);
Mat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x8(%rdi), %ebp
cmpl 0xc(%rdi), %ebp
jne 0x975a
movq %rsi, %rbx
testl %ebp, %ebp
setle %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x976d
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
pop... | /sp-nitech[P]SPTK/src/math/matrix.cc |
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 0x20d0
pushq %rax
callq 0x2030
movl $0x16, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
| /nomaster[P]curl/tests/libtest/first.c |
tutil_tvdiff | long tutil_tvdiff(struct timeval newer, struct timeval older)
{
return (long)(newer.tv_sec-older.tv_sec)*1000+
(long)(newer.tv_usec-older.tv_usec)/1000;
} | movq %rsi, %rax
subq %rdx, %rdi
subq %rcx, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
imulq $0x3e8, %rdi, %rcx # imm = 0x3E8
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rdx, %rax
addq %rcx, %rax
retq
| /nomaster[P]curl/tests/libtest/testutil.c |
curlx_sztosi | int curlx_sztosi(ssize_t sznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sznum >= 0);
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
#endif
return (int)(sznum & (ssize_t... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /nomaster[P]curl/lib/warnless.c |
curlx_uitosi | int curlx_uitosi(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_SINT);
return (int) (uinum & (unsigned int) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warni... | movl %edi, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /nomaster[P]curl/lib/warnless.c |
verifyChunkLNU1(njoy::ENDFtk::section::Type<1, 456> const&) | void verifyChunkLNU1( const section::Type< 1, 456 >& chunk ) {
CHECK( 456 == chunk.MT() );
CHECK( 456 == chunk.sectionNumber() );
CHECK( 92235 == chunk.ZA() );
CHECK( 92235 == chunk.targetIdentifier() );
CHECK_THAT( 233.0248, WithinRel( chunk.atomicWeightRatio() ) );
CHECK_THAT( 233.0248, WithinRel( chunk.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x80465(%rip), %r13 # 0x9d484
leaq 0x58(%rsp), %r14
movq %r13, (%r14)
movq $0xd3, 0x8(%r14)
movl $0x2, (%rsp)
leaq 0x805c8(%rip), %rsi # 0x9d605
leaq 0x805c7(%rip), %r8 # 0x9d60b
leaq 0x8(%rsp), %r15
mov... | /njoy[P]ENDFtk/src/ENDFtk/section/1/456/test/456.test.cpp |
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned long>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned long>, fmt::v9::basic... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x74a9a(%rip), %rcx # 0x9f5a0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
void fmt::v9::detail::for_each_codepoint<fmt::v9::detail::find_escape(char const*, char const*)::'lambda'(unsigned int, fmt::v9::basic_string_view<char>)>(fmt::v9::basic_string_view<char>, fmt::v9::detail::find_escape(char const*, char const*)::'lambda'(unsigned int, fmt::v9::basic_string_view<char>))::'lambda'(char co... | FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) {
auto decode = [f](const char* buf_ptr, const char* ptr) {
auto cp = uint32_t();
auto error = 0;
auto end = utf8_decode(buf_ptr, &cp, &error);
bool result = f(error ? invalid_code_point : cp,
string_view(ptr, error ? 1 : to... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movzbl (%rsi), %ecx
movl %ecx, %edi
shrl $0x3, %edi
leaq 0x71e1d(%rip), %rax # 0x9f348
movsbq (%rdi,%rax), %r13
movl $0x80ff0000, %esi # imm = 0x80FF0000
xorl %eax, %eax
btl %edi, %esi
setb... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
spdlog::details::M_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_min, dest);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movl 0x4(%rdx), %r14d
cmpq $0x63, %r14
ja 0x47f9c
movl $0xcccccccd, %r15d # imm = 0xCCCCCCCD
imulq %r14, %r15
shrq $0x23, %r15
leal (%r15,%r15), %eax
leal (%rax,%rax,4), %eax
subl %eax, %r14d
orb $0x30, %r15b
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rs... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::elapsed_formatter<spdlog::details::null_scoped_padder, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
auto delta = (std::max)(msg.time - last_message_time_, log_clock::duration::zero());
auto delta_units = std::chrono::duration_cast<DurationUnits>(delta);
last_message_time_ = msg.time;
auto delta... | subq $0x28, %rsp
movq 0x18(%rsi), %rax
movq %rax, %rdx
subq 0x18(%rdi), %rdx
xorl %r8d, %r8d
testq %rdx, %rdx
cmovgq %rdx, %r8
movq %rax, 0x18(%rdi)
leaq 0x1d(%rsp), %rsi
leaq 0x55352(%rip), %rdi # 0x9e3a9
cmpq $0x64, %rdx
jl 0x4909a
movabsq $0x28f5c28f5c28f5c3, %r9 # imm = 0x28F5C28F5C28F5C3
movq %r8, %rax
shrq $0... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
iu_Locale_x_iutest_x_Invalid_Test::Body() | IUTEST(Locale, Invalid)
{
IUTEST_ASSUME_NULL(setlocale(LC_CTYPE, "xxx"));
IUTEST_ASSERT_STRIN("failed: setlocale LC_CTYPE to hoge", stderr_capture.GetStreamString());
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
leaq 0x13330(%rip), %rsi # 0x2418e
xorl %edi, %edi
callq 0x102b0
leaq 0x1330c(%rip), %rsi # 0x24178
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11a70
movb 0x20(%rbx), %bpl
testb %bpl, %bpl
jne 0x10f1c
leaq 0x68(%rsp), ... | /srz-zumix[P]iutest/test/invalid_locale_ctype_tests.cpp |
iutest::detail::iuConsole::color_output(iutest::detail::iuConsole::Color, char const*, ...) | inline void iuConsole::color_output(Color color, const char *fmt, ...)
{
va_list va;
va_start(va, fmt);
if( IsShouldUseColor(true) )
{
color_output_impl(color, fmt, va);
}
else
{
voutput(fmt, va);
}
va_end(va);
} | 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 0x113fc
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0... | /srz-zumix[P]iutest/include/internal/iutest_console.hpp |
iutest::detail::TestInstance<iu_Locale_x_iutest_x_Invalid_Test>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x1733a
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x20c80
movq %rax, 0x8(%rbx)
leaq 0x1d34a(%r... | /srz-zumix[P]iutest/include/iutest_core.hpp |
iutest::detail::IUStreamCapture::GetStreamString[abi:cxx11]() | ::std::string GetStreamString()
{
if( !m_tempfile.Open(iutest::IFile::OpenRead) )
{
IUTEST_LOG_(WARNING) << "temp file open failed: " << m_tempfile.GetFileName();
return "";
}
return m_tempfile.ReadAll();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x30(%rsi), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq *0x28(%rax)
testb %al, %al
je 0x11bb1
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15d10
jmp 0x11c14
leaq 0x12776(%rip), %r... | /srz-zumix[P]iutest/include/internal/iutest_stream_capture.hpp |
iutest::DefaultXmlGeneratorListener::~DefaultXmlGeneratorListener() | virtual ~DefaultXmlGeneratorListener()
{
FileClose();
TestEnv::event_listeners().set_default_xml_generator(NULL);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b240(%rip), %rax # 0x2e2e0
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x130d0
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x1c787(%rip), %rdi # 0x2f840
testq %rdi, %rdi
je 0x130c8
movq 0x48(%rbx), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
mov... | /srz-zumix[P]iutest/include/listener/iutest_default_xml_generator.hpp |
iutest::TestEnv::Variable::Variable() | Variable()
: m_random_seed(0)
, m_current_random_seed(0)
, m_before_origin_random_seed(0)
, m_repeat_count(1)
, m_testpartresult_reporter(NULL)
{} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movaps 0xee06(%rip), %xmm0 # 0x24030
movups %xmm0, (%rdi)
leaq 0x28(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
leaq 0x48(%rdi), %rcx
movq %rcx, 0... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_env.hpp |
iutest::TestEnv::Variable::~Variable() | Variable()
: m_random_seed(0)
, m_current_random_seed(0)
, m_before_origin_random_seed(0)
, m_repeat_count(1)
, m_testpartresult_reporter(NULL)
{} | pushq %rbx
movq %rdi, %rbx
movq 0x2a8(%rdi), %rdi
leaq 0x2b8(%rbx), %rax
cmpq %rax, %rdi
je 0x15418
movq (%rax), %rsi
incq %rsi
callq 0x102f0
leaq 0x120(%rbx), %rdi
movq 0x19b92(%rip), %rsi # 0x2efb8
callq 0x10250
leaq 0x1a0(%rbx), %rdi
callq 0x100f0
leaq 0x18d22(%rip), %rax # 0x2e160
movq %rax, 0xe8(%rbx)
movq... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_env.hpp |
iutest::detail::iuRandom::init() | void init()
{
init(GetIndefiniteValue());
} | pushq %rbx
movq %rdi, %rbx
movb 0x1a230(%rip), %al # 0x2f748
testb %al, %al
je 0x15577
imull $0x19660d, 0x1a21a(%rip), %eax # imm = 0x19660D
addl $0x3c6ef35f, %eax # imm = 0x3C6EF35F
movl %eax, 0x1a20f(%rip) # 0x2f740
movl %eax, %ecx
shrl $0x1e, %ecx
xorl %eax, %ecx
imull $0x6c078965, %ecx, %ecx # imm = ... | /srz-zumix[P]iutest/include/internal/../internal/../internal/iutest_random.hpp |
iutest::detail::SocketWriter::SendLn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool SendLn(const ::std::string& message)
{
#ifdef IUTEST_OS_WINDOWS
return Send(message + "\r\n");
#else
return Send(message + "\r\n");
//return Send(message + "\n");
#endif
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x15618
leaq 0xed4f(%rip), %rsi # 0x24301
movq %r14, %rdi
callq 0x105a0
movq (%rsp), %rsi
movq ... | /srz-zumix[P]iutest/include/listener/../internal/iutest_socket.hpp |
iutest::detail::IUStreamCapture::IUStreamCapture(int) | explicit IUStreamCapture(int fd)
: m_fd(fd), m_prev_fd(internal::posix::Dup(fd)), m_new_fd(-1)
{
if( m_prev_fd == -1 )
{
IUTEST_LOG_(WARNING) << "file descriptor dup failed";
}
else
{
if( !m_tempfile.Create("iutest_stream_capture") )
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18fcb(%rip), %rax # 0x2e690
movq %rax, (%rdi)
leaq 0x19011(%rip), %rax # 0x2e6e0
movq %rax, 0x8(%rdi)
leaq 0x190ae(%rip), %rax # 0x2e788
movq %rax, 0x10(%rdi)
leaq 0x190f3(%rip), %rax # 0x2... | /srz-zumix[P]iutest/include/internal/iutest_stream_capture.hpp |
iutest::TempFile::Create(char const*) | bool Create(const char* basename)
{
#if defined(IUTEST_OS_WINDOWS)
char tmp_dir[IUTEST_MAX_PATH] = { '\0' };
GetTempPathA(sizeof(tmp_dir), tmp_dir);
char name_template[IUTEST_MAX_PATH] = { '\0' };
UINT ret = GetTempFileNameA(tmp_dir, basename, 0, name_template);
IUTEST_CHECK... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xea2f(%rip), %rsi # 0x24443
leaq 0xea2d(%rip), %rdx # 0x24448
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x160e6
movq %r15, %rdi
movq %r14, %rsi
callq 0x105a0
leaq 0x... | /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_file.hpp |
iutest::detail::IUStreamCapture::Close() | void Close()
{
if( m_prev_fd != -1 )
{
internal::posix::Dup2(m_prev_fd, m_fd);
internal::posix::FdClose(m_prev_fd);
m_prev_fd = -1;
m_new_fd = -1;
}
} | pushq %rbx
movq %rdi, %rbx
movl 0x54(%rdi), %edi
cmpl $-0x1, %edi
je 0x15ad4
movl 0x50(%rbx), %esi
callq 0x102c0
movl 0x54(%rbx), %edi
callq 0x105c0
movq $-0x1, 0x54(%rbx)
popq %rbx
retq
| /srz-zumix[P]iutest/include/internal/iutest_stream_capture.hpp |
iutest::TempFile::Close() | virtual void Close() IUTEST_CXX_OVERRIDE
{
m_file.Close();
if( m_fd != -1 )
{
internal::posix::FdClose(m_fd);
m_fd = -1;
}
} | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x15af0
callq 0x102d0
movq $0x0, 0x20(%rbx)
movl 0x28(%rbx), %edi
cmpl $-0x1, %edi
je 0x15b04
callq 0x105c0
movl $0xffffffff, 0x28(%rbx) # imm = 0xFFFFFFFF
popq %rbx
retq
| /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_file.hpp |
iutest::TempFile::~TempFile() | virtual ~TempFile() { Close(); } | pushq %rbx
movq %rdi, %rbx
leaq 0x18b7f(%rip), %rax # 0x2e690
movq %rax, (%rdi)
leaq 0x18bc5(%rip), %rax # 0x2e6e0
movq %rax, 0x8(%rdi)
callq 0x15ad6
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x15b3c
movq (%rax), %rsi
incq %rsi
callq 0x102f0
leaq 0x18c45(%rip), %rax # 0x2e788
movq %rax,... | /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_file.hpp |
iutest::detail::IInStream::ReadAll[abi:cxx11]() | virtual ::std::string ReadAll()
{
::std::string str;
const size_t size = static_cast<size_t>(GetSize());
if( size != 0 )
{
char* buf = new char[size+1];
buf[size] = '\0';
if( Read(buf, size, 1) )
{
str = buf;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x18(%rax)
movq %rax, %r12
testq %rax, %rax
je 0x15d94
leaq 0x1(%r12), %rdi
callq 0x10030
movq %rax, %r14
mov... | /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_stream.hpp |
iutest::StdioFile::OpenImpl(char const*, int) | virtual bool OpenImpl(const char* filename, int mode) IUTEST_CXX_OVERRIDE
{
Close();
switch( mode )
{
case IFile::OpenRead:
m_fp = internal::posix::FileOpen(filename, "rb");
break;
case IFile::OpenWrite:
m_fp = internal::posix::FileOpen(fil... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0x1, %ebp
je 0x15eb5
cmpl $0x2, %ebp
je 0x15eac
cmpl $0x3, %ebp
jne 0x15eca
leaq 0xe55d(%rip), %rsi # 0x24407
jmp 0x15ebc
leaq 0xe551(%rip), %rsi # 0x24404
jmp 0x15ebc
leaq 0xe545(%rip), ... | /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_file.hpp |
iutest::detail::StringFormat[abi:cxx11](char const*, __va_list_tag*) | inline ::std::string StringFormat(const char* format, va_list va)
{
size_t n = strlen(format) * 2 + 1;
{
va_list va2;
iu_va_copy(va2, va); // cppcheck-suppress va_list_usedBeforeStarted
const int ret = iu_vsnprintf(NULL, 0u, format, va2);
va_end(va2);
if( ret > 0 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x10140
leaq 0x1(,%rax,2), %rbp
movq 0x10(%r14), %rax
movq %rsp, %r12
movq %rax, 0x10(%r12)
movups (%r14), %xmm0
movaps %xmm0, (%r12)
xorl %edi, %edi
xorl %esi, %esi
m... | /srz-zumix[P]iutest/include/internal/iutest_string.hpp |
iutest::TempFile::Delete() | void Delete()
{
Close();
if( !m_filename.empty() )
{
remove(m_filename.c_str());
m_filename = "";
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
cmpq $0x0, 0x38(%rbx)
je 0x162f8
leaq 0x30(%rbx), %r14
movq 0x30(%rbx), %rdi
callq 0x10570
movq 0x38(%rbx), %rdx
leaq 0xfe98(%rip), %rcx # 0x2617c
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14... | /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_file.hpp |
iutest::AssertionHelper::OnFixed(iutest::AssertionHelper::Fixed const&, bool) | void OnFixed(const Fixed& fixed, bool isException = false)
{
// OnFixed で throw しないこと！テスト側の例外キャッチにかからなくなる
const ::std::string append_message = fixed.GetString();
if( !append_message.empty() )
{
m_part_result.add_message(" " + append_message);
}
ScopedTrace... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rdi, %rbx
addq $0x18, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x104b0
cmpq $0x0, 0x8(%r14)
je 0x166fd
leaq 0xfd13(%rip), %rsi # 0x263d7
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x167d2
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::TestEventListeners::Release(iutest::TestEventListener*) | TestEventListener* Release(TestEventListener* listener)
{
if( listener == m_default_result_printer )
{
m_default_result_printer = NULL;
}
if( listener == m_default_xml_generator )
{
m_default_xml_generator = NULL;
}
return m_repeater.Re... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq %rsi, 0x20(%rdi)
jne 0x19536
movq $0x0, 0x20(%rbx)
cmpq %rsi, 0x28(%rbx)
jne 0x19544
movq $0x0, 0x28(%rbx)
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x19812
movq 0x10(%rbx), %rdx
cmpq %rdx, %rax
je 0x19589
leaq 0x8(%rax), %rs... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_listener.hpp |
iutest::DefaultXmlGeneratorListener::SetFilePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SetFilePath(const ::std::string& path)
{
if( path.empty() )
{
m_output_path_format.clear();
m_output_path = detail::kStrings::DefaultXmlReportFileName;
}
else
{
m_output_path_format = path;
const ::std::string::size_type po... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x197df
movq %rsi, %r15
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x101a0
movq %r15, %rdi
movl $0x2e, %esi
xorl %edx, %edx
callq 0x103f0
cmpq $-0x1, %rax
je 0x197af
movq 0x8(%r15), %rcx
decq %rcx
cmpq %rcx, %rax
jne 0x197cb
movq %r14, %rdi
movl $... | /srz-zumix[P]iutest/include/listener/iutest_default_xml_generator.hpp |
iutest::detail::BasicSocket::Open(char const*, char const*) | bool Open(const char* host, const char* port)
{
if( m_socket != INVALID_DESCRIPTOR )
{
return true;
}
addrinfo* servinfo = NULL;
addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;... | movb $0x1, %al
cmpl $-0x1, (%rdi)
je 0x19d2c
retq
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movl $0x1, 0x8(%rax)
movq %rsi, %rdi
movq %rdx, %rsi
... | /srz-zumix[P]iutest/include/listener/../internal/iutest_socket.hpp |
iutest::detail::iuOptionMessage::ShowSpec() | inline void iuOptionMessage::ShowSpec()
{
IIUT_SHOW_MACRO(IUTEST_PLATFORM);
IIUT_SHOW_MACRO(IUTEST_CHECK_STRICT);
IIUT_SHOW_MACRO(IUTEST_CPLUSPLUS);
IIUT_SHOW_MACRO(IUTEST_FORCE_COLORCONSOLE);
IIUT_SHOW_MACRO(IUTEST_HAS_ANALYSIS_ASSUME);
IIUT_SHOW_MACRO(IUTEST_HAS_ATTRIBUTE);
IIUT_SHOW_MACR... | pushq %r15
pushq %r14
pushq %rbx
leaq 0xabec(%rip), %rbx # 0x25206
leaq 0xb114(%rip), %rsi # 0x25735
leaq 0xb11d(%rip), %rdx # 0x25745
movq %rbx, %rdi
xorl %eax, %eax
callq 0x150f6
leaq 0xb114(%rip), %rsi # 0x2574d
leaq 0xb4a0(%rip), %r14 # 0x25ae0
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %ea... | /srz-zumix[P]iutest/include/internal/iutest_option_message.hpp |
iutest::TestSuite::testsuite_name_with_where[abi:cxx11]() const | ::std::string testsuite_name_with_where() const
{
::std::string str = m_testsuite_name;
if( type_param() != NULL )
{
str += ", where TypeParam = ";
str += type_param();
}
return str;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x15618
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testq %rax, %rax
je 0x1af49
leaq 0xb152(%rip), %rsi # 0x2607f
movq %rbx, %rdi
callq 0... | /srz-zumix[P]iutest/include/internal/../iutest_suite.hpp |
iutest::TestInfo::test_name_with_where[abi:cxx11]() const | ::std::string test_name_with_where() const
{
::std::string str = m_testname;
if( value_param() != NULL )
{
str += ", where GetParam() = ";
str += m_value_param;
}
return str;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x15618
cmpq $0x0, 0x28(%r14)
je 0x1afbe
cmpq $0x0, 0x20(%r14)
je 0x1afbe
leaq 0xb0ee(%rip), %rsi # 0x26094
movq %rbx, %rdi
callq 0x105a0
movq 0x20(%... | /srz-zumix[P]iutest/include/internal/../iutest_info.hpp |
iutest::detail::FormatCxxException[abi:cxx11](char const*) | inline ::std::string FormatCxxException(const char* description)
{
iu_stringstream strm;
if( description != NULL )
{
strm << "C++ exception with description \"" << description << "\"";
}
else
{
strm << "Unknown C++ exception";
}
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10220
leaq 0x18(%rsp), %r14
testq %r15, %r15
je 0x1c859
leaq 0x9882(%rip), %rsi # 0x260aa
movl $0x20, %edx
movq %r14, %rdi
callq 0x10380
movq %r15, %rdi
callq 0x10140
movq %r14, ... | /srz-zumix[P]iutest/include/internal/iutest_exception.hpp |
iutest::UnitTestImpl::ValidateTestPropertyName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static bool ValidateTestPropertyName(const ::std::string& name)
{
const char* ban[] = {
"name", "tests", "failures", "disabled", "skip", "errors", "time", "timestamp", "random_seed"
};
#if !defined(IUTEST_NO_FUNCTION_TEMPLATE_ORDERING)
return TestProperty::ValidateName(name, ban)... | pushq %rbx
subq $0x50, %rsp
movq %rdi, %rdx
leaq 0x1061f(%rip), %rsi # 0x2e5b0
movq %rsp, %rax
movl $0x9, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
leaq 0x48(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1e84c
cmpq %rbx, %rax
sete %al
addq $0x50, %rsp
popq %rbx
retq
nop
| /srz-zumix[P]iutest/include/internal/iutest_core_impl.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<int>(int const&) | iuStreamMessage& operator << (const T& value)
{
#if !defined(IUTEST_NO_ARGUMENT_DEPENDENT_LOOKUP)
m_stream << PrintToString(value);
#else
m_stream << value;
#endif
return *this;
} | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x164aa
leaq 0x30(%rsp), %rdi
movl (%r14), %esi
callq 0x10530
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x104b0
leaq 0x10(%rbx), %r14
leaq 0xe295(%rip), %rsi # 0x2e898
leaq 0x20(%rsp), %rd... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char const*>(char const* const&) | iuStreamMessage& operator << (const T& value)
{
#if !defined(IUTEST_NO_ARGUMENT_DEPENDENT_LOOKUP)
m_stream << PrintToString(value);
#else
m_stream << value;
#endif
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x20716
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x10380
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x206e3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x102f0... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char const*>(char const* const&) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x164aa
movq (%r14), %r15
leaq 0x30(%rsp), %r14
testq %r15, %r15
je 0x20785
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x10140
leaq (%rax,%r15), %rdx... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_printers.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<unsigned long>(unsigned long const&) | iuStreamMessage& operator << (const T& value)
{
#if !defined(IUTEST_NO_ARGUMENT_DEPENDENT_LOOKUP)
m_stream << PrintToString(value);
#else
m_stream << value;
#endif
return *this;
} | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x164aa
leaq 0x30(%rsp), %rdi
movq (%r14), %rsi
callq 0x10210
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x104b0
leaq 0x10(%rbx), %r14
leaq 0xdea3(%rip), %rsi # 0x2e898
leaq 0x20(%rsp), %rd... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
iutest::TestInfo::Mediator::HasFatalFailure() const | TestInfo* ptr() const IUTEST_CXX_NOEXCEPT_SPEC { return m_test_info; } | movq 0x8(%rdi), %rax
movq 0x40(%rax), %rdx
movq 0x48(%rax), %rcx
cmpq %rcx, %rdx
je 0x2106d
addq $0x30, %rdx
cmpl $0x2, -0x4(%rdx)
sete %al
je 0x2106c
leaq 0x30(%rdx), %rsi
cmpq %rcx, %rdx
movq %rsi, %rdx
jne 0x21057
retq
xorl %eax, %eax
retq
| /srz-zumix[P]iutest/include/internal/../internal/iutest_mediator.hpp |
iutest::TestInfo::Mediator::HasNonfatalFailure() const | TestInfo* ptr() const IUTEST_CXX_NOEXCEPT_SPEC { return m_test_info; } | movq 0x8(%rdi), %rax
movq 0x40(%rax), %rdx
movq 0x48(%rax), %rcx
cmpq %rcx, %rdx
je 0x2109b
addq $0x30, %rdx
cmpl $0x1, -0x4(%rdx)
sete %al
je 0x2109a
leaq 0x30(%rdx), %rsi
cmpq %rcx, %rdx
movq %rsi, %rdx
jne 0x21085
retq
xorl %eax, %eax
retq
| /srz-zumix[P]iutest/include/internal/../internal/iutest_mediator.hpp |
iutest::AssertionResult& iutest::AssertionResult::operator<<<char [17]>(char const (&) [17]) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x164aa
movq %r15, %rdi
movq %r14, %rsi
callq 0x21632
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x104b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rd... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::AssertionResult& iutest::AssertionResult::operator<<<char const*>(char const* const&) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x164aa
movq %r15, %rdi
movq %r14, %rsi
callq 0x2069e
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x104b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rd... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::AssertionResult& iutest::AssertionResult::operator<<<char [12]>(char const (&) [12]) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x164aa
movq %r15, %rdi
movq %r14, %rsi
callq 0x2178e
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x104b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rd... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::AssertionResult& iutest::AssertionResult::operator<<<char [16]>(char const (&) [16]) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x164aa
movq %r15, %rdi
movq %r14, %rsi
callq 0x218ea
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x104b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rd... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char, 12ul>(char const (&) [12ul]) | iuStreamMessage& operator << (const T(&value)[SIZE])
{
m_stream << PrintToString(value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x21806
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x10380
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x217d3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x102f0... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char, 8ul>(char const (&) [8ul]) | iuStreamMessage& operator << (const T(&value)[SIZE])
{
m_stream << PrintToString(value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x2249a
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x10380
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22467
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x102f0... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char, 10ul>(char const (&) [10ul]) | iuStreamMessage& operator << (const T(&value)[SIZE])
{
m_stream << PrintToString(value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x22752
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x10380
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2271f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x102f0... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char [10]>(char const (&) [10]) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x164aa
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x10140
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x160e6
leaq 0x38(%rsp), %rsi
leaq ... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_printers.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char [9]>(char const (&) [9]) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x164aa
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x10140
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x160e6
leaq 0x38(%rsp), %rsi
leaq ... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_printers.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char, 35ul>(char const (&) [35ul]) | iuStreamMessage& operator << (const T(&value)[SIZE])
{
m_stream << PrintToString(value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x22c40
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x10380
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22c0d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x102f0... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char [5]>(char const (&) [5]) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x164aa
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x10140
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x160e6
leaq 0x38(%rsp), %rsi
leaq ... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_printers.hpp |
testing::internal::(anonymous namespace)::UnitTestFilter::MatchesName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool MatchesName(const std::string& name) const {
return exact_match_patterns_.find(name) != exact_match_patterns_.end() ||
std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
[&name](const std::string& pattern) {
return PatternMatchesString(
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
addq $0x18, %rdi
callq 0x1ec44
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0xbd15
movq (%r14), %rbx
movq 0x8(%r14), %r12
leaq -0x38(%rbp), %r14
movq %r15, (%r14)
movq %r12, -0x30(%r... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::PositiveAndNegativeUnitTestFilter::PositiveAndNegativeUnitTestFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filter) {
std::vector<std::string> positive_and_negative_filters;
// NOTE: `SplitString` always returns a non-empty container.
SplitString(filter, '-', &positive_and_negative_filters);
const auto& positive_filter = positive_and_negative_filt... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x48(%rdi), %rax
movq %rax, 0x18(%rdi)
pushq $0x1
popq %rax
movq %rax, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
movl $0x3f800000, %ecx # ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::CalculateOptimalEdits(std::vector<unsigned long, std::allocator<unsigned long>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
const std::vector<size_t>& right) {
std::vector<std::vector<double> > costs(
left.size() + 1, std::vector<double>(right.size() + 1));
std::vector<std::vector<EditType> > best_move(
le... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %r13
movq (%rsi), %rbx
movq 0x8(%rsi), %r12
movq 0x8(%rdx), %rsi
movq %rdx, -0x38(%rbp)
subq (%rdx), %rsi
sarq $0x3, %rsi
incq %rsi
leaq -0x50(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x1b61e
su... | /alk[P]gperftools/vendor/googletest/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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rcx, -0x48(%rbp)
movq %rsi, %r12
movq %rdi, %r15
leaq -0x68(%rbp), %rdi
movq %rdx, -0xe0(%rbp)
callq 0xd003
leaq -0x268(%rbp), %rdi
callq 0x7370
leaq -0xd8(%rbp), %rbx
pushq $0x20
popq %r14... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestResult(std::ostream*, testing::TestResult const&) | void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream,
const TestResult& result) {
int failures = 0;
int skips = 0;
for (int i = 0; i < result.total_part_count(); ++i) {
const TestPartResult& part = result.GetTestPartResult(i);
if (par... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, -0x2c(%rbp)
leaq -0x88(%rbp), %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
movq %rsi, -0x48(%rbp)
movq %rdi, -0x38(%rbp)
movq 0x40(%rbx), %rax
subq 0x38(%rbx), %rax
cqto
pushq $0x70
... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator... | void JsonUnitTestResultPrinter::OutputJsonKey(std::ostream* stream,
const std::string& element_name,
const std::string& name,
const std::string& value,
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, %r13
movq %rcx, -0x38(%rbp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %r15
movq %r15, %rdi
callq 0x13840
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %r12, %rdx
call... | /alk[P]gperftools/vendor/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.push_back('%');
result.append(String::FormatByt... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x7200
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x78c0
movabsq $0x2000006000000400... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::TempDir[abi:cxx11]() | std::string TempDir() {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#elif defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_WINDOWS_MOBILE)
return GetDirFromEnv({"TEST_TMPDIR", "TEMP"}, "\\temp\\", '\\');
#elif defined(GTEST_OS_LINUX_ANDROID)
return GetDirFromEnv({"TEST_TMPDIR... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x130a7(%rip), %rax # 0x2cbaf
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x1309e(%rip), %rax # 0x2cbb4
movq %rax, 0x8(%rsi)
leaq 0x10b14(%rip), %rcx # 0x2a635
pushq $0x2
popq %rdx
callq 0x19b33
movq %rbx, %rax
addq $0x18, %rsp
po... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
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 g... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x74f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char const*>(char const* const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xca14
movq %r15, %rdi
movq %r14, %rsi
callq 0x9e52
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8e72
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1b953
movq (%rdi), %rax
callq ... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [6]>(char const (&) [6]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xca14
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x74f0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x8e72
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1b9c... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [100]>(char const (&) [100]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xca14
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x74f0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x8e72
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1bcc... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [106]>(char const (&) [106]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xca14
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x74f0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x8e72
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1bd2... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.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 g... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x74f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-message.h |
int testing::internal::CountIf<std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>>, bool (*)(testing::TestInfo const*)>(std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>> const&, bool (*)(testing::TestInfo 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 (auto it = c.begin(); it != c.end(); ++it) {
if (predicate(*it)) ++count;
}
return count;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
xorl %r15d, %r15d
cmpq 0x8(%r14), %r12
je 0x1cfe4
movq (%r12), %rdi
callq *%rbx
movzbl %al, %eax
addl %eax, %r15d
addq $0x8, %r12
jmp 0x1cfcc
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.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 file with a single "0... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0xef3a(%rip), %rax # 0x2c3df
cmoveq %rax, %rsi
leaq -0x9(%rbp), %rdx
callq 0x86a2
cmpq $0x0, 0x8(%rbx)
je 0x1d4de
movq (%rbx), %rdi
leaq 0xf5b4(%rip), %rsi # 0x2ca77
callq 0x7640
movq %rax, %rbx
pushq $0x30
popq %rdi
movq %... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<wchar_t>(int*, wchar_t**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
std::string flagfile_value;
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseFlag;
bool remove_flag = false;
if (ParseGo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
pushq $0x1
popq %r13
cmpl (%r14), %r13d
jge 0x1e053
movslq %r13d, %r15
leaq (%rbx,%r15,8), %rsi
leaq -0... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
void testing::internal::InitGoogleTestImpl<char>(int*, char**) | void InitGoogleTestImpl(int* argc, CharType** argv) {
// We don't want to run the initialization code twice.
if (GTestIsInitialized()) return;
if (*argc <= 0) return;
g_argvs.clear();
for (int i = 0; i != *argc; i++) {
g_argvs.push_back(StreamableToString(argv[i]));
}
#ifdef GTEST_HAS_ABSL
absl::In... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %r14
callq 0x19151
testb %al, %al
jne 0x1e124
cmpl $0x0, (%r14)
jle 0x1e124
leaq 0x225e6(%rip), %r15 # 0x406b0
movq %r15, %rdi
callq 0x23dae
xorl %ebx, %ebx
leaq -0x50(%rbp), %r12
movq %r13,... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
void testing::internal::InitGoogleTestImpl<wchar_t>(int*, wchar_t**) | void InitGoogleTestImpl(int* argc, CharType** argv) {
// We don't want to run the initialization code twice.
if (GTestIsInitialized()) return;
if (*argc <= 0) return;
g_argvs.clear();
for (int i = 0; i != *argc; i++) {
g_argvs.push_back(StreamableToString(argv[i]));
}
#ifdef GTEST_HAS_ABSL
absl::In... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %r14
callq 0x19151
testb %al, %al
jne 0x1e1ce
cmpl $0x0, (%r14)
jle 0x1e1ce
leaq 0x2253c(%rip), %r15 # 0x406b0
movq %r15, %rdi
callq 0x23dae
xorl %ebx, %ebx
leaq -0x50(%rbp), %r12
movq %r13,... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<testing::TestPartResult>(testing::TestPartResult const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xca14
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x291a3
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x8e72
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1ee... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [14]>(char const (&) [14]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xca14
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x74f0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x8e72
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1eef... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd2a9(%rip), %rsi # 0x2d14d
leaq -0x60(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x86a2
movq 0x20(%r14), %rdx
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x9ed9
leaq -0x40(%rbp), %rsi
... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::FloatingPoint<float>::AlmostEquals(testing::internal::FloatingPoint<float> const&) const | Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } | movl (%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx # imm = 0x7F800000
sete %cl
testl $0x7fffff, %eax # imm = 0x7FFFFF
setne %al
testb %al, %cl
jne 0x21a00
movl (%rsi), %eax
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx # imm = 0x7F800000
sete %cl
testl $0x7fffff, %eax # ... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::GTestFlagSaver::~GTestFlagSaver() | ~GTestFlagSaver() {
GTEST_FLAG_SET(also_run_disabled_tests, also_run_disabled_tests_);
GTEST_FLAG_SET(break_on_failure, break_on_failure_);
GTEST_FLAG_SET(catch_exceptions, catch_exceptions_);
GTEST_FLAG_SET(color, color_);
GTEST_FLAG_SET(death_test_style, death_test_style_);
GTEST_FLAG_SET(deat... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movb (%rdi), %al
movb %al, 0x1e005(%rip) # 0x405e3
movb 0x1(%rdi), %al
movb %al, 0x1dffd(%rip) # 0x405e4
movb 0x2(%rdi), %al
movb %al, 0x1dff5(%rip) # 0x405e5
leaq 0x8(%rdi), %rsi
leaq 0x1df... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<char*>(char* const&) | std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xca14
movq %r15, %rdi
movq %r14, %rsi
callq 0x23d14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xcbe4
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x23ceb
movq (%rdi), %rax
callq... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char>(char* const&) | inline Message& operator<<(T* const& pointer) { // NOLINT
if (pointer == nullptr) {
*ss_ << "(null)";
} else {
*ss_ << pointer;
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rdi), %rdi
addq $0x10, %rdi
testq %rax, %rax
leaq 0x69b5(%rip), %rsi # 0x2a6e6
cmovneq %rax, %rsi
callq 0x74f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::DeathTestAbort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | [[noreturn]] 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... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1b4b8
movq 0x2a8(%rax), %rax
testq %rax, %rax
jne 0x23f30
movq 0x1c0b0(%rip), %r14 # 0x3ffc8
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x75c0
movq (%r14), %rdi
callq 0x7630
callq 0x9fdc
movl 0x28(%rax), %edi
leaq 0x8b3d(%rip), %rsi # 0x2c... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::Passed(bool) | bool DeathTestImpl::Passed(bool status_ok) {
if (!spawned()) return false;
const std::string error_message = GetErrorLogs();
bool success = false;
Message buffer;
buffer << "Death test: " << statement() << "\n";
switch (outcome()) {
case LIVED:
buffer << " Result: failed to die.\n"
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
cmpb $0x1, 0x28(%rdi)
jne 0x24807
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq *0x30(%rax)
leaq -0x18(%rbp), %rdi
callq 0xca14
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq 0x973... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-death-test.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.