name string | code string | asm string | file string |
|---|---|---|---|
Json::Value::operator[](unsigned int) const | const Value &
Value::operator[]( ArrayIndex index ) const
{
JSON_ASSERT( type_ == nullValue || type_ == arrayValue );
if ( type_ == nullValue )
return null;
#ifndef JSON_VALUE_USE_INTERNAL_MAP
CZString key( index );
ObjectValues::const_iterator it = value_.map_->find( key );
if ( it == value_.map... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movzbl 0x8(%rdi), %eax
testl %eax, %eax
je 0x47071
cmpl $0x6, %eax
jne 0x47093
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x213a0
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x23f00
movq %rax, %rbx
movq (%r14), %rax
addq $0x8, %rax
cmpq %rax, %rbx
jne 0x4707a
movq 0x56... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Json::Value::append(Json::Value const&) | Value &
Value::append( const Value &value )
{
return (*this)[size()] = value;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x23740
movq %rbx, %rdi
movl %eax, %esi
callq 0x22400
movq %rax, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x236a0
movzwl 0x8(%rbx), %eax
movzwl 0x8(%r15), %ecx
movl $0xfe00, %edx # imm = 0xFE00
movl ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Json::valueToString[abi:cxx11](unsigned long long) | std::string valueToString( LargestUInt value )
{
UIntToStringBuffer buffer;
char *current = buffer + sizeof(buffer);
uintToString( value, current );
assert( current >= buffer );
return current;
} | pushq %rbx
subq $0x30, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x28(%rsp), %rsi
movb $0x0, (%rsi)
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r8d
subl %eax, %r8d
orb $0x30, %r8b
movb %r8b, -0x1(%rsi... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_writer.cpp |
Json::StyledWriter::writeCommentAfterValueOnSameLine(Json::Value const&) | void
StyledWriter::writeCommentAfterValueOnSameLine( const Value &root )
{
if ( root.hasComment( commentAfterOnSameLine ) )
document_ += " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );
if ( root.hasComment( commentAfter ) )
{
document_ += "\n";
document_ += normalizeEOL( ro... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x1, %esi
callq 0x22e80
testb %al, %al
je 0x4a4da
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x22a50
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x21850
leaq 0x32ff8(%rip), %rcx #... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_writer.cpp |
Json::StyledStreamWriter::StyledStreamWriter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | StyledStreamWriter::StyledStreamWriter( std::string indentation )
: document_(NULL)
, rightMargin_( 74 )
, indentation_( indentation )
, addChildValues_()
{
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %r15, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
movl $0x4a, 0x40(%rdi)
addq $0x48, %rdi
leaq 0x58(%rbx), %rax
movq %rax, 0x48(%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_writer.cpp |
Json::StyledStreamWriter::isMultineArray(Json::Value const&) | bool
StyledStreamWriter::isMultineArray( const Value &value )
{
int size = value.size();
bool isMultiLine = size*3 >= rightMargin_ ;
childValues_.clear();
for ( int index =0; index < size && !isMultiLine; ++index )
{
const Value &childValue = value[index];
isMultiLine = isMultiLine ||
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x23740
movl %eax, %r15d
leal (%r15,%r15,2), %eax
cmpl 0x40(%rbx), %eax
setge %bpl
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x22380
testl %r15d, %r15d
setle %al
orb %bpl, %al
testb $0x1, %al... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_writer.cpp |
Json::StyledStreamWriter::normalizeEOL(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
StyledStreamWriter::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++;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x23550
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x4b9c3
movq (%r14), %rax
addq %rax, %r12
leaq 0x1(%rax), %r14
movb (%rax)... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_writer.cpp |
urlencode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | std::string urlencode( const std::string c)
{
std::string escaped;
int max = c.length();
for(int i=0; i<max; i++)
{
if ( (48 <= c[i] && c[i] <= 57) || //0-9
(65 <= c[i] && c[i] <= 90) || //ABC...XYZ
(97 <= c[i] && c[i] <= 122) || //abc...xyz
(c[i]=='~' || c[i]=='-' || c[i]=='_' || c[i]=='.')
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rbp
testl %ebp, %ebp
jle 0x4e3c5
movq %rsi, %r14
andl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
xorl %... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/utils/ali_urlencode.cpp |
mbedtls_aes_crypt_cfb128 | int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
int mode,
size_t length,
size_t *iv_off,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
int c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rdx, %r12
movq %rdi, 0x8(%rsp)
movq 0x50(%rsp), %rbx
movq %rcx, 0x10(%rsp)
movq (%rcx), %rbp
testl %esi, %esi
je 0x4f721
testq %r12, %r12
je 0x4f762
xorl %r13d, %r13d
testq %rbp, %rbp
jne 0x4f702
movq ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/aes.c |
mbedtls_asn1_get_mpi | int mbedtls_asn1_get_tag( unsigned char **p,
const unsigned char *end,
size_t *len, int tag )
{
if( ( end - *p ) < 1 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
if( **p != tag )
return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
(*p)++;
return( mbedtls_asn1_g... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rcx
movq %rsi, %rax
subq %rcx, %rax
testq %rax, %rax
jle 0x50666
movl $0xffffff9e, %eax # imm = 0xFFFFFF9E
cmpb $0x2, (%rcx)
jne 0x5066b
movq %rdx, %r14
movq %rdi, %rbx
incq %rcx
movq %rcx, (%rdi)
leaq 0x8(%rsp), %rdx
callq 0x21b10
testl %eax, %eax
j... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/asn1parse.c |
mbedtls_mpi_grow | int mbedtls_mpi_grow( mbedtls_mpi *X, size_t nblimbs )
{
mbedtls_mpi_uint *p;
if( nblimbs > MBEDTLS_MPI_MAX_LIMBS )
return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
if( X->n < nblimbs )
{
if( ( p = mbedtls_calloc( nblimbs, ciL ) ) == NULL )
return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xfffffff0, %ebp # imm = 0xFFFFFFF0
cmpq $0x2710, %rsi # imm = 0x2710
ja 0x50b3d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
cmpq %rsi, %r15
jae 0x50b3b
movl $0x8, %esi
movq %r14, %rdi
callq 0x21fd0
testq %rax, %... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/bignum.c |
mbedtls_mpi_set_bit | int mbedtls_mpi_set_bit( mbedtls_mpi *X, size_t pos, unsigned char val )
{
int ret = 0;
size_t off = pos / biL;
size_t idx = pos % biL;
if( val != 0 && val != 1 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
if( X->n * biL <= pos )
{
if( val == 0 )
return( 0 );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl $0xfffffffc, %eax # imm = 0xFFFFFFFC
cmpb $0x1, %bpl
ja 0x50ed0
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r15
shrq $0x6, %r15
movq 0x8(%rdi), %rax
shlq $0x6, %rax
cmpq %rsi, %rax
jbe 0x50eb7
andl $0x3f, %ebx
movq 0x10(%r14), %rax
movq (... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/bignum.c |
mbedtls_mpi_sub_int | int mbedtls_mpi_sub_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
return( mbedtls_mpi_sub_mpi( X, A, &_B ) );
} | subq $0x28, %rsp
movq %rdx, %rax
negq %rax
cmovsq %rdx, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
sarq $0x3f, %rdx
orl $0x1, %edx
leaq 0x10(%rsp), %rax
movl %edx, (%rax)
movq $0x1, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x219e0
addq $0x28, %rsp
retq
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/bignum.c |
mbedtls_mpi_write_binary | int mbedtls_mpi_write_binary( const mbedtls_mpi *X, unsigned char *buf, size_t buflen )
{
size_t i, j, n;
n = mbedtls_mpi_size( X );
if( buflen < n )
return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
memset( buf, 0, buflen );
for( i = buflen - 1, j = 0; n > 0; i--, j++, n-- )
buf[i] = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x218c0
movq %rax, %r13
addq $0x7, %r13
movq %r13, %rbp
shrq $0x3, %rbp
movl $0xfffffff8, %r14d # imm = 0xFFFFFFF8
cmpq %r15, %rbp
ja 0x518bc
xorl %r14d, %r14d
movq %r12, %rdi
xorl %es... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/bignum.c |
mbedtls_mpi_div_int | int mbedtls_mpi_div_int( mbedtls_mpi *Q, mbedtls_mpi *R, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
return( mbedtls_mpi_div_mpi( Q, R, A, &_B ) );
} | subq $0x28, %rsp
movq %rcx, %rax
negq %rax
cmovsq %rcx, %rax
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
sarq $0x3f, %rcx
orl $0x1, %ecx
leaq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq $0x1, 0x8(%rax)
movq %r8, 0x10(%rax)
movq %rax, %rcx
callq 0x21510
addq $0x28, %rsp
retq
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/bignum.c |
mbedtls_mpi_mod_mpi | int mbedtls_mpi_mod_mpi( mbedtls_mpi *R, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret;
if( mbedtls_mpi_cmp_int( B, 0 ) < 0 )
return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( NULL, R, A, B ) );
while( mbedtls_mpi_cmp_int( R, 0 ) < 0 )
MBEDTLS_MPI_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
leaq 0x10(%rsp), %rsi
movl $0x1, (%rsi)
movq $0x1, 0x8(%rsi)
movq %r12, 0x10(%rsi)
movq %rdx, %rdi
callq 0x21f00
testl %eax, %eax
js 0x52c00
xorl %edi, %edi
movq %r14, %rsi... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/bignum.c |
mbedtls_cipher_info_from_string | const mbedtls_cipher_info_t *mbedtls_cipher_info_from_string( const char *cipher_name )
{
const mbedtls_cipher_definition_t *def;
if( NULL == cipher_name )
return( NULL );
for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
if( ! strcmp( def->info->name, cipher_name ) )
... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x54adc
movq 0x494a8(%rip), %r15 # 0x9df58
movq 0x8(%r15), %rbx
testq %rbx, %rbx
je 0x54adc
movq %rdi, %r14
addq $0x18, %r15
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x23150
testl %eax, %eax
je 0x54ade
movq (%r15), %rbx
addq $0x10, %r15
testq %rbx, %rbx
jne 0x... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/cipher.c |
arc4_ctx_alloc | static void * arc4_ctx_alloc( void )
{
mbedtls_arc4_context *ctx;
ctx = mbedtls_calloc( 1, sizeof( mbedtls_arc4_context ) );
if( ctx == NULL )
return( NULL );
mbedtls_arc4_init( ctx );
return( ctx );
} | pushq %rbx
movl $0x1, %edi
movl $0x108, %esi # imm = 0x108
callq 0x21fd0
movq %rax, %rbx
testq %rax, %rax
je 0x55751
movq %rbx, %rdi
callq 0x23410
movq %rbx, %rax
popq %rbx
retq
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/cipher_wrap.c |
mbedtls_debug_print_ret | void mbedtls_debug_print_ret( const mbedtls_ssl_context *ssl, int level,
const char *file, int line,
const char *text, int ret )
{
char str[DEBUG_BUF_SIZE];
if( ssl->conf == NULL || ssl->conf->f_dbg == NULL || level > debug_threshold )
return;
/*
* ... | movq (%rdi), %rax
testq %rax, %rax
je 0x55a44
cmpl $0xffff9700, %r9d # imm = 0xFFFF9700
je 0x55a44
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp # imm = 0x200
cmpq $0x0, 0x20(%rax)
je 0x55a35
movl %esi, %ebp
cmpl %esi, 0x4c8b0(%rip) # 0xa22a0
jl 0x55a35
movl %ecx, %ebx
mo... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/debug.c |
mbedtls_des3_crypt_ecb | int mbedtls_des3_crypt_ecb( mbedtls_des3_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
int i;
uint32_t X, Y, T, *SK;
SK = ctx->sk;
GET_UINT32_BE( X, input, 0 );
GET_UINT32_BE( Y, input, 4 );
DES_IP( X, Y );
for( i = 0; i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
movl (%rsi), %eax
movl 0x4(%rsi), %ecx
bswapl %eax
bswapl %ecx
movl %eax, %edx
shrl $0x4, %edx
xorl %ecx, %edx
andl $0xf0f0f0f, %edx # imm = 0xF0F0F0F
xorl %edx, %ecx
shll $0x4, %edx
xorl %eax, %edx
movl %edx, %esi
shrl $0x10... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/des.c |
mbedtls_des_self_test | int mbedtls_des_self_test( int verbose )
{
int i, j, u, v, ret = 0;
mbedtls_des_context ctx;
mbedtls_des3_context ctx3;
unsigned char buf[8];
#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char prv[8];
unsigned char iv[8];
#endif
mbedtls_des_init( &ctx );
mbedtls_des3_init( &ctx3 );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3c8, %rsp # imm = 0x3C8
movl %edi, %ebx
xorps %xmm0, %xmm0
leaq 0x1c0(%rsp), %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x50(%r14)
movaps ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/des.c |
mbedtls_dhm_make_public | int mbedtls_dhm_make_public( mbedtls_dhm_context *ctx, int x_size,
unsigned char *output, size_t olen,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret, count = 0;
if( ctx == NULL || olen < 1 || olen > ctx->len )
retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
testq %rdi, %rdi
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
movl $0xffffcf80, %r14d # imm = 0xFFFFCF80
jne 0x57b2d
movq %rdi, %r15
cmpq %rbx, (%rdi)
jb 0x57b2d
movl %esi, %r13d
movq %r8, 0x8(%rsp)
movq %r9, 0x10... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/dhm.c |
mbedtls_ecp_grp_id_list | const mbedtls_ecp_group_id *mbedtls_ecp_grp_id_list( void )
{
static int init_done = 0;
if( ! init_done )
{
size_t i = 0;
const mbedtls_ecp_curve_info *curve_info;
for( curve_info = mbedtls_ecp_curve_list();
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve... | cmpb $0x0, 0x49c99(%rip) # 0xa22b0
jne 0x58650
movl $0x5, %ecx
xorl %eax, %eax
leaq 0x49c99(%rip), %rdx # 0xa22c0
leaq 0x42c92(%rip), %rsi # 0x9b2c0
movl %ecx, (%rax,%rdx)
movl 0x10(%rsi,%rax,4), %ecx
addq $0x4, %rax
cmpq $0x2c, %rax
jne 0x5862e
movl $0x0, 0x49ca3(%rip) # 0xa22ec
movb $0x1, 0x49c60(%rip... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ecp.c |
mbedtls_ecp_set_zero | int mbedtls_ecp_set_zero( mbedtls_ecp_point *pt )
{
int ret;
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &pt->X , 1 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &pt->Y , 1 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &pt->Z , 0 ) );
cleanup:
return( ret );
} | pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x21450
testl %eax, %eax
jne 0x588dc
leaq 0x18(%rbx), %rdi
movl $0x1, %esi
callq 0x21450
testl %eax, %eax
je 0x588de
popq %rbx
retq
addq $0x30, %rbx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x21450
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ecp.c |
mbedtls_ecp_muladd | int mbedtls_ecp_muladd( mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
const mbedtls_mpi *m, const mbedtls_ecp_point *P,
const mbedtls_mpi *n, const mbedtls_ecp_point *Q )
{
int ret;
mbedtls_ecp_point mP;
if( ecp_get_type( grp ) != ECP_TYPE_SHORT_WEIERSTRASS )
return( MBEDT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl $0xffffb180, %ebp # imm = 0xFFFFB180
cmpq $0x0, 0x60(%rdi)
je 0x59d88
movq %rdi, %r12
cmpq $0x0, 0x78(%rdi)
je 0x59d88
movq %r9, %r13
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
leaq 0x10(%rsp), %rbp
mo... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ecp.c |
ecp_double_jac | static int ecp_double_jac( const mbedtls_ecp_group *grp, mbedtls_ecp_point *R,
const mbedtls_ecp_point *P )
{
int ret;
mbedtls_mpi M, S, T, U;
#if defined(MBEDTLS_SELF_TEST)
dbl_count++;
#endif
mbedtls_mpi_init( &M ); mbedtls_mpi_init( &S ); mbedtls_mpi_init( &T ); mbedtls_m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
incq 0x46e76(%rip) # 0xa22f8
leaq 0x60(%rsp), %rdi
callq 0x235d0
leaq 0x8(%rsp), %rdi
callq 0x235d0
leaq 0x28(%rsp), %rdi
callq 0x235d0
leaq 0x40(%rsp), %rdi
callq 0x235d0
cmpq $0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ecp.c |
ecp_mod_p192 | static int ecp_mod_p192( mbedtls_mpi *N )
{
int ret;
mbedtls_mpi_uint c = 0;
mbedtls_mpi_uint *p, *end;
/* Make sure we have enough blocks so that A(5) is legal */
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( N, 6 * WIDTH ) );
p = N->p;
end = p + N->n;
ADD( 3 ); ADD( 5 ); NEXT; // A... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x6, %esi
callq 0x21500
movl %eax, %ebx
testl %eax, %eax
jne 0x5c4b5
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
movq (%rax), %r8
movq 0x18(%rax), %r9
movq 0x20(%rax), %rsi
leaq (%r9,%r8), %r10
movq 0x28(%rax), %rdx
xorl %edi, %edi
addq %rdx, %r10
setb %dil
addq %r9... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ecp_curves.c |
ecp_mod_p224k1 | static int ecp_mod_p224k1( mbedtls_mpi *N )
{
static mbedtls_mpi_uint Rp[] = {
BYTES_TO_T_UINT_8( 0x93, 0x1A, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 ) };
#if defined(MBEDTLS_HAVE_INT64)
return( ecp_mod_koblitz( N, Rp, 4, 1, 32, 0xFFFFFFFF ) );
#else
return( ecp_mod_koblitz( N, Rp, 224 / 8 / sizeof( mbe... | leaq 0x42d56(%rip), %rsi # 0x9ff38
movl $0x4, %edx
movl $0x1, %ecx
movl $0x20, %r8d
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
jmp 0x5d2f0
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ecp_curves.c |
mbedtls_md5_process | void mbedtls_md5_process( mbedtls_md5_context *ctx, const unsigned char data[64] )
{
uint32_t X[16], A, B, C, D;
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_LE( X[ 4], data, 16 );
GET_UINT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r9
movq %rdi, -0x20(%rsp)
movl (%rsi), %r11d
movl 0x4(%rsi), %r13d
movl 0x8(%rsi), %r12d
movl 0x8(%rdi), %ebx
movq %rbx, -0x8(%rsp)
movl 0xc(%rdi), %esi
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
movl %ecx, %eax
xorl %edx, %eax
movq %rsi, %r... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/md5.c |
pem_des_decrypt | static void pem_des_decrypt( unsigned char des_iv[8],
unsigned char *buf, size_t buflen,
const unsigned char *pwd, size_t pwdlen )
{
mbedtls_des_context des_ctx;
unsigned char des_key[8];
mbedtls_des_init( &des_ctx );
pem_pbkdf1( des_key, 8... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %r13
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
callq 0x23250
leaq 0x10(%rsp), %r15
movl $0x8, %esi
movq %r15, %rdi
movq %r13, %rdx
movq %r14, %rcx
movq %rbx, %r8
... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pem.c |
pem_aes_decrypt | static void pem_aes_decrypt( unsigned char aes_iv[16], unsigned int keylen,
unsigned char *buf, size_t buflen,
const unsigned char *pwd, size_t pwdlen )
{
mbedtls_aes_context aes_ctx;
unsigned char aes_key[32];
mbedtls_aes_init( &aes_ctx );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %r9, %rbp
movq %r8, %r13
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %r12
leaq 0x38(%rsp), %rdi
callq 0x236b0
movl %r14d, %ebx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pem.c |
mbedtls_pk_setup_rsa_alt | int mbedtls_pk_setup_rsa_alt( mbedtls_pk_context *ctx, void * key,
mbedtls_pk_rsa_alt_decrypt_func decrypt_func,
mbedtls_pk_rsa_alt_sign_func sign_func,
mbedtls_pk_rsa_alt_key_len_func key_len_func )
{
mbedtls_rsa_alt_context *rsa_alt;
c... | movl $0xffffc180, %eax # imm = 0xFFFFC180
testq %rdi, %rdi
je 0x5ffc5
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
cmpq $0x0, (%rdi)
jne 0x5ffb7
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x3df69(%rip), %rbp # 0x9def8
callq *0x48(%rbp)
m... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pk.c |
rsa_debug | static void rsa_debug( const void *ctx, mbedtls_pk_debug_item *items )
{
items->type = MBEDTLS_PK_DEBUG_MPI;
items->name = "rsa.N";
items->value = &( ((mbedtls_rsa_context *) ctx)->N );
items++;
items->type = MBEDTLS_PK_DEBUG_MPI;
items->name = "rsa.E";
items->value = &( ((mbedtls_rsa_cont... | movl $0x1, %eax
movl %eax, (%rsi)
leaq 0x2020b(%rip), %rcx # 0x806a7
movq %rcx, 0x8(%rsi)
leaq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rsi)
movl %eax, 0x18(%rsi)
leaq 0x201fb(%rip), %rax # 0x806ad
movq %rax, 0x20(%rsi)
addq $0x28, %rdi
movq %rdi, 0x28(%rsi)
retq
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pk_wrap.c |
mbedtls_pk_load_file | int mbedtls_pk_load_file( const char *path, unsigned char **buf, size_t *n )
{
FILE *f;
long size;
if( ( f = fopen( path, "rb" ) ) == NULL )
return( MBEDTLS_ERR_PK_FILE_IO_ERROR );
fseek( f, 0, SEEK_END );
if( ( size = ftell( f ) ) == -1 )
{
fclose( f );
return( MBEDTLS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
leaq 0x16a53(%rip), %rsi # 0x772c3
callq 0x22be0
movl $0xffffc200, %ebx # imm = 0xFFFFC200
testq %rax, %rax
je 0x60936
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x22a60
movq... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pkparse.c |
pk_get_pk_alg | static int pk_get_pk_alg( unsigned char **p,
const unsigned char *end,
mbedtls_pk_type_t *pk_alg, mbedtls_asn1_buf *params )
{
int ret;
mbedtls_asn1_buf alg_oid;
memset( params, 0, sizeof(mbedtls_asn1_buf) );
if( ( ret = mbedtls_asn1_get_alg( p, end,... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movq %rsp, %rdx
callq 0x23d50
testl %eax, %eax
je 0x60f8a
addl $0xffffc580, %eax # imm = 0xFFFFC580
jmp 0x60fbf
movq %rsp, %rdi
movq %r14, %rsi
callq 0x23bb0
movl %eax, %ecx
movl $0... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pkparse.c |
pk_use_ecparams | static int pk_use_ecparams( const mbedtls_asn1_buf *params, mbedtls_ecp_group *grp )
{
int ret;
mbedtls_ecp_group_id grp_id;
if( params->tag == MBEDTLS_ASN1_OID )
{
if( mbedtls_oid_get_ec_grp( params, &grp_id ) != 0 )
return( MBEDTLS_ERR_PK_UNKNOWN_NAMED_CURVE );
}
else
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x6, (%rdi)
jne 0x610a6
movq %rsp, %rsi
movq %r15, %rdi
callq 0x22d70
movl $0xffffc600, %ebp # imm = 0xFFFFC600
testl %eax, %eax
jne 0x612ed
movl (%rsp), %r15d
jmp 0x6... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/pkparse.c |
mbedtls_rsa_pkcs1_decrypt | int mbedtls_rsa_pkcs1_decrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode, size_t *olen,
const unsigned char *input,
unsigned char *output,
... | movq %r9, %r10
movq %r8, %rax
movl 0x148(%rdi), %r8d
cmpl $0x1, %r8d
je 0x6315a
testl %r8d, %r8d
jne 0x63177
movq %rax, %r8
movq %r10, %r9
jmp 0x23010
pushq %rax
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq 0x18(%rsp)
pushq 0x18(%rsp)
pushq %r10
pushq %rax
callq 0x22c10
addq $0x20, %rsp
popq %rcx
retq
movl $0xffffbf00, %eax ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/rsa.c |
mbedtls_rsa_rsassa_pkcs1_v15_sign | int mbedtls_rsa_rsassa_pkcs1_v15_sign( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
mbedtls_md_type_t md_alg,
unsi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %r13d
movl %ecx, %ebp
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x18(%rsp)
cmpl $0x1, %ecx
jne 0x63413
movl $0xffffbf80, %r14d # imm = 0xFFFFBF80
cmpl $0x0, 0x148(%rdi)
j... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/rsa.c |
mbedtls_rsa_copy | int mbedtls_rsa_copy( mbedtls_rsa_context *dst, const mbedtls_rsa_context *src )
{
int ret;
dst->ver = src->ver;
dst->len = src->len;
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->N, &src->N ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->E, &src->E ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &dst->D, &... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x23e00
testl %eax, %eax
jne 0x63cf7
leaq 0x28(%rbx), %rdi
leaq 0x28(%r14), %rsi
callq 0x23e00
testl %eax, %eax
jne 0x63cf7
leaq 0x40(%rb... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/rsa.c |
mbedtls_ssl_get_ciphersuite_id | int mbedtls_ssl_get_ciphersuite_id( const char *ciphersuite_name )
{
const mbedtls_ssl_ciphersuite_t *cur;
cur = mbedtls_ssl_ciphersuite_from_string( ciphersuite_name );
if( cur == NULL )
return( 0 );
return( cur->id );
} | pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x64219
movq %rdi, %r14
leaq 0x38017(%rip), %r15 # 0x9c210
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x23150
testl %eax, %eax
je 0x64216
cmpl $0x0, 0x30(%r15)
leaq 0x30(%r15), %r15
jne 0x641f9
jmp 0x64219
movl (%r15), %ebx
movl %ebx, %eax
popq %r... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_ciphersuites.c |
mbedtls_ssl_ciphersuite_uses_ec | int mbedtls_ssl_ciphersuite_uses_ec( const mbedtls_ssl_ciphersuite_t *info )
{
switch( info->key_exchange )
{
case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
case MBEDTLS_... | movl 0x18(%rdi), %ecx
addl $-0x3, %ecx
xorl %eax, %eax
cmpl $0x7, %ecx
ja 0x64253
movl %ecx, %eax
leaq 0x1e114(%rip), %rcx # 0x82364
movl (%rcx,%rax,4), %eax
retq
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_ciphersuites.c |
mbedtls_ssl_handshake_client_step | int mbedtls_ssl_handshake_client_step( mbedtls_ssl_context *ssl )
{
int ret = 0;
if( ssl->state == MBEDTLS_SSL_HANDSHAKE_OVER || ssl->handshake == NULL )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
MBEDTLS_SSL_DEBUG_MSG( 2, ( "client state: %d", ssl->state ) );
if( ( ret = mbedtls_ssl_flush_out... | pushq %rbp
pushq %rbx
pushq %rax
movl 0x8(%rdi), %r9d
movl $0xffff8f00, %ebp # imm = 0xFFFF8F00
cmpl $0x10, %r9d
je 0x642b0
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
je 0x642b0
leaq 0x1e17d(%rip), %rdx # 0x82404
leaq 0x1e210(%rip), %r8 # 0x8249e
movq %rbx, %rdi
movl $0x2, %esi
movl $0xc00, %ecx # ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_cli.c |
ssl_write_certificate_request | static int ssl_write_certificate_request( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
const mbedtls_ssl_ciphersuite_t *ciphersuite_info = ssl->transform_negotiate->ciphersuite_info;
size_t dn_size, total_dn_size; /* excluding length bytes */
size_t ct_len, sa_len; /* incl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
movq 0x80(%rdi), %rax
movq (%rax), %rbx
movl $0x4000, %eax # imm = 0x4000
addq 0x148(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x18c08(%rip), %rdx # 0x83598
leaq 0x19850(%rip), %r8 # 0x841e7
movl $0x2, %es... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
ssl_parse_client_psk_identity | static int ssl_parse_client_psk_identity( mbedtls_ssl_context *ssl, unsigned char **p,
const unsigned char *end )
{
int ret = 0;
size_t n;
if( ssl->conf->f_psk == NULL &&
( ssl->conf->psk == NULL || ssl->conf->psk_identity == NULL ||
ssl->conf->ps... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpq $0x0, 0x78(%rax)
je 0x6c50b
movq (%r14), %rax
leaq 0x2(%rax), %r9
cmpq %rdx, %r9
jbe 0x6c55c
leaq 0x170a6(%rip), %rdx # 0x83598
leaq 0x17dc9(%rip), %r8 # 0x842c2
movq %rbx, %rdi
movl $0x1, %esi
movl $0xc04,... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_srv.c |
mbedtls_x509_get_ext | int mbedtls_x509_get_ext( unsigned char **p, const unsigned char *end,
mbedtls_x509_buf *ext, int tag )
{
int ret;
size_t len;
if( *p == end )
return( 0 );
ext->tag = **p;
if( ( ret = mbedtls_asn1_get_tag( p, end, &ext->len,
MBEDTLS_ASN1_CONTEXT_SPECIFIC | MB... | movq (%rdi), %rax
cmpq %rsi, %rax
je 0x6d335
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movzbl (%rax), %eax
movl %eax, (%rdx)
addq $0x8, %rdx
orl $0xa0, %ecx
callq 0x22320
testl %eax, %eax
jne 0x6d34d
movq (%rbx), %r15
movq %r15, 0x10(%r14)
addq 0x8(%r14), %r15
leaq 0x8(%rsp), %rd... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movl $0x100, %edx # imm = 0x100
xorl %esi, %esi
callq 0x21d00
movq %rbx, %r12
testq %rbp, %rbp
je 0x6d4d9
mov... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509.c |
mbedtls_x509_serial_gets | int mbedtls_x509_serial_gets( char *buf, size_t size, const mbedtls_x509_buf *serial )
{
int ret;
size_t i, n, nr;
char *p;
p = buf;
n = size;
nr = ( serial->len <= 32 )
? serial->len : 28;
for( i = 0; i < nr; i++ )
{
if( i == 0 && nr > 1 && serial->p[i] == 0x0 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %r15
movq 0x8(%rdx), %rax
cmpq $0x21, %rax
movl $0x1c, %ebp
cmovbq %rax, %rbp
testq %rbp, %rbp
je 0x6d5a1
movq %rdx, %r12
leaq -0x1(%rbp), %rbx
movq %r13, (%rsp)
movq %r13, %r14
xorl %r13d, %r13d
cmpq $0x1, %rbp
sete... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509.c |
camellia_feistel | static void camellia_feistel( const uint32_t x[2], const uint32_t k[2],
uint32_t z[2])
{
uint32_t I0, I1;
I0 = x[0] ^ k[0];
I1 = x[1] ^ k[1];
I0 = ((uint32_t) SBOX1((I0 >> 24) & 0xFF) << 24) |
((uint32_t) SBOX2((I0 >> 16) & 0xFF) << 16) |
((uint32_t) SBOX... | pushq %rbx
xorl %edx, %edi
xorl %ecx, %esi
movl %edi, %ecx
shrl $0x18, %ecx
leaq 0x16f46(%rip), %rax # 0x85950
movzbl (%rcx,%rax), %edx
shll $0x18, %edx
movl %edi, %r9d
shrl $0x10, %r9d
movl $0xff, %ecx
andl %ecx, %r9d
leaq 0x17029(%rip), %r10 # 0x85a50
movzbl (%r9,%r10), %r9d
shll $0x10, %r9d
orl %edx, %r9d
mo... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/camellia.c |
mbedtls_asn1_write_oid | int mbedtls_asn1_write_oid( unsigned char **p, unsigned char *start,
const char *oid, size_t oid_len )
{
int ret;
size_t len = 0;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) oid, oid_len ) );
MBEDTLS_A... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
movslq %ebx, %rcx
movl $0xffffff94, %ebp # imm = 0xFFFFFF94
cmpq %rcx, %rax
jl 0x71f6e
movq %rsi, %r15
subq %rbx, %rdi
movq %rdi, (%r14)
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/asn1write.c |
mbedtls_asn1_write_ia5_string | int mbedtls_asn1_write_ia5_string( unsigned char **p, unsigned char *start,
const char *text, size_t text_len )
{
int ret;
size_t len = 0;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned char *) text, text_len ) );
MBEDTL... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
movslq %ebx, %rcx
movl $0xffffff94, %ebp # imm = 0xFFFFFF94
cmpq %rcx, %rax
jl 0x72212
movq %rsi, %r15
subq %rbx, %rdi
movq %rdi, (%r14)
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x... | /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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x23c90
testq %rax, %rax
je 0x723b9
movq %rax, %rbx
cmpq %r14, 0x20(%rax)
jae 0x7242d
movq 0x28(%rbx), %rdi
callq 0x22c30
movq %r14, 0x20(%r... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/asn1write.c |
main | int main(int argc, char * argv[]) {
bool verbose = false;
const size_t test_size = 32 * 128;
std::string arg;
for (int i = 1; i < argc; i++) {
arg = argv[i];
if (arg == "-v") {
verbose = true;
} else {
fprintf(stderr, "error: unknown argument: %s\n", arg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %rbx
movb $0x0, (%rax)
movslq %edi, %r12
pushq $0x1
popq %r13
movl $0x0, 0x18(%rsp)
leaq 0xa8(%rsp), %r14
leaq 0xd5e(%rip), %r15 # 0x3050
cmpq %r12, %r13... | /ggerganov[P]llama/tests/test-quantize-fns.cpp |
(anonymous namespace)::test7() | void
testThrowErrnoExc (int err)
{
bool caught = false;
try
{
IEX_INTERNAL_NAMESPACE::throwErrnoExc ("err", err);
}
catch (const T& e)
{
caught = true;
}
catch (const std::exception& e)
{
std::cerr << "testThrowErrnoExc: caught " << typeid (e).name ()
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x885e(%rip), %rsi # 0x741dc
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x73790
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x223e0
leaq 0x8(%rsp), %rdi
callq 0x22c60
leaq 0x8800(%rip), %rdi # 0x741ab
leaq 0x8693(%rip), %rsi # 0x74045
leaq 0x884e(%rip)... | /AcademySoftwareFoundation[P]openexr/src/test/IexTest/testBaseExc.cpp |
testMathExc() | void
testMathExc ()
{
std::cout << "See if floating-point exceptions work:" << std::endl;
test1 ();
test2 ();
test3 ();
std::cout << " ok" << std::endl;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x113be(%rip), %rbx # 0x84c70
leaq 0x5877(%rip), %rsi # 0x79130
movq %rbx, %rdi
callq 0x23f60
movq %rax, %rdi
callq 0x22e00
leaq 0x588b(%rip), %rsi # 0x7915b
movq %rbx, %rdi
callq 0x23f60
movq %rax, %rdi
callq 0x22e00
xorl %... | /AcademySoftwareFoundation[P]openexr/src/test/IexTest/testMathExc.cpp |
main | int main(int argc, const char* argv[]) {
std::vector<std::string> inputFiles;
std::vector<std::string> inputFileNames;
bool emitBinary = true;
bool debugInfo = false;
std::map<size_t, std::string> inputSourceMapFilenames;
std::string outputSourceMapFilename;
std::string outputSourceMapUrl;
const std::s... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x988, %rsp # imm = 0x988
movq %rsi, %r15
movl %edi, %r13d
xorps %xmm0, %xmm0
movaps %xmm0, -0x1e0(%rbp)
xorl %eax, %eax
movq %rax, -0x1d0(%rbp)
movq %rax, -0x380(%rbp)
movaps %xmm0, -0x390(%rbp)
movb $0x1, -0x2a(%rbp)
mo... | /WebAssembly[P]binaryen/src/tools/wasm-merge.cpp |
(anonymous namespace)::updateNames(wasm::Module&, std::unordered_map<wasm::ModuleItemKind, std::unordered_map<wasm::Name, wasm::Name, std::hash<wasm::Name>, std::equal_to<wasm::Name>, std::allocator<std::pair<wasm::Name const, wasm::Name>>>, std::hash<wasm::ModuleItemKind>, std::equal_to<wasm::ModuleItemKind>, std::all... | void updateNames(Module& wasm, KindNameUpdates& kindNameUpdates) {
if (kindNameUpdates.empty()) {
return;
}
struct NameMapper
: public WalkerPass<
PostWalker<NameMapper, UnifiedExpressionVisitor<NameMapper>>> {
bool isFunctionParallel() override { return true; }
std::unique_ptr<Pass> cre... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
cmpq $0x0, 0x18(%rsi)
je 0xe46b
movq %rdi, %r12
leaq -0x158(%rbp), %rax
movq %rax, -0x10(%rax)
xorl %ecx, %ecx
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
movb %cl, 0x30(%rax)
xorps %xmm0, %xmm0
movup... | /WebAssembly[P]binaryen/src/tools/wasm-merge.cpp |
(anonymous namespace)::updateNames(wasm::Module&, std::unordered_map<wasm::ModuleItemKind, std::unordered_map<wasm::Name, wasm::Name, std::hash<wasm::Name>, std::equal_to<wasm::Name>, std::allocator<std::pair<wasm::Name const, wasm::Name>>>, std::hash<wasm::ModuleItemKind>, std::equal_to<wasm::ModuleItemKind>, std::all... | bool isFunctionParallel() override { return true; } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x108(%rdi), %rdi
testq %rdi, %rdi
je 0xe524
movq 0x118(%rbx), %rsi
subq %rdi, %rsi
callq 0xa0a0
movq %rbx, %rdi
callq 0x193ca
movl $0x138, %esi # imm = 0x138
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa0a0
nop
| /WebAssembly[P]binaryen/src/tools/wasm-merge.cpp |
wasm::WalkerPass<wasm::PostWalker<(anonymous namespace)::updateNames(wasm::Module&, std::unordered_map<wasm::ModuleItemKind, std::unordered_map<wasm::Name, wasm::Name, std::hash<wasm::Name>, std::equal_to<wasm::Name>, std::allocator<std::pair<wasm::Name const, wasm::Name>>>, std::hash<wasm::ModuleItemKind>, std::equal_... | void run(Module* module) override {
assert(getPassRunner());
// Parallel pass running is implemented in the PassRunner.
if (isFunctionParallel()) {
// Reduce opt/shrink levels to a maximum of one in nested runners like
// these, to balance runtime. We definitely want the full levels in the
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
cmpq $0x0, 0x8(%rdi)
je 0xe8d2
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
movq %r13, -0x38(%rbp)
je 0xe7a5
movq 0x8(%rbx), %r15
leaq 0x30(%r15), %rsi
leaq ... | /WebAssembly[P]binaryen/src/pass.h |
(anonymous namespace)::updateNames(wasm::Module&, std::unordered_map<wasm::ModuleItemKind, std::unordered_map<wasm::Name, wasm::Name, std::hash<wasm::Name>, std::equal_to<wasm::Name>, std::allocator<std::pair<wasm::Name const, wasm::Name>>>, std::hash<wasm::ModuleItemKind>, std::equal_to<wasm::ModuleItemKind>, std::all... | std::unique_ptr<Pass> create() override {
return std::make_unique<NameMapper>(kindNameUpdates);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x130(%rsi), %r14
movl $0x138, %edi # imm = 0x138
callq 0xa0c0
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x20(%rax), %rdx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movb %cl, 0x20(%rax)
movb %cl, 0x50(%rax)
xorps %xmm0, %xmm0
movups %xmm0... | /WebAssembly[P]binaryen/src/tools/wasm-merge.cpp |
wasm::PostWalker<(anonymous namespace)::updateNames(wasm::Module&, std::unordered_map<wasm::ModuleItemKind, std::unordered_map<wasm::Name, wasm::Name, std::hash<wasm::Name>, std::equal_to<wasm::Name>, std::allocator<std::pair<wasm::Name const, wasm::Name>>>, std::hash<wasm::ModuleItemKind>, std::equal_to<wasm::ModuleIt... | static void scan(SubType* self, Expression** currp) {
Expression* curr = *currp;
#define DELEGATE_ID curr->_id
#define DELEGATE_START(id) \
self->pushTask(SubType::doVisit##id, currp); \
[[maybe_unused]] auto* cast = curr->cas... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %rbx
movzbl (%rbx), %eax
cmpq $0x60, %rax
ja 0x104c9
movq %rsi, %rdx
movq %rdi, %r14
leaq 0xd486(%rip), %rcx # 0x1c060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x58, %r14
leaq 0x1e36(%... | /WebAssembly[P]binaryen/src/wasm-traversal.h |
void wasm::SmallVector<wasm::Walker<(anonymous namespace)::updateNames(wasm::Module&, std::unordered_map<wasm::ModuleItemKind, std::unordered_map<wasm::Name, wasm::Name, std::hash<wasm::Name>, std::equal_to<wasm::Name>, std::allocator<std::pair<wasm::Name const, wasm::Name>>>, std::hash<wasm::ModuleItemKind>, std::equa... | void emplace_back(ArgTypes&&... Args) {
if (usedFixed < N) {
new (&fixed[usedFixed++]) T(std::forward<ArgTypes>(Args)...);
} else {
flexible.emplace_back(std::forward<ArgTypes>(Args)...);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %rax
cmpq $0x9, %rax
ja 0x1090d
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
shlq $0x4, %rax
movq (%r13), %rcx
movq (%r12), %rdx
movq %rcx, 0x8(%rbx,%rax)
movq %rdx, ... | /WebAssembly[P]binaryen/src/support/small_vector.h |
(anonymous namespace)::updateNames(wasm::Module&, std::unordered_map<wasm::ModuleItemKind, std::unordered_map<wasm::Name, wasm::Name, std::hash<wasm::Name>, std::equal_to<wasm::Name>, std::allocator<std::pair<wasm::Name const, wasm::Name>>>, std::hash<wasm::ModuleItemKind>, std::equal_to<wasm::ModuleItemKind>, std::all... | void visitExpression(Expression* curr) {
#define DELEGATE_ID curr->_id
#define DELEGATE_START(id) [[maybe_unused]] auto* cast = curr->cast<id>();
#define DELEGATE_GET_FIELD(id, field) cast->field
#define DELEGATE_FIELD_TYPE(id, field)
#define DELEGATE_FIELD_HEAPTYPE(id, field)
#define DELEGATE_FIELD_CHILD(id, field)... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzbl (%rsi), %eax
cmpq $0x60, %rax
ja 0x11f0e
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa5d8(%rip), %rcx # 0x1c1e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, 0x18(%rbx)
je 0x11f0e
movl $0x1, %esi
jmp 0x11df7
cmpq $0x0, 0x18... | /WebAssembly[P]binaryen/src/tools/wasm-merge.cpp |
(anonymous namespace)::updateNames(wasm::Module&, std::unordered_map<wasm::ModuleItemKind, std::unordered_map<wasm::Name, wasm::Name, std::hash<wasm::Name>, std::equal_to<wasm::Name>, std::allocator<std::pair<wasm::Name const, wasm::Name>>>, std::hash<wasm::ModuleItemKind>, std::equal_to<wasm::ModuleItemKind>, std::all... | void mapName(ModuleItemKind kind, Name& name) {
auto iter = kindNameUpdates.find(kind);
if (iter == kindNameUpdates.end()) {
return;
}
auto& nameUpdates = iter->second;
auto iter2 = nameUpdates.find(name);
if (iter2 != nameUpdates.end()) {
name = resolveName(nameUpdat... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdx, %rbx
leaq -0x4c(%rbp), %rax
movl %esi, (%rax)
movq 0x130(%rdi), %rdi
movq %rax, %rsi
callq 0x19a20
testq %rax, %rax
je 0x12052
movq %rax, %r14
movq %rax, %r15
addq $0x10, %r15
movq 0x8... | /WebAssembly[P]binaryen/src/tools/wasm-merge.cpp |
(anonymous namespace)::reportTypeMismatch(bool&, char const*, wasm::Importable*) | void reportTypeMismatch(bool& valid, const char* kind, Importable* import) {
valid = false;
std::cerr << "Type mismatch when importing " << kind << " " << import->base
<< " from module " << import->module << " ($" << import->name
<< "): ";
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movb $0x0, (%rdi)
movq 0x13f17(%rip), %r15 # 0x25ff0
leaq 0xce3d(%rip), %rsi # 0x1ef1d
movl $0x1d, %edx
movq %r15, %rdi
callq 0xa490
testq %r14, %r14
je 0x1210e
movq %r14, %rdi
callq 0xa1c0
movq 0x13eef(%rip)... | /WebAssembly[P]binaryen/src/tools/wasm-merge.cpp |
wasm::Module::Module() | Module() = default; | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x130(%rdi), %r14
xorl %r12d, %r12d
movl $0x120, %edx # imm = 0x120
xorl %esi, %esi
callq 0xa1a0
movq %r14, 0x120(%rbx)
movq %r12, 0x128(%rbx)
movb %r12b, 0x130(%rbx)
leaq 0x150(%rbx), %rax
movq %rax, 0x140(%rbx)
movq... | /WebAssembly[P]binaryen/src/wasm.h |
ipv4toa(unsigned int) | const char* ipv4toa(uint32_t addr)
{
static char rc[20];
sprintf(rc,
"%d.%d.%d.%d",
(addr >> 24) & 0xFF,
(addr >> 16) & 0xFF,
(addr >> 8) & 0xFF,
(addr >> 0) & 0xFF);
return rc;
} | pushq %rbx
movl %edi, %ecx
shrl $0x10, %ecx
movl $0xff, %r9d
andl %r9d, %ecx
movl %edi, %r8d
shrl $0x8, %r8d
andl %r9d, %r8d
andl %edi, %r9d
movl %edi, %edx
shrl $0x18, %edx
leaq 0x46881(%rip), %rbx # 0x535c0
leaq 0x2f939(%rip), %rsi # 0x3c67f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x80e0
movq %rbx, %rax
popq %r... | /rkimball[P]tinytcp/tcp_stack/Utility.cpp |
ReadLine(char*, unsigned long, int (*)()) | int ReadLine(char* buffer, size_t size, int (*ReadFunction)())
{
int i;
char c;
bool done = false;
int bytesProcessed = 0;
while (!done)
{
i = ReadFunction();
if (i == -1)
{
*buffer = 0;
break;
}
c = (char)i;
bytesProcessed... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
decq %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
callq *%r14
cmpl $-0x1, %eax
je 0xceb4
cmpb $0xd, %al
je 0xce96
movsbl %al, %ecx
cmpl $0xa, %ecx
jne 0xce98
movb $0x1, %r13b
xorl %eax, %eax
movb %al, (%rbx,%r12)
leaq 0x1... | /rkimball[P]tinytcp/tcp_stack/Utility.cpp |
testing::AssertionResult::AssertionResult(testing::AssertionResult const&) | AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_),
message_(other.message_ != nullptr
? new ::std::string(*other.message_)
: static_cast< ::std::string*>(nullptr)) {} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rsi), %al
movb %al, (%rdi)
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0xcf42
movl $0x20, %edi
callq 0x84a0
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-assertion-result.cc |
testing::AssertionResult::swap(testing::AssertionResult&) | void AssertionResult::swap(AssertionResult& other) {
using std::swap;
swap(success_, other.success_);
swap(message_, other.message_);
} | pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
movb (%rsi), %cl
movb %cl, (%rdi)
movb %al, (%rsi)
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x8(%rsi)
popq %rbp
retq
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-assertion-result.cc |
testing::AssertionResult::operator!() const | AssertionResult AssertionResult::operator!() const {
AssertionResult negation(!success_);
if (message_ != nullptr) negation << *message_;
return negation;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movb (%rsi), %al
xorb $0x1, %al
movb %al, (%rdi)
movq $0x0, 0x8(%rdi)
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0xcfb7
leaq 0x8(%r14), %rbx
movq %r14, %rdi
callq 0x304f0
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rsi
t... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-assertion-result.cc |
testing::AssertionFailure(testing::Message const&) | AssertionResult AssertionFailure(const Message& message) {
return AssertionFailure() << message;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq -0x18(%rbp), %rbx
movb $0x0, -0x8(%rbx)
movq $0x0, (%rbx)
leaq -0x20(%rbp), %rdi
callq 0x30562
movq %r14, %rdi
movq %rax, %rsi
callq 0xcf00
movq -0x18(%rbp), %rsi
testq %rsi, %rsi
je 0xd04b
movq %rbx, %rdi
callq 0xc0a8
movq %r14, %ra... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-assertion-result.cc |
testing::internal::StringFromGTestEnv(char const*, char const*) | const char* StringFromGTestEnv(const char* flag, const char* default_value) {
#if defined(GTEST_GET_STRING_FROM_ENV_)
return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const value = posix::GetEnv(env_var.c_str());
return value == nullptr ? ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x15be0
movq (%r14), %r15
movq %r15, %rdi
callq 0x8650
movq %rax, %r14
leaq -0x28(%rbp), %rax
cmpq %rax, %r15
je 0xd0b8
movq -0x28(%rbp), %rsi
incq %rsi
movq %r15, %r... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-port.cc |
testing::internal::InDeathTestChild() | bool InDeathTestChild() {
#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_FUCHSIA)
// On Windows and Fuchsia, death tests are thread-safe regardless of the value
// of the death_test_style flag.
return !GTEST_FLAG_GET(internal_run_death_test).empty();
#else
if (GTEST_FLAG_GET(death_test_style) == "threadsa... | pushq %rbp
movq %rsp, %rbp
leaq 0x464e5(%rip), %rdi # 0x53620
leaq 0x3075b(%rip), %rsi # 0x3d89d
callq 0x8170
xorl %ecx, %ecx
cmpq $0x0, 0x464ff(%rip) # 0x53650
setne %cl
testl %eax, %eax
movzbl 0x4650b(%rip), %eax # 0x53668
cmovel %ecx, %eax
andb $0x1, %al
popq %rbp
retq
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-death-test.cc |
testing::KilledBySignal::operator()(int) const | bool KilledBySignal::operator()(int exit_status) const {
#if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
{
bool result;
if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
return result;
}
}
#endif // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
return WIFSIGNALED(exit_status) && ... | pushq %rbp
movq %rsp, %rbp
andl $0x7f, %esi
movl %esi, %eax
shll $0x18, %eax
addl $0x1000000, %eax # imm = 0x1000000
cmpl $0x2000000, %eax # imm = 0x2000000
setge %cl
cmpl (%rdi), %esi
sete %al
andb %cl, %al
popq %rbp
retq
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::Abort(testing::internal::DeathTest::AbortReason) | void DeathTestImpl::Abort(AbortReason reason) {
// The parent process considers the death test to be a failure if
// it finds any data in our pipe. So, here we write a single flag byte
// to the pipe, then exit.
const char status_ch = reason == TEST_DID_NOT_DIE ? kDeathTestLived
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %rbx
cmpl $0x1, %esi
sete %al
addb %al, %al
addb $0x52, %al
cmpl $0x2, %esi
movzbl %al, %eax
movl $0x4c, %ecx
cmovnel %eax, %ecx
leaq -0x29(%rbp), %r14
movb %cl, (%r14)
movl 0x38(%rbx)... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::Passed(bool) | bool DeathTestImpl::Passed(bool status_ok) {
if (!spawned()) return false;
const std::string error_message = GetErrorLogs();
bool success = false;
Message buffer;
buffer << "Death test: " << statement() << "\n";
switch (outcome()) {
case LIVED:
buffer << " Result: failed to die.\n"
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
cmpb $0x1, 0x28(%rdi)
jne 0xdff4
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %rax
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq *0x30(%rax)
leaq -0x48(%rbp), %rdi
callq 0x1b1fc
movq -0x48(%rbp), %rbx
addq ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-death-test.cc |
testing::internal::FormatDeathTestOutput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static ::std::string FormatDeathTestOutput(const ::std::string& output) {
::std::string ret;
for (size_t at = 0;;) {
const size_t line_end = output.find('\n', at);
ret += "[ DEATH ] ";
if (line_end == ::std::string::npos) {
ret += output.substr(at);
break;
}
ret += output.substr(a... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
movq %r14, %rdi
movl $0xa, %esi
movq %r12, %rdx
callq 0x8700
movq... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-death-test.cc |
testing::internal::ForkingDeathTest::Wait() | int ForkingDeathTest::Wait() {
if (!spawned()) return 0;
ReadAndInterpretStatusByte();
int status_value;
GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
set_status(status_value);
return status_value;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
xorl %eax, %eax
cmpb $0x1, 0x28(%rdi)
jne 0xe8c2
movq %rdi, %rbx
callq 0xd3bc
leaq -0x2c(%rbp), %r14
movl 0x3c(%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x83d0
cmpl $-0x1, %eax
jne 0xe8bc... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-death-test.cc |
testing::internal::NoExecDeathTest::AssumeRole() | DeathTest::TestRole NoExecDeathTest::AssumeRole() {
const size_t thread_count = GetThreadCount();
if (thread_count != 1) {
GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
}
int pipe_fd[2];
GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
DeathTest::set_last_death_test_message("");
CaptureS... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %rbx
callq 0xf9b2
cmpq $0x1, %rax
je 0xed2f
movq %rax, %r12
leaq 0x2ed08(%rip), %rdx # 0x3d8e6
leaq -0x88(%rbp), %rdi
movl $0x1, %esi
movl $0x44e, %ecx # imm = 0x44E
cal... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-death-test.cc |
testing::internal::GetThreadCount() | size_t GetThreadCount() {
const std::string filename =
(Message() << "/proc/" << getpid() << "/stat").GetString();
return ReadProcFileField<size_t>(filename, 19);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp # imm = 0x250
leaq -0x270(%rbp), %rbx
movq %rbx, %rdi
callq 0x1b1fc
movq (%rbx), %rbx
leaq 0x10(%rbx), %r14
leaq 0x2e2e2(%rip), %rsi # 0x3dcc3
movl $0x6, %edx
movq %r14, %rdi
callq 0x85a0
callq 0x87e0
movq %r14, %rdi... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-port.cc |
testing::internal::FilePath::RemoveFileName() const | FilePath FilePath::RemoveFileName() const {
const char* const last_sep = FindLastPathSeparator();
std::string dir;
if (last_sep) {
dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str()));
} else {
dir = kCurrentDirectoryString;
}
return FilePath(dir);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %rdi
movl $0x2f, %esi
callq 0x8550
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
testq %rax, %rax
je 0x12fd8
incq %rax
leaq -0x50(%rbp), %r12
movq ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::MakeFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, int, char const*) | FilePath FilePath::MakeFileName(const FilePath& directory,
const FilePath& base_name, int number,
const char* extension) {
std::string file;
if (number == 0) {
file = base_name.string() + "." + extension;
} else {
file =
base_name.str... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, -0x6c(%rbp)
leaq -0xc0(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
testl %ecx, %ecx
je 0x1313b
leaq -0x80(%rbp), %r12
movq %r12, -0x... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::RemoveTrailingPathSeparator() const | FilePath FilePath::RemoveTrailingPathSeparator() const {
return IsDirectory() ? FilePath(pathname_.substr(0, pathname_.length() - 1))
: *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x13739
movq (%rsi), %rax
cmpb $0x2f, -0x1(%rax,%rcx)
sete %r15b
jmp 0x1373c
xorl %r15d, %r15d
testb %r15b, %r15b
je 0x13775
decq %rcx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
xorl %edx, %... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::GenerateUniqueFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, char const*) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
const FilePath& base_name,
const char* extension) {
FilePath full_pathname;
int number = 0;
do {
full_pathname.Set(MakeFileName(directory, base_name, number+... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r13d, %r13d
leaq -0xc8(%rbp), %r14
mov... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::CreateDirectoriesRecursively() const | bool FilePath::CreateDirectoriesRecursively() const {
if (!this->IsDirectory()) {
return false;
}
if (pathname_.length() == 0 || this->DirectoryExists()) {
return true;
}
const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
return parent.CreateDirectoriesRecursively() && th... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x13ab4
movq %rdi, %rbx
sete %cl
movq (%rdi), %rdx
cmpb $0x2f, -0x1(%rdx,%rax)
sete %r14b
setne %al
orb %cl, %al
jne 0x13adb
leaq -0xc0(%rbp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x82b0
mov... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::CreateFolder() const | bool FilePath::CreateFolder() const {
#ifdef GTEST_OS_WINDOWS_MOBILE
FilePath removed_sep(this->RemoveTrailingPathSeparator());
LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
delete[] unicode;
#elif defined(GTEST_OS_WINDOWS)
int result = _m... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1ff, %esi # imm = 0x1FF
callq 0x8210
movl %eax, %ecx
movb $0x1, %al
cmpl $-0x1, %ecx
jne 0x13b87
leaq -0xa0(%rbp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x82b0
movq (%rbx), %rdi
m... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::Normalize() | void FilePath::Normalize() {
auto out = pathname_.begin();
auto i = pathname_.cbegin();
#ifdef GTEST_OS_WINDOWS
// UNC paths are treated specially
if (pathname_.end() - i >= 3 && IsPathSeparator(*i) &&
IsPathSeparator(*(i + 1)) && !IsPathSeparator(*(i + 2))) {
*(out++) = kPathSeparator;
*(out++) ... | pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
cmpq $0x0, 0x8(%rdi)
je 0x13bd9
movq %rdx, %rax
movq %rdx, %rcx
movb (%rcx), %sil
cmpb $0x2f, %sil
jne 0x13bbf
movb $0x2f, %sil
cmpq %rdx, %rax
je 0x13bbf
cmpb $0x2f, -0x1(%rax)
je 0x13bc5
movb %sil, (%rax)
incq %rax
incq %rcx
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
addq %rdx... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-filepath.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3eb0c(%rip), %r14 # 0x52718
movq %r14, (%rdi)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x60(%rbp... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(char const*) | Matcher<const std::string&>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3e998(%rip), %r14 # 0x52718
movq %r14, (%rdi)
leaq -0x78(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3061e
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x78(%rbp), %rs... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3e860(%rip), %r14 # 0x52748
movq %r14, (%rdi)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x60(%rbp... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3e196(%rip), %r14 # 0x527a8
movq %r14, (%rdi)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x60(%rbp... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(char const*) | Matcher<internal::StringView>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3e022(%rip), %r14 # 0x527a8
movq %r14, (%rdi)
leaq -0x78(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3061e
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x78(%rbp), %rs... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-matchers.cc |
testing::internal::FormatFileLocation[abi:cxx11](char const*, int) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
const std::string file_name(file == nullptr ? kUnknownFile : file);
if (line < 0) {
return file_name + ":";
}
#ifdef _MSC_VER
return file_name + "(" + StreamableToString(line) + "):";
#else
return file_name + ":" + StreamableToStri... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, -0x24(%rbp)
testq %rsi, %rsi
leaq 0x2774f(%rip), %rax # 0x3c718
cmoveq %rax, %r14
leaq -0x98(%rbp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x8200
leaq (%rax,%r14), %rdx
leaq ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-port.cc |
testing::internal::FormatCompilerIndependentFileLocation[abi:cxx11](char const*, int) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
int line) {
const std::string file_name(file == nullptr ? kUnknownFile : file);
if (line < 0)
return file_name;
else
return file_name + ":" + StreamableToString(... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, -0x1c(%rbp)
testq %rsi, %rsi
leaq 0x2748f(%rip), %rax # 0x3c718
cmoveq %rax, %r14
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x8200
leaq (%rax,%r14), %rdx
leaq -0x80(%rbp)... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-port.cc |
testing::internal::GTestLog::~GTestLog() | GTestLog::~GTestLog() {
GetStream() << ::std::endl;
if (severity_ == GTEST_FATAL) {
fflush(stderr);
posix::Abort();
}
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3da40(%rip), %rdi # 0x52fe8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x8480
movsbl %al, %esi
movq 0x3da25(%rip), %rdi # 0x52fe8
callq 0x8050
movq %rax, %rdi
callq 0x8320
cmpl $0x3, (%rbx)
je 0x155dc
addq $0x8, %rsp
pop... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-port.cc |
testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*) | std::string ReadEntireFile(FILE* file) {
const size_t file_size = GetFileSize(file);
char* const buffer = new char[file_size];
size_t bytes_last_read = 0; // # of bytes read in the last fread()
size_t bytes_read = 0; // # of bytes read so far
fseek(file, 0, SEEK_SET);
// Keeps reading the file unt... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x8560
movq %r14, %rdi
callq 0x8030
movq %rax, %r12
movq %rax, %rdi
callq 0x8040
movq %rax, %r15
movq %r14, %rdi
xorl %esi,... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-port.cc |
testing::internal::PrintTo(wchar_t const*, std::ostream*) | void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x16545
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x83b0
leaq 0x29b55(%rip), %rsi # 0x40073
movl $0xd, %edx
movq %rax, %rdi
callq 0x85a0
movq %r14, %rdi
callq 0x8400
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-printers.cc |
testing::internal::HasNewFatalFailureHelper::~HasNewFatalFailureHelper() | HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
original_reporter_);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3afb4(%rip), %rax # 0x51de8
movq %rax, (%rdi)
callq 0x176be
movq 0x10(%rbx), %rbx
movl $0x90, %edi
addq 0x3c98c(%rip), %rdi # 0x537d8
callq 0x39610
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x30b01
nop... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-test-part.cc |
testing::internal::RegisterTypeParameterizedTestSuite(char const*, testing::internal::CodeLocation) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
CodeLocation code_location) {
GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
test_suite_name, code_location);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x176be
movl $0x100, %r15d # imm = 0x100
addq 0x3c3ac(%rip), %r15 # 0x537d8
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rs... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&) | std::string AppendUserMessage(const std::string& gtest_msg,
const Message& user_msg) {
// Appends the user message if it's non-empty.
const std::string user_msg_string = user_msg.GetString();
if (user_msg_string.empty()) {
return gtest_msg;
}
if (gtest_msg.empty()) {
retu... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x1b469
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x17b86
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x17ba1
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
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.