name string | code string | asm string | file string |
|---|---|---|---|
shift_window_transformer::WindowAttention<float>::~WindowAttention() | ~WindowAttention() {
if (qLinear != nullptr) {
delete qLinear;
qLinear = nullptr;
}
if (kLinear != nullptr) {
delete kLinear;
kLinear = nullptr;
}
if (vLinear != nullptr) {
delete ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rcx
movq -0x28(%rax), %rax
movq %rcx, (%rdi,%rax)
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0x3947
movq %r14, %rdi
callq 0x2b14
movl $0x28, %esi
movq %r14, %rdi
callq 0x2180
movq $0x0, 0x18(%rbx)
movq 0x20(%rbx), %r14
... | /dianhsu[P]swin-transformer-cpp/model/window_attention.h |
shift_window_transformer::WindowAttention<float>::parameterCount() | long long parameterCount() {
long long ret = 0;
if (cyclicShift != nullptr) ret += cyclicShift->parameterCount();
if (cyclicBackShift != nullptr) ret += cyclicBackShift->parameterCount();
if (qLinear != nullptr) ret += qLinear->parameterCount();
if (kLinear !=... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4a2b
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rbx
jmp 0x4a2d
xorl %ebx, %ebx
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x4a3f
movq (%rdi), %rax
callq *0x8(%rax)
addq %rax, %rbx
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x4... | /dianhsu[P]swin-transformer-cpp/model/window_attention.h |
shift_window_transformer::SoftMax<float>::forward(shift_window_transformer::Tensor<float> const&, shift_window_transformer::Tensor<float>&) | void forward(const Tensor <T> &input, Tensor <T> &output) {
int dim = input.shape.back();
output.clear();
output.shape = input.shape;
for (int i = 0; i < input.size(); i += dim) {
T sum = 0;
for (int j = 0; j < dim; ++j) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
addq $0x18, %rsi
movq 0x20(%r14), %rax
movslq -0x4(%rax), %rbp
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x4dbb
movq %rax, 0x8(%rbx)
leaq 0x18(%rbx), %rdi
callq 0x4caa
movq 0x8(%r14), %rax
cmpq (%r14), %ra... | /dianhsu[P]swin-transformer-cpp/model/softmax.h |
shift_window_transformer::FeedForward<float>::forward(shift_window_transformer::Tensor<float> const&, shift_window_transformer::Tensor<float>&) | void forward(const Tensor <T> &input, Tensor <T> &output) {
Tensor<T> tmp1{};
linear1->forward(input, tmp1);
Tensor<T> tmp2{};
tmp2.shape.insert(tmp2.shape.end(), tmp1.shape.begin(), tmp1.shape.end());
for (auto item: tmp1) {
tmp2.push_back(GEL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdx
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x28(%rsp), %rdi
xorps %xmm0, %xmm0... | /dianhsu[P]swin-transformer-cpp/model/feed_forward.h |
shift_window_transformer::PatchMerging<float>::parameterCount() | long long parameterCount() {
if (use_bias)
return weights->size() + bias->size();
return weights->size();
} | movq 0x20(%rdi), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x2, %rax
cmpb $0x1, 0x38(%rdi)
jne 0x5825
movq 0x28(%rdi), %rcx
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x2, %rdx
addq %rdx, %rax
retq
| /dianhsu[P]swin-transformer-cpp/model/linear.h |
shift_window_transformer::StageModule<float>::StageModule(int, int, int, int, int, int, int, bool) | StageModule(int in_channels, int hidden_dimension, int layers_cnt, int downscaling_factor, int num_heads,
int head_dim, int window_size, bool relative_pos_embedding) : patch_partition(in_channels,
hidde... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %r14d
movl %ecx, %ebp
movl %edx, %r13d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x5d42(%rip), %rax # 0xba28
movq %rax, (%rdi)
leaq 0x5ec0(%rip), %rax # 0xbbb0
movq %rax, 0x8(%rdi)
addq $0x20, %rdi
m... | /dianhsu[P]swin-transformer-cpp/model/stage_module.h |
shift_window_transformer::WindowAttention<float>::WindowAttention(int, int, int, bool, int, bool) | WindowAttention(int dim, int heads, int headDim, bool shifted, int windowSize, bool relativePosEmbedding)
: shifted(shifted),
scale(1 / sqrt(headDim)),
innerDim(heads * headDim),
heads(heads),
headDim(headDim),
win... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2748, %rsp # imm = 0x2748
movl %r9d, %r14d
movl %r8d, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movb 0x2780(%rsp), %r13b
leaq 0x5a70(%rip), %rax # 0xbae8
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%... | /dianhsu[P]swin-transformer-cpp/model/window_attention.h |
Decrypt::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::ostream&) | void Decrypt::operator()(const std::string &inputPath, std::ostream &os) {
// Read input file and tell it to not ignore whitespaces while reading
std::ifstream is(inputPath, std::ios::in | std::ios::binary | std::ios::ate);
is >> std::noskipws;
auto size = is.tellg();
is.seekg(0, std::ios::beg);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x478, %rsp # imm = 0x478
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xf8(%rsp), %r15
pushq $0xe
popq %rdx
movq %r15, %rdi
callq 0x3280
movq (%r15), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x110(%rsp,%rax) # imm = 0xFFFFEFFF
movq %r15, %... | /Spriithy[P]3des-cpp/3des/Crypt.cpp |
Decrypt::decrypt(SequenceD<64>&) | SequenceD<64> &Decrypt::decrypt(SequenceD<64> &seq) {
DESinv d1(m_k1);
seq = d1(seq);
DES c(m_k2);
seq = c(seq);
DESinv d2(m_k1);
seq = d2(seq);
return seq;
} | pushq %r14
pushq %rbx
subq $0x4d8, %rsp # imm = 0x4D8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x428(%rsp), %rdi
movq %r14, %rsi
callq 0x4634
leaq 0x378(%rsp), %rdi
movq %rbx, %rsi
callq 0x4634
leaq 0xb8(%rsp), %rdi
leaq 0x428(%rsp), %rsi
leaq 0x378(%rsp), %rdx
callq 0xb126
leaq 0xb8(%rsp), %rsi
movq %rbx, %rdi
... | /Spriithy[P]3des-cpp/3des/Crypt.cpp |
fsm_from_file(boost::filesystem::path const&) | fsm_def fsm_from_file(const boost::filesystem::path& input_file_path)
{
namespace ba = boost::algorithm;
fsm_def sm;
std::ifstream file (input_file_path.native());
if (file.is_open()) {
std::cout << "Reading statemachine from: " << input_file_path.native() << std::endl;
std::string line;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
callq 0x6b38
leaq 0x90(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x5460
leaq 0x108(%rsp), %rdi
callq 0x5090
testb %al, %al
je 0x5b73
movq 0x186df(%rip), %rdi ... | /mlutken[P]nestle/estl/fsm/playground/fsm2dot_playground.cpp |
fsm_def::fsm_def() | fsm_def()
: general_options({"node [shape = circle]"})
{
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
leaq 0xb853(%rip), %rsi # 0x123b8
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6bc8
leaq 0x38(%rbx), %rdi... | /mlutken[P]nestle/estl/fsm/playground/fsm2dot_playground.cpp |
operator<<(std::ostream&, fsm_def&) | inline std::ostream& operator <<(std::ostream& os, fsm_def& sm)
{
os << "digraph " << sm.name << " {\n";
for (const auto& state : sm.get_states()) {
os << "\t" << state << ";\n";
}
os << "\n";
for (const auto& option : sm.general_options) {
os << "\t" << option << ";\n";
}
os... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xaaea(%rip), %rsi # 0x12429
callq 0x52b0
leaq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x5290
leaq 0xaadb(%rip), %rsi # 0x12432
movq %rax, %rdi
callq 0x52b0
movq %rsp, %r12
movq %r12, %rdi
mo... | /mlutken[P]nestle/estl/fsm/playground/fsm2dot_playground.cpp |
transition::fix_names() | void fix_names()
{
fix_name(state_from);
fix_name(state_to);
const size_t pos = label.rfind(':');
if (pos != std::string::npos) {
label = label.substr(pos+1);
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rdi, %rsi
callq 0xc2ac
leaq 0x20(%rbx), %rsi
movq %rbx, %rdi
callq 0xc2ac
addq $0x40, %rbx
pushq $0x3a
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x55b0
cmpq $-0x1, %rax
je 0xc278
incq %rax
leaq 0x8(%rsp), %r14
pushq $-0x1
popq %rcx
movq %r14, %rdi... | /mlutken[P]nestle/estl/fsm/playground/fsm2dot_playground.cpp |
secp256k1_context_preallocated_size | size_t secp256k1_context_preallocated_size(unsigned int flags) {
size_t ret = sizeof(secp256k1_context);
/* A return value of 0 is reserved as an indicator for errors when we call this function internally. */
VERIFY_CHECK(ret != 0);
if (EXPECT((flags & SECP256K1_FLAGS_TYPE_MASK) != SECP256K1_FLAGS_TYPE... | subq $0x48, %rsp
cmpb $0x1, %dil
jne 0x1252bd
leaq 0x10(%rsp), %rax
movq $0x4d430002, (%rax) # imm = 0x4D430002
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %r... | /sipsorcery[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ecdsa_verify | int secp256k1_ecdsa_verify(const secp256k1_context* ctx, const secp256k1_ecdsa_signature *sig, const unsigned char *msghash32, const secp256k1_pubkey *pubkey) {
secp256k1_ge q;
secp256k1_scalar r, s;
secp256k1_scalar m;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(msghash32 != NULL);
ARG_CHECK(sig != NU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
testq %rdx, %rdx
je 0x127020
movq %rsi, %r12
testq %rsi, %rsi
je 0x12702a
movq %rcx, %r15
testq %rcx, %rcx
je 0x127034
movq %rdi, (%rsp)
xorl %ebx, %ebx
leaq 0xf0(%rsp), %rdi
movq %rdx, %rsi
xorl %edx, %edx
call... | /sipsorcery[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_sha256_write | static void secp256k1_sha256_write(secp256k1_sha256 *hash, const unsigned char *data, size_t len) {
size_t bufsize = hash->bytes & 0x3F;
hash->bytes += len;
VERIFY_CHECK(hash->bytes >= len);
while (len >= 64 - bufsize) {
/* Fill the buffer, and process it. */
size_t chunk_len = 64 - bufs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x60(%rdi), %rax
movl %eax, %edi
andl $0x3f, %edi
addq %rdx, %rax
movq %rax, 0x60(%r15)
movl $0x40, %r12d
subq %rdi, %r12
cmpq %rdx, %r12
jbe 0x12c769
movq %r... | /sipsorcery[P]bitcoin/src/secp256k1/src/hash_impl.h |
secp256k1_ecdsa_recoverable_signature_parse_compact | int secp256k1_ecdsa_recoverable_signature_parse_compact(const secp256k1_context* ctx, secp256k1_ecdsa_recoverable_signature* sig, const unsigned char *input64, int recid) {
secp256k1_scalar r, s;
int ret = 1;
int overflow = 0;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(sig != NULL);
ARG_CHECK(input64... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl $0x0, 0xc(%rsp)
testq %rsi, %rsi
je 0x12f2b9
movq %rdx, %r14
testq %rdx, %rdx
je 0x12f2c0
movl %ecx, %ebp
cmpl $0x4, %ecx
jae 0x12f2c7
movq %rsi, %rbx
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x1268ce
mo... | /sipsorcery[P]bitcoin/src/secp256k1/src/modules/recovery/main_impl.h |
secp256k1_ecdsa_recoverable_signature_convert | int secp256k1_ecdsa_recoverable_signature_convert(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const secp256k1_ecdsa_recoverable_signature* sigin) {
secp256k1_scalar r, s;
int recid;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(sig != NULL);
ARG_CHECK(sigin != NULL);
secp256k1_ecdsa_r... | subq $0x28, %rsp
testq %rsi, %rsi
je 0x12f397
testq %rdx, %rdx
je 0x12f39e
movups 0x20(%rdx), %xmm0
movups 0x30(%rdx), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm... | /sipsorcery[P]bitcoin/src/secp256k1/src/modules/recovery/main_impl.h |
secp256k1_xonly_pubkey_tweak_add_check | int secp256k1_xonly_pubkey_tweak_add_check(const secp256k1_context* ctx, const unsigned char *tweaked_pubkey32, int tweaked_pk_parity, const secp256k1_xonly_pubkey *internal_pubkey, const unsigned char *tweak32) {
secp256k1_ge pk;
unsigned char pk_expected32[32];
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(in... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
testq %rcx, %rcx
je 0x130268
movq %rsi, %r14
testq %rsi, %rsi
je 0x13026f
movq %r8, %r12
testq %r8, %r8
je 0x130276
movl %edx, %ebx
leaq 0x20(%rsp), %rsi
movq %rcx, %rdx
callq 0x1263b7
xorl %r15d, %r15d
testl %eax, %eax
je 0x130259
leaq 0x20(%rsp), %rdi
movq ... | /sipsorcery[P]bitcoin/src/secp256k1/src/modules/extrakeys/main_impl.h |
secp256k1_keypair_pub | int secp256k1_keypair_pub(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const secp256k1_keypair *keypair) {
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(pubkey != NULL);
memset(pubkey, 0, sizeof(*pubkey));
ARG_CHECK(keypair != NULL);
memcpy(pubkey->data, &keypair->data[32], sizeof(*pubkey));
... | pushq %rax
testq %rsi, %rsi
je 0x1304f5
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsi)
movups %xmm0, 0x20(%rsi)
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
testq %rdx, %rdx
je 0x1304fc
movups 0x20(%rdx), %xmm0
movups 0x30(%rdx), %xmm1
movups 0x40(%rdx), %xmm2
movups 0x50(%rdx), %xmm3
movups %xmm3, 0x30(%rsi)
movups %xmm... | /sipsorcery[P]bitcoin/src/secp256k1/src/modules/extrakeys/main_impl.h |
secp256k1_der_read_len | static int secp256k1_der_read_len(size_t *len, const unsigned char **sigp, const unsigned char *sigend) {
size_t lenleft;
unsigned char b1;
VERIFY_CHECK(len != NULL);
*len = 0;
if (*sigp >= sigend) {
return 0;
}
b1 = *((*sigp)++);
if (b1 == 0xFF) {
/* X.690-0207 8.1.3.5.c... | movq $0x0, (%rdi)
movq (%rsi), %rcx
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x13cb6f
leaq 0x1(%rcx), %r9
movq %r9, (%rsi)
movzbl (%rcx), %r8d
cmpq $0xff, %r8
je 0x13cb6f
testb %r8b, %r8b
js 0x13cb08
movq %r8, (%rdi)
movl $0x1, %eax
retq
cmpl $0x80, %r8d
je 0x13cb6f
andl $0x7f, %r8d
subq %r9, %rdx
cmpq %r8, %rdx
jb 0x13cb6f... | /sipsorcery[P]bitcoin/src/secp256k1/src/ecdsa_impl.h |
secp256k1_der_parse_integer | static int secp256k1_der_parse_integer(secp256k1_scalar *r, const unsigned char **sig, const unsigned char *sigend) {
int overflow = 0;
unsigned char ra[32] = {0};
size_t rlen;
if (*sig == sigend || **sig != 0x02) {
/* Not a primitive integer (X.690-0207 8.3.1). */
return 0;
}
(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl $0x0, 0x4(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq (%rsi), %rax
xorl %ebp, %ebp
cmpq %rdx, %rax
je 0x13cc76
cmpb $0x2, (%rax)
jne 0x13cc76
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
incq %rax
movq %r... | /sipsorcery[P]bitcoin/src/secp256k1/src/ecdsa_impl.h |
secp256k1_gej_eq_x_var | static int secp256k1_gej_eq_x_var(const secp256k1_fe *x, const secp256k1_gej *a) {
secp256k1_fe r;
SECP256K1_FE_VERIFY(x);
SECP256K1_GEJ_VERIFY(a);
VERIFY_CHECK(!a->infinity);
secp256k1_fe_sqr(&r, &a->z); secp256k1_fe_mul(&r, &r, x);
return secp256k1_fe_equal(&r, &a->x);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x50(%rsi), %rcx
movq 0x58(%rsi), %r10
movq %r10, 0x8(%rsp)
movq 0x68(%rsi), %r13
movq %rsi, %r9
leaq (%rcx,%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq %r13, %rax
movq %r13, 0x18(%rsp)
mulq %rdx
movq %rax, %rsi
movq %rdx, %r8
movq 0x60(%... | /sipsorcery[P]bitcoin/src/secp256k1/src/group_impl.h |
hts_idx_getfn | char *hts_idx_getfn(const char *fn, const char *ext)
{
int i, l_fn, l_ext;
char *fnidx, *ret;
l_fn = strlen(fn); l_ext = strlen(ext);
fnidx = (char*)calloc(l_fn + l_ext + 1, 1);
strcpy(fnidx, fn); strcpy(fnidx + l_fn, ext);
if ((ret = test_and_fetch(fnidx)) == 0) {
for (i = l_fn - 1; i >... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x91b0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x91b0
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x92f0
mov... | /gatoravi[P]bam-parser-tutorial/htslib/hts.c |
test_and_fetch | static char *test_and_fetch(const char *fn)
{
FILE *fp;
if (hisremote(fn)) {
const int buf_size = 1 * 1024 * 1024;
hFILE *fp_remote;
uint8_t *buf;
int l;
const char *p;
for (p = fn + strlen(fn) - 1; p >= fn; --p)
if (*p == '/') break;
++p; // p... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14100
cmpl $0x0, %eax
je 0x1233d
movl $0x100000, -0x1c(%rbp) # imm = 0x100000
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x91b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
addq $... | /gatoravi[P]bam-parser-tutorial/htslib/hts.c |
kputsn | static inline int kputsn(const char *p, int l, kstring_t *s)
{
if (s->l + l + 1 >= s->m) {
char *tmp;
s->m = s->l + l + 2;
kroundup32(s->m);
if ((tmp = (char*)realloc(s->s, s->m)))
s->s = tmp;
else
return EOF;
}
memcpy(s->s + s->l, p, l);
s->l += l;
s->s[s->l] = 0;
return l;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x1258c
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movslq -0x14(... | /gatoravi[P]bam-parser-tutorial/htslib/htslib/kstring.h |
hread | static inline ssize_t HTS_RESULT_USED
hread(hFILE *fp, void *buffer, size_t nbytes)
{
extern ssize_t hread2(hFILE *, void *, size_t, size_t);
size_t n = fp->end - fp->begin;
if (n > nbytes) n = nbytes;
memcpy(buffer, fp->begin, n);
fp->begin += n;
return (n == nbytes)? (ssize_t) n : hread2(fp, ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x131ad
movq -0x18(%rbp), %rax
m... | /gatoravi[P]bam-parser-tutorial/htslib/htslib/hfile.h |
bam_index_build | int bam_index_build(const char *fn, int min_shift)
{
hts_idx_t *idx;
htsFile *fp;
int ret = 0;
if ((fp = hts_open(fn, "r")) == 0) return -1;
switch (fp->format.format) {
case cram:
ret = cram_index_build(fp->fp.cram, fn);
break;
case bam:
idx = bam_index(fp->fp.bgzf... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x55a2a(%rip), %rsi # 0x6cedb
callq 0xc470
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x174cc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1755f
movq -0x28(%rbp), %ra... | /gatoravi[P]bam-parser-tutorial/htslib/sam.c |
bam_index | static hts_idx_t *bam_index(BGZF *fp, int min_shift)
{
int n_lvls, i, fmt;
bam1_t *b;
hts_idx_t *idx;
bam_hdr_t *h;
h = bam_hdr_read(fp);
if (min_shift > 0) {
int64_t max_len = 0, s;
for (i = 0; i < h->n_targets; ++i)
if (max_len < h->target_len[i]) max_len = h->targe... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16200
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x17639
movq $0x0, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x175e8
movq -0x40(%r... | /gatoravi[P]bam-parser-tutorial/htslib/sam.c |
sam_index_load | hts_idx_t *sam_index_load(samFile *fp, const char *fn)
{
switch (fp->format.format) {
case bam:
return bam_index_load(fn);
case cram: {
if (cram_index_load(fp->fp.cram, fn) < 0) return NULL;
// Cons up a fake "index" just pointing at the associated cram_fd:
hts_cram_idx_t *i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x4, %eax
je 0x177eb
jmp 0x177e1
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0x177ff
jmp 0x17862
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x12380
movq %ra... | /gatoravi[P]bam-parser-tutorial/htslib/sam.c |
sam_bam_cram_readrec | static int sam_bam_cram_readrec(BGZF *bgzfp, void *fpv, void *bv, int *tid, int *beg, int *end)
{
htsFile *fp = fpv;
bam1_t *b = bv;
switch (fp->format.format) {
case bam: return bam_read1(bgzfp, b);
case cram: return cram_get_bam_seq(fp->fp.cram, &b);
default:
// TODO Need headers av... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movl 0x44(%rax), %eax
mov... | /gatoravi[P]bam-parser-tutorial/htslib/sam.c |
bam_readrec | static int bam_readrec(BGZF *fp, void *ignored, void *bv, int *tid, int *beg, int *end)
{
bam1_t *b = bv;
int ret;
if ((ret = bam_read1(fp, b)) >= 0) {
*tid = b->core.tid; *beg = b->core.pos;
*end = b->core.pos + (b->core.n_cigar? bam_cigar2rlen(b->core.n_cigar, bam_get_cigar(b)) : 1);
}... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x16b40
movl %eax, -0x3c(%rbp)
cmpl $0x0, %e... | /gatoravi[P]bam-parser-tutorial/htslib/sam.c |
sam_hdr_parse | bam_hdr_t *sam_hdr_parse(int l_text, const char *text)
{
const char *q, *r, *p;
khash_t(s2i) *d;
d = kh_init(s2i);
for (p = text; *p; ++p) {
if (strncmp(p, "@SQ", 3) == 0) {
char *sn = 0;
int ln = -1;
for (q = p + 4;; ++q) {
if (strncmp(q, "SN:... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xaa80
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x17f79
movq -0x28(%rbp), %rdi
leaq 0x54c29(%rip), %rsi # 0x6c971
movl $0x3, %edx
callq 0x9210
cmpl $... | /gatoravi[P]bam-parser-tutorial/htslib/sam.c |
sam_hdr_read | bam_hdr_t *sam_hdr_read(htsFile *fp)
{
switch (fp->format.format) {
case bam:
return bam_hdr_read(fp->fp.bgzf);
case cram:
return cram_header_to_bam(fp->fp.cram->header);
case sam: {
kstring_t str;
bam_hdr_t *h;
int has_SQ = 0;
str.l = str.m = 0; str.s =... | pushq %rbp
movq %rsp, %rbp
subq $0x860, %rsp # imm = 0x860
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x85c(%rbp)
subl $0x3, %eax
je 0x18140
jmp 0x180f3
movl -0x85c(%rbp), %eax
subl $0x4, %eax
je 0x18110
jmp 0x18100
movl -0x85c(%rbp), %eax
subl $0x6, %eax
je 0x18126
jmp 0... | /gatoravi[P]bam-parser-tutorial/htslib/sam.c |
kputsn | static inline int kputsn(const char *p, int l, kstring_t *s)
{
if (s->l + l + 1 >= s->m) {
char *tmp;
s->m = s->l + l + 2;
kroundup32(s->m);
if ((tmp = (char*)realloc(s->s, s->m)))
s->s = tmp;
else
return EOF;
}
memcpy(s->s + s->l, p, l);
s->l += l;
s->s[s->l] = 0;
return l;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x1843c
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movslq -0x14(... | /gatoravi[P]bam-parser-tutorial/htslib/htslib/kstring.h |
sam_hdr_write | int sam_hdr_write(htsFile *fp, const bam_hdr_t *h)
{
switch (fp->format.format) {
case binary_format:
fp->format.category = sequence_data;
fp->format.format = bam;
/* fall-through */
case bam:
bam_hdr_write(fp->fp.bgzf, h);
break;
case cram: {
cram_fd *fd... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x5, %eax
ja 0x18811
movq -0x38(%rbp), %rax
leaq 0x54209(%rip), %rcx # 0x6c81c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq... | /gatoravi[P]bam-parser-tutorial/htslib/sam.c |
kputw | static inline int kputw(int c, kstring_t *s)
{
char buf[16];
int i, l = 0;
unsigned int x = c;
if (c < 0) x = -x;
do { buf[l++] = x%10 + '0'; x /= 10; } while (x > 0);
if (c < 0) buf[l++] = '-';
if (s->l + l + 1 >= s->m) {
char *tmp;
s->m = s->l + l + 2;
kroundup32(s->m);
if ((tmp = (char*)realloc(s->s, ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x1893a
xorl %eax, %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1893c
movl -0x2c(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
... | /gatoravi[P]bam-parser-tutorial/htslib/htslib/kstring.h |
bam_plp_auto | const bam_pileup1_t *bam_plp_auto(bam_plp_t iter, int *_tid, int *_pos, int *_n_plp)
{
const bam_pileup1_t *plp;
if (iter->func == 0 || iter->error) { *_n_plp = -1; return 0; }
if ((plp = bam_plp_next(iter, _tid, _pos, _n_plp)) != 0) return plp;
else { // no pileup line can be obtained; read alignments
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x1d57d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x1d594
movq -0x28(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
m... | /gatoravi[P]bam-parser-tutorial/htslib/sam.c |
cram_byte_array_len_decode_init | cram_codec *cram_byte_array_len_decode_init(char *data, int size,
enum cram_external_type option,
int version) {
cram_codec *c;
char *cp = data;
int32_t encoding;
int32_t sub_size;
if (!(c = malloc(sizeof(*c))))
return NULL;
c->codec = E_BYTE_ARRAY_LEN;
c->decode = cram... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x240, %edi # imm = 0x240
callq 0x9670
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x68811
movq $0x0, -0x8(%rbp)
jmp 0x68e... | /gatoravi[P]bam-parser-tutorial/htslib/cram/cram_codecs.c |
main | int main() {
{
acto::actor_ref analizer = acto::spawn< Analizer >(acto::actor_thread::exclusive);
// -
std::cout << "Statistic is being collected." << std::endl;
std::cout << "Please wait some seconds..." << std::endl;
// Запустить выполнение примера
analizer.send(msg_start());
acto::this... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x35a0
movq 0x27b34(%rip), %rdi # 0x2afd8
leaq 0x16bbd(%rip), %rsi # 0x1a068
callq 0x31c0
movq %rax, -0x38(%rbp)
jmp 0x34b6
movq -0x38(%rbp), %rdi
movq 0x27aff(%rip), %rsi # 0x2afc0
callq 0x31f0
jm... | /artpaul[P]acto/samples/cycles.cpp |
bool acto::actor_ref::send<msg_start>(msg_start&&) const | inline bool send(Msg&& msg) const {
if (!object_) {
return false;
}
return send_message(
std::make_unique<core::msg_wrap_t<std::remove_cvref_t<Msg>>>(
std::forward<Msg>(msg)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
jne 0x36a4
movb $0x0, -0x1(%rbp)
jmp 0x3714
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3820
movq -0x58(%rbp), %rsi
leaq -0x20(%rbp),... | /artpaul[P]acto/include/acto/acto.h |
bool acto::actor_ref::send<msg_stop>(msg_stop&&) const | inline bool send(Msg&& msg) const {
if (!object_) {
return false;
}
return send_message(
std::make_unique<core::msg_wrap_t<std::remove_cvref_t<Msg>>>(
std::forward<Msg>(msg)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
jne 0x3794
movb $0x0, -0x1(%rbp)
jmp 0x3804
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4110
movq -0x58(%rbp), %rsi
leaq -0x20(%rbp),... | /artpaul[P]acto/include/acto/acto.h |
Listener::Listener() | Listener()
: m_active(false)
, m_counter(0)
{
handler< msg_loop >(&Listener::doLoop);
handler< msg_start >(&Listener::doStart);
handler< msg_stop >(&Listener::doStop);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4a10
movq -0x50(%rbp), %rdi
leaq 0x2348c(%rip), %rax # 0x2a920
movq %rax, (%rdi)
movb $0x0, 0x51(%rdi)
movq $0x0, 0x58(%rdi)
leaq 0x196(%rip), %rax # 0x7640
movq %rax, -0x18(%rbp)
movq $0x0, ... | /artpaul[P]acto/samples/cycles.cpp |
bool acto::actor_ref::send<msg_loop>(msg_loop&&) const | inline bool send(Msg&& msg) const {
if (!object_) {
return false;
}
return send_message(
std::make_unique<core::msg_wrap_t<std::remove_cvref_t<Msg>>>(
std::forward<Msg>(msg)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
jne 0x8744
movb $0x0, -0x1(%rbp)
jmp 0x87b4
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x87d0
movq -0x58(%rbp), %rsi
leaq -0x20(%rbp),... | /artpaul[P]acto/include/acto/acto.h |
acto::actor::mem_handler_t<msg_stop, Listener, msg_stop const&>::mem_handler_t(std::function<void (Listener*, acto::actor_ref, msg_stop const&)>&&, Listener*) | mem_handler_t(F&& func, C* ptr) noexcept
: func_(std::move(func))
, ptr_(ptr) {
assert(func_);
assert(ptr_);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x5ab0
movq -0x20(%rbp), %rdi
leaq 0x20d8c(%rip), %rax # 0x2aaf8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xa280
m... | /artpaul[P]acto/include/acto/acto.h |
acto::core::(anonymous namespace)::binding_context_t::~binding_context_t() | ~binding_context_t() {
// Mark all actors as deleting to prevent message loops.
for (auto* obj : actors) {
runtime_t::instance()->deconstruct_object(obj);
}
process_actors(true);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13da0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13dd0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
call... | /artpaul[P]acto/src/runtime.cpp |
acto::intrusive::queue<acto::core::object_t, acto::intrusive::spin_lock>::queue() | sequence<T> extract() {
std::lock_guard g(mutex_);
if (tail_) {
T* head = tail_->next;
tail_->next = nullptr;
tail_ = nullptr;
return sequence<T>(head);
}
return nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq $0x0, (%rdi)
addq $0x8, %rdi
callq 0x14170
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /artpaul[P]acto/include/acto/intrusive.h |
acto::intrusive::spin_lock::unlock() | void unlock() noexcept {
flag_.clear(std::memory_order_release);
#if defined(__cpp_lib_atomic_wait) && __cpp_lib_atomic_wait >= 201907L
flag_.notify_one();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rax, -0x10(%rbp)
movl $0x3, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
movl $0xffff, %esi # imm = 0xFFFF
callq 0x106b0
movl %eax, -0x18(%rbp)
movl -0x14(... | /artpaul[P]acto/include/acto/intrusive.h |
acto::core::worker_t::process() | bool worker_t::process() {
while (object_t* const obj = object_) {
bool need_delete = false;
while (true) {
// Handle a message.
if (auto msg = obj->select_message()) {
slots_->handle_message(obj, std::move(msg));
// Continue processing messages if the object is bound to the threa... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x17efa
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xe2e0
leaq -0x28(%rbp), %rdi
... | /artpaul[P]acto/src/worker.cpp |
test | int test(char *URL)
{
int res = 0;
CURLM *m = NULL;
CURLMsg *msg; /* for picking up messages with the transfer status */
int msgs_left; /* how many messages are left */
int running;
int handlenum = 0;
struct timeval last_handle_add;
if(parse_url_file(libtest_arg2) <= 0)
goto test_cleanup;
start_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, %rbx
leaq 0x3f09(%rip), %rax # 0x6220
movq (%rax), %rdi
xorl %r15d, %r15d
movl %r15d, 0x2f3c(%rip) # 0x5260
movl %r15d, 0x38a5(%rip) # 0x5bd0
leaq 0xe2e(%rip), %rsi # 0x3160
callq 0... | /macressler[P]curl/tests/libtest/lib1900.c |
setup_handle | static void setup_handle(char *base_url, CURLM *m, int handlenum)
{
char urlbuf[256];
snprintf(urlbuf, sizeof(urlbuf), "%s%s", base_url, urlstring[handlenum]);
curl_easy_setopt(handles[handlenum], CURLOPT_URL, urlbuf);
curl_easy_setopt(handles[handlenum], CURLOPT_VERBOSE, 1L);
curl_easy_setopt(handles[handle... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %rbx
movq %rdi, %rcx
movslq %edx, %r15
leaq 0x2ffd(%rip), %rax # 0x5be0
movq (%rax,%r15,8), %r8
leaq 0x58f(%rip), %rdx # 0x317d
movq %rsp, %r14
movl $0x100, %esi # imm = 0x100
movq %r14, %rdi
xorl %ea... | /macressler[P]curl/tests/libtest/lib1900.c |
select_wrapper | int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset... | testl %edi, %edi
jns 0x20d0
pushq %rax
callq 0x2030
movl $0x16, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
| /macressler[P]curl/tests/libtest/first.c |
hexdump | char *hexdump(const unsigned char *buffer, size_t len)
{
static char dump[200 * 3 + 1];
char *p = dump;
size_t i;
if(len > 200)
return NULL;
for(i = 0; i<len; i++, p += 3)
snprintf(p, 4, "%02x ", buffer[i]);
return dump;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0xc8, %rsi
jbe 0x2d0f
xorl %ebx, %ebx
jmp 0x2d59
movq %rsi, %r14
testq %rsi, %rsi
je 0x2d52
movq %rdi, %r15
leaq 0x350f(%rip), %rbx # 0x6230
leaq 0x45a(%rip), %r12 # 0x3182
xorl %ebp, %ebp
movq %rbx, %r13
movzbl (%r15,%rbp), %... | /macressler[P]curl/tests/libtest/first.c |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x33f(%rip), %rsi # 0x30b9
movl $0x6, %edi
callq 0x20b0
cmpl $0x1, %ebp
jg 0x2dad
movq 0x2250(%rip), %rax # 0x4fe0
movq (%rax), %rdi
leaq 0x3ee(%rip), %rsi # 0x3188
xorl %eax, %eax
callq 0x2130
movl $0x1, %eax
addq $0x8, %rsp
popq %r... | /macressler[P]curl/tests/libtest/first.c |
tutil_tvnow | struct timeval tutil_tvnow(void)
{
/*
** gettimeofday() is not granted to be increased monotonically, due to
** clock drifting and external source time synchronization it can jump
** forward or backward in time.
*/
struct timeval now;
(void)gettimeofday(&now, NULL);
return now;
} | pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21b0
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
| /macressler[P]curl/tests/libtest/testutil.c |
curlx_ultous | unsigned short curlx_ultous(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(ulnum & (unsigned long) CURL_MASK_USHORT);
#ifdef __IN... | movq %rdi, %rax
retq
| /macressler[P]curl/lib/warnless.c |
curlx_ultouc | unsigned char curlx_ultouc(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_UCHAR);
return (unsigned char)(ulnum & (unsigned long) CURL_MASK_UCHAR);
#ifdef __INTEL_... | movq %rdi, %rax
retq
| /macressler[P]curl/lib/warnless.c |
curlx_ultosi | int curlx_ultosi(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_SINT);
return (int)(ulnum & (unsigned long) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma war... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /macressler[P]curl/lib/warnless.c |
curlx_uztoso | curl_off_t curlx_uztoso(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#elif defined(_MSC_VER)
# pragma warning(push)
# pragma warning(disable:4310) /* cast truncates constant value */
#endif
DEBUGASSERT(uznum <= (size_t) CU... | movq %rdi, %rax
btrq $0x3f, %rax
retq
| /macressler[P]curl/lib/warnless.c |
curlx_uztosi | int curlx_uztosi(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SINT);
return (int)(uznum & (size_t) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /macressler[P]curl/lib/warnless.c |
curlx_uztoui | unsigned int curlx_uztoui(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT(uznum <= (size_t) CURL_MASK_UINT);
#endif
return (unsigned int)(uznum & (size_t) CURL_MASK_UINT);
#i... | movq %rdi, %rax
retq
| /macressler[P]curl/lib/warnless.c |
curlx_sztosi | int curlx_sztosi(ssize_t sznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sznum >= 0);
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
#endif
return (int)(sznum & (ssize_t... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /macressler[P]curl/lib/warnless.c |
curlx_uitous | unsigned short curlx_uitous(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_USHORT);
return (unsigned short) (uinum & (unsigned int) CURL_MASK_USHORT);
#ifdef __INTE... | movl %edi, %eax
retq
| /macressler[P]curl/lib/warnless.c |
curlx_uitouc | unsigned char curlx_uitouc(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_UCHAR);
return (unsigned char) (uinum & (unsigned int) CURL_MASK_UCHAR);
#ifdef __INTEL_CO... | movl %edi, %eax
retq
| /macressler[P]curl/lib/warnless.c |
transform_suite::test_add_const() | void test_add_const()
{
using typelist = meta::list<bool, int>;
using constlist = meta::transform<typelist, std::add_const>;
TRIAL_PROTOCOL_TEST_EQUAL((meta::to_index<constlist, bool>::value), 2);
TRIAL_PROTOCOL_TEST_EQUAL((meta::to_index<constlist, const bool>::value), 0);
TRIAL_PROTOCOL_TEST_EQUAL... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x2, -0x8(%rbp)
leaq 0xd7e(%rip), %rdi # 0x2004
leaq 0xda0(%rip), %rsi # 0x202d
leaq 0xd9b(%rip), %rdx # 0x202f
movl $0x1c, %ecx
leaq 0xdf0(%rip), %r8 # 0x2090
leaq 0xff9(%rip), %r9 # 0x22a0
leaq -0x8(%rbp), %rax
movq %rax, (%rsp)
callq 0... | /breese[P]trial/test/core/detail/meta_suite.cpp |
vstr_to_float(char const*) | static float vstr_to_float(const char vstr[16])
{
double v = 0.0;
const char* p = vstr;
// sign
bool sign = *p != '-';
if (*p == '+' || *p == '-')
{
p++;
}
// digits before decimal point or exponent
unsigned int v1 = 0;
while (isdigit(*p))
{
v1 = v1 * 10 + ... | movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x3a3b1
cmpl $0x2b, %eax
jne 0x3a3b4
incq %rdi
xorl %edx, %edx
movsbl (%rdi), %ecx
leal -0x30(%rcx), %esi
cmpl $0x9, %esi
ja 0x3a3cd
imull $0xa, %edx, %ecx
addl %ecx, %esi
incq %rdi
movl %esi, %edx
jmp 0x3a3b6
movl %edx, %edx
cvtsi2sd %rdx, %xmm0
cmpb $0x2e, %cl
jne 0x3a415
incq ... | /tpoisonooo[P]ncnn/tools/ncnn2mem.cpp |
ncnn::Mat::create(int, int, unsigned long, ncnn::Allocator*) | void Mat::create(int _w, int _h, size_t _elemsize, Allocator* _allocator)
{
if (dims == 2 && w == _w && h == _h && elemsize == _elemsize && elempack == 1 && allocator == _allocator)
return;
release();
elemsize = _elemsize;
elempack = 1;
allocator = _allocator;
dims = 2;
w = _w;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
cmpl $0x2, 0x28(%rdi)
jne 0x470ed
cmpl %r12d, 0x2c(%rbx)
jne 0x470ed
cmpl %ebp, 0x30(%rbx)
jne 0x470ed
cmpq %r15, 0x10(%rbx)
jne 0x470ed
cmpl $0x1, 0x18(%rbx)
jne 0x470ed
cmpq %r14, 0x2... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::Mat::create(int, int, int, unsigned long, ncnn::Allocator*) | void Mat::create(int _w, int _h, int _c, size_t _elemsize, Allocator* _allocator)
{
if (dims == 3 && w == _w && h == _h && c == _c && elemsize == _elemsize && elempack == 1 && allocator == _allocator)
return;
release();
elemsize = _elemsize;
elempack = 1;
allocator = _allocator;
dims ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
cmpl $0x3, 0x28(%rdi)
jne 0x471c1
cmpl %r13d, 0x2c(%rbx)
jne 0x471c1
cmpl %r12d, 0x30(%rbx)
jne 0x471c1
cmpl %ebp, 0x38(%rbx)
jne 0x471c1
cmpq %r15... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::Mat::create(int, int, int, int, unsigned long, ncnn::Allocator*) | void Mat::create(int _w, int _h, int _d, int _c, size_t _elemsize, Allocator* _allocator)
{
if (dims == 4 && w == _w && h == _h && d == _d && c == _c && elemsize == _elemsize && elempack == 1 && allocator == _allocator)
return;
release();
elemsize = _elemsize;
elempack = 1;
allocator = _al... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movl %r8d, %ebp
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, %rbx
movq 0x40(%rsp), %rcx
movdqu 0x28(%rdi), %xmm0
movd %r12d, %xmm1
movd %edx, %xmm2
punpckldq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::Mat::create_like(ncnn::Mat const&, ncnn::Allocator*) | void Mat::create_like(const Mat& m, Allocator* _allocator)
{
int _dims = m.dims;
if (_dims == 1)
create(m.w, m.elemsize, m.elempack, _allocator);
if (_dims == 2)
create(m.w, m.h, m.elemsize, m.elempack, _allocator);
if (_dims == 3)
create(m.w, m.h, m.c, m.elemsize, m.elempack, _a... | pushq %rax
movl 0x28(%rsi), %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0x473f5
movq %rdx, %rax
leaq 0x1872bf(%rip), %rdx # 0x1ce650
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x2c(%rsi), %r8d
movq 0x10(%rsi), %rdx
movl 0x18(%rsi), %ecx
movl %r8d, %esi
movq %rax, %r8
popq %rax
jmp 0x465fc
movl 0x2c(%rsi), %r10... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::Mat::substract_mean_normalize(float const*, float const*) | void Mat::substract_mean_normalize(const float* mean_vals, const float* norm_vals)
{
Layer* op;
if (mean_vals && !norm_vals)
{
// substract mean only
op = create_layer(LayerType::Bias);
ParamDict pd;
pd.set(0, c);
op->load_param(pd);
Mat weights[1];
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
setne %cl
orb %al, %cl
je 0x474ff
movq %rdx, %r12
testq %rdx, %rdx
sete %al
testq %r15, %r15
setne %cl
orb %al, %cl
jne 0x475d3
pushq $0x1d
popq %rdi
callq 0x3d2f3
movq %rax... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::float16_to_float32(unsigned short) | float float16_to_float32(unsigned short value)
{
// 1 : 5 : 10
unsigned short sign = (value & 0x8000) >> 15;
unsigned short exponent = (value & 0x7c00) >> 10;
unsigned short significand = value & 0x03FF;
// NCNN_LOGE("%d %d %d", sign, exponent, significand);
// 1 : 8 : 23
union
{
... | movl %edi, %eax
shrl $0xf, %eax
movl %edi, %ecx
shrl $0xa, %ecx
andl $0x1f, %ecx
cmpw $0x1f, %cx
je 0x47918
andl $0x3ff, %edi # imm = 0x3FF
testl %ecx, %ecx
jne 0x4792d
testw %di, %di
je 0x47965
xorl %ecx, %ecx
btl $0x9, %edi
leal (%rdi,%rdi), %edx
movl %edx, %edi
jb 0x47947
incl %ecx
jmp 0x47909
shll $0x1f,... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::float32_to_float16(float) | unsigned short float32_to_float16(float value)
{
// 1 : 8 : 23
union
{
unsigned int u;
float f;
} tmp;
tmp.f = value;
// 1 : 8 : 23
unsigned short sign = (tmp.u & 0x80000000) >> 31;
unsigned short exponent = (tmp.u & 0x7F800000) >> 23;
unsigned int significand = tmp... | movd %xmm0, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
movl %ecx, %edx
shrl $0x17, %edx
andl $0x7fffff, %ecx # imm = 0x7FFFFF
cmpb $-0x1, %dl
je 0x4799e
movzbl %dl, %esi
shll $0xf, %eax
testl %esi, %esi
je 0x4799d
cmpl $0x8f, %esi
jb 0x479b3
orl $0x7c00, %eax # imm = 0x7C00
retq
shll $0xf, %eax
xorl %edx, ... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::copy_make_border(ncnn::Mat const&, ncnn::Mat&, int, int, int, int, int, float, ncnn::Option const&) | void copy_make_border(const Mat& src, Mat& dst, int top, int bottom, int left, int right, int type, float v, const Option& opt)
{
Layer* padding = create_layer(LayerType::Padding);
ParamDict pd;
pd.set(0, top);
pd.set(1, bottom);
pd.set(2, left);
pd.set(3, right);
pd.set(4, type);
pd.se... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm0, 0x14(%rsp)
movl %r9d, %ebp
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %r14d
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
pushq $0x2b
popq %rdi
callq 0x3d2f3
movq %rax, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x49b10
movq... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::copy_make_border_3d(ncnn::Mat const&, ncnn::Mat&, int, int, int, int, int, int, int, float, ncnn::Option const&) | void copy_make_border_3d(const Mat& src, Mat& dst, int top, int bottom, int left, int right, int front, int behind, int type, float v, const Option& opt)
{
Layer* padding = create_layer(LayerType::Padding);
ParamDict pd;
pd.set(0, top);
pd.set(1, bottom);
pd.set(2, left);
pd.set(3, right);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm0, 0x14(%rsp)
movl %r9d, %ebp
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %r14d
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
pushq $0x2b
popq %rdi
callq 0x3d2f3
movq %rax, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x49b10
movq... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::copy_cut_border(ncnn::Mat const&, ncnn::Mat&, int, int, int, int, ncnn::Option const&) | void copy_cut_border(const Mat& src, Mat& dst, int top, int bottom, int left, int right, const Option& opt)
{
if (left + right > src.w || top + bottom > src.h)
{
NCNN_LOGE("copy_cut_border parameter error, top: %d, bottom: %d, left: %d, right: %d, src.w: %d, src.h: %d", top, bottom, left, right, src.w, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %edx, %r13d
movq %rdi, %r14
leal (%r9,%rbp), %edx
movl 0x2c(%rdi), %r10d
cmpl %r10d, %edx
jg 0x47d1f
leal (%rcx,%r13), %eax
movl 0x30(%r14), %r11d
cmpl %r11d, %eax
jg 0x47d23
movl %edx, 0x1c(%rsp)
movl %eax, 0x18(%rs... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::resize_nearest(ncnn::Mat const&, ncnn::Mat&, int, int, ncnn::Option const&) | void resize_nearest(const Mat& src, Mat& dst, int w, int h, const Option& opt)
{
Layer* interp = create_layer(LayerType::Interp);
ParamDict pd;
pd.set(0, 1);
pd.set(3, h);
pd.set(4, w);
interp->load_param(pd);
interp->create_pipeline(opt);
interp->forward(src, dst, opt);
interp-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %r13d
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
pushq $0x32
popq %rdi
callq 0x3d2f3
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x49b10
pushq $0x1
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::resize_bilinear(ncnn::Mat const&, ncnn::Mat&, int, int, ncnn::Option const&) | void resize_bilinear(const Mat& src, Mat& dst, int w, int h, const Option& opt)
{
Layer* interp = create_layer(LayerType::Interp);
ParamDict pd;
pd.set(0, 2);
pd.set(3, h);
pd.set(4, w);
interp->load_param(pd);
interp->create_pipeline(opt);
interp->forward(src, dst, opt);
interp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %r13d
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
pushq $0x32
popq %rdi
callq 0x3d2f3
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x49b10
pushq $0x2
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::resize_bicubic(ncnn::Mat const&, ncnn::Mat&, int, int, ncnn::Option const&) | void resize_bicubic(const Mat& src, Mat& dst, int w, int h, const Option& opt)
{
Layer* interp = create_layer(LayerType::Interp);
ParamDict pd;
pd.set(0, 3);
pd.set(3, h);
pd.set(4, w);
interp->load_param(pd);
interp->create_pipeline(opt);
interp->forward(src, dst, opt);
interp-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %r13d
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
pushq $0x32
popq %rdi
callq 0x3d2f3
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x49b10
pushq $0x3
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::convert_packing(ncnn::Mat const&, ncnn::Mat&, int, ncnn::Option const&) | void convert_packing(const Mat& src, Mat& dst, int _elempack, const Option& opt)
{
Layer* packing = create_layer(LayerType::Packing);
ParamDict pd;
pd.set(0, _elempack);
packing->load_param(pd);
packing->create_pipeline(opt);
packing->forward(src, dst, opt);
packing->destroy_pipeline(op... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
pushq $0x3e
popq %rdi
callq 0x3d2f3
movq %rax, %r14
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x49b10
movq %r13, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x49d7e
movq (%r... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::flatten(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | void flatten(const Mat& src, Mat& dst, const Option& opt)
{
Layer* flatten = create_layer(LayerType::Flatten);
ParamDict pd;
flatten->load_param(pd);
flatten->create_pipeline(opt);
flatten->forward(src, dst, opt);
flatten->destroy_pipeline(opt);
delete flatten;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0xe
popq %rdi
callq 0x3d2f3
movq %rax, %rbx
movq %rsp, %r13
movq %r13, %rdi
callq 0x49b10
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
m... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::cast_float16_to_float32(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | void cast_float16_to_float32(const Mat& src, Mat& dst, const Option& opt)
{
Layer* cast = create_layer(LayerType::Cast);
ParamDict pd;
pd.set(0, 2);
pd.set(1, 1);
cast->load_param(pd);
cast->create_pipeline(opt);
cast->forward(src, dst, opt);
cast->destroy_pipeline(opt);
delete... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x40
popq %rdi
callq 0x3d2f3
movq %rax, %rbx
movq %rsp, %r13
movq %r13, %rdi
callq 0x49b10
pushq $0x2
popq %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x49d7e
movq %rsp, %rdi
pushq $0x1
popq %rd... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::cast_int8_to_float32(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | void cast_int8_to_float32(const Mat& src, Mat& dst, const Option& opt)
{
Layer* cast = create_layer(LayerType::Cast);
ParamDict pd;
pd.set(0, 3);
pd.set(1, 1);
cast->load_param(pd);
cast->create_pipeline(opt);
cast->forward(src, dst, opt);
cast->destroy_pipeline(opt);
delete ca... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x40
popq %rdi
callq 0x3d2f3
movq %rax, %rbx
movq %rsp, %r13
movq %r13, %rdi
callq 0x49b10
pushq $0x3
popq %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x49d7e
movq %rsp, %rdi
pushq $0x1
popq %rd... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::cast_float32_to_bfloat16(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | void cast_float32_to_bfloat16(const Mat& src, Mat& dst, const Option& opt)
{
Layer* cast = create_layer(LayerType::Cast);
ParamDict pd;
pd.set(0, 1);
pd.set(1, 4);
cast->load_param(pd);
cast->create_pipeline(opt);
cast->forward(src, dst, opt);
cast->destroy_pipeline(opt);
delet... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x40
popq %rdi
callq 0x3d2f3
movq %rax, %rbx
movq %rsp, %r13
movq %r13, %rdi
callq 0x49b10
pushq $0x1
popq %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x49d7e
movq %rsp, %rdi
pushq $0x1
popq %rs... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::cast_bfloat16_to_float32(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | void cast_bfloat16_to_float32(const Mat& src, Mat& dst, const Option& opt)
{
Layer* cast = create_layer(LayerType::Cast);
ParamDict pd;
pd.set(0, 4);
pd.set(1, 1);
cast->load_param(pd);
cast->create_pipeline(opt);
cast->forward(src, dst, opt);
cast->destroy_pipeline(opt);
delet... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x40
popq %rdi
callq 0x3d2f3
movq %rax, %rbx
movq %rsp, %r13
movq %r13, %rdi
callq 0x49b10
pushq $0x4
popq %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x49d7e
movq %rsp, %rdi
pushq $0x1
popq %rd... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::quantize_to_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | void quantize_to_int8(const Mat& src, Mat& dst, const Mat& scale_data, const Option& opt)
{
Layer* quantize = create_layer(LayerType::Quantize);
ParamDict pd;
pd.set(0, scale_data.w);
quantize->load_param(pd);
Mat weights[1];
weights[0] = scale_data;
quantize->load_model(ModelBinFromMatA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
pushq $0x39
popq %rdi
callq 0x3d2f3
movq %rax, %r14
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x49b10
movl 0x2c(%r13), %edx
movq %rbp, %rdi
xorl %esi, %esi
callq 0x49d7e
m... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::dequantize_from_int32(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, ncnn::Option const&) | void dequantize_from_int32(const Mat& src, Mat& dst, const Mat& scale_data, const Mat& bias_data, const Option& opt)
{
Layer* dequantize = create_layer(LayerType::Dequantize);
ParamDict pd;
pd.set(0, scale_data.w);
pd.set(1, bias_data.w);
dequantize->load_param(pd);
Mat weights[2];
weight... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, 0x18(%rsp)
movq %rdi, %r12
pushq $0x3a
popq %rdi
callq 0x3d2f3
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x49b10
movl 0x2c(%rbp), %edx
movq %r15, %rdi
xorl %esi, ... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::requantize_from_int32_to_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat const&, int, ncnn::Mat const&, ncnn::Option const&) | void requantize_from_int32_to_int8(const Mat& src, Mat& dst, const Mat& scale_in_data, const Mat& scale_out_data, const Mat& bias_data, int activation_type, const Mat& activation_params, const Option& opt)
{
Layer* requantize = create_layer(LayerType::Requantize);
ParamDict pd;
pd.set(0, scale_in_data.w);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r9d, %r14d
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
pushq $0x3f
popq %rdi
callq 0x3d2f3
movq %rax, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x49b10
movl ... | /tpoisonooo[P]ncnn/src/mat.cpp |
ncnn::Mat::channel(int) | inline Mat Mat::channel(int _c)
{
if (dims == 3)
return Mat(w, h, (unsigned char*)data + cstep * _c * elemsize, elemsize, elempack, allocator);
// if (dims == 4)
Mat m(w, h, d, (unsigned char*)data + cstep * _c * elemsize, elemsize, elempack, allocator);
m.cstep = (size_t)w * h;
return m;
} | pushq %r14
pushq %rbx
pushq %rax
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x2c(%rsi), %esi
cmpl $0x3, 0x28(%r14)
movl 0x30(%r14), %edx
jne 0x48927
movslq %eax, %rcx
imulq 0x40(%r14), %rcx
movq 0x10(%r14), %r8
imulq %r8, %rcx
addq (%r14), %rcx
movl 0x18(%r14), %r9d
subq $0x8, %rsp
movq %rbx, %rdi
pushq 0x20(... | /tpoisonooo[P]ncnn/src/mat.h |
ncnn::Mat::channel(int) const | inline const Mat Mat::channel(int _c) const
{
if (dims == 3)
return Mat(w, h, (unsigned char*)data + cstep * _c * elemsize, elemsize, elempack, allocator);
// if (dims == 4)
Mat m(w, h, d, (unsigned char*)data + cstep * _c * elemsize, elemsize, elempack, allocator);
m.cstep = (size_t)w * h;
... | pushq %r14
pushq %rbx
pushq %rax
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x2c(%rsi), %esi
cmpl $0x3, 0x28(%r14)
movl 0x30(%r14), %edx
jne 0x489b1
movslq %eax, %rcx
imulq 0x40(%r14), %rcx
movq 0x10(%r14), %r8
imulq %r8, %rcx
addq (%r14), %rcx
movl 0x18(%r14), %r9d
subq $0x8, %rsp
movq %rbx, %rdi
pushq 0x20(... | /tpoisonooo[P]ncnn/src/mat.h |
ncnn::ModelBin::load(int, int, int) const | Mat ModelBin::load(int w, int h, int type) const
{
Mat m = load(w * h, type);
if (m.empty())
return m;
return m.reshape(w, h);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
movl %ecx, %edx
imull %r14d, %edx
movq (%rsi), %rax
movq %rsp, %r15
movq %r15, %rdi
movl %r8d, %ecx
callq *0x10(%rax)
cmpq $0x0, (%r15)
je 0x48b0e
movslq 0x38(%rsp), %rax
imulq 0x40(%rsp), %rax
testq %rax, %rax... | /tpoisonooo[P]ncnn/src/modelbin.cpp |
ncnn::ModelBin::load(int, int, int, int) const | Mat ModelBin::load(int w, int h, int c, int type) const
{
Mat m = load(w * h * c, type);
if (m.empty())
return m;
return m.reshape(w, h, c);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
movl %ecx, %edx
imull %r15d, %edx
imull %r8d, %edx
movq (%rsi), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl %r9d, %ecx
callq *0x10(%rax)
cmpq $0x0, (%r12)
je 0x48ba7
movslq 0x40(%... | /tpoisonooo[P]ncnn/src/modelbin.cpp |
ncnn::ModelBinFromDataReader::load(int, int) const | Mat ModelBinFromDataReader::load(int w, int type) const
{
Mat m;
if (type == 0)
{
size_t nread;
union
{
struct
{
unsigned char f0;
unsigned char f1;
unsigned char f2;
unsigned char f3;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x480, %rsp # imm = 0x480
movl %edx, %r14d
andq $0x0, 0x60(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movups %xmm0, 0x2c(%rsp)
movaps %xmm0, 0x40(%rsp)
movups %xmm0, 0x4c(%rsp)
cmpl $0x1, %ecx
je 0x48d45
testl... | /tpoisonooo[P]ncnn/src/modelbin.cpp |
ncnn::Option::Option() | Option::Option()
{
lightmode = true;
num_threads = get_big_cpu_count();
blob_allocator = 0;
workspace_allocator = 0;
#if NCNN_VULKAN
blob_vkallocator = 0;
workspace_vkallocator = 0;
staging_vkallocator = 0;
pipeline_cache = 0;
#endif // NCNN_VULKAN
openmp_blocktime = 20;
use_w... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, %bpl
movb %bpl, (%rdi)
callq 0x1ccdf0
movl %eax, 0x4(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movabsq $0x1010100000014, %rax # imm = 0x1010100000014
movq %rax, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
movb %bpl, 0x25(%rbx)
movl $0x1010101, 0x21(%rbx) # imm =... | /tpoisonooo[P]ncnn/src/option.cpp |
ncnn::ParamDict::ParamDict(ncnn::ParamDict const&) | ParamDict::ParamDict(const ParamDict& rhs)
: d(new ParamDictPrivate)
{
for (int i = 0; i < NCNN_MAX_PARAM_COUNT; i++)
{
int type = rhs.d->params[i].type;
d->params[i].type = type;
if (type == 1 || type == 2 || type == 3)
{
d->params[i].i = rhs.d->params[i].i;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1d08e2(%rip), %rax # 0x21a518
movq %rax, (%rdi)
movl $0xa00, %edi # imm = 0xA00
callq 0x381b0
movq %rax, %r15
movq %rax, %rdi
callq 0x4a3d4
movq %r15, 0x8(%r14)
pushq $0x8
popq %r15
cmpq $0xa08, %r15 # imm = 0xA08
je 0x49c9... | /tpoisonooo[P]ncnn/src/paramdict.cpp |
ncnn::ParamDict::operator=(ncnn::ParamDict const&) | ParamDict& ParamDict::operator=(const ParamDict& rhs)
{
if (this == &rhs)
return *this;
for (int i = 0; i < NCNN_MAX_PARAM_COUNT; i++)
{
int type = rhs.d->params[i].type;
d->params[i].type = type;
if (type == 1 || type == 2 || type == 3)
{
d->params[i].i ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x49d07
movq %rsi, %r14
pushq $0x8
popq %r15
cmpq $0xa08, %r15 # imm = 0xA08
je 0x49d07
movq 0x8(%r14), %rsi
movl -0x8(%rsi,%r15), %eax
movq 0x8(%rbx), %rdi
movl %eax, -0x8(%rdi,%r15)
decl %eax
cmpl $0x2, %eax
ja 0x49cf6
movl -0x4(%rsi,%r15)... | /tpoisonooo[P]ncnn/src/paramdict.cpp |
ncnn::ParamDict::load_param(ncnn::DataReader const&) | int ParamDict::load_param(const DataReader& dr)
{
clear();
// 0=100 1=1.250000 -23303=5,0.1,0.2,0.4,0.8,1.0
// parse each key=value pair
int id = 0;
while (dr.scan("%d=", &id) == 1)
{
bool is_array = id <= -23300;
if (is_array)
{
id = -id - 23300;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
callq 0x49b62
movq %rsp, %rbx
andl $0x0, (%rbx)
leaq 0x1833cb(%rip), %r14 # 0x1cd1c5
leaq 0x10(%rsp), %r15
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
c... | /tpoisonooo[P]ncnn/src/paramdict.cpp |
ncnn::vstr_is_float(char const*) | static bool vstr_is_float(const char vstr[16])
{
// look ahead for determine isfloat
for (int j = 0; j < 16; j++)
{
if (vstr[j] == '\0')
break;
if (vstr[j] == '.' || tolower(vstr[j]) == 'e')
return true;
}
return false;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x10, %r14
je 0x4a0d2
movzbl (%rbx,%r14), %eax
testl %eax, %eax
je 0x4a0d2
cmpl $0x2e, %eax
je 0x4a0ce
movsbl %al, %edi
callq 0x382b0
incq %r14
cmpl $0x65, %eax
jne 0x4a0aa
movb $0x1, %al
jmp 0x4a0d4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq ... | /tpoisonooo[P]ncnn/src/paramdict.cpp |
ncnn::vstr_to_float(char const*) | static float vstr_to_float(const char vstr[16])
{
double v = 0.0;
const char* p = vstr;
// sign
bool sign = *p != '-';
if (*p == '+' || *p == '-')
{
p++;
}
// digits before decimal point or exponent
unsigned int v1 = 0;
while (isdigit(*p))
{
v1 = v1 * 10 + ... | movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x4a0e9
cmpl $0x2b, %eax
jne 0x4a0ec
incq %rdi
xorl %edx, %edx
movsbl (%rdi), %ecx
leal -0x30(%rcx), %esi
cmpl $0x9, %esi
ja 0x4a105
imull $0xa, %edx, %ecx
addl %ecx, %esi
incq %rdi
movl %esi, %edx
jmp 0x4a0ee
movl %edx, %edx
cvtsi2sd %rdx, %xmm0
cmpb $0x2e, %cl
jne 0x4a14d
incq ... | /tpoisonooo[P]ncnn/src/paramdict.cpp |
ncnn::BatchNorm::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BatchNorm::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
// a = bias - slope * mean / sqrt(var)
// b = slope / sqrt(var)
// value = b * value + a
int dims = bottom_top_blob.dims;
if (dims == 1)
{
int w = bottom_top_blob.w;
float* ptr = bottom_top_blob;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x28(%rsi), %eax
cmpl $0x2, %eax
je 0x4a94c
cmpl $0x1, %eax
jne 0x4a9b8
movl 0x2c(%rbx), %ecx
movq (%rbx), %rdx
movq 0x1f8(%r14), %rsi
movq 0x240(%r14), %rdi
xorl %r8d, %r8d
testl %ecx, %ecx
cmovlel %... | /tpoisonooo[P]ncnn/src/layer/batchnorm.cpp |
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.