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... | 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... | /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__... | 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];... | 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++)
{
... | 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... | /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];... | 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 (to... | 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), ... | /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__... | 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)
{
... | 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(... | /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__... | 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;
flo... | 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)... | /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];... | 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 ==... | 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... | /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__... | 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];... | 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];... | 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];... | 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__... | 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];... | 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... | 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(%... | /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)
{
... | 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... | /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)
{
... | 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... | /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... | 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... | /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... | /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... | /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];... | 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__... | 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__... | 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... | 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... | /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];... | 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 _... | 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 0x1... | /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__... | 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;
c... | 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 ... | /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... | 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 %e... | /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
ca... | /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__... | 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];... | 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
ca... | /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++)
... | 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(... | /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];... | 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 = bo... | 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(%... | /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];... | 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;
... | 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 0x1... | /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_p... | 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... | /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__... | 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];... | 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__... | 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__... | 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_(cw... | 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, %rs... | /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
l... | /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... | /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... | /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);
... | 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 0x306d... | /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 ... | 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... | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %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 ... | /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) pad... | 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 $0... | /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 ? ... | 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
... | /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) {... | 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(%r... | /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 %... | /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 nev... | 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... | /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,
... | 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)... | /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+... | 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
mov... | /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_repor... | 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 0x2a... | /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 %... | /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) {
... | 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, ... | /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... | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
const std::vector<std::string>& right,
size_t context) {
const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
size_t l_i = 0, r_i = 0, edit_i = 0;
std::stringstream s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rcx, 0x8(%rsp)
movq %rdi, 0xa0(%rsp)
leaq 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,... | /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 = sizeo... | 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
c... | /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
... | 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 0x84... | /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)... | /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, %... | /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 %... | /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... | /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... | 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... | /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 %rb... | /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 ... | 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),... | /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)... | /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 ... | 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... | /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 exit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %rbx
leaq 0x7(%rsp), %r14
movl 0x34(%rbx), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x8820
movq %rax, %r15
cmpl $-0x1, %r15d
jne 0x2128d
callq 0x8070
cmpl $0x4, (%rax)
je 0x21259
leaq 0x34(%rbx), %r... | /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"
... | 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), %... | /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("");
CaptureS... | 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... | /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(kCurrentDire... | 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(%r... | /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(%... | /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
... | /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(pa... | 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
co... | 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
a... | /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),... | /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 << ... | 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 0... | /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
mov... | /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 ... | /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... | /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 CharTy... | 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 %r1... | /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 CharTy... | 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... | /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 # 0x3... | /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(%rs... | /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
ca... | /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(%rs... | /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(%rs... | /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(%rs... | /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.