name string | code string | asm string | file string |
|---|---|---|---|
testing::internal::FloatingPoint<float>::AlmostEquals(testing::internal::FloatingPoint<float> const&) const | Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } | movl (%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx # imm = 0x7F800000
sete %cl
testl $0x7fffff, %eax # imm = 0x7FFFFF
setne %dl
testb %dl, %cl
jne 0x566c5
movl (%rsi), %ecx
movl %ecx, %edx
notl %edx
testl $0x7f800000, %edx # imm = 0x7F800000
sete %dl
testl $0x7fffff, %ecx # ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::CreateKey() | static pthread_key_t CreateKey() {
pthread_key_t key;
// When a thread exits, DeleteThreadLocalValue() will be called on
// the object managed for that thread.
GTEST_CHECK_POSIX_SUCCESS_(
pthread_key_create(&key, &DeleteThreadLocalValue));
return key;
} | pushq %rbx
subq $0x10, %rsp
leaq -0x2558e(%rip), %rsi # 0x326c0
leaq 0xc(%rsp), %rdi
callq 0xaa30
testl %eax, %eax
je 0x57cc1
movl %eax, %ebx
leaq 0x839a(%rip), %rdx # 0x5ffff
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x6f8, %ecx # imm = 0x6F8
callq 0x4d76a
movq 0x29368(%rip), %rdi # 0x80fe8
lea... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::ComparisonBase<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, testing::internal::AnyEq>::Impl<std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | bool MatchAndExplain(Lhs lhs,
MatchResultListener* /* listener */) const override {
return Op()(lhs, Unwrap(rhs_));
} | pushq %rbx
movq %rdi, %rbx
leaq 0x28c53(%rip), %rax # 0x80d08
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x580ca
callq 0xa570
movq %rbx, %rdi
popq %rbx
jmp 0xa570
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-matchers.h |
virtual thunk to ncnn::BatchNorm_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BatchNorm_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int dims = bottom_top_blob.dims;
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int d = bottom_top_blob.d;
int c = bottom_top_blob.c;
int elempack = bottom_top_blob.elempack;
if (dims == 1)
{
... | pushq %rax
movq (%rdi), %rax
addq -0x58(%rax), %rdi
callq 0x90ec0
xorl %eax, %eax
popq %rcx
retq
nop
| /ysh329[P]ncnn/build_O3/src/layer/x86/batchnorm_x86_avx.cpp |
ncnn::conv3x3s1_winograd43_transform_kernel_pack8to1_int8_sse(ncnn::Mat const&, ncnn::Mat&, int, int, ncnn::Option const&) | static void conv3x3s1_winograd43_transform_kernel_pack8to1_int8_sse(const Mat& kernel, Mat& kernel_tm_pack8to1, int inch, int outch, const Option& opt)
{
#if !(__AVX512VNNI__ || __AVXVNNI__ || __AVX2__ || __XOP__)
#if NCNN_RUNTIME_CPU && NCNN_AVX512VNNI && __AVX512F__ && !__AVX512VNNI__
if (ncnn::cpu_support_x86_av... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %ecx, %r14d
movl %edx, %ebx
movq %rsi, 0x30(%rsp)
movq %rdi, %r12
leaq 0x80(%rsp), %rdi
movq $0x0, 0x40(%rdi)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, (%rdi)
vmovdqu %xmm0, 0xc(%rdi)
vmovdqa %xmm0, 0x20(%rdi)
vmovdqu %xmm0, 0x2c(%rd... | /ysh329[P]ncnn/src/layer/x86/convolution_3x3_pack8to1_int8.h |
ncnn::conv1x1s2_sgemm_pack8to4_int8_sse(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void conv1x1s2_sgemm_pack8to4_int8_sse(const Mat& bottom_blob, Mat& top_blob, const Mat& kernel, const Option& opt)
{
int w = bottom_blob.w;
int channels = bottom_blob.c;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elempack;
int outw = top_blob.w;
int outh = top_bl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movl 0x2c(%rdi), %ebx
movl 0x38(%rdi), %r13d
movq 0x10(%rdi), %r8
movl 0x18(%rdi), %r9d
movl 0x2c(%rsi), %ebp
movl 0x30(%rsi), %r14d
leaq 0x20(%rsp), %rdi
movq $0x0, 0x40(%rdi)
vxorps... | /ysh329[P]ncnn/src/layer/x86/convolution_1x1_pack8to4_int8.h |
ncnn::conv1x1s2_sgemm_pack1to4_int8_sse(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void conv1x1s2_sgemm_pack1to4_int8_sse(const Mat& bottom_blob, Mat& top_blob, const Mat& kernel, const Option& opt)
{
int w = bottom_blob.w;
int channels = bottom_blob.c;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elempack;
int outw = top_blob.w;
int outh = top_bl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movl 0x2c(%rdi), %ebx
movl 0x38(%rdi), %r13d
movq 0x10(%rdi), %r8
movl 0x18(%rdi), %r9d
movl 0x2c(%rsi), %ebp
movl 0x30(%rsi), %r14d
leaq 0x20(%rsp), %rdi
movq $0x0, 0x40(%rdi)
vxorps... | /ysh329[P]ncnn/src/layer/x86/convolution_1x1_pack1to4_int8.h |
ncnn::conv3x3s1_pack1to4_int8_sse(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void conv3x3s1_pack1to4_int8_sse(const Mat& bottom_blob, Mat& top_blob, const Mat& kernel, const Option& opt)
{
int w = bottom_blob.w;
int inch = bottom_blob.c;
int outw = top_blob.w;
int outh = top_blob.h;
const int size = outw * outh;
const int maxk = 9;
// im2col
Mat bottom_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x18(%rsp)
movslq 0x2c(%rdi), %rbp
movq %rdi, 0x28(%rsp)
movslq 0x38(%rdi), %r14
movslq 0x2c(%rsi), %rbx
movq %rsi, 0x10(%rsp)
movl 0x30(%rsi), %r15d
movl %r15d, %esi
imull %ebx, %esi
movq %rcx, 0x8(%rsp)
movq 0x10(%rcx), %rax... | /ysh329[P]ncnn/src/layer/x86/convolution_3x3_pack1to4_int8.h |
ncnn::conv7x7s2_pack1to4_int8_sse(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void conv7x7s2_pack1to4_int8_sse(const Mat& bottom_blob, Mat& top_blob, const Mat& kernel, const Option& opt)
{
int w = bottom_blob.w;
int inch = bottom_blob.c;
int outw = top_blob.w;
int outh = top_blob.h;
const int size = outw * outh;
const int maxk = 49;
// im2col
Mat bottom... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x18(%rsp)
movslq 0x2c(%rdi), %rbp
movq %rdi, 0x28(%rsp)
movslq 0x38(%rdi), %r14
movslq 0x2c(%rsi), %rbx
movq %rsi, 0x10(%rsp)
movl 0x30(%rsi), %r15d
movl %r15d, %esi
imull %ebx, %esi
movq %rcx, 0x8(%rsp)
movq 0x10(%rcx), %rax... | /ysh329[P]ncnn/src/layer/x86/convolution_7x7_pack1to4_int8.h |
ncnn::im2col_sgemm_pack4to8_avx(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, ncnn::Option const&) | static void im2col_sgemm_pack4to8_avx(const Mat& bottom_im2col, Mat& top_blob, const Mat& kernel, const Mat& _bias, const Option& opt)
{
// Mat bottom_im2col(size, maxk, inch, 16u, 4, opt.workspace_allocator);
const int size = bottom_im2col.w;
const int maxk = bottom_im2col.h;
const int inch = bottom_i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x58(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movslq 0x2c(%rdi), %rbp
movl 0x30(%rdi), %ebx
movl 0x38(%rdi), %r12d
leal (,%rbx,8), %esi
movl %ebp, %eax
shrl $0x3, %eax
movl %ebp, %ecx
andl $0x7, %ecx
addl %eax, %e... | /ysh329[P]ncnn/src/layer/x86/convolution_sgemm_pack4to8.h |
ncnn::im2col_sgemm_pack8to1_avx(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, ncnn::Option const&) | static void im2col_sgemm_pack8to1_avx(const Mat& bottom_im2col, Mat& top_blob, const Mat& kernel, const Mat& _bias, const Option& opt)
{
// Mat bottom_im2col(size, maxk, inch, 4u * 8, 8, opt.workspace_allocator);
const int size = bottom_im2col.w;
const int maxk = bottom_im2col.h;
const int inch = botto... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %r14
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r13
movslq 0x2c(%rdi), %r12
movl 0x30(%rdi), %ebp
movl 0x38(%rdi), %ebx
leal (,%rbp,8), %esi
movl %r12d, %eax
shrl $0x3, %eax
movl %r12d, %ecx
andl $0x7, %ecx
addl %eax, %... | /ysh329[P]ncnn/src/layer/x86/convolution_sgemm_pack8to1.h |
ncnn::im2col_sgemm_pack8to4_avx(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, ncnn::Option const&) | static void im2col_sgemm_pack8to4_avx(const Mat& bottom_im2col, Mat& top_blob, const Mat& kernel, const Mat& _bias, const Option& opt)
{
// Mat bottom_im2col(size, maxk, inch, 32u, 8, opt.workspace_allocator);
const int size = bottom_im2col.w;
const int maxk = bottom_im2col.h;
const int inch = bottom_i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x70(%rsp)
movq %rdx, %r14
movq %rdi, %r13
movslq 0x2c(%rdi), %rbp
movl %ebp, %r15d
movl 0x30(%rdi), %ebx
movl 0x38(%rdi), %r12d
movq %rsi, 0x68(%rsp)
movslq 0x38(%rsi), %rax
movq %rax, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
vxorpd ... | /ysh329[P]ncnn/src/layer/x86/convolution_sgemm_pack8to4.h |
ncnn::conv3x3s1_winograd43_pack8_avx(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, ncnn::Option const&) | static void conv3x3s1_winograd43_pack8_avx(const Mat& bottom_blob, Mat& top_blob, const Mat& kernel_tm, const Mat& bias, const Option& opt)
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int inch = bottom_blob.c;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elempack;
int ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x6c0, %rsp # imm = 0x6C0
movq %r8, %r14
movq %rcx, 0x138(%rsp)
movq %rdx, 0x148(%rsp)
movq %rsi, %rbx
movl 0x38(%rdi), %r15d
movq 0x10(%rdi), %r12
movl 0x18(%rdi), %r13d
vmovq 0x2c(%rsi), %xmm0
movl 0x3... | /ysh329[P]ncnn/src/layer/x86/convolution_3x3_pack8.h |
ncnn::conv1x1s2_sgemm_pack8to4_avx(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, ncnn::Option const&) | static void conv1x1s2_sgemm_pack8to4_avx(const Mat& bottom_blob, Mat& top_blob, const Mat& kernel, const Mat& _bias, const Option& opt)
{
int w = bottom_blob.w;
int channels = bottom_blob.c;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elempack;
int outw = top_blob.w;
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rax
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %r13
movl 0x2c(%rdi), %ebx
movl 0x38(%rdi), %ebp
movq 0x10(%rdi), %r8
movl 0x18(%rdi), %r9d
movl 0x2c(%rsi), %r14d
movl 0x30(%rsi), %r15d
leaq 0x20(%rsp... | /ysh329[P]ncnn/src/layer/x86/convolution_1x1_pack8to4.h |
virtual thunk to ncnn::Crop_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Crop_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_blob.c;
int dims = bottom_blob.dims;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elempack;... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0x18258c
| /ysh329[P]ncnn/src/layer/x86/crop_x86.cpp |
ncnn::Crop_x86_avx512::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Crop_x86_avx512::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_blob.c;
int dims = bottom_blob.dims;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.el... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, 0x78(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, 0x140(%rsp)
movl 0x2c(%rsi), %r14d
movslq %r14d, %rax
movl 0x30(%rsi), %r15d
movslq %r15d, %rcx
movl 0x34(%rsi), %edx
movl %edx, 0xf4(%rsp)
m... | /ysh329[P]ncnn/build_O3/src/layer/x86/crop_x86_avx512.cpp |
ncnn::crop_pack16_avx512(ncnn::Mat const&, ncnn::Mat&, int, int) | static void crop_pack16_avx512(const Mat& src, Mat& dst, int top, int left)
{
int w = dst.w;
int h = dst.h;
int right = src.w - dst.w - left;
const float* ptr = src.row(top) + left * 16;
float* outptr = dst;
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
... | movl 0x30(%rsi), %eax
testl %eax, %eax
jle 0x1888fd
movl 0x2c(%rsi), %r8d
movslq %r8d, %r10
movq (%rsi), %rsi
movslq 0x2c(%rdi), %r9
movslq %edx, %rdx
imulq %r9, %rdx
imulq 0x10(%rdi), %rdx
addq (%rdi), %rdx
shll $0x4, %ecx
movslq %ecx, %rcx
leaq (%rdx,%rcx,4), %rcx
subq %r10, %r9
shlq $0x4, %r9
xorl %edx, %edx
movl %r... | /ysh329[P]ncnn/build_O3/src/layer/x86/crop_x86_avx512.cpp |
ncnn::crop_pack8_avx(ncnn::Mat const&, ncnn::Mat&, int, int) | static void crop_pack8_avx(const Mat& src, Mat& dst, int top, int left)
{
int w = dst.w;
int h = dst.h;
int right = src.w - dst.w - left;
const float* ptr = src.row(top) + left * 8;
float* outptr = dst;
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
... | movl 0x30(%rsi), %eax
testl %eax, %eax
jle 0x18895e
movl 0x2c(%rsi), %r8d
movslq %r8d, %r10
movq (%rsi), %rsi
movslq 0x2c(%rdi), %r9
movslq %edx, %rdx
imulq %r9, %rdx
imulq 0x10(%rdi), %rdx
addq (%rdi), %rdx
shll $0x3, %ecx
movslq %ecx, %rcx
leaq (%rdx,%rcx,4), %rcx
subq %r10, %r9
shlq $0x3, %r9
xorl %edx, %edx
movl %r... | /ysh329[P]ncnn/build_O3/src/layer/x86/crop_x86_avx512.cpp |
ncnn::Crop_x86_avx512::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Crop_x86_avx512::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& reference_blob = bottom_blobs[1];
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rcx, 0xd8(%rsp)
movq %rdi, %rbp
movq (%rsi), %r12
leaq 0x48(%r12), %rax
movq %rax, 0x158(%rsp)
movl 0x2c(%r12), %eax
movl %eax, 0x60(%rsp)
cltq
movl 0x30(%r12), %ecx
movl %ecx, 0xbc(%rsp)
movslq %ecx, %rcx... | /ysh329[P]ncnn/build_O3/src/layer/x86/crop_x86_avx512.cpp |
ncnn::Crop_x86_fma::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Crop_x86_fma::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_blob.c;
int dims = bottom_blob.dims;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elemp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, 0x78(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, 0x140(%rsp)
movl 0x2c(%rsi), %r15d
movslq %r15d, %rax
movl 0x30(%rsi), %r14d
movslq %r14d, %rcx
movl 0x34(%rsi), %edx
movl %edx, 0xf4(%rsp)
m... | /ysh329[P]ncnn/build_O3/src/layer/x86/crop_x86_fma.cpp |
ncnn::crop_pack4_sse(ncnn::Mat const&, ncnn::Mat&, int, int) | static void crop_pack4_sse(const Mat& src, Mat& dst, int top, int left)
{
int w = dst.w;
int h = dst.h;
int right = src.w - dst.w - left;
const float* ptr = src.row(top) + left * 4;
float* outptr = dst;
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
... | movl 0x30(%rsi), %eax
testl %eax, %eax
jle 0x18f527
movl 0x2c(%rsi), %r8d
movslq %r8d, %r10
movq (%rsi), %rsi
movslq 0x2c(%rdi), %r9
movslq %edx, %rdx
imulq %r9, %rdx
imulq 0x10(%rdi), %rdx
addq (%rdi), %rdx
shll $0x2, %ecx
movslq %ecx, %rcx
leaq (%rdx,%rcx,4), %rcx
subq %r10, %r9
shlq $0x2, %r9
xorl %edx, %edx
movl %r... | /ysh329[P]ncnn/build_O3/src/layer/x86/crop_x86_fma.cpp |
virtual thunk to ncnn::Crop_x86_fma::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Crop_x86_fma::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_blob.c;
int dims = bottom_blob.dims;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elemp... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0x18d160
| /ysh329[P]ncnn/build_O3/src/layer/x86/crop_x86_fma.cpp |
virtual thunk to ncnn::Crop_x86_fma::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Crop_x86_fma::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& reference_blob = bottom_blobs[1];
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bott... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x18f534
| /ysh329[P]ncnn/build_O3/src/layer/x86/crop_x86_fma.cpp |
ncnn::crop_pack8_avx(ncnn::Mat const&, ncnn::Mat&, int, int) | static void crop_pack8_avx(const Mat& src, Mat& dst, int top, int left)
{
int w = dst.w;
int h = dst.h;
int right = src.w - dst.w - left;
const float* ptr = src.row(top) + left * 8;
float* outptr = dst;
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
... | movl 0x30(%rsi), %eax
testl %eax, %eax
jle 0x194a1e
movl 0x2c(%rsi), %r8d
movslq %r8d, %r10
movq (%rsi), %rsi
movslq 0x2c(%rdi), %r9
movslq %edx, %rdx
imulq %r9, %rdx
imulq 0x10(%rdi), %rdx
addq (%rdi), %rdx
shll $0x3, %ecx
movslq %ecx, %rcx
leaq (%rdx,%rcx,4), %rcx
subq %r10, %r9
shlq $0x3, %r9
xorl %edx, %edx
movl %r... | /ysh329[P]ncnn/build_O3/src/layer/x86/crop_x86_avx.cpp |
virtual thunk to ncnn::Crop_x86_avx::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Crop_x86_avx::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& reference_blob = bottom_blobs[1];
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bott... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x194a8c
| /ysh329[P]ncnn/build_O3/src/layer/x86/crop_x86_avx.cpp |
ncnn::Deconvolution_x86_avx512::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Deconvolution_x86_avx512::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// deconvolv with NxN kernel
// value = value + bias
int w = bottom_blob.w;
int h = bottom_blob.h;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elempack;
// NCN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, %rbp
movl 0x2c(%rsi), %ebx
movl 0x30(%rsi), %r14d
movq 0x10(%rsi), %rax
movq (%rdi), %r8
movq -0x18(%r8), %rdx
movl 0xd4(%rdi,%rdx), %r9d
decl %r9d
imull 0xdc(%rdi,%rdx), %r9d
movl %r9d, 0x12c(%rsp)
m... | /ysh329[P]ncnn/build_O3/src/layer/x86/deconvolution_x86_avx512.cpp |
virtual thunk to ncnn::Deconvolution_x86_fma::create_pipeline(ncnn::Option const&) | int Deconvolution_x86_fma::create_pipeline(const Option& opt)
{
const int maxk = kernel_w * kernel_h;
int num_input = weight_data_size / maxk / num_output;
Mat weight_data_transposed(weight_data.w);
{
float* pt = weight_data_transposed;
const float* p = weight_data;
for (int i ... | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0x1a2fd4
xorl %eax, %eax
popq %rcx
retq
nop
| /ysh329[P]ncnn/build_O3/src/layer/x86/deconvolution_x86_fma.cpp |
ncnn::Dropout_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Dropout_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
if (scale == 1.f)
{
return 0;
}
#if __SSE2__
int dims = bottom_top_blob.dims;
int elempack = bottom_top_blob.elempack;
#if __AVX__
#if __AVX512F__
if (elempack == 16)
{
Mat tmp;
co... | movq (%rdi), %rax
movq -0x18(%rax), %rax
vmovss 0xd0(%rdi,%rax), %xmm0
vmovss 0x2684e4(%rip), %xmm1 # 0x414d18
vucomiss %xmm0, %xmm1
jne 0x1ac840
xorl %eax, %eax
vzeroupper
retq
movl 0x18(%rsi), %ecx
movl 0x28(%rsi), %r8d
cmpl $0x4, %ecx
je 0x1ac89e
cmpl $0x8, %ecx
jne 0x1ac8ec
movl 0x2c(%rsi), %ecx
movl 0x30(%rsi), ... | /ysh329[P]ncnn/build_O3/src/layer/x86/dropout_x86_avx.cpp |
ncnn::ELU_x86::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int ELU_x86::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 elempack = bottom_top_blob.elempack;
int size = w * h * elempack;
#pragma omp parallel for num_threads(opt.num_threads)
f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, 0x18(%rsp)
movslq 0x38(%rsi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
jle 0x1afb2d
movq 0x18(%rsp), %rax
movl 0x30(%rax), %ebp
imull 0x2c(%rax), %ebp
imull 0x18(%rax), %ebp
movq 0x8(%rsp), %rax
movq (%... | /ysh329[P]ncnn/src/layer/x86/elu_x86.cpp |
ncnn::Flatten_x86_avx::forward_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Flatten_x86_avx::forward_int8(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int dims = bottom_blob.dims;
if (dims == 1)
{
top_blob = bottom_blob;
return 0;
}
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bott... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r9
movq %rsi, %r14
movl 0x28(%rsi), %r12d
cmpl $0x1, %r12d
jne 0x1b685b
xorl %ebp, %ebp
cmpq %r14, %r9
je 0x1b6d48
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x1b6827
lock
incl (%rax)
movq 0x8(%r9), %rax
testq %rax, %rax
je 0x1... | /ysh329[P]ncnn/build_O3/src/layer/x86/flatten_x86_avx.cpp |
ncnn::InnerProduct::forward_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int InnerProduct::forward_int8(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
const int num_input = weight_data_size / num_output;
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;
Mat bo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movl 0xd8(%rdi), %eax
cltd
idivl 0xd0(%rdi)
movl 0x38(%rsi), %r15d
movq 0x10(%rsi), %rsi
movq (%r13), %rcx
movq %rcx, 0x68(%rsp)
movq 0x8(%r13), %r... | /ysh329[P]ncnn/src/layer/innerproduct.cpp |
ncnn::InnerProduct_x86::create_pipeline_int8_x86(ncnn::Option const&) | int InnerProduct_x86::create_pipeline_int8_x86(const Option& opt)
{
const int num_input = weight_data_size / num_output;
int out_elempack = 1;
#if __SSE2__
if (opt.use_packing_layout)
{
out_elempack = num_output % 8 == 0 ? 8 : 1;
}
#endif // __SSE2__
// src = inch-outch
// dst = pb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rax
leaq 0x130(%rdi,%rax), %rsi
movl -0x60(%rsi), %ecx
movl -0x58(%rsi), %eax
cltd
idivl %ecx
movl %eax, %ebp
testb $0x7, %cl
sete %r12b
andb 0x27(%rbx), %r12b
movl $0x8, %eax
mov... | /ysh329[P]ncnn/src/layer/x86/innerproduct_x86.cpp |
ncnn::InnerProduct_x86::forward_fp16s(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int InnerProduct_x86::forward_fp16s(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
const int num_input = weight_data_size / num_output;
if (bottom_blob.dims == 2 && bottom_blob.w == num_input && bottom_blob.h * bottom_blob.elempack > 1)
{
// gemm
int h = bottom_blob.h;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
movl 0x28(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x1c0497
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0xd0(%r15,%rax), %r10d
movl 0xd8(%r15,%rax), %eax
cltd
idivl %r10d
movl 0x2c(%rsi), %edi
cmpl %eax, %edi
jne 0x1c049a
movl 0x... | /ysh329[P]ncnn/src/layer/x86/innerproduct_x86.cpp |
ncnn::InnerProduct_x86_avx512::create_pipeline_int8_x86(ncnn::Option const&) | int InnerProduct_x86_avx512::create_pipeline_int8_x86(const Option& opt)
{
const int num_input = weight_data_size / num_output;
int out_elempack = 1;
#if __SSE2__
if (opt.use_packing_layout)
{
out_elempack = num_output % 8 == 0 ? 8 : 1;
}
#endif // __SSE2__
// src = inch-outch
// d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rax
leaq 0x130(%rdi,%rax), %rsi
movl -0x60(%rsi), %ecx
movl -0x58(%rsi), %eax
cltd
idivl %ecx
movl %eax, %ebp
testb $0x7, %cl
sete %r12b
andb 0x27(%rbx), %r12b
movl $0x8, %eax
mov... | /ysh329[P]ncnn/build_O3/src/layer/x86/innerproduct_x86_avx512.cpp |
ncnn::InnerProduct_x86_avx512::forward_fp16s(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int InnerProduct_x86_avx512::forward_fp16s(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
const int num_input = weight_data_size / num_output;
if (bottom_blob.dims == 2 && bottom_blob.w == num_input && bottom_blob.h * bottom_blob.elempack > 1)
{
// gemm
int h = bottom_blo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3e8, %rsp # imm = 0x3E8
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbp
movl 0x28(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x1dfe10
movq (%rbp), %rax
movq -0x18(%rax), %rax
movl 0xd0(%rbp,%rax), %esi
movl 0xd8(%rbp,%rax), %eax
c... | /ysh329[P]ncnn/build_O3/src/layer/x86/innerproduct_x86_avx512.cpp |
ncnn::InnerProduct_x86_fma::create_pipeline_int8_x86(ncnn::Option const&) | int InnerProduct_x86_fma::create_pipeline_int8_x86(const Option& opt)
{
const int num_input = weight_data_size / num_output;
int out_elempack = 1;
#if __SSE2__
if (opt.use_packing_layout)
{
out_elempack = num_output % 8 == 0 ? 8 : 1;
}
#endif // __SSE2__
// src = inch-outch
// dst ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rax
leaq 0x130(%rdi,%rax), %rsi
movl -0x60(%rsi), %ecx
movl -0x58(%rsi), %eax
cltd
idivl %ecx
movl %eax, %ebp
testb $0x7, %cl
sete %r12b
andb 0x27(%rbx), %r12b
movl $0x8, %eax
mov... | /ysh329[P]ncnn/build_O3/src/layer/x86/innerproduct_x86_fma.cpp |
ncnn::innerproduct_fp16s_pack4_sse_f16c(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, int, ncnn::Mat const&, ncnn::Option const&) | static void innerproduct_fp16s_pack4_sse(const Mat& bottom_blob, Mat& top_blob, const Mat& weight_data_fp16, const Mat& bias_data, int activation_type, const Mat& activation_params, const Option& opt)
{
#if NCNN_RUNTIME_CPU && NCNN_F16C && __AVX__ && !__F16C__
if (ncnn::cpu_support_x86_f16c())
{
innerpr... | movslq 0x2c(%rsi), %rax
testq %rax, %rax
jle 0x21f750
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rcx), %rcx
movl 0x18(%rdi), %r10d
imull 0x2c(%rdi), %r10d
movl %r10d, %r11d
andl $-0x8, %r11d
xorl %ebx, %ebx
decl %r8d
leaq 0x1fd06a(%rip), %r14 # 0x41c178
vxorps %xmm5, %xmm5, %xmm5
vbroad... | /ysh329[P]ncnn/src/layer/x86/innerproduct_fp16s.h |
ncnn::Input::Input() | Input::Input()
{
one_blob_only = true;
support_inplace = true;
support_vulkan = true;
support_packing = true;
support_bf16_storage = true;
support_image_storage = true;
} | pushq %rbx
movq %rdi, %rbx
callq 0x70f80
leaq 0x27255c(%rip), %rax # 0x49bb40
movq %rax, (%rbx)
movb $0x1, %al
movb %al, 0xf(%rbx)
movb %al, 0xc(%rbx)
movl $0x1010101, 0x8(%rbx) # imm = 0x1010101
popq %rbx
retq
| /ysh329[P]ncnn/src/layer/input.cpp |
ncnn::LRN::load_param(ncnn::ParamDict const&) | int LRN::load_param(const ParamDict& pd)
{
region_type = pd.get(0, 0);
local_size = pd.get(1, 5);
alpha = pd.get(2, 1.f);
beta = pd.get(3, 0.75f);
bias = pd.get(4, 1.f);
return 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x69336
movl %eax, 0xd0(%rbx)
movq %r14, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x69336
movl %eax, 0xd4(%rbx)
movss 0x1eb47c(%rip), %xmm0 # 0x414d18
movq %r14, %rdi
movl $0x2, %esi
callq 0x69354
... | /ysh329[P]ncnn/src/layer/lrn.cpp |
ncnn::LRN_x86::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN_x86::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;
size_t elemsize = bottom_top_blob.elemsize;
int size = w * h;
// squared values with local_size padding
Mat square_blob;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
movl 0x2c(%rsi), %esi
movl 0x30(%r12), %edx
movl 0x38(%r12), %r14d
movq 0x10(%r12), %rbx
leaq 0xa0(%rsp), %rdi
movq $0x0, 0x40(%rdi)
xorps %xmm0, %xmm0
movap... | /ysh329[P]ncnn/src/layer/x86/lrn_x86.cpp |
ncnn::LRN_x86_avx512::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN_x86_avx512::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;
size_t elemsize = bottom_top_blob.elemsize;
int size = w * h;
// squared values with local_size padding
Mat square_blo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
movl 0x2c(%rsi), %esi
movl 0x30(%r12), %edx
movl 0x38(%r12), %r14d
movq 0x10(%r12), %rbx
leaq 0x80(%rsp), %rdi
movq $0x0, 0x40(%rdi)
vxorps %xmm0, %xmm0, %xmm... | /ysh329[P]ncnn/build_O3/src/layer/x86/lrn_x86_avx512.cpp |
ncnn::LRN_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN_x86_avx::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;
size_t elemsize = bottom_top_blob.elemsize;
int size = w * h;
// squared values with local_size padding
Mat square_blob;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
movl 0x2c(%rsi), %esi
movl 0x30(%r13), %edx
movl 0x38(%r13), %r14d
movq 0x10(%r13), %rbx
leaq 0x90(%rsp), %rdi
movq $0x0, 0x40(%rdi)
vxorps %xmm0, %xmm0, %xmm... | /ysh329[P]ncnn/build_O3/src/layer/x86/lrn_x86_avx.cpp |
ncnn::MVN::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int MVN::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(w, h, channels, elemsize, opt.blob_allocator);
if (top_blo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r12
movl 0x2c(%rsi), %r13d
movl 0x30(%rsi), %ebx
movl 0x38(%rsi), %r14d
movq 0x10(%rsi), %r8
movq %rcx, 0x10(%rsp)
movq 0x8(%rcx), %r9
movq %rdx, %rdi
movl %r13d, %esi
movl %ebx, %edx
movl %r14... | /ysh329[P]ncnn/src/layer/mvn.cpp |
ncnn::Pooling::make_padding(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | void Pooling::make_padding(const Mat& bottom_blob, Mat& bottom_blob_bordered, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
bottom_blob_bordered = bottom_blob;
float pad_value = 0.f;
if (pooling_type == PoolMethod_MAX)
{
pad_value = bottom_blob.elemsize == 1 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl 0x2c(%rsi), %r13d
movl 0x30(%rsi), %ebp
cmpq %rsi, %rdx
je 0x22f170
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x22f0ee
lock
incl (%rax)
movq 0x8(%rbx), %rax
testq %rax, ... | /ysh329[P]ncnn/src/layer/pooling.cpp |
ncnn::Pooling_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Pooling_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// max value in NxN window
// avg value in NxN window
if (adaptive_pooling)
{
return Pooling::forward(bottom_blob, top_blob, opt);
}
#if __SSE2__
int elempack = bottom_blob.elempack;
int w = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %r14
movq %rdx, %r9
movq %rsi, %rbp
movq %rdi, %r15
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
cmpl $0x0, 0x100(%r15,%rax)
je 0x22f523
movq %rbp, %rsi
movq %r9, %rdx
movq %r14, %rcx
addq... | /ysh329[P]ncnn/src/layer/x86/pooling_x86.cpp |
virtual thunk to ncnn::Pooling_x86_avx512::create_pipeline(ncnn::Option const&) | int Pooling_x86_avx512::create_pipeline(const Option& /*opt*/)
{
if (adaptive_pooling)
{
support_packing = false;
support_bf16_storage = false;
support_fp16_storage = false;
support_int8_storage = false;
support_tensor_storage = false;
}
return 0;
} | movq (%rdi), %rax
movq -0x30(%rax), %rcx
leaq (%rdi,%rcx), %rax
movq (%rdi,%rcx), %rcx
movq -0x18(%rcx), %rdx
cmpl $0x0, 0x100(%rdx,%rax)
je 0x23020a
xorl %esi, %esi
movb %sil, 0xb(%rax,%rdx)
movq -0x18(%rcx), %rdx
movb %sil, 0xc(%rax,%rdx)
movq -0x18(%rcx), %rdx
movb %sil, 0xd(%rax,%rdx)
movq -0x18(%rcx), %rdx
movb %s... | /ysh329[P]ncnn/build_O3/src/layer/x86/pooling_x86_avx512.cpp |
int ncnn::binary_op_6_11_16_25<ncnn::BinaryOp_x86_functor::binary_op_pow>(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | static int binary_op_6_11_16_25(const Mat& a, const Mat& b, Mat& c, const Option& opt)
{
Op op;
int w = a.w;
int h = a.h;
int d = a.d;
int channels = a.c;
int elempack = a.elempack;
int size = w * h * d * elempack;
// type 6 11 16 25
c.create_like(a, opt.blob_allocator);
if (c.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r13
movq %rsi, 0x20(%rsp)
movq %rdi, %rsi
movl 0x30(%rdi), %edx
movl 0x38(%rdi), %eax
movq %rax, 0x8(%rsp)
imull 0x2c(%rdi), %edx
imull 0x34(%rdi), %edx
imull 0x18(%rdi), %edx
movl %edx, 0x4(%rsp)
movq %r13, %rdi
movq %rsi, 0... | /ysh329[P]ncnn/src/layer/x86/binaryop_x86.cpp |
int ncnn::binary_op_7_13_19_29<ncnn::BinaryOp_x86_avx512_functor::binary_op_add>(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | static int binary_op_7_13_19_29(const Mat& a, const Mat& b, Mat& c, const Option& opt)
{
Op op;
int w = a.w;
int h = a.h;
int d = a.d;
int channels = a.c;
int elempack = a.elempack;
int size = w * h * d * elempack;
// type 7 13 19 29
c.create_like(a, opt.blob_allocator);
if (c.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x30(%rdi), %ebp
movl 0x38(%rdi), %r12d
imull 0x2c(%rdi), %ebp
imull 0x34(%rdi), %ebp
imull 0x18(%rdi), %ebp
movq %rdx, %rdi
movq %r15, %rsi
movq %rcx, %rdx
callq 0x5b4ec
movl $0xffffff9c, %eax # imm = 0xFF... | /ysh329[P]ncnn/build_O3/src/layer/x86/binaryop_x86_avx512.cpp |
int ncnn::binary_op_6_11_16_25<ncnn::BinaryOp_x86_avx512_functor::binary_op_pow>(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | static int binary_op_6_11_16_25(const Mat& a, const Mat& b, Mat& c, const Option& opt)
{
Op op;
int w = a.w;
int h = a.h;
int d = a.d;
int channels = a.c;
int elempack = a.elempack;
int size = w * h * d * elempack;
// type 6 11 16 25
c.create_like(a, opt.blob_allocator);
if (c.... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x40, %rsp
subq $0x180, %rsp # imm = 0x180
movq %rdx, %rbx
movq %rsi, 0x30(%rsp)
movq %rdi, %rsi
movl 0x30(%rdi), %r14d
movl 0x38(%rdi), %eax
movq %rax, 0x18(%rsp)
imull 0x2c(%rdi), %r14d
imull 0x34(%rdi), %r14d
imull 0x... | /ysh329[P]ncnn/build_O3/src/layer/x86/binaryop_x86_avx512.cpp |
virtual thunk to ncnn::UnaryOp_x86::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int UnaryOp_x86::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
using namespace UnaryOp_x86_functor;
if (op_type == Operation_ABS)
return unary_op_inplace<unary_op_abs>(bottom_top_blob, opt);
if (op_type == Operation_NEG)
return unary_op_inplace<unary_op_neg>(bottom_top_bl... | pushq %rax
movq (%rdi), %rax
addq -0x58(%rax), %rdi
callq 0x2fc5d0
xorl %eax, %eax
popq %rcx
retq
nop
| /ysh329[P]ncnn/src/layer/x86/unaryop_x86.cpp |
ncnn::convolutiondepthwise(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, int, int, int, int, int, int, int, int, ncnn::Mat const&, ncnn::Option const&) | static int convolutiondepthwise(const Mat& bottom_blob, Mat& top_blob, const Mat& weight_data, const Mat& bias_data, int kernel_w, int kernel_h, int stride_w, int stride_h, int dilation_w, int dilation_h, int group, int activation_type, const Mat& activation_params, const Option& opt)
{
const int w = bottom_blob.w;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movl %r9d, %ebx
movl %r8d, %r12d
movq %rsi, %r13
movq %rdi, 0x48(%rsp)
cmpq $0x0, (%rcx)
movq %rcx, 0xb8(%rsp)
movq %rdx, 0x10(%rsp)
je 0x30ae40
movslq 0x38(%rcx), %rax
imulq 0x40(%rcx), %rax
testq %rax, %rax
se... | /ysh329[P]ncnn/src/layer/convolutiondepthwise.cpp |
virtual thunk to ncnn::ConvolutionDepthWise_x86_avx512::destroy_pipeline(ncnn::Option const&) | int ConvolutionDepthWise_x86_avx512::destroy_pipeline(const Option& opt)
{
if (activation)
{
activation->destroy_pipeline(opt);
delete activation;
activation = 0;
}
for (int i = 0; i < (int)group_ops.size(); i++)
{
group_ops[i]->destroy_pipeline(opt);
delete ... | pushq %rax
movq (%rdi), %rax
addq -0x38(%rax), %rdi
callq 0x315d16
xorl %eax, %eax
popq %rcx
retq
nop
| /ysh329[P]ncnn/build_O3/src/layer/x86/convolutiondepthwise_x86_avx512.cpp |
ncnn::convdw5x5s1_pack8_avx(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, ncnn::Option const&) | static void convdw5x5s1_pack8_avx(const Mat& bottom_blob, Mat& top_blob, const Mat& kernel, const Mat& _bias, const Option& opt)
{
int outw = top_blob.w;
int outh = top_blob.h;
const int group = bottom_blob.c;
const float* bias = _bias;
#pragma omp parallel for num_threads(opt.num_threads)
for... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x18(%rsp)
movq %rsi, -0x28(%rsp)
movq %rdi, -0x20(%rsp)
movslq 0x38(%rdi), %rax
movq %rax, -0x8(%rsp)
testq %rax, %rax
jle 0x31bfa1
movq -0x28(%rsp), %rax
movl 0x2c(%rax), %esi
movl 0x30(%rax), %r9d
xorl %edi, %edi
movl $0x80, %r11d
movq %rc... | /ysh329[P]ncnn/src/layer/x86/convolutiondepthwise_5x5_pack8.h |
ncnn::InstanceNorm::load_model(ncnn::ModelBin const&) | int InstanceNorm::load_model(const ModelBin& mb)
{
if (affine == 0)
return 0;
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;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
xorl %ebx, %ebx
cmpl $0x0, 0xd8(%rdi)
je 0x369609
movq %rsi, %r15
movq %rdi, %r14
movl 0xd0(%rdi), %edx
movq (%rsi), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl $0x1, %ecx
callq *0x10(%rax)
leaq 0xe0(%r14), %r13
movq 0x8(%r12), %rax
cmpq %r12, %... | /ysh329[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 c = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
f... | movslq 0x38(%rsi), %rax
testq %rax, %rax
jle 0x3697cd
pushq %rbx
movl 0x30(%rsi), %ecx
imull 0x2c(%rsi), %ecx
movq (%rsi), %rdx
cvtsi2ss %ecx, %xmm1
movq 0x40(%rsi), %r8
movl 0xd8(%rdi), %r9d
movq 0xe0(%rdi), %r10
movq 0x128(%rdi), %r11
movss 0xab64d(%rip), %xmm0 # 0x414d18
divss %xmm1, %xmm0
imulq 0x10(%rsi), %r8
x... | /ysh329[P]ncnn/src/layer/instancenorm.cpp |
virtual thunk to ncnn::Clip_x86::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Clip_x86::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int d = bottom_top_blob.d;
int channels = bottom_top_blob.c;
int elempack = bottom_top_blob.elempack;
int size = w * h * d * elempack;
#pragma omp parallel fo... | pushq %rax
movq (%rdi), %rax
addq -0x58(%rax), %rdi
callq 0x36991c
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
| /ysh329[P]ncnn/src/layer/x86/clip_x86.cpp |
ncnn::Convolution1D_x86_avx::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Convolution1D_x86_avx::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.elempack;
#if __AVX512F__
if (elempack == 16)
{
Mat tmp;
convert_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movslq 0x18(%rsi), %rax
movq %rax, 0x58(%rsp)
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0xd4(%rdi,%rax), %r15d
decl %r15d
imull 0xd8(%rdi,%rax), %r15d
addq %rax, %... | /ysh329[P]ncnn/build_O3/src/layer/x86/convolution1d_x86_avx.cpp |
ncnn::DeconvolutionDepthWise3D::load_param(ncnn::ParamDict const&) | int DeconvolutionDepthWise3D::load_param(const ParamDict& pd)
{
num_output = pd.get(0, 0);
kernel_w = pd.get(1, 0);
kernel_h = pd.get(11, kernel_w);
kernel_d = pd.get(21, kernel_w);
dilation_w = pd.get(2, 1);
dilation_h = pd.get(12, dilation_w);
dilation_d = pd.get(22, dilation_w);
strid... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x69336
movl %eax, 0xd0(%rbx)
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x69336
movl %eax, 0xd4(%rbx)
movq %r14, %rdi
movl $0xb, %esi
movl %eax, %edx
callq 0x69336
movl %ea... | /ysh329[P]ncnn/src/layer/deconvolutiondepthwise3d.cpp |
ncnn::sum_dim(std::vector<int, std::allocator<int>> const&, int, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> 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&, s... | static float sum_dim(const std::vector<int>& dim_sizes, int d, const std::vector<Mat>& bottom_blobs, const std::vector<std::string>& tokens, std::vector<int>& indexes)
{
if (d == (int)dim_sizes.size())
{
float v = 1.f;
for (size_t b = 0; b < bottom_blobs.size(); b++)
{
v *= g... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %rbp
movq %rdi, %r12
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
subq %rax, %rdi
shrq $0x2, %rdi
movl %esi, (%rsp)
cmpl %esi, %edi
jne 0x40ca6c
movq (%rbp), %rax
movq 0x8(%rbp), %rdx
subq %rax, %rdx
je 0x40... | /ysh329[P]ncnn/src/layer/einsum.cpp |
ncnn::DeformableConv2D::load_param(ncnn::ParamDict const&) | int DeformableConv2D::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_left = pd.get(4, 0);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x69336
movl %eax, 0xd0(%rbx)
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x69336
movl %eax, 0xd4(%rbx)
movq %r14, %rdi
movl $0xb, %esi
movl %eax, %edx
callq 0x69336
movl %ea... | /ysh329[P]ncnn/src/layer/deformableconv2d.cpp |
cJSON_strdup | static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)
{
size_t length = 0;
unsigned char *copy = NULL;
if (string == NULL)
{
return NULL;
}
length = strlen((const char*)string) + sizeof("");
copy = (unsigned char*)hooks->allocate(length... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3721
movq $0x0, -0x8(%rbp)
jmp 0x376d
movq -0x10(%rbp), %rdi
callq 0x30a0
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
m... | /dparo[P]master-thesis/deps/cJSON/tests/../cJSON.c |
get_object_item | static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)
{
cJSON *current_element = NULL;
if ((object == NULL) || (name == NULL))
{
return NULL;
}
current_element = object->child;
if (case_sensitive)
{
while ((curre... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x46c9
cmpq $0x0, -0x18(%rbp)
jne 0x46d6
movq $0x0, -0x8(%rbp)
jmp 0x479c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c... | /dparo[P]master-thesis/deps/cJSON/tests/../cJSON.c |
minify_string | static void minify_string(char **input, char **output) {
(*output)[0] = (*input)[0];
*input += static_strlen("\"");
*output += static_strlen("\"");
for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) {
(*output)[0] = (*input)[0];
if ((*input)[0] == '\"') {
(*output)... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
mo... | /dparo[P]master-thesis/deps/cJSON/tests/../cJSON.c |
ensure | static unsigned char* ensure(printbuffer * const p, size_t needed)
{
unsigned char *newbuffer = NULL;
size_t newsize = 0;
if ((p == NULL) || (p->buffer == NULL))
{
return NULL;
}
if ((p->length > 0) && (p->offset >= p->length))
{
/* make sure that offset is valid */
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7f11
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7f1e
movq $0x0, -0x8(%rbp)
jmp 0x80e9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x7f48
movq -0x10(... | /dparo[P]master-thesis/deps/cJSON/tests/../cJSON.c |
print_array | static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer)
{
unsigned char *output_pointer = NULL;
size_t length = 0;
cJSON *current_element = item->child;
if (output_buffer == NULL)
{
return false;
}
/* Compose the output array. */
/* opening sq... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x839f
movl $0x0, -0x4(%rbp)
jmp 0x8517
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x7e... | /dparo[P]master-thesis/deps/cJSON/tests/../cJSON.c |
UnityAssertEqualNumber | void UnityAssertEqualNumber(const UNITY_INT expected,
const UNITY_INT actual,
const char* msg,
const UNITY_LINE_TYPE lineNumber,
const UNITY_DISPLAY_STYLE_T style)
{
RETURN_IF_FAIL_OR_IGNORE;
if (exp... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpq $0x0, 0x69a4(%rip) # 0x10148
jne 0x97b0
cmpq $0x0, 0x69a2(%rip) # 0x10150
je 0x97b2
jmp 0x981e
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x98... | /dparo[P]master-thesis/deps/cJSON/tests/unity/src/unity.c |
UnityIsOneArrayNull | static int UnityIsOneArrayNull(UNITY_INTERNAL_PTR expected,
UNITY_INTERNAL_PTR actual,
const UNITY_LINE_TYPE lineNumber,
const char* msg)
{
if (expected == actual) return 0; /* Both are NULL or same pointer */
/* print... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x9c8b
movl $0x0, -0x4(%rbp)
jmp 0x9cee
cmpq $0x0, -0x10(%rbp)
jne 0x9cb9
movq -0x20(%rbp), %rdi
callq 0x96c0
leaq 0x293e(%rip), %rdi ... | /dparo[P]master-thesis/deps/cJSON/tests/unity/src/unity.c |
UnityAssertEqualFloatArray | void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected,
UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual,
const UNITY_UINT32 num_elements,
const char* msg,
const UNITY_LI... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmp... | /dparo[P]master-thesis/deps/cJSON/tests/unity/src/unity.c |
Catch::makeCommandLineParser(Catch::ConfigData&) | Clara::Parser makeCommandLineParser( ConfigData& config ) {
using namespace Clara;
auto const setWarning = [&]( std::string const& warning ) {
if ( warning == "NoAssertions" ) {
config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b58, %rsp # imm = 0x2B58
movq %rsi, %r14
movq %rdi, 0x60(%rsp)
addq $0xa8, %rsi
leaq 0x1360(%rsp), %rdi
callq 0x2bc36
leaq 0x7(%r14), %rsi
leaq 0x1dc0(%rsp), %rdi
callq 0x2d04a
leaq 0x1e38(%rsp), %rdi
leaq 0x1360(%rsp), %rsi
leaq 0x1dc... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Session::showHelp() const | void Session::showHelp() const {
Catch::cout()
<< "\nCatch2 v" << libraryVersion() << '\n'
<< m_cli << '\n'
<< "For more detailed usage please see the project docs\n\n" << std::flush;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x1223d2(%rip), %r14 # 0x147f98
leaq 0xd2b73(%rip), %rsi # 0xf8740
movl $0x9, %edx
movq %r14, %rdi
callq 0x12630
callq 0x25d44
leaq 0x1241b2(%rip), %rsi # 0x149d98
movq %r14, %rdi
callq 0x25c51
movb $0xa, %bpl
leaq 0xe(%rsp), %rsi
movb %bp... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Session::applyCommandLine(int, char const* const*) | int Session::applyCommandLine( int argc, char const * const * argv ) {
if( m_startupExceptions )
return 1;
auto result = m_cli.parse( Clara::Args( argc, argv ) );
if( !result ) {
config();
getCurrentMutableContext().setConfig(m_config.get());
aut... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movl $0x1, %ebp
cmpb $0x0, 0x178(%rdi)
jne 0x26152
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2cf78
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2624e
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x4c0f8
movq -0x2... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Session::useConfigData(Catch::ConfigData const&) | void Session::useConfigData( ConfigData const& configData ) {
m_configData = configData;
m_config.reset();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x60, %rdi
movl $0xc, %ecx
rep movsq (%rsi), %es:(%rdi)
movl 0x60(%r14), %eax
movl %eax, 0xc0(%rbx)
movl $0xc8, %r15d
leaq (%rbx,%r15), %rdi
leaq 0x68(%r14), %rsi
callq 0x12290
leaq 0xe8(%rbx), %rdi
leaq 0x88(%r14), %rsi
callq 0x12290
leaq 0x108(%r... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Session::runInternal() | int Session::runInternal() {
if( m_startupExceptions )
return 1;
if (m_configData.showHelp || m_configData.libIdentify) {
return 0;
}
if ( m_configData.shardIndex >= m_configData.shardCount ) {
Catch::cerr() << "The shard count (" << m_configData.sha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movl $0x1, %ebp
cmpb $0x0, 0x178(%rdi)
jne 0x26a18
movq %rdi, %r12
xorl %ebp, %ebp
cmpb $0x0, 0x67(%rdi)
jne 0x26a18
cmpb $0x0, 0x6a(%r12)
jne 0x26a18
movl 0x78(%r12), %eax
cmpl 0x74(%r12), %eax
jae 0x264e9
movq... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::(anonymous namespace)::TestGroup::TestGroup(Catch::Detail::unique_ptr<Catch::IEventListener>&&, Catch::Config const*) | explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
m_reporter(reporter.get()),
m_config{config},
m_context{config, CATCH_MOVE(reporter)} {
assert( m_config->testSpec().getInvalidSpecs().empty() &&
"Invalid test... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq (%rsi), %rcx
movq %rcx, (%rdi)
movq %rdx, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2fbba
leaq 0x1d8(%rbx), %r15
leaq 0x1e0(%rbx), %r12
movl $0x0, 0x1e0(... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::toLower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string toLower( std::string const& s ) {
std::string lc = s;
toLowerInPlace( lc );
return lc;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x53b7e
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x286ae
movq (%rbx), %r15
xorl %r12d, %r12d
movzbl (%r15,%r12), %edi
callq 0x127d0
... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::TestSpec::matches(Catch::TestCaseInfo const&) const | bool TestSpec::matches( TestCaseInfo const& testCase ) const {
return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rbx
movq 0x8(%rdi), %r12
movq %r12, %rbp
subq %rbx, %rbp
sarq $0x4, %rbp
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r13, %rbp
sarq $0x2, %rbp
testq %rbp, %rbp
jle 0x28c84
incq %rbp
movq %... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Detail::convertIntoString[abi:cxx11](Catch::StringRef) | std::string convertIntoString(StringRef string) {
return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles());
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x120cfd(%rip) # 0x149dc0
jne 0x290dc
movl $0x10, %edi
callq 0x12540
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x120ce4(%rip) # 0x149dc0
movq 0x120cdd(%rip), %rax # 0x149dc0
movq (%rax), %rdi
movq (%rdi), %rax
... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::StringMaker<char const*, void>::convert[abi:cxx11](char const*) | std::string StringMaker<char const*>::convert(char const* str) {
if (str) {
return Detail::convertIntoString( str );
} else {
return{ "{null string}" };
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2926d
movq %rsi, %r14
movq %rsi, %rdi
callq 0x12210
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x290ad
jmp 0x2928a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xcf781(%rip), %rsi # 0xf89fc
leaq 0xcf787(%rip), %rdx # 0xf8a09
movq ... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Section::Section(Catch::SourceLineInfo const&, Catch::StringRef, char const*) | Section::Section( SourceLineInfo const& _lineInfo,
StringRef _name,
const char* const ):
m_info( { "invalid", static_cast<std::size_t>( -1 ) }, std::string{} ),
m_sectionIncluded(
getResultCapture().sectionStarted( _name, _lineInfo, m_assertions ) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
xorl %ecx, %ecx
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movb (%rax), %dl
movb %dl, 0x10(%... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Section::~Section() | Section::~Section() {
if( m_sectionIncluded ) {
SectionEndInfo endInfo{ CATCH_MOVE(m_info), m_assertions, m_timer.getElapsedSeconds() };
if ( uncaught_exceptions() ) {
getResultCapture().sectionEndedEarly( CATCH_MOVE(endInfo) );
} else {
getRes... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x50(%rdi)
jne 0x331c6
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rcx
leaq 0x10(%rbx), %rax
cmpq %rax, %rcx
je 0x33117
movq %rcx, (%rsp)
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
jmp 0x3311e
movups (%rax), %xmm0
movups %xmm0, (%r14)
movq 0x... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::operator<<(std::ostream&, Catch::SourceLineInfo const&) | std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
#ifndef __GNUG__
os << info.file << '(' << info.line << ')';
#else
os << info.file << ':' << info.line;
#endif
return os;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
je 0x332e8
movq %r15, %rdi
callq 0x12210
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12630
jmp 0x332ff
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %e... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::replaceInPlace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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&) | bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
bool replaced = false;
std::size_t i = str.find( replaceThis );
while( i != std::string::npos ) {
replaced = true;
str = str.substr( 0, i ) + withThis + str.substr( i+re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r15
movq (%rsi), %rsi
movq %rax, 0x50(%rsp)
movq 0x8(%rax), %rcx
xorl %edx, %edx
callq 0x12980
movq %rax, 0x48(%rsp)
cmpq $-0x1, %rax
je 0x3367f
leaq 0x38(%rsp), %rbp
leaq 0x68(%rsp), %r13
movq... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::TestSpecParser::processNoneChar(char) | bool TestSpecParser::processNoneChar( char c ) {
switch( c ) {
case ' ':
return true;
case '~':
m_exclusion = true;
return false;
case '[':
startNewMode( Tag );
return false;
case '"':
startNewMode( QuotedNam... | cmpl $0x5a, %esi
jg 0x3539f
cmpl $0x20, %esi
je 0x353b7
cmpl $0x22, %esi
jne 0x353af
movl $0x2, (%rdi)
jmp 0x353c0
cmpl $0x5b, %esi
je 0x353ba
cmpl $0x7e, %esi
jne 0x353af
movb $0x1, 0x8(%rdi)
jmp 0x353c0
movl $0x1, (%rdi)
jmp 0x353c0
movb $0x1, %al
retq
movl $0x3, (%rdi)
xorl %eax, %eax
retq
nop
| /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Matchers::WithinULP(double, unsigned long) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Double);
} | movq %rdi, %rax
leaq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x10c4e1(%rip), %rcx # 0x144298
movq %rcx, (%rdi)
movsd %xmm0, 0x28(%rdi)
movq %rsi, 0x30(%rdi)
movb $0x1, 0x38(%rdi)
retq
| /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Matchers::AllTrue() | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; } | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x20(%rdi)
leaq 0x18(%rdi), %rdx
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x10da8b(%rip), %rcx # 0x145a60
movq %rcx, (%rdi)
retq
nop
| /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Matchers::AnyTrue() | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; } | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x20(%rdi)
leaq 0x18(%rdi), %rdx
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x10da67(%rip), %rcx # 0x145ae0
movq %rcx, (%rdi)
retq
nop
| /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Matchers::ContainsSubstring(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CaseSensitive) | StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity ) {
return StringContainsMatcher( CasedString( str, caseSensitivity) );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl %edx, -0x8(%rdi)
movq %rsp, %r14
movq %r14, %rsi
movq %rax, %rdx
callq 0x38096
leaq 0xc1841(%rip), %rsi # 0xf9f7b
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x380ec
leaq 0x10bc07(%rip), %rax # 0x144358
mov... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::ReporterBase::listTests(std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>> const&) | void ReporterBase::listTests(std::vector<TestCaseHandle> const& tests) {
defaultListTests(m_stream,
m_colour.get(),
tests,
m_config->hasTestFilters(),
m_config->verbosity());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq 0x20(%r14), %r15
movq 0x28(%r14), %r12
movq (%rdi), %rax
callq *0x70(%rax)
movl %eax, %ebp
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0xb0(%rax)
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r12, %rsi
movq %r... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::defaultListTags(std::ostream&, std::vector<Catch::TagInfo, std::allocator<Catch::TagInfo>> const&, bool) | void defaultListTags( std::ostream& out,
std::vector<TagInfo> const& tags,
bool isFiltered ) {
if ( isFiltered ) {
out << "Tags for matching test cases:\n";
} else {
out << "All available tags:\n";
}
for ( auto ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
testl %edx, %edx
movq %rdi, 0x8(%rsp)
je 0x3997a
leaq 0xc0aca(%rip), %rsi # 0xfa43d
movl $0x1e, %edx
jmp 0x39986
leaq 0xc0adb(%rip), %rsi # 0xfa45c
movl $0x14, %edx
callq 0x12630
movq (%rbx), %r15
movq %rbx, 0x50(... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::(anonymous namespace)::SummaryColumn::addRow(unsigned long) && | SummaryColumn&& addRow( std::uint64_t count ) && {
std::string row = std::to_string(count);
auto const new_width = std::max( m_width, row.size() );
if ( new_width > m_width ) {
for ( auto& oldRow : m_rows ) {
oldRow.insert( 0, n... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %esi
cmpq $0xa, %r14
jb 0x3e4e7
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r14, %rcx
cmpq $0x63, %rcx
jbe 0x3e4e0
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x3e... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::(anonymous namespace)::TapAssertionPrinter::printOriginalExpression() const | void printOriginalExpression() const {
if (result.hasExpression()) {
stream << ' ' << result.getExpression();
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %rax
cmpq $0x0, 0x28(%rax)
je 0x45d7c
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x8(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
callq 0x12630
movq %rax, %r14
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1be3c
movq (%rbx), %rsi
movq 0x8(%rbx), %... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::(anonymous namespace)::TapAssertionPrinter::printMessage() | void printMessage() {
if (itMessage != messages.end()) {
stream << " '" << itMessage->message << '\'';
++itMessage;
}
} | movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq 0x8(%rax), %rcx
je 0x46107
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0xb6395(%rip), %rsi # 0xfc45a
movl $0x2, %edx
movq %r14, %rdi
callq 0x12630
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq %r14, %rdi
callq 0x12... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::(anonymous namespace)::TapAssertionPrinter::printExpressionWas() | void printExpressionWas() {
if (result.hasExpression()) {
stream << ';';
stream << colourImpl->guardColour( tapDimColour )
<< " expression was:";
printOriginalExpression();
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdi), %rax
cmpq $0x0, 0x28(%rax)
je 0x46187
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rsp, %r15
movb $0x3b, (%r15)
movl $0x1, %edx
movq %r15, %rsi
callq 0x12630
movq (%rbx), %r14
movq 0x30(%rbx), %rax
movq %rax, (%r15)
movl $0x17, 0x8(%r15)
movb $0x0, 0xc(%r15)
... | /jbaldwin[P]libcappuccino/test/catch.cpp |
Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::~Singleton() | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | pushq %rbx
movq %rdi, %rbx
leaq 0xffc3b(%rip), %rax # 0x145ff8
movq %rax, (%rdi)
leaq 0xffcb1(%rip), %rax # 0x146078
movq %rax, 0x8(%rdi)
leaq 0xff3ce(%rip), %rax # 0x1457a0
movq %rax, 0x110(%rdi)
addq $0x118, %rdi # imm = 0x118
callq 0x539da
leaq 0xf8(%rbx), %rdi
callq 0x550fe
leaq 0xfdd40(%rip)... | /jbaldwin[P]libcappuccino/test/catch.hpp |
Catch::(anonymous namespace)::RegistryHub::registerReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Detail::unique_ptr<Catch::IReporterFactory>) | void registerReporter( std::string const& name, IReporterFactoryPtr factory ) override {
m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) );
} | pushq %rbx
subq $0x10, %rsp
addq $0x98, %rdi
movq (%rdx), %rcx
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq $0x0, (%rdx)
movq %rax, %rdx
callq 0x2edf2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x464a4
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
... | /jbaldwin[P]libcappuccino/test/catch.cpp |
non-virtual thunk to Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::~Singleton() | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq -0x130(%rdi), %rbx
leaq 0xff7db(%rip), %rax # 0x145ff8
movq %rax, -0x130(%rdi)
leaq 0xff84d(%rip), %rax # 0x146078
movq %rax, -0x128(%rdi)
leaq 0xfef67(%rip), %rax # 0x1457a0
movq %rax, -0x20(%rdi)
addq $-0x18, %rdi
callq 0x539da
leaq -0x38(%r14), %rdi
c... | /jbaldwin[P]libcappuccino/test/catch.hpp |
Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_7>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const& arg )
-> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
m_lambda, arg );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x48(%rsp), %rdi
movq %rdx, %rsi
callq 0x12290
xorl %eax, %eax
leaq 0x88(%rsp), %r13
movq... | /jbaldwin[P]libcappuccino/test/catch.hpp |
Catch::Clara::Detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_10>::setFlag(bool) | auto setFlag( bool flag ) -> ParserResult override {
return LambdaInvoker<typename UnaryLambdaTraits<
L>::ReturnType>::invoke( m_lambda, flag );
} | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movl $0x1, 0xc(%rcx)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
leaq 0xffda5(%rip), %rdx # 0x146fb8
movq %rdx, (%rdi)
leaq 0x20(%rdi), %rdx
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
retq
nop
| /jbaldwin[P]libcappuccino/test/catch.hpp |
Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_12>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const& arg )
-> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf(%rsp), %rax
movb $0x0, (%rax)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2ab3c
movl 0x8(%r15), %eax
testl %eax, %eax
je 0x4771b
movl %eax, 0x8(%rbx)
leaq 0xff8c0(%rip), %r15 # 0x146fb8
movq ... | /jbaldwin[P]libcappuccino/test/catch.hpp |
Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_6>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const& arg )
-> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
m_lambda, arg );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x12290
xorl %ebp, %ebp
leaq 0xa8(%rsp), %r12
movq %rbp, -0x18(%r12)
leaq 0xf... | /jbaldwin[P]libcappuccino/test/catch.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.