name
string | code
string | asm
string | file
string |
|---|---|---|---|
ncnn::ModelBinFromStdio::load(int, int) const
|
Mat ModelBinFromStdio::load(int w, int type) const
{
if (!binfp)
return Mat();
if (type == 0)
{
int nread;
union
{
struct
{
unsigned char f0;
unsigned char f1;
unsigned char f2;
unsigned char f3;
};
unsigned int tag;
} flag_struct;
nread = fread(&flag_struct, sizeof(flag_struct), 1, binfp);
if (nread != 1)
{
fprintf(stderr, "ModelBin read flag_struct failed %d\n", nread);
return Mat();
}
unsigned int flag = flag_struct.f0 + flag_struct.f1 + flag_struct.f2 + flag_struct.f3;
if (flag_struct.tag == 0x01306B47)
{
// half-precision data
int align_data_size = alignSize(w * sizeof(unsigned short), 4);
std::vector<unsigned short> float16_weights;
float16_weights.resize(align_data_size);
nread = fread(float16_weights.data(), align_data_size, 1, binfp);
if (nread != 1)
{
fprintf(stderr, "ModelBin read float16_weights failed %d\n", nread);
return Mat();
}
return Mat::from_float16(float16_weights.data(), w);
}
else if (flag_struct.tag == 0x000D4B38)
{
// int8 data
int align_data_size = alignSize(w, 4);
std::vector<signed char> int8_weights;
int8_weights.resize(align_data_size);
nread = fread(int8_weights.data(), align_data_size, 1, binfp);
if (nread != 1)
{
fprintf(stderr, "ModelBin read int8_weights failed %d\n", nread);
return Mat();
}
Mat m(w, (size_t)1u);
if (m.empty())
return m;
memcpy(m.data, int8_weights.data(), w);
return m;
}
else if (flag_struct.tag == 0x0002C056)
{
Mat m(w);
if (m.empty())
return m;
// raw data with extra scaling
nread = fread(m, w * sizeof(float), 1, binfp);
if (nread != 1)
{
fprintf(stderr, "ModelBin read weight_data failed %d\n", nread);
return Mat();
}
return m;
}
Mat m(w);
if (m.empty())
return m;
if (flag != 0)
{
// quantized data
float quantization_value[256];
nread = fread(quantization_value, 256 * sizeof(float), 1, binfp);
if (nread != 1)
{
fprintf(stderr, "ModelBin read quantization_value failed %d\n", nread);
return Mat();
}
int align_weight_data_size = alignSize(w * sizeof(unsigned char), 4);
std::vector<unsigned char> index_array;
index_array.resize(align_weight_data_size);
nread = fread(index_array.data(), align_weight_data_size, 1, binfp);
if (nread != 1)
{
fprintf(stderr, "ModelBin read index_array failed %d\n", nread);
return Mat();
}
float* ptr = m;
for (int i = 0; i < w; i++)
{
ptr[i] = quantization_value[ index_array[i] ];
}
}
else if (flag_struct.f0 == 0)
{
// raw data
nread = fread(m, w * sizeof(float), 1, binfp);
if (nread != 1)
{
fprintf(stderr, "ModelBin read weight_data failed %d\n", nread);
return Mat();
}
}
return m;
}
else if (type == 1)
{
Mat m(w);
if (m.empty())
return m;
// raw data
int nread = fread(m, w * sizeof(float), 1, binfp);
if (nread != 1)
{
fprintf(stderr, "ModelBin read weight_data failed %d\n", nread);
return Mat();
}
return m;
}
else
{
fprintf(stderr, "ModelBin load type %d not implemented\n", type);
return Mat();
}
return Mat();
}
|
subq $0x648, %rsp # imm = 0x648
movq %rdi, 0xc0(%rsp)
movq %rdi, %rax
movq %rax, 0xc8(%rsp)
movq %rdi, 0x640(%rsp)
movq %rsi, 0x638(%rsp)
movl %edx, 0x634(%rsp)
movl %ecx, 0x630(%rsp)
movq 0x638(%rsp), %rax
movq %rax, 0xd0(%rsp)
cmpq $0x0, 0x8(%rax)
jne 0x24561
movq 0xc0(%rsp), %rdi
callq 0x15850
jmp 0x24ff2
cmpl $0x0, 0x630(%rsp)
jne 0x24e6b
movq 0xd0(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0x628(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x14370
movl %eax, 0x62c(%rsp)
cmpl $0x1, 0x62c(%rsp)
je 0x245d4
movq 0x9ba36(%rip), %rax # 0xbffe0
movq (%rax), %rdi
movl 0x62c(%rsp), %edx
leaq 0x7a570(%rip), %rsi # 0x9eb2b
movb $0x0, %al
callq 0x14310
movq 0xc0(%rsp), %rdi
callq 0x15850
jmp 0x24ff2
movzbl 0x628(%rsp), %eax
movzbl 0x629(%rsp), %ecx
addl %ecx, %eax
movzbl 0x62a(%rsp), %ecx
addl %ecx, %eax
movzbl 0x62b(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x624(%rsp)
cmpl $0x1306b47, 0x628(%rsp) # imm = 0x1306B47
jne 0x2474f
movslq 0x634(%rsp), %rdi
addq %rdi, %rdi
movl $0x4, %esi
callq 0x25010
movl %eax, 0x620(%rsp)
leaq 0x608(%rsp), %rdi
movq %rdi, 0xb8(%rsp)
callq 0x25c40
movq 0xb8(%rsp), %rdi
movslq 0x620(%rsp), %rsi
callq 0x25c50
jmp 0x2465a
leaq 0x608(%rsp), %rdi
callq 0x25cf0
movq %rax, %rdi
movq 0xd0(%rsp), %rax
movslq 0x620(%rsp), %rsi
movq 0x8(%rax), %rcx
movl $0x1, %edx
callq 0x14370
movq %rax, 0xb0(%rsp)
jmp 0x24692
movq 0xb0(%rsp), %rax
movl %eax, 0x62c(%rsp)
cmpl $0x1, 0x62c(%rsp)
je 0x2470c
movq 0x9b92e(%rip), %rax # 0xbffe0
movq (%rax), %rdi
movl 0x62c(%rsp), %edx
leaq 0x7a48d(%rip), %rsi # 0x9eb50
xorl %eax, %eax
callq 0x14310
movq 0xc0(%rsp), %rdi
callq 0x15850
jmp 0x246d9
movl $0x1, 0x5f8(%rsp)
jmp 0x2473d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x600(%rsp)
movl %eax, 0x5fc(%rsp)
leaq 0x608(%rsp), %rdi
callq 0x25d10
jmp 0x25002
leaq 0x608(%rsp), %rdi
callq 0x25cf0
movq 0xc0(%rsp), %rdi
movq %rax, %rsi
movl 0x634(%rsp), %edx
callq 0x9cac0
jmp 0x24732
movl $0x1, 0x5f8(%rsp)
leaq 0x608(%rsp), %rdi
callq 0x25d10
jmp 0x24ff2
cmpl $0xd4b38, 0x628(%rsp) # imm = 0xD4B38
jne 0x24957
movslq 0x634(%rsp), %rdi
movl $0x4, %esi
callq 0x25010
movl %eax, 0x5f4(%rsp)
leaq 0x5d8(%rsp), %rdi
movq %rdi, 0xa8(%rsp)
callq 0x25d70
movq 0xa8(%rsp), %rdi
movslq 0x5f4(%rsp), %rsi
callq 0x25d80
jmp 0x247a5
leaq 0x5d8(%rsp), %rdi
callq 0x25e20
movq %rax, %rdi
movq 0xd0(%rsp), %rax
movslq 0x5f4(%rsp), %rsi
movq 0x8(%rax), %rcx
movl $0x1, %edx
callq 0x14370
movq %rax, 0xa0(%rsp)
jmp 0x247dd
movq 0xa0(%rsp), %rax
movl %eax, 0x62c(%rsp)
cmpl $0x1, 0x62c(%rsp)
je 0x2484d
movq 0x9b7e3(%rip), %rax # 0xbffe0
movq (%rax), %rdi
movl 0x62c(%rsp), %edx
leaq 0x7a36b(%rip), %rsi # 0x9eb79
xorl %eax, %eax
callq 0x14310
movq 0xc0(%rsp), %rdi
callq 0x15850
jmp 0x24824
movl $0x1, 0x5f8(%rsp)
jmp 0x24933
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x600(%rsp)
movl %eax, 0x5fc(%rsp)
jmp 0x24945
movq 0xc0(%rsp), %rdi
movb $0x0, 0x5d7(%rsp)
movl 0x634(%rsp), %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
callq 0x15ae0
jmp 0x24874
movq 0xc0(%rsp), %rdi
callq 0x1b5a0
movb %al, 0x9f(%rsp)
jmp 0x2488a
movb 0x9f(%rsp), %al
testb $0x1, %al
jne 0x24897
jmp 0x248cf
movb $0x1, 0x5d7(%rsp)
movl $0x1, 0x5f8(%rsp)
jmp 0x2491a
movq 0xc0(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x600(%rsp)
movl %eax, 0x5fc(%rsp)
callq 0x15950
jmp 0x24945
movq 0xc0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x90(%rsp)
leaq 0x5d8(%rsp), %rdi
callq 0x25e20
movq 0x90(%rsp), %rdi
movq %rax, %rsi
movslq 0x634(%rsp), %rdx
callq 0x141a0
movb $0x1, 0x5d7(%rsp)
movl $0x1, 0x5f8(%rsp)
testb $0x1, 0x5d7(%rsp)
jne 0x24931
movq 0xc0(%rsp), %rdi
callq 0x15950
jmp 0x24933
leaq 0x5d8(%rsp), %rdi
callq 0x25e40
jmp 0x24ff2
leaq 0x5d8(%rsp), %rdi
callq 0x25e40
jmp 0x25002
cmpl $0x2c056, 0x628(%rsp) # imm = 0x2C056
jne 0x24ac4
movl 0x634(%rsp), %esi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x590(%rsp), %rdi
movq %rdi, 0x80(%rsp)
movl $0x4, %edx
callq 0x15ae0
movq 0x80(%rsp), %rdi
callq 0x1b5a0
movb %al, 0x8f(%rsp)
jmp 0x249a3
movb 0x8f(%rsp), %al
testb $0x1, %al
jne 0x249b0
jmp 0x249fd
movq 0xc0(%rsp), %rdi
leaq 0x590(%rsp), %rsi
callq 0x23b80
jmp 0x249c7
movl $0x1, 0x5f8(%rsp)
jmp 0x24ab2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x600(%rsp)
movl %eax, 0x5fc(%rsp)
leaq 0x590(%rsp), %rdi
callq 0x15950
jmp 0x25002
leaq 0x590(%rsp), %rdi
callq 0x25ea0
movq %rax, 0x78(%rsp)
jmp 0x24a11
movq 0x78(%rsp), %rdi
movq 0xd0(%rsp), %rax
movslq 0x634(%rsp), %rsi
shlq $0x2, %rsi
movq 0x8(%rax), %rcx
movl $0x1, %edx
callq 0x14370
movq %rax, 0x70(%rsp)
jmp 0x24a3f
movq 0x70(%rsp), %rax
movl %eax, 0x62c(%rsp)
cmpl $0x1, 0x62c(%rsp)
je 0x24a90
movq 0x9b584(%rip), %rax # 0xbffe0
movq (%rax), %rdi
movl 0x62c(%rsp), %edx
leaq 0x7a132(%rip), %rsi # 0x9eb9f
xorl %eax, %eax
callq 0x14310
movq 0xc0(%rsp), %rdi
callq 0x15850
jmp 0x24a83
movl $0x1, 0x5f8(%rsp)
jmp 0x24ab2
movq 0xc0(%rsp), %rdi
leaq 0x590(%rsp), %rsi
callq 0x23b80
jmp 0x24aa7
movl $0x1, 0x5f8(%rsp)
leaq 0x590(%rsp), %rdi
callq 0x15950
jmp 0x24ff2
jmp 0x24ac6
jmp 0x24ac8
movl 0x634(%rsp), %esi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x550(%rsp), %rdi
movq %rdi, 0x60(%rsp)
movl $0x4, %edx
callq 0x15ae0
movq 0x60(%rsp), %rdi
callq 0x1b5a0
movb %al, 0x6f(%rsp)
jmp 0x24afa
movb 0x6f(%rsp), %al
testb $0x1, %al
jne 0x24b04
jmp 0x24b44
movq 0xc0(%rsp), %rdi
leaq 0x550(%rsp), %rsi
callq 0x23b80
jmp 0x24b1b
movl $0x1, 0x5f8(%rsp)
jmp 0x24e47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x600(%rsp)
movl %eax, 0x5fc(%rsp)
jmp 0x24e59
cmpl $0x0, 0x624(%rsp)
je 0x24d7d
movq 0xd0(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0x150(%rsp), %rdi
movl $0x400, %esi # imm = 0x400
movl $0x1, %edx
callq 0x14370
movq %rax, 0x58(%rsp)
jmp 0x24b7c
movq 0x58(%rsp), %rax
movl %eax, 0x62c(%rsp)
cmpl $0x1, 0x62c(%rsp)
je 0x24bd0
movq 0x9b447(%rip), %rax # 0xbffe0
movq (%rax), %rdi
movl 0x62c(%rsp), %edx
leaq 0x7a01a(%rip), %rsi # 0x9ebc4
xorl %eax, %eax
callq 0x14310
movq 0xc0(%rsp), %rdi
callq 0x15850
jmp 0x24bc0
movl $0x1, 0x5f8(%rsp)
jmp 0x24e47
movslq 0x634(%rsp), %rdi
movl $0x4, %esi
callq 0x25010
movq %rax, 0x50(%rsp)
jmp 0x24be9
movq 0x50(%rsp), %rax
movl %eax, 0x14c(%rsp)
leaq 0x130(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x25eb0
movq 0x48(%rsp), %rdi
movslq 0x14c(%rsp), %rsi
callq 0x25ec0
jmp 0x24c1b
leaq 0x130(%rsp), %rdi
callq 0x25f60
movq %rax, %rdi
movq 0xd0(%rsp), %rax
movslq 0x14c(%rsp), %rsi
movq 0x8(%rax), %rcx
movl $0x1, %edx
callq 0x14370
movq %rax, 0x40(%rsp)
jmp 0x24c50
movq 0x40(%rsp), %rax
movl %eax, 0x62c(%rsp)
cmpl $0x1, 0x62c(%rsp)
je 0x24cca
movq 0x9b373(%rip), %rax # 0xbffe0
movq (%rax), %rdi
movl 0x62c(%rsp), %edx
leaq 0x79f72(%rip), %rsi # 0x9ebf0
xorl %eax, %eax
callq 0x14310
movq 0xc0(%rsp), %rdi
callq 0x15850
jmp 0x24c94
movl $0x1, 0x5f8(%rsp)
jmp 0x24d5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x600(%rsp)
movl %eax, 0x5fc(%rsp)
leaq 0x130(%rsp), %rdi
callq 0x25fb0
jmp 0x24e59
leaq 0x550(%rsp), %rdi
callq 0x25f80
movq %rax, 0x38(%rsp)
jmp 0x24cde
movq 0x38(%rsp), %rax
movq %rax, 0x128(%rsp)
movl $0x0, 0x124(%rsp)
movl 0x124(%rsp), %eax
cmpl 0x634(%rsp), %eax
jge 0x24d4f
movslq 0x124(%rsp), %rsi
leaq 0x130(%rsp), %rdi
callq 0x25f90
movzbl (%rax), %eax
movss 0x150(%rsp,%rax,4), %xmm0
movq 0x128(%rsp), %rax
movslq 0x124(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x124(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x124(%rsp)
jmp 0x24cf6
movl $0x0, 0x5f8(%rsp)
leaq 0x130(%rsp), %rdi
callq 0x25fb0
movl 0x5f8(%rsp), %eax
testl %eax, %eax
jne 0x24e47
jmp 0x24d78
jmp 0x24e25
movzbl 0x628(%rsp), %eax
cmpl $0x0, %eax
jne 0x24e23
leaq 0x550(%rsp), %rdi
callq 0x25ea0
movq %rax, 0x30(%rsp)
jmp 0x24da2
movq 0x30(%rsp), %rdi
movq 0xd0(%rsp), %rax
movslq 0x634(%rsp), %rsi
shlq $0x2, %rsi
movq 0x8(%rax), %rcx
movl $0x1, %edx
callq 0x14370
movq %rax, 0x28(%rsp)
jmp 0x24dd0
movq 0x28(%rsp), %rax
movl %eax, 0x62c(%rsp)
cmpl $0x1, 0x62c(%rsp)
je 0x24e21
movq 0x9b1f3(%rip), %rax # 0xbffe0
movq (%rax), %rdi
movl 0x62c(%rsp), %edx
leaq 0x79da1(%rip), %rsi # 0x9eb9f
xorl %eax, %eax
callq 0x14310
movq 0xc0(%rsp), %rdi
callq 0x15850
jmp 0x24e14
movl $0x1, 0x5f8(%rsp)
jmp 0x24e47
jmp 0x24e23
jmp 0x24e25
movq 0xc0(%rsp), %rdi
leaq 0x550(%rsp), %rsi
callq 0x23b80
jmp 0x24e3c
movl $0x1, 0x5f8(%rsp)
leaq 0x550(%rsp), %rdi
callq 0x15950
jmp 0x24ff2
leaq 0x550(%rsp), %rdi
callq 0x15950
jmp 0x25002
cmpl $0x1, 0x630(%rsp)
jne 0x24fc6
movl 0x634(%rsp), %esi
xorl %eax, %eax
movl %eax, %ecx
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x4, %edx
callq 0x15ae0
movq 0x18(%rsp), %rdi
callq 0x1b5a0
movb %al, 0x27(%rsp)
jmp 0x24eab
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x24eb5
jmp 0x24f02
movq 0xc0(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x23b80
jmp 0x24ecc
movl $0x1, 0x5f8(%rsp)
jmp 0x24fb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x600(%rsp)
movl %eax, 0x5fc(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x15950
jmp 0x25002
leaq 0xe0(%rsp), %rdi
callq 0x25ea0
movq %rax, 0x10(%rsp)
jmp 0x24f16
movq 0x10(%rsp), %rdi
movq 0xd0(%rsp), %rax
movslq 0x634(%rsp), %rsi
shlq $0x2, %rsi
movq 0x8(%rax), %rcx
movl $0x1, %edx
callq 0x14370
movq %rax, 0x8(%rsp)
jmp 0x24f44
movq 0x8(%rsp), %rax
movl %eax, 0xdc(%rsp)
cmpl $0x1, 0xdc(%rsp)
je 0x24f95
movq 0x9b07f(%rip), %rax # 0xbffe0
movq (%rax), %rdi
movl 0xdc(%rsp), %edx
leaq 0x79c2d(%rip), %rsi # 0x9eb9f
xorl %eax, %eax
callq 0x14310
movq 0xc0(%rsp), %rdi
callq 0x15850
jmp 0x24f88
movl $0x1, 0x5f8(%rsp)
jmp 0x24fb7
movq 0xc0(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x23b80
jmp 0x24fac
movl $0x1, 0x5f8(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x15950
jmp 0x24ff2
movq 0x9b013(%rip), %rax # 0xbffe0
movq (%rax), %rdi
movl 0x630(%rsp), %edx
leaq 0x79c37(%rip), %rsi # 0x9ec15
movb $0x0, %al
callq 0x14310
movq 0xc0(%rsp), %rdi
callq 0x15850
movq 0xc8(%rsp), %rax
addq $0x648, %rsp # imm = 0x648
retq
movq 0x600(%rsp), %rdi
callq 0x14410
nop
|
/tongxiaobin[P]ncnn/src/modelbin.cpp
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x25664
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x25685
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::Mat::reshape(int, int, ncnn::Allocator*) const
|
inline Mat Mat::reshape(int _w, int _h, Allocator* _allocator) const
{
if (w * h * c != _w * _h)
return Mat();
if (dims == 3 && cstep != (size_t)w * h)
{
Mat m;
m.create(_w, _h, elemsize, packing, _allocator);
// flatten
for (int i=0; i<c; i++)
{
const void* ptr = (unsigned char*)data + i * cstep * elemsize;
void* mptr = (unsigned char*)m.data + i * w * h * elemsize;
memcpy(mptr, ptr, w * h * elemsize);
}
return m;
}
Mat m = *this;
m.dims = 2;
m.w = _w;
m.h = _h;
m.c = 1;
m.cstep = _w * _h;
return m;
}
|
subq $0x68, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq 0x58(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0x2c(%rcx), %eax
imull 0x30(%rcx), %eax
imull 0x34(%rcx), %eax
movl 0x54(%rsp), %ecx
imull 0x50(%rsp), %ecx
cmpl %ecx, %eax
je 0x256e7
movq (%rsp), %rdi
callq 0x15850
jmp 0x25858
movq 0x10(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x257fe
movq 0x10(%rsp), %rdx
movq 0x38(%rdx), %rax
movslq 0x2c(%rdx), %rcx
movslq 0x30(%rdx), %rdx
imulq %rdx, %rcx
cmpq %rcx, %rax
je 0x257fe
movq (%rsp), %rdi
movb $0x0, 0x47(%rsp)
callq 0x15850
movq 0x10(%rsp), %rax
movq (%rsp), %rdi
movl 0x54(%rsp), %esi
movl 0x50(%rsp), %edx
movq 0x10(%rax), %rcx
movl 0x18(%rax), %r8d
movq 0x48(%rsp), %r9
callq 0x230c0
jmp 0x25747
movl $0x0, 0x30(%rsp)
movq 0x10(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0x34(%rcx), %eax
jge 0x257e7
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq (%rax), %rdx
movslq 0x30(%rsp), %rsi
imulq 0x38(%rax), %rsi
imulq 0x10(%rax), %rsi
addq %rsi, %rdx
movq %rdx, 0x28(%rsp)
movq (%rcx), %rcx
movl 0x30(%rsp), %edx
imull 0x2c(%rax), %edx
imull 0x30(%rax), %edx
movslq %edx, %rdx
imulq 0x10(%rax), %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x2c(%rax), %ecx
imull 0x30(%rax), %ecx
movslq %ecx, %rdx
imulq 0x10(%rax), %rdx
callq 0x141a0
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x2574f
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x15950
jmp 0x25862
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x257fc
movq (%rsp), %rdi
callq 0x15950
jmp 0x25858
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movb $0x0, 0x1f(%rsp)
callq 0x23b80
movq (%rsp), %rax
movl $0x2, 0x28(%rax)
movl 0x54(%rsp), %ecx
movl %ecx, 0x2c(%rax)
movl 0x50(%rsp), %ecx
movl %ecx, 0x30(%rax)
movl $0x1, 0x34(%rax)
movl 0x54(%rsp), %ecx
imull 0x50(%rsp), %ecx
movslq %ecx, %rcx
movq %rcx, 0x38(%rax)
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x25856
movq (%rsp), %rdi
callq 0x15950
jmp 0x25858
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x14410
nopl (%rax)
|
/tongxiaobin[P]ncnn/src/mat.h
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x52e25
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::Flatten::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const
|
int Flatten::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int channels = bottom_blob.c;
size_t elemsize = bottom_blob.elemsize;
int size = w * h;
top_blob.create(size * channels, elemsize, opt.blob_allocator);
if (top_blob.empty())
return -100;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
const float* ptr = bottom_blob.channel(q);
float* outptr = (float*)top_blob + size * q;
for (int i=0; i<size; i++)
{
outptr[i] = ptr[i];
}
}
return 0;
}
|
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq %rcx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x9c(%rsp)
movq 0xb0(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x98(%rsp)
movq 0xb0(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x94(%rsp)
movq 0xb0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x88(%rsp)
movl 0x9c(%rsp), %eax
imull 0x98(%rsp), %eax
movl %eax, 0x84(%rsp)
movq 0xa8(%rsp), %rdi
movl 0x84(%rsp), %esi
imull 0x94(%rsp), %esi
movq 0x88(%rsp), %rdx
movq 0xa0(%rsp), %rax
movq 0x8(%rax), %rcx
callq 0x15b60
movq 0xa8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x52fda
jmp 0x52fea
movl $0xffffff9c, 0xc4(%rsp) # imm = 0xFFFFFF9C
jmp 0x530f4
movl $0x0, 0x80(%rsp)
movl 0x80(%rsp), %eax
cmpl 0x94(%rsp), %eax
jge 0x530e9
movq 0xb0(%rsp), %rsi
movl 0x80(%rsp), %edx
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x34a30
movq 0x8(%rsp), %rdi
callq 0x34880
movq %rax, 0x10(%rsp)
jmp 0x53038
leaq 0x38(%rsp), %rdi
callq 0x15950
movq 0x10(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x25f80
movl 0x84(%rsp), %ecx
imull 0x80(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x84(%rsp), %eax
jge 0x530d1
movq 0x78(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5307f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x15950
jmp 0x53103
jmp 0x530d3
movl 0x80(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x80(%rsp)
jmp 0x52ff5
movl $0x0, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x14410
nopl (%rax)
|
/tongxiaobin[P]ncnn/src/layer/flatten.cpp
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x53174
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::InnerProduct::load_model(ncnn::ModelBin const&)
|
int InnerProduct::load_model(const ModelBin& mb)
{
weight_data = mb.load(weight_data_size, 0);
if (weight_data.empty())
return -100;
if (bias_term)
{
bias_data = mb.load(num_output, 1);
if (bias_data.empty())
return -100;
}
if (int8_scale_term)
{
weight_data_int8_scales = mb.load(num_output, 1);
bottom_blob_int8_scale = mb.load(1, 1)[0];
}
return 0;
}
|
subq $0x158, %rsp # imm = 0x158
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x140(%rsp), %rsi
movl 0x88(%rax), %edx
movq (%rsi), %rax
movq (%rax), %rax
leaq 0x100(%rsp), %rdi
movq %rdi, 0x28(%rsp)
xorl %ecx, %ecx
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0xd8, %rdi
callq 0x1b4b0
jmp 0x53521
leaq 0x100(%rsp), %rdi
callq 0x15950
movq 0x20(%rsp), %rdi
addq $0xd8, %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x53545
jmp 0x5357b
movl $0xffffff9c, 0x154(%rsp) # imm = 0xFFFFFF9C
jmp 0x5372b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0x100(%rsp), %rdi
callq 0x15950
jmp 0x5373a
movq 0x20(%rsp), %rax
cmpl $0x0, 0x84(%rax)
je 0x5362e
movq 0x20(%rsp), %rax
movq 0x140(%rsp), %rsi
movl 0x80(%rax), %edx
movq (%rsi), %rax
movq (%rax), %rax
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %ecx
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x118, %rdi # imm = 0x118
callq 0x1b4b0
jmp 0x535d2
leaq 0xb0(%rsp), %rdi
callq 0x15950
movq 0x20(%rsp), %rdi
addq $0x118, %rdi # imm = 0x118
callq 0x1b5a0
testb $0x1, %al
jne 0x535f6
jmp 0x5362c
movl $0xffffff9c, 0x154(%rsp) # imm = 0xFFFFFF9C
jmp 0x5372b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x15950
jmp 0x5373a
jmp 0x5362e
movq 0x20(%rsp), %rax
cmpl $0x0, 0x8c(%rax)
je 0x53720
movq 0x20(%rsp), %rax
movq 0x140(%rsp), %rsi
movl 0x80(%rax), %edx
movq (%rsi), %rax
movq (%rax), %rax
leaq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x1, %ecx
callq *%rax
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x158, %rdi # imm = 0x158
callq 0x1b4b0
jmp 0x53682
leaq 0x70(%rsp), %rdi
callq 0x15950
movq 0x140(%rsp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x1, %ecx
movl %ecx, %edx
callq *%rax
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x32f10
movq %rax, 0x8(%rsp)
jmp 0x536be
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movss (%rcx), %xmm0
movss %xmm0, 0x198(%rax)
leaq 0x30(%rsp), %rdi
callq 0x15950
jmp 0x53720
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x15950
jmp 0x5373a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x15950
jmp 0x5373a
movl $0x0, 0x154(%rsp)
movl 0x154(%rsp), %eax
addq $0x158, %rsp # imm = 0x158
retq
movq 0xf8(%rsp), %rdi
callq 0x14410
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/innerproduct.cpp
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x575a4
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::nms_sorted_bboxes(std::vector<ncnn::Rect, std::allocator<ncnn::Rect>> const&, std::vector<int, std::allocator<int>>&, float)
|
static void nms_sorted_bboxes(const std::vector<Rect>& bboxes, std::vector<int>& picked, float nms_threshold)
{
picked.clear();
const int n = bboxes.size();
std::vector<float> areas(n);
for (int i = 0; i < n; i++)
{
const Rect& r = bboxes[i];
float width = r.x2 - r.x1;
float height = r.y2 - r.y1;
areas[i] = width * height;
}
for (int i = 0; i < n; i++)
{
const Rect& a = bboxes[i];
int keep = 1;
for (int j = 0; j < (int)picked.size(); j++)
{
const Rect& b = bboxes[picked[j]];
// intersection over union
float inter_area = intersection_area(a, b);
float union_area = areas[i] + areas[picked[j]] - inter_area;
// float IoU = inter_area / union_area
if (inter_area / union_area > nms_threshold)
keep = 0;
}
if (keep)
picked.push_back(i);
}
}
|
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movss %xmm0, 0xa4(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x5bbe0
movq 0xb0(%rsp), %rdi
callq 0x5b940
movl %eax, 0xa0(%rsp)
movslq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x38380
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x88(%rsp), %rdi
callq 0x5bc00
jmp 0x5b2d9
leaq 0x87(%rsp), %rdi
callq 0x1c610
movl $0x0, 0x70(%rsp)
movl 0x70(%rsp), %eax
cmpl 0xa0(%rsp), %eax
jge 0x5b3a7
movq 0xb0(%rsp), %rdi
movslq 0x70(%rsp), %rsi
callq 0x5bc80
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movss 0x8(%rax), %xmm0
movq 0x68(%rsp), %rax
subss (%rax), %xmm0
movss %xmm0, 0x64(%rsp)
movq 0x68(%rsp), %rax
movss 0xc(%rax), %xmm0
movq 0x68(%rsp), %rax
subss 0x4(%rax), %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x64(%rsp), %xmm0
mulss 0x60(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movslq 0x70(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x4de80
movss 0x24(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x70(%rsp)
jmp 0x5b2ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x1c610
jmp 0x5b546
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
cmpl 0xa0(%rsp), %eax
jge 0x5b531
movq 0xb0(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0x5bc80
movq %rax, 0x50(%rsp)
movl $0x1, 0x4c(%rsp)
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x2c4a0
movq %rax, %rcx
movl 0x20(%rsp), %eax
cmpl %ecx, %eax
jge 0x5b502
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xa8(%rsp), %rdi
movslq 0x48(%rsp), %rsi
callq 0x2c280
movq 0x10(%rsp), %rdi
movslq (%rax), %rsi
callq 0x5bc80
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x5b5e0
movss %xmm0, 0x1c(%rsp)
jmp 0x5b453
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x3c(%rsp)
movslq 0x5c(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x4de80
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0xa8(%rsp), %rdi
movslq 0x48(%rsp), %rsi
callq 0x2c280
movslq (%rax), %rsi
leaq 0x88(%rsp), %rdi
callq 0x4de80
movss 0xc(%rsp), %xmm0
addss (%rax), %xmm0
subss 0x3c(%rsp), %xmm0
movss %xmm0, 0x38(%rsp)
movss 0x3c(%rsp), %xmm0
divss 0x38(%rsp), %xmm0
ucomiss 0xa4(%rsp), %xmm0
jbe 0x5b4f0
movl $0x0, 0x4c(%rsp)
jmp 0x5b4f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1c3e0
jmp 0x5b546
jmp 0x5b4f2
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x5b3e7
cmpl $0x0, 0x4c(%rsp)
je 0x5b51f
movq 0xa8(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x2c210
jmp 0x5b51d
jmp 0x5b51f
jmp 0x5b521
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x5b3af
leaq 0x88(%rsp), %rdi
callq 0x1c3e0
addq $0xb8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x14410
|
/tongxiaobin[P]ncnn/src/layer/proposal.cpp
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x62825
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::ReLU::forward_inplace(ncnn::Mat&, ncnn::Option const&) const
|
int ReLU::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
if (bottom_top_blob.elemsize == 1u)
return ReLU::forward_inplace_int8(bottom_top_blob, opt);
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
if (slope == 0.f)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
float* ptr = bottom_top_blob.channel(q);
for (int i=0; i<size; i++)
{
if (ptr[i] < 0)
ptr[i] = 0;
}
}
}
else
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
float* ptr = bottom_top_blob.channel(q);
for (int i=0; i<size; i++)
{
if (ptr[i] < 0)
ptr[i] *= slope;
}
}
}
return 0;
}
|
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0xf8(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x100(%rsp), %rax
cmpq $0x1, 0x10(%rax)
jne 0x62cc1
movq 0x28(%rsp), %rdi
movq 0x100(%rsp), %rsi
movq 0xf8(%rsp), %rdx
callq 0x62b00
movl %eax, 0x114(%rsp)
jmp 0x62f3e
movq 0x28(%rsp), %rax
movq 0x100(%rsp), %rcx
movl 0x2c(%rcx), %ecx
movl %ecx, 0xf4(%rsp)
movq 0x100(%rsp), %rcx
movl 0x30(%rcx), %ecx
movl %ecx, 0xf0(%rsp)
movq 0x100(%rsp), %rcx
movl 0x34(%rcx), %ecx
movl %ecx, 0xec(%rsp)
movl 0xf4(%rsp), %ecx
imull 0xf0(%rsp), %ecx
movl %ecx, 0xe8(%rsp)
movss 0x80(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x62e3d
jp 0x62e3d
movl $0x0, 0xe4(%rsp)
movl 0xe4(%rsp), %eax
cmpl 0xec(%rsp), %eax
jge 0x62e38
movq 0x100(%rsp), %rsi
movl 0xe4(%rsp), %edx
leaq 0x98(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x322b0
movq 0x18(%rsp), %rdi
callq 0x25f80
movq %rax, 0x20(%rsp)
jmp 0x62d7d
leaq 0x98(%rsp), %rdi
callq 0x15950
movq 0x20(%rsp), %rax
movq %rax, 0xd8(%rsp)
movl $0x0, 0x88(%rsp)
movl 0x88(%rsp), %eax
cmpl 0xe8(%rsp), %eax
jge 0x62e20
movq 0xd8(%rsp), %rax
movslq 0x88(%rsp), %rcx
xorps %xmm0, %xmm0
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x62e0b
movq 0xd8(%rsp), %rax
movslq 0x88(%rsp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x62e0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x15950
jmp 0x62f4d
jmp 0x62e0d
movl 0x88(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x88(%rsp)
jmp 0x62da2
jmp 0x62e22
movl 0xe4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe4(%rsp)
jmp 0x62d37
jmp 0x62f33
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
cmpl 0xec(%rsp), %eax
jge 0x62f31
movq 0x100(%rsp), %rsi
movl 0x84(%rsp), %edx
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x322b0
movq 0x8(%rsp), %rdi
callq 0x25f80
movq %rax, 0x10(%rsp)
jmp 0x62e8b
leaq 0x38(%rsp), %rdi
callq 0x15950
movq 0x10(%rsp), %rax
movq %rax, 0x78(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0xe8(%rsp), %eax
jge 0x62f19
movq 0x78(%rsp), %rax
movslq 0x34(%rsp), %rcx
xorps %xmm0, %xmm0
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x62f0a
movq 0x28(%rsp), %rax
movss 0x80(%rax), %xmm0
movq 0x78(%rsp), %rax
movslq 0x34(%rsp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x62f0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x15950
jmp 0x62f4d
jmp 0x62f0c
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x62ea7
jmp 0x62f1b
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x62e48
jmp 0x62f33
movl $0x0, 0x114(%rsp)
movl 0x114(%rsp), %eax
addq $0x118, %rsp # imm = 0x118
retq
movq 0x90(%rsp), %rdi
callq 0x14410
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/relu.cpp
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x637a4
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x64c45
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x64e85
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x66055
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x67c64
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x67e05
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::Threshold::forward_inplace(ncnn::Mat&, ncnn::Option const&) const
|
int Threshold::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
float* ptr = bottom_top_blob.channel(q);
for (int i=0; i<size; i++)
{
ptr[i] = ptr[i] > threshold ? 1.f : 0.f;
}
}
return 0;
}
|
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x98(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x8c(%rsp)
movq 0x98(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x88(%rsp)
movq 0x98(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x84(%rsp)
movl 0x8c(%rsp), %eax
imull 0x88(%rsp), %eax
movl %eax, 0x80(%rsp)
movl $0x0, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0x84(%rsp), %eax
jge 0x682a6
movq 0x98(%rsp), %rsi
movl 0x7c(%rsp), %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x322b0
movq 0x8(%rsp), %rdi
callq 0x25f80
movq %rax, 0x10(%rsp)
jmp 0x681fd
leaq 0x30(%rsp), %rdi
callq 0x15950
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x80(%rsp), %eax
jge 0x68294
movq 0x18(%rsp), %rax
movq 0x70(%rsp), %rcx
movslq 0x20(%rsp), %rdx
movss (%rcx,%rdx,4), %xmm1
movss 0x80(%rax), %xmm0
movss 0x35fda(%rip), %xmm3 # 0x9e224
xorps %xmm2, %xmm2
cmpltss %xmm1, %xmm0
movaps %xmm0, %xmm1
andps %xmm3, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
movq 0x70(%rsp), %rax
movslq 0x20(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x68219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x15950
jmp 0x682b0
jmp 0x68296
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x681c0
xorl %eax, %eax
addq $0xa8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x14410
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/threshold.cpp
|
int ncnn::binary_op<std::plus<float>>(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&)
|
static int binary_op(const Mat& a, const Mat& b, Mat& c, const Option& opt)
{
Op op;
int w = a.w;
int h = a.h;
int channels = a.c;
int size = w * h;
size_t elemsize = a.elemsize;
int w1 = b.w;
int h1 = b.h;
int channels1 = b.c;
int size1 = w1 * h1;
if (a.dims == 3)
{
c.create(w, h, channels, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
if (b.dims == 3)
{
if (b.w == 1&&b.h==1)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const float* ptr = a.channel(q);
float* outptr = c.channel(q);
const float* b0 = b.channel(q);
for (int i = 0; i < size; i++)
{
outptr[i] = op(ptr[i], b0[0]);
}
}
return 0;
}
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
const float* ptr = a.channel(q);
const float* ptr1 = b.channel(q);
float* outptr = c.channel(q);
for (int i=0; i<size; i++)
{
outptr[i] = op(ptr[i], ptr1[i]);
}
}
return 0;
}
if (b.dims == 2)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
const float* ptr = a.channel(q);
const float* ptr1 = (const float*)b + h * q;
float* outptr = c.channel(q);
for (int y=0; y<h; y++)
{
const float b0 = ptr1[y];
for (int x=0; x<w; x++)
{
outptr[x] = op(ptr[x], b0);
}
ptr += w;
outptr += w;
}
}
return 0;
}
if (b.dims == 1)
{
if (b.w == 1)
{
const float b0 = b[0];
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
const float* ptr = a.channel(q);
float* outptr = c.channel(q);
for (int i=0; i<size; i++)
{
outptr[i] = op(ptr[i], b0);
}
}
return 0;
}
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
const float* ptr = a.channel(q);
const float b0 = b[q];
float* outptr = c.channel(q);
for (int i=0; i<size; i++)
{
outptr[i] = op(ptr[i], b0);
}
}
return 0;
}
}
else if (a.dims == 2)
{
if (b.dims == 3)
{
c.create(w1, h1, channels1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels1; q++)
{
const float* ptr = (const float*)a + h1 * q;
const float* ptr1 = b.channel(q);
float* outptr = c.channel(q);
for (int y=0; y<h1; y++)
{
const float a0 = ptr[y];
for (int x=0; x<w1; x++)
{
outptr[x] = op(a0, ptr1[x]);
}
ptr1 += w1;
outptr += w1;
}
}
return 0;
}
c.create(w, h, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
if (b.dims == 2)
{
for (int i=0; i<size; i++)
{
c[i] = op(a[i], b[i]);
}
return 0;
}
if (b.dims == 1)
{
c.create(w, h, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
if (b.w == 1)
{
const float b0 = b[0];
for (int i=0; i<size; i++)
{
c[i] = op(a[i], b0);
}
return 0;
}
const float* ptr = a;
float* outptr = c;
for (int y=0; y<h; y++)
{
const float b0 = b[y];
for (int x=0; x<w; x++)
{
outptr[x] = op(ptr[x], b0);
}
ptr += w;
outptr += w;
}
return 0;
}
}
else if (a.dims == 1)
{
if (a.w == 1)
{
if (b.dims == 3)
{
c.create(w1, h1, channels1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
const float a0 = a[0];
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels1; q++)
{
const float* ptr1 = b.channel(q);
float* outptr = c.channel(q);
for (int i=0; i<size1; i++)
{
outptr[i] = op(a0, ptr1[i]);
}
}
return 0;
}
if (b.dims == 2)
{
c.create(w1, h1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
const float a0 = a[0];
for (int i=0; i<size1; i++)
{
c[i] = op(a0, b[i]);
}
return 0;
}
if (b.dims == 1)
{
c.create(w1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
const float a0 = a[0];
for (int i=0; i<size1; i++)
{
c[i] = op(a0, b[i]);
}
return 0;
}
}
if (b.dims == 3)
{
c.create(w1, h1, channels1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels1; q++)
{
const float a0 = a[q];
const float* ptr1 = b.channel(q);
float* outptr = c.channel(q);
for (int i=0; i<size1; i++)
{
outptr[i] = op(a0, ptr1[i]);
}
}
return 0;
}
if (b.dims == 2)
{
c.create(w1, h1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
const float* ptr1 = b;
float* outptr = c;
for (int y=0; y<h1; y++)
{
const float a0 = a[y];
for (int x=0; x<w1; x++)
{
outptr[x] = op(a0, ptr1[x]);
}
ptr1 += w1;
outptr += w1;
}
return 0;
}
if (b.dims == 1)
{
c.create(w, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
if (b.w == 1)
{
const float b0 = b[0];
for (int i=0; i<size; i++)
{
c[i] = op(a[i], b0);
}
return 0;
}
for (int i=0; i<size; i++)
{
c[i] = op(a[i], b[i]);
}
}
}
return 0;
}
|
subq $0x7b8, %rsp # imm = 0x7B8
movq %rdi, 0x7a8(%rsp)
movq %rsi, 0x7a0(%rsp)
movq %rdx, 0x798(%rsp)
movq %rcx, 0x790(%rsp)
movq 0x7a8(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x788(%rsp)
movq 0x7a8(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x784(%rsp)
movq 0x7a8(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x780(%rsp)
movl 0x788(%rsp), %eax
imull 0x784(%rsp), %eax
movl %eax, 0x77c(%rsp)
movq 0x7a8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x770(%rsp)
movq 0x7a0(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x76c(%rsp)
movq 0x7a0(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x768(%rsp)
movq 0x7a0(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x764(%rsp)
movl 0x76c(%rsp), %eax
imull 0x768(%rsp), %eax
movl %eax, 0x760(%rsp)
movq 0x7a8(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x69287
movq 0x798(%rsp), %rdi
movl 0x788(%rsp), %esi
movl 0x784(%rsp), %edx
movl 0x780(%rsp), %ecx
movq 0x770(%rsp), %r8
movq 0x790(%rsp), %rax
movq 0x8(%rax), %r9
callq 0x15fe0
movq 0x798(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6876e
jmp 0x6877e
movl $0xffffff9c, 0x7b4(%rsp) # imm = 0xFFFFFF9C
jmp 0x6a2d9
movq 0x7a0(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x68c2b
movq 0x7a0(%rsp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x689e8
movq 0x7a0(%rsp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x689e8
movl $0x0, 0x75c(%rsp)
movl 0x75c(%rsp), %eax
cmpl 0x780(%rsp), %eax
jge 0x689d8
movq 0x7a8(%rsp), %rsi
movl 0x75c(%rsp), %edx
leaq 0x710(%rsp), %rdi
movq %rdi, 0x148(%rsp)
callq 0x34a30
movq 0x148(%rsp), %rdi
callq 0x34880
movq %rax, 0x150(%rsp)
jmp 0x6880e
leaq 0x710(%rsp), %rdi
callq 0x15950
movq 0x150(%rsp), %rax
movq %rax, 0x750(%rsp)
movq 0x798(%rsp), %rsi
movl 0x75c(%rsp), %edx
leaq 0x6b8(%rsp), %rdi
movq %rdi, 0x138(%rsp)
callq 0x322b0
movq 0x138(%rsp), %rdi
callq 0x25f80
movq %rax, 0x140(%rsp)
jmp 0x68866
leaq 0x6b8(%rsp), %rdi
callq 0x15950
movq 0x140(%rsp), %rax
movq %rax, 0x6f8(%rsp)
movq 0x7a0(%rsp), %rsi
movl 0x75c(%rsp), %edx
leaq 0x670(%rsp), %rdi
movq %rdi, 0x128(%rsp)
callq 0x34a30
movq 0x128(%rsp), %rdi
callq 0x34880
movq %rax, 0x130(%rsp)
jmp 0x688be
leaq 0x670(%rsp), %rdi
callq 0x15950
movq 0x130(%rsp), %rax
movq %rax, 0x6b0(%rsp)
movl $0x0, 0x66c(%rsp)
movl 0x66c(%rsp), %eax
cmpl 0x77c(%rsp), %eax
jge 0x689c0
movq 0x750(%rsp), %rsi
movslq 0x66c(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x6b0(%rsp), %rdx
leaq 0x78f(%rsp), %rdi
callq 0x628d0
movq 0x6f8(%rsp), %rax
movslq 0x66c(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x66c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x66c(%rsp)
jmp 0x688e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x710(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x6b8(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x670(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
jmp 0x689c2
movl 0x75c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x75c(%rsp)
jmp 0x687bf
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movl $0x0, 0x668(%rsp)
movl 0x668(%rsp), %eax
cmpl 0x780(%rsp), %eax
jge 0x68c1b
movq 0x7a8(%rsp), %rsi
movl 0x668(%rsp), %edx
leaq 0x620(%rsp), %rdi
movq %rdi, 0x118(%rsp)
callq 0x34a30
movq 0x118(%rsp), %rdi
callq 0x34880
movq %rax, 0x120(%rsp)
jmp 0x68a42
leaq 0x620(%rsp), %rdi
callq 0x15950
movq 0x120(%rsp), %rax
movq %rax, 0x660(%rsp)
movq 0x7a0(%rsp), %rsi
movl 0x668(%rsp), %edx
leaq 0x5d8(%rsp), %rdi
movq %rdi, 0x108(%rsp)
callq 0x34a30
movq 0x108(%rsp), %rdi
callq 0x34880
movq %rax, 0x110(%rsp)
jmp 0x68a9a
leaq 0x5d8(%rsp), %rdi
callq 0x15950
movq 0x110(%rsp), %rax
movq %rax, 0x618(%rsp)
movq 0x798(%rsp), %rsi
movl 0x668(%rsp), %edx
leaq 0x590(%rsp), %rdi
movq %rdi, 0xf8(%rsp)
callq 0x322b0
movq 0xf8(%rsp), %rdi
callq 0x25f80
movq %rax, 0x100(%rsp)
jmp 0x68af2
leaq 0x590(%rsp), %rdi
callq 0x15950
movq 0x100(%rsp), %rax
movq %rax, 0x5d0(%rsp)
movl $0x0, 0x58c(%rsp)
movl 0x58c(%rsp), %eax
cmpl 0x77c(%rsp), %eax
jge 0x68c03
movq 0x660(%rsp), %rsi
movslq 0x58c(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x618(%rsp), %rdx
movslq 0x58c(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x78f(%rsp), %rdi
callq 0x628d0
movq 0x5d0(%rsp), %rax
movslq 0x58c(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x58c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58c(%rsp)
jmp 0x68b1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x620(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x5d8(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x590(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
jmp 0x68c05
movl 0x668(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x668(%rsp)
jmp 0x689f3
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movq 0x7a0(%rsp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x68eb5
movl $0x0, 0x588(%rsp)
movl 0x588(%rsp), %eax
cmpl 0x780(%rsp), %eax
jge 0x68ea5
movq 0x7a8(%rsp), %rsi
movl 0x588(%rsp), %edx
leaq 0x540(%rsp), %rdi
movq %rdi, 0xe8(%rsp)
callq 0x34a30
movq 0xe8(%rsp), %rdi
callq 0x34880
movq %rax, 0xf0(%rsp)
jmp 0x68c97
leaq 0x540(%rsp), %rdi
callq 0x15950
movq 0xf0(%rsp), %rax
movq %rax, 0x580(%rsp)
movq 0x7a0(%rsp), %rdi
callq 0x34880
movl 0x784(%rsp), %ecx
movl 0x588(%rsp), %edx
imull %edx, %ecx
movslq %ecx, %rcx
leaq (%rax,%rcx,4), %rax
movq %rax, 0x538(%rsp)
movq 0x798(%rsp), %rsi
movl 0x588(%rsp), %edx
leaq 0x4f0(%rsp), %rdi
movq %rdi, 0xd8(%rsp)
callq 0x322b0
movq 0xd8(%rsp), %rdi
callq 0x25f80
movq %rax, 0xe0(%rsp)
jmp 0x68d1c
leaq 0x4f0(%rsp), %rdi
callq 0x15950
movq 0xe0(%rsp), %rax
movq %rax, 0x530(%rsp)
movl $0x0, 0x4ec(%rsp)
movl 0x4ec(%rsp), %eax
cmpl 0x784(%rsp), %eax
jge 0x68e8d
movq 0x538(%rsp), %rax
movslq 0x4ec(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x4e8(%rsp)
movl $0x0, 0x4e4(%rsp)
movl 0x4e4(%rsp), %eax
cmpl 0x788(%rsp), %eax
jge 0x68e35
movq 0x580(%rsp), %rsi
movslq 0x4e4(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x78f(%rsp), %rdi
leaq 0x4e8(%rsp), %rdx
callq 0x628d0
movq 0x530(%rsp), %rax
movslq 0x4e4(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x4e4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4e4(%rsp)
jmp 0x68d81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x540(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x4f0(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movl 0x788(%rsp), %ecx
movq 0x580(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x580(%rsp)
movl 0x788(%rsp), %ecx
movq 0x530(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x530(%rsp)
movl 0x4ec(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4ec(%rsp)
jmp 0x68d44
jmp 0x68e8f
movl 0x588(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x588(%rsp)
jmp 0x68c48
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movq 0x7a0(%rsp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x69282
movq 0x7a0(%rsp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x690ab
movq 0x7a0(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x4e0(%rsp)
movl $0x0, 0x4dc(%rsp)
movl 0x4dc(%rsp), %eax
cmpl 0x780(%rsp), %eax
jge 0x6909b
movq 0x7a8(%rsp), %rsi
movl 0x4dc(%rsp), %edx
leaq 0x490(%rsp), %rdi
movq %rdi, 0xc8(%rsp)
callq 0x34a30
movq 0xc8(%rsp), %rdi
callq 0x34880
movq %rax, 0xd0(%rsp)
jmp 0x68f4f
leaq 0x490(%rsp), %rdi
callq 0x15950
movq 0xd0(%rsp), %rax
movq %rax, 0x4d0(%rsp)
movq 0x798(%rsp), %rsi
movl 0x4dc(%rsp), %edx
leaq 0x448(%rsp), %rdi
movq %rdi, 0xb8(%rsp)
callq 0x322b0
movq 0xb8(%rsp), %rdi
callq 0x25f80
movq %rax, 0xc0(%rsp)
jmp 0x68fa7
leaq 0x448(%rsp), %rdi
callq 0x15950
movq 0xc0(%rsp), %rax
movq %rax, 0x488(%rsp)
movl $0x0, 0x444(%rsp)
movl 0x444(%rsp), %eax
cmpl 0x77c(%rsp), %eax
jge 0x69083
movq 0x4d0(%rsp), %rsi
movslq 0x444(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x78f(%rsp), %rdi
leaq 0x4e0(%rsp), %rdx
callq 0x628d0
movq 0x488(%rsp), %rax
movslq 0x444(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x444(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x444(%rsp)
jmp 0x68fcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x490(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x448(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
jmp 0x69085
movl 0x4dc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4dc(%rsp)
jmp 0x68f00
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movl $0x0, 0x440(%rsp)
movl 0x440(%rsp), %eax
cmpl 0x780(%rsp), %eax
jge 0x69272
movq 0x7a8(%rsp), %rsi
movl 0x440(%rsp), %edx
leaq 0x3f8(%rsp), %rdi
movq %rdi, 0xa8(%rsp)
callq 0x34a30
movq 0xa8(%rsp), %rdi
callq 0x34880
movq %rax, 0xb0(%rsp)
jmp 0x69105
leaq 0x3f8(%rsp), %rdi
callq 0x15950
movq 0xb0(%rsp), %rax
movq %rax, 0x438(%rsp)
movq 0x7a0(%rsp), %rdi
movl 0x440(%rsp), %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x3f4(%rsp)
movq 0x798(%rsp), %rsi
movl 0x440(%rsp), %edx
leaq 0x3a8(%rsp), %rdi
movq %rdi, 0x98(%rsp)
callq 0x322b0
movq 0x98(%rsp), %rdi
callq 0x25f80
movq %rax, 0xa0(%rsp)
jmp 0x6917e
leaq 0x3a8(%rsp), %rdi
callq 0x15950
movq 0xa0(%rsp), %rax
movq %rax, 0x3e8(%rsp)
movl $0x0, 0x3a4(%rsp)
movl 0x3a4(%rsp), %eax
cmpl 0x77c(%rsp), %eax
jge 0x6925a
movq 0x438(%rsp), %rsi
movslq 0x3a4(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x78f(%rsp), %rdi
leaq 0x3f4(%rsp), %rdx
callq 0x628d0
movq 0x3e8(%rsp), %rax
movslq 0x3a4(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x3a4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3a4(%rsp)
jmp 0x691a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x3f8(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x3a8(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
jmp 0x6925c
movl 0x440(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x440(%rsp)
jmp 0x690b6
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
jmp 0x6a2ce
movq 0x7a8(%rsp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x698e7
movq 0x7a0(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x69576
movq 0x798(%rsp), %rdi
movl 0x76c(%rsp), %esi
movl 0x768(%rsp), %edx
movl 0x764(%rsp), %ecx
movq 0x770(%rsp), %r8
movq 0x790(%rsp), %rax
movq 0x8(%rax), %r9
callq 0x15fe0
movq 0x798(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x692f4
jmp 0x69304
movl $0xffffff9c, 0x7b4(%rsp) # imm = 0xFFFFFF9C
jmp 0x6a2d9
movl $0x0, 0x3a0(%rsp)
movl 0x3a0(%rsp), %eax
cmpl 0x764(%rsp), %eax
jge 0x69566
movq 0x7a8(%rsp), %rdi
callq 0x34880
movl 0x768(%rsp), %ecx
movl 0x3a0(%rsp), %edx
imull %edx, %ecx
movslq %ecx, %rcx
leaq (%rax,%rcx,4), %rax
movq %rax, 0x398(%rsp)
movq 0x7a0(%rsp), %rsi
movl 0x3a0(%rsp), %edx
leaq 0x350(%rsp), %rdi
movq %rdi, 0x88(%rsp)
callq 0x34a30
movq 0x88(%rsp), %rdi
callq 0x34880
movq %rax, 0x90(%rsp)
jmp 0x6938b
leaq 0x350(%rsp), %rdi
callq 0x15950
movq 0x90(%rsp), %rax
movq %rax, 0x390(%rsp)
movq 0x798(%rsp), %rsi
movl 0x3a0(%rsp), %edx
leaq 0x308(%rsp), %rdi
movq %rdi, 0x78(%rsp)
callq 0x322b0
movq 0x78(%rsp), %rdi
callq 0x25f80
movq %rax, 0x80(%rsp)
jmp 0x693dd
leaq 0x308(%rsp), %rdi
callq 0x15950
movq 0x80(%rsp), %rax
movq %rax, 0x348(%rsp)
movl $0x0, 0x304(%rsp)
movl 0x304(%rsp), %eax
cmpl 0x768(%rsp), %eax
jge 0x6954e
movq 0x398(%rsp), %rax
movslq 0x304(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x300(%rsp)
movl $0x0, 0x2fc(%rsp)
movl 0x2fc(%rsp), %eax
cmpl 0x76c(%rsp), %eax
jge 0x694f6
movq 0x390(%rsp), %rdx
movslq 0x2fc(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x78f(%rsp), %rdi
leaq 0x300(%rsp), %rsi
callq 0x628d0
movq 0x348(%rsp), %rax
movslq 0x2fc(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x2fc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2fc(%rsp)
jmp 0x69442
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x350(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x308(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movl 0x76c(%rsp), %ecx
movq 0x390(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x390(%rsp)
movl 0x76c(%rsp), %ecx
movq 0x348(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x348(%rsp)
movl 0x304(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x304(%rsp)
jmp 0x69405
jmp 0x69550
movl 0x3a0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3a0(%rsp)
jmp 0x6930f
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movq 0x798(%rsp), %rdi
movl 0x788(%rsp), %esi
movl 0x784(%rsp), %edx
movq 0x770(%rsp), %rcx
movq 0x790(%rsp), %rax
movq 0x8(%rax), %r8
callq 0x34890
movq 0x798(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x695b8
jmp 0x695c8
movl $0xffffff9c, 0x7b4(%rsp) # imm = 0xFFFFFF9C
jmp 0x6a2d9
movq 0x7a0(%rsp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x69681
movl $0x0, 0x2f8(%rsp)
movl 0x2f8(%rsp), %eax
cmpl 0x77c(%rsp), %eax
jge 0x69671
movq 0x7a8(%rsp), %rdi
movl 0x2f8(%rsp), %esi
callq 0x32f30
movq %rax, 0x68(%rsp)
movq 0x7a0(%rsp), %rdi
movl 0x2f8(%rsp), %esi
callq 0x32f30
movq 0x68(%rsp), %rsi
movq %rax, %rdx
leaq 0x78f(%rsp), %rdi
callq 0x628d0
movss %xmm0, 0x74(%rsp)
movq 0x798(%rsp), %rdi
movl 0x2f8(%rsp), %esi
callq 0x32f10
movss 0x74(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x2f8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2f8(%rsp)
jmp 0x695e5
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movq 0x7a0(%rsp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x698e2
movq 0x798(%rsp), %rdi
movl 0x788(%rsp), %esi
movl 0x784(%rsp), %edx
movq 0x770(%rsp), %rcx
movq 0x790(%rsp), %rax
movq 0x8(%rax), %r8
callq 0x34890
movq 0x798(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x696d5
jmp 0x696e5
movl $0xffffff9c, 0x7b4(%rsp) # imm = 0xFFFFFF9C
jmp 0x6a2d9
movq 0x7a0(%rsp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x697a1
movq 0x7a0(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x2f4(%rsp)
movl $0x0, 0x2f0(%rsp)
movl 0x2f0(%rsp), %eax
cmpl 0x77c(%rsp), %eax
jge 0x69791
movq 0x7a8(%rsp), %rdi
movl 0x2f0(%rsp), %esi
callq 0x32f30
movq %rax, %rsi
leaq 0x78f(%rsp), %rdi
leaq 0x2f4(%rsp), %rdx
callq 0x628d0
movss %xmm0, 0x64(%rsp)
movq 0x798(%rsp), %rdi
movl 0x2f0(%rsp), %esi
callq 0x32f10
movss 0x64(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x2f0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2f0(%rsp)
jmp 0x6971e
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movq 0x7a8(%rsp), %rdi
callq 0x34880
movq %rax, 0x2e8(%rsp)
movq 0x798(%rsp), %rdi
callq 0x25f80
movq %rax, 0x2e0(%rsp)
movl $0x0, 0x2dc(%rsp)
movl 0x2dc(%rsp), %eax
cmpl 0x784(%rsp), %eax
jge 0x698d2
movq 0x7a0(%rsp), %rdi
movl 0x2dc(%rsp), %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x2d8(%rsp)
movl $0x0, 0x2d4(%rsp)
movl 0x2d4(%rsp), %eax
cmpl 0x788(%rsp), %eax
jge 0x6987a
movq 0x2e8(%rsp), %rsi
movslq 0x2d4(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x78f(%rsp), %rdi
leaq 0x2d8(%rsp), %rdx
callq 0x628d0
movq 0x2e0(%rsp), %rax
movslq 0x2d4(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x2d4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2d4(%rsp)
jmp 0x69816
movl 0x788(%rsp), %ecx
movq 0x2e8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x2e8(%rsp)
movl 0x788(%rsp), %ecx
movq 0x2e0(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x2e0(%rsp)
movl 0x2dc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2dc(%rsp)
jmp 0x697d6
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
jmp 0x6a2cc
movq 0x7a8(%rsp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x6a2ca
movq 0x7a8(%rsp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x69d47
movq 0x7a0(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x69b30
movq 0x798(%rsp), %rdi
movl 0x76c(%rsp), %esi
movl 0x768(%rsp), %edx
movl 0x764(%rsp), %ecx
movq 0x770(%rsp), %r8
movq 0x790(%rsp), %rax
movq 0x8(%rax), %r9
callq 0x15fe0
movq 0x798(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x69966
jmp 0x69976
movl $0xffffff9c, 0x7b4(%rsp) # imm = 0xFFFFFF9C
jmp 0x6a2d9
movq 0x7a8(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x2d0(%rsp)
movl $0x0, 0x2cc(%rsp)
movl 0x2cc(%rsp), %eax
cmpl 0x764(%rsp), %eax
jge 0x69b20
movq 0x7a0(%rsp), %rsi
movl 0x2cc(%rsp), %edx
leaq 0x280(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x34a30
movq 0x50(%rsp), %rdi
callq 0x34880
movq %rax, 0x58(%rsp)
jmp 0x699e3
leaq 0x280(%rsp), %rdi
callq 0x15950
movq 0x58(%rsp), %rax
movq %rax, 0x2c0(%rsp)
movq 0x798(%rsp), %rsi
movl 0x2cc(%rsp), %edx
leaq 0x238(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x322b0
movq 0x40(%rsp), %rdi
callq 0x25f80
movq %rax, 0x48(%rsp)
jmp 0x69a2f
leaq 0x238(%rsp), %rdi
callq 0x15950
movq 0x48(%rsp), %rax
movq %rax, 0x278(%rsp)
movl $0x0, 0x234(%rsp)
movl 0x234(%rsp), %eax
cmpl 0x760(%rsp), %eax
jge 0x69b08
movq 0x2c0(%rsp), %rdx
movslq 0x234(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x78f(%rsp), %rdi
leaq 0x2d0(%rsp), %rsi
callq 0x628d0
movq 0x278(%rsp), %rax
movslq 0x234(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x234(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x234(%rsp)
jmp 0x69a54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x280(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x238(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
jmp 0x69b0a
movl 0x2cc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2cc(%rsp)
jmp 0x6999d
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movq 0x7a0(%rsp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x69c3e
movq 0x798(%rsp), %rdi
movl 0x76c(%rsp), %esi
movl 0x768(%rsp), %edx
movq 0x770(%rsp), %rcx
movq 0x790(%rsp), %rax
movq 0x8(%rax), %r8
callq 0x34890
movq 0x798(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x69b84
jmp 0x69b94
movl $0xffffff9c, 0x7b4(%rsp) # imm = 0xFFFFFF9C
jmp 0x6a2d9
movq 0x7a8(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x230(%rsp)
movl $0x0, 0x22c(%rsp)
movl 0x22c(%rsp), %eax
cmpl 0x760(%rsp), %eax
jge 0x69c2e
movq 0x7a0(%rsp), %rdi
movl 0x22c(%rsp), %esi
callq 0x32f30
movq %rax, %rdx
leaq 0x78f(%rsp), %rdi
leaq 0x230(%rsp), %rsi
callq 0x628d0
movss %xmm0, 0x3c(%rsp)
movq 0x798(%rsp), %rdi
movl 0x22c(%rsp), %esi
callq 0x32f10
movss 0x3c(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x22c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x22c(%rsp)
jmp 0x69bbb
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movq 0x7a0(%rsp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x69d45
movq 0x798(%rsp), %rdi
movl 0x76c(%rsp), %esi
movq 0x770(%rsp), %rdx
movq 0x790(%rsp), %rax
movq 0x8(%rax), %rcx
callq 0x15b60
movq 0x798(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x69c8b
jmp 0x69c9b
movl $0xffffff9c, 0x7b4(%rsp) # imm = 0xFFFFFF9C
jmp 0x6a2d9
movq 0x7a8(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x228(%rsp)
movl $0x0, 0x224(%rsp)
movl 0x224(%rsp), %eax
cmpl 0x760(%rsp), %eax
jge 0x69d35
movq 0x7a0(%rsp), %rdi
movl 0x224(%rsp), %esi
callq 0x32f30
movq %rax, %rdx
leaq 0x78f(%rsp), %rdi
leaq 0x228(%rsp), %rsi
callq 0x628d0
movss %xmm0, 0x38(%rsp)
movq 0x798(%rsp), %rdi
movl 0x224(%rsp), %esi
callq 0x32f10
movss 0x38(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x224(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x224(%rsp)
jmp 0x69cc2
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
jmp 0x69d47
movq 0x7a0(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x69f71
movq 0x798(%rsp), %rdi
movl 0x76c(%rsp), %esi
movl 0x768(%rsp), %edx
movl 0x764(%rsp), %ecx
movq 0x770(%rsp), %r8
movq 0x790(%rsp), %rax
movq 0x8(%rax), %r9
callq 0x15fe0
movq 0x798(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x69da2
jmp 0x69db2
movl $0xffffff9c, 0x7b4(%rsp) # imm = 0xFFFFFF9C
jmp 0x6a2d9
movl $0x0, 0x220(%rsp)
movl 0x220(%rsp), %eax
cmpl 0x764(%rsp), %eax
jge 0x69f61
movq 0x7a8(%rsp), %rdi
movl 0x220(%rsp), %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x21c(%rsp)
movq 0x7a0(%rsp), %rsi
movl 0x220(%rsp), %edx
leaq 0x1d0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x34a30
movq 0x28(%rsp), %rdi
callq 0x34880
movq %rax, 0x30(%rsp)
jmp 0x69e24
leaq 0x1d0(%rsp), %rdi
callq 0x15950
movq 0x30(%rsp), %rax
movq %rax, 0x210(%rsp)
movq 0x798(%rsp), %rsi
movl 0x220(%rsp), %edx
leaq 0x188(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x322b0
movq 0x18(%rsp), %rdi
callq 0x25f80
movq %rax, 0x20(%rsp)
jmp 0x69e70
leaq 0x188(%rsp), %rdi
callq 0x15950
movq 0x20(%rsp), %rax
movq %rax, 0x1c8(%rsp)
movl $0x0, 0x184(%rsp)
movl 0x184(%rsp), %eax
cmpl 0x760(%rsp), %eax
jge 0x69f49
movq 0x210(%rsp), %rdx
movslq 0x184(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x78f(%rsp), %rdi
leaq 0x21c(%rsp), %rsi
callq 0x628d0
movq 0x1c8(%rsp), %rax
movslq 0x184(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x184(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x184(%rsp)
jmp 0x69e95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x1d0(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x708(%rsp)
movl %eax, 0x704(%rsp)
leaq 0x188(%rsp), %rdi
callq 0x15950
jmp 0x6a2e8
jmp 0x69f4b
movl 0x220(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x220(%rsp)
jmp 0x69dbd
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movq 0x7a0(%rsp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x6a116
movq 0x798(%rsp), %rdi
movl 0x76c(%rsp), %esi
movl 0x768(%rsp), %edx
movq 0x770(%rsp), %rcx
movq 0x790(%rsp), %rax
movq 0x8(%rax), %r8
callq 0x34890
movq 0x798(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x69fc5
jmp 0x69fd5
movl $0xffffff9c, 0x7b4(%rsp) # imm = 0xFFFFFF9C
jmp 0x6a2d9
movq 0x7a0(%rsp), %rdi
callq 0x34880
movq %rax, 0x178(%rsp)
movq 0x798(%rsp), %rdi
callq 0x25f80
movq %rax, 0x170(%rsp)
movl $0x0, 0x16c(%rsp)
movl 0x16c(%rsp), %eax
cmpl 0x768(%rsp), %eax
jge 0x6a106
movq 0x7a8(%rsp), %rdi
movl 0x16c(%rsp), %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x168(%rsp)
movl $0x0, 0x164(%rsp)
movl 0x164(%rsp), %eax
cmpl 0x76c(%rsp), %eax
jge 0x6a0ae
movq 0x178(%rsp), %rdx
movslq 0x164(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x78f(%rsp), %rdi
leaq 0x168(%rsp), %rsi
callq 0x628d0
movq 0x170(%rsp), %rax
movslq 0x164(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x164(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x164(%rsp)
jmp 0x6a04a
movl 0x76c(%rsp), %ecx
movq 0x178(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x178(%rsp)
movl 0x76c(%rsp), %ecx
movq 0x170(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x170(%rsp)
movl 0x16c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x16c(%rsp)
jmp 0x6a00a
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movq 0x7a0(%rsp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x6a2c8
movq 0x798(%rsp), %rdi
movl 0x788(%rsp), %esi
movq 0x770(%rsp), %rdx
movq 0x790(%rsp), %rax
movq 0x8(%rax), %rcx
callq 0x15b60
movq 0x798(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6a163
jmp 0x6a173
movl $0xffffff9c, 0x7b4(%rsp) # imm = 0xFFFFFF9C
jmp 0x6a2d9
movq 0x7a0(%rsp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x6a22f
movq 0x7a0(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x160(%rsp)
movl $0x0, 0x15c(%rsp)
movl 0x15c(%rsp), %eax
cmpl 0x77c(%rsp), %eax
jge 0x6a21f
movq 0x7a8(%rsp), %rdi
movl 0x15c(%rsp), %esi
callq 0x32f30
movq %rax, %rsi
leaq 0x78f(%rsp), %rdi
leaq 0x160(%rsp), %rdx
callq 0x628d0
movss %xmm0, 0x14(%rsp)
movq 0x798(%rsp), %rdi
movl 0x15c(%rsp), %esi
callq 0x32f10
movss 0x14(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x15c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x15c(%rsp)
jmp 0x6a1ac
movl $0x0, 0x7b4(%rsp)
jmp 0x6a2d9
movl $0x0, 0x158(%rsp)
movl 0x158(%rsp), %eax
cmpl 0x77c(%rsp), %eax
jge 0x6a2c6
movq 0x7a8(%rsp), %rdi
movl 0x158(%rsp), %esi
callq 0x32f30
movq %rax, 0x8(%rsp)
movq 0x7a0(%rsp), %rdi
movl 0x158(%rsp), %esi
callq 0x32f30
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x78f(%rsp), %rdi
callq 0x628d0
movss %xmm0, 0x10(%rsp)
movq 0x798(%rsp), %rdi
movl 0x158(%rsp), %esi
callq 0x32f10
movss 0x10(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x158(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x158(%rsp)
jmp 0x6a23a
jmp 0x6a2c8
jmp 0x6a2ca
jmp 0x6a2cc
jmp 0x6a2ce
movl $0x0, 0x7b4(%rsp)
movl 0x7b4(%rsp), %eax
addq $0x7b8, %rsp # imm = 0x7B8
retq
movq 0x708(%rsp), %rdi
callq 0x14410
nopw %cs:(%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/binaryop.cpp
|
int ncnn::binary_op<std::multiplies<float>>(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&)
|
static int binary_op(const Mat& a, const Mat& b, Mat& c, const Option& opt)
{
Op op;
int w = a.w;
int h = a.h;
int channels = a.c;
int size = w * h;
size_t elemsize = a.elemsize;
int w1 = b.w;
int h1 = b.h;
int channels1 = b.c;
int size1 = w1 * h1;
if (a.dims == 3)
{
c.create(w, h, channels, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
if (b.dims == 3)
{
if (b.w == 1&&b.h==1)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const float* ptr = a.channel(q);
float* outptr = c.channel(q);
const float* b0 = b.channel(q);
for (int i = 0; i < size; i++)
{
outptr[i] = op(ptr[i], b0[0]);
}
}
return 0;
}
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
const float* ptr = a.channel(q);
const float* ptr1 = b.channel(q);
float* outptr = c.channel(q);
for (int i=0; i<size; i++)
{
outptr[i] = op(ptr[i], ptr1[i]);
}
}
return 0;
}
if (b.dims == 2)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
const float* ptr = a.channel(q);
const float* ptr1 = (const float*)b + h * q;
float* outptr = c.channel(q);
for (int y=0; y<h; y++)
{
const float b0 = ptr1[y];
for (int x=0; x<w; x++)
{
outptr[x] = op(ptr[x], b0);
}
ptr += w;
outptr += w;
}
}
return 0;
}
if (b.dims == 1)
{
if (b.w == 1)
{
const float b0 = b[0];
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
const float* ptr = a.channel(q);
float* outptr = c.channel(q);
for (int i=0; i<size; i++)
{
outptr[i] = op(ptr[i], b0);
}
}
return 0;
}
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
const float* ptr = a.channel(q);
const float b0 = b[q];
float* outptr = c.channel(q);
for (int i=0; i<size; i++)
{
outptr[i] = op(ptr[i], b0);
}
}
return 0;
}
}
else if (a.dims == 2)
{
if (b.dims == 3)
{
c.create(w1, h1, channels1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels1; q++)
{
const float* ptr = (const float*)a + h1 * q;
const float* ptr1 = b.channel(q);
float* outptr = c.channel(q);
for (int y=0; y<h1; y++)
{
const float a0 = ptr[y];
for (int x=0; x<w1; x++)
{
outptr[x] = op(a0, ptr1[x]);
}
ptr1 += w1;
outptr += w1;
}
}
return 0;
}
c.create(w, h, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
if (b.dims == 2)
{
for (int i=0; i<size; i++)
{
c[i] = op(a[i], b[i]);
}
return 0;
}
if (b.dims == 1)
{
c.create(w, h, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
if (b.w == 1)
{
const float b0 = b[0];
for (int i=0; i<size; i++)
{
c[i] = op(a[i], b0);
}
return 0;
}
const float* ptr = a;
float* outptr = c;
for (int y=0; y<h; y++)
{
const float b0 = b[y];
for (int x=0; x<w; x++)
{
outptr[x] = op(ptr[x], b0);
}
ptr += w;
outptr += w;
}
return 0;
}
}
else if (a.dims == 1)
{
if (a.w == 1)
{
if (b.dims == 3)
{
c.create(w1, h1, channels1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
const float a0 = a[0];
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels1; q++)
{
const float* ptr1 = b.channel(q);
float* outptr = c.channel(q);
for (int i=0; i<size1; i++)
{
outptr[i] = op(a0, ptr1[i]);
}
}
return 0;
}
if (b.dims == 2)
{
c.create(w1, h1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
const float a0 = a[0];
for (int i=0; i<size1; i++)
{
c[i] = op(a0, b[i]);
}
return 0;
}
if (b.dims == 1)
{
c.create(w1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
const float a0 = a[0];
for (int i=0; i<size1; i++)
{
c[i] = op(a0, b[i]);
}
return 0;
}
}
if (b.dims == 3)
{
c.create(w1, h1, channels1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels1; q++)
{
const float a0 = a[q];
const float* ptr1 = b.channel(q);
float* outptr = c.channel(q);
for (int i=0; i<size1; i++)
{
outptr[i] = op(a0, ptr1[i]);
}
}
return 0;
}
if (b.dims == 2)
{
c.create(w1, h1, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
const float* ptr1 = b;
float* outptr = c;
for (int y=0; y<h1; y++)
{
const float a0 = a[y];
for (int x=0; x<w1; x++)
{
outptr[x] = op(a0, ptr1[x]);
}
ptr1 += w1;
outptr += w1;
}
return 0;
}
if (b.dims == 1)
{
c.create(w, elemsize, opt.blob_allocator);
if (c.empty())
return -100;
if (b.w == 1)
{
const float b0 = b[0];
for (int i=0; i<size; i++)
{
c[i] = op(a[i], b0);
}
return 0;
}
for (int i=0; i<size; i++)
{
c[i] = op(a[i], b[i]);
}
}
}
return 0;
}
|
subq $0x718, %rsp # imm = 0x718
movq %rdi, 0x708(%rsp)
movq %rsi, 0x700(%rsp)
movq %rdx, 0x6f8(%rsp)
movq %rcx, 0x6f0(%rsp)
movq 0x708(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x6e8(%rsp)
movq 0x708(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x6e4(%rsp)
movq 0x708(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x6e0(%rsp)
movl 0x6e8(%rsp), %eax
imull 0x6e4(%rsp), %eax
movl %eax, 0x6dc(%rsp)
movq 0x708(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x6d0(%rsp)
movq 0x700(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x6cc(%rsp)
movq 0x700(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x6c8(%rsp)
movq 0x700(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x6c4(%rsp)
movl 0x6cc(%rsp), %eax
imull 0x6c8(%rsp), %eax
movl %eax, 0x6c0(%rsp)
movq 0x708(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x6c612
movq 0x6f8(%rsp), %rdi
movl 0x6e8(%rsp), %esi
movl 0x6e4(%rsp), %edx
movl 0x6e0(%rsp), %ecx
movq 0x6d0(%rsp), %r8
movq 0x6f0(%rsp), %rax
movq 0x8(%rax), %r9
callq 0x15fe0
movq 0x6f8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6bd5e
jmp 0x6bd6e
movl $0xffffff9c, 0x714(%rsp) # imm = 0xFFFFFF9C
jmp 0x6d54b
movq 0x700(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x6c0f3
movq 0x700(%rsp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x6bf44
movq 0x700(%rsp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x6bf44
movl $0x0, 0x6bc(%rsp)
movl 0x6bc(%rsp), %eax
cmpl 0x6e0(%rsp), %eax
jge 0x6bf34
movq 0x708(%rsp), %rsi
movl 0x6bc(%rsp), %edx
leaq 0x670(%rsp), %rdi
callq 0x34a30
leaq 0x670(%rsp), %rdi
callq 0x34880
movq %rax, 0xb0(%rsp)
leaq 0x670(%rsp), %rdi
callq 0x15950
movq 0xb0(%rsp), %rax
movq %rax, 0x6b0(%rsp)
movq 0x6f8(%rsp), %rsi
movl 0x6bc(%rsp), %edx
leaq 0x628(%rsp), %rdi
callq 0x322b0
leaq 0x628(%rsp), %rdi
callq 0x25f80
movq %rax, 0xb8(%rsp)
leaq 0x628(%rsp), %rdi
callq 0x15950
movq 0xb8(%rsp), %rax
movq %rax, 0x668(%rsp)
movq 0x700(%rsp), %rsi
movl 0x6bc(%rsp), %edx
leaq 0x5e0(%rsp), %rdi
callq 0x34a30
leaq 0x5e0(%rsp), %rdi
callq 0x34880
movq %rax, 0xc0(%rsp)
leaq 0x5e0(%rsp), %rdi
callq 0x15950
movq 0xc0(%rsp), %rax
movq %rax, 0x620(%rsp)
movl $0x0, 0x5dc(%rsp)
movl 0x5dc(%rsp), %eax
cmpl 0x6dc(%rsp), %eax
jge 0x6bf1c
movq 0x6b0(%rsp), %rsi
movslq 0x5dc(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x620(%rsp), %rdx
leaq 0x6ef(%rsp), %rdi
callq 0x62a00
movq 0x668(%rsp), %rax
movslq 0x5dc(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x5dc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5dc(%rsp)
jmp 0x6beb8
jmp 0x6bf1e
movl 0x6bc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6bc(%rsp)
jmp 0x6bdaf
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movl $0x0, 0x5d8(%rsp)
movl 0x5d8(%rsp), %eax
cmpl 0x6e0(%rsp), %eax
jge 0x6c0e3
movq 0x708(%rsp), %rsi
movl 0x5d8(%rsp), %edx
leaq 0x590(%rsp), %rdi
callq 0x34a30
leaq 0x590(%rsp), %rdi
callq 0x34880
movq %rax, 0x98(%rsp)
leaq 0x590(%rsp), %rdi
callq 0x15950
movq 0x98(%rsp), %rax
movq %rax, 0x5d0(%rsp)
movq 0x700(%rsp), %rsi
movl 0x5d8(%rsp), %edx
leaq 0x548(%rsp), %rdi
callq 0x34a30
leaq 0x548(%rsp), %rdi
callq 0x34880
movq %rax, 0xa0(%rsp)
leaq 0x548(%rsp), %rdi
callq 0x15950
movq 0xa0(%rsp), %rax
movq %rax, 0x588(%rsp)
movq 0x6f8(%rsp), %rsi
movl 0x5d8(%rsp), %edx
leaq 0x500(%rsp), %rdi
callq 0x322b0
leaq 0x500(%rsp), %rdi
callq 0x25f80
movq %rax, 0xa8(%rsp)
leaq 0x500(%rsp), %rdi
callq 0x15950
movq 0xa8(%rsp), %rax
movq %rax, 0x540(%rsp)
movl $0x0, 0x4fc(%rsp)
movl 0x4fc(%rsp), %eax
cmpl 0x6dc(%rsp), %eax
jge 0x6c0cb
movq 0x5d0(%rsp), %rsi
movslq 0x4fc(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x588(%rsp), %rdx
movslq 0x4fc(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x6ef(%rsp), %rdi
callq 0x62a00
movq 0x540(%rsp), %rax
movslq 0x4fc(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x4fc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4fc(%rsp)
jmp 0x6c058
jmp 0x6c0cd
movl 0x5d8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5d8(%rsp)
jmp 0x6bf4f
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movq 0x700(%rsp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x6c31a
movl $0x0, 0x4f8(%rsp)
movl 0x4f8(%rsp), %eax
cmpl 0x6e0(%rsp), %eax
jge 0x6c30a
movq 0x708(%rsp), %rsi
movl 0x4f8(%rsp), %edx
leaq 0x4b0(%rsp), %rdi
callq 0x34a30
leaq 0x4b0(%rsp), %rdi
callq 0x34880
movq %rax, 0x88(%rsp)
leaq 0x4b0(%rsp), %rdi
callq 0x15950
movq 0x88(%rsp), %rax
movq %rax, 0x4f0(%rsp)
movq 0x700(%rsp), %rdi
callq 0x34880
movl 0x6e4(%rsp), %ecx
imull 0x4f8(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x4a8(%rsp)
movq 0x6f8(%rsp), %rsi
movl 0x4f8(%rsp), %edx
leaq 0x460(%rsp), %rdi
callq 0x322b0
leaq 0x460(%rsp), %rdi
callq 0x25f80
movq %rax, 0x90(%rsp)
leaq 0x460(%rsp), %rdi
callq 0x15950
movq 0x90(%rsp), %rax
movq %rax, 0x4a0(%rsp)
movl $0x0, 0x45c(%rsp)
movl 0x45c(%rsp), %eax
cmpl 0x6e4(%rsp), %eax
jge 0x6c2f2
movq 0x4a8(%rsp), %rax
movslq 0x45c(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x458(%rsp)
movl $0x0, 0x454(%rsp)
movl 0x454(%rsp), %eax
cmpl 0x6e8(%rsp), %eax
jge 0x6c29a
movq 0x4f0(%rsp), %rsi
movslq 0x454(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x6ef(%rsp), %rdi
leaq 0x458(%rsp), %rdx
callq 0x62a00
movq 0x4a0(%rsp), %rax
movslq 0x454(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x454(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x454(%rsp)
jmp 0x6c236
movl 0x6e8(%rsp), %ecx
movq 0x4f0(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x4f0(%rsp)
movl 0x6e8(%rsp), %ecx
movq 0x4a0(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x4a0(%rsp)
movl 0x45c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x45c(%rsp)
jmp 0x6c1f9
jmp 0x6c2f4
movl 0x4f8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4f8(%rsp)
jmp 0x6c110
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movq 0x700(%rsp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x6c60d
movq 0x700(%rsp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x6c4a6
movq 0x700(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x450(%rsp)
movl $0x0, 0x44c(%rsp)
movl 0x44c(%rsp), %eax
cmpl 0x6e0(%rsp), %eax
jge 0x6c496
movq 0x708(%rsp), %rsi
movl 0x44c(%rsp), %edx
leaq 0x400(%rsp), %rdi
callq 0x34a30
leaq 0x400(%rsp), %rdi
callq 0x34880
movq %rax, 0x78(%rsp)
leaq 0x400(%rsp), %rdi
callq 0x15950
movq 0x78(%rsp), %rax
movq %rax, 0x440(%rsp)
movq 0x6f8(%rsp), %rsi
movl 0x44c(%rsp), %edx
leaq 0x3b8(%rsp), %rdi
callq 0x322b0
leaq 0x3b8(%rsp), %rdi
callq 0x25f80
movq %rax, 0x80(%rsp)
leaq 0x3b8(%rsp), %rdi
callq 0x15950
movq 0x80(%rsp), %rax
movq %rax, 0x3f8(%rsp)
movl $0x0, 0x3b4(%rsp)
movl 0x3b4(%rsp), %eax
cmpl 0x6dc(%rsp), %eax
jge 0x6c47e
movq 0x440(%rsp), %rsi
movslq 0x3b4(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x6ef(%rsp), %rdi
leaq 0x450(%rsp), %rdx
callq 0x62a00
movq 0x3f8(%rsp), %rax
movslq 0x3b4(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x3b4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3b4(%rsp)
jmp 0x6c41a
jmp 0x6c480
movl 0x44c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44c(%rsp)
jmp 0x6c365
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movl $0x0, 0x3b0(%rsp)
movl 0x3b0(%rsp), %eax
cmpl 0x6e0(%rsp), %eax
jge 0x6c5fd
movq 0x708(%rsp), %rsi
movl 0x3b0(%rsp), %edx
leaq 0x368(%rsp), %rdi
callq 0x34a30
leaq 0x368(%rsp), %rdi
callq 0x34880
movq %rax, 0x68(%rsp)
leaq 0x368(%rsp), %rdi
callq 0x15950
movq 0x68(%rsp), %rax
movq %rax, 0x3a8(%rsp)
movq 0x700(%rsp), %rdi
movl 0x3b0(%rsp), %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x364(%rsp)
movq 0x6f8(%rsp), %rsi
movl 0x3b0(%rsp), %edx
leaq 0x318(%rsp), %rdi
callq 0x322b0
leaq 0x318(%rsp), %rdi
callq 0x25f80
movq %rax, 0x70(%rsp)
leaq 0x318(%rsp), %rdi
callq 0x15950
movq 0x70(%rsp), %rax
movq %rax, 0x358(%rsp)
movl $0x0, 0x314(%rsp)
movl 0x314(%rsp), %eax
cmpl 0x6dc(%rsp), %eax
jge 0x6c5e5
movq 0x3a8(%rsp), %rsi
movslq 0x314(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x6ef(%rsp), %rdi
leaq 0x364(%rsp), %rdx
callq 0x62a00
movq 0x358(%rsp), %rax
movslq 0x314(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x314(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x314(%rsp)
jmp 0x6c581
jmp 0x6c5e7
movl 0x3b0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3b0(%rsp)
jmp 0x6c4b1
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
jmp 0x6d540
movq 0x708(%rsp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x6cc09
movq 0x700(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x6c898
movq 0x6f8(%rsp), %rdi
movl 0x6cc(%rsp), %esi
movl 0x6c8(%rsp), %edx
movl 0x6c4(%rsp), %ecx
movq 0x6d0(%rsp), %r8
movq 0x6f0(%rsp), %rax
movq 0x8(%rax), %r9
callq 0x15fe0
movq 0x6f8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6c67f
jmp 0x6c68f
movl $0xffffff9c, 0x714(%rsp) # imm = 0xFFFFFF9C
jmp 0x6d54b
movl $0x0, 0x310(%rsp)
movl 0x310(%rsp), %eax
cmpl 0x6c4(%rsp), %eax
jge 0x6c888
movq 0x708(%rsp), %rdi
callq 0x34880
movl 0x6c8(%rsp), %ecx
imull 0x310(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x308(%rsp)
movq 0x700(%rsp), %rsi
movl 0x310(%rsp), %edx
leaq 0x2c0(%rsp), %rdi
callq 0x34a30
leaq 0x2c0(%rsp), %rdi
callq 0x34880
movq %rax, 0x58(%rsp)
leaq 0x2c0(%rsp), %rdi
callq 0x15950
movq 0x58(%rsp), %rax
movq %rax, 0x300(%rsp)
movq 0x6f8(%rsp), %rsi
movl 0x310(%rsp), %edx
leaq 0x278(%rsp), %rdi
callq 0x322b0
leaq 0x278(%rsp), %rdi
callq 0x25f80
movq %rax, 0x60(%rsp)
leaq 0x278(%rsp), %rdi
callq 0x15950
movq 0x60(%rsp), %rax
movq %rax, 0x2b8(%rsp)
movl $0x0, 0x274(%rsp)
movl 0x274(%rsp), %eax
cmpl 0x6c8(%rsp), %eax
jge 0x6c870
movq 0x308(%rsp), %rax
movslq 0x274(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x270(%rsp)
movl $0x0, 0x26c(%rsp)
movl 0x26c(%rsp), %eax
cmpl 0x6cc(%rsp), %eax
jge 0x6c818
movq 0x300(%rsp), %rdx
movslq 0x26c(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x6ef(%rsp), %rdi
leaq 0x270(%rsp), %rsi
callq 0x62a00
movq 0x2b8(%rsp), %rax
movslq 0x26c(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x26c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x26c(%rsp)
jmp 0x6c7b4
movl 0x6cc(%rsp), %ecx
movq 0x300(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x300(%rsp)
movl 0x6cc(%rsp), %ecx
movq 0x2b8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x2b8(%rsp)
movl 0x274(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x274(%rsp)
jmp 0x6c777
jmp 0x6c872
movl 0x310(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x310(%rsp)
jmp 0x6c69a
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movq 0x6f8(%rsp), %rdi
movl 0x6e8(%rsp), %esi
movl 0x6e4(%rsp), %edx
movq 0x6d0(%rsp), %rcx
movq 0x6f0(%rsp), %rax
movq 0x8(%rax), %r8
callq 0x34890
movq 0x6f8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6c8da
jmp 0x6c8ea
movl $0xffffff9c, 0x714(%rsp) # imm = 0xFFFFFF9C
jmp 0x6d54b
movq 0x700(%rsp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x6c9a3
movl $0x0, 0x268(%rsp)
movl 0x268(%rsp), %eax
cmpl 0x6dc(%rsp), %eax
jge 0x6c993
movq 0x708(%rsp), %rdi
movl 0x268(%rsp), %esi
callq 0x32f30
movq %rax, 0x48(%rsp)
movq 0x700(%rsp), %rdi
movl 0x268(%rsp), %esi
callq 0x32f30
movq 0x48(%rsp), %rsi
movq %rax, %rdx
leaq 0x6ef(%rsp), %rdi
callq 0x62a00
movss %xmm0, 0x54(%rsp)
movq 0x6f8(%rsp), %rdi
movl 0x268(%rsp), %esi
callq 0x32f10
movss 0x54(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x268(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x268(%rsp)
jmp 0x6c907
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movq 0x700(%rsp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x6cc04
movq 0x6f8(%rsp), %rdi
movl 0x6e8(%rsp), %esi
movl 0x6e4(%rsp), %edx
movq 0x6d0(%rsp), %rcx
movq 0x6f0(%rsp), %rax
movq 0x8(%rax), %r8
callq 0x34890
movq 0x6f8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6c9f7
jmp 0x6ca07
movl $0xffffff9c, 0x714(%rsp) # imm = 0xFFFFFF9C
jmp 0x6d54b
movq 0x700(%rsp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x6cac3
movq 0x700(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x264(%rsp)
movl $0x0, 0x260(%rsp)
movl 0x260(%rsp), %eax
cmpl 0x6dc(%rsp), %eax
jge 0x6cab3
movq 0x708(%rsp), %rdi
movl 0x260(%rsp), %esi
callq 0x32f30
movq %rax, %rsi
leaq 0x6ef(%rsp), %rdi
leaq 0x264(%rsp), %rdx
callq 0x62a00
movss %xmm0, 0x44(%rsp)
movq 0x6f8(%rsp), %rdi
movl 0x260(%rsp), %esi
callq 0x32f10
movss 0x44(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x260(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x260(%rsp)
jmp 0x6ca40
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movq 0x708(%rsp), %rdi
callq 0x34880
movq %rax, 0x258(%rsp)
movq 0x6f8(%rsp), %rdi
callq 0x25f80
movq %rax, 0x250(%rsp)
movl $0x0, 0x24c(%rsp)
movl 0x24c(%rsp), %eax
cmpl 0x6e4(%rsp), %eax
jge 0x6cbf4
movq 0x700(%rsp), %rdi
movl 0x24c(%rsp), %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x248(%rsp)
movl $0x0, 0x244(%rsp)
movl 0x244(%rsp), %eax
cmpl 0x6e8(%rsp), %eax
jge 0x6cb9c
movq 0x258(%rsp), %rsi
movslq 0x244(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x6ef(%rsp), %rdi
leaq 0x248(%rsp), %rdx
callq 0x62a00
movq 0x250(%rsp), %rax
movslq 0x244(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x244(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x244(%rsp)
jmp 0x6cb38
movl 0x6e8(%rsp), %ecx
movq 0x258(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x258(%rsp)
movl 0x6e8(%rsp), %ecx
movq 0x250(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x250(%rsp)
movl 0x24c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24c(%rsp)
jmp 0x6caf8
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
jmp 0x6d53e
movq 0x708(%rsp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x6d53c
movq 0x708(%rsp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x6d011
movq 0x700(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x6cdfa
movq 0x6f8(%rsp), %rdi
movl 0x6cc(%rsp), %esi
movl 0x6c8(%rsp), %edx
movl 0x6c4(%rsp), %ecx
movq 0x6d0(%rsp), %r8
movq 0x6f0(%rsp), %rax
movq 0x8(%rax), %r9
callq 0x15fe0
movq 0x6f8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6cc88
jmp 0x6cc98
movl $0xffffff9c, 0x714(%rsp) # imm = 0xFFFFFF9C
jmp 0x6d54b
movq 0x708(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x240(%rsp)
movl $0x0, 0x23c(%rsp)
movl 0x23c(%rsp), %eax
cmpl 0x6c4(%rsp), %eax
jge 0x6cdea
movq 0x700(%rsp), %rsi
movl 0x23c(%rsp), %edx
leaq 0x1f0(%rsp), %rdi
callq 0x34a30
leaq 0x1f0(%rsp), %rdi
callq 0x34880
movq %rax, 0x30(%rsp)
leaq 0x1f0(%rsp), %rdi
callq 0x15950
movq 0x30(%rsp), %rax
movq %rax, 0x230(%rsp)
movq 0x6f8(%rsp), %rsi
movl 0x23c(%rsp), %edx
leaq 0x1a8(%rsp), %rdi
callq 0x322b0
leaq 0x1a8(%rsp), %rdi
callq 0x25f80
movq %rax, 0x38(%rsp)
leaq 0x1a8(%rsp), %rdi
callq 0x15950
movq 0x38(%rsp), %rax
movq %rax, 0x1e8(%rsp)
movl $0x0, 0x1a4(%rsp)
movl 0x1a4(%rsp), %eax
cmpl 0x6c0(%rsp), %eax
jge 0x6cdd2
movq 0x230(%rsp), %rdx
movslq 0x1a4(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x6ef(%rsp), %rdi
leaq 0x240(%rsp), %rsi
callq 0x62a00
movq 0x1e8(%rsp), %rax
movslq 0x1a4(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x1a4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1a4(%rsp)
jmp 0x6cd6e
jmp 0x6cdd4
movl 0x23c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x23c(%rsp)
jmp 0x6ccbf
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movq 0x700(%rsp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x6cf08
movq 0x6f8(%rsp), %rdi
movl 0x6cc(%rsp), %esi
movl 0x6c8(%rsp), %edx
movq 0x6d0(%rsp), %rcx
movq 0x6f0(%rsp), %rax
movq 0x8(%rax), %r8
callq 0x34890
movq 0x6f8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6ce4e
jmp 0x6ce5e
movl $0xffffff9c, 0x714(%rsp) # imm = 0xFFFFFF9C
jmp 0x6d54b
movq 0x708(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x1a0(%rsp)
movl $0x0, 0x19c(%rsp)
movl 0x19c(%rsp), %eax
cmpl 0x6c0(%rsp), %eax
jge 0x6cef8
movq 0x700(%rsp), %rdi
movl 0x19c(%rsp), %esi
callq 0x32f30
movq %rax, %rdx
leaq 0x6ef(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
callq 0x62a00
movss %xmm0, 0x2c(%rsp)
movq 0x6f8(%rsp), %rdi
movl 0x19c(%rsp), %esi
callq 0x32f10
movss 0x2c(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x19c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x19c(%rsp)
jmp 0x6ce85
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movq 0x700(%rsp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x6d00f
movq 0x6f8(%rsp), %rdi
movl 0x6cc(%rsp), %esi
movq 0x6d0(%rsp), %rdx
movq 0x6f0(%rsp), %rax
movq 0x8(%rax), %rcx
callq 0x15b60
movq 0x6f8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6cf55
jmp 0x6cf65
movl $0xffffff9c, 0x714(%rsp) # imm = 0xFFFFFF9C
jmp 0x6d54b
movq 0x708(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x198(%rsp)
movl $0x0, 0x194(%rsp)
movl 0x194(%rsp), %eax
cmpl 0x6c0(%rsp), %eax
jge 0x6cfff
movq 0x700(%rsp), %rdi
movl 0x194(%rsp), %esi
callq 0x32f30
movq %rax, %rdx
leaq 0x6ef(%rsp), %rdi
leaq 0x198(%rsp), %rsi
callq 0x62a00
movss %xmm0, 0x28(%rsp)
movq 0x6f8(%rsp), %rdi
movl 0x194(%rsp), %esi
callq 0x32f10
movss 0x28(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x194(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x194(%rsp)
jmp 0x6cf8c
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
jmp 0x6d011
movq 0x700(%rsp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x6d1e3
movq 0x6f8(%rsp), %rdi
movl 0x6cc(%rsp), %esi
movl 0x6c8(%rsp), %edx
movl 0x6c4(%rsp), %ecx
movq 0x6d0(%rsp), %r8
movq 0x6f0(%rsp), %rax
movq 0x8(%rax), %r9
callq 0x15fe0
movq 0x6f8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6d06c
jmp 0x6d07c
movl $0xffffff9c, 0x714(%rsp) # imm = 0xFFFFFF9C
jmp 0x6d54b
movl $0x0, 0x190(%rsp)
movl 0x190(%rsp), %eax
cmpl 0x6c4(%rsp), %eax
jge 0x6d1d3
movq 0x708(%rsp), %rdi
movl 0x190(%rsp), %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0x18c(%rsp)
movq 0x700(%rsp), %rsi
movl 0x190(%rsp), %edx
leaq 0x140(%rsp), %rdi
callq 0x34a30
leaq 0x140(%rsp), %rdi
callq 0x34880
movq %rax, 0x18(%rsp)
leaq 0x140(%rsp), %rdi
callq 0x15950
movq 0x18(%rsp), %rax
movq %rax, 0x180(%rsp)
movq 0x6f8(%rsp), %rsi
movl 0x190(%rsp), %edx
leaq 0xf8(%rsp), %rdi
callq 0x322b0
leaq 0xf8(%rsp), %rdi
callq 0x25f80
movq %rax, 0x20(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0x15950
movq 0x20(%rsp), %rax
movq %rax, 0x138(%rsp)
movl $0x0, 0xf4(%rsp)
movl 0xf4(%rsp), %eax
cmpl 0x6c0(%rsp), %eax
jge 0x6d1bb
movq 0x180(%rsp), %rdx
movslq 0xf4(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x6ef(%rsp), %rdi
leaq 0x18c(%rsp), %rsi
callq 0x62a00
movq 0x138(%rsp), %rax
movslq 0xf4(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0xf4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf4(%rsp)
jmp 0x6d157
jmp 0x6d1bd
movl 0x190(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x190(%rsp)
jmp 0x6d087
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movq 0x700(%rsp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x6d388
movq 0x6f8(%rsp), %rdi
movl 0x6cc(%rsp), %esi
movl 0x6c8(%rsp), %edx
movq 0x6d0(%rsp), %rcx
movq 0x6f0(%rsp), %rax
movq 0x8(%rax), %r8
callq 0x34890
movq 0x6f8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6d237
jmp 0x6d247
movl $0xffffff9c, 0x714(%rsp) # imm = 0xFFFFFF9C
jmp 0x6d54b
movq 0x700(%rsp), %rdi
callq 0x34880
movq %rax, 0xe8(%rsp)
movq 0x6f8(%rsp), %rdi
callq 0x25f80
movq %rax, 0xe0(%rsp)
movl $0x0, 0xdc(%rsp)
movl 0xdc(%rsp), %eax
cmpl 0x6c8(%rsp), %eax
jge 0x6d378
movq 0x708(%rsp), %rdi
movl 0xdc(%rsp), %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0xd8(%rsp)
movl $0x0, 0xd4(%rsp)
movl 0xd4(%rsp), %eax
cmpl 0x6cc(%rsp), %eax
jge 0x6d320
movq 0xe8(%rsp), %rdx
movslq 0xd4(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x6ef(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x62a00
movq 0xe0(%rsp), %rax
movslq 0xd4(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0xd4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd4(%rsp)
jmp 0x6d2bc
movl 0x6cc(%rsp), %ecx
movq 0xe8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0xe8(%rsp)
movl 0x6cc(%rsp), %ecx
movq 0xe0(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0xe0(%rsp)
movl 0xdc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xdc(%rsp)
jmp 0x6d27c
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movq 0x700(%rsp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x6d53a
movq 0x6f8(%rsp), %rdi
movl 0x6e8(%rsp), %esi
movq 0x6d0(%rsp), %rdx
movq 0x6f0(%rsp), %rax
movq 0x8(%rax), %rcx
callq 0x15b60
movq 0x6f8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x6d3d5
jmp 0x6d3e5
movl $0xffffff9c, 0x714(%rsp) # imm = 0xFFFFFF9C
jmp 0x6d54b
movq 0x700(%rsp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x6d4a1
movq 0x700(%rsp), %rdi
xorl %esi, %esi
callq 0x32f30
movss (%rax), %xmm0
movss %xmm0, 0xd0(%rsp)
movl $0x0, 0xcc(%rsp)
movl 0xcc(%rsp), %eax
cmpl 0x6dc(%rsp), %eax
jge 0x6d491
movq 0x708(%rsp), %rdi
movl 0xcc(%rsp), %esi
callq 0x32f30
movq %rax, %rsi
leaq 0x6ef(%rsp), %rdi
leaq 0xd0(%rsp), %rdx
callq 0x62a00
movss %xmm0, 0x14(%rsp)
movq 0x6f8(%rsp), %rdi
movl 0xcc(%rsp), %esi
callq 0x32f10
movss 0x14(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0xcc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xcc(%rsp)
jmp 0x6d41e
movl $0x0, 0x714(%rsp)
jmp 0x6d54b
movl $0x0, 0xc8(%rsp)
movl 0xc8(%rsp), %eax
cmpl 0x6dc(%rsp), %eax
jge 0x6d538
movq 0x708(%rsp), %rdi
movl 0xc8(%rsp), %esi
callq 0x32f30
movq %rax, 0x8(%rsp)
movq 0x700(%rsp), %rdi
movl 0xc8(%rsp), %esi
callq 0x32f30
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x6ef(%rsp), %rdi
callq 0x62a00
movss %xmm0, 0x10(%rsp)
movq 0x6f8(%rsp), %rdi
movl 0xc8(%rsp), %esi
callq 0x32f10
movss 0x10(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0xc8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc8(%rsp)
jmp 0x6d4ac
jmp 0x6d53a
jmp 0x6d53c
jmp 0x6d53e
jmp 0x6d540
movl $0x0, 0x714(%rsp)
movl 0x714(%rsp), %eax
addq $0x718, %rsp # imm = 0x718
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/binaryop.cpp
|
int ncnn::binary_op_scalar_inplace<ncnn::binary_op_rdiv<float>>(ncnn::Mat&, float, ncnn::Option const&)
|
static int binary_op_scalar_inplace(Mat& a, float b, const Option& opt)
{
Op op;
int w = a.w;
int h = a.h;
int channels = a.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
float* ptr = a.channel(q);
for (int i=0; i<size; i++)
{
ptr[i] = op(ptr[i], b);
}
}
return 0;
}
|
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movss %xmm0, 0x7c(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x80(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x68(%rsp)
movq 0x80(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x64(%rsp)
movq 0x80(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x60(%rsp)
movl 0x68(%rsp), %eax
imull 0x64(%rsp), %eax
movl %eax, 0x5c(%rsp)
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x777e1
movq 0x80(%rsp), %rsi
movl 0x58(%rsp), %edx
leaq 0x10(%rsp), %rdi
callq 0x322b0
leaq 0x10(%rsp), %rdi
callq 0x25f80
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0x15950
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x5c(%rsp), %eax
jge 0x777cf
movq 0x50(%rsp), %rsi
movslq 0xc(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x6f(%rsp), %rdi
leaq 0x7c(%rsp), %rdx
callq 0x779d0
movq 0x50(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x77789
jmp 0x777d1
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x7773c
xorl %eax, %eax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/binaryop.cpp
|
int ncnn::unary_op_inplace<ncnn::unary_op_floor<float>>(ncnn::Mat&, ncnn::Option const&)
|
static int unary_op_inplace(Mat& a, const Option& opt)
{
Op op;
int size = a.total();
#pragma omp parallel for num_threads(opt.num_threads)
for (int i=0; i<size; i++)
{
a[i] = op(a[i]);
}
return 0;
}
|
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15d80
movl %eax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x77eb4
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x32f10
movq %rax, %rsi
leaq 0x17(%rsp), %rdi
callq 0x785d0
movss %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x32f10
movss 0x8(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x77e64
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/unaryop.cpp
|
int ncnn::unary_op_inplace<ncnn::unary_op_square<float>>(ncnn::Mat&, ncnn::Option const&)
|
static int unary_op_inplace(Mat& a, const Option& opt)
{
Op op;
int size = a.total();
#pragma omp parallel for num_threads(opt.num_threads)
for (int i=0; i<size; i++)
{
a[i] = op(a[i]);
}
return 0;
}
|
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x15d80
movl %eax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x77fb4
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x32f10
movq %rax, %rsi
leaq 0x17(%rsp), %rdi
callq 0x78630
movss %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x32f10
movss 0x8(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x77f64
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/unaryop.cpp
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x86015
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x86084
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x86fe4
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::PriorBox::load_param(ncnn::ParamDict const&)
|
int PriorBox::load_param(const ParamDict& pd)
{
min_sizes = pd.get(0, Mat());
max_sizes = pd.get(1, Mat());
aspect_ratios = pd.get(2, Mat());
variances[0] = pd.get(3, 0.1f);
variances[1] = pd.get(4, 0.1f);
variances[2] = pd.get(5, 0.2f);
variances[3] = pd.get(6, 0.2f);
flip = pd.get(7, 1);
clip = pd.get(8, 0);
image_width = pd.get(9, 0);
image_height = pd.get(10, 0);
step_width = pd.get(11, -233.f);
step_height = pd.get(12, -233.f);
offset = pd.get(13, 0.f);
return 0;
}
|
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq 0x1d0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x1c8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x148(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x15850
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rcx
leaq 0x188(%rsp), %rdi
xorl %edx, %edx
callq 0x31250
jmp 0x8719e
movq 0x20(%rsp), %rdi
subq $-0x80, %rdi
leaq 0x188(%rsp), %rsi
callq 0x1b4b0
jmp 0x871b6
leaq 0x188(%rsp), %rdi
callq 0x15950
leaq 0x148(%rsp), %rdi
callq 0x15950
movq 0x1c8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x15850
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
leaq 0xf8(%rsp), %rdi
movl $0x1, %edx
callq 0x31250
jmp 0x8720d
movq 0x20(%rsp), %rdi
addq $0xc0, %rdi
leaq 0xf8(%rsp), %rsi
callq 0x1b4b0
jmp 0x87228
leaq 0xf8(%rsp), %rdi
callq 0x15950
leaq 0xb8(%rsp), %rdi
callq 0x15950
movq 0x1c8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x15850
movq (%rsp), %rsi
movq 0x8(%rsp), %rcx
leaq 0x78(%rsp), %rdi
movl $0x2, %edx
callq 0x31250
jmp 0x87277
movq 0x20(%rsp), %rdi
addq $0x100, %rdi # imm = 0x100
leaq 0x78(%rsp), %rsi
callq 0x1b4b0
jmp 0x8728f
leaq 0x78(%rsp), %rdi
callq 0x15950
leaq 0x38(%rsp), %rdi
callq 0x15950
movq 0x1c8(%rsp), %rdi
movl $0x3, %esi
movss 0x18034(%rip), %xmm0 # 0x9f2ec
callq 0x311f0
movq 0x20(%rsp), %rax
movss %xmm0, 0x140(%rax)
movq 0x1c8(%rsp), %rdi
movl $0x4, %esi
movss 0x1800d(%rip), %xmm0 # 0x9f2ec
callq 0x311f0
movq 0x20(%rsp), %rax
movss %xmm0, 0x144(%rax)
movq 0x1c8(%rsp), %rdi
movl $0x5, %esi
movss 0x1827a(%rip), %xmm0 # 0x9f580
callq 0x311f0
movq 0x20(%rsp), %rax
movss %xmm0, 0x148(%rax)
movq 0x1c8(%rsp), %rdi
movl $0x6, %esi
movss 0x18253(%rip), %xmm0 # 0x9f580
callq 0x311f0
movq 0x20(%rsp), %rax
movss %xmm0, 0x14c(%rax)
movq 0x1c8(%rsp), %rdi
movl $0x7, %esi
movl $0x1, %edx
callq 0x311a0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x150(%rax)
movq 0x1c8(%rsp), %rdi
movl $0x8, %esi
xorl %edx, %edx
callq 0x311a0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x154(%rax)
movq 0x1c8(%rsp), %rdi
movl $0x9, %esi
xorl %edx, %edx
callq 0x311a0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x158(%rax)
movq 0x1c8(%rsp), %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x311a0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x15c(%rax)
movq 0x1c8(%rsp), %rdi
movl $0xb, %esi
movss 0x181a1(%rip), %xmm0 # 0x9f57c
callq 0x311f0
movq 0x20(%rsp), %rax
movss %xmm0, 0x160(%rax)
movq 0x1c8(%rsp), %rdi
movl $0xc, %esi
movss 0x1817a(%rip), %xmm0 # 0x9f57c
callq 0x311f0
movq 0x20(%rsp), %rax
movss %xmm0, 0x164(%rax)
movq 0x1c8(%rsp), %rdi
movl $0xd, %esi
xorps %xmm0, %xmm0
callq 0x311f0
movq 0x20(%rsp), %rax
movss %xmm0, 0x168(%rax)
xorl %eax, %eax
addq $0x1d8, %rsp # imm = 0x1D8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x140(%rsp)
movl %eax, 0x13c(%rsp)
jmp 0x87477
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x140(%rsp)
movl %eax, 0x13c(%rsp)
leaq 0x188(%rsp), %rdi
callq 0x15950
leaq 0x148(%rsp), %rdi
callq 0x15950
jmp 0x8750d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x140(%rsp)
movl %eax, 0x13c(%rsp)
jmp 0x874c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x140(%rsp)
movl %eax, 0x13c(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0x15950
leaq 0xb8(%rsp), %rdi
callq 0x15950
jmp 0x8750d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x140(%rsp)
movl %eax, 0x13c(%rsp)
jmp 0x87503
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x140(%rsp)
movl %eax, 0x13c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x15950
leaq 0x38(%rsp), %rdi
callq 0x15950
movq 0x140(%rsp), %rdi
callq 0x14410
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/priorbox.cpp
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x88485
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::DetectionOutput::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const
|
int DetectionOutput::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& location = bottom_blobs[0];
const Mat& confidence = bottom_blobs[1];
const Mat& priorbox = bottom_blobs[2];
bool mxnet_ssd_style = num_class == -233;
// mxnet-ssd _contrib_MultiBoxDetection
const int num_prior = mxnet_ssd_style ? priorbox.h : priorbox.w / 4;
int num_class_copy = mxnet_ssd_style ? confidence.h : num_class;
// apply location with priorbox
Mat bboxes;
bboxes.create(4, num_prior, 4u, opt.workspace_allocator);
if (bboxes.empty())
return -100;
const float* location_ptr = location;
const float* priorbox_ptr = priorbox.row(0);
const float* variance_ptr = mxnet_ssd_style ? 0 : priorbox.row(1);
#pragma omp parallel for num_threads(opt.num_threads)
for (int i = 0; i < num_prior; i++)
{
const float* loc = location_ptr + i * 4;
const float* pb = priorbox_ptr + i * 4;
const float* var = variance_ptr ? variance_ptr + i * 4 : variances;
float* bbox = bboxes.row(i);
// CENTER_SIZE
float pb_w = pb[2] - pb[0];
float pb_h = pb[3] - pb[1];
float pb_cx = (pb[0] + pb[2]) * 0.5f;
float pb_cy = (pb[1] + pb[3]) * 0.5f;
float bbox_cx = var[0] * loc[0] * pb_w + pb_cx;
float bbox_cy = var[1] * loc[1] * pb_h + pb_cy;
float bbox_w = exp(var[2] * loc[2]) * pb_w;
float bbox_h = exp(var[3] * loc[3]) * pb_h;
bbox[0] = bbox_cx - bbox_w * 0.5f;
bbox[1] = bbox_cy - bbox_h * 0.5f;
bbox[2] = bbox_cx + bbox_w * 0.5f;
bbox[3] = bbox_cy + bbox_h * 0.5f;
}
// sort and nms for each class
std::vector< std::vector<BBoxRect> > all_class_bbox_rects;
std::vector< std::vector<float> > all_class_bbox_scores;
all_class_bbox_rects.resize(num_class_copy);
all_class_bbox_scores.resize(num_class_copy);
// start from 1 to ignore background class
#pragma omp parallel for num_threads(opt.num_threads)
for (int i = 1; i < num_class_copy; i++)
{
// filter by confidence_threshold
std::vector<BBoxRect> class_bbox_rects;
std::vector<float> class_bbox_scores;
for (int j = 0; j < num_prior; j++)
{
// prob data layout
// caffe-ssd = num_class x num_prior
// mxnet-ssd = num_prior x num_class
float score = mxnet_ssd_style ? confidence[i * num_prior + j] : confidence[j * num_class_copy + i];
if (score > confidence_threshold)
{
const float* bbox = bboxes.row(j);
BBoxRect c = { bbox[0], bbox[1], bbox[2], bbox[3], i };
class_bbox_rects.push_back(c);
class_bbox_scores.push_back(score);
}
}
// sort inplace
qsort_descent_inplace(class_bbox_rects, class_bbox_scores);
// keep nms_top_k
if (nms_top_k < (int)class_bbox_rects.size())
{
class_bbox_rects.resize(nms_top_k);
class_bbox_scores.resize(nms_top_k);
}
// apply nms
std::vector<int> picked;
nms_sorted_bboxes(class_bbox_rects, picked, nms_threshold);
// select
for (int j = 0; j < (int)picked.size(); j++)
{
int z = picked[j];
all_class_bbox_rects[i].push_back(class_bbox_rects[z]);
all_class_bbox_scores[i].push_back(class_bbox_scores[z]);
}
}
// gather all class
std::vector<BBoxRect> bbox_rects;
std::vector<float> bbox_scores;
for (int i = 1; i < num_class_copy; i++)
{
const std::vector<BBoxRect>& class_bbox_rects = all_class_bbox_rects[i];
const std::vector<float>& class_bbox_scores = all_class_bbox_scores[i];
bbox_rects.insert(bbox_rects.end(), class_bbox_rects.begin(), class_bbox_rects.end());
bbox_scores.insert(bbox_scores.end(), class_bbox_scores.begin(), class_bbox_scores.end());
}
// global sort inplace
qsort_descent_inplace(bbox_rects, bbox_scores);
// keep_top_k
if (keep_top_k < (int)bbox_rects.size())
{
bbox_rects.resize(keep_top_k);
bbox_scores.resize(keep_top_k);
}
// fill result
int num_detected = bbox_rects.size();
if (num_detected == 0)
return 0;
Mat& top_blob = top_blobs[0];
top_blob.create(6, num_detected, 4u, opt.blob_allocator);
if (top_blob.empty())
return -100;
for (int i = 0; i < num_detected; i++)
{
const BBoxRect& r = bbox_rects[i];
float score = bbox_scores[i];
float* outptr = top_blob.row(i);
outptr[0] = r.label;
outptr[1] = score;
outptr[2] = r.xmin;
outptr[3] = r.ymin;
outptr[4] = r.xmax;
outptr[5] = r.ymax;
}
return 0;
}
|
subq $0x358, %rsp # imm = 0x358
movq %rdi, 0x348(%rsp)
movq %rsi, 0x340(%rsp)
movq %rdx, 0x338(%rsp)
movq %rcx, 0x330(%rsp)
movq 0x348(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x340(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b2d0
movq %rax, 0x328(%rsp)
movq 0x340(%rsp), %rdi
movl $0x1, %esi
callq 0x1b2d0
movq %rax, 0x320(%rsp)
movq 0x340(%rsp), %rdi
movl $0x2, %esi
callq 0x1b2d0
movq %rax, %rcx
movq 0xd8(%rsp), %rax
movq %rcx, 0x318(%rsp)
cmpl $0xffffff17, 0x80(%rax) # imm = 0xFFFFFF17
sete %al
andb $0x1, %al
movb %al, 0x317(%rsp)
testb $0x1, 0x317(%rsp)
je 0x887d3
movq 0x318(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0xd4(%rsp)
jmp 0x887ed
movq 0x318(%rsp), %rax
movl 0x2c(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, 0xd4(%rsp)
movl 0xd4(%rsp), %eax
movl %eax, 0x310(%rsp)
testb $0x1, 0x317(%rsp)
je 0x88819
movq 0x320(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0xd0(%rsp)
jmp 0x8882e
movq 0xd8(%rsp), %rax
movl 0x80(%rax), %eax
movl %eax, 0xd0(%rsp)
movl 0xd0(%rsp), %eax
movl %eax, 0x30c(%rsp)
leaq 0x2c8(%rsp), %rdi
movq %rdi, 0xc8(%rsp)
callq 0x15850
movq 0xc8(%rsp), %rdi
movl 0x310(%rsp), %edx
movq 0x330(%rsp), %rax
movq 0x10(%rax), %r8
movl $0x4, %esi
movl $0x4, %ecx
callq 0x34890
jmp 0x8887d
leaq 0x2c8(%rsp), %rdi
callq 0x1b5a0
movb %al, 0xc7(%rsp)
jmp 0x88893
movb 0xc7(%rsp), %al
testb $0x1, %al
jne 0x888a0
jmp 0x888d4
movl $0xffffff9c, 0x354(%rsp) # imm = 0xFFFFFF9C
movl $0x1, 0x2b8(%rsp)
jmp 0x895e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2c0(%rsp)
movl %eax, 0x2bc(%rsp)
jmp 0x89604
movq 0x328(%rsp), %rdi
callq 0x34880
movq %rax, 0xb8(%rsp)
jmp 0x888eb
movq 0xb8(%rsp), %rax
movq %rax, 0x2b0(%rsp)
movq 0x318(%rsp), %rdi
xorl %esi, %esi
callq 0x34a00
movq %rax, 0xb0(%rsp)
jmp 0x88914
movq 0xb0(%rsp), %rax
movq %rax, 0x2a8(%rsp)
testb $0x1, 0x317(%rsp)
je 0x8893a
xorl %eax, %eax
movq %rax, 0xa8(%rsp)
jmp 0x88968
movq 0x318(%rsp), %rdi
movl $0x1, %esi
callq 0x34a00
movq %rax, 0xa0(%rsp)
jmp 0x88956
movq 0xa0(%rsp), %rax
movq %rax, 0xa8(%rsp)
jmp 0x88968
movq 0xa8(%rsp), %rax
movq %rax, 0x2a0(%rsp)
movl $0x0, 0x29c(%rsp)
movl 0x29c(%rsp), %eax
cmpl 0x310(%rsp), %eax
jge 0x88cc5
movq 0x2b0(%rsp), %rax
movl 0x29c(%rsp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x290(%rsp)
movq 0x2a8(%rsp), %rax
movl 0x29c(%rsp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x288(%rsp)
cmpq $0x0, 0x2a0(%rsp)
je 0x88a10
movq 0x2a0(%rsp), %rax
movl 0x29c(%rsp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x98(%rsp)
jmp 0x88a26
movq 0xd8(%rsp), %rax
addq $0x94, %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x280(%rsp)
movl 0x29c(%rsp), %esi
leaq 0x2c8(%rsp), %rdi
callq 0x32f50
movq %rax, 0x90(%rsp)
jmp 0x88a54
movq 0x90(%rsp), %rax
movq %rax, 0x278(%rsp)
movq 0x288(%rsp), %rax
movss (%rax), %xmm1
movss 0x8(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x274(%rsp)
movq 0x288(%rsp), %rax
movss 0x4(%rax), %xmm1
movss 0xc(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x270(%rsp)
movq 0x288(%rsp), %rax
movss (%rax), %xmm0
movss 0x8(%rax), %xmm1
addss %xmm1, %xmm0
movss 0x1555a(%rip), %xmm1 # 0x9e018
mulss %xmm1, %xmm0
movss %xmm0, 0x26c(%rsp)
movq 0x288(%rsp), %rax
movss 0x4(%rax), %xmm0
movss 0xc(%rax), %xmm2
addss %xmm2, %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x268(%rsp)
movq 0x280(%rsp), %rax
movss (%rax), %xmm0
movq 0x290(%rsp), %rax
movss (%rax), %xmm1
mulss %xmm1, %xmm0
movss 0x274(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x26c(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x264(%rsp)
movq 0x280(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x290(%rsp), %rax
movss 0x4(%rax), %xmm1
mulss %xmm1, %xmm0
movss 0x270(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x268(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x260(%rsp)
movq 0x280(%rsp), %rax
movss 0x8(%rax), %xmm0
movq 0x290(%rsp), %rax
movss 0x8(%rax), %xmm1
mulss %xmm1, %xmm0
callq 0x335e0
movss %xmm0, 0x8c(%rsp)
jmp 0x88b9c
movss 0x8c(%rsp), %xmm0
movss 0x274(%rsp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x25c(%rsp)
movq 0x280(%rsp), %rax
movss 0xc(%rax), %xmm0
movq 0x290(%rsp), %rax
movss 0xc(%rax), %xmm1
mulss %xmm1, %xmm0
callq 0x335e0
movss %xmm0, 0x88(%rsp)
jmp 0x88be9
movss 0x88(%rsp), %xmm0
mulss 0x270(%rsp), %xmm0
movss %xmm0, 0x258(%rsp)
movss 0x264(%rsp), %xmm0
movss 0x15403(%rip), %xmm1 # 0x9e018
mulss 0x25c(%rsp), %xmm1
subss %xmm1, %xmm0
movq 0x278(%rsp), %rax
movss %xmm0, (%rax)
movss 0x260(%rsp), %xmm0
movss 0x153d9(%rip), %xmm1 # 0x9e018
mulss 0x258(%rsp), %xmm1
subss %xmm1, %xmm0
movq 0x278(%rsp), %rax
movss %xmm0, 0x4(%rax)
movss 0x264(%rsp), %xmm0
movss 0x153ae(%rip), %xmm1 # 0x9e018
mulss 0x25c(%rsp), %xmm1
addss %xmm1, %xmm0
movq 0x278(%rsp), %rax
movss %xmm0, 0x8(%rax)
movss 0x260(%rsp), %xmm0
movss 0x15383(%rip), %xmm1 # 0x9e018
mulss 0x258(%rsp), %xmm1
addss %xmm1, %xmm0
movq 0x278(%rsp), %rax
movss %xmm0, 0xc(%rax)
movl 0x29c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x29c(%rsp)
jmp 0x88983
leaq 0x240(%rsp), %rdi
movq %rdi, 0x80(%rsp)
callq 0x89cb0
leaq 0x228(%rsp), %rdi
callq 0x89cc0
movq 0x80(%rsp), %rdi
movslq 0x30c(%rsp), %rsi
callq 0x89cd0
jmp 0x88cfe
movslq 0x30c(%rsp), %rsi
leaq 0x228(%rsp), %rdi
callq 0x89d70
jmp 0x88d15
movl $0x1, 0x224(%rsp)
movl 0x224(%rsp), %eax
cmpl 0x30c(%rsp), %eax
jge 0x8913f
leaq 0x208(%rsp), %rdi
callq 0x89e10
leaq 0x1f0(%rsp), %rdi
callq 0x38020
movl $0x0, 0x1ec(%rsp)
movl 0x1ec(%rsp), %eax
cmpl 0x310(%rsp), %eax
jge 0x88f27
testb $0x1, 0x317(%rsp)
je 0x88db6
movq 0x320(%rsp), %rdi
movl 0x224(%rsp), %esi
movl 0x310(%rsp), %eax
imull %eax, %esi
movl 0x1ec(%rsp), %eax
addl %eax, %esi
callq 0x32f30
movq %rax, 0x78(%rsp)
jmp 0x88da5
movq 0x78(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x74(%rsp)
jmp 0x88df3
movq 0x320(%rsp), %rdi
movl 0x1ec(%rsp), %esi
movl 0x30c(%rsp), %eax
imull %eax, %esi
movl 0x224(%rsp), %eax
addl %eax, %esi
callq 0x32f30
movq %rax, 0x68(%rsp)
jmp 0x88de4
movq 0x68(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x74(%rsp)
movq 0xd8(%rsp), %rax
movss 0x74(%rsp), %xmm0
movss %xmm0, 0x1e8(%rsp)
movss 0x1e8(%rsp), %xmm0
ucomiss 0x90(%rax), %xmm0
jbe 0x88f0f
movl 0x1ec(%rsp), %esi
leaq 0x2c8(%rsp), %rdi
callq 0x32f50
movq %rax, 0x60(%rsp)
jmp 0x88e3b
movq 0x60(%rsp), %rax
movq %rax, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x1cc(%rsp)
movq 0x1e0(%rsp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, 0x1d0(%rsp)
movq 0x1e0(%rsp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, 0x1d4(%rsp)
movq 0x1e0(%rsp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, 0x1d8(%rsp)
movl 0x224(%rsp), %eax
movl %eax, 0x1dc(%rsp)
leaq 0x208(%rsp), %rdi
leaq 0x1cc(%rsp), %rsi
callq 0x89e20
jmp 0x88ec4
leaq 0x1f0(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x38090
jmp 0x88edb
jmp 0x88f0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2c0(%rsp)
movl %eax, 0x2bc(%rsp)
jmp 0x895cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2c0(%rsp)
movl %eax, 0x2bc(%rsp)
jmp 0x89120
jmp 0x88f11
movl 0x1ec(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1ec(%rsp)
jmp 0x88d59
leaq 0x208(%rsp), %rdi
leaq 0x1f0(%rsp), %rsi
callq 0x89620
jmp 0x88f3e
movq 0xd8(%rsp), %rax
movl 0x88(%rax), %eax
movl %eax, 0x5c(%rsp)
leaq 0x208(%rsp), %rdi
callq 0x89e90
movq %rax, %rcx
movl 0x5c(%rsp), %eax
cmpl %ecx, %eax
jge 0x88fa6
movq 0xd8(%rsp), %rax
movslq 0x88(%rax), %rsi
leaq 0x208(%rsp), %rdi
callq 0x89eb0
jmp 0x88f86
movq 0xd8(%rsp), %rax
movslq 0x88(%rax), %rsi
leaq 0x1f0(%rsp), %rdi
callq 0x5ba00
jmp 0x88fa4
jmp 0x88fa6
leaq 0x1b0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x1af80
movq 0xd8(%rsp), %rax
movq 0x50(%rsp), %rsi
movss 0x84(%rax), %xmm0
leaq 0x208(%rsp), %rdi
callq 0x89690
jmp 0x88fdc
movl $0x0, 0x1ac(%rsp)
movl 0x1ac(%rsp), %eax
movl %eax, 0x4c(%rsp)
leaq 0x1b0(%rsp), %rdi
callq 0x2c4a0
movq %rax, %rcx
movl 0x4c(%rsp), %eax
cmpl %ecx, %eax
jge 0x890e3
movslq 0x1ac(%rsp), %rsi
leaq 0x1b0(%rsp), %rdi
callq 0x2c280
movl (%rax), %eax
movl %eax, 0x1a8(%rsp)
movslq 0x224(%rsp), %rsi
leaq 0x240(%rsp), %rdi
callq 0x89f50
movq %rax, 0x40(%rsp)
movslq 0x1a8(%rsp), %rsi
leaq 0x208(%rsp), %rdi
callq 0x89f70
movq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x89e20
jmp 0x8906a
movslq 0x224(%rsp), %rsi
leaq 0x228(%rsp), %rdi
callq 0x89f90
movq %rax, 0x38(%rsp)
movslq 0x1a8(%rsp), %rsi
leaq 0x1f0(%rsp), %rdi
callq 0x4de80
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x38090
jmp 0x890a8
jmp 0x890aa
movl 0x1ac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1ac(%rsp)
jmp 0x88fe7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2c0(%rsp)
movl %eax, 0x2bc(%rsp)
leaq 0x1b0(%rsp), %rdi
callq 0x1af90
jmp 0x89120
leaq 0x1b0(%rsp), %rdi
callq 0x1af90
leaq 0x1f0(%rsp), %rdi
callq 0x1c3e0
leaq 0x208(%rsp), %rdi
callq 0x89fb0
movl 0x224(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x224(%rsp)
jmp 0x88d20
leaq 0x1f0(%rsp), %rdi
callq 0x1c3e0
leaq 0x208(%rsp), %rdi
callq 0x89fb0
jmp 0x895cc
leaq 0x190(%rsp), %rdi
callq 0x89e10
leaq 0x178(%rsp), %rdi
callq 0x38020
movl $0x1, 0x174(%rsp)
movl 0x174(%rsp), %eax
cmpl 0x30c(%rsp), %eax
jge 0x89319
movslq 0x174(%rsp), %rsi
leaq 0x240(%rsp), %rdi
callq 0x89f50
movq %rax, 0x168(%rsp)
movslq 0x174(%rsp), %rsi
leaq 0x228(%rsp), %rdi
callq 0x89f90
movq %rax, 0x160(%rsp)
leaq 0x190(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x8a0d0
movq %rax, 0x150(%rsp)
leaq 0x158(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x8a100
movq 0x168(%rsp), %rdi
callq 0x8a140
movq %rax, 0x148(%rsp)
movq 0x168(%rsp), %rdi
callq 0x8a170
movq 0x28(%rsp), %rdi
movq %rax, 0x140(%rsp)
movq 0x158(%rsp), %rsi
movq 0x148(%rsp), %rdx
movq 0x140(%rsp), %rcx
callq 0x8a010
movq %rax, 0x30(%rsp)
jmp 0x89234
movq 0x30(%rsp), %rax
movq %rax, 0x138(%rsp)
leaq 0x178(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x386e0
movq %rax, 0x128(%rsp)
leaq 0x130(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x8a260
movq 0x160(%rsp), %rdi
callq 0x4e020
movq %rax, 0x120(%rsp)
movq 0x160(%rsp), %rdi
callq 0x4e050
movq 0x18(%rsp), %rdi
movq %rax, 0x118(%rsp)
movq 0x130(%rsp), %rsi
movq 0x120(%rsp), %rdx
movq 0x118(%rsp), %rcx
callq 0x8a1a0
movq %rax, 0x20(%rsp)
jmp 0x892c3
movq 0x20(%rsp), %rax
movq %rax, 0x110(%rsp)
movl 0x174(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x174(%rsp)
jmp 0x89164
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2c0(%rsp)
movl %eax, 0x2bc(%rsp)
leaq 0x178(%rsp), %rdi
callq 0x1c3e0
leaq 0x190(%rsp), %rdi
callq 0x89fb0
jmp 0x895cc
leaq 0x190(%rsp), %rdi
leaq 0x178(%rsp), %rsi
callq 0x89620
jmp 0x89330
movq 0xd8(%rsp), %rax
movl 0x8c(%rax), %eax
movl %eax, 0x14(%rsp)
leaq 0x190(%rsp), %rdi
callq 0x89e90
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x89398
movq 0xd8(%rsp), %rax
movslq 0x8c(%rax), %rsi
leaq 0x190(%rsp), %rdi
callq 0x89eb0
jmp 0x89378
movq 0xd8(%rsp), %rax
movslq 0x8c(%rax), %rsi
leaq 0x178(%rsp), %rdi
callq 0x5ba00
jmp 0x89396
jmp 0x89398
leaq 0x190(%rsp), %rdi
callq 0x89e90
movl %eax, 0x10c(%rsp)
cmpl $0x0, 0x10c(%rsp)
jne 0x893d1
movl $0x0, 0x354(%rsp)
movl $0x1, 0x2b8(%rsp)
jmp 0x89596
movq 0x338(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b490
movq %rax, 0x100(%rsp)
movq 0x100(%rsp), %rdi
movl 0x10c(%rsp), %edx
movq 0x330(%rsp), %rax
movq 0x8(%rax), %r8
movl $0x6, %esi
movl $0x4, %ecx
callq 0x34890
jmp 0x89416
movq 0x100(%rsp), %rdi
callq 0x1b5a0
movb %al, 0x13(%rsp)
jmp 0x89429
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x89433
jmp 0x8944e
movl $0xffffff9c, 0x354(%rsp) # imm = 0xFFFFFF9C
movl $0x1, 0x2b8(%rsp)
jmp 0x89596
movl $0x0, 0xfc(%rsp)
movl 0xfc(%rsp), %eax
cmpl 0x10c(%rsp), %eax
jge 0x89580
movslq 0xfc(%rsp), %rsi
leaq 0x190(%rsp), %rdi
callq 0x89f70
movq %rax, 0xf0(%rsp)
movslq 0xfc(%rsp), %rsi
leaq 0x178(%rsp), %rdi
callq 0x4de80
movss (%rax), %xmm0
movss %xmm0, 0xec(%rsp)
movq 0x100(%rsp), %rdi
movl 0xfc(%rsp), %esi
callq 0x32f50
movq %rax, 0x8(%rsp)
jmp 0x894c7
movq 0x8(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
cvtsi2ssl 0x10(%rax), %xmm0
movq 0xe0(%rsp), %rax
movss %xmm0, (%rax)
movss 0xec(%rsp), %xmm0
movq 0xe0(%rsp), %rax
movss %xmm0, 0x4(%rax)
movq 0xf0(%rsp), %rax
movss (%rax), %xmm0
movq 0xe0(%rsp), %rax
movss %xmm0, 0x8(%rax)
movq 0xf0(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0xe0(%rsp), %rax
movss %xmm0, 0xc(%rax)
movq 0xf0(%rsp), %rax
movss 0x8(%rax), %xmm0
movq 0xe0(%rsp), %rax
movss %xmm0, 0x10(%rax)
movq 0xf0(%rsp), %rax
movss 0xc(%rax), %xmm0
movq 0xe0(%rsp), %rax
movss %xmm0, 0x14(%rax)
movl 0xfc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xfc(%rsp)
jmp 0x89459
movl $0x0, 0x354(%rsp)
movl $0x1, 0x2b8(%rsp)
leaq 0x178(%rsp), %rdi
callq 0x1c3e0
leaq 0x190(%rsp), %rdi
callq 0x89fb0
leaq 0x228(%rsp), %rdi
callq 0x8a2a0
leaq 0x240(%rsp), %rdi
callq 0x8a300
jmp 0x895e8
leaq 0x228(%rsp), %rdi
callq 0x8a2a0
leaq 0x240(%rsp), %rdi
callq 0x8a300
jmp 0x89604
leaq 0x2c8(%rsp), %rdi
callq 0x15950
movl 0x354(%rsp), %eax
addq $0x358, %rsp # imm = 0x358
retq
leaq 0x2c8(%rsp), %rdi
callq 0x15950
movq 0x2c0(%rsp), %rdi
callq 0x14410
nop
|
/tongxiaobin[P]ncnn/src/layer/detectionoutput.cpp
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x899e4
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::interpolate_cubic(float, float*)
|
static inline void interpolate_cubic(float fx, float* coeffs)
{
const float A = -0.75f;
float fx0 = fx + 1;
float fx1 = fx;
float fx2 = 1 - fx;
// float fx3 = 2 - fx;
coeffs[0] = A * fx0*fx0*fx0 - 5*A * fx0*fx0 + 8*A * fx0 - 4*A;
coeffs[1] = (A+2) * fx1*fx1*fx1 - (A+3) * fx1*fx1 + 1;
coeffs[2] = (A+2) * fx2*fx2*fx2 - (A+3) * fx2*fx2 + 1;
coeffs[3] = 1.f - coeffs[0] - coeffs[1] - coeffs[2];
}
|
movss %xmm0, -0x4(%rsp)
movq %rdi, -0x10(%rsp)
movss 0xde21(%rip), %xmm0 # 0x9f5e4
movss %xmm0, -0x14(%rsp)
movss 0xca53(%rip), %xmm0 # 0x9e224
addss -0x4(%rsp), %xmm0
movss %xmm0, -0x18(%rsp)
movss -0x4(%rsp), %xmm0
movss %xmm0, -0x1c(%rsp)
movss 0xca33(%rip), %xmm0 # 0x9e224
subss -0x4(%rsp), %xmm0
movss %xmm0, -0x20(%rsp)
movss 0xdddf(%rip), %xmm0 # 0x9f5e4
mulss -0x18(%rsp), %xmm0
mulss -0x18(%rsp), %xmm0
mulss -0x18(%rsp), %xmm0
movss 0xddc1(%rip), %xmm1 # 0x9f5e0
mulss -0x18(%rsp), %xmm1
mulss -0x18(%rsp), %xmm1
subss %xmm1, %xmm0
movss 0xdda5(%rip), %xmm1 # 0x9f5dc
mulss -0x18(%rsp), %xmm1
addss %xmm1, %xmm0
movss 0xdd8f(%rip), %xmm1 # 0x9f5d8
subss %xmm1, %xmm0
movq -0x10(%rsp), %rax
movss %xmm0, (%rax)
movss 0xdd76(%rip), %xmm0 # 0x9f5d4
mulss -0x1c(%rsp), %xmm0
mulss -0x1c(%rsp), %xmm0
mulss -0x1c(%rsp), %xmm0
movss 0xdd58(%rip), %xmm1 # 0x9f5d0
mulss -0x1c(%rsp), %xmm1
mulss -0x1c(%rsp), %xmm1
subss %xmm1, %xmm0
movss 0xc994(%rip), %xmm1 # 0x9e224
addss %xmm1, %xmm0
movq -0x10(%rsp), %rax
movss %xmm0, 0x4(%rax)
movss 0xdd2e(%rip), %xmm0 # 0x9f5d4
mulss -0x20(%rsp), %xmm0
mulss -0x20(%rsp), %xmm0
mulss -0x20(%rsp), %xmm0
movss 0xdd10(%rip), %xmm1 # 0x9f5d0
mulss -0x20(%rsp), %xmm1
mulss -0x20(%rsp), %xmm1
subss %xmm1, %xmm0
movss 0xc94c(%rip), %xmm1 # 0x9e224
addss %xmm1, %xmm0
movq -0x10(%rsp), %rax
movss %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movss 0xc931(%rip), %xmm0 # 0x9e224
subss (%rax), %xmm0
movq -0x10(%rsp), %rax
subss 0x4(%rax), %xmm0
movq -0x10(%rsp), %rax
subss 0x8(%rax), %xmm0
movq -0x10(%rsp), %rax
movss %xmm0, 0xc(%rax)
retq
nopw %cs:(%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/interp.cpp
|
ncnn::DeconvolutionDepthWise::load_param(ncnn::ParamDict const&)
|
int DeconvolutionDepthWise::load_param(const ParamDict& pd)
{
num_output = pd.get(0, 0);
kernel_w = pd.get(1, 0);
kernel_h = pd.get(11, kernel_w);
dilation_w = pd.get(2, 1);
dilation_h = pd.get(12, dilation_w);
stride_w = pd.get(3, 1);
stride_h = pd.get(13, stride_w);
pad_w = pd.get(4, 0);
pad_h = pd.get(14, pad_w);
bias_term = pd.get(5, 0);
weight_data_size = pd.get(6, 0);
group = pd.get(7, 1);
activation_type = pd.get(9, 0);
activation_params = pd.get(10, Mat());
return 0;
}
|
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xb8(%rsp), %rdi
xorl %edx, %edx
movl %edx, 0xc(%rsp)
movl %edx, %esi
callq 0x311a0
movl 0xc(%rsp), %edx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x80(%rax)
movq 0xb8(%rsp), %rdi
movl $0x1, %esi
movl %esi, 0x8(%rsp)
callq 0x311a0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x84(%rax)
movq 0xb8(%rsp), %rdi
movl 0x84(%rax), %edx
movl $0xb, %esi
callq 0x311a0
movl 0x8(%rsp), %edx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x88(%rax)
movq 0xb8(%rsp), %rdi
movl $0x2, %esi
callq 0x311a0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8c(%rax)
movq 0xb8(%rsp), %rdi
movl 0x8c(%rax), %edx
movl $0xc, %esi
callq 0x311a0
movl 0x8(%rsp), %edx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x90(%rax)
movq 0xb8(%rsp), %rdi
movl $0x3, %esi
callq 0x311a0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x94(%rax)
movq 0xb8(%rsp), %rdi
movl 0x94(%rax), %edx
movl $0xd, %esi
callq 0x311a0
movl 0xc(%rsp), %edx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x98(%rax)
movq 0xb8(%rsp), %rdi
movl $0x4, %esi
callq 0x311a0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x9c(%rax)
movq 0xb8(%rsp), %rdi
movl 0x9c(%rax), %edx
movl $0xe, %esi
callq 0x311a0
movl 0xc(%rsp), %edx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xa0(%rax)
movq 0xb8(%rsp), %rdi
movl $0x5, %esi
callq 0x311a0
movl 0xc(%rsp), %edx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xa4(%rax)
movq 0xb8(%rsp), %rdi
movl $0x6, %esi
callq 0x311a0
movl 0x8(%rsp), %edx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xa8(%rax)
movq 0xb8(%rsp), %rdi
movl $0x7, %esi
callq 0x311a0
movl 0xc(%rsp), %edx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xac(%rax)
movq 0xb8(%rsp), %rdi
movl $0x9, %esi
callq 0x311a0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xb0(%rax)
movq 0xb8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x15850
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rcx
leaq 0x78(%rsp), %rdi
movl $0xa, %edx
callq 0x31250
jmp 0x91c9d
movq 0x10(%rsp), %rdi
addq $0xb8, %rdi
leaq 0x78(%rsp), %rsi
callq 0x1b4b0
jmp 0x91cb5
leaq 0x78(%rsp), %rdi
callq 0x15950
leaq 0x38(%rsp), %rdi
callq 0x15950
xorl %eax, %eax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x91cfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x15950
leaq 0x38(%rsp), %rdi
callq 0x15950
movq 0x30(%rsp), %rdi
callq 0x14410
nop
|
/tongxiaobin[P]ncnn/src/layer/deconvolutiondepthwise.cpp
|
ncnn::DeconvolutionDepthWise::load_model(ncnn::ModelBin const&)
|
int DeconvolutionDepthWise::load_model(const ModelBin& mb)
{
weight_data = mb.load(weight_data_size, 0);
if (weight_data.empty())
return -100;
if (bias_term)
{
bias_data = mb.load(num_output, 1);
if (bias_data.empty())
return -100;
}
return 0;
}
|
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xb0(%rsp), %rsi
movl 0xa8(%rax), %edx
movq (%rsi), %rax
movq (%rax), %rax
leaq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorl %ecx, %ecx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0xf8, %rdi
callq 0x1b4b0
jmp 0x91d6e
leaq 0x70(%rsp), %rdi
callq 0x15950
movq 0x10(%rsp), %rdi
addq $0xf8, %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x91d8f
jmp 0x91dbc
movl $0xffffff9c, 0xc4(%rsp) # imm = 0xFFFFFF9C
jmp 0x91e65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x15950
jmp 0x91e74
movq 0x10(%rsp), %rax
cmpl $0x0, 0xa4(%rax)
je 0x91e5a
movq 0x10(%rsp), %rax
movq 0xb0(%rsp), %rsi
movl 0x80(%rax), %edx
movq (%rsi), %rax
movq (%rax), %rax
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %ecx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x138, %rdi # imm = 0x138
callq 0x1b4b0
jmp 0x91e10
leaq 0x20(%rsp), %rdi
callq 0x15950
movq 0x10(%rsp), %rdi
addq $0x138, %rdi # imm = 0x138
callq 0x1b5a0
testb $0x1, %al
jne 0x91e31
jmp 0x91e58
movl $0xffffff9c, 0xc4(%rsp) # imm = 0xFFFFFF9C
jmp 0x91e65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x15950
jmp 0x91e74
jmp 0x91e5a
movl $0x0, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x14410
nop
|
/tongxiaobin[P]ncnn/src/layer/deconvolutiondepthwise.cpp
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x939d4
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x939f5
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::InstanceNorm::load_model(ncnn::ModelBin const&)
|
int InstanceNorm::load_model(const ModelBin& mb)
{
gamma_data = mb.load(channels, 1);
if (gamma_data.empty())
return -100;
beta_data = mb.load(channels, 1);
if (beta_data.empty())
return -100;
return 0;
}
|
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xb0(%rsp), %rsi
movl 0x80(%rax), %edx
movq (%rsi), %rax
movq (%rax), %rax
leaq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %ecx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x88, %rdi
callq 0x1b4b0
jmp 0x93bf1
leaq 0x70(%rsp), %rdi
callq 0x15950
movq 0x10(%rsp), %rdi
addq $0x88, %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x93c12
jmp 0x93c3f
movl $0xffffff9c, 0xc4(%rsp) # imm = 0xFFFFFF9C
jmp 0x93cd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x15950
jmp 0x93ce3
movq 0x10(%rsp), %rax
movq 0xb0(%rsp), %rsi
movl 0x80(%rax), %edx
movq (%rsi), %rax
movq (%rax), %rax
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %ecx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0xc8, %rdi
callq 0x1b4b0
jmp 0x93c81
leaq 0x20(%rsp), %rdi
callq 0x15950
movq 0x10(%rsp), %rdi
addq $0xc8, %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x93ca2
jmp 0x93cc9
movl $0xffffff9c, 0xc4(%rsp) # imm = 0xFFFFFF9C
jmp 0x93cd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x15950
jmp 0x93ce3
movl $0x0, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x14410
nopl (%rax)
|
/tongxiaobin[P]ncnn/src/layer/instancenorm.cpp
|
ncnn::InstanceNorm::forward_inplace(ncnn::Mat&, ncnn::Option const&) const
|
int InstanceNorm::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
// x = (x - mean) / (sqrt(var) + eps) * gamma + beta
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
float* ptr = bottom_top_blob.channel(q);
// mean and var
float sum = 0.f;
float sqsum = 0.f;
for (int i=0; i<size; i++)
{
sum += ptr[i];
//sqsum += ptr[i] * ptr[i];
}
float mean = sum / size;
float tmp = 0.f;
for (int i=0; i<size; i++)
{
tmp = ptr[i] - mean;
sqsum += tmp * tmp;
}
float var = sqsum / size;
// the var maybe minus due to accuracy
//float var = sqsum / size - mean * mean;
float gamma = gamma_data[q];
float beta = beta_data[q];
float a = gamma / (sqrt(var + eps));
float b = - mean * a + beta;
for (int i=0; i<size; i++)
{
ptr[i] = ptr[i] * a + b;
}
}
return 0;
}
|
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xc8(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0xbc(%rsp)
movq 0xc8(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0xb8(%rsp)
movl 0xbc(%rsp), %eax
imull 0xb8(%rsp), %eax
movl %eax, 0xb4(%rsp)
movl $0x0, 0xb0(%rsp)
movq 0x20(%rsp), %rcx
movl 0xb0(%rsp), %eax
cmpl 0x80(%rcx), %eax
jge 0x93fce
movq 0xc8(%rsp), %rsi
movl 0xb0(%rsp), %edx
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x322b0
movq 0x10(%rsp), %rdi
callq 0x25f80
movq %rax, 0x18(%rsp)
jmp 0x93da8
leaq 0x68(%rsp), %rdi
callq 0x15950
movq 0x18(%rsp), %rax
movq %rax, 0xa8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x58(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x54(%rsp)
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
cmpl 0xb4(%rsp), %eax
jge 0x93e2e
movq 0xa8(%rsp), %rax
movslq 0x50(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
addss 0x58(%rsp), %xmm0
movss %xmm0, 0x58(%rsp)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x93dd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x15950
jmp 0x93fd8
movss 0x58(%rsp), %xmm0
cvtsi2ssl 0xb4(%rsp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x4c(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0xb4(%rsp), %eax
jge 0x93ea8
movq 0xa8(%rsp), %rax
movslq 0x44(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
subss 0x4c(%rsp), %xmm0
movss %xmm0, 0x48(%rsp)
movss 0x48(%rsp), %xmm0
mulss 0x48(%rsp), %xmm0
addss 0x54(%rsp), %xmm0
movss %xmm0, 0x54(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x93e58
movq 0x20(%rsp), %rdi
movss 0x54(%rsp), %xmm0
cvtsi2ssl 0xb4(%rsp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x40(%rsp)
addq $0x88, %rdi
movl 0xb0(%rsp), %esi
callq 0x32f30
movq 0x20(%rsp), %rdi
movss (%rax), %xmm0
movss %xmm0, 0x3c(%rsp)
addq $0xc8, %rdi
movl 0xb0(%rsp), %esi
callq 0x32f30
movq %rax, %rcx
movq 0x20(%rsp), %rax
movss (%rcx), %xmm0
movss %xmm0, 0x38(%rsp)
movss 0x3c(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x40(%rsp), %xmm0
addss 0x84(%rax), %xmm0
callq 0x32ef0
movaps %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x34(%rsp)
movss 0x4c(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
mulss 0x34(%rsp), %xmm0
addss 0x38(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0xb4(%rsp), %eax
jge 0x93fb6
movq 0xa8(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
mulss 0x34(%rsp), %xmm0
addss 0x30(%rsp), %xmm0
movq 0xa8(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x93f6c
jmp 0x93fb8
movl 0xb0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb0(%rsp)
jmp 0x93d61
xorl %eax, %eax
addq $0xd8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x14410
nopw %cs:(%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/instancenorm.cpp
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x94005
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::Clip::forward_inplace(ncnn::Mat&, ncnn::Option const&) const
|
int Clip::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
float* ptr = bottom_top_blob.channel(q);
for (int i=0; i<size; i++)
{
if (ptr[i] < min)
ptr[i] = min;
if (ptr[i] > max)
ptr[i] = max;
}
}
return 0;
}
|
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x98(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x8c(%rsp)
movq 0x98(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x88(%rsp)
movq 0x98(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x84(%rsp)
movl 0x8c(%rsp), %eax
imull 0x88(%rsp), %eax
movl %eax, 0x80(%rsp)
movl $0x0, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0x84(%rsp), %eax
jge 0x942e0
movq 0x98(%rsp), %rsi
movl 0x7c(%rsp), %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x322b0
movq 0x8(%rsp), %rdi
callq 0x25f80
movq %rax, 0x10(%rsp)
jmp 0x941fd
leaq 0x30(%rsp), %rdi
callq 0x15950
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x80(%rsp), %eax
jge 0x942ce
movq 0x18(%rsp), %rax
movq 0x70(%rsp), %rcx
movslq 0x20(%rsp), %rdx
movss (%rcx,%rdx,4), %xmm1
movss 0x80(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x94283
movq 0x18(%rsp), %rax
movss 0x80(%rax), %xmm0
movq 0x70(%rsp), %rax
movslq 0x20(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x94283
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x15950
jmp 0x942ea
movq 0x18(%rsp), %rax
movq 0x70(%rsp), %rcx
movslq 0x20(%rsp), %rdx
movss (%rcx,%rdx,4), %xmm0
ucomiss 0x84(%rax), %xmm0
jbe 0x942bc
movq 0x18(%rsp), %rax
movss 0x84(%rax), %xmm0
movq 0x70(%rsp), %rax
movslq 0x20(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x942be
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x94219
jmp 0x942d0
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x941c0
xorl %eax, %eax
addq $0xa8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x14410
nopw %cs:(%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/clip.cpp
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x94315
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::Reorg::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const
|
int Reorg::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int channels = bottom_blob.c;
size_t elemsize = bottom_blob.elemsize;
int outw = w / stride;
int outh = h / stride;
int outc = channels * stride * stride;
top_blob.create(outw, outh, outc, elemsize, opt.blob_allocator);
if (top_blob.empty())
return -100;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
const Mat m = bottom_blob.channel(q);
for (int sh = 0; sh < stride; sh++)
{
for (int sw = 0; sw < stride; sw++)
{
float* outptr = top_blob.channel(q*stride*stride + sh*stride + sw);
for (int i = 0; i < outh; i++)
{
const float* sptr = m.row(i*stride + sh) + sw;
for (int j = 0; j < outw; j++)
{
outptr[0] = sptr[0];
sptr += stride;
outptr++;
}
}
}
}
}
return 0;
}
|
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0xf8(%rsp)
movq %rcx, 0xf0(%rsp)
movq 0x108(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x100(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0xec(%rsp)
movq 0x100(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0xe8(%rsp)
movq 0x100(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0xe4(%rsp)
movq 0x100(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xd8(%rsp)
movl 0xec(%rsp), %eax
cltd
idivl 0x80(%rcx)
movl %eax, 0xd4(%rsp)
movl 0xe8(%rsp), %eax
cltd
idivl 0x80(%rcx)
movl %eax, 0xd0(%rsp)
movl 0xe4(%rsp), %eax
imull 0x80(%rcx), %eax
imull 0x80(%rcx), %eax
movl %eax, 0xcc(%rsp)
movq 0xf8(%rsp), %rdi
movl 0xd4(%rsp), %esi
movl 0xd0(%rsp), %edx
movl 0xcc(%rsp), %ecx
movq 0xd8(%rsp), %r8
movq 0xf0(%rsp), %rax
movq 0x8(%rax), %r9
callq 0x15fe0
movq 0xf8(%rsp), %rdi
callq 0x1b5a0
testb $0x1, %al
jne 0x9452d
jmp 0x9453d
movl $0xffffff9c, 0x114(%rsp) # imm = 0xFFFFFF9C
jmp 0x9478d
movl $0x0, 0xc8(%rsp)
movl 0xc8(%rsp), %eax
cmpl 0xe4(%rsp), %eax
jge 0x94782
movq 0x100(%rsp), %rsi
movl 0xc8(%rsp), %edx
leaq 0x88(%rsp), %rdi
callq 0x34a30
movl $0x0, 0x84(%rsp)
movq 0x10(%rsp), %rcx
movl 0x84(%rsp), %eax
cmpl 0x80(%rcx), %eax
jge 0x94750
movl $0x0, 0x80(%rsp)
movq 0x10(%rsp), %rcx
movl 0x80(%rsp), %eax
cmpl 0x80(%rcx), %eax
jge 0x94738
movq 0x10(%rsp), %rax
movq 0xf8(%rsp), %rsi
movl 0xc8(%rsp), %edx
movl 0x80(%rax), %ecx
imull %ecx, %edx
imull %ecx, %edx
movl 0x84(%rsp), %eax
imull %ecx, %eax
addl %eax, %edx
movl 0x80(%rsp), %eax
addl %eax, %edx
leaq 0x38(%rsp), %rdi
callq 0x322b0
jmp 0x945ff
leaq 0x38(%rsp), %rdi
callq 0x25f80
movq %rax, 0x8(%rsp)
jmp 0x94610
leaq 0x38(%rsp), %rdi
callq 0x15950
movq 0x8(%rsp), %rax
movq %rax, 0x78(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0xd0(%rsp), %eax
jge 0x94720
movq 0x10(%rsp), %rax
movl 0x28(%rsp), %esi
movl 0x80(%rax), %eax
imull %eax, %esi
movl 0x84(%rsp), %eax
addl %eax, %esi
leaq 0x88(%rsp), %rdi
callq 0x34a00
movq %rax, (%rsp)
jmp 0x9466b
movq (%rsp), %rax
movslq 0x80(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0xd4(%rsp), %eax
jge 0x9470e
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movss (%rcx), %xmm0
movq 0x78(%rsp), %rcx
movss %xmm0, (%rcx)
movl 0x80(%rax), %ecx
movq 0x20(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x78(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x9468b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x94773
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x15950
jmp 0x94773
jmp 0x94710
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x9462c
jmp 0x94722
movl 0x80(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x80(%rsp)
jmp 0x945a6
jmp 0x9473a
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x94583
leaq 0x88(%rsp), %rdi
callq 0x15950
movl 0xc8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc8(%rsp)
jmp 0x94548
leaq 0x88(%rsp), %rdi
callq 0x15950
jmp 0x9479c
movl $0x0, 0x114(%rsp)
movl 0x114(%rsp), %eax
addq $0x118, %rsp # imm = 0x118
retq
movq 0x30(%rsp), %rdi
callq 0x14410
nopw %cs:(%rax,%rax)
|
/tongxiaobin[P]ncnn/src/layer/reorg.cpp
|
ncnn::YoloDetectionOutput::create_pipeline(ncnn::Option const&)
|
int YoloDetectionOutput::create_pipeline(const Option& opt)
{
{
softmax = ncnn::create_layer(ncnn::LayerType::Softmax);
ncnn::ParamDict pd;
pd.set(0, 0);// axis
softmax->load_param(pd);
Option opt_cpu = opt;
opt_cpu.vulkan_compute = false;
softmax->create_pipeline(opt_cpu);
}
return 0;
}
|
subq $0x5f8, %rsp # imm = 0x5F8
movq %rdi, 0x5f0(%rsp)
movq %rsi, 0x5e8(%rsp)
movq 0x5f0(%rsp), %rax
movq %rax, (%rsp)
movl $0x20, %edi
callq 0x19b60
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xd0(%rax)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x30ff0
movq 0x8(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x312d0
jmp 0x94aea
movq (%rsp), %rax
movq 0xd0(%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq 0x48(%rsp), %rsi
callq *%rax
jmp 0x94b05
movq (%rsp), %rax
movq 0x5e8(%rsp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x30(%rsp)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movb $0x0, 0x28(%rsp)
movq 0xd0(%rax), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq 0x10(%rsp), %rsi
callq *%rax
jmp 0x94b47
leaq 0x48(%rsp), %rdi
callq 0x2c2a0
xorl %eax, %eax
addq $0x5f8, %rsp # imm = 0x5F8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2c2a0
movq 0x40(%rsp), %rdi
callq 0x14410
nopl (%rax)
|
/tongxiaobin[P]ncnn/src/layer/yolodetectionoutput.cpp
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x96144
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastFree(void*)
|
static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];
free(udata);
#endif
}
}
|
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x96955
movq (%rsp), %rdi
callq 0x142b0
popq %rax
retq
nopw (%rax,%rax)
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x98fe4
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
ncnn::fastMalloc(unsigned long)
|
static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__ < 17
return memalign(MALLOC_ALIGN, size);
#else
unsigned char* udata = (unsigned char*)malloc(size + sizeof(void*) + MALLOC_ALIGN);
if (!udata)
return 0;
unsigned char** adata = alignPtr((unsigned char**)udata + 1, MALLOC_ALIGN);
adata[-1] = udata;
return adata;
#endif
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x140d0
cmpl $0x0, %eax
je 0x9be94
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
|
/tongxiaobin[P]ncnn/src/allocator.h
|
testing::internal::ExecDeathTest::AssumeRole() (.cold.1)
|
static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
ExecDeathTestArgs args = { argv, close_fd };
pid_t child_pid = -1;
# if GTEST_OS_QNX
// Obtains the current directory and sets it to be closed in the child
// process.
const int cwd_fd = open(".", O_RDONLY);
GTEST_DEATH_TEST_CHECK_(cwd_fd != -1);
GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC));
// We need to execute the test program in the same environment where
// it was originally invoked. Therefore we change to the original
// working directory first.
const char* const original_dir =
UnitTest::GetInstance()->original_working_dir();
// We can safely call chdir() as it's a direct system call.
if (chdir(original_dir) != 0) {
DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
GetLastErrnoDescription());
return EXIT_FAILURE;
}
int fd_flags;
// Set close_fd to be closed after spawn.
GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
fd_flags | FD_CLOEXEC));
struct inheritance inherit = {0};
// spawn is a system call.
child_pid = spawn(args.argv[0], 0, nullptr, &inherit, args.argv, environ);
// Restores the current working directory.
GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
# else // GTEST_OS_QNX
# if GTEST_OS_LINUX
// When a SIGPROF signal is received while fork() or clone() are executing,
// the process may hang. To avoid this, we ignore SIGPROF here and re-enable
// it after the call to fork()/clone() is complete.
struct sigaction saved_sigprof_action;
struct sigaction ignore_sigprof_action;
memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
sigemptyset(&ignore_sigprof_action.sa_mask);
ignore_sigprof_action.sa_handler = SIG_IGN;
GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
# endif // GTEST_OS_LINUX
# if GTEST_HAS_CLONE
const bool use_fork = GTEST_FLAG(death_test_use_fork);
if (!use_fork) {
static const bool stack_grows_down = StackGrowsDown();
const auto stack_size = static_cast<size_t>(getpagesize() * 2);
// MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
void* const stack = mmap(nullptr, stack_size, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE, -1, 0);
GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
// Maximum stack alignment in bytes: For a downward-growing stack, this
// amount is subtracted from size of the stack space to get an address
// that is within the stack space and is aligned on all systems we care
// about. As far as I know there is no ABI with stack alignment greater
// than 64. We assume stack and stack_size already have alignment of
// kMaxStackAlignment.
const size_t kMaxStackAlignment = 64;
void* const stack_top =
static_cast<char*>(stack) +
(stack_grows_down ? stack_size - kMaxStackAlignment : 0);
GTEST_DEATH_TEST_CHECK_(
static_cast<size_t>(stack_size) > kMaxStackAlignment &&
reinterpret_cast<uintptr_t>(stack_top) % kMaxStackAlignment == 0);
child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
}
# else
const bool use_fork = true;
# endif // GTEST_HAS_CLONE
if (use_fork && (child_pid = fork()) == 0) {
ExecDeathTestChildMain(&args);
_exit(0);
}
# endif // GTEST_OS_QNX
# if GTEST_OS_LINUX
GTEST_DEATH_TEST_CHECK_SYSCALL_(
sigaction(SIGPROF, &saved_sigprof_action, nullptr));
# endif // GTEST_OS_LINUX
GTEST_DEATH_TEST_CHECK_(child_pid != -1);
return child_pid;
}
|
pushq %rbx
subq $0x10, %rsp
leaq 0x4d0a2(%rip), %rdi # 0x55c78
callq 0x8a70
testl %eax, %eax
je 0x8c08
leaq 0xc(%rsp), %rdi
andl $0x0, (%rdi)
leaq 0xb(%rsp), %rbx
movq %rbx, %rsi
callq 0x29e59
movb (%rbx), %al
movb %al, 0x4d074(%rip) # 0x55c70
leaq 0x4d075(%rip), %rdi # 0x55c78
callq 0x8320
addq $0x10, %rsp
popq %rbx
retq
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-death-test.cc
|
prometheus::(anonymous namespace)::Base64Test_encodeTest_Test::TestBody()
|
TEST(Base64Test, encodeTest) {
for (const auto& test_case : testVector) {
std::string encoded = detail::base64_encode(test_case.decoded);
EXPECT_EQ(test_case.encoded, encoded);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl $0x480, %r13d # imm = 0x480
leaq 0x4b3ef(%rip), %rbx # 0x555f0
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %rbp
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xadf1
leaq 0x20(%rbx), %rcx
leaq 0x10(%rsp), %rdi
leaq 0x30f20(%rip), %rsi # 0x3b14b
leaq 0x30f23(%rip), %rdx # 0x3b155
movq %r14, %r8
callq 0xb0d7
cmpb $0x0, 0x10(%rsp)
jne 0xa299
movq %rbp, %rdi
callq 0xf68a
movq 0x18(%rsp), %rax
leaq 0x3358e(%rip), %r8 # 0x3d7e3
testq %rax, %rax
je 0xa25d
movq (%rax), %r8
movq %r15, %rdi
movl $0x1, %esi
leaq 0x30df2(%rip), %rdx # 0x3b05e
movl $0x2e, %ecx
callq 0xbc60
movq %r15, %rdi
movq %rbp, %rsi
callq 0xbcec
movq %r15, %rdi
callq 0xbcc6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa299
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %r12
testq %r12, %r12
je 0xa2be
movq (%r12), %rdi
leaq 0x10(%r12), %rax
cmpq %rax, %rdi
je 0xa2b6
callq 0x84a0
movq %r12, %rdi
callq 0x84a0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xa2d2
callq 0x84a0
addq $0x40, %rbx
addq $-0x40, %r13
jne 0xa210
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xa306
movq %rax, %rbx
jmp 0xa31f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbcc6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa316
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xb09e
jmp 0xa32e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xa342
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/util/tests/unit/base64_test.cc
|
prometheus::(anonymous namespace)::Base64Test_encodeUrlTest_Test::TestBody()
|
TEST(Base64Test, encodeUrlTest) {
const char unicodeText[] =
"\xce\xa0\xcf\x81\xce\xbf\xce\xbc\xce\xb7\xce\xb8\xce\xb5\xcf\x8d\xcf"
"\x82"; // Προμηθεύς
std::string encoded = detail::base64url_encode(unicodeText);
EXPECT_EQ("zqDPgc6_zrzOt864zrXPjc-C", encoded);
}
|
pushq %r14
pushq %rbx
subq $0x68, %rsp
movaps 0x3153e(%rip), %xmm0 # 0x3b8f0
leaq 0x50(%rsp), %rbx
movaps %xmm0, (%rbx)
movl $0x82cf8d, 0xf(%rbx) # imm = 0x82CF8D
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq %rbx, %rdi
callq 0x8210
leaq (%rsp,%rax), %rdx
addq $0x50, %rdx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xb728
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xadf1
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xa429
movq 0x30(%rsp), %rcx
xorl %edx, %edx
movzbl (%rcx,%rdx), %esi
cmpl $0x2b, %esi
je 0xa41a
cmpl $0x2f, %esi
jne 0xa41d
movb $0x5f, %sil
jmp 0xa41d
movb $0x2d, %sil
movb %sil, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0xa407
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xa438
callq 0x84a0
leaq 0x30d1e(%rip), %rsi # 0x3b15d
leaq 0x30d0f(%rip), %rdx # 0x3b155
leaq 0x30d2b(%rip), %rcx # 0x3b178
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %r8
callq 0xb272
cmpb $0x0, 0x10(%rsp)
jne 0xa4c2
movq %rsp, %rdi
callq 0xf68a
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xa47a
movq (%rax), %r8
jmp 0xa481
leaq 0x33362(%rip), %r8 # 0x3d7e3
leaq 0x30bd6(%rip), %rdx # 0x3b05e
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x37, %ecx
callq 0xbc60
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0xbcec
leaq 0x8(%rsp), %rdi
callq 0xbcc6
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa4c2
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rbx
testq %rbx, %rbx
je 0xa4e5
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0xa4dd
callq 0x84a0
movq %rbx, %rdi
callq 0x84a0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4f8
callq 0x84a0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbcc6
jmp 0xa512
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa521
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0xa52e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb09e
jmp 0xa53d
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xa55a
jmp 0xa564
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xa564
callq 0x84a0
jmp 0xa564
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/util/tests/unit/base64_test.cc
|
prometheus::(anonymous namespace)::Base64Test_rejectInvalidPadding_Test::TestBody()
|
TEST(Base64Test, rejectInvalidPadding) {
EXPECT_ANY_THROW(detail::base64_decode("A==="));
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
callq 0xf687
testb %al, %al
je 0xaac7
callq 0xf687
testb %al, %al
je 0xaac7
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x30820(%rip), %rsi # 0x3b2a5
leaq 0x3081d(%rip), %rdx # 0x3b2a9
leaq 0x8(%rsp), %rdi
callq 0xb728
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb498
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaab8
callq 0x84a0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xaac7
callq 0x84a0
leaq 0x8(%rsp), %rdi
callq 0xf68a
leaq 0x30586(%rip), %rdx # 0x3b05e
leaq 0x307cb(%rip), %r8 # 0x3b2aa
movq %rsp, %rdi
movl $0x1, %esi
movl $0x4a, %ecx
callq 0xbc60
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xbcec
movq %rsp, %rdi
callq 0xbcc6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xab16
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xab37
callq 0x84a0
jmp 0xab37
jmp 0xab34
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8200
callq 0x8990
jmp 0xab16
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbcc6
jmp 0xab56
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xab66
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/util/tests/unit/base64_test.cc
|
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);
SetUpTearDownSuiteFuncType test_suite_fp =
GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);
GTEST_CHECK_(!test_case_fp || !test_suite_fp)
<< "Test can not provide both TearDownTestSuite and TearDownTestCase,"
" please make sure there is only one present at"
<< filename << ":" << line_num;
return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
#else
(void)(filename);
(void)(line_num);
return &T::TearDownTestSuite;
#endif
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xbc5c
testb %al, %al
jne 0xad3d
leaq 0x30670(%rip), %rdx # 0x3b2fd
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x226, %ecx # imm = 0x226
callq 0x27da0
movq 0x4a338(%rip), %rdi # 0x54fe0
leaq 0x306df(%rip), %rsi # 0x3b38e
movl $0x32, %edx
callq 0x85f0
movq 0x4a320(%rip), %r15 # 0x54fe0
leaq 0x30765(%rip), %rsi # 0x3b42c
movl $0x6f, %edx
movq %r15, %rdi
callq 0x85f0
testq %r14, %r14
je 0xacf5
movq %r14, %rdi
callq 0x8210
movq 0x4a2f8(%rip), %rdi # 0x54fe0
movq %r14, %rsi
movq %rax, %rdx
callq 0x85f0
jmp 0xad0d
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x89b0
movq 0x4a2cc(%rip), %rdi # 0x54fe0
leaq 0x35069(%rip), %rsi # 0x3fd84
movl $0x1, %edx
callq 0x85f0
movq 0x4a2b4(%rip), %rdi # 0x54fe0
movl %ebx, %esi
callq 0x89d0
leaq 0xc(%rsp), %rdi
callq 0x27ed2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x27ed2
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/internal/gtest-internal.h
|
testing::AssertionResult::~AssertionResult()
|
class GTEST_API_ AssertionResult {
public:
// Copy constructor.
// Used in EXPECT_TRUE/FALSE(assertion_result).
AssertionResult(const AssertionResult& other);
// C4800 is a level 3 warning in Visual Studio 2015 and earlier.
// This warning is not emitted in Visual Studio 2017.
// This warning is off by default starting in Visual Studio 2019 but can be
// enabled with command-line options.
#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
#endif
// Used in the EXPECT_TRUE/FALSE(bool_expression).
//
// T must be contextually convertible to bool.
//
// The second parameter prevents this overload from being considered if
// the argument is implicitly convertible to AssertionResult. In that case
// we want AssertionResult's copy constructor to be used.
template <typename T>
explicit AssertionResult(
const T& success,
typename std::enable_if<
!std::is_convertible<T, AssertionResult>::value>::type*
/*enabler*/
= nullptr)
: success_(success) {}
#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
GTEST_DISABLE_MSC_WARNINGS_POP_()
#endif
// Assignment operator.
AssertionResult& operator=(AssertionResult other) {
swap(other);
return *this;
}
// Returns true if and only if the assertion succeeded.
operator bool() const { return success_; } // NOLINT
// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
AssertionResult operator!() const;
// Returns the text streamed into this AssertionResult. Test assertions
// use it when they fail (i.e., the predicate's outcome doesn't match the
// assertion's expectation). When nothing has been streamed into the
// object, returns an empty string.
const char* message() const {
return message_.get() != nullptr ? message_->c_str() : "";
}
// Deprecated; please use message() instead.
const char* failure_message() const { return message(); }
// Streams a custom failure message into this object.
template <typename T> AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
// Allows streaming basic output manipulators such as endl or flush into
// this object.
AssertionResult& operator<<(
::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
AppendMessage(Message() << basic_manipulator);
return *this;
}
private:
// Appends the contents of message to message_.
void AppendMessage(const Message& a_message) {
if (message_.get() == nullptr) message_.reset(new ::std::string);
message_->append(a_message.GetString().c_str());
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0xb0c7
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0xb0bf
callq 0x84a0
movq %r14, %rdi
callq 0x84a0
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0xb1ef
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xb1ef
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x1075f
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb197
callq 0x84a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1aa
callq 0x84a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1d4
callq 0x84a0
jmp 0xb1d4
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1e7
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h
|
prometheus::detail::base64_decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
inline std::string base64_decode(const std::string& input) {
if (input.length() % 4) {
throw std::runtime_error("Invalid base64 length!");
}
std::size_t padding = 0;
if (!input.empty()) {
if (input[input.length() - 1] == kPadCharacter) padding++;
if (input[input.length() - 2] == kPadCharacter) padding++;
}
std::string decoded;
decoded.reserve(((input.length() / 4) * 3) - padding);
std::uint32_t temp = 0;
auto it = input.begin();
while (it < input.end()) {
for (std::size_t i = 0; i < 4; ++i) {
temp <<= 6;
if (*it >= 0x41 && *it <= 0x5A) {
temp |= *it - 0x41;
} else if (*it >= 0x61 && *it <= 0x7A) {
temp |= *it - 0x47;
} else if (*it >= 0x30 && *it <= 0x39) {
temp |= *it + 0x04;
} else if (*it == 0x2B) {
temp |= 0x3E;
} else if (*it == 0x2F) {
temp |= 0x3F;
} else if (*it == kPadCharacter) {
switch (input.end() - it) {
case 1:
decoded.push_back((temp >> 16) & 0x000000FF);
decoded.push_back((temp >> 8) & 0x000000FF);
return decoded;
case 2:
decoded.push_back((temp >> 10) & 0x000000FF);
return decoded;
default:
throw std::runtime_error("Invalid padding in base64!");
}
} else {
throw std::runtime_error("Invalid character in base64!");
}
++it;
}
decoded.push_back((temp >> 16) & 0x000000FF);
decoded.push_back((temp >> 8) & 0x000000FF);
decoded.push_back((temp) & 0x000000FF);
}
return decoded;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testb $0x3, %al
jne 0xb69a
movq %rdi, %rbx
testq %rax, %rax
je 0xb4e5
movq 0x8(%rsp), %rcx
movq (%rcx), %rdx
xorl %ecx, %ecx
cmpb $0x3d, -0x1(%rdx,%rax)
sete %cl
movq %rcx, %rsi
negq %rsi
cmpb $0x3d, -0x2(%rdx,%rax)
notq %rcx
cmovneq %rsi, %rcx
jmp 0xb4e7
xorl %ecx, %ecx
leaq 0x10(%rbx), %rdx
movq %rdx, 0x10(%rsp)
movq %rdx, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
shrq $0x2, %rax
leaq (%rax,%rax,2), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x8910
movq 0x8(%rsp), %rax
movq (%rax), %r15
movl $0x0, 0x4(%rsp)
xorl %ebp, %ebp
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
addq (%rcx), %rax
cmpq %rax, %r15
jae 0xb656
leaq 0x4(%r15), %rcx
xorl %r12d, %r12d
xorl %r13d, %r13d
movl %ebp, %r14d
shll $0x6, %r14d
movzbl (%r15,%r13), %edx
leal -0x41(%rdx), %esi
cmpb $0x19, %sil
ja 0xb55d
addl $-0x41, %edx
jmp 0xb577
leal -0x61(%rdx), %esi
cmpb $0x19, %sil
ja 0xb56b
addl $-0x47, %edx
jmp 0xb577
leal -0x30(%rdx), %esi
cmpb $0x9, %sil
ja 0xb593
addl $0x4, %edx
movl %edx, %ebp
orl %r14d, %ebp
cmpq $0x3, %r13
leaq 0x1(%r13), %rdx
setae %r12b
movq %rdx, %r13
cmpq $0x4, %rdx
jne 0xb543
jmp 0xb5a9
movl $0x3e, %ebp
cmpl $0x2b, %edx
je 0xb579
cmpl $0x2f, %edx
jne 0xb5e7
movl $0x3f, %ebp
jmp 0xb579
movq %rcx, %r15
testb $0x1, %r12b
je 0xb640
movl %ebp, %eax
shrl $0x10, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8440
movl %ebp, %eax
shrl $0x8, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8440
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x8440
jmp 0xb524
cmpl $0x3d, %edx
jne 0xb668
subq %r15, %rax
subq %r13, %rax
movl $0xa, %ebp
cmpq $0x2, %rax
je 0xb61d
cmpq $0x1, %rax
jne 0xb6cc
movl %r14d, %eax
shrl $0x10, %eax
movl $0x8, %ebp
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8440
movl %r14d, %eax
movl %ebp, %ecx
shrl %cl, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8440
addq %r13, %r15
movb $0x1, %al
movl %eax, 0x4(%rsp)
movl %r14d, %ebp
jmp 0xb5ac
testb $0x1, 0x4(%rsp)
jne 0xb656
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0xb656
callq 0x84a0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x8240
movq %rax, %r15
leaq 0x2fb5e(%rip), %rsi # 0x3b1da
movq %rax, %rdi
callq 0x81e0
movq 0x4995d(%rip), %rsi # 0x54fe8
movq 0x49906(%rip), %rdx # 0x54f98
movq %r15, %rdi
callq 0x89c0
movl $0x10, %edi
callq 0x8240
movq %rax, %rbx
leaq 0x2fafa(%rip), %rsi # 0x3b1a8
movq %rax, %rdi
callq 0x81e0
movq 0x4992b(%rip), %rsi # 0x54fe8
movq 0x498d4(%rip), %rdx # 0x54f98
movq %rbx, %rdi
callq 0x89c0
movl $0x10, %edi
callq 0x8240
movq %rax, %r15
leaq 0x2fadf(%rip), %rsi # 0x3b1bf
movq %rax, %rdi
callq 0x81e0
jmp 0xb684
jmp 0xb6fd
movq %rax, %r14
movq %rbx, %rdi
callq 0x8390
jmp 0xb71e
jmp 0xb70c
jmp 0xb70c
movq %rax, %r14
movq %r15, %rdi
callq 0x8390
jmp 0xb70f
jmp 0xb70c
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0xb71e
callq 0x84a0
movq %r14, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/util/include/prometheus/detail/base64.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 ? default_value : value;
#endif // defined(GTEST_GET_STRING_FROM_ENV_)
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x28200
movq (%r14), %r15
movq %r15, %rdi
callq 0x86b0
movq %rax, %r14
leaq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0xb84b
movq %r15, %rdi
callq 0x84a0
testq %r14, %r14
cmovneq %r14, %rbx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-port.cc
|
testing::internal::Int32FromGTestEnv(char const*, int)
|
int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
#if defined(GTEST_GET_INT32_FROM_ENV_)
return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const string_value = posix::GetEnv(env_var.c_str());
if (string_value == nullptr) {
// The environment variable is not set.
return default_value;
}
int32_t result = default_value;
if (!ParseInt32(Message() << "Environment variable " << env_var,
string_value, &result)) {
printf("The default value %s is used.\n",
(Message() << default_value).GetString().c_str());
fflush(stdout);
return default_value;
}
return result;
#endif // defined(GTEST_GET_INT32_FROM_ENV_)
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x28200
movq (%r14), %rdi
callq 0x86b0
testq %rax, %rax
je 0xba7c
movq %rax, %r15
movl %ebx, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf68a
movq 0x10(%rsp), %r14
leaq 0x10(%r14), %r12
leaq 0x32b78(%rip), %rsi # 0x3e53f
movl $0x15, %edx
movq %r12, %rdi
callq 0x85f0
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %r12, %rdi
callq 0x85f0
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r15, %rsi
callq 0x208d4
movl %eax, %ebp
testq %r14, %r14
je 0xba08
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
testb %bpl, %bpl
je 0xba13
movl 0x4(%rsp), %ebx
jmp 0xba7c
leaq 0x8(%rsp), %rdi
callq 0xf68a
movq 0x8(%rsp), %r14
leaq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x89d0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xf8c7
leaq 0x20(%rsp), %r15
movq -0x10(%r15), %rsi
leaq 0x32b0b(%rip), %rdi # 0x3e555
xorl %eax, %eax
callq 0x8080
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0xba5f
callq 0x84a0
testq %r14, %r14
je 0xba6d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x494fc(%rip), %rax # 0x54f70
movq (%rax), %rdi
callq 0x8640
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xba8f
callq 0x84a0
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbabc
movq %rax, %rbx
testq %r14, %r14
je 0xbab1
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0xbadb
movq %rax, %rbx
jmp 0xbadb
movq %rax, %rbx
testq %r14, %r14
je 0xbad2
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbaee
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-port.cc
|
testing::internal::AssertHelper::~AssertHelper()
|
AssertHelper::~AssertHelper() {
delete data_;
}
|
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xbcea
movq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0xbce1
callq 0x84a0
movq %rbx, %rdi
popq %rbx
jmp 0x84a0
popq %rbx
retq
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/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(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 0xc303
movl $0x8, %edi
callq 0x84e0
leaq 0x47c7f(%rip), %rcx # 0x53f78
movq %rcx, (%rax)
movq %rax, 0x210(%r14)
movq 0x210(%r14), %rsi
movl 0x49810(%rip), %edx # 0x55b20
incl %ebp
movq (%rsi), %rax
movq %rbx, %rdi
movl %ebp, %ecx
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)
|
void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
bool has_test_p) {
const auto& ignored = *GetIgnoredParameterizedTestSuites();
if (ignored.find(name) != ignored.end()) return;
const char kMissingInstantiation[] = //
" is defined via TEST_P, but never instantiated. None of the test cases "
"will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only "
"ones provided expand to nothing."
"\n\n"
"Ideally, TEST_P definitions should only ever be included as part of "
"binaries that intend to use them. (As opposed to, for example, being "
"placed in a library that may be linked in to get other utilities.)";
const char kMissingTestCase[] = //
" is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are "
"defined via TEST_P . No test cases will run."
"\n\n"
"Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from "
"code that always depend on code that provides TEST_P. Failing to do "
"so is often an indication of dead code, e.g. the last TEST_P was "
"removed but the rest got left behind.";
std::string message =
"Parameterized test suite " + name +
(has_test_p ? kMissingInstantiation : kMissingTestCase) +
"\n\n"
"To suppress this error for this test suite, insert the following line "
"(in a non-header) in the namespace it is defined in:"
"\n\n"
"GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + name + ");";
std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">";
RegisterTest( //
"GoogleTestVerification", full_name.c_str(),
nullptr, // No type parameter.
nullptr, // No value parameter.
location.file.c_str(), location.line, [message, location] {
return new FailureTest(location, message,
kErrorOnUninstantiatedParameterizedTest);
});
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xbdbe
movq 0x497f8(%rip), %r15 # 0x55bd0
leaq 0x130(%r15), %rdi
movq %r14, %rsi
callq 0x31670
addq $0x138, %r15 # imm = 0x138
cmpq %r15, %rax
jne 0xc960
leaq 0x33092(%rip), %rsi # 0x3f490
leaq 0x2a0(%rsp), %r15
movl $0x17a, %edx # imm = 0x17A
movq %r15, %rdi
callq 0x8410
leaq 0x331f6(%rip), %rsi # 0x3f610
leaq 0x140(%rsp), %r12
movl $0x15c, %edx # imm = 0x15C
movq %r12, %rdi
callq 0x8410
leaq 0x308d9(%rip), %rsi # 0x3cd0f
leaq 0x88(%rsp), %r13
movq %r13, %rdi
movq %r14, %rdx
callq 0x2ab4b
testb %bpl, %bpl
cmovneq %r15, %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x8af0
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xc482
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0xc489
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30a5e(%rip), %rsi # 0x3cf0a
callq 0x8af0
leaq 0xb8(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xc4e1
movq %rdx, 0xa8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xb8(%rsp)
jmp 0xc4e9
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0xa8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x8170
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xc53c
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0xc544
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x307c2(%rip), %rsi # 0x3cd29
callq 0x8af0
leaq 0xe0(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xc59c
movq %rdx, 0xd0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xe0(%rsp)
jmp 0xc5a2
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0xd8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xc5cc
callq 0x84a0
movq 0xa8(%rsp), %rdi
cmpq %r13, %rdi
je 0xc5de
callq 0x84a0
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0xc5ed
callq 0x84a0
leaq 0x98(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0xc603
callq 0x84a0
leaq 0x30722(%rip), %rsi # 0x3cd2c
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x2ab4b
leaq 0x3145b(%rip), %rsi # 0x3da79
leaq 0x20(%rsp), %rdi
callq 0x8af0
movq %r15, 0x88(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xc654
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
jmp 0xc65b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x90(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xc685
callq 0x84a0
movq 0x88(%rsp), %rax
movq %rax, 0x138(%rsp)
movq (%rbx), %r15
movl 0x20(%rbx), %r14d
leaq 0x100(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
addq %rsi, %rdx
leaq 0xf0(%rsp), %rdi
callq 0xad5e
leaq 0x110(%rsp), %rdi
leaq 0x120(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
callq 0xad5e
movl 0x20(%rbx), %eax
movl %eax, 0x130(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x1f(%rsp), %rdx
movq %r15, %rsi
callq 0x81f0
leaq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
movq %rax, (%rdi)
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
addq %rsi, %rdx
callq 0xad5e
movl %r14d, 0xc8(%rsp)
movl $0x50, %edi
callq 0x84e0
movq %r12, 0x20(%rsp)
movq 0xf0(%rsp), %rcx
cmpq %rbp, %rcx
je 0xc764
movq %rcx, 0x20(%rsp)
movq 0x100(%rsp), %rcx
movq %rcx, 0x30(%rsp)
jmp 0xc76d
movups (%rbp), %xmm0
movups %xmm0, (%r12)
movq 0xf8(%rsp), %rcx
movq 0x110(%rsp), %rdx
leaq 0x50(%rsp), %rbx
movq %rcx, -0x28(%rbx)
movq %rbp, 0xf0(%rsp)
movq $0x0, 0xf8(%rsp)
movb $0x0, 0x100(%rsp)
movq %rbx, -0x10(%rbx)
cmpq %r13, %rdx
je 0xc7bf
movq %rdx, 0x40(%rsp)
movq 0x120(%rsp), %rdx
movq %rdx, 0x50(%rsp)
jmp 0xc7c7
movups (%r13), %xmm0
movups %xmm0, (%rbx)
movq 0x118(%rsp), %rdx
movq %rdx, 0x48(%rsp)
movq %r13, 0x110(%rsp)
movq $0x0, 0x118(%rsp)
movb $0x0, 0x120(%rsp)
movl 0x130(%rsp), %esi
movl %esi, 0x60(%rsp)
leaq 0x47c8e(%rip), %rdi # 0x54490
movq %rdi, (%rax)
leaq 0x18(%rax), %rdi
movq %rdi, 0x8(%rax)
movq 0x20(%rsp), %r8
cmpq %r12, %r8
je 0xc826
movq %r8, 0x8(%rax)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rax)
jmp 0xc82e
movups (%r12), %xmm0
movups %xmm0, (%rdi)
movq %rcx, 0x10(%rax)
movq %r12, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movb $0x0, 0x30(%rsp)
movq %rax, %rcx
addq $0x38, %rcx
movq %rcx, 0x28(%rax)
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc869
movq %rdi, 0x28(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x38(%rax)
jmp 0xc86f
movups (%rbx), %xmm0
movups %xmm0, (%rcx)
movq %rdx, 0x30(%rax)
movq %rbx, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movb $0x0, 0x50(%rsp)
movl %esi, 0x48(%rax)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
leaq 0x304b6(%rip), %rdi # 0x3cd52
leaq 0x493dd(%rip), %r9 # 0x55c80
leaq 0xa8(%rsp), %r8
movq 0x138(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x13b26
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc8cb
callq 0x84a0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xc8da
callq 0x84a0
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0xc8f4
callq 0x84a0
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0xc908
callq 0x84a0
movq 0x110(%rsp), %rdi
cmpq %r13, %rdi
je 0xc91a
callq 0x84a0
movq 0xf0(%rsp), %rdi
cmpq %rbp, %rdi
leaq 0x98(%rsp), %rbx
je 0xc934
callq 0x84a0
movq 0x88(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc946
callq 0x84a0
movq 0xd0(%rsp), %rdi
leaq 0xe0(%rsp), %rax
cmpq %rax, %rdi
je 0xc960
callq 0x84a0
addq $0x428, %rsp # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xca86
jmp 0xc984
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0xc9a3
callq 0x84a0
jmp 0xc9a3
movq %rax, %rbx
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0xc9bc
callq 0x84a0
jmp 0xc9bc
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xca86
jmp 0xc9e5
movq %rax, %rbx
movq 0xf0(%rsp), %rdi
cmpq %rbp, %rdi
je 0xc9e5
callq 0x84a0
jmp 0xc9e5
movq %rax, %rbx
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0xca13
callq 0x84a0
jmp 0xca13
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
jne 0xc9fa
jmp 0xca13
movq %rax, %rbx
movq 0xd0(%rsp), %rdi
leaq 0xe0(%rsp), %rax
jmp 0xca73
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xca3c
callq 0x84a0
jmp 0xca3c
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
cmpq %r13, %rdi
je 0xca53
callq 0x84a0
jmp 0xca53
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0xca67
callq 0x84a0
jmp 0xca67
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xca7d
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::internal::UnitTestOptions::GetOutputFormat[abi:cxx11]()
|
std::string UnitTestOptions::GetOutputFormat() {
const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
const char* const colon = strchr(gtest_output_flag, ':');
return (colon == nullptr)
? std::string(gtest_output_flag)
: std::string(gtest_output_flag,
static_cast<size_t>(colon - gtest_output_flag));
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x4843d(%rip), %r15 # 0x55af0
movq %r15, %rdi
movl $0x3a, %esi
callq 0x81d0
movq %rax, %rbx
testq %rax, %rax
je 0xd6df
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xb728
jmp 0xd6ef
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x81f0
testq %rbx, %rbx
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xd701
testq %rbx, %rbx
movq %rax, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::internal::FilePath::GenerateUniqueFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, char const*)
|
FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
const FilePath& base_name,
const char* extension) {
FilePath full_pathname;
int number = 0;
do {
full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
} while (full_pathname.FileOrDirectoryExists());
return full_pathname;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
callq 0xde34
movq %rbx, %rdi
movq %r13, %rsi
callq 0x82a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe4a5
callq 0x84a0
movl $0x90, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x82c0
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x8470
incl %ebp
testl %eax, %eax
je 0xe473
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xe4f6
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe4f6
callq 0x84a0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0xe504
callq 0x84a0
movq %r14, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-filepath.cc
|
testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter()
|
ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
impl->SetGlobalTestPartResultReporter(old_reporter_);
} else {
impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
}
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x45231(%rip), %rax # 0x53c20
movq %rax, (%rdi)
callq 0xbdbe
movq 0x471d2(%rip), %rdi # 0x55bd0
cmpl $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rbx
jne 0xea12
movq %rbx, %rsi
callq 0xe98a
jmp 0xea21
addq $0x90, %rdi
callq 0x31a5c
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x2acfd
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::internal::UnitTestImpl::skipped_test_count() const
|
DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
UnitTestImpl* unit_test) : unit_test_(unit_test) {}
|
pushq %rbp
pushq %r14
pushq %rbx
movq 0xb8(%rdi), %rax
cmpq %rax, 0xc0(%rdi)
je 0xf11c
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %ebp, %ebp
movq (%rax,%r14,8), %rdi
callq 0xf126
addl %eax, %ebp
incq %r14
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jb 0xf0f2
jmp 0xf11e
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::internal::AlwaysTrue()
|
bool AlwaysTrue() {
#if GTEST_HAS_EXCEPTIONS
// This condition is always false so AlwaysTrue() never actually throws,
// but it makes the compiler think that it may throw.
if (IsTrue(false))
throw ClassUniqueToAlwaysTrue();
#endif // GTEST_HAS_EXCEPTIONS
return true;
}
|
movb $0x1, %al
retq
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*)
|
std::string StringStreamToString(::std::stringstream* ss) {
const ::std::string& str = ss->str();
const char* const start = str.c_str();
const char* const end = start + str.length();
std::string result;
result.reserve(static_cast<size_t>(2 * (end - start)));
for (const char* ch = start; ch != end; ++ch) {
if (*ch == '\0') {
result += "\\0"; // Replaces NUL with "\\0";
} else {
result += *ch;
}
}
return result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x18, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8930
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq (,%r13,2), %rsi
movq %rbx, %rdi
callq 0x8910
testq %r13, %r13
je 0xf949
xorl %ebp, %ebp
leaq 0x2d8d0(%rip), %r14 # 0x3d1f1
movb (%r12,%rbp), %al
testb %al, %al
je 0xf936
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8440
jmp 0xf941
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8af0
incq %rbp
cmpq %rbp, %r13
jne 0xf921
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf95c
callq 0x84a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf970
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xf980
callq 0x84a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf993
callq 0x84a0
movq %r14, %rdi
callq 0x8a20
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/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::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, unsigned long)
|
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 ss;
while (edit_i < edits.size()) {
// Find first edit.
while (edit_i < edits.size() && edits[edit_i] == kMatch) {
++l_i;
++r_i;
++edit_i;
}
// Find the first line to include in the hunk.
const size_t prefix_context = std::min(l_i, context);
Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
for (size_t i = prefix_context; i > 0; --i) {
hunk.PushLine(' ', left[l_i - i].c_str());
}
// Iterate the edits until we found enough suffix for the hunk or the input
// is over.
size_t n_suffix = 0;
for (; edit_i < edits.size(); ++edit_i) {
if (n_suffix >= context) {
// Continue only if the next hunk is very close.
auto it = edits.begin() + static_cast<int>(edit_i);
while (it != edits.end() && *it == kMatch) ++it;
if (it == edits.end() ||
static_cast<size_t>(it - edits.begin()) - edit_i >= context) {
// There is no next edit or it is too far away.
break;
}
}
EditType edit = edits[edit_i];
// Reset count when a non match is found.
n_suffix = edit == kMatch ? n_suffix + 1 : 0;
if (edit == kMatch || edit == kRemove || edit == kReplace) {
hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
}
if (edit == kAdd || edit == kReplace) {
hunk.PushLine('+', right[r_i].c_str());
}
// Advance indices, depending on edit type.
l_i += edit != kAdd;
r_i += edit != kRemove;
}
if (!hunk.has_edits()) {
// We are done. We don't want this hunk.
break;
}
hunk.PrintTo(&ss);
}
return ss.str();
}
|
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 0x88(%rsp), %rdi
movq %rsi, 0x80(%rsp)
movq %rdx, 0xa8(%rsp)
callq 0xff19
leaq 0xb0(%rsp), %rdi
callq 0x8360
leaq 0x38(%rsp), %r12
leaq 0x50(%rsp), %rbp
xorl %ebx, %ebx
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x88(%rsp), %rcx
movq 0x90(%rsp), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rax, %r13
jae 0x105b9
leaq (%rbx,%rax), %rdx
subq %r13, %rdx
leaq (%r14,%rax), %rsi
subq %r13, %rsi
cmpl $0x0, (%rcx,%r13,4)
jne 0x101ac
incq %rbx
incq %r14
incq %r13
cmpq %r13, %rax
jne 0x1018e
movq %rdx, %rbx
movq %rax, %r13
movq %rsi, %r14
movq 0x8(%rsp), %r15
cmpq %r15, %rbx
cmovbq %rbx, %r15
movq %rbx, %rax
subq %r15, %rax
incq %rax
movq %r14, %rcx
subq %r15, %rcx
incq %rcx
movq %rax, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
leaq 0x20(%rsp), %rax
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r12, 0x40(%rsp)
movq %r12, 0x38(%rsp)
movq %rcx, 0x48(%rsp)
movq %rbp, 0x58(%rsp)
movq %rbp, 0x50(%rsp)
movq %rcx, 0x60(%rsp)
leaq 0x68(%rsp), %rax
movq %rax, 0x70(%rsp)
movq %rax, 0x68(%rsp)
movq %rcx, 0x78(%rsp)
testq %r15, %r15
je 0x10254
movq %rbx, %r12
shlq $0x5, %r12
movq %r15, %rax
shlq $0x5, %rax
subq %rax, %r12
movq 0x80(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r12), %rdx
leaq 0x10(%rsp), %rdi
movl $0x20, %esi
callq 0x10672
addq $0x20, %r12
decq %r15
jne 0x1022d
movq 0x88(%rsp), %rax
movq 0x90(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rdx, %r13
jae 0x1038b
xorl %r15d, %r15d
cmpq 0x8(%rsp), %r15
jb 0x102b6
movslq %r13d, %rdx
leaq (%rax,%rdx,4), %rdx
cmpq %rcx, %rdx
je 0x10298
cmpl $0x0, (%rdx)
jne 0x10298
addq $0x4, %rdx
jmp 0x10288
cmpq %rcx, %rdx
je 0x1038b
subq %rax, %rdx
sarq $0x2, %rdx
subq %r13, %rdx
cmpq 0x8(%rsp), %rdx
jae 0x1038b
movl (%rax,%r13,4), %ebp
incq %r15
testl %ebp, %ebp
movl $0x0, %eax
cmovneq %rax, %r15
cmpl $0x3, %ebp
ja 0x10301
cmpl $0x1, %ebp
je 0x10301
movq %rbx, %rax
shlq $0x5, %rax
testl %ebp, %ebp
movq 0x80(%rsp), %rcx
movq (%rcx), %rcx
movq (%rcx,%rax), %rdx
movl $0x2d, %esi
movl $0x20, %eax
cmovel %eax, %esi
leaq 0x10(%rsp), %rdi
callq 0x10672
movl %ebp, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x1034a
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq %r14, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %r12
incq 0x20(%rsp)
movl $0x20, %edi
callq 0x84e0
movb $0x2b, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rax, %rdi
leaq 0x50(%rsp), %rsi
callq 0x80a0
incq 0x60(%rsp)
xorl %eax, %eax
cmpl $0x1, %ebp
setne %al
addq %rax, %rbx
xorl %eax, %eax
cmpl $0x2, %ebp
setne %al
addq %rax, %r14
incq %r13
movq 0x88(%rsp), %rax
movq 0x90(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rdx, %r13
leaq 0x50(%rsp), %rbp
jb 0x1027a
movq 0x28(%rsp), %rax
orq 0x20(%rsp), %rax
setne 0x6(%rsp)
je 0x10556
movl $0x3, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x2e401(%rip), %rsi # 0x3e7b5
callq 0x85f0
cmpq $0x0, 0x28(%rsp)
je 0x10415
movl $0x1, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x2dbc5(%rip), %rsi # 0x3df9a
callq 0x85f0
movq 0x10(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x8330
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2e3bb(%rip), %rsi # 0x3e7b9
callq 0x85f0
movq 0x30(%rsp), %rsi
addq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x8330
cmpq $0x0, 0x28(%rsp)
je 0x1043e
cmpq $0x0, 0x20(%rsp)
je 0x1043e
movl $0x1, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x2cbcd(%rip), %rsi # 0x3d006
callq 0x85f0
cmpq $0x0, 0x20(%rsp)
je 0x1049a
movl $0x1, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x2e130(%rip), %rsi # 0x3e58a
callq 0x85f0
movq 0x18(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x8330
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2e336(%rip), %rsi # 0x3e7b9
callq 0x85f0
movq 0x30(%rsp), %rsi
addq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x8330
movl $0x4, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x2e30d(%rip), %rsi # 0x3e7bb
callq 0x85f0
leaq 0x10(%rsp), %rdi
callq 0x294d4
movq 0x38(%rsp), %r12
leaq 0x38(%rsp), %rax
cmpq %rax, %r12
je 0x10556
movb 0x10(%r12), %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x7(%rsp), %rsi
callq 0x85f0
movq %rax, %r15
movq 0x18(%r12), %rbp
testq %rbp, %rbp
je 0x1051a
movq %rbp, %rdi
callq 0x8210
movq %r15, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x85f0
leaq 0x50(%rsp), %rbp
jmp 0x10539
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x89b0
leaq 0x50(%rsp), %rbp
movl $0x1, %edx
movq %r15, %rdi
leaq 0x2d29a(%rip), %rsi # 0x3d7e2
callq 0x85f0
movq (%r12), %r12
jmp 0x104c2
movq 0x68(%rsp), %rdi
leaq 0x68(%rsp), %r12
cmpq %r12, %rdi
je 0x10575
movq (%rdi), %r15
callq 0x84a0
movq %r15, %rdi
cmpq %r12, %r15
jne 0x10565
movq 0x50(%rsp), %rdi
cmpq %rbp, %rdi
leaq 0x38(%rsp), %r12
je 0x10594
movq (%rdi), %r15
callq 0x84a0
movq %r15, %rdi
cmpq %rbp, %r15
jne 0x10584
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x105ae
movq (%rdi), %r15
callq 0x84a0
movq %r15, %rdi
cmpq %r12, %r15
jne 0x1059e
cmpb $0x0, 0x6(%rsp)
jne 0x10160
leaq 0xc8(%rsp), %rsi
movq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0x8930
movq 0x449a0(%rip), %rsi # 0x54f78
leaq 0xb0(%rsp), %rdi
callq 0x83b0
leaq 0x130(%rsp), %rdi
callq 0x8190
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x10604
callq 0x84a0
movq %rbx, %rax
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x10636
movq %rax, %rbx
jmp 0x10657
jmp 0x10629
jmp 0x10629
jmp 0x10629
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x106fa
movq 0x4493b(%rip), %rsi # 0x54f78
leaq 0xb0(%rsp), %rdi
callq 0x83b0
leaq 0x130(%rsp), %rdi
callq 0x8190
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x10669
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/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(needle, haystack) == expected_to_be_substring)
return AssertionSuccess();
const bool is_wide_string = sizeof(needle[0]) > 1;
const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
return AssertionFailure()
<< "Value of: " << needle_expr << "\n"
<< " Actual: " << begin_string_quote << needle << "\"\n"
<< "Expected: " << (expected_to_be_substring ? "" : "not ")
<< "a substring of " << haystack_expr << "\n"
<< "Which is: " << begin_string_quote << haystack << "\"";
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movq %r8, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0x117ae
cmpq %rdi, %rsi
sete %al
jmp 0x117b9
callq 0x8680
testq %rax, %rax
setne %al
cmpb %bpl, %al
je 0x11901
leaq 0x2d9a5(%rip), %rax # 0x3f16e
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
leaq 0x2b84f(%rip), %rsi # 0x3d034
callq 0x2eab6
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2b166
leaq 0x2bfe4(%rip), %rsi # 0x3d7e2
movq %rax, %rdi
callq 0x2b754
leaq 0x2b833(%rip), %rsi # 0x3d040
movq %rax, %rdi
callq 0x2eab6
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2b166
movq %rax, %rdi
movq %r15, %rsi
callq 0x32474
leaq 0x2c3b0(%rip), %rsi # 0x3dbe4
movq %rax, %rdi
callq 0x2b460
leaq 0x2b809(%rip), %rsi # 0x3d04c
movq %rax, %rdi
callq 0x2eab6
leaq 0x2bf91(%rip), %rcx # 0x3d7e3
leaq 0x2d900(%rip), %rdx # 0x3f159
testb %bpl, %bpl
cmovneq %rcx, %rdx
leaq 0x30(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0x2b166
leaq 0x2d8e7(%rip), %rsi # 0x3f15e
movq %rax, %rdi
callq 0x323f6
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2b166
leaq 0x2bf4f(%rip), %rsi # 0x3d7e2
movq %rax, %rdi
callq 0x2b754
leaq 0x2b76b(%rip), %rsi # 0x3d00d
movq %rax, %rdi
callq 0x2eab6
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2b166
movq %rax, %rdi
movq %r14, %rsi
callq 0x32474
leaq 0x2c308(%rip), %rsi # 0x3dbd1
movq %rax, %rdi
callq 0x2b754
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf99c
movq 0x28(%rsp), %r14
testq %r14, %r14
je 0x1190c
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x118f7
callq 0x84a0
movq %r14, %rdi
callq 0x84a0
jmp 0x1190c
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1191c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb09e
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::internal::String::CaseInsensitiveWideCStringEquals(wchar_t const*, wchar_t const*)
|
bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
const wchar_t* rhs) {
if (lhs == nullptr) return rhs == nullptr;
if (rhs == nullptr) return false;
#if GTEST_OS_WINDOWS
return _wcsicmp(lhs, rhs) == 0;
#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
return wcscasecmp(lhs, rhs) == 0;
#else
// Android, Mac OS X and Cygwin don't define wcscasecmp.
// Other unknown OSes may not define it either.
wint_t left, right;
do {
left = towlower(static_cast<wint_t>(*lhs++));
right = towlower(static_cast<wint_t>(*rhs++));
} while (left && left == right);
return left == right;
#endif // OS selector
}
|
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movq %rdi, %rax
orq %rsi, %rax
sete %al
testb %cl, %cl
jne 0x123f2
pushq %rax
callq 0x8ac0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::internal::String::FormatByte[abi:cxx11](unsigned char)
|
std::string String::FormatByte(unsigned char value) {
std::stringstream ss;
ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
<< static_cast<unsigned int>(value);
return ss.str();
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8360
movq 0x10(%r14), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r14
addq $0x18, %r14
cmpb $0x0, 0xe1(%r14)
jne 0x1258d
movq %r14, %rdi
movl $0x20, %esi
callq 0x84c0
movb %al, 0xe0(%r14)
movb $0x1, 0xe1(%r14)
leaq 0x18(%rsp), %rdi
movb $0x30, 0xe0(%r14)
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x28(%rsp,%rcx)
movq -0x18(%rax), %rcx
movl 0x30(%rsp,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x30(%rsp,%rcx)
movq -0x18(%rax), %rax
orl $0x4000, 0x30(%rsp,%rax) # imm = 0x4000
movzbl %bpl, %esi
callq 0x8330
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8930
movq 0x42993(%rip), %rsi # 0x54f78
leaq 0x8(%rsp), %rdi
callq 0x83b0
leaq 0x88(%rsp), %rdi
callq 0x8190
movq %rbx, %rax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x42963(%rip), %rsi # 0x54f78
leaq 0x8(%rsp), %rdi
callq 0x83b0
leaq 0x88(%rsp), %rdi
callq 0x8190
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::TestResult::GetTestProperty(int) const
|
const TestProperty& TestResult::GetTestProperty(int i) const {
if (i < 0 || i >= test_property_count())
internal::posix::Abort();
return test_properties_.at(static_cast<size_t>(i));
}
|
pushq %rax
testl %esi, %esi
js 0x1271b
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
subq %rax, %rcx
shrq $0x6, %rcx
cmpl %esi, %ecx
jle 0x1271b
movl %esi, %esi
movq 0x58(%rdi), %rdx
subq %rax, %rdx
sarq $0x6, %rdx
cmpq %rsi, %rdx
jbe 0x12720
shlq $0x6, %rsi
addq %rsi, %rax
popq %rcx
retq
callq 0x2c09b
leaq 0x2ca4a(%rip), %rdi # 0x3f171
xorl %eax, %eax
callq 0x88c0
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::TestResult::ValidateTestProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&)
|
bool TestResult::ValidateTestProperty(const std::string& xml_element,
const TestProperty& test_property) {
return ValidateTestPropertyName(test_property.key(),
GetReservedAttributesForElement(xml_element));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x78(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x81f0
leaq 0x2b1f7(%rip), %rsi # 0x3dac6
movq %rbx, %rdi
callq 0x8160
testl %eax, %eax
je 0x12988
leaq 0x2b0b4(%rip), %rsi # 0x3d99a
movq %rbx, %rdi
callq 0x8160
testl %eax, %eax
je 0x129a7
leaq 0x2b0e7(%rip), %rsi # 0x3d9e4
movq %rbx, %rdi
callq 0x8160
testl %eax, %eax
je 0x129c6
leaq 0x2a2b8(%rip), %rdx # 0x3cbcc
leaq 0x40(%rsp), %rdi
movl $0x3, %esi
movl $0x8fb, %ecx # imm = 0x8FB
callq 0x27da0
movq 0x426b1(%rip), %rdi # 0x54fe0
leaq 0x2bf08(%rip), %rsi # 0x3e83e
movl $0x18, %edx
callq 0x85f0
movq 0x42699(%rip), %rdi # 0x54fe0
leaq 0x2bf09(%rip), %rsi # 0x3e857
movl $0x23, %edx
callq 0x85f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x4267a(%rip), %rdi # 0x54fe0
callq 0x85f0
leaq 0x40(%rsp), %rdi
callq 0x27ed2
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
jmp 0x129e3
leaq 0x419e1(%rip), %rsi # 0x54370
leaq 0x41a1a(%rip), %rdx # 0x543b0
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rcx
callq 0x2f2d0
jmp 0x129e3
leaq 0x41a02(%rip), %rsi # 0x543b0
leaq 0x41a3b(%rip), %rdx # 0x543f0
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rcx
callq 0x2f2d0
jmp 0x129e3
leaq 0x41a23(%rip), %rsi # 0x543f0
leaq 0x41a5c(%rip), %rdx # 0x54430
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rcx
callq 0x2f2d0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x32d18
movq %rax, %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rax
je 0x12c1d
leaq 0x38(%rsp), %rdi
callq 0xf68a
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x10(%rax), %r15
leaq 0x2bddd(%rip), %rsi # 0x3e804
movl $0x27, %edx
movq %r15, %rdi
callq 0x85f0
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq %r15, %rdi
callq 0x85f0
leaq 0x2ddda(%rip), %rsi # 0x4082a
movl $0x2, %edx
movq %r15, %rdi
callq 0x85f0
movq %r15, 0x68(%rsp)
movq %r14, 0x70(%rsp)
movq %rbx, 0x60(%rsp)
movq %rsp, %rdi
callq 0xf68a
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
je 0x12b49
sarq $0x5, %rax
movq (%rsp), %r12
addq $0x10, %r12
movl $0x8, %r14d
xorl %r15d, %r15d
leaq 0x2dc27(%rip), %r13 # 0x406c7
leaq 0x2d63b(%rip), %rbp # 0x400e2
leaq 0x2a2e0(%rip), %rbx # 0x3cd8e
testq %r15, %r15
sete %cl
cmpq $0x3, %rax
setb %al
orb %cl, %al
jne 0x12acf
movl $0x2, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x85f0
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
sarq $0x5, %rax
decq %rax
cmpq %rax, %r15
jne 0x12af5
movl $0x4, %edx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x85f0
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x85f0
movq 0x10(%rsp), %rax
movq -0x8(%rax,%r14), %rsi
movq (%rax,%r14), %rdx
movq %r12, %rdi
callq 0x85f0
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x85f0
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
incq %r15
sarq $0x5, %rax
addq $0x20, %r14
cmpq %rax, %r15
jb 0x12aae
movq (%rsp), %rbx
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0xf8c7
testq %rbx, %rbx
movq 0x68(%rsp), %r15
je 0x12b6d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %r15, %rdi
callq 0x85f0
movq 0x70(%rsp), %r14
leaq 0x2bca1(%rip), %rsi # 0x3e82c
movl $0x11, %edx
movq %r15, %rdi
callq 0x85f0
leaq 0x2ab30(%rip), %rsi # 0x3d6cf
movl $0xb, %edx
movq %r15, %rdi
callq 0x85f0
leaq 0x2d6bf(%rip), %rsi # 0x40272
movl $0x1, %edx
movq %r15, %rdi
callq 0x85f0
leaq 0x2a005(%rip), %rdx # 0x3cbcc
leaq 0x2a745(%rip), %r8 # 0x3d313
movq %rsp, %rdi
movl $0x1, %esi
movl $0x924, %ecx # imm = 0x924
callq 0xbc60
movq 0x60(%rsp), %rbx
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
callq 0xbcec
movq %rsp, %rdi
callq 0xbcc6
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12c0d
callq 0x84a0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x12c1d
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x2ac36
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12c3d
callq 0x84a0
cmpq %r14, %rbx
sete %al
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0xbcc6
jmp 0x12c89
jmp 0x12c86
jmp 0x12c9e
jmp 0x12c81
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x27ed2
jmp 0x12ccd
movq %rax, %r14
jmp 0x12ccd
movq %rax, %r14
jmp 0x12cc3
movq %rax, %r14
jmp 0x12cb0
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12cb0
callq 0x84a0
jmp 0x12cb0
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x12cb0
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x0, 0x30(%rsp)
je 0x12cc3
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x2ac36
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12ce3
callq 0x84a0
movq %r14, %rdi
callq 0x8a20
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::TestResult::Skipped() const
|
bool TestResult::Skipped() const {
return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x12d58
testb %al, %al
je 0x12d2d
xorl %eax, %eax
jmp 0x12d55
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x12d55
xorl %esi, %esi
cmpl $0x3, (%rcx)
sete %sil
addl %esi, %eax
addq $0x70, %rcx
cmpq %rdx, %rcx
jne 0x12d3c
testl %eax, %eax
setne %al
popq %rbx
retq
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::UnitTest::RecordProperty(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 UnitTest::RecordProperty(const std::string& key,
const std::string& value) {
impl_->RecordProperty(TestProperty(key, value));
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x40(%rdi), %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2cc44
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ed02
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12eda
callq 0x84a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12eed
callq 0x84a0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2cca2
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/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 about the source file where the exception occurred.
-1, // We have no info on which line caused the exception.
message,
""); // No stack trace, either.
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
callq 0xbdbe
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2a7cb(%rip), %rdx # 0x3d7e3
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xb728
leaq 0x42b61(%rip), %rdi # 0x55b90
movl %ebp, %esi
xorl %edx, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movq %rbx, %r8
movq %r14, %r9
callq 0xbe2e
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x13052
callq 0x84a0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1306f
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::internal::GoogleTestFailureException::GoogleTestFailureException(testing::TestPartResult const&)
|
GoogleTestFailureException::GoogleTestFailureException(
const TestPartResult& failure)
: ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x134e5
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x8ae0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x134b5
callq 0x84a0
leaq 0x410ac(%rip), %rax # 0x54568
movq %rax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x134dd
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::Test::Run()
|
void Test::Run() {
if (!HasSameFixtureClass()) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
// We will run the test only if SetUp() was successful and didn't call
// GTEST_SKIP().
if (!HasFatalFailure() && !IsSkipped()) {
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
this, &Test::TestBody, "the test body");
}
// However, we want to clean up as much as possible. Hence we will
// always call TearDown(), even if SetUp() or the test body has
// failed.
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
this, &Test::TearDown, "TearDown()");
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x13078
testb %al, %al
je 0x13735
callq 0xbdbe
movq 0x4258c(%rip), %r14 # 0x55bd0
cmpq $0x0, 0x210(%r14)
jne 0x13669
movl $0x8, %edi
callq 0x84e0
leaq 0x40919(%rip), %rcx # 0x53f78
movq %rcx, (%rax)
movq %rax, 0x210(%r14)
movq 0x210(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x29dd2(%rip), %rcx # 0x3d44f
movl $0x11, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2c4c0
callq 0x1373e
testb %al, %al
jne 0x136e6
callq 0x137a8
testb %al, %al
jne 0x136e6
cmpq $0x0, 0x210(%r14)
jne 0x136c3
movl $0x8, %edi
callq 0x84e0
leaq 0x408bf(%rip), %rcx # 0x53f78
movq %rcx, (%rax)
movq %rax, 0x210(%r14)
movq 0x210(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x29d80(%rip), %rcx # 0x3d457
movl $0x21, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2c4c0
cmpq $0x0, 0x210(%r14)
jne 0x1370b
movl $0x8, %edi
callq 0x84e0
leaq 0x40877(%rip), %rcx # 0x53f78
movq %rcx, (%rax)
movq %rax, 0x210(%r14)
movq 0x210(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x29d46(%rip), %rcx # 0x3d465
movl $0x19, %esi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2c4c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc
|
testing::internal::UnitTestImpl::ConfigureStreamingOutput()
|
std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
return os_stack_trace_getter()->CurrentStackTrace(
static_cast<int>(GTEST_FLAG(stack_trace_depth)),
skip_count + 1
// Skips the user-specified number of frames plus this function
// itself.
); // NOLINT
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x35e1c(%rip) # 0x55b30
je 0x1fe37
movq %rdi, %r14
leaq 0x35e04(%rip), %rdi # 0x55b28
movl $0x3a, %esi
xorl %edx, %edx
callq 0x8770
cmpq $-0x1, %rax
je 0x1fdcc
movq %rax, %r15
movl $0x10, %edi
callq 0x84e0
movq %rax, %rbx
leaq 0x35dd7(%rip), %rsi # 0x55b28
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x8540
incq %r15
leaq 0x35dbe(%rip), %rsi # 0x55b28
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x8540
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x2d174
movq 0x1f8(%r14), %rdi
xorl %ebp, %ebp
movq %rbx, %rsi
callq 0x1664e
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fdb7
callq 0x84a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fe37
callq 0x84a0
jmp 0x1fe37
leaq 0x1cdf9(%rip), %rdx # 0x3cbcc
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x15e9, %ecx # imm = 0x15E9
callq 0x27da0
movq 0x351f2(%rip), %rdi # 0x54fe0
leaq 0x1df63(%rip), %rsi # 0x3dd58
movl $0x1f, %edx
callq 0x85f0
movq 0x35d22(%rip), %rsi # 0x55b28
movq 0x35d23(%rip), %rdx # 0x55b30
movq 0x351cc(%rip), %rdi # 0x54fe0
callq 0x85f0
leaq 0x1df2d(%rip), %rsi # 0x3dd4d
movl $0xa, %edx
movq %rax, %rdi
callq 0x85f0
leaq 0x8(%rsp), %rdi
callq 0x27ed2
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movb $0x1, %bpl
jmp 0x1fe77
movq %rax, %r14
movb $0x1, %bpl
jmp 0x1fe8a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x27ed2
jmp 0x1fe97
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fe77
callq 0x84a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fe8a
callq 0x84a0
testb %bpl, %bpl
je 0x1fe97
movq %rbx, %rdi
callq 0x84a0
movq %r14, %rdi
callq 0x8a20
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.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 =
GetUnitTestImpl()->internal_run_death_test_flag();
if (flag != nullptr) {
FILE* parent = posix::FDOpen(flag->write_fd(), "w");
fputc(kDeathTestInternalError, parent);
fprintf(parent, "%s", message.c_str());
fflush(parent);
_exit(1);
} else {
fprintf(stderr, "%s", message.c_str());
fflush(stderr);
posix::Abort();
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xbdbe
movq 0x34ab0(%rip), %rax # 0x55bd0
movq 0x238(%rax), %rax
testq %rax, %rax
jne 0x2114b
movq 0x33e8d(%rip), %r14 # 0x54fc0
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x85c0
movq (%r14), %rdi
callq 0x8640
callq 0x2c09b
movl 0x28(%rax), %edi
leaq 0x1f0d4(%rip), %rsi # 0x40229
callq 0x30d80
movq %rax, %r14
movl $0x49, %edi
movq %rax, %rsi
callq 0x86e0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x85c0
movq %r14, %rdi
callq 0x8640
movl $0x1, %edi
callq 0x8980
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-death-test.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 exited.
do {
bytes_read = posix::Read(read_fd(), &flag, 1);
} while (bytes_read == -1 && errno == EINTR);
if (bytes_read == 0) {
set_outcome(DIED);
} else if (bytes_read == 1) {
switch (flag) {
case kDeathTestReturned:
set_outcome(RETURNED);
break;
case kDeathTestThrew:
set_outcome(THREW);
break;
case kDeathTestLived:
set_outcome(LIVED);
break;
case kDeathTestInternalError:
FailFromInternalError(read_fd()); // Does not return.
break;
default:
GTEST_LOG_(FATAL) << "Death test child process reported "
<< "unexpected status byte ("
<< static_cast<unsigned int>(flag) << ")";
}
} else {
GTEST_LOG_(FATAL) << "Read from death test child process failed: "
<< GetLastErrnoDescription();
}
GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
set_read_fd(-1);
}
|
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 0x8820
movq %rax, %r15
cmpl $-0x1, %r15d
jne 0x2128d
callq 0x8070
cmpl $0x4, (%rax)
je 0x21259
leaq 0x34(%rbx), %r13
testl %r15d, %r15d
je 0x212d0
cmpl $0x1, %r15d
je 0x2129c
jmp 0x212e3
testl %r15d, %r15d
je 0x212cc
cmpl $0x1, %r15d
jne 0x212dc
leaq 0x34(%rbx), %r13
movzbl 0x7(%rsp), %r14d
cmpl $0x51, %r14d
jg 0x213f7
cmpl $0x49, %r14d
je 0x21499
cmpl $0x4c, %r14d
jne 0x21413
movl $0x2, 0x30(%rbx)
jmp 0x2135f
leaq 0x34(%rbx), %r13
movl $0x1, 0x30(%rbx)
jmp 0x2135f
addq $0x34, %rbx
movq %rbx, %r13
leaq 0x1cd13(%rip), %rdx # 0x3dffd
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x1f0, %ecx # imm = 0x1F0
callq 0x27da0
movq 0x33cdb(%rip), %rdi # 0x54fe0
leaq 0x1cdae(%rip), %rsi # 0x3e0ba
movl $0x2b, %edx
callq 0x85f0
leaq 0xf0(%rsp), %rdi
callq 0x2105d
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq 0x33ca6(%rip), %rdi # 0x54fe0
callq 0x85f0
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21355
callq 0x84a0
leaq 0x8(%rsp), %rdi
callq 0x27ed2
movl (%r13), %edi
callq 0x8b10
cmpl $-0x1, %eax
jne 0x213dd
callq 0x8070
cmpl $0x4, (%rax)
je 0x2135f
leaq 0xe0(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x1cd5c(%rip), %rsi # 0x3e0e6
leaq 0x1cd68(%rip), %rdx # 0x3e0f9
leaq 0xd0(%rsp), %rdi
callq 0xb728
leaq 0x1cc58(%rip), %rsi # 0x3dffd
leaq 0xd0(%rsp), %rdi
callq 0x8af0
leaq 0xc0(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x21623
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x21636
movl $0xffffffff, (%r13) # imm = 0xFFFFFFFF
addq $0x1f8, %rsp # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x54, %r14d
je 0x215a5
cmpl $0x52, %r14d
jne 0x21413
movl $0x3, 0x30(%rbx)
jmp 0x2135f
leaq 0x1cbe3(%rip), %rdx # 0x3dffd
leaq 0xf0(%rsp), %rdi
movl $0x3, %esi
movl $0x1eb, %ecx # imm = 0x1EB
callq 0x27da0
movq 0x33ba8(%rip), %rdi # 0x54fe0
leaq 0x1cc3f(%rip), %rsi # 0x3e07e
movl $0x22, %edx
callq 0x85f0
movq 0x33b90(%rip), %rdi # 0x54fe0
leaq 0x1cc4a(%rip), %rsi # 0x3e0a1
movl $0x18, %edx
callq 0x85f0
movsbq %r14b, %rax
movl %eax, %esi
movq 0x33b72(%rip), %rdi # 0x54fe0
callq 0x8330
leaq 0x1edf8(%rip), %rsi # 0x40272
movl $0x1, %edx
movq %rax, %rdi
callq 0x85f0
leaq 0xf0(%rsp), %rdi
callq 0x27ed2
jmp 0x2135f
movl (%r13), %ebp
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0xf68a
movq (%rbx), %rbx
leaq 0x10(%rbx), %r14
leaq 0xf0(%rsp), %r15
movl $0xff, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x8820
movq %rax, %r12
testl %r12d, %r12d
jle 0x214fb
andl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
movb $0x0, 0xf0(%rsp,%r12)
movq %r15, %rdi
callq 0x8210
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x85f0
jmp 0x214bc
cmpl $-0x1, %r12d
jne 0x2150b
callq 0x8070
cmpl $0x4, (%rax)
je 0x214bc
testl %r12d, %r12d
je 0x215b1
callq 0x8070
movl (%rax), %ebp
leaq 0x1cadb(%rip), %rdx # 0x3dffd
leaq 0x28(%rsp), %rdi
movl $0x3, %esi
movl $0x16b, %ecx # imm = 0x16B
callq 0x27da0
movq 0x33aa3(%rip), %rdi # 0x54fe0
leaq 0x1d7b1(%rip), %rsi # 0x3ecf5
movl $0x29, %edx
callq 0x85f0
leaq 0x8(%rsp), %rdi
callq 0x2105d
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x33a77(%rip), %rdi # 0x54fe0
callq 0x85f0
movq %rax, %r14
leaq 0x1dd94(%rip), %rsi # 0x3f30c
movl $0x2, %edx
movq %rax, %rdi
callq 0x85f0
movq %r14, %rdi
movl %ebp, %esi
callq 0x89d0
leaq 0x1cf2c(%rip), %rsi # 0x3e4c2
movl $0x1, %edx
movq %rax, %rdi
callq 0x85f0
jmp 0x215ef
movl $0x4, 0x30(%rbx)
jmp 0x2135f
leaq 0x1ca45(%rip), %rdx # 0x3dffd
leaq 0x28(%rsp), %rdi
movl $0x3, %esi
movl $0x168, %ecx # imm = 0x168
callq 0x27da0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xf8c7
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x339f6(%rip), %rdi # 0x54fe0
callq 0x85f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21602
callq 0x84a0
leaq 0x28(%rsp), %rdi
callq 0x27ed2
testq %rbx, %rbx
je 0x2135f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0x2135f
movq %rdx, 0xb0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xc0(%rsp)
movq 0x8(%rax), %rdx
leaq 0xb0(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1ca9e(%rip), %rsi # 0x3e0fa
callq 0x8af0
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x21684
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x21691
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x8c(%rsp), %rsi
movl $0x1f3, (%rsi) # imm = 0x1F3
leaq 0x68(%rsp), %rdi
callq 0x2cbb6
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x70(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x216e3
movq 0x58(%rsp), %rsi
leaq 0x78(%rsp), %r13
cmpq %rsi, %rax
jbe 0x21703
movl $0xf, %esi
cmpq %r13, 0x68(%rsp)
je 0x216fe
movq 0x78(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x21714
movq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x8170
jmp 0x21722
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85d0
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x2173f
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x2174c
movq %rsi, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x1c413(%rip), %rsi # 0x3db83
leaq 0x28(%rsp), %rdi
callq 0x8af0
leaq 0xa0(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2179e
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x217b1
movq %rdx, 0x90(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xa0(%rsp)
movq 0x8(%rax), %rdx
leaq 0x90(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1c92b(%rip), %rsi # 0x3e102
callq 0x8af0
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x21801
movups (%rcx), %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x2180e
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1cae6(%rip), %rsi # 0x3e317
callq 0x8af0
leaq 0x100(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x21861
movups (%rcx), %xmm0
leaq 0x100(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x21874
movq %rdx, 0xf0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x100(%rsp)
movq 0x8(%rax), %rdx
leaq 0xf0(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x2110d
jmp 0x218e5
jmp 0x218a3
jmp 0x2199d
jmp 0x218a3
movq %rax, %r14
jmp 0x218fb
jmp 0x2199d
movq %rax, %r14
movq 0xf0(%rsp), %rdi
leaq 0x100(%rsp), %rax
cmpq %rax, %rdi
je 0x218cf
callq 0x84a0
jmp 0x218cf
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2190d
callq 0x84a0
jmp 0x2190d
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x218fb
callq 0x84a0
leaq 0x28(%rsp), %rdi
callq 0x27ed2
jmp 0x219a0
movq %rax, %r14
movq 0x90(%rsp), %rdi
cmpq %rbp, %rdi
je 0x21960
callq 0x84a0
jmp 0x21960
movq %rax, %r14
leaq 0xf0(%rsp), %rdi
jmp 0x21953
movq %rax, %r14
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2194e
callq 0x84a0
jmp 0x2194e
jmp 0x2194b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x27ed2
jmp 0x219e1
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21978
callq 0x84a0
jmp 0x21978
movq %rax, %r14
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x2198c
callq 0x84a0
jmp 0x2198c
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x219b3
callq 0x84a0
jmp 0x219b3
movq %rax, %r14
testq %rbx, %rbx
je 0x219e1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0x219e1
movq %rax, %r14
movq 0xb0(%rsp), %rdi
cmpq %r15, %rdi
je 0x219ca
callq 0x84a0
jmp 0x219ca
movq %rax, %r14
movq 0xd0(%rsp), %rdi
cmpq %rbx, %rdi
je 0x219e1
callq 0x84a0
jmp 0x219e1
movq %rax, %r14
movq %r14, %rdi
callq 0x8a20
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/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"
<< " Error msg:\n" << FormatDeathTestOutput(error_message);
break;
case THREW:
buffer << " Result: threw an exception.\n"
<< " Error msg:\n" << FormatDeathTestOutput(error_message);
break;
case RETURNED:
buffer << " Result: illegal return in test statement.\n"
<< " Error msg:\n" << FormatDeathTestOutput(error_message);
break;
case DIED:
if (status_ok) {
if (matcher_.Matches(error_message)) {
success = true;
} else {
std::ostringstream stream;
matcher_.DescribeTo(&stream);
buffer << " Result: died but not with expected error.\n"
<< " Expected: " << stream.str() << "\n"
<< "Actual msg:\n"
<< FormatDeathTestOutput(error_message);
}
} else {
buffer << " Result: died but not with expected exit code:\n"
<< " " << ExitSummary(status()) << "\n"
<< "Actual msg:\n" << FormatDeathTestOutput(error_message);
}
break;
case IN_PROGRESS:
default:
GTEST_LOG_(FATAL)
<< "DeathTest::Passed somehow called before conclusion of test";
}
DeathTest::set_last_death_test_message(buffer.GetString());
return success;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
cmpb $0x1, 0x28(%rdi)
jne 0x21e65
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq *0x30(%rax)
leaq 0x8(%rsp), %rdi
callq 0xf68a
movq 0x8(%rsp), %rbx
addq $0x10, %rbx
leaq 0x1c300(%rip), %rsi # 0x3e142
movl $0xc, %edx
movq %rbx, %rdi
callq 0x85f0
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x21e6c
movq %r15, %rdi
callq 0x8210
movq %rax, %rdx
jmp 0x21e78
xorl %ebp, %ebp
jmp 0x222d7
movl $0x6, %edx
leaq 0x1b361(%rip), %r15 # 0x3d1d9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x85f0
leaq 0x1b958(%rip), %rsi # 0x3d7e2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85f0
movl 0x30(%r14), %eax
decl %eax
cmpl $0x3, %eax
ja 0x220ce
leaq 0x19aeb(%rip), %rcx # 0x3b998
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testb %bpl, %bpl
je 0x22110
addq $0x10, %r14
leaq 0x70(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq 0x32b09(%rip), %rax # 0x549e0
movq %rax, (%rdx)
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x33d9c
movb $0x1, %bpl
testb %al, %al
jne 0x2227d
leaq 0x70(%rsp), %rdi
callq 0x87b0
leaq 0x70(%rsp), %rsi
movq %r14, %rdi
callq 0x2dc64
leaq 0x1c2b8(%rip), %rsi # 0x3e1c8
movl $0x2e, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x1c2d3(%rip), %rsi # 0x3e1f7
movl $0xc, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x78(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x8930
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x85f0
leaq 0x1b889(%rip), %rsi # 0x3d7e2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x1c297(%rip), %rsi # 0x3e204
movl $0xc, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x223ff
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x85f0
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21fae
callq 0x84a0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21fc1
callq 0x84a0
movq 0x32fd8(%rip), %rsi # 0x54fa0
leaq 0x70(%rsp), %rdi
callq 0x8290
leaq 0xe0(%rsp), %rdi
callq 0x8190
jmp 0x2227b
leaq 0x1c1ae(%rip), %rsi # 0x3e199
movl $0x2e, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x1c16c(%rip), %rsi # 0x3e16b
movl $0xc, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x223ff
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %rbx, %rdi
callq 0x85f0
jmp 0x22265
leaq 0x1c13f(%rip), %rsi # 0x3e178
movl $0x20, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x1c11e(%rip), %rsi # 0x3e16b
movl $0xc, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x223ff
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %rbx, %rdi
callq 0x85f0
jmp 0x22265
leaq 0x1c0c8(%rip), %rsi # 0x3e14f
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x1c0d0(%rip), %rsi # 0x3e16b
movl $0xc, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x223ff
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %rbx, %rdi
callq 0x85f0
jmp 0x22265
leaq 0x1bf28(%rip), %rdx # 0x3dffd
leaq 0x70(%rsp), %rdi
movl $0x3, %esi
movl $0x265, %ecx # imm = 0x265
callq 0x27da0
movq 0x32ef0(%rip), %rdi # 0x54fe0
leaq 0x1c15a(%rip), %rsi # 0x3e251
movl $0x3a, %edx
callq 0x85f0
leaq 0x70(%rsp), %rdi
callq 0x27ed2
jmp 0x2227b
leaq 0x1c0fa(%rip), %rsi # 0x3e211
movl $0x32, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x1c119(%rip), %rsi # 0x3e244
movl $0xc, %edx
movq %rbx, %rdi
callq 0x85f0
movl 0x2c(%r14), %r14d
leaq 0x10(%rsp), %rdi
callq 0xf68a
movl %r14d, %ebp
andl $0x7f, %r14d
je 0x2218e
movl %r14d, %eax
shll $0x18, %eax
addl $0x1000000, %eax # imm = 0x1000000
cmpl $0x2000000, %eax # imm = 0x2000000
jl 0x221b8
movl %r14d, %r15d
movq 0x10(%rsp), %r14
addq $0x10, %r14
leaq 0x1cbd2(%rip), %rsi # 0x3ed46
movl $0x15, %edx
movq %r14, %rdi
callq 0x85f0
movq %r14, %rdi
movl %r15d, %esi
callq 0x89d0
jmp 0x221b8
movq 0x10(%rsp), %r14
addq $0x10, %r14
leaq 0x1cb8f(%rip), %rsi # 0x3ed2d
movl $0x18, %edx
movq %r14, %rdi
callq 0x85f0
movl %ebp, %eax
movzbl %ah, %esi
movq %r14, %rdi
callq 0x89d0
testb %bpl, %bpl
jns 0x221d7
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x1cb8f(%rip), %rsi # 0x3ed5c
movl $0xe, %edx
callq 0x85f0
movq 0x10(%rsp), %r14
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
callq 0xf8c7
testq %r14, %r14
je 0x221f7
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %rbx, %rdi
callq 0x85f0
leaq 0x1b5d2(%rip), %rsi # 0x3d7e2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x1bfe0(%rip), %rsi # 0x3e204
movl $0xc, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x223ff
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x85f0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22265
callq 0x84a0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2227b
callq 0x84a0
xorl %ebp, %ebp
movq 0x8(%rsp), %rbx
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0xf8c7
leaq 0x33992(%rip), %rdi # 0x55c28
leaq 0x70(%rsp), %rsi
callq 0x82a0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x222b6
callq 0x84a0
testq %rbx, %rbx
je 0x222c4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x222d7
callq 0x84a0
movl %ebp, %eax
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2238d
jmp 0x2238d
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22338
callq 0x84a0
jmp 0x22338
jmp 0x22335
jmp 0x2234d
jmp 0x223c8
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x223a7
callq 0x84a0
jmp 0x223a7
jmp 0x223a4
jmp 0x223c8
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22350
callq 0x84a0
jmp 0x22350
movq %rax, %rbx
movq 0x32c49(%rip), %rsi # 0x54fa0
leaq 0x70(%rsp), %rdi
callq 0x8290
leaq 0xe0(%rsp), %rdi
callq 0x8190
jmp 0x223cb
jmp 0x223a4
jmp 0x223a4
jmp 0x223a4
jmp 0x223c8
jmp 0x223c8
jmp 0x223c8
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x27ed2
jmp 0x223cb
jmp 0x223c8
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x223cb
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x223cb
jmp 0x223a4
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x223cb
callq 0x84a0
jmp 0x223cb
jmp 0x223c8
movq %rax, %rbx
jmp 0x223e4
jmp 0x223c8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x223db
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x223f7
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-death-test.cc
|
testing::internal::NoExecDeathTest::AssumeRole()
|
DeathTest::TestRole NoExecDeathTest::AssumeRole() {
const size_t thread_count = GetThreadCount();
if (thread_count != 1) {
GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
}
int pipe_fd[2];
GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
DeathTest::set_last_death_test_message("");
CaptureStderr();
// When we fork the process below, the log file buffers are copied, but the
// file descriptors are shared. We flush all log files here so that closing
// the file descriptors in the child process doesn't throw off the
// synchronization between descriptors and buffers in the parent process.
// This is as close to the fork as possible to avoid a race condition in case
// there are multiple threads running before the death test, and another
// thread writes to the log file.
FlushInfoLog();
const pid_t child_pid = fork();
GTEST_DEATH_TEST_CHECK_(child_pid != -1);
set_child_pid(child_pid);
if (child_pid == 0) {
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0]));
set_write_fd(pipe_fd[1]);
// Redirects all logging to stderr in the child process to prevent
// concurrent writes to the log files. We capture stderr in the parent
// process and append the child process' output to a log.
LogToStderr();
// Event forwarding to the listeners of event listener API mush be shut
// down in death test subprocesses.
GetUnitTestImpl()->listeners()->SuppressEventForwarding();
g_in_fast_death_test_child = true;
return EXECUTE_TEST;
} else {
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
set_read_fd(pipe_fd[0]);
set_spawned(true);
return OVERSEE_TEST;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %rbx
callq 0x23a39
cmpq $0x1, %rax
je 0x22b61
movq %rax, %r12
leaq 0x1b5ee(%rip), %rdx # 0x3dffd
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
movl $0x461, %ecx # imm = 0x461
callq 0x27da0
leaq 0x88(%rsp), %rdi
callq 0xf68a
movq 0x88(%rsp), %r14
leaq 0x10(%r14), %r15
leaq 0x1c328(%rip), %rsi # 0x3ed6b
movl $0x34, %edx
movq %r15, %rdi
callq 0x85f0
leaq 0x1c349(%rip), %rsi # 0x3eda0
movl $0x27, %edx
movq %r15, %rdi
callq 0x85f0
leaq 0x1ac64(%rip), %rsi # 0x3d6cf
movl $0xb, %edx
movq %r15, %rdi
callq 0x85f0
leaq 0x1a587(%rip), %rsi # 0x3d006
movl $0x1, %edx
movq %r15, %rdi
callq 0x85f0
testq %r12, %r12
je 0x22abf
leaq 0x1c357(%rip), %rsi # 0x3edef
movl $0x9, %r13d
movl $0x9, %edx
movq %r15, %rdi
callq 0x85f0
movq %r15, %rdi
movq %r12, %rsi
callq 0x8330
leaq 0x1c328(%rip), %rsi # 0x3ede5
jmp 0x22acc
movl $0x26, %r13d
leaq 0x1c2fc(%rip), %rsi # 0x3edc8
movq %r15, %rdi
movq %r13, %rdx
callq 0x85f0
leaq 0x1c31b(%rip), %rsi # 0x3edf9
movl $0x5e, %edx
movq %r15, %rdi
callq 0x85f0
leaq 0x1c366(%rip), %rsi # 0x3ee58
movl $0x3c, %edx
movq %r15, %rdi
callq 0x85f0
leaq 0x1c38f(%rip), %rsi # 0x3ee95
movl $0x3d, %edx
movq %r15, %rdi
callq 0x85f0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0xf8c7
testq %r14, %r14
je 0x22b2e
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x324a1(%rip), %rdi # 0x54fe0
callq 0x85f0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22b57
callq 0x84a0
leaq 0x28(%rsp), %rdi
callq 0x27ed2
leaq 0xc8(%rsp), %rdi
callq 0x87c0
cmpl $-0x1, %eax
je 0x22eb0
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1ac5c(%rip), %rdx # 0x3d7e3
leaq 0x48(%rsp), %rdi
movq %rdx, %rsi
callq 0xb728
leaq 0x3308d(%rip), %rdi # 0x55c28
leaq 0x48(%rsp), %rsi
callq 0x82a0
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x22bb4
callq 0x84a0
leaq 0x1b910(%rip), %rsi # 0x3e4cb
leaq 0x3308e(%rip), %rdx # 0x55c50
movl $0x2, %edi
callq 0x27f3d
xorl %edi, %edi
callq 0x8640
callq 0x8130
cmpl $-0x1, %eax
je 0x22f13
movl %eax, 0x3c(%rbx)
testl %eax, %eax
je 0x22c7d
movl 0xcc(%rsp), %edi
callq 0x8b10
cmpl $-0x1, %eax
jne 0x22cbd
callq 0x8070
cmpl $0x4, (%rax)
je 0x22bec
leaq 0xb8(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1b4c8(%rip), %rsi # 0x3e0e6
leaq 0x1b4d4(%rip), %rdx # 0x3e0f9
leaq 0xa8(%rsp), %rdi
callq 0xb728
leaq 0x1b3c4(%rip), %rsi # 0x3dffd
leaq 0xa8(%rsp), %rdi
callq 0x8af0
leaq 0xe0(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x22d40
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x22d53
callq 0x8070
cmpl $0x4, (%rax)
jne 0x22cdf
movl 0xc8(%rsp), %edi
callq 0x8b10
cmpl $-0x1, %eax
je 0x22c73
movl 0xcc(%rsp), %eax
movl %eax, 0x38(%rbx)
callq 0xbdbe
movq 0x32f2c(%rip), %rax # 0x55bd0
movq 0x1f8(%rax), %rax
movb $0x0, 0x8(%rax)
movb $0x1, 0x32f6b(%rip) # 0x55c21
movl $0x1, %eax
jmp 0x22ccd
movl 0xc8(%rsp), %eax
movl %eax, 0x34(%rbx)
movb $0x1, 0x28(%rbx)
xorl %eax, %eax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb8(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1b3f4(%rip), %rsi # 0x3e0e6
leaq 0x1b400(%rip), %rdx # 0x3e0f9
leaq 0xa8(%rsp), %rdi
callq 0xb728
leaq 0x1b2f0(%rip), %rsi # 0x3dffd
leaq 0xa8(%rsp), %rdi
callq 0x8af0
leaq 0xe0(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x22da0
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x22db3
movq %rdx, 0xd0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xe0(%rsp)
movq 0x8(%rax), %rdx
leaq 0xd0(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1b381(%rip), %rsi # 0x3e0fa
callq 0x8af0
leaq 0x78(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x22e07
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x22e14
movq %rdx, 0xd0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xe0(%rsp)
movq 0x8(%rax), %rdx
leaq 0xd0(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1b321(%rip), %rsi # 0x3e0fa
callq 0x8af0
leaq 0x78(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x22f78
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x22f85
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x70(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x114(%rsp), %rsi
movl $0x482, (%rsi) # imm = 0x482
leaq 0xf0(%rsp), %rdi
callq 0x2cbb6
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %r8
movq 0xf8(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r13, %rcx
je 0x22e6c
movq 0x78(%rsp), %rsi
leaq 0x100(%rsp), %rbp
cmpq %rsi, %rax
jbe 0x22e99
movl $0xf, %esi
cmpq %rbp, 0xf0(%rsp)
je 0x22e90
movq 0x100(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x2301d
movq 0xf0(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x8170
jmp 0x2302e
leaq 0xe0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b223(%rip), %rsi # 0x3e0e6
leaq 0x1b22f(%rip), %rdx # 0x3e0f9
leaq 0xd0(%rsp), %rdi
callq 0xb728
leaq 0x1b11f(%rip), %rsi # 0x3dffd
leaq 0xd0(%rsp), %rdi
callq 0x8af0
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x231aa
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x231b7
leaq 0xe0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1b1c0(%rip), %rsi # 0x3e0e6
leaq 0x1b1cc(%rip), %rdx # 0x3e0f9
leaq 0xd0(%rsp), %rdi
callq 0xb728
leaq 0x1b0bc(%rip), %rsi # 0x3dffd
leaq 0xd0(%rsp), %rdi
callq 0x8af0
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x23209
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x23216
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x70(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x114(%rsp), %rsi
movl $0x476, (%rsi) # imm = 0x476
leaq 0xf0(%rsp), %rdi
callq 0x2cbb6
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %r8
movq 0xf8(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r13, %rcx
je 0x22fdd
movq 0x78(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x23006
leaq 0x100(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x22ffd
movq 0x100(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x230b2
movq 0xf0(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x8170
jmp 0x230c3
leaq 0xf0(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85d0
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x2304b
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x23058
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x1ab07(%rip), %rsi # 0x3db83
leaq 0x8(%rsp), %rdi
callq 0x8af0
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x23143
movups (%rcx), %xmm0
leaq 0x38(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x23150
leaq 0xf0(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85d0
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x230e0
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x230ed
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x1aa72(%rip), %rsi # 0x3db83
leaq 0x8(%rsp), %rdi
callq 0x8af0
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x23267
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x23274
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1b175(%rip), %rsi # 0x3e2e8
callq 0x8af0
leaq 0x98(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x232ce
movups (%rcx), %xmm0
leaq 0x98(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x232e1
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1af20(%rip), %rsi # 0x3e0fa
callq 0x8af0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x23330
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x2333d
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1aec1(%rip), %rsi # 0x3e0fa
callq 0x8af0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x233d5
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x233e2
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1b03f(%rip), %rsi # 0x3e2d6
callq 0x8af0
leaq 0x98(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2347a
movups (%rcx), %xmm0
leaq 0x98(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x2348d
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1b010(%rip), %rsi # 0x3e317
callq 0x8af0
movq %r14, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x234d5
movups (%rcx), %xmm0
movups %xmm0, (%r14)
jmp 0x234e2
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xf0(%rsp), %rsi
movl $0x465, (%rsi) # imm = 0x465
leaq 0xa8(%rsp), %rdi
callq 0x2cbb6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0xb0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x23395
movq 0x18(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x233be
leaq 0xb8(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x233b5
movq 0xb8(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x23531
movq 0xa8(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x8170
jmp 0x23542
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xf0(%rsp), %rsi
movl $0x473, (%rsi) # imm = 0x473
leaq 0xa8(%rsp), %rdi
callq 0x2cbb6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0xb0(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r13, %rcx
je 0x2343a
movq 0x18(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x23463
leaq 0xb8(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x2345a
movq 0xb8(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x235c6
movq 0xa8(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x8170
jmp 0x235d7
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1ae64(%rip), %rsi # 0x3e317
callq 0x8af0
movq %r14, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x23503
movups (%rcx), %xmm0
movups %xmm0, (%r14)
jmp 0x23510
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x2110d
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x2110d
leaq 0xa8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85d0
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x2355f
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x2356c
movq %rsi, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x1a5f3(%rip), %rsi # 0x3db83
leaq 0x28(%rsp), %rdi
callq 0x8af0
leaq 0x98(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x23653
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x23666
leaq 0xa8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85d0
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x235f4
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x23601
movq %rsi, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x1a55e(%rip), %rsi # 0x3db83
leaq 0x28(%rsp), %rdi
callq 0x8af0
leaq 0x98(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x236b2
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x236c5
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1ac26(%rip), %rsi # 0x3e2b2
callq 0x8af0
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2370d
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
jmp 0x2371a
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x1abdb(%rip), %rsi # 0x3e2c6
callq 0x8af0
movq %r14, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2373b
movups (%rcx), %xmm0
movups %xmm0, (%r14)
jmp 0x23748
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x2110d
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x2110d
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x23780
callq 0x84a0
jmp 0x23780
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %rbp, %rdi
je 0x237c2
callq 0x84a0
jmp 0x237c2
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x237ab
callq 0x84a0
jmp 0x237ab
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r13, %rdi
je 0x237da
callq 0x84a0
jmp 0x237da
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x237f2
callq 0x84a0
jmp 0x237f2
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2380d
callq 0x84a0
jmp 0x2380d
movq %rax, %rbx
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2385b
callq 0x84a0
jmp 0x2385b
movq %rax, %rbx
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2386f
callq 0x84a0
jmp 0x2386f
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x2383c
callq 0x84a0
jmp 0x2383c
movq %rax, %rbx
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x238b6
callq 0x84a0
jmp 0x238b6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x238ca
callq 0x84a0
jmp 0x238ca
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x238de
callq 0x84a0
jmp 0x238de
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x23897
callq 0x84a0
jmp 0x23897
movq %rax, %rbx
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x238f2
callq 0x84a0
jmp 0x238f2
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2390b
callq 0x84a0
jmp 0x2390b
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x23923
callq 0x84a0
jmp 0x23923
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x23933
callq 0x84a0
jmp 0x23933
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x23943
callq 0x84a0
jmp 0x23943
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2395b
callq 0x84a0
jmp 0x2395b
movq %rax, %rbx
movq 0xd0(%rsp), %rdi
jmp 0x23a03
movq %rax, %rbx
movq 0xd0(%rsp), %rdi
jmp 0x239c0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x239a2
callq 0x84a0
jmp 0x239a2
movq %rax, %rbx
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x239af
jmp 0x239cc
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23a20
callq 0x84a0
jmp 0x23a20
jmp 0x23a2e
jmp 0x23a2e
movq %rax, %rbx
jmp 0x23a20
movq %rax, %rbx
movq 0xf0(%rsp), %rdi
cmpq %rbp, %rdi
je 0x239cc
callq 0x84a0
jmp 0x239cc
jmp 0x239c9
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
jne 0x23a08
jmp 0x23a31
jmp 0x23a2e
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x239e2
callq 0x84a0
jmp 0x239e2
jmp 0x239df
movq %rax, %rbx
movq 0xd0(%rsp), %rdi
cmpq %r12, %rdi
je 0x239fb
callq 0x84a0
jmp 0x239fb
jmp 0x239f8
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
cmpq %r15, %rdi
je 0x23a31
callq 0x84a0
jmp 0x23a31
movq %rax, %rbx
testq %r14, %r14
je 0x23a20
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x28(%rsp), %rdi
callq 0x27ed2
jmp 0x23a31
jmp 0x23a2e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-death-test.cc
|
testing::internal::FilePath::GetCurrentDir()
|
FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \
GTEST_OS_XTENSA
// These platforms do not have a current directory, so we just return
// something reasonable.
return FilePath(kCurrentDirectoryString);
#elif GTEST_OS_WINDOWS
char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
#else
char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
char* result = getcwd(cwd, sizeof(cwd));
# if GTEST_OS_NACL
// getcwd will likely fail in NaCl due to the sandbox, so return something
// reasonable. The user may have provided a shim implementation for getcwd,
// however, so fallback only when failure is detected.
return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
# endif // GTEST_OS_NACL
return FilePath(result == nullptr ? "" : cwd);
#endif // GTEST_OS_WINDOWS_MOBILE
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1028, %rsp # imm = 0x1028
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x1001, %edx # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0x82c0
movl $0x1001, %esi # imm = 0x1001
movq %r14, %rdi
callq 0x8260
testq %rax, %rax
leaq 0x16845(%rip), %r15 # 0x3d7e3
cmovneq %r14, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x8210
leaq (%rax,%r15), %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xb728
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xad5e
movq %rbx, %rdi
callq 0x2754c
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x26ff5
callq 0x84a0
movq %rbx, %rax
addq $0x1028, %rsp # imm = 0x1028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x27018
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-filepath.cc
|
testing::internal::FilePath::RemoveFileName() const
|
FilePath FilePath::RemoveFileName() const {
const char* const last_sep = FindLastPathSeparator();
std::string dir;
if (last_sep) {
dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str()));
} else {
dir = kCurrentDirectoryString;
}
return FilePath(dir);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %rdi
movl $0x2f, %esi
callq 0x85a0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
testq %rax, %rax
je 0x27216
incq %rax
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb728
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x86c0
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x27231
callq 0x84a0
jmp 0x27231
leaq 0x14a00(%rip), %rcx # 0x3bc1d
leaq 0x8(%rsp), %rdi
movl $0x2, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x8900
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xad5e
movq %rbx, %rdi
callq 0x2754c
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x27264
callq 0x84a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x27275
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x27287
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-filepath.cc
|
testing::internal::FilePath::RemoveTrailingPathSeparator() const
|
FilePath FilePath::RemoveTrailingPathSeparator() const {
return IsDirectory()
? FilePath(pathname_.substr(0, pathname_.length() - 1))
: *this;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x272b2
movq (%rsi), %rax
cmpb $0x2f, -0x1(%rax,%rcx)
sete %bpl
jmp 0x272b4
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x272ec
decq %rcx
movq %rsp, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x8540
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xad5e
movq %rbx, %rdi
callq 0x2754c
jmp 0x27304
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsi), %rsi
addq %rsi, %rcx
movq %rbx, %rdi
movq %rcx, %rdx
callq 0xad5e
testb %bpl, %bpl
je 0x2731c
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2731c
callq 0x84a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
testb %bpl, %bpl
je 0x27343
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27343
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-filepath.cc
|
testing::internal::FilePath::FileOrDirectoryExists() const
|
bool FilePath::FileOrDirectoryExists() const {
#if GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
const DWORD attributes = GetFileAttributes(unicode);
delete [] unicode;
return attributes != kInvalidFileAttributes;
#else
posix::StatStruct file_stat{};
return posix::Stat(pathname_.c_str(), &file_stat) == 0;
#endif // GTEST_OS_WINDOWS_MOBILE
}
|
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x82c0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x8470
testl %eax, %eax
sete %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-filepath.cc
|
testing::internal::FilePath::DirectoryExists() const
|
bool FilePath::DirectoryExists() const {
bool result = false;
#if GTEST_OS_WINDOWS
// Don't strip off trailing separator if path is a root directory on
// Windows (like "C:\\").
const FilePath& path(IsRootDirectory() ? *this :
RemoveTrailingPathSeparator());
#else
const FilePath& path(*this);
#endif
#if GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
const DWORD attributes = GetFileAttributes(unicode);
delete [] unicode;
if ((attributes != kInvalidFileAttributes) &&
(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
result = true;
}
#else
posix::StatStruct file_stat{};
result = posix::Stat(path.c_str(), &file_stat) == 0 &&
posix::IsDir(file_stat);
#endif // GTEST_OS_WINDOWS_MOBILE
return result;
}
|
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x82c0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x8470
movl 0x18(%r14), %ecx
andl $0xf000, %ecx # imm = 0xF000
xorl $0x4000, %ecx # imm = 0x4000
orl %eax, %ecx
sete %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-filepath.cc
|
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(char const*)
|
Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); }
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x2cc57(%rip), %r14 # 0x54618
movq %r14, (%rdi)
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x81f0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xad5e
leaq 0x2cea6(%rip), %rax # 0x548a0
movq %rax, 0x28(%rsp)
leaq 0x2d052(%rip), %rax # 0x54a58
movq %rax, 0x30(%rsp)
movl $0x28, %edi
callq 0x84e0
movl $0x1, (%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdx
cmpq %r15, %rdx
je 0x27a3f
movq %rdx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x27a46
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r15, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
movq %rax, 0x10(%rsi)
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x30fae
leaq 0x28(%rsp), %rdi
callq 0x31434
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x27a8f
callq 0x84a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27aa2
callq 0x84a0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x31434
jmp 0x27abe
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x27ad2
callq 0x84a0
jmp 0x27ad2
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27aea
callq 0x84a0
jmp 0x27aea
movq %rax, %r14
movq %rbx, %rdi
callq 0x31434
movq %r14, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-matchers.cc
|
testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int)
|
GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
: severity_(severity) {
const char* const marker =
severity == GTEST_INFO ? "[ INFO ]" :
severity == GTEST_WARNING ? "[WARNING]" :
severity == GTEST_ERROR ? "[ ERROR ]" : "[ FATAL ]";
GetStream() << ::std::endl << marker << " "
<< FormatFileLocation(file, line).c_str() << ": ";
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, (%rdi)
cmpl $0x2, %esi
leaq 0x166f5(%rip), %rax # 0x3e4b0
leaq 0x166f8(%rip), %rcx # 0x3e4ba
cmoveq %rax, %rcx
cmpl $0x1, %esi
leaq 0x166d6(%rip), %rax # 0x3e4a6
cmovneq %rcx, %rax
testl %esi, %esi
leaq 0x166bf(%rip), %r15 # 0x3e49c
cmovneq %rax, %r15
movq 0x2d1f8(%rip), %rbx # 0x54fe0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x84c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8050
movq %rax, %rdi
callq 0x8340
movq %rax, %rbx
movl $0x9, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x85f0
leaq 0x151dd(%rip), %rsi # 0x3d006
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x13ef9
movq (%r15), %r14
testq %r14, %r14
je 0x27e68
movq %r14, %rdi
callq 0x8210
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85f0
jmp 0x27e81
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x89b0
leaq 0x15cfb(%rip), %rsi # 0x3db83
movl $0x2, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27ea8
callq 0x84a0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27ec9
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
nop
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-port.cc
|
testing::internal::GTestLog::~GTestLog()
|
GTestLog::~GTestLog() {
GetStream() << ::std::endl;
if (severity_ == GTEST_FATAL) {
fflush(stderr);
posix::Abort();
}
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x2d103(%rip), %rdi # 0x54fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x84c0
movsbl %al, %esi
movq 0x2d0e8(%rip), %rdi # 0x54fe0
callq 0x8050
movq %rax, %rdi
callq 0x8340
cmpl $0x3, (%rbx)
je 0x27f0c
popq %rbx
retq
movq 0x2d0ad(%rip), %rax # 0x54fc0
movq (%rax), %rdi
callq 0x8640
callq 0x2c09b
movq %rax, %rdi
callq 0x2acfd
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-port.cc
|
testing::internal::PrintTo(char const*, std::ostream*)
|
void PrintTo(const char* s, ostream* os) { PrintCStringTo(s, os); }
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x285cc
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x83e0
leaq 0x16e87(%rip), %rsi # 0x3f429
movl $0xd, %edx
movq %rax, %rdi
callq 0x85f0
movq %r14, %rdi
callq 0x8210
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2896a
leaq 0x12bbe(%rip), %rsi # 0x3b191
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x85f0
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/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 0x286a9
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x83e0
leaq 0x16db2(%rip), %rsi # 0x3f429
movl $0xd, %edx
movq %rax, %rdi
callq 0x85f0
movq $-0x1, %rsi
cmpl $0x0, 0x4(%r14,%rsi,4)
leaq 0x1(%rsi), %rsi
jne 0x2868b
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28b3f
leaq 0x12ae1(%rip), %rsi # 0x3b191
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x85f0
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-printers.cc
|
testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<char>(char const*, unsigned long, std::ostream*)
|
static CharFormat PrintCharsAsStringTo(
const CharType* begin, size_t len, ostream* os) {
const char* const quote_prefix = GetCharWidthPrefix(*begin);
*os << quote_prefix << "\"";
bool is_previous_hex = false;
CharFormat print_format = kAsIs;
for (size_t index = 0; index < len; ++index) {
const CharType cur = begin[index];
if (is_previous_hex && IsXDigit(cur)) {
// Previous character is of '\x..' form and this character can be
// interpreted as another hexadecimal digit in its number. Break string to
// disambiguate.
*os << "\" " << quote_prefix << "\"";
}
is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
// Remember if any characters required hex escaping.
if (is_previous_hex) {
print_format = kHexEscape;
}
}
*os << "\"";
return print_format;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x14e5e(%rip), %rsi # 0x3d7e3
xorl %r12d, %r12d
movq %rdx, %rdi
xorl %edx, %edx
callq 0x85f0
leaq 0x15238(%rip), %rsi # 0x3dbd1
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85f0
testq %r14, %r14
je 0x28a1d
xorl %ecx, %ecx
xorl %r13d, %r13d
xorl %r12d, %r12d
movzbl (%r15,%r13), %ebp
testb $0x1, %cl
je 0x28a01
movl %ebp, %edi
callq 0x8100
testl %eax, %eax
je 0x28a01
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x16a60(%rip), %rsi # 0x3f437
callq 0x85f0
movq %rbx, %rdi
leaq 0x14dfd(%rip), %rsi # 0x3d7e3
xorl %edx, %edx
callq 0x85f0
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x151d5(%rip), %rsi # 0x3dbd1
callq 0x85f0
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2aa0b
cmpl $0x1, %eax
sete %cl
cmovel %eax, %r12d
incq %r13
cmpq %r13, %r14
jne 0x289b3
leaq 0x151ad(%rip), %rsi # 0x3dbd1
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85f0
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-printers.cc
|
testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<char16_t>(char16_t const*, unsigned long, std::ostream*)
|
static CharFormat PrintCharsAsStringTo(
const CharType* begin, size_t len, ostream* os) {
const char* const quote_prefix = GetCharWidthPrefix(*begin);
*os << quote_prefix << "\"";
bool is_previous_hex = false;
CharFormat print_format = kAsIs;
for (size_t index = 0; index < len; ++index) {
const CharType cur = begin[index];
if (is_previous_hex && IsXDigit(cur)) {
// Previous character is of '\x..' form and this character can be
// interpreted as another hexadecimal digit in its number. Break string to
// disambiguate.
*os << "\" " << quote_prefix << "\"";
}
is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
// Remember if any characters required hex escaping.
if (is_previous_hex) {
print_format = kHexEscape;
}
}
*os << "\"";
return print_format;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x169d0(%rip), %rsi # 0x3f43d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x15150(%rip), %rsi # 0x3dbd1
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85f0
testq %r14, %r14
je 0x28b0e
xorl %eax, %eax
leaq 0x15135(%rip), %rbp # 0x3dbd1
xorl %r13d, %r13d
movzwl (%r15,%r13,2), %r12d
testb $0x1, %al
je 0x28af5
cmpl $0xff, %r12d
ja 0x28af5
movl %r12d, %edi
callq 0x8100
testl %eax, %eax
je 0x28af5
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x1696b(%rip), %rsi # 0x3f437
callq 0x85f0
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x1695d(%rip), %rsi # 0x3f43d
callq 0x85f0
movl $0x1, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x85f0
movl %r12d, %edi
movq %rbx, %rsi
callq 0x2aa0b
cmpl $0x1, %eax
sete %al
incq %r13
cmpq %r13, %r14
jne 0x28a9f
leaq 0x150bc(%rip), %rsi # 0x3dbd1
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x85f0
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-printers.cc
|
testing::AssertionResult& testing::AssertionResult::operator<<<char const*>(char const* const&)
|
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0xf68a
movq (%r14), %r15
movq (%r12), %r14
addq $0x10, %r14
testq %r15, %r15
je 0x2b19c
movq %r15, %rdi
callq 0x8210
movq %rax, %rdx
jmp 0x2b1a8
movl $0x6, %edx
leaq 0x12031(%rip), %r15 # 0x3d1d9
movq %r14, %rdi
movq %r15, %rsi
callq 0x85f0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2ec22
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2b1cd
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2b1ee
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult& testing::AssertionResult::operator<<<char [6]>(char const (&) [6])
|
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf68a
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8210
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ec22
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b24c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b26c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult& testing::AssertionResult::operator<<<double>(double const&)
|
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf68a
movq (%r15), %rdi
addq $0x10, %rdi
movsd (%r14), %xmm0
callq 0x8960
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ec22
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b33c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b35c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult& testing::AssertionResult::operator<<<char [9]>(char const (&) [9])
|
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf68a
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8210
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ec22
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b3ba
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b3da
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult& testing::AssertionResult::operator<<<char [15]>(char const (&) [15])
|
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf68a
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8210
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ec22
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b438
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b458
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h
|
testing::AssertionResult& testing::AssertionResult::operator<<<char [100]>(char const (&) [100])
|
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf68a
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8210
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ec22
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b5b2
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b5d2
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h
|
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.