name string | code string | asm string | file string |
|---|---|---|---|
(anonymous namespace)::Json2Array<aliyun::CdnDescribeCdnServiceLockReasonType>::Json2Array(Json::Value const&, std::vector<aliyun::CdnDescribeCdnServiceLockReasonType, std::allocator<aliyun::CdnDescribeCdnServiceLockReasonType>>*) | 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 $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42590
testb $0x1, %al
jne 0x50296
jmp 0x50319
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42440
movl %eax, %ecx
movl -0x5... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-cdn/2014-11-11/src/ali_cdn_describe_cdn_service.cc |
aliyun::Cdn::DescribeRefreshTasks(aliyun::CdnDescribeRefreshTasksRequestType const&, aliyun::CdnDescribeRefreshTasksResponseType*, aliyun::CdnErrorInfo*) | int Cdn::DescribeRefreshTasks(const CdnDescribeRefreshTasksRequestType& req,
CdnDescribeRefreshTasksResponseType* response,
CdnErrorInfo* error_info) {
std::string str_response;
int status_code;
int ret = 0;
bool parse_success = false;
std::string secheme = ... | pushq %rbp
movq %rsp, %rbp
subq $0x760, %rsp # imm = 0x760
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x5f0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x415c0
movq -0x5f0(%rbp), %rax
movl $0x0, -0x48(%rbp)
movb $0x0, -0x49(%rbp)
movb 0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-cdn/2014-11-11/src/ali_cdn_describe_refresh_tasks.cc |
aliyun::Cdn::DescribeUserDomains(aliyun::CdnDescribeUserDomainsRequestType const&, aliyun::CdnDescribeUserDomainsResponseType*, aliyun::CdnErrorInfo*) | int Cdn::DescribeUserDomains(const CdnDescribeUserDomainsRequestType& req,
CdnDescribeUserDomainsResponseType* response,
CdnErrorInfo* error_info) {
std::string str_response;
int status_code;
int ret = 0;
bool parse_success = false;
std::string secheme = thi... | pushq %rbp
movq %rsp, %rbp
subq $0x6b0, %rsp # imm = 0x6B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x560(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x415c0
movq -0x560(%rbp), %rax
movl $0x0, -0x48(%rbp)
movb $0x0, -0x49(%rbp)
movb 0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-cdn/2014-11-11/src/ali_cdn_describe_user_domains.cc |
(anonymous namespace)::Json2Array<aliyun::CdnDescribeUserDomainsPageDataType>::Json2Array(Json::Value const&, std::vector<aliyun::CdnDescribeUserDomainsPageDataType, std::allocator<aliyun::CdnDescribeUserDomainsPageDataType>>*) | 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 $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42590
testb $0x1, %al
jne 0x55869
jmp 0x5590d
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xf0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42440... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-cdn/2014-11-11/src/ali_cdn_describe_user_domains.cc |
(anonymous namespace)::Json2Type(Json::Value const&, aliyun::CdnDescribeUserDomainsPageDataType*) | void Json2Type(const Json::Value& value, CdnDescribeUserDomainsPageDataType* item) {
if(value.isMember("DomainName")) {
item->domain_name = value["DomainName"].asString();
}
if(value.isMember("Cname")) {
item->cname = value["Cname"].asString();
}
if(value.isMember("CdnType")) {
item->cdn_t... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x8472f(%rip), %rsi # 0xda07d
callq 0x3fc20
testb $0x1, %al
jne 0x55959
jmp 0x5598b
movq -0x8(%rbp), %rdi
leaq 0x84719(%rip), %rsi # 0xda07d
callq 0x428f0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
ca... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-cdn/2014-11-11/src/ali_cdn_describe_user_domains.cc |
aliyun::Cdn::ModifyCdnService(aliyun::CdnModifyCdnServiceRequestType const&, aliyun::CdnModifyCdnServiceResponseType*, aliyun::CdnErrorInfo*) | int Cdn::ModifyCdnService(const CdnModifyCdnServiceRequestType& req,
CdnModifyCdnServiceResponseType* response,
CdnErrorInfo* error_info) {
std::string str_response;
int status_code;
int ret = 0;
bool parse_success = false;
std::string secheme = this->use_tl... | pushq %rbp
movq %rsp, %rbp
subq $0x660, %rsp # imm = 0x660
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x518(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x415c0
movq -0x518(%rbp), %rax
movl $0x0, -0x48(%rbp)
movb $0x0, -0x49(%rbp)
movb 0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-cdn/2014-11-11/src/ali_cdn_modify_cdn_service.cc |
aliyun::Cdn::OpenCdnService(aliyun::CdnOpenCdnServiceRequestType const&, aliyun::CdnOpenCdnServiceResponseType*, aliyun::CdnErrorInfo*) | int Cdn::OpenCdnService(const CdnOpenCdnServiceRequestType& req,
CdnOpenCdnServiceResponseType* response,
CdnErrorInfo* error_info) {
std::string str_response;
int status_code;
int ret = 0;
bool parse_success = false;
std::string secheme = this->use_tls_ ? "... | pushq %rbp
movq %rsp, %rbp
subq $0x660, %rsp # imm = 0x660
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x518(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x415c0
movq -0x518(%rbp), %rax
movl $0x0, -0x48(%rbp)
movb $0x0, -0x49(%rbp)
movb 0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-cdn/2014-11-11/src/ali_cdn_open_cdn_service.cc |
aliyun::Cdn::StartCdnDomain(aliyun::CdnStartCdnDomainRequestType const&, aliyun::CdnStartCdnDomainResponseType*, aliyun::CdnErrorInfo*) | int Cdn::StartCdnDomain(const CdnStartCdnDomainRequestType& req,
CdnStartCdnDomainResponseType* response,
CdnErrorInfo* error_info) {
std::string str_response;
int status_code;
int ret = 0;
bool parse_success = false;
std::string secheme = this->use_tls_ ? "... | pushq %rbp
movq %rsp, %rbp
subq $0x660, %rsp # imm = 0x660
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x518(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x415c0
movq -0x518(%rbp), %rax
movl $0x0, -0x48(%rbp)
movb $0x0, -0x49(%rbp)
movb 0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-cdn/2014-11-11/src/ali_cdn_start_cdn_domain.cc |
aliyun::Cdn::StopCdnDomain(aliyun::CdnStopCdnDomainRequestType const&, aliyun::CdnStopCdnDomainResponseType*, aliyun::CdnErrorInfo*) | int Cdn::StopCdnDomain(const CdnStopCdnDomainRequestType& req,
CdnStopCdnDomainResponseType* response,
CdnErrorInfo* error_info) {
std::string str_response;
int status_code;
int ret = 0;
bool parse_success = false;
std::string secheme = this->use_tls_ ? "htt... | pushq %rbp
movq %rsp, %rbp
subq $0x660, %rsp # imm = 0x660
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x518(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x415c0
movq -0x518(%rbp), %rax
movl $0x0, -0x48(%rbp)
movb $0x0, -0x49(%rbp)
movb 0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-cdn/2014-11-11/src/ali_cdn_stop_cdn_domain.cc |
aliyun::AliGetEndpointHost(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | std::string AliGetEndpointHost(std::string region, std::string product) {
std::string ret;
for(int i = 0; regions[i].region_name_ ; i++) {
for(int j = 0; regions[i].productions[j].product_name_ ; j++) {
if(regions[i].productions[j].product_name_ == product) {
ret = regions[i].productions[j].d... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x415c0
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rcx
leaq 0xb22f2(%rip), %rax # 0x10f37... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/ali_get_region_host.cc |
AliRpcRequest::AliRpcRequest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<c... | AliRpcRequest::AliRpcRequest(std::string version,
std::string appid,
std::string secret,
std::string url)
: AliHttpRequest(url),
version_(v... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %r8, -0x90(%rbp)
movq %rsi, %rax
movq -0x90(%rbp), %rsi
movq %rax, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
movq %rcx, -0x78(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x8... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/ali_rpc_request.cc |
mbedtls_base64_self_test | int mbedtls_base64_self_test( int verbose )
{
size_t len;
const unsigned char *src;
unsigned char buffer[128];
if( verbose != 0 )
mbedtls_printf( " Base64 encoding test: " );
src = base64_test_dec;
if( mbedtls_base64_encode( buffer, sizeof( buffer ), &len, src, 64 ) != 0 ||
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x642a2
leaq 0x7687e(%rip), %rdi # 0xdab19
movb $0x0, %al
callq 0x3d1e0
leaq 0x767d7(%rip), %rax # 0xdaa80
movq %rax, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x80, %esi
leaq -0x10(%rbp), %rdx
movl ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/base64.c |
mbedtls_ripemd160_process | void mbedtls_ripemd160_process( mbedtls_ripemd160_context *ctx, const unsigned char data[64] )
{
uint32_t A, B, C, D, E, Ap, Bp, Cp, Dp, Ep, X[16];
GET_UINT32_LE( X[ 0], data, 0 );
GET_UINT32_LE( X[ 1], data, 4 );
GET_UINT32_LE( X[ 2], data, 8 );
GET_UINT32_LE( X[ 3], data, 12 );
GET_UINT32_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ripemd160.c |
mbedtls_ripemd160_finish | void mbedtls_ripemd160_finish( mbedtls_ripemd160_context *ctx, unsigned char output[20] )
{
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 );
... | 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/ripemd160.c |
mbedtls_ssl_write_change_cipher_spec | int mbedtls_ssl_write_change_cipher_spec( mbedtls_ssl_context *ssl )
{
int ret;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write change cipher spec" ) );
ssl->out_msgtype = MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC;
ssl->out_msglen = 1;
ssl->out_msg[0] = 1;
ssl->state++;
if( ( ret = mbedtls_ssl_write_re... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x66270(%rip), %rdx # 0xdf36c
movl $0x1135, %ecx # imm = 0x1135
leaq 0x66b3c(%rip), %r8 # 0xdfc44
movb $0x0, %al
callq 0x42fc0
movq -0x10(%rbp), %rax
movl $0x14, 0x150(%rax)
movq -0x10(%rbp)... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_tls.c |
ssl_write_split | static int ssl_write_split( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
int ret;
if( ssl->conf->cbc_record_splitting ==
MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED ||
len <= 1 ||
ssl->minor_ver > MBEDTLS_SSL_MINOR_VERSION_1 ||
... | 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), %rax
movl 0x164(%rax), %eax
shrl $0xd, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7cab6
cmpq $0x1, -0x20(%rbp)
jbe 0x7cab6
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jg 0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_tls.c |
Json::Reader::readValue() | bool
Reader::readValue()
{
Token token;
skipCommentTokens( token );
bool successful = true;
if ( collectComments_ && !commentsBefore_.empty() )
{
currentValue().setComment( commentsBefore_, commentBefore );
commentsBefore_ = "";
}
switch ( token.type_ )
{
case tokenObjectBegi... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x42350
movq -0xb8(%rbp), %rax
movb $0x1, -0x29(%rbp)
testb $0x1, 0x10a(%rax)
je 0x84e7c
movq -0xb8(%rbp), %rdi
addq $0xe8, %rdi
callq 0x42640
testb $0x1, %al
jne 0x84e7c
movq -0... | /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 0x41480
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::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 0x866b7
movb $0x0, -0x1(%rbp)
jmp 0x86717
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::decodeString(Json::Reader::Token&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool
Reader::decodeString( Token &token, std::string &decoded )
{
decoded.reserve( token.end_ - token.start_ - 2 );
Location current = token.start_ + 1; // skip '"'
Location end = token.end_ - 1; // do not include '"'
while ( current != end )
{
Char c = *current++;
if ( c == '"' )
... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
subq %rax, %rsi
subq $0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::codePointToUTF8[abi:cxx11](unsigned int) | static inline std::string
codePointToUTF8(unsigned int cp)
{
std::string result;
// based on description from http://en.wikipedia.org/wiki/UTF-8
if (cp <= 0x7f)
{
result.resize(1);
result[0] = static_cast<char>(cp);
}
else if (cp <= 0x7FF)
{
result.resize(2);
result... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x415c0
cmpl $0x7f, -0xc(%rbp)
ja 0x8769d
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x41580
jmp 0x8765c
movq -0x30(%rbp), %rdi
movb -0xc(%r... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_tool.h |
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 0x879c1
leaq -0x... | /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 0x8b4aa
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x8b450
cmpq $0x0, -0x10(%rbp)
je 0x8b4b3
jmp 0x8b4d2
leaq 0x56bea(%rip), %rdi # 0xe20a4
leaq 0x56bed(%rip... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Json::Value::Value(Json::ValueType) | Value::Value( ValueType type )
: type_( type )
, allocated_( false )
# ifdef JSON_VALUE_USE_INTERNAL_MAP
, itemIsUsed_( 0 )
#endif
, comments_( 0 )
{
switch ( type )
{
case nullValue:
break;
case intValue:
case uintValue:
value_.int_ = 0;
break;
case realValue:
valu... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb -0xc(%rbp), %cl
movb %cl, 0x8(%rax)
movb 0x9(%rax), %cl
andb $-0x2, %cl
movb %cl, 0x9(%rax)
movq $0x0, 0x10(%rax)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x8b... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Json::Value::isInt64() const | bool
Value::isInt64() const
{
# if defined(JSON_HAS_INT64)
switch ( type_ )
{
case intValue:
return true;
case uintValue:
return value_.uint_ <= UInt64(maxInt64);
case realValue:
// Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
// double, so double(maxInt64) wi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, -0x14(%rbp)
subw $0x1, %ax
je 0x8d2aa
jmp 0x8d296
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x8d2b0
jmp 0x8d2a0
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Json::Value::getComment[abi:cxx11](Json::CommentPlacement) const | std::string
Value::getComment( CommentPlacement placement ) const
{
if ( hasComment(placement) )
return comments_[placement].comment_;
return "";
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0x41150
testb $0x1, %al
jne 0x8f6a4
jmp 0x8f6f9
movq -0x30(%rbp), %rax
... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Json::Value::begin() | Value::iterator
Value::begin()
{
switch ( type_ )
{
#ifdef JSON_VALUE_USE_INTERNAL_MAP
case arrayValue:
if ( value_.array_ )
{
ValueInternalArray::IteratorState it;
value_.array_->makeBeginIterator( it );
return iterator( it );
}
break;
case objectValue:
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl 0x8(%rax), %eax
addl $-0x6, %eax
subl $0x1, %eax
ja 0x8f93c
jmp 0x8f911
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Json::Path::make(Json::Value&) const | Value &
Path::make( Value &root ) const
{
Value *node = &root;
for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
{
const PathArgument &arg = *it;
if ( arg.kind_ == PathArgument::kindIndex )
{
if ( !node->isArray() )
{
// Error: node is not ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x41840
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3e230
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %r... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Json::StyledWriter::writeCommentBeforeValue(Json::Value const&) | void
StyledWriter::writeCommentBeforeValue( const Value &root )
{
if ( !root.hasComment( commentBefore ) )
return;
document_ += normalizeEOL( root.getComment( commentBefore ) );
document_ += "\n";
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x41150
testb $0x1, %al
jne 0x96189
jmp 0x961e4
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
xorl %edx, %edx
callq 0x... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_writer.cpp |
Json::StyledWriter::normalizeEOL(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
StyledWriter::normalizeEOL( const std::string &text )
{
std::string normalized;
normalized.reserve( text.length() );
const char *begin = text.c_str();
const char *end = begin + text.length();
const char *current = begin;
while ( current != end )
{
char c = *current++;
if ( ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x415c0
movq -0x10(%rbp), %rdi
callq 0x41c70
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x42050
jmp 0x9731b
movq -0x10(%rbp), %rdi
callq 0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_writer.cpp |
Json::StyledStreamWriter::writeValue(Json::Value const&) | void
StyledStreamWriter::writeValue( const Value &value )
{
switch ( value.type() )
{
case nullValue:
pushValue( "null" );
break;
case intValue:
pushValue( valueToString( value.asLargestInt() ) );
break;
case uintValue:
pushValue( valueToString( value.asLargestUInt() ) );
... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x421c0
movl %eax, %ecx
movq %rcx, -0x1c0(%rbp)
subl $0x7, %eax
ja 0x97c58
movq -0x1c0(%rbp), %rax
leaq 0x4b1dd(%rip), %rcx # ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_writer.cpp |
ssl_get_ecdh_params_from_cert | static int ssl_get_ecdh_params_from_cert( mbedtls_ssl_context *ssl )
{
int ret;
const mbedtls_ecp_keypair *peer_key;
if( ssl->session_negotiate->peer_cert == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 2, ( "certificate required" ) );
return( MBEDTLS_ERR_SSL_UNEXPECTED_MESSAGE );
}
if( ! m... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
cmpq $0x0, 0x68(%rax)
jne 0xc8dba
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x20989(%rip), %rdx # 0xe9724
movl $0x7ca, %ecx # imm = 0x7CA
leaq 0x21490(%rip), %r8 # 0xea237
movb $0x0, %al... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_cli.c |
ssl_parse_server_ecdh_params | static int ssl_parse_server_ecdh_params( mbedtls_ssl_context *ssl,
unsigned char **p,
unsigned char *end )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
/*
* Ephemeral ECDH parameters:
*
* struct {
* EC... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffff8f80, -0x24(%rbp) # imm = 0xFFFF8F80
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
addq $0x108, %rdi # imm = 0x108
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3d3b0
movl %eax,... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_cli.c |
ssl_check_server_ecdh_params | static int ssl_check_server_ecdh_params( const mbedtls_ssl_context *ssl )
{
const mbedtls_ecp_curve_info *curve_info;
curve_info = mbedtls_ecp_curve_info_from_grp_id( ssl->handshake->ecdh_ctx.grp.id );
if( curve_info == NULL )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "should never happen" ) );
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movl 0x108(%rax), %edi
callq 0x3f4d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc9409
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x2033a(%rip), %rdx # 0xe9724
movl $0x6db, %ecx # imm ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_cli.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 0xc94da
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
cmpq $0x0, 0x388(%rax)
je 0xc94da
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x388(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc94ec
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 |
ssl_write_encrypted_pms | static int ssl_write_encrypted_pms( mbedtls_ssl_context *ssl,
size_t offset, size_t *olen,
size_t pms_offset )
{
int ret;
size_t len_bytes = ssl->minor_ver == MBEDTLS_SSL_MINOR_VERSION_0 ? 0 : 2;
unsigned char *p = ssl->handshake->prema... | 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 -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movl $0x2, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_cli.c |
mbedtls_ssl_own_cert | static inline mbedtls_x509_crt *mbedtls_ssl_own_cert( 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 0xc981a
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
cmpq $0x0, 0x388(%rax)
je 0xc981a
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x388(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc982c
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_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 0xce249
movq $0xc, -0x8(%rbp)
jmp 0xce251
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_parse_truncated_hmac_ext | static int ssl_parse_truncated_hmac_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
if( len != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_H... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcea97
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x1bdf1(%rip), %rdx # 0xea86c
movl $0x159, %ecx # imm = 0x159
leaq 0x1bec8(%rip), %r8 # 0xea94f
movb $0x0, %a... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
ssl_parse_extended_ms_ext | static int ssl_parse_extended_ms_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
if( len != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcebb7
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x1bcd1(%rip), %rdx # 0xea86c
movl $0x184, %ecx # imm = 0x184
leaq 0x1bda8(%rip), %r8 # 0xea94f
movb $0x0, %a... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
ssl_parse_alpn_ext | static int ssl_parse_alpn_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf, size_t len )
{
size_t list_len, cur_len, ours_len;
const unsigned char *theirs, *start, *end;
const char **ours;
/* If ALPN not configured, just ignore the extension */
if( ssl->conf->a... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x138(%rax)
jne 0xceeb1
movl $0x0, -0x4(%rbp)
jmp 0xcf013
cmpq $0x4, -0x20(%rbp)
jae 0xceec4
movl $0xffff8700, -0x4(%rbp) # imm = 0xFFFF8700
jmp 0xcf013
mo... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
mbedtls_ssl_safer_memcmp | static inline int mbedtls_ssl_safer_memcmp( const void *a, const void *b, size_t n )
{
size_t i;
const unsigned char *A = (const unsigned char *) a;
const unsigned char *B = (const unsigned char *) b;
unsigned char diff = 0;
for( i = 0; i < n; i++ )
diff |= A[i] ^ B[i];
return( diff );... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xcf327
movq -0x28(%rbp), %rax
movq -0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/include/mbedtls/ssl_internal.h |
ssl_check_key_curve | static int ssl_check_key_curve( mbedtls_pk_context *pk,
const mbedtls_ecp_curve_info **curves )
{
const mbedtls_ecp_curve_info **crv = curves;
mbedtls_ecp_group_id grp_id = mbedtls_pk_ec( *pk )->grp.id;
while( *crv != NULL )
{
if( (*crv)->grp_id == grp_id )
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0xcf690
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xcf67c
movq -0x20(%rbp... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
ssl_write_hello_verify_request | static int ssl_write_hello_verify_request( mbedtls_ssl_context *ssl )
{
int ret;
unsigned char *p = ssl->out_msg + 4;
unsigned char *cookie_len_byte;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> write hello verify request" ) );
/*
* struct {
* ProtocolVersion server_version;
* opaque cookie<... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x1b18d(%rip), %rdx # 0xea86c
movl $0x804, %ecx # imm = 0x804
leaq 0x1bacd(%rip), %r8 # 0xeb1b8
movb $0x... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
ssl_write_renegotiation_ext | static void ssl_write_renegotiation_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
if( ssl->secure_renegotiation != MBEDTLS_SSL_SECURE_RENEGOTIATION )
{
*olen = 0;
... | 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
cmpl $0x1, 0x190(%rax)
je 0xcf969
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0xcfad0
movq -0x8(%rbp), %rdi
movl $0x3, %esi
leaq 0x1aef3(%r... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
ssl_write_truncated_hmac_ext | static void ssl_write_truncated_hmac_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
if( ssl->session_negotiate->trunc_hmac == MBEDTLS_SSL_TRUNC_HMAC_DISABLED )
{
*olen = ... | 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 0x58(%rax), %rax
cmpl $0x0, 0x90(%rax)
jne 0xcfbfa
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0xcfc70
movq -0x8(%rbp), %rdi
movl $0x3... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
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 0xcfdd7
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xcfde4
movq -0x18(%rbp), %rax
movq ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
ssl_write_supported_point_formats_ext | static void ssl_write_supported_point_formats_ext( mbedtls_ssl_context *ssl,
unsigned char *buf,
size_t *olen )
{
unsigned char *p = buf;
((void) ssl);
if( ( ssl->handshake->cli_exts &
MBEDTLS_TL... | 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
movl 0xa90(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xcff62
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0xcfff... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
ssl_parse_client_dh_public | static int ssl_parse_client_dh_public( mbedtls_ssl_context *ssl, unsigned char **p,
const unsigned char *end )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t n;
/*
* Receive G^Y mod P, premaster = (G^Y)^X mod P
*/
if( *p + 2 > end )
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffff8f80, -0x24(%rbp) # imm = 0xFFFF8F80
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x2, %rax
cmpq -0x20(%rbp), %rax
jbe 0xd02eb
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x1a5a0(%rip), %rdx ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
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 0xd0bee
movl $0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509.c |
mbedtls_x509_get_name | int mbedtls_x509_get_name( unsigned char **p, const unsigned char *end,
mbedtls_x509_name *cur )
{
int ret;
size_t set_len;
const unsigned char *end_set;
/* don't use recursion, we'd risk stack overflow if not optimized */
while( 1 )
{
/*
* parse SET
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %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 $0x31, %ecx
callq 0x3f6b0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xd10c2
movl -0x24(%rbp), %eax
addl $0xffffdc80, %eax # imm... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509.c |
PyInit_ikfast_kukakr3r540 | PYBIND11_MODULE(ikfast_kukakr3r540, m)
{
m.doc() = R"pbdoc(
ikfast_pybind_kukakr3r540
-----------------------
.. currentmodule:: ikfast_pybind_kukakr3r540
.. autosummary::
:toctree: _generate
get_ik
get_fk
)pbdoc";
m.def("get_ik", [](const st... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
callq 0x65f0
movq %rax, %r14
leaq 0x2cf30(%rip), %rsi # 0x34038
movl $0x4, %edx
movq %rax, %rdi
callq 0x6320
testl %eax, %eax
jne 0x7123
movb 0x4(%r14), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x7158
movq 0x35eae(%rip), %rax # 0x3cfd8
movq (... | /Simon-Steinmann[P]ikfast_pybind_PR/src/kukakr3r540/ikfast_pybind_kukakr3r540.cpp |
pybind11::module::module(char const*, char const*) | explicit module(const char *name, const char *doc = nullptr) {
if (!options::show_user_defined_docstrings()) doc = nullptr;
#if PY_MAJOR_VERSION >= 3
PyModuleDef *def = new PyModuleDef();
std::memset(def, 0, sizeof(PyModuleDef));
def->m_name = name;
def->m_doc = doc;
def-... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, (%rdi)
movb 0x35724(%rip), %bpl # 0x3d6c0
movl $0x68, %edi
callq 0x66f0
xorl %ecx, %ecx
testb %bpl, %bpl
cmoveq %rcx, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xm... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pybind11.h |
void pybind11::detail::accessor<pybind11::detail::accessor_policies::str_attr>::operator=<char const (&) [217]>(char const (&) [217]) && | void operator=(T &&value) && {
Policy::set(obj, key, object_or_cast(std::forward<T>(value)));
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %r14
movq %rsi, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0xa464
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x811a
movq %rsp, %rdi
callq 0x12f1e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
c... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pytypes.h |
void pybind11::detail::accessor<pybind11::detail::accessor_policies::str_attr>::operator=<char const (&) [4]>(char const (&) [4]) && | void operator=(T &&value) && {
Policy::set(obj, key, object_or_cast(std::forward<T>(value)));
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %r14
movq %rsi, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0xa464
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x811a
movq %rsp, %rdi
callq 0x12f1e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
c... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pytypes.h |
ZNK8pybind113strcvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv | operator std::string() const {
object temp = *this;
if (PyUnicode_Check(m_ptr)) {
temp = reinterpret_steal<object>(PyUnicode_AsUTF8String(m_ptr));
if (!temp)
pybind11_fail("Unable to extract string contents! (encoding issue)");
}
char *buffer;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x8cac
incq (%rax)
movq (%rsi), %rdi
movq 0x8(%rdi), %rax
testb $0x10, 0xab(%rax)
je 0x8ce7
callq 0x6d50
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %r... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pytypes.h |
pybind11::detail::clean_type_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | PYBIND11_NOINLINE inline void clean_type_id(std::string &name) {
#if defined(__GNUG__)
int status = 0;
std::unique_ptr<char, void (*)(void *)> res {
abi::__cxa_demangle(name.c_str(), nullptr, nullptr, &status), std::free };
if (status == 0)
name = res.get();
#else
detail::erase_all(name,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x24(%rsp), %r15
movl $0x0, (%r15)
movq (%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x65e0
movq %rax, %rbx
cmpl $0x0, (%r15)
jne 0x94cc
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0x62e0
movq %r14, %rdi
xorl %esi, %e... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/typeid.h |
pybind11::detail::get_internals() | PYBIND11_NOINLINE inline internals &get_internals() {
auto **&internals_pp = get_internals_pp();
if (internals_pp && *internals_pp)
return **internals_pp;
// Ensure that the GIL is held since we will need to make Python calls.
// Cannot use py::gil_scoped_acquire here since that constructor cal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq 0x3400d(%rip), %rax # 0x3d728
testq %rax, %rax
je 0x972c
movq (%rax), %r14
testq %r14, %r14
jne 0x9b10
callq 0x6cc0
movl %eax, %ebx
leaq 0x2ad1d(%rip), %rax # 0x34457
movq %rax, 0x48(%rsp)
callq 0x6a50
leaq 0x18(%rsp), %rdi
movq %rax, ... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/internals.h |
bool pybind11::detail::object_api<pybind11::handle>::contains<char const* const&>(char const* const&) const | bool object_api<D>::contains(T &&item) const {
return attr("__contains__")(std::forward<T>(item)).template cast<bool>();
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq (%rdi), %rax
leaq 0x28(%rsp), %rbx
movq %rax, -0x10(%rbx)
leaq 0x2a8d5(%rip), %rax # 0x344af
movq %rax, -0x8(%rbx)
movq $0x0, (%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xa1ee
leaq 0x8(%rsp), %rdi
callq 0xa636
movl %eax, %ebp
leaq 0... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pytypes.h |
pybind11::detail::make_static_property_type() | inline PyTypeObject *make_static_property_type() {
constexpr auto *name = "pybind11_static_property";
auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
/* Danger zone: from now (and until PyType_Ready), make sure to
issue no Python C API calls which could potentially invoke the
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x2aa1b(%rip), %r14 # 0x3472d
movq %r14, %rdi
callq 0x65c0
movq %rax, 0x10(%rsp)
movq 0x3320a(%rip), %rdi # 0x3cf30
xorl %esi, %esi
callq *0x130(%rdi)
movq %rax, %rbx
testq %rax, %rax
je 0x9dfc
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x9d5e
movq (%rax), %rcx
leaq 0x... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/class.h |
pybind11::tuple pybind11::make_tuple<(pybind11::return_value_policy)1, char const* const&>(char const* const&) | tuple make_tuple(Args&&... args_) {
constexpr size_t size = sizeof...(Args);
std::array<object, size> args {
{ reinterpret_steal<object>(detail::make_caster<Args>::cast(
std::forward<Args>(args_), policy, nullptr))... }
};
for (size_t i = 0; i < args.size(); i++) {
if (!args[... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xa464
movq %rax, (%rsp)
testq %rax, %rax
je 0xa30b
movl $0x1, %esi
movq %rbx, %rdi
callq 0xa598
movq (%rsp), %rax
movq $0x0, (%rsp)
movq (%rbx), %rcx
movq 0x8(%rcx), %rdx
testb $0x4, 0xa... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
std::enable_if<!detail::move_never<bool>::value, bool>::type pybind11::move<bool>(pybind11::object&&) | detail::enable_if_t<!detail::move_never<T>::value, T> move(object &&obj) {
if (obj.ref_count() > 1)
#if defined(NDEBUG)
throw cast_error("Unable to cast Python instance to C++ rvalue: instance has multiple references"
" (compile in debug mode for details)");
#else
throw cast_error("Unabl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpl $0x2, (%rax)
jge 0xa6a3
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa8f5
movb (%rbx), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %e... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::detail::type_caster<bool, void>& pybind11::detail::load_type<bool, void>(pybind11::detail::type_caster<bool, void>&, pybind11::handle const&) | type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
if (!conv.load(handle, true)) {
#if defined(NDEBUG)
throw cast_error("Unable to cast Python instance to C++ type (compile in debug mode for details)");
#else
throw cast_error("Unable to cast Python instance of ty... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movl $0x1, %edx
callq 0xab80
testb %al, %al
je 0xa92e
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x6340
movq %rax, %rbx
movq (%r14... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11_object_init | inline int pybind11_object_init(PyObject *self, PyObject *, PyObject *) {
PyTypeObject *type = Py_TYPE(self);
std::string msg;
#if defined(PYPY_VERSION)
msg += handle((PyObject *) type).attr("__module__").cast<std::string>() + ".";
#endif
msg += type->tp_name;
msg += ": No constructor defined!";
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %rax
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x18(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6d30
leaq 0x2a2e0(%rip), %rsi # 0x353cd
leaq 0x8(%rsp), %rdi
callq 0x6d30
movq 0x31eaa(%rip), %rax # 0x3cfa8
movq (%... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/class.h |
pybind11::cpp_function::initialize_generic(pybind11::detail::function_record*, char const*, std::type_info const* const*, unsigned long) | void initialize_generic(detail::function_record *rec, const char *text,
const std::type_info *const *types, size_t args) {
/* Create copies of all referenced C-style strings */
rec->name = strdup(rec->name ? rec->name : "");
if (rec->doc) rec->doc = strdup(rec->doc);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %r8, 0x110(%rsp)
movq %rcx, 0xc0(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, 0xb0(%rsp)
movq (%rsi), %rax
testq %rax, %rax
leaq 0x2947e(%rip), %rdi # 0x34fce
cmovneq %rax, %rdi
callq 0x6c90
movq %r... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pybind11.h |
pybind11::object pybind11::detail::object_api<pybind11::detail::accessor<pybind11::detail::accessor_policies::str_attr>>::operator()<(pybind11::return_value_policy)1>() const | object object_api<Derived>::operator()(Args &&...args) const {
return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
xorl %esi, %esi
callq 0xa598
movq %r14, %rdi
callq 0x8f2c
movq (%rax), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa240
movq %rsp, %rdi
callq 0x12f1e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::detail::instance::get_value_and_holder(pybind11::detail::type_info const*, bool) | PYBIND11_NOINLINE inline value_and_holder instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/, bool throw_if_missing /*= true in common.h*/) {
// Optimize common case:
if (!find_type || Py_TYPE(this) == find_type->type)
return value_and_holder(this, find_type, 0, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xfa70
movq 0x8(%rbx), %r12
cmpq (%r15), %r12
je 0xfa70
movl %ecx, %ebp
movq %rbx, 0xa8(%rsp)
movq %r12, %rdi
callq 0xb31e
movq %rax, %r13
test... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/cast.h |
pybind11::cpp_function::destruct(pybind11::detail::function_record*) | static void destruct(detail::function_record *rec) {
while (rec) {
detail::function_record *next = rec->next;
if (rec->free_data)
rec->free_data(rec);
std::free((char *) rec->name);
std::free((char *) rec->doc);
std::free((char *) rec->... | testq %rdi, %rdi
je 0x115dd
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rbx), %rax
movq 0x78(%rbx), %r14
testq %rax, %rax
je 0x1152e
movq %rbx, %rdi
callq *%rax
movq (%rbx), %rdi
callq 0x6810
movq 0x8(%rbx), %rdi
callq 0x6810
movq 0x10(%rbx), %rdi
callq 0x6810
movq 0x18(%rbx), %r15... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/pybind11.h |
pybind11::detail::clear_instance(_object*) | inline void clear_instance(PyObject *self) {
auto instance = reinterpret_cast<detail::instance *>(self);
// Deallocate any values/holders, if present:
for (auto &v_h : values_and_holders(instance)) {
if (v_h) {
// We have to deregister before we call dealloc because, for virtual MI typ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0xb31e
movq %rax, %r14
movq %rax, %r12
testb $0x1, %dl
je 0x118fb
leaq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0xb3fe
addq $0x10, %r14
movq %rbx, (%rsp)
movq %r14, 0x8(%rsp)
movq ... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/detail/class.h |
pybind11::handle pybind11::detail::list_caster<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>, std::vector<double, std::allocator<double>>>::cast<std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::alloca... | static handle cast(T &&src, return_value_policy policy, handle parent) {
if (!std::is_lvalue_reference<T>::value)
policy = return_value_policy_override<Value>::policy(policy);
list l(src.size());
size_t index = 0;
for (auto &&value : src) {
auto value_ = reinterpr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movl %esi, %ebp
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
leaq 0x8(%rsp), %rdi
callq 0x12df2
movq (%r14), %r15
mo... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/stl.h |
pybind11::handle pybind11::detail::list_caster<std::vector<double, std::allocator<double>>, double>::cast<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>&&, pybind11::return_value_policy, pybind11::handle) | static handle cast(T &&src, return_value_policy policy, handle parent) {
if (!std::is_lvalue_reference<T>::value)
policy = return_value_policy_override<Value>::policy(policy);
list l(src.size());
size_t index = 0;
for (auto &&value : src) {
auto value_ = reinterpr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
subq (%rdi), %rsi
sarq $0x3, %rsi
leaq 0x8(%rsp), %rdi
callq 0x12df2
movq (%rbx), %r12
movq 0x8(%rbx), %r13
cmpq %r13, %r12
je 0x12ebf
xorl %ebx, %ebx
leaq 0x10(%rsp), %r14
xorl %ebp, %ebp
movsd (%r12... | /Simon-Steinmann[P]ikfast_pybind_PR/ext/pybind11/include/pybind11/stl.h |
ikfast::IkSolutionList<double>::GetSolution(unsigned long) const | virtual const IkSolutionBase<T>& GetSolution(size_t index) const
{
if( index >= _listsolutions.size() ) {
throw std::runtime_error("GetSolution index is invalid");
}
typename std::list< IkSolution<T> >::const_iterator it = _listsolutions.begin();
std::advance(it,index);
... | pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, 0x18(%rdi)
jbe 0x13080
movq 0x8(%rdi), %rax
testq %rsi, %rsi
jle 0x13069
movq (%rax), %rax
decq %rsi
jne 0x1305f
jmp 0x13074
je 0x13074
movq 0x8(%rax), %rax
incq %rsi
jne 0x1306b
addq $0x10, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x6340
movq %rax... | /Simon-Steinmann[P]ikfast_pybind_PR/src/kukakr3r540/ikfast.h |
ikfast::IkSolution<double>::GetSolution(double*, double const*) const | virtual void GetSolution(T* solution, const T* freevalues) const {
for(std::size_t i = 0; i < _vbasesol.size(); ++i) {
if( _vbasesol[i].freeind < 0 )
solution[i] = _vbasesol[i].foffset;
else {
solution[i] = freevalues[_vbasesol[i].freeind]*_vbasesol[i].fmu... | movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
subq %rax, %rdi
je 0x133f7
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x10, %rax
xorl %edi, %edi
movsd 0x20c85(%rip), %xmm0 # 0x34018
movsd 0x20c95(%rip), %xmm1 # 0x34030
movsd 0x20... | /Simon-Steinmann[P]ikfast_pybind_PR/src/kukakr3r540/ikfast.h |
ikfast::IkSolution<double>::Validate() const | virtual void Validate() const {
for(size_t i = 0; i < _vbasesol.size(); ++i) {
if( _vbasesol[i].maxsolutions == (unsigned char)-1) {
throw std::runtime_error("max solutions for joint not initialized");
}
if( _vbasesol[i].maxsolutions > 0 ) {
if... | pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
subq %rax, %rdx
je 0x134ef
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x14, %rax
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
movabsq $0x7... | /Simon-Steinmann[P]ikfast_pybind_PR/src/kukakr3r540/ikfast.h |
ComputeFk(double const*, double*, double*) | IKFAST_API void ComputeFk(const IkReal* j, IkReal* eetrans, IkReal* eerot) {
IkReal x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49;
x0=IKcos(j[0]);
x1=IKcos(j[1]);
x2=IKsin(j[2]... | pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movsd (%rdi), %xmm0
callq 0x6cb0
movaps %xmm0, 0xb0(%rsp)
movsd 0x8(%r15), %xmm0
callq 0x6cb0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%r15), %xmm0
callq 0x6100
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%r15), %xmm0
callq 0x6cb0
movaps ... | /Simon-Steinmann[P]ikfast_pybind_PR/src/kukakr3r540/ikfast61_kukakr3r540.cpp |
IKSolver::polyroots4(double*, double*, int&) | static inline void polyroots4(IkReal rawcoeffs[4+1], IkReal rawroots[4], int& numroots)
{
using std::complex;
if( rawcoeffs[0] == 0 ) {
// solve with one reduced degree
polyroots3(&rawcoeffs[1], &rawroots[0], numroots);
return;
}
IKFAST_ASSERT(rawcoeffs[0] != 0);
const IkReal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movsd (%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x32b23
jp 0x32b23
addq $0x8, %rdi
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32ecc
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
xorpd... | /Simon-Steinmann[P]ikfast_pybind_PR/src/kukakr3r540/ikfast61_kukakr3r540.cpp |
bsp_nprocs | bsp_pid_t bsp_nprocs()
{
if (!s_spmd) {
int init, fini;
MPI_Initialized( & init );
MPI_Finalized( &fini );
if ( fini )
bsp_abort("bsp_nprocs: internal error\n");
if (!init ) {
MPI_Init(NULL, NULL);
atexit( bsp_check_exit );
... | movq 0x11098(%rip), %rax # 0x172c8
testq %rax, %rax
je 0x6239
movl 0x24(%rax), %eax
retq
pushq %rbx
subq $0x10, %rsp
leaq 0x4(%rsp), %rdi
callq 0x5140
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x5250
cmpl $0x0, (%rbx)
je 0x6268
leaq 0xa394(%rip), %rdi # 0x105f5
xorl %eax, %eax
callq 0x5a11
cmpl $0x0, 0x4(%rsp... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bsplib::Rdma::get(int, unsigned long, unsigned long, void*, unsigned long) | void Rdma::get( int src_pid, Memslot src_slot, size_t src_offset,
void * dst, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::GET );
#endif
assert( !( slot( m_pid, src_slot ).status & Memblock::PUSHED) );
Memslot dst_slot = m_local_slots.size();
m_local_slots.push_back( dst );
Action acti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movl %esi, %ebp
movq %r8, 0x8(%rsp)
movslq 0x2f4(%rdi), %rax
imulq %rdx, %rax
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0x338(%rdi), %rsi
movslq 0x2f0(%rdi), %rax
leaq (%rax,%rax,2), %rdx
testb $0x1, 0x10(%rsi,%rdx,8)... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
bsplib::Rdma::ActionBuf::~ActionBuf() | ActionBuf( int nprocs )
: m_actions()
, m_counts( nprocs )
, m_get_buffer_offset( nprocs )
{} | pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xc45b
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x52a0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xc470
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x52a0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc485
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
... | /wijnand-suijlen[P]bsponmpi/src/rdma.h |
bsplib::UIntSerialize<int>::write(int, unsigned char (&) [5]) | static int write( UInt x, Buffer & bytes ) {
assert( x >= 0 );
int i = 0;
do {
unsigned char m = (1 << (CHAR_BIT-1));
unsigned char c = x & (m-1); // cut out least significant bits
x >>= (CHAR_BIT-1); // and save these in c
c |= (x > 0) * ... | testl %edi, %edi
js 0xd370
xorl %eax, %eax
movl %edi, %ecx
movl %edi, %edx
andl $0x7f, %edx
shrl $0x7, %ecx
xorl %r8d, %r8d
cmpl $0x7f, %edi
seta %r8b
shll $0x7, %r8d
orl %edx, %r8d
movb %r8b, (%rsi,%rax)
incq %rax
cmpl $0x7f, %edi
movl %ecx, %edi
ja 0xd348
retq
pushq %rax
leaq 0x48ab(%rip), %rdi # 0x11c23
leaq 0x... | /wijnand-suijlen[P]bsponmpi/src/uintserialize.h |
bsplib::Bsmp::Bsmp(ompi_communicator_t*, unsigned long, unsigned long) | Bsmp::Bsmp(MPI_Comm comm, size_t max_msg_size, size_t small_exch_size)
: m_set_tag_size_counter(0)
, m_recv_tag_size(0)
, m_send_tag_size(0)
, m_next_tag_size(0)
, m_total_n_messages(0)
, m_total_payload(0)
, m_send_empty(true)
, m_a2a(comm, max_msg_size, small_exch_size )
, m_tag_bu... | pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movb $0x1, 0x30(%rdi)
addq $0x38, %rdi
movsd 0x248a(%rip), %xmm0 # 0x10060
movsd 0x248a(%rip), %xmm1 # 0x10068
xorl %r8d, %r8d
callq 0x8384
movl $0x10, %eax
movq %rax, 0x1b0(%rbx)
xorps %xmm0, %x... | /wijnand-suijlen[P]bsponmpi/src/bsmp.cc |
bsplib::LinCost::reset(int) | void LinCost::reset(int nprocs)
{
m_nprocs = nprocs;
m_sizes.clear(); m_counts.clear();
m_sizes.reserve( nprocs + 1);
m_counts.reserve( nprocs + 1);
m_sizes.push_back(0); // we insert 0 as an extra option
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x10(%rdi)
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0xe294
movq %rax, 0x20(%rbx)
leaq 0x18(%rbx), %r14
leaq 0x30(%rbx), %r15
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0xe2aa
movq %rax, 0x38(%rbx)
incl %esi
movslq %esi, %r12
mov... | /wijnand-suijlen[P]bsponmpi/src/lincost.cc |
int_pow | unsigned int_pow( unsigned base, unsigned n )
{
unsigned result = 1;
unsigned power = base;
while (n > 0) {
if ( n & 0x1 )
result *= power;
n >>= 1;
power = power * power;
}
return result;
} | testl %esi, %esi
je 0xece6
movl $0x1, %ecx
movl $0x1, %eax
movl %esi, %edx
testb $0x1, %sil
movl %edi, %r8d
cmovel %ecx, %r8d
imull %r8d, %eax
shrl %edx
imull %edi, %edi
cmpl $0x1, %esi
movl %edx, %esi
ja 0xecca
retq
movl $0x1, %eax
retq
| /wijnand-suijlen[P]bsponmpi/src/util.c |
rand_next | double rand_next( size_t * next )
{
#ifdef UINT64_MAX
#if SIZE_MAX == UINT64_MAX
return rand_next_uint64( (uint64_t *) next );
#elif SIZE_MAX == UINT32_MAX
return rand_next_uint32( (uint32_t *) next );
#endif
#else
return rand_next_uint32( (uint32_t *) next );
#endif
} | movabsq $0x5851f42d4c957f2d, %rax # imm = 0x5851F42D4C957F2D
imulq (%rdi), %rax
movabsq $0x14057b7ef767814f, %rcx # imm = 0x14057B7EF767814F
addq %rax, %rcx
movq %rcx, (%rdi)
movq %rcx, %xmm1
punpckldq 0x3012(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x301a(%rip), %xmm1 # 0x11da0
movapd %xmm1, %xmm0... | /wijnand-suijlen[P]bsponmpi/src/util.c |
main | int main(int argc, char ** arg) {
IO myIO;
ParameterObj myparameters = myIO.read(argc, arg);
NetworkArray network(myparameters); // Set up the network
const int num_sims = 1000;
std::vector<ModelInstance*> sims; // create vector of pointers to model objects
for (int i=0; i<num_sims; i++){
sims.push_back(new ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x75d8, %rsp # imm = 0x75D8
movq %rsi, %rcx
movl %edi, %edx
leaq 0x1868(%rsp), %rbx
leaq 0x150f(%rsp), %rsi
movq %rbx, %rdi
callq 0x6168
movl 0x10(%rbx), %eax
movl %eax, 0x10(%rsp)
movupd (%rbx), %xmm0
movupd %xmm0, (%rsp)
leaq 0x60f0(%rs... | /celinevw[P]markov-net/main.cpp |
Distribution::Distribution() | Distribution::Distribution() {
std::random_device rd; //Will be used to obtain a seed for the random number engine
gen = std::mt19937 (rd()); //Standard mersenne_twister_engine seeded with rd()
distrib = std::uniform_real_distribution<> (0,1);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2718, %rsp # imm = 0x2718
movq %rdi, %rbx
leaq 0x782c(%rip), %rax # 0xbd00
movq %rax, (%rdi)
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x4964
movq $0x0, 0x1390(%rbx)
movabsq $0x3ff0000000000000, %r12 # imm = 0x3FF0000000000000
movq %r12, 0x1398(%rbx)
l... | /celinevw[P]markov-net/Distribution.cpp |
NormalDistribution::getRandomNumber() | float NormalDistribution::getRandomNumber() {
float u1;
float u2;
float u3;
bool accepted = false;
while(!accepted){
u1 = this->distrib(gen);
u2 = this->distrib(gen);
if (u2 <= exp(-0.5*pow(-log(u1)-1,2))){
accepted = true;
}
}
u3 = this->distrib(gen);
if (u3 < 0.5) return sigma*log(u1)+mu;
else r... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x13a0(%rdi), %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x49ce
movsd 0x1390(%rbx), %xmm1
movsd 0x1398(%rbx), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movss %xmm0, (%rsp)
movq %r14, %rdi... | /celinevw[P]markov-net/Distribution.cpp |
ModelInstance::assign(NetworkArray, ParameterObj) | void ModelInstance::assign(NetworkArray net, ParameterObj par) {
network = net;
position = network.mismatchsite; // starting position and mismatch position must be the same
state = 1; // graph is symmetric, so let all start in state 1
dt_react = net.dt_react; // for reaction, check dt with networkarray f... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
addq $0x14, %rdi
leaq 0x60(%rsp), %r14
movl $0x14e4, %edx # imm = 0x14E4
movq %r14, %rsi
callq 0x21a0
movl 0x14e8(%rbx), %eax
movl %eax, 0x4(%rbx)
movl $0x1, (%rbx)
movss 0x14e0(%r14), %xmm0
movss %xmm0, 0x1508(%rbx)
movl $0x38d1b717, 0x1504(%r... | /celinevw[P]markov-net/ModelInstance.cpp |
ModelInstance::ModelInstance() | ModelInstance::ModelInstance() {
NetworkArray myNet;
ParameterObj myPars;
assign(myNet, myPars);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x2a00, %rsp # imm = 0x2A00
movq %rdi, %rbx
addq $0x14, %rdi
callq 0x6138
xorps %xmm0, %xmm0
movups %xmm0, 0x1568(%rbx)
movups %xmm0, 0x1558(%rbx)
movups %xmm0, 0x1548(%rbx)
movups %xmm0, 0x1538(%rbx)
movups %xmm0, 0x1528(%rbx)
movups %xmm0, 0x1518(%rbx)
leaq 0x1518(%rsp... | /celinevw[P]markov-net/ModelInstance.cpp |
ModelInstance::transition(float) | void ModelInstance::transition(float x) {
// No outgoing edges, then stay in this state
if (std::accumulate(network.transitions.at(state).begin(), network.transitions.at(state).end(), 0.0) == 0){
return;
}
// Iterate over outgoing edges, find the one to take depending on the random number x
std::array<float, 36... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movslq (%rdi), %rsi
cmpq $0x24, %rsi
jae 0x52c3
movq %rdi, %rbx
leaq (%rsi,%rsi,8), %r15
shlq $0x4, %r15
leaq (%rdi,%r15), %r12
addq $0x14, %r12
leaq (%rdi,%r15), %rax
xorpd %xmm2, %xmm2
movq $-0x90, %rcx
xorps %xmm1, %xmm1
cvtss2sd 0xa4... | /celinevw[P]markov-net/ModelInstance.cpp |
getMoments(std::vector<float, std::allocator<float>>) | std::tuple<float, float> getMoments (std::vector <float> results){
float sum = std::accumulate(results.begin(), results.end(), 0.0);
float mean = sum / results.size();
float sq_sum = 0.0;
for (float x: results){
sq_sum += (x-mean)*(x-mean);
}
float variance = sq_sum / results.size();
return std::make_tuple(m... | movq %rdi, %rax
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
cmpq %rdx, %rcx
je 0x5898
xorpd %xmm0, %xmm0
movq %rcx, %rsi
xorps %xmm1, %xmm1
cvtss2sd (%rsi), %xmm1
addsd %xmm1, %xmm0
addq $0x4, %rsi
cmpq %rdx, %rsi
jne 0x587e
cvtsd2ss %xmm0, %xmm0
jmp 0x589b
xorps %xmm0, %xmm0
movq %rdx, %rsi
subq %rcx, %rsi
sarq $0x2, %rsi
... | /celinevw[P]markov-net/TestingDistributions.cpp |
IO::momentsNicking(std::vector<ModelInstance*, std::allocator<ModelInstance*>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void IO::momentsNicking(std::vector<ModelInstance*> sims, std::string filename) {
std::ofstream outstream;
outstream.open(filename, std::ios::app);
for (ModelInstance* model: sims){
outstream << model->nick1 << "\t" << model->nick2 << std::endl;
}
outstream.close();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2320
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x20f0
movq (%rbx), %r12
movq 0x8(%rbx), %r13
cmpq %r13, %r12
je 0x681a
lea... | /celinevw[P]markov-net/IO.cpp |
IO::momentsActive(std::vector<ModelInstance*, std::allocator<ModelInstance*>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void IO::momentsActive(std::vector<ModelInstance*> sims, std::string filename){
std::ofstream outstream;
outstream.open(filename, std::ios::app);
for (ModelInstance* model: sims){
for (auto i: model->dimersactive.at(0)){
outstream << i << "\t";
}
outstream << std::endl;
for (auto i: model->dimersactive.at... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, %r15
movq %rsi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2320
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x20f0
movq (%r14), %r15
movq 0x8(%r14), %rax
movq %rax, (%rsp)
cmpq %rax, ... | /celinevw[P]markov-net/IO.cpp |
IO::singleStates(ModelInstance*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void IO::singleStates(ModelInstance *model, std::string filename) {
std::ofstream outstream;
outstream.open(filename, std::ios::app);
for (int thisstate : model->states){
outstream << thisstate << "\t";
}
outstream << std::endl;
outstream.close();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp # imm = 0x200
movq %rdx, %r15
movq %rsi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2320
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x20f0
movq 0x1560(%r14), %r12
movq 0x1568(%r14), %r13
cmpq %r13, %r12
je 0x6b9f
movq %rsp,... | /celinevw[P]markov-net/IO.cpp |
IO::writeNicking(std::vector<std::array<float, 4ul>, std::allocator<std::array<float, 4ul>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void IO::writeNicking(std::vector<std::array<float, 4>> nicking_arr, std::string filename) {
std::ofstream outstream;
outstream.open(filename, std::ios::app);
for (auto timestep: nicking_arr){
for (auto nicked: timestep){
outstream << nicked << "\t";
}
outstream << std::endl;
}
outstream.close();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rdx, %r15
movq %rsi, %r14
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2320
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x20f0
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x6e10
leaq 0x12ac(%... | /celinevw[P]markov-net/IO.cpp |
IO::writeDimerActivating(std::vector<std::array<int, 4ul>, std::allocator<std::array<int, 4ul>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void IO::writeDimerActivating(std::vector<std::array<int, 4>> dimer_arr, std::string filename) {
std::ofstream outstream;
outstream.open(filename, std::ios::app);
for (auto timestep: dimer_arr){
for (auto bound: timestep){
outstream << bound << "\t";
}
outstream << std::endl;
}
outstream.close();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rdx, %r15
movq %rsi, %r14
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2320
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x20f0
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x6f1f
leaq 0x1198(%... | /celinevw[P]markov-net/IO.cpp |
IO::writeHomotetramers(std::vector<std::array<float, 2ul>, std::allocator<std::array<float, 2ul>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void IO::writeHomotetramers(std::vector<std::array<float, 2>> homotetramer_arr, std::string filename) {
std::ofstream outstream;
outstream.open(filename, std::ios::app);
for (auto timestep: homotetramer_arr){
outstream << timestep.at(0)/(timestep.at(0)+timestep.at(1)) << "\t"
<< timestep.at(1)/(timestep.at(... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x2320
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x20f0
movq (%rbx), %r12
movq 0x8(%rbx), %r13
cmpq %r13, %r12
je 0x7067
leaq 0x10(%rs... | /celinevw[P]markov-net/IO.cpp |
main | int main(int argc, char **argv)
{
/* TEST 1 */
{
printf("Test 1: check that elements in cache with time_max == 0 do not expire\n");
coda_cache<int, int> cache (1024, 0);
cache.set(0, 23, false);
const int *v = cache.get(0);
printf("right after insert got %d\n", (int) (v ? *v : 0));
sleep(1);
v = cache... | subq $0x1f8, %rsp # imm = 0x1F8
movl $0x0, 0x1f4(%rsp)
movl %edi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
leaq 0x6b90(%rip), %rdi # 0x13008
xorl %eax, %eax
movl %eax, 0x94(%rsp)
callq 0xc050
movl 0x94(%rsp), %eax
movl %eax, %edx
leaq 0x188(%rsp), %rdi
movq %rdi, 0x88(%rsp)
movl $0x400, %esi # imm ... | /bachan[P]coda/tests/cache/test.cpp |
coda_strappend(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*, ...) | int coda_strappend(std::string& out, const char* fmt, ...)
{
va_list ap;
char *BUF = (char *) alloca(BUFSZ);
va_start(ap, fmt);
int bytes = vsnprintf(BUF, BUFSZ, fmt, ap);
va_end(ap);
if (BUFSZ <= bytes)
{
BUF = (char *) alloca(bytes + 1);
va_start(ap, fmt);
vsnprintf(BUF, bytes + 1, fmt, ap);
va_end(a... | pushq %rbp
movq %rsp, %rbp
subq $0x80f0, %rsp # imm = 0x80F0
testb %al, %al
je 0xf4d7
movaps %xmm0, -0x80c0(%rbp)
movaps %xmm1, -0x80b0(%rbp)
movaps %xmm2, -0x80a0(%rbp)
movaps %xmm3, -0x8090(%rbp)
movaps %xmm4, -0x8080(%rbp)
movaps %xmm5, -0x8070(%rbp)
movaps %xmm6, -0x8060(%rbp)
movaps %xmm7, -0x8050(%rbp)
... | /bachan[P]coda/coda/string.cpp |
coda_strnprintf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long, unsigned long, char const*, ...) | int coda_strnprintf(std::string& out, size_t pos, size_t num, const char* fmt, ...)
{
if (out.size() < pos) return -1;
va_list ap;
va_start(ap, fmt);
int bytes;
if (num < BUFSZ)
{
char BUF[BUFSZ];
if ((int) num < (bytes = vsnprintf(BUF, num + 1, fmt, ap)))
{
bytes = num;
}
out.insert(pos, BUF, b... | subq $0x8128, %rsp # imm = 0x8128
testb %al, %al
je 0xf7df
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rdi... | /bachan[P]coda/coda/string.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.