name string | code string | asm string | file string |
|---|---|---|---|
test_inverse_scalar | static void test_inverse_scalar(secp256k1_scalar* out, const secp256k1_scalar* x, int var)
{
secp256k1_scalar l, r, t;
(var ? secp256k1_scalar_inverse_var : secp256k1_scalar_inverse)(&l, x); /* l = 1/x */
if (out) *out = l;
if (secp256k1_scalar_is_zero(x)) {
CHECK(secp256k1_scalar_is_zero(&l))... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
leaq -0x17067(%rip), %rax # 0x4bf47
leaq -0x19286(%rip), %r15 # 0x49d2f
cmoveq %rax, %r15
movq %rsp, %rdi
callq *%r15
testq %r14, %r14
je 0x62fd6
movups (%rsp), %xmm0
movups 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%r14... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
test_hsort_is_sorted | static void test_hsort_is_sorted(unsigned char *elements, size_t n, size_t len) {
size_t i;
for (i = 1; i < n; i++) {
CHECK(secp256k1_memcmp_var(&elements[(i-1) * len], &elements[i * len], len) <= 0);
}
} | pushq %rbp
pushq %rbx
pushq %rax
cmpq $0x2, %rsi
jb 0x63274
movq %rdx, %rax
negq %rax
leaq (%rdi,%rdx), %rcx
movl $0x1, %r8d
testq %rdx, %rdx
je 0x63266
xorl %r10d, %r10d
movl %r9d, %r11d
movzbl (%rdi,%r10), %ebx
movzbl (%rcx,%r10), %ebp
movl %ebx, %r9d
subl %ebp, %r9d
cmpb %bpl, %bl
cmovel %r11d, %r9d
jne 0x63261
incq... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
secp256k1_wnaf_fixed | static int secp256k1_wnaf_fixed(int *wnaf, const secp256k1_scalar *s, int w) {
int skew = 0;
int pos;
int max_pos;
int last_w;
const secp256k1_scalar *work = s;
if (secp256k1_scalar_is_zero(s)) {
for (pos = 0; pos < WNAF_SIZE(w); pos++) {
wnaf[pos] = 0;
}
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r8d
movq 0x8(%rsi), %rcx
orq 0x10(%rsi), %rcx
movq (%rsi), %rax
orq 0x18(%rsi), %rcx
orq %rax, %rcx
je 0x6a966
movl %eax, %edx
notl %edx
andl $0x1, %edx
movl %r8d, %ecx
negb %cl
shll %cl, %eax
shrl %cl, %eax
movl %edx, 0x4(%rsp)
ad... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
test_ecmult_target | static void test_ecmult_target(const secp256k1_scalar* target, int mode) {
/* Mode: 0=ecmult_gen, 1=ecmult, 2=ecmult_const */
secp256k1_scalar n1, n2;
secp256k1_ge p;
secp256k1_gej pj, p1j, p2j, ptj;
/* Generate random n1,n2 such that n1+n2 = -target. */
testutil_random_scalar_order_test(&n1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xac8, %rsp # imm = 0xAC8
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x27a08
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4be5c
movq %r15, %rdi
movq %r15, %rsi
callq 0x152b3
tes... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
test_ecmult_accumulate | static void test_ecmult_accumulate(secp256k1_sha256* acc, const secp256k1_scalar* x, secp256k1_scratch* scratch) {
/* Compute x*G in 6 different ways, serialize it uncompressed, and feed it into acc. */
secp256k1_gej rj1, rj2, rj3, rj4, rj5, rj6, gj, infj;
secp256k1_ge r;
unsigned char bytes[65];
si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb98, %rsp # imm = 0xB98
movq %rdx, 0x18(%rsp)
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq $0x41, 0x20(%rsp)
leaq 0x850(%rsp), %r12
movl $0x0, 0x78(%r12)
movups 0x183b4(%rip), %xmm0 # 0x831c0
movaps %xmm0, (%r12)
movups 0x183b8(%rip),... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
secp256k1_ecmult_multi_var | static int secp256k1_ecmult_multi_var(const secp256k1_callback* error_callback, secp256k1_scratch *scratch, secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n) {
size_t i;
int (*f)(const secp256k1_callback* error_callback, secp256k1_scratch*, secp256k... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x878, %rsp # imm = 0x878
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x8b0(%rsp), %r8
movl $0x1, 0x78(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movups %xmm0, 0x10(%rdx)
movups %xmm0, 0x20(%rdx)
movups %xmm0, ... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_ecmult_multi_simple_var | static int secp256k1_ecmult_multi_simple_var(secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n_points) {
size_t point_idx;
secp256k1_gej tmpj;
secp256k1_gej_set_infinity(r);
secp256k1_gej_set_infinity(&tmpj);
/* r = inp_g_sc*G */
secp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9c8, %rsp # imm = 0x9C8
movq %r8, %r14
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r9
movq %rdi, %r13
movl $0x1, %ebx
movl %ebx, 0x78(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_pippenger_max_points | static size_t secp256k1_pippenger_max_points(const secp256k1_callback* error_callback, secp256k1_scratch *scratch) {
size_t max_alloc = secp256k1_scratch_max_allocation(error_callback, scratch, PIPPENGER_SCRATCH_OBJECTS);
int bucket_window;
size_t res = 0;
for (bucket_window = 1; bucket_window <= PIPPE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x6, %edx
callq 0x60ea6
movq %rax, %r14
movl $0x1, %r15d
movl $0x2, %ebp
xorl %ebx, %ebx
cmpq $0xd, %r15
je 0x6b6ae
xorl %esi, %esi
movl $0x7f, %eax
xorl %edx, %edx
divl %ebp
movl $0x80, %edx
movl %r15d, %ecx
shlq %cl, %rdx
leaq (%rdx,%r... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_ecmult_pippenger_batch | static int secp256k1_ecmult_pippenger_batch(const secp256k1_callback* error_callback, secp256k1_scratch *scratch, secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n_points, size_t cb_offset) {
const size_t scratch_checkpoint = secp256k1_scratch_checkpoint(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbp
movq 0x140(%rsp), %r12
xorl %eax, %eax
leaq 0x758c(%rip), %rdx # 0x72c82
movl %ecx, %esi
movzbl (%r14,%rax... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_ecmult_strauss_batch | static int secp256k1_ecmult_strauss_batch(const secp256k1_callback* error_callback, secp256k1_scratch *scratch, secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n_points, size_t cb_offset) {
secp256k1_gej* points;
secp256k1_scalar* scalars;
struct ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq 0xf8(%rsp), %rbp
xorl %eax, %eax
leaq 0x6e61(%rip), %rdx # 0x72c82
movl %ecx, %esi
movzbl (%rbx,%rax), %edi
movzbl (%rax,... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_pippenger_bucket_window_inv | static size_t secp256k1_pippenger_bucket_window_inv(int bucket_window) {
switch(bucket_window) {
case 1: return 1;
case 2: return 4;
case 3: return 20;
case 4: return 57;
case 5: return 136;
case 6: return 235;
case 7: return 1260;
case 8: return 1260;... | decl %edi
cmpl $0xb, %edi
ja 0x6c0d5
movl %edi, %eax
leaq 0x31050(%rip), %rcx # 0x9d120
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
| /fanquake[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_pippenger_bucket_window | static int secp256k1_pippenger_bucket_window(size_t n) {
if (n <= 1) {
return 1;
} else if (n <= 4) {
return 2;
} else if (n <= 20) {
return 3;
} else if (n <= 57) {
return 4;
} else if (n <= 136) {
return 5;
} else if (n <= 235) {
return 6;
} ... | movl $0x1, %eax
cmpq $0x2, %rdi
jb 0x6c159
movl $0x2, %eax
cmpq $0x5, %rdi
jb 0x6c159
movl $0x3, %eax
cmpq $0x15, %rdi
jb 0x6c159
movl $0x4, %eax
cmpq $0x3a, %rdi
jb 0x6c159
movl $0x5, %eax
cmpq $0x89, %rdi
jb 0x6c159
movl $0x6, %eax
cmpq $0xec, %rdi
jb 0x6c159
movl $0x7, %eax
cmpq $0x4ed, %rdi # imm = 0x4ED... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
secp256k1_ecmult_endo_split | SECP256K1_INLINE static void secp256k1_ecmult_endo_split(secp256k1_scalar *s1, secp256k1_scalar *s2, secp256k1_ge *p1, secp256k1_ge *p2) {
secp256k1_scalar tmp = *s1;
secp256k1_scalar_split_lambda(s1, s2, &tmp);
secp256k1_ge_mul_lambda(p2, p1);
if (secp256k1_scalar_is_high(s1)) {
secp256k1_scal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movq %rsp, %rdx
movaps %xmm1, 0x10(%rdx)
movaps %xmm0, (%rdx)
callq 0x54dc2
movl $0xb, %ecx
movq %rbx, %rdi
movq %r15, %rsi
rep... | /fanquake[P]bitcoin/src/secp256k1/src/ecmult_impl.h |
test_ecmult_multi_batch_single | static void test_ecmult_multi_batch_single(secp256k1_ecmult_multi_func ecmult_multi) {
secp256k1_scalar sc;
secp256k1_ge pt;
secp256k1_gej r;
ecmult_multi_data data;
secp256k1_scratch *scratch_empty;
testutil_random_ge_test(&pt);
testutil_random_scalar_order(&sc);
data.sc = ≻
dat... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x27711
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x27a83
leaq 0x10(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl $0xb8, %r14d
movq 0x154c2c(%rip), %rdi # 0x1... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
ec_pubkey_parse_pointtest | static void ec_pubkey_parse_pointtest(const unsigned char *input, int xvalid, int yvalid) {
unsigned char pubkeyc[65];
secp256k1_pubkey pubkey;
secp256k1_ge ge;
size_t pubkeyclen;
for (pubkeyclen = 3; pubkeyclen <= 65; pubkeyclen++) {
/* Smaller sizes are tested exhaustively elsewhere. */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %edx, 0xa8(%rsp)
movl %esi, 0x48(%rsp)
movq %rdi, %r14
movl $0x3, %ecx
leaq 0x50(%rsp), %r13
xorl %ebp, %ebp
movq %rdi, 0xb0(%rsp)
cmpl $0x0, 0x48(%rsp)
setne %sil
movups (%r14), %xmm0
movups 0x10(%r14), %x... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
nonce_function_test_retry | static int nonce_function_test_retry(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, const unsigned char *algo16, void *data, unsigned int counter) {
/* Dummy nonce generator that produces unacceptable nonces for the first several counter values. */
if (counter < 3) {
memset... | cmpl $0x2, %r9d
ja 0x6fd58
xorl %eax, %eax
movl %r9d, %ecx
negl %ecx
sbbl %eax, %eax
movd %eax, %xmm0
punpcklbw %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movdqu %xmm0, 0x10(%rdi)
mov... | /fanquake[P]bitcoin/src/secp256k1/src/tests.c |
test_schnorrsig_bip_vectors_check_signing | static void test_schnorrsig_bip_vectors_check_signing(const unsigned char *sk, const unsigned char *pk_serialized, const unsigned char *aux_rand, const unsigned char *msg, size_t msglen, const unsigned char *expected_sig) {
unsigned char sig[64];
secp256k1_keypair keypair;
secp256k1_xonly_pubkey pk, pk_expe... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp # imm = 0x150
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rdx
movups 0x2d0ff(%rip), %xmm0 # 0x9d010
movaps %xmm0, 0x10(%rsp)
movq %r13, 0x20(%rsp)
movq 0x1521de(%rip), %rdi # 0x1c2100
... | /fanquake[P]bitcoin/src/secp256k1/src/modules/schnorrsig/tests_impl.h |
nonce_function_0 | static int nonce_function_0(unsigned char *nonce32, const unsigned char *msg, size_t msglen, const unsigned char *key32, const unsigned char *xonly_pk32, const unsigned char *algo, size_t algolen, void *data) {
(void) msg;
(void) msglen;
(void) key32;
(void) xonly_pk32;
(void) algo;
(void) algol... | xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x1, %eax
retq
| /fanquake[P]bitcoin/src/secp256k1/src/modules/schnorrsig/tests_impl.h |
(anonymous namespace)::Json2Array<aliyun::RamListEntitiesForPolicyGroupType>::Json2Array(Json::Value const&, std::vector<aliyun::RamListEntitiesForPolicyGroupType, std::allocator<aliyun::RamListEntitiesForPolicyGroupType>>*) | Json2Array(const Json::Value& value, std::vector<T>* vec) {
if(!value.isArray()) {
return;
}
for(int i = 0; i < value.size(); i++) {
T val;
Json2Type(value[i], &val);
vec->push_back(val);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x54b60
testb $0x1, %al
jne 0x80559
jmp 0x805ee
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x549c0
movl %eax, %ecx
movl -0x9... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-ram/2015-05-01/src/ali_ram_list_entities_for_policy.cc |
(anonymous namespace)::Json2Type(Json::Value const&, aliyun::RamListEntitiesForPolicyGroupType*) | void Json2Type(const Json::Value& value, RamListEntitiesForPolicyGroupType* item) {
if(value.isMember("GroupName")) {
item->group_name = value["GroupName"].asString();
}
if(value.isMember("Comments")) {
item->comments = value["Comments"].asString();
}
if(value.isMember("AttachDate")) {
ite... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa1fbe(%rip), %rsi # 0x1227c9
callq 0x51870
testb $0x1, %al
jne 0x80816
jmp 0x80848
movq -0x8(%rbp), %rdi
leaq 0xa1fa8(%rip), %rsi # 0x1227c9
callq 0x54f20
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-ram/2015-05-01/src/ali_ram_list_entities_for_policy.cc |
(anonymous namespace)::Json2Type(Json::Value const&, aliyun::RamListEntitiesForPolicyUserType*) | void Json2Type(const Json::Value& value, RamListEntitiesForPolicyUserType* item) {
if(value.isMember("UserId")) {
item->user_id = value["UserId"].asString();
}
if(value.isMember("UserName")) {
item->user_name = value["UserName"].asString();
}
if(value.isMember("DisplayName")) {
item->displ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa1952(%rip), %rsi # 0x122260
callq 0x51870
testb $0x1, %al
jne 0x80919
jmp 0x8094b
movq -0x8(%rbp), %rdi
leaq 0xa193c(%rip), %rsi # 0x122260
callq 0x54f20
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-ram/2015-05-01/src/ali_ram_list_entities_for_policy.cc |
(anonymous namespace)::Json2Type(Json::Value const&, aliyun::RamListEntitiesForPolicyRoleType*) | void Json2Type(const Json::Value& value, RamListEntitiesForPolicyRoleType* item) {
if(value.isMember("RoleId")) {
item->role_id = value["RoleId"].asString();
}
if(value.isMember("RoleName")) {
item->role_name = value["RoleName"].asString();
}
if(value.isMember("Arn")) {
item->arn = value["... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa17dc(%rip), %rsi # 0x12224a
callq 0x51870
testb $0x1, %al
jne 0x80a79
jmp 0x80aab
movq -0x8(%rbp), %rdi
leaq 0xa17c6(%rip), %rsi # 0x12224a
callq 0x54f20
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-ram/2015-05-01/src/ali_ram_list_entities_for_policy.cc |
(anonymous namespace)::Json2Type(Json::Value const&, aliyun::RamListGroupsResponseType*) | void Json2Type(const Json::Value& value, RamListGroupsResponseType* item) {
if(value.isMember("IsTruncated")) {
item->is_truncated = value["IsTruncated"].asBool();
}
if(value.isMember("Marker")) {
item->marker = value["Marker"].asString();
}
if(value.isMember("Groups") && value["Groups"].isMemb... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9e61e(%rip), %rsi # 0x122669
callq 0x51870
testb $0x1, %al
jne 0x84056
jmp 0x8407a
movq -0x8(%rbp), %rdi
leaq 0x9e608(%rip), %rsi # 0x122669
callq 0x54f20
movq %rax, %rdi
callq 0x53120
movb %al,... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-ram/2015-05-01/src/ali_ram_list_groups.cc |
(anonymous namespace)::Json2Array<aliyun::RamListGroupsGroupType>::Json2Array(Json::Value const&, std::vector<aliyun::RamListGroupsGroupType, std::allocator<aliyun::RamListGroupsGroupType>>*) | Json2Array(const Json::Value& value, std::vector<T>* vec) {
if(!value.isArray()) {
return;
}
for(int i = 0; i < value.size(); i++) {
T val;
Json2Type(value[i], &val);
vec->push_back(val);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x54b60
testb $0x1, %al
jne 0x84169
jmp 0x8420d
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x549c0
movl %eax, %ecx
movl -0xb... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-ram/2015-05-01/src/ali_ram_list_groups.cc |
mbedtls_x509_crt_is_revoked | int mbedtls_x509_crt_is_revoked( const mbedtls_x509_crt *crt, const mbedtls_x509_crl *crl )
{
const mbedtls_x509_crl_entry *cur = &crl->entry;
while( cur != NULL && cur->serial.len != 0 )
{
if( crt->serial.len == cur->serial.len &&
memcmp( crt->serial.p, cur->serial.p, crt->serial.len )... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0xd8, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0xc97f9
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
mbedtls_x509_crt_verify_with_profile | int mbedtls_x509_crt_verify_with_profile( mbedtls_x509_crt *crt,
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
const mbedtls_x509_crt_profile *profile,
const char *cn, uint32_t *flags,
int (*f_vrfy)(void *, ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x48(%rbp)
movq $0x0, -0x60(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xc992d
movl $0xffffd80... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_memcasecmp | static int x509_memcasecmp( const void *s1, const void *s2, size_t len )
{
size_t i;
unsigned char diff;
const unsigned char *n1 = s1, *n2 = s2;
for( i = 0; i < len; i++ )
{
diff = n1[i] ^ n2[i];
if( diff == 0 )
continue;
if( diff == 32 &&
( ( n1[i]... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xc9d57
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movzb... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_check_wildcard | static int x509_check_wildcard( const char *cn, mbedtls_x509_buf *name )
{
size_t i;
size_t cn_idx = 0, cn_len = strlen( cn );
if( name->len < 3 || name->p[0] != '*' || name->p[1] != '.' )
return( 0 );
for( i = 0; i < cn_len; ++i )
{
if( cn[i] == '.' )
{
cn_idx ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4f860
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x3, 0x8(%rax)
jb 0xc9dc1
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2a, %eax
jne 0xc9dc... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_crt_check_parent | static int x509_crt_check_parent( const mbedtls_x509_crt *child,
const mbedtls_x509_crt *parent,
int top, int bottom )
{
int need_ca_bit;
/* Parent must be the issuer */
if( x509_name_cmp( &child->issuer, &parent->subject ) != 0 )
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
movq -0x18(%rbp), %rsi
addq $0xd8, %rsi
callq 0xcb450
cmpl $0x0, %eax
je 0xc9ec2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc9f6c
mov... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_crt_verify_child | static int x509_crt_verify_child(
mbedtls_x509_crt *child, mbedtls_x509_crt *parent,
mbedtls_x509_crt *trust_ca, mbedtls_x509_crl *ca_crl,
const mbedtls_x509_crt_profile *profile,
int path_cnt, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
cmpl $0x8, ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
mbedtls_x509_crt_free | void mbedtls_x509_crt_free( mbedtls_x509_crt *crt )
{
mbedtls_x509_crt *cert_cur = crt;
mbedtls_x509_crt *cert_prv;
mbedtls_x509_name *name_cur;
mbedtls_x509_name *name_prv;
mbedtls_x509_sequence *seq_cur;
mbedtls_x509_sequence *seq_prv;
if( crt == NULL )
return;
do
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xca7d0
jmp 0xca98e
jmp 0xca7d2
movq -0x10(%rbp), %rdi
addq $0x148, %rdi # imm = 0x148
callq 0x552c0
movq -0x10(%rbp), %rax
movq 0x218(%rax), %rdi
callq 0x52ae0
movq -0x10(... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_get_version | static int x509_get_version( unsigned char **p,
const unsigned char *end,
int *ver )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) != 0 )
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0xa0, %ecx
callq 0x511a0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xca9f3
cmpl $-0x62, -0x24(%rbp)
jne 0xca9eb
movq -0x20(%rbp), %r... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_get_dates | static int x509_get_dates( unsigned char **p,
const unsigned char *end,
mbedtls_x509_time *from,
mbedtls_x509_time *to )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCT... | 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), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl $0x30, %ecx
callq 0x511a0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0xcaa93
movl -0x2c(%rbp), %eax
addl $0xfff... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_get_uid | static int x509_get_uid( unsigned char **p,
const unsigned char *end,
mbedtls_x509_buf *uid, int n )
{
int ret;
if( *p == end )
return( 0 );
uid->tag = **p;
if( ( ret = mbedtls_asn1_get_tag( p, end, &uid->len,
MBEDTLS_ASN1_CONTEXT_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xcab3d
movl $0x0, -0x4(%rbp)
jmp 0xcabb2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %ecx
movq -0x20(%r... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_get_basic_constraints | static int x509_get_basic_constraints( unsigned char **p,
const unsigned char *end,
int *ca_istrue,
int *max_pathlen )
{
int ret;
size_t len;
/*
* BasicConstraints ::= SEQUENCE {
*... | 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 -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl $0x30, %ecx
callq 0x511a0
mo... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_get_key_usage | static int x509_get_key_usage( unsigned char **p,
const unsigned char *end,
unsigned int *key_usage)
{
int ret;
size_t i;
mbedtls_x509_bitstring bs = { 0, 0, NULL };
if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x50010
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x50e20
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xcb0ea
movl... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_get_ext_key_usage | static int x509_get_ext_key_usage( unsigned char **p,
const unsigned char *end,
mbedtls_x509_sequence *ext_key_usage)
{
int ret;
if( ( ret = mbedtls_asn1_get_sequence_of( p, end, ext_key_usage, MBEDTLS_ASN1_OID ) ) != 0 )
return( MBEDTLS_ERR... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x6, %ecx
callq 0x4fe30
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xcb1af
movl -0x24(%rbp), %eax
addl $0xffffdb00, %eax # imm ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_get_subject_alt_name | static int x509_get_subject_alt_name( unsigned char **p,
const unsigned char *end,
mbedtls_x509_sequence *subject_alt_name )
{
int ret;
size_t len, tag_len;
mbedtls_asn1_buf *buf;
unsigned char tag;
mbedtls_asn1_sequence *cu... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x30, %ecx
callq 0x511a0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xcb22a
movl -0x24(... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_get_ns_cert_type | static int x509_get_ns_cert_type( unsigned char **p,
const unsigned char *end,
unsigned char *ns_cert_type)
{
int ret;
mbedtls_x509_bitstring bs = { 0, 0, NULL };
if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x50010
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x50e20
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xcb41a
movl... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_name_cmp | static int x509_name_cmp( const mbedtls_x509_name *a, const mbedtls_x509_name *b )
{
/* Avoid recursion, it might not be optimised by the compiler */
while( a != NULL || b != NULL )
{
if( a == NULL || b == NULL )
return( -1 );
/* type */
if( a->oid.tag != b->oid.tag ||
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
jne 0xcb477
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xcb483
jmp 0xcb545
cmpq $0x0, -0x10(%rbp)
je 0xcb491
cmpq $0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_string_cmp | static int x509_string_cmp( const mbedtls_x509_buf *a, const mbedtls_x509_buf *b )
{
if( a->tag == b->tag &&
a->len == b->len &&
memcmp( a->p, b->p, b->len ) == 0 )
{
return( 0 );
}
if( ( a->tag == MBEDTLS_ASN1_UTF8_STRING || a->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xcb5bb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xcb5bb
movq -0x10(%rbp), %rax
movq 0x10(%ra... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_profile_check_key | static int x509_profile_check_key( const mbedtls_x509_crt_profile *profile,
mbedtls_pk_type_t pk_alg,
const mbedtls_pk_context *pk )
{
#if defined(MBEDTLS_RSA_C)
if( pk_alg == MBEDTLS_PK_RSA || pk_alg == MBEDTLS_PK_RSASSA_PSS )
{
if( ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0xcb6cf
cmpl $0x6, -0x14(%rbp)
jne 0xcb6f6
movq -0x20(%rbp), %rdi
callq 0x4e270
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
jb 0xcb6ed
movl $0x0, -0x4(%rbp)
jmp 0xcb... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_crt_verifycrl | static int x509_crt_verifycrl( mbedtls_x509_crt *crt, mbedtls_x509_crt *ca,
mbedtls_x509_crl *crl_list,
const mbedtls_x509_crt_profile *profile )
{
int flags = 0;
unsigned char hash[MBEDTLS_MD_MAX_SIZE];
const mbedtls_md_info_t *md_info;
if(... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xcb784
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcb9e1
jmp 0xcb786
cmpq $0x0, -0x20(%rbp)
je 0xcb9db
movq -0x20(%rbp), %rax
... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
Json::Reader::Reader() | Reader::Reader()
: errors_(),
document_(),
begin_(),
end_(),
current_(),
lastValueEnd_(),
lastValue_(),
commentsBefore_(),
features_( Features::all() ),
collectComments_()
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x55840
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x50, %rdi
movq %rdi, -0x20(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rax)
movups %xmm0, 0x80(%rax)
movups %... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::Reader(Json::Features const&) | Reader::Reader( const Features &features )
: errors_(),
document_(),
begin_(),
end_(),
current_(),
lastValueEnd_(),
lastValue_(),
commentsBefore_(),
features_( features ),
collectComments_()
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x55840
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x50, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rax)
movups %xmm0, 0x80(%rax)
movups %... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::parse(char const*, char const*, Json::Value&, bool) | bool
Reader::parse( const char *beginDoc, const char *endDoc,
Value &root,
bool collectComments )
{
if ( !features_.allowComments_ )
{
collectComments = false;
}
begin_ = beginDoc;
end_ = endDoc;
collectComments_ = collectComments;
current_ = begin_;
lastVa... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
testb $0x1, 0x108(%rax)
jne 0xcbd7b
movb $0x0, -0x29(%rbp)
movq -0x98(%rbp), %rdi
movq... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::parse(std::istream&, Json::Value&, bool) | bool
Reader::parse( std::istream& sin,
Value &root,
bool collectComments )
{
//std::istream_iterator<char> begin(sin);
//std::istream_iterator<char> end;
// Those would allow streamed input from a file, if parse() were a
// template function.
// Since std::string is referen... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x53890
movq -0x58(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::addError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Reader::Token&, char const*) | bool
Reader::addError( const std::string &message,
Token &token,
Location extra )
{
ErrorInfo info;
info.token_ = token;
info.message_ = message;
info.extra_ = extra;
errors_.push_back( info );
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x536d0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x50(%rbp)
movups (%rax), %xmm0
movaps %xmm0, ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::readObject(Json::Reader::Token&) | bool
Reader::readObject( Token &/*tokenStart*/ )
{
Token tokenName;
std::string name;
currentValue() = Value( objectValue );
while ( readToken( tokenName ) )
{
bool initialTokenOk = true;
while ( tokenName.type_ == tokenComment && initialTokenOk )
initialTokenOk = readToken( token... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x53890
leaq -0x68(%rbp), %rdi
movl $0x7, %esi
callq 0x4f760
jmp 0xcc4c7
movq -0x148(%rbp), %rdi
callq 0x51c90
movq %rax, -0x150... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::readArray(Json::Reader::Token&) | bool
Reader::readArray( Token &/*tokenStart*/ )
{
currentValue() = Value( arrayValue );
skipSpaces();
if ( *current_ == ']' ) // empty array
{
Token endArray;
readToken( endArray );
return true;
}
int index = 0;
for (;;)
{
Value &value = currentValue()[ index++ ];
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x6, %esi
callq 0x4f760
movq -0xd0(%rbp), %rdi
callq 0x51c90
movq %rax, -0xc8(%rbp)
jmp 0xccaa1
movq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x53b90... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::decodeNumber(Json::Reader::Token&) | bool
Reader::decodeNumber( Token &token )
{
bool isDouble = false;
for ( Location inspect = token.start_; inspect != token.end_; ++inspect )
{
isDouble = isDouble
|| in( *inspect, '.', 'e', 'E', '+' )
|| ( *inspect == '-' && inspect != token.start_ );
}
if... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x120(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::decodeString(Json::Reader::Token&) | bool
Reader::decodeString( Token &token )
{
std::string decoded;
if ( !decodeString( token, decoded ) )
return false;
currentValue() = decoded;
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x53890
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x535c0
movb %al, -0x61(%rbp)
jmp 0xcd26e
movb -0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::readToken(Json::Reader::Token&) | bool
Reader::readToken( Token &token )
{
skipSpaces();
token.start_ = current_;
Char c = getNextChar();
bool ok = true;
switch ( c )
{
case '{':
token.type_ = tokenObjectBegin;
break;
case '}':
token.type_ = tokenObjectEnd;
break;
case '[':
token.type_ = tokenAr... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4e5b0
movq -0x28(%rbp), %rdi
movq 0xd0(%rdi), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x4f5a0
movb %al, -0x11(%rbp)
movb $0x1, -0x12(%rbp)
movsbl -0x11(%rbp), %eax... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::skipSpaces() | void
Reader::skipSpaces()
{
while ( current_ != end_ )
{
Char c = *current_;
if ( c == ' ' || c == '\t' || c == '\r' || c == '\n' )
++current_;
else
break;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0xcd644
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rax
movb (%rax), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x20, %eax
je 0xcd628
movsbl -0x9(%... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::readComment() | bool
Reader::readComment()
{
Location commentBegin = current_ - 1;
Char c = getNextChar();
bool successful = false;
if ( c == '*' )
successful = readCStyleComment();
else if ( c == '/' )
successful = readCppStyleComment();
if ( !successful )
return false;
if ( collectComments_ )
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq 0xd0(%rdi), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
callq 0x4f5a0
movb %al, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x2a, %eax
jne 0xcd758
movq -0x28(%rbp), %rdi
callq 0x4... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::match(char const*, int) | bool
Reader::match( Location pattern,
int patternLength )
{
if ( end_ - current_ < patternLength )
return false;
int index = patternLength;
while ( index-- )
if ( current_[index] != pattern[index] )
return false;
current_ += patternLength;
return true;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0xc8(%rcx), %rax
movq 0xd0(%rcx), %rcx
subq %rcx, %rax
movslq -0x1c(%rbp), %rcx
cmpq %rcx, %rax
jge 0xcd8f7
movb $0x0, -0x1(%rbp)
jmp 0xcd957
movl -0x1c(%rbp), %eax
movl %ea... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::readCppStyleComment() | bool
Reader::readCppStyleComment()
{
while ( current_ != end_ )
{
Char c = getNextChar();
if ( c == '\r' || c == '\n' )
break;
}
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0xcda1a
movq -0x18(%rbp), %rdi
callq 0x4f5a0
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0xd, %eax
je 0xcda16
movsbl -0x9(%rbp), %ea... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::addComment(char const*, char const*, Json::CommentPlacement) | void
Reader::addComment( Location begin,
Location end,
CommentPlacement placement )
{
assert( collectComments_ );
if ( placement == commentAfterOnSameLine )
{
assert( lastValue_ != 0 );
lastValue_->setComment( std::string( begin, end ), placement );
}
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
testb $0x1, 0x10a(%rax)
je 0xcdab0
jmp 0xcdacf
leaq 0x5c452(%rip), %rdi # 0x129f09
leaq 0x5c45c(%rip), %rsi # 0x129f1a
movl $0x190, ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::decodeUnicodeEscapeSequence(Json::Reader::Token&, char const*&, char const*, unsigned int&) | bool
Reader::decodeUnicodeEscapeSequence( Token &token,
Location ¤t,
Location end,
unsigned int &unicode )
{
if ( end - current < 4 )
return addError( "Bad unicode escape sequence in string:... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x4, %rax
jge 0xcec01
leaq -0x... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::getLocationLineAndColumn(char const*, int&, int&) const | void
Reader::getLocationLineAndColumn( Location location,
int &line,
int &column ) const
{
Location current = begin_;
Location lastLineStart = current;
line = 0;
while ( current < location && current != end_ )
{
Char c = *curren... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0xc0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rcx
xo... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::operator>>(std::istream&, Json::Value&) | std::istream& operator>>( std::istream &sin, Value &root )
{
Json::Reader reader;
bool ok = reader.parse(sin, root, true);
if (!ok) {
fprintf(
stderr,
"Error from reader: %s",
reader.getFormattedErrorMessages().c_str());
JSON_FAIL_MESSAGE("reader error");
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x120(%rbp), %rdi
movq %rdi, -0x168(%rbp)
callq 0x52270
movq -0x168(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x559a0
movb %al, -0x159(%rbp)
jmp 0xcf357
movb -0x1... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Value::CommentInfo::setComment(char const*) | void
Value::CommentInfo::setComment( const char *text )
{
if ( comment_ )
releaseStringValue( comment_ );
JSON_ASSERT( text != 0 );
JSON_ASSERT_MESSAGE( text[0]=='\0' || text[0]=='/', "Comments must start with /");
// It seems that /**/ style comments are acceptable as well.
comment_ = duplicateSt... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0xd26ea
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0xd2690
cmpq $0x0, -0x10(%rbp)
je 0xd26f3
jmp 0xd2712
leaq 0x57daa(%rip), %rdi # 0x12a4a4
leaq 0x57dad(%ri... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Json::duplicateStringValue(char const*, unsigned int) | static inline char *
duplicateStringValue( const char *value,
unsigned int length = unknown )
{
if ( length == unknown )
length = (unsigned int)strlen(value);
// Avoid an integer overflow in the call to malloc below by limiting length
// to a sane value.
if (length >= (unsigned... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0xd27d1
movq -0x8(%rbp), %rdi
callq 0x4f860
movl %eax, -0xc(%rbp)
cmpl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
jb 0xd27e1
movl $0x7ffffffe, -0xc(%rbp) # imm = 0x7FFFFFFE
movl -0xc(%rbp), %eax
addl $0x1,... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Json::Value::CZString::CZString(Json::Value::CZString const&) | Value::CZString::CZString( const CZString &other )
: cstr_( other.index_ != noDuplication && other.cstr_ != 0
? duplicateStringValue( other.cstr_ )
: other.cstr_ )
, index_( other.cstr_ ? (other.index_ == noDuplication ? noDuplication : duplicate)
: other.in... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0xd2943
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd2943
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi # imm = 0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
ecp_group_load | static int ecp_group_load( mbedtls_ecp_group *grp,
const mbedtls_mpi_uint *p, size_t plen,
const mbedtls_mpi_uint *a, size_t alen,
const mbedtls_mpi_uint *b, size_t blen,
const mbedtls_mpi_uint *gx, size_t gxl... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9,... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ecp_curves.c |
mbedtls_md5_finish | void mbedtls_md5_finish( mbedtls_md5_context *ctx, unsigned char output[16] )
{
uint32_t last, padn;
uint32_t high, low;
unsigned char msglen[8];
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT32_LE( low, msglen, 0 );
PUT_UINT32_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x1d, %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shll $0x3, %eax
movl %eax, -0x20(%rbp... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/md5.c |
mbedtls_pk_setup | int mbedtls_pk_setup( mbedtls_pk_context *ctx, const mbedtls_pk_info_t *info )
{
if( ctx == NULL || info == NULL || ctx->pk_info != NULL )
return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
if( ( ctx->pk_ctx = info->ctx_alloc_func() ) == NULL )
return( MBEDTLS_ERR_PK_ALLOC_FAILED );
ctx->pk_info = i... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1035e8
cmpq $0x0, -0x18(%rbp)
je 0x1035e8
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1035f1
movl $0xffffc180, -0x4(%rbp) # imm = 0xFFFFC180
jmp 0x103621
movq -0x18(%rbp), %rax
callq *0x48(%rax)
movq ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pk.c |
mbedtls_pk_parse_public_keyfile | int mbedtls_pk_parse_public_keyfile( mbedtls_pk_context *ctx, const char *path )
{
int ret;
size_t n;
unsigned char *buf;
if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
return( ret );
ret = mbedtls_pk_parse_public_key( ctx, buf, n );
mbedtls_zeroize( buf, n );
mbedtls... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x541e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x105031
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x105061
movq -0x10(%rbp), %rdi
movq -0x30(%rbp... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pkparse.c |
pk_parse_key_pkcs1_der | static int pk_parse_key_pkcs1_der( mbedtls_rsa_context *rsa,
const unsigned char *key,
size_t keylen )
{
int ret;
size_t len;
unsigned char *p, *end;
p = (unsigned char *) key;
end = p + keylen;
/*
* This function parse... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
movl $0x30, %ecx
callq ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pkparse.c |
mbedtls_ssl_hdr_len | static inline size_t mbedtls_ssl_hdr_len( const mbedtls_ssl_context *ssl )
{
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
return( 13 );
#else
((void) ssl);
#endif
return( 5 );
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x164(%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x115449
movq $0xd, -0x8(%rbp)
jmp 0x115451
movq $0x5, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/include/mbedtls/ssl_internal.h |
mbedtls_ssl_hs_hdr_len | static inline size_t mbedtls_ssl_hs_hdr_len( const mbedtls_ssl_context *ssl )
{
#if defined(MBEDTLS_SSL_PROTO_DTLS)
if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM )
return( 12 );
#else
((void) ssl);
#endif
return( 4 );
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x164(%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x115489
movq $0xc, -0x8(%rbp)
jmp 0x115491
movq $0x4, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/include/mbedtls/ssl_internal.h |
ssl_write_extended_ms_ext | static void ssl_write_extended_ms_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
if( ssl->handshake->extended_ms == MBEDTLS_SSL_EXTENDED_MS_DISABLED ||
ssl->minor_ver == MBEDTLS_SS... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
cmpl $0x0, 0xa98(%rax)
je 0x117017
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x117024
movq -0x18(%rbp), %rax
mov... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
ssl_get_ecdh_params_from_cert | static int ssl_get_ecdh_params_from_cert( mbedtls_ssl_context *ssl )
{
int ret;
if( ! mbedtls_pk_can_do( mbedtls_ssl_own_key( ssl ), MBEDTLS_PK_ECKEY ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "server key not ECDH capable" ) );
return( MBEDTLS_ERR_SSL_PK_TYPE_MISMATCH );
}
if( ( ret = mbedt... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x117460
movq %rax, %rdi
movl $0x2, %esi
callq 0x50ec0
cmpl $0x0, %eax
jne 0x1173e3
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x1b8a5(%rip), %rdx # 0x132c6c
movl $0x9d7, %ecx # imm = 0x9D7
leaq 0x1b2a8(%rip)... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
mbedtls_ssl_own_key | static inline mbedtls_pk_context *mbedtls_ssl_own_key( mbedtls_ssl_context *ssl )
{
mbedtls_ssl_key_cert *key_cert;
if( ssl->handshake != NULL && ssl->handshake->key_cert != NULL )
key_cert = ssl->handshake->key_cert;
else
key_cert = ssl->conf->key_cert;
return( key_cert == NULL ? NULL... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x11749a
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
cmpq $0x0, 0x388(%rax)
je 0x11749a
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x388(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1174ac
movq -0x8(%rbp), %rax
movq (%rax)... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/include/mbedtls/ssl_internal.h |
mbedtls_x509_get_rsassa_pss_params | int mbedtls_x509_get_rsassa_pss_params( const mbedtls_x509_buf *params,
mbedtls_md_type_t *md_alg, mbedtls_md_type_t *mgf_md,
int *salt_len )
{
int ret;
unsigned char *p;
const unsigned char *end, *end2;
size_t len;
mbedtls_x509_buf alg... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
movq -0x20(%rbp), %rax
movl $0x4, (%rax)
movq -0x28(%rbp), %rax
movl $0x14, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x30, (%rax)
je 0x117e2e
movl $... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509.c |
x509_get_hash_alg | static int x509_get_hash_alg( const mbedtls_x509_buf *alg, mbedtls_md_type_t *md_alg )
{
int ret;
unsigned char *p;
const unsigned char *end;
mbedtls_x509_buf md_oid;
size_t len;
/* Make sure we got a SEQUENCE and setup bounds */
if( alg->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x30, (%rax)
je 0x1181a5
movl $0xffffdc9e, -0x4(%rbp) # imm = 0xFFFFDC9E
jmp 0x1182a8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
a... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509.c |
mbedtls_x509_get_time | int mbedtls_x509_get_time( unsigned char **p, const unsigned char *end,
mbedtls_x509_time *time )
{
int ret;
size_t len;
unsigned char tag;
if( ( end - *p ) < 1 )
return( MBEDTLS_ERR_X509_INVALID_DATE +
MBEDTLS_ERR_ASN1_OUT_OF_DATA );
tag = **p;
if( ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jge 0x118614
movl $0xffffdba0, -0x4(%rbp) # imm = 0xFFFFDBA0
jmp 0x118933
movq -0x10(%rbp), %rax
movq (%rax), %... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509.c |
mbedtls_x509_dn_gets | int mbedtls_x509_dn_gets( char *buf, size_t size, const mbedtls_x509_name *dn )
{
int ret;
size_t i, n;
unsigned char c, merge = 0;
const mbedtls_x509_name *name;
const char *short_name = NULL;
char s[MBEDTLS_X509_MAX_DN_NAME_SIZE], *p;
memset( s, 0, sizeof( s ) );
name = dn;
p = b... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x3a(%rbp)
movq $0x0, -0x50(%rbp)
leaq -0x150(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx # imm = 0x100
callq 0x50010
movq -0x20(%rbp), %rax
movq %rax, -0x4... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509.c |
mbedtls_x509_sig_alg_gets | int mbedtls_x509_sig_alg_gets( char *buf, size_t size, const mbedtls_x509_buf *sig_oid,
mbedtls_pk_type_t pk_alg, mbedtls_md_type_t md_alg,
const void *sig_opts )
{
int ret;
char *p = buf;
size_t n = size;
const char *desc = NULL;
ret = mbedtls_oid_get_... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x20(%rbp), %rdi
l... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509.c |
x509_get_current_time | static int x509_get_current_time( mbedtls_x509_time *now )
{
struct tm *lt;
time_t tt;
int ret = 0;
#if defined(MBEDTLS_THREADING_C)
if( mbedtls_mutex_lock( &mbedtls_threading_gmtime_mutex ) != 0 )
return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
#endif
tt = time( NULL );
lt = gmtime( &tt ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x51a10
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x51630
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11939d
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x1193f8
movq... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509.c |
mbedtls_arc4_crypt | int mbedtls_arc4_crypt( mbedtls_arc4_context *ctx, size_t length, const unsigned char *input,
unsigned char *output )
{
int x, y, a, b;
size_t i;
unsigned char *m;
x = ctx->x;
y = ctx->y;
m = ctx->m;
for( i = 0; i < length; i++ )
{
x = ( x + 1 ) & 0xFF; a = m[x]... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq $0x0, -... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/arc4.c |
blowfish_enc | static void blowfish_enc( mbedtls_blowfish_context *ctx, uint32_t *xl, uint32_t *xr )
{
uint32_t Xl, Xr, temp;
short i;
Xl = *xl;
Xr = *xr;
for( i = 0; i < MBEDTLS_BLOWFISH_ROUNDS; ++i )
{
Xl = Xl ^ ctx->P[i];
Xr = F( ctx, Xl ) ^ Xr;
temp = Xl;
Xl = Xr;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movw $0x0, -0x26(%rbp)
movswl -0x26(%rbp), %eax
cmpl $0x10, %eax
jge 0x119e69
mo... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/blowfish.c |
mbedtls_ccm_self_test | int mbedtls_ccm_self_test( int verbose )
{
mbedtls_ccm_context ctx;
unsigned char out[32];
size_t i;
int ret;
mbedtls_ccm_init( &ctx );
if( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES, key, 8 * sizeof key ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( " CCM: setup f... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xb8, %rsp
movl %edi, -0x10(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4f000
leaq -0x68(%rbp), %rdi
movl $0x2, %esi
leaq 0x185a8(%rip), %rdx # 0x1356c0
movl $0x80, %ecx
callq 0x50320
cmpl $0x0, %eax
je 0x11d147
cmpl $0x0, -0x10(%rbp)
je 0x11d13b
leaq 0x186cc(%rip), %rdi # 0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ccm.c |
derive_mpi | static int derive_mpi( const mbedtls_ecp_group *grp, mbedtls_mpi *x,
const unsigned char *buf, size_t blen )
{
int ret;
size_t n_size = ( grp->nbits + 7 ) / 8;
size_t use_size = blen > n_size ? n_size : blen;
MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( x, buf, use_size ) );
if(... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
addq $0x7, %rax
shrq $0x3, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x11d7f3
movq -0x30(%rbp), %rax
movq... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ecdsa.c |
mbedtls_ecdsa_verify | int mbedtls_ecdsa_verify( mbedtls_ecp_group *grp,
const unsigned char *buf, size_t blen,
const mbedtls_ecp_point *Q, const mbedtls_mpi *r, const mbedtls_mpi *s)
{
int ret;
mbedtls_mpi e, s_inv, u1, u2;
mbedtls_ecp_point R;
mbedtls_ecp_point_init( &R );
mbedtls_mp... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %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)
leaq -0xe8(%rbp), %rdi
callq 0x4efb0
leaq -0x58(%rbp), %rdi
callq 0x54660
leaq -0x70(%rbp), %rdi
callq 0x54660
leaq -0x88(%rbp), %rdi
callq ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ecdsa.c |
mbedtls_hmac_drbg_seed | int mbedtls_hmac_drbg_seed( mbedtls_hmac_drbg_context *ctx,
const mbedtls_md_info_t * md_info,
int (*f_entropy)(void *, unsigned char *, size_t),
void *p_entropy,
const unsigned char *custom,
size_t len )
{
int ret;
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x51a60
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x11e535
movl -0x3c(%r... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/hmac_drbg.c |
mbedtls_pkcs5_pbes2 | int mbedtls_pkcs5_pbes2( const mbedtls_asn1_buf *pbe_params, int mode,
const unsigned char *pwd, size_t pwdlen,
const unsigned char *data, size_t datalen,
unsigned char *output )
{
int ret, iterations = 0, keylen = 0;
unsigned char *p, *end;
mbedtls_asn1_b... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x4, -0xd4(%rbp)
movq $0x0, -0x128(%rbp)... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pkcs5.c |
mbedtls_pkcs5_pbkdf2_hmac | int mbedtls_pkcs5_pbkdf2_hmac( mbedtls_md_context_t *ctx, const unsigned char *password,
size_t plen, const unsigned char *salt, size_t slen,
unsigned int iteration_count,
uint32_t key_length, unsigned char *output )
{
int ret, j;
unsigned int... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x546b0
movb %al, -0xc1(%rbp)
movq 0x18(%rbp), %... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pkcs5.c |
mbedtls_asn1_write_raw_buffer | int mbedtls_asn1_write_raw_buffer( unsigned char **p, unsigned char *start,
const unsigned char *buf, size_t size )
{
size_t len = 0;
if( *p - start < (int) size )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
len = size;
(*p) -= len;
memcpy( *p, buf, len );
ret... | 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 $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq -0x28(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x120493
movl $0xfff... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/asn1write.c |
mbedtls_asn1_store_named_data | mbedtls_asn1_named_data *mbedtls_asn1_store_named_data( mbedtls_asn1_named_data **head,
const char *oid, size_t oid_len,
const unsigned char *val,
size_t val_len )
{
mbedtls_asn1_named_data *cur;
... | 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 %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x55830
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x120fae
movl $0x1... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/asn1write.c |
pfederc::Lexer::getLineFromIndex[abi:cxx11](unsigned long) const | std::string Lexer::getLineFromIndex(size_t index) const noexcept {
if (index > currentEndIndex) {
fatal("lexer.cpp", __LINE__, "Out of bounds: " + std::to_string(index));
return "";
}
size_t lineIndex = getLineNumber(index);
size_t lineStartIndex = lineIndices[lineIndex];
size_t lineEndIndex = lineI... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpq %rdx, 0xa8(%rsi)
jae 0x4f65
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x5aa1
leaq 0x51b8(%rip), %rsi # 0xa0cf
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x5a7d
leaq 0x5198(%rip), %rdi # 0xa0c5
pushq $0x1c
popq %rsi
leaq 0x28(%rsp), %r14
movq %... | /federlang[P]pfederc/libs/pfederc_lexer/src/lexer.cpp |
pfederc::Token::toString[abi:cxx11](pfederc::Lexer const&) const | std::string Token::toString(const Lexer &lexer) const noexcept {
switch(getType()) {
case TokenType::TOK_KW_TRUE:
return "True";
case TokenType::TOK_KW_FALSE:
return "False";
default:
return lexer.getFileContent().substr(getPosition().startIndex,
getPosition().endIndex - getPosition().startIndex + 1);
... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzwl 0x10(%rsi), %eax
cmpl $0x2b, %eax
je 0x595c
cmpl $0x2a, %eax
jne 0x5972
leaq 0x48b8(%rip), %rsi # 0xa205
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x482e
jmp 0x5992
leaq 0x48a7(%rip), %rsi # 0xa20a
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x482e
jmp 0x5992... | /federlang[P]pfederc/libs/pfederc_lexer/src/lexer.cpp |
pfederc::Lexer::next() | Token& Lexer::next() noexcept {
if (!currentToken) {
lineIndices.push_back(0);
nextChar();
currentEndIndex = 0;
} else if (*currentToken == TokenType::TOK_EOF)
return *currentToken;
std::unique_ptr<Token> result(nextToken());
Token &tok = *result;
currentToken = result.get();
tokens.push_... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xb8(%rdi), %rdi
testq %rdi, %rdi
je 0x5fbd
pushq $0x2
popq %rsi
callq 0x859c
testb %al, %al
je 0x5fdf
movq 0xb8(%rbx), %r14
jmp 0x6018
leaq 0x70(%rbx), %rdi
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
callq 0x7dda
movq %rbx, %rdi
callq 0x602e
andq $0x0,... | /federlang[P]pfederc/libs/pfederc_lexer/src/lexer_next.cpp |
pfederc::Lexer::nextToken() | std::unique_ptr<Token> Lexer::nextToken() noexcept {
// Ignore spaces
skipSpace();
// set token starting point
currentStartIndex = currentEndIndex;
if (std::isalpha(currentChar) || currentChar == '_')
return nextTokenId();
if (_isNewLineCharacter(currentChar))
return nextTokenLine();
if (std::s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6208
movq 0xa8(%r14), %rax
movq %rax, 0xa0(%r14)
movl 0xb0(%r14), %ebp
movl %ebp, %edi
callq 0x22c0
cmpl $0x5f, %ebp
je 0x60d0
testl %eax, %eax
jne 0x60d0
cmpb $0xd, %bpl
ja 0x60ed
... | /federlang[P]pfederc/libs/pfederc_lexer/src/lexer_next.cpp |
smf::MidiFile::writeVLValue(long, std::vector<unsigned char, std::allocator<unsigned char>>&) | void MidiFile::writeVLValue(long aValue, std::vector<uchar>& outdata) {
uchar bytes[4] = {0};
if ((unsigned long)aValue >= (1 << 28)) {
std::cerr << "Error: number too large to convert to VLV" << std::endl;
aValue = 0x0FFFffff;
}
bytes[0] = (uchar)(((ulong)aValue >> 21) & 0x7f); // most significant 7 bits
b... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x25190
cmpq $0x10000000, -0x10(%rbp) # imm = 0x10000000
jb 0x39798
movq 0x2587b(%rip), %rdi # 0x5eff0
leaq 0x142c1(%rip), %rsi # 0x4da3d
c... | /dean-deng[P]midifile/src-library/MidiFile.cpp |
smf::MidiMessage::isPressure() const | bool MidiMessage::isPressure(void) const {
if (((*this)[0] & 0xf0) != 0xd0) {
return false;
} else if (size() != 2) {
return false;
} else {
return true;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x45290
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0xd0, %eax
je 0x430f2
movb $0x0, -0x1(%rbp)
jmp 0x4310b
movq -0x18(%rbp), %rdi
callq 0x3e950
cmpq $0x2, %rax
je 0x4310... | /dean-deng[P]midifile/src-library/MidiMessage.cpp |
smf::Binasc::writeToBinary(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | int Binasc::writeToBinary(std::ostream& out, const std::string& infile) {
std::ifstream input;
input.open(infile.c_str());
if (!input.is_open()) {
std::cerr << "Cannot open " << infile
<< " for reading in binasc." << std::endl;
return 0;
}
int status = writeToBinary(out, input);
input.close();
r... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x250(%rbp)
leaq -0x228(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x25380
movq -0x20(%rbp), %rdi
callq 0x25160
movq -0x248(%rbp), %rdi
movq %rax, ... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::outputStyleBinary(std::ostream&, std::istream&) | int Binasc::outputStyleBinary(std::ostream& out, std::istream& input) {
int currentByte = 0; // current byte output in line
uchar ch; // current input byte
ch = input.get();
if (input.eof()) {
std::cerr << "End of the file right away!" << std::endl;
return 0;
}
while (!input.eof()) {
if (... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x253c0
movb %al, -0x25(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x25640
t... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::processAsciiWord(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | int Binasc::processAsciiWord(std::ostream& out, const std::string& word,
int lineNum) {
int length = (int)word.size();
uchar outputByte;
if (word[0] != '+') {
std::cerr << "Error on line " << lineNum << " at token: " << word << std::endl;
std::cerr << "character byte must start with \'+\' sign: " << std::endl... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x25200
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25370
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x489fe
movq 0x... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::processVlvWord(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | int Binasc::processVlvWord(std::ostream& out, const std::string& word,
int lineNum) {
if (word.size() < 2) {
std::cerr << "Error on line: " << lineNum
<< ": 'v' needs to be followed immediately by a decimal digit"
<< std::endl;
return 0;
}
if (!isdigit(word[1])) {
std::cerr << "Error on line: " << ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x25200
cmpq $0x2, %rax
jae 0x48b5e
movq 0x164d3(%rip), %rdi # 0x5eff0
leaq 0x5fac(%rip), %rsi # 0x4ead0
callq 0x25300
movq %rax, %rdi
movl -0x24(... | /dean-deng[P]midifile/src-library/Binasc.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.