name string | code string | asm string | file string |
|---|---|---|---|
ecp_safe_invert_jac | static int ecp_safe_invert_jac( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *Q,
unsigned char inv )
{
int ret;
unsigned char nonzero;
mbedtls_mpi mQY;
mbedtls_mpi_init( &mQY );
/* Use the fact that -Q.Y mod P = P - Q.Y unless Q.Y == 0 */
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3aa30
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
leaq -0x38(%rbp), %rdi
callq 0x3cdc0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
mbedtls_ecp_group_load | int mbedtls_ecp_group_load( mbedtls_ecp_group *grp, mbedtls_ecp_group_id id )
{
mbedtls_ecp_group_free( grp );
grp->id = id;
switch( id )
{
#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
case MBEDTLS_ECP_DP_SECP192R1:
NIST_MODP( p192 );
return( LOAD_GROUP( secp192r1 ) );... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x476b0
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xb, %eax
ja 0x4ceef
movq -0x20(%rbp), %rax
leaq 0x... | /Dragonchang[P]https_client/mbedtls/library/ecp_curves.c |
ecp_group_load | static int ecp_group_load( mbedtls_ecp_group *grp,
const mbedtls_mpi_uint *p, size_t plen,
const mbedtls_mpi_uint *a, size_t alen,
const mbedtls_mpi_uint *b, size_t blen,
const mbedtls_mpi_uint *gx, size_t gxl... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9,... | /Dragonchang[P]https_client/mbedtls/library/ecp_curves.c |
ecp_mod_p256 | static int ecp_mod_p256( mbedtls_mpi *N )
{
INIT( 256 );
ADD( 8 ); ADD( 9 );
SUB( 11 ); SUB( 12 ); SUB( 13 ); SUB( 14 ); NEXT; // A0
ADD( 9 ); ADD( 10 );
SUB( 12 ); SUB( 13 ); SUB( 14 ); SUB( 15 ); NEXT; // A1
ADD( 10 ); ADD( 11 );
SUB( 13 ); SUB( 14 ); SUB( 15 ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0xd(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x100, -0x28(%rbp) # imm = 0x100
movl $0x1, -0x40(%rbp)
movq $0x5, -0x38(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %... | /Dragonchang[P]https_client/mbedtls/library/ecp_curves.c |
ecp_use_curve25519 | static int ecp_use_curve25519( mbedtls_ecp_group *grp )
{
int ret;
/* Actually ( A + 2 ) / 4 */
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &grp->A, 16, "01DB42" ) );
/* P = 2^255 - 19 */
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &grp->P, 1 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &grp->P, 255 ) );
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl $0x10, %esi
leaq 0x33d70(%rip), %rdx # 0x84610
callq 0x3b550
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x508b2
jmp 0x5099f
jmp 0x508b4
jmp 0x508b6
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq ... | /Dragonchang[P]https_client/mbedtls/library/ecp_curves.c |
mbedtls_entropy_init | void mbedtls_entropy_init( mbedtls_entropy_context *ctx )
{
memset( ctx, 0, sizeof(mbedtls_entropy_context) );
#if defined(MBEDTLS_THREADING_C)
mbedtls_mutex_init( &ctx->mutex );
#endif
#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
mbedtls_sha512_starts( &ctx->accumulator, 0 );
#else
mbedtls_sha256_... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx # imm = 0x400
callq 0x10140
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x68630
movq -0x8(%rbp), %rdi
leaq 0x95e(%rip), %rsi # 0x51930
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %e... | /Dragonchang[P]https_client/mbedtls/library/entropy.c |
mbedtls_md_setup | int mbedtls_md_setup( mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info, int hmac )
{
if( md_info == NULL || ctx == NULL )
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
if( ( ctx->md_ctx = md_info->ctx_alloc_func() ) == NULL )
return( MBEDTLS_ERR_MD_ALLOC_FAILED );
if( hmac != 0 )
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x55591
cmpq $0x0, -0x10(%rbp)
jne 0x5559a
movl $0xffffaf00, -0x4(%rbp) # imm = 0xFFFFAF00
jmp 0x55615
movq -0x18(%rbp), %rax
callq *0x38(%rax)
movq -0x10(%rbp), %rcx
movq %rax, 0x8... | /Dragonchang[P]https_client/mbedtls/library/md.c |
mbedtls_md_hmac_starts | int mbedtls_md_hmac_starts( mbedtls_md_context_t *ctx, const unsigned char *key, size_t keylen )
{
unsigned char sum[MBEDTLS_MD_MAX_SIZE];
unsigned char *ipad, *opad;
size_t i;
if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
if( k... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x558c3
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x558c3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x558cf
movl $0xffffaf00, -0x4(%rbp) # imm = 0xFFFFAF00
jmp 0x55a59
movq... | /Dragonchang[P]https_client/mbedtls/library/md.c |
mbedtls_md_hmac | int mbedtls_md_hmac( const mbedtls_md_info_t *md_info, const unsigned char *key, size_t keylen,
const unsigned char *input, size_t ilen,
unsigned char *output )
{
mbedtls_md_context_t ctx;
int ret;
if( md_info == NULL )
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
m... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x55ca0
movl $0xffffaf00, -0x4(%rbp) # imm = 0xFFFFAF00
jmp 0x55d0a
leaq -0x50(%rbp), %rdi
callq 0x553c0
movq -0x... | /Dragonchang[P]https_client/mbedtls/library/md.c |
mbedtls_pk_verify | int mbedtls_pk_verify( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len )
{
if( ctx == NULL || ctx->pk_info == NULL ||
pk_hashlen_helper( md_alg, &hash_len ) != 0 )
return( MBEDTLS_ER... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x59a41
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x59a41
movl -0x14(%rbp), %edi
leaq -0x28(%rbp), %rsi
callq 0x... | /Dragonchang[P]https_client/mbedtls/library/pk.c |
mbedtls_pk_verify_ext | int mbedtls_pk_verify_ext( mbedtls_pk_type_t type, const void *options,
mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len )
{
if( ctx == NULL || ctx->pk_info == NULL )
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x59b48
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x59b5... | /Dragonchang[P]https_client/mbedtls/library/pk.c |
mbedtls_pk_decrypt | int mbedtls_pk_decrypt( mbedtls_pk_context *ctx,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
if( ctx == NULL || ctx->pk_info == NULL )
return( MBEDTL... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x59de9
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x59df2
movl $0xf... | /Dragonchang[P]https_client/mbedtls/library/pk.c |
rsa_alt_decrypt_wrap | static int rsa_alt_decrypt_wrap( void *ctx,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen, size_t osize,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
mbedtls_rsa_alt_context *rsa_alt = (mbedtls_rsa_alt_conte... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq... | /Dragonchang[P]https_client/mbedtls/library/pk_wrap.c |
rsa_alt_check_pair | static int rsa_alt_check_pair( const void *pub, const void *prv )
{
unsigned char sig[MBEDTLS_MPI_MAX_SIZE];
unsigned char hash[32];
size_t sig_len = 0;
int ret;
if( rsa_alt_get_bitlen( prv ) != rsa_get_bitlen( pub ) )
return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
memset( hash, 0x2a, siz... | pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp # imm = 0x470
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x448(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5a870
movq %rax, -0x458(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5a0e0
movq %rax, %rcx
movq -0x458(%rbp), %rax
cmpq %rcx, %rax
je 0x5aa52
movl $0xffffbe0... | /Dragonchang[P]https_client/mbedtls/library/pk_wrap.c |
pk_get_rsapubkey | static int pk_get_rsapubkey( unsigned char **p,
const unsigned char *end,
mbedtls_rsa_context *rsa )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x30, %ecx
callq 0x3a1e0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x5b772
movl -0x24(%rbp), %eax
addl $0xffffc500, %eax # imm... | /Dragonchang[P]https_client/mbedtls/library/pkparse.c |
mbedtls_rsa_rsaes_pkcs1_v15_decrypt | int mbedtls_rsa_rsaes_pkcs1_v15_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,
... | pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp # imm = 0x480
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x0, -0x62(%rbp)
cmpl $0x1, -0x24(%rbp)
j... | /Dragonchang[P]https_client/mbedtls/library/rsa.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,
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl 0x148(%rax), %eax
movl %eax, -0x44(%rbp)
testl %eax, %eax... | /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mbedtls_sha1_finish | void mbedtls_sha1_finish( mbedtls_sha1_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_BE( high, msglen, 0 );
PUT_UINT3... | 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... | /Dragonchang[P]https_client/mbedtls/library/sha1.c |
mbedtls_timing_get_timer | unsigned long mbedtls_timing_get_timer( struct mbedtls_timing_hr_time *val, int reset )
{
unsigned long delta;
struct timeval offset;
struct _hr_time *t = (struct _hr_time *) val;
gettimeofday( &offset, NULL );
if( reset )
{
t->start.tv_sec = offset.tv_sec;
t->start.tv_usec = ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10130
cmpl $0x0, -0x14(%rbp)
je 0x69fdb
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp),... | /Dragonchang[P]https_client/mbedtls/library/timing.c |
busy_msleep | static void busy_msleep( unsigned long msec )
{
struct mbedtls_timing_hr_time hires;
unsigned long i = 0; /* for busy-waiting */
volatile unsigned long j; /* to prevent optimisation */
(void) mbedtls_timing_get_timer( &hires, 1 );
while( mbedtls_timing_get_timer( &hires, 0 ) < msec )
i++;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x69f90
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x69f90
cmpq -0x8(%rbp), %rax
jae 0x6a601
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6a5e2
movq -0x30(%rbp),... | /Dragonchang[P]https_client/mbedtls/library/timing.c |
aes_gen_tables | static void aes_gen_tables( void )
{
int i, x, y, z;
int pow[256];
int log[256];
/*
* compute pow and log tables over GF(2^8)
*/
for( i = 0, x = 1; i < 256; i++ )
{
pow[i] = x;
log[x] = i;
x = ( x ^ XTIME( x ) ) & 0xFF;
}
/*
* calculate the round ... | pushq %rbp
movq %rsp, %rbp
subq $0x7b0, %rsp # imm = 0x7B0
movl $0x0, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
cmpl $0x100, -0x4(%rbp) # imm = 0x100
jge 0x6ace3
movl -0x8(%rbp), %ecx
movslq -0x4(%rbp), %rax
movl %ecx, -0x410(%rbp,%rax,4)
movl -0x4(%rbp), %ecx
movslq -0x8(%rbp), %rax
movl %ecx, -0x810(%rbp,%rax,... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_decrypt | void mbedtls_aes_decrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] )
{
int i;
uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
RK = ctx->rk;
GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
GET_UINT32_LE( X1, inp... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%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)... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_crypt_ctr | int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
size_t length,
size_t *nc_off,
unsigned char nonce_counter[16],
unsigned char stream_block[16],
const unsigned char *input,
unsig... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aesni_setkey_enc | int mbedtls_aesni_setkey_enc( unsigned char *rk,
const unsigned char *key,
size_t bits )
{
switch( bits )
{
case 128: aesni_setkey_enc_128( rk, key ); break;
case 192: aesni_setkey_enc_192( rk, key ); break;
case 256: aesni_setkey_enc_256( rk, ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
subq $0x80, %rax
je 0x6dc22
jmp 0x6dc06
movq -0x28(%rbp), %rax
subq $0xc0, %rax
je 0x6dc31
jmp 0x6dc14
movq -0x28(%rbp), %rax
subq $0x100, %rax # imm ... | /Dragonchang[P]https_client/mbedtls/library/aesni.c |
blowfish_enc | static void blowfish_enc( mbedtls_blowfish_context *ctx, uint32_t *xl, uint32_t *xr )
{
uint32_t Xl, Xr, temp;
short i;
Xl = *xl;
Xr = *xr;
for( i = 0; i < MBEDTLS_BLOWFISH_ROUNDS; ++i )
{
Xl = Xl ^ ctx->P[i];
Xr = F( ctx, Xl ) ^ Xr;
temp = Xl;
Xl = Xr;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movw $0x0, -0x26(%rbp)
movswl -0x26(%rbp), %eax
cmpl $0x10, %eax
jge 0x6ede9
mov... | /Dragonchang[P]https_client/mbedtls/library/blowfish.c |
argagg::parser_results::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline
option_results& parser_results::operator [] (const std::string& name)
try {
return this->options.at(name);
} catch (const std::out_of_range& e) {
std::ostringstream msg;
msg << "no option named \"" << name << "\" in parser_results";
throw unknown_option(msg.str());
} | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rdi
addq $0x8, %rdi
movq 0x1d8(%rsp), %rsi
callq 0x17ed0
movq %rax, 0x18(%rsp)
jmp 0xf697
movq 0x18(%rsp), %rax
addq $0x1e8, %rsp # imm = 0x1E8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1d0(%rs... | /catid[P]mau/tests/argagg.hpp |
int argagg::option_result::as<int>(int const&) const | T option_result::as(const T& t) const
{
if (this->arg) {
try {
return convert::arg<T>(this->arg);
} catch (...) {
return t;
}
} else {
// I actually think this will never happen. To call this method you have
// to access a specific option_result for an option. If there's a
// spe... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
je 0x19ef5
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x19f70
movl %eax, 0x4(%rsp)
jmp 0x19ec1
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x19f00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1... | /catid[P]mau/tests/argagg.hpp |
float argagg::convert::arg<float>(char const*) | inline
float arg(const char* arg)
{
char* endptr = nullptr;
errno = 0;
float ret = std::strtof(arg, &endptr);
if (endptr == arg) {
std::ostringstream msg;
msg << "unable to convert argument to integer: \"" << arg << "\"";
throw std::invalid_argument(msg.str());
}
if (errno ... | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movq $0x0, 0x1e8(%rsp)
callq 0x7050
movl $0x0, (%rax)
movq 0x1f0(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x7600
vmovss %xmm0, 0x1e4(%rsp)
movq 0x1e8(%rsp), %rax
cmpq 0x1f0(%rsp), %rax
jne 0x1a48e
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x7610
... | /catid[P]mau/tests/argagg.hpp |
unsigned int argagg::convert::long_<unsigned int>(char const*) | inline
T long_(const char* arg)
{
char* endptr = nullptr;
errno = 0;
T ret = static_cast<T>(std::strtol(arg, &endptr, 0));
if (endptr == arg) {
std::ostringstream msg;
msg << "unable to convert argument to integer: \"" << arg << "\"";
throw std::invalid_argument(msg.str());
}
... | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movq $0x0, 0x1e8(%rsp)
callq 0x7050
movl $0x0, (%rax)
movq 0x1f0(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
xorl %edx, %edx
callq 0x76a0
movl %eax, 0x1e4(%rsp)
movq 0x1e8(%rsp), %rax
cmpq 0x1f0(%rsp), %rax
jne 0x1a6fe
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
... | /catid[P]mau/tests/argagg.hpp |
mau_proxy_create | MAU_EXPORT MauResult mau_proxy_create(
const MauProxyConfig* config, ///< [in] Configuration for the socket
const MauChannelConfig* channel, ///< [in] Channel configuration
const char* hostname, ///< [in] Hostname of the server
uint16_t port, ///< [in] UDP Port for the se... | subq $0x78, %rsp
movw %cx, %ax
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movw %ax, 0x5e(%rsp)
movq %r8, 0x50(%rsp)
callq 0x1b4e0
movq $0x0, 0x48(%rsp)
movl $0x2, 0x44(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0x1b356
cmpq $0x0, 0x50(%rsp)
jne 0x1b363
movl $0x1, 0x44(%rsp)
jmp 0x1b4a7
movq 0x70(%rsp), %rax
... | /catid[P]mau/mau.cpp |
IncrementLoggerRefs() | static void IncrementLoggerRefs()
{
Locker locker(LoggerLock);
if (LoggerRefs == 0)
logger::Start();
++LoggerRefs;
} | subq $0x28, %rsp
leaq 0x20(%rsp), %rdi
leaq 0x3bff8(%rip), %rsi # 0x574e8
callq 0x1bba0
cmpq $0x0, 0x3c193(%rip) # 0x57690
jne 0x1b535
callq 0x399e0
movq %rax, 0x8(%rsp)
jmp 0x1b50b
movq 0x8(%rsp), %rdi
callq 0x39c10
jmp 0x1b517
jmp 0x1b519
jmp 0x1b535
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl ... | /catid[P]mau/mau.cpp |
ValidateMauChannelConfig(MauChannelConfig_t const&) | static bool ValidateMauChannelConfig(const MauChannelConfig& config)
{
if (!IsWithin01(config.LossRate)) {
return false;
}
if (!IsWithin01(config.DeliveryRate)) {
return false;
}
if (config.Router_MBPS <= 0.01f) {
return false;
}
if (config.Router_QueueMsec <= 10) {
... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
vmovss 0x4(%rax), %xmm0
callq 0x1b920
testb $0x1, %al
jne 0x1b606
movb $0x0, 0x17(%rsp)
jmp 0x1b6dc
movq 0x8(%rsp), %rax
vmovss 0x8(%rax), %xmm0
callq 0x1b920
testb $0x1, %al
jne 0x1b623
movb $0x0, 0x17(%rsp)
jmp 0x1b6dc
movq 0x8(%rsp), %rax
vmovss 0x239ec(%rip... | /catid[P]mau/mau.cpp |
DecrementLoggerRefs() | static void DecrementLoggerRefs()
{
Locker locker(LoggerLock);
--LoggerRefs;
MAU_DEBUG_ASSERT(LoggerRefs >= 0);
#ifdef MAU_DLL
// Stop logger when built as DLL
if (LoggerRefs == 0)
logger::Stop();
#endif
} | pushq %rax
movq %rsp, %rdi
leaq 0x3bded(%rip), %rsi # 0x574e8
callq 0x1bba0
movq 0x3bf89(%rip), %rax # 0x57690
addq $-0x1, %rax
movq %rax, 0x3bf7e(%rip) # 0x57690
movq %rsp, %rdi
callq 0x1bbe0
popq %rax
retq
nopl (%rax)
| /catid[P]mau/mau.cpp |
asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::cancel(asio::detail::deadline_timer_service<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::imp... | std::size_t cancel(implementation_type& impl, asio::error_code& ec)
{
if (!impl.might_have_pending_waits)
{
ec = asio::error_code();
return 0;
}
ASIO_HANDLER_OPERATION((scheduler_.context(),
"deadline_timer", &impl, 0, "cancel"));
std::size_t count = scheduler_.cancel_timer... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
testb $0x1, 0x8(%rax)
jne 0x1c3c3
leaq 0x38(%rsp), %rdi
callq 0x1c340
movq 0x48(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%r... | /catid[P]mau/thirdparty/asio/detail/deadline_timer_service.hpp |
asio::detail::timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::cancel_timer(asio::detail::timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::per_timer_data&, as... | std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops,
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)())
{
std::size_t num_cancelled = 0;
if (timer.prev_ != 0 || &timer == timers_)
{
while (wait_op* op = (num_cancelled != max_cancelled)
? timer... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1c5cb
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
cmpq 0x10(%rcx), %rax
jne 0x1c662
jmp 0x1c5cd
mov... | /catid[P]mau/thirdparty/asio/detail/timer_queue.hpp |
asio::detail::timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>::up_heap(unsigned long) | void up_heap(std::size_t index)
{
while (index > 0)
{
std::size_t parent = (index - 1) / 2;
if (!Time_Traits::less_than(heap_[index].time_, heap_[parent].time_))
break;
swap_heap(index, parent);
index = parent;
}
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jbe 0x1ce4d
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
subq $0x1, %rax
shrq %rax
movq %rax, 0x10(%rsp)
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
callq 0x1cda0
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)... | /catid[P]mau/thirdparty/asio/detail/timer_queue.hpp |
void asio::detail::op_queue<asio::detail::scheduler_operation>::push<asio::detail::scheduler_operation>(asio::detail::op_queue<asio::detail::scheduler_operation>&) | void push(op_queue<OtherOperation>& q)
{
if (Operation* other_front = op_queue_access::front(q))
{
if (back_)
op_queue_access::next(back_, other_front);
else
front_ = other_front;
back_ = op_queue_access::back(q);
op_queue_access::front(q) = 0;
op_queue_access::ba... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1d360
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1d2cb
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1d283
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), ... | /catid[P]mau/thirdparty/asio/detail/op_queue.hpp |
bool asio::detail::posix_event::maybe_unlock_and_signal_one<asio::detail::scoped_lock<asio::detail::posix_mutex>>(asio::detail::scoped_lock<asio::detail::posix_mutex>&) | bool maybe_unlock_and_signal_one(Lock& lock)
{
ASIO_ASSERT(lock.locked());
state_ |= 1;
if (state_ > 1)
{
lock.unlock();
::pthread_cond_signal(&cond_); // Ignore EINVAL.
return true;
}
return false;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x187e0
testb $0x1, %al
jne 0x1d3a8
jmp 0x1d3aa
jmp 0x1d3c9
leaq 0x223f7(%rip), %rdi # 0x3f7a8
leaq 0x223fe(%rip), %rsi # 0x3f7b6
movl $0x4d, %edx
leaq 0x226b6(%rip), %rcx # 0x... | /catid[P]mau/thirdparty/asio/detail/posix_event.hpp |
asio::detail::op_queue<asio::detail::scheduler_operation>::pop() | void pop()
{
if (front_)
{
Operation* tmp = front_;
front_ = op_queue_access::next(front_);
if (front_ == 0)
back_ = 0;
op_queue_access::next(tmp, static_cast<Operation*>(0));
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rax)
je 0x1d466
movq (%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
callq 0x1d480
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x1d458
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
le... | /catid[P]mau/thirdparty/asio/detail/op_queue.hpp |
asio::detail::op_queue<asio::detail::reactor_op>::pop() | void pop()
{
if (front_)
{
Operation* tmp = front_;
front_ = op_queue_access::next(front_);
if (front_ == 0)
back_ = 0;
op_queue_access::next(tmp, static_cast<Operation*>(0));
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rax)
je 0x1df86
movq (%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
callq 0x1e000
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x1df78
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
le... | /catid[P]mau/thirdparty/asio/detail/op_queue.hpp |
mau::ProxySession::Initialize(char const*, unsigned short, MauProxyConfig_t const&, MauChannelConfig_t const&) | MauResult ProxySession::Initialize(
const char* serverHostname,
uint16_t serverPort,
const MauProxyConfig& proxyConfig,
const MauChannelConfig& channelConfig)
{
MauResult result = Mau_Success;
try
{
ProxyConfig = proxyConfig;
ChannelConfig.Set(channelConfig);
ServerH... | subq $0x8e8, %rsp # imm = 0x8E8
movw %dx, %ax
movq %rdi, 0x4b8(%rsp)
movq %rsi, 0x4b0(%rsp)
movw %ax, 0x4ae(%rsp)
movq %rcx, 0x4a0(%rsp)
movq %r8, 0x498(%rsp)
movq 0x4b8(%rsp), %rdi
movq %rdi, 0x1d8(%rsp)
movl $0x0, 0x494(%rsp)
movq 0x4a0(%rsp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x2f0(%rdi)
vmovdqu (%rax... | /catid[P]mau/MauProxy.cpp |
mau::ProxySession::Inject(unsigned short, void const*, unsigned int) | MauResult ProxySession::Inject(
uint16_t sourcePort, ///< [in] Source port
const void* datagram, ///< [in] Datagram buffer
unsigned bytes) ///< [in] Datagram bytes
{
Locker locker(APILock);
if (Terminated) {
return Mau_Success;
}
if (bytes > ProxyConfig.MaxDatagramBytes) {
... | subq $0x9c8, %rsp # imm = 0x9C8
movw %si, %ax
movq %rdi, 0x248(%rsp)
movw %ax, 0x246(%rsp)
movq %rdx, 0x238(%rsp)
movl %ecx, 0x234(%rsp)
movq 0x248(%rsp), %rsi
movq %rsi, 0xe8(%rsp)
addq $0x338, %rsi # imm = 0x338
leaq 0x228(%rsp), %rdi
callq 0x1bba0
movq 0xe8(%rsp), %rdi
addq $0x360, %rdi ... | /catid[P]mau/MauProxy.cpp |
pktalloc::Allocator::~Allocator() | Allocator::~Allocator()
{
for (unsigned i = 0, count = PreferredWindows.GetSize(); i < count; ++i)
{
WindowHeader* window = PreferredWindows.GetRef(i);
PKTALLOC_DEBUG_ASSERT(window != nullptr);
if (window && !window->Preallocated) {
SIMDSafeFree(window);
}
}
f... | subq $0x88, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x4c(%rsp)
addq $0x8, %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movl 0xc8(%rax), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x48(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x48(%rsp), %eax
jae 0x3ce68
movq 0x20(%... | /catid[P]mau/PacketAllocator.cpp |
elt_mul | static void elt_mul(u8 *d, u8 *a, u8 *b)
{
u32 i, n;
u8 mask;
elt_zero(d);
i = 0;
mask = 1;
for (n = 0; n < 233; n++) {
elt_mul_x(d, d);
if ((a[i] & mask) != 0)
elt_add(d, d, b);
mask >>= 1;
if (mask == 0) {
mask = 0x80;
i++;
}
}
} | pushq %rbp
pushq %r14
pushq %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0xe(%rdi)
movups %xmm0, (%rdi)
xorl %eax, %eax
movl $0x1, %ecx
movl $0x80, %r8d
xorl %r9d, %r9d
movb (%rdi), %r10b
movl $0x1, %ebx
xorl %r11d, %r11d
movb (%rdi,%rbx), %bpl
movl %ebp, %r14d
shrb $0x7, %r14b
orb %r11b, %r14b
movb %r14b, -0x1(%rdi,%rbx)
mov... | /simontime[P]devicecert-validator/ec.c |
PDCLIB_print | const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status )
{
const char * orig_spec = spec;
if ( *( ++spec ) == '%' )
{
/* %% -> print single '%' */
PUT( *spec );
return ++spec;
}
/* Initializing status structure */
status->flags = 0;
status->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
incq %rdi
movq %rdi, 0x10(%rsp)
cmpb $0x25, 0x1(%r14)
jne 0x24e1
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0x25f7
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x25ef
pushq $0x25
popq %rdi
callq 0x3784
jmp 0x25f7
an... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print.c |
PDCLIB_print_string | void _PDCLIB_print_string( const char * s, struct _PDCLIB_status_t * status )
{
if ( status->flags & E_char )
{
status->prec = 1;
}
else
{
if ( status->prec < 0 )
{
status->prec = strlen( s );
}
else
{
int i;
for ( ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %ebp
testb $0x40, %bpl
jne 0x358d
movl 0x30(%rbx), %ecx
testl %ecx, %ecx
js 0x3592
xorl %eax, %eax
cmpq %rax, %rcx
je 0x36b6
cmpb $0x0, (%r14,%rax)
je 0x359a
incq %rax
jmp 0x3578
pushq $0x1
popq %rax
jmp 0x359a
movq %r14, %rdi
callq 0x3928... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_string.c |
puts | int puts( const char * s )
{
_PDCLIB_LOCK( stdout->mtx );
if ( _PDCLIB_prepwrite( stdout ) == EOF )
{
_PDCLIB_UNLOCK( stdout->mtx );
return EOF;
}
while ( *s != '\0' )
{
stdout->buffer[ stdout->bufidx++ ] = *s++;
if ( stdout->bufidx == stdout->bufsize )
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38be(%rip), %r14 # 0x7058
movq (%r14), %rdi
addq $0x48, %rdi
callq 0x3748
movq (%r14), %rdi
callq 0x2450
cmpl $-0x1, %eax
je 0x37e6
movb (%rbx), %al
testb %al, %al
je 0x37ee
incq %rbx
movq (%r14), %rcx
movq 0x8(%rcx), %rdx
movq 0x18(%rcx), %rsi
leaq 0x1(%rsi)... | /DevSolar[P]pdclib/functions/stdio/puts.c |
fputc | int fputc( int c, struct _PDCLIB_file_t * stream )
{
_PDCLIB_LOCK( stream->mtx );
if ( _PDCLIB_prepwrite( stream ) == EOF )
{
_PDCLIB_UNLOCK( stream->mtx );
return EOF;
}
stream->buffer[stream->bufidx++] = ( char )c;
if ( ( stream->bufidx == stream->bufsize ) ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movl %edi, %ebx
leaq 0x48(%rsi), %r14
movq %r14, %rdi
callq 0x3748
movq %r15, %rdi
callq 0x2450
cmpl $-0x1, %eax
je 0x3b4e
movq 0x8(%r15), %rax
movq 0x18(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%r15)
movb %bl, (%rax,%rcx)
movq 0x18(%r15), %rax
cmpq 0x10(%r15), %... | /DevSolar[P]pdclib/functions/stdio/fputc.c |
Matrix::AddRow(int, int, Fraction) | bool Matrix::AddRow(int first_row, int second_row, Fraction coefficient) {
if (coefficient == 0) {
return false;
}
bool result = false;
for (int column = 0; column < m_; ++column) {
if (elements_[second_row][column] != 0) {
result = true;
elements_[first_row][column] += coefficient * elemen... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0xd260
leaq -0xc(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd760
testb $0x1, %al
jne 0x11f5c
j... | /Nicksechko[P]Math/matrix.cpp |
Matrix::CopyRow(Matrix const&, int, int) | bool Matrix::CopyRow(const Matrix& source_matrix, int source_row, int destination_row) {
bool result = false;
for (int column = 0; column < m_; ++column) {
if (elements_[destination_row][column] != source_matrix.At(source_row, column)) {
result = true;
elements_[destination_row][column] = source_mat... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x124d9
movq -0x28(%rbp... | /Nicksechko[P]Math/matrix.cpp |
Matrix::CopyColumn(int, int) | bool Matrix::CopyColumn(int source_column, int destination_column) {
if (source_column == destination_column) {
return false;
}
bool result = false;
for (int row = 0; row < n_; ++row) {
if (elements_[row][destination_column] != elements_[row][source_column]) {
result = true;
elements_[row][... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x1290b
movb $0x0, -0x1(%rbp)
jmp 0x129d9
movb $0x0, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
... | /Nicksechko[P]Math/matrix.cpp |
Matrix::GetInverse(Options::ChoiceType) const | Matrix Matrix::GetInverse(Options::ChoiceType choice_type) const {
assert(n_ == m_);
LinearSystem inverser(*this, Identity(n_));
bool linear_independent = inverser.RunGauss(choice_type);
Options::writer << inverser << std::endl;
if (!linear_independent) {
return Matrix(n_, n_);
}
return inverser.GetS... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x1a0(%rbp)
movq %rdi, %rax
movq %rax, -0x198(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x190(%rbp)
movl (%rcx), %eax
cmpl 0x4(%rcx), %eax
jne 0x12d3b
jmp 0x12d5a
leaq 0xa... | /Nicksechko[P]Math/matrix.cpp |
operator<<(std::ostream&, Permutation const&) | std::ostream& operator<<(std::ostream& out, const Permutation& permutation) {
if (Options::output_type == Options::OutputType::Standard) {
out << permutation.ToString();
} else if (Options::output_type == Options::OutputType::LaTex) {
out << permutation.ToLaTex();
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xcb6e(%rip), %rax # 0x273c8
cmpl $0x0, (%rax)
jne 0x1a8a9
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1a5a0
movq -0x70(%rbp), %rdi
movq -0x68(... | /Nicksechko[P]Math/permutation.cpp |
Permutation::IsIdentity() const | bool Permutation::IsIdentity() const {
for (int i = 0; i < static_cast<int>(permutation_.size()); ++i) {
if (permutation_[i] != i) {
return false;
}
}
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x173d0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x1a97b
movq -0x20(%rbp), %rdi
movslq -0x1... | /Nicksechko[P]Math/permutation.cpp |
icu_63::Calendar::getLocalDOW() | int32_t Calendar::getLocalDOW()
{
// Get zero-based localized DOW, valid range 0..6. This is the DOW
// we are looking for.
int32_t dowLocal = 0;
switch (resolveFields(kDOWPrecedence)) {
case UCAL_DAY_OF_WEEK:
dowLocal = internalGet(UCAL_DAY_OF_WEEK) - fFirstDayOfWeek;
break;
case... | pushq %rbx
movq %rdi, %rbx
leaq 0x10e605(%rip), %rsi # 0x1f8d20
callq 0xe9cf2
cmpl $0x12, %eax
je 0xea737
xorl %ecx, %ecx
cmpl $0x7, %eax
jne 0xea73c
movl 0x28(%rbx), %ecx
subl 0x100(%rbx), %ecx
jmp 0xea73c
movl 0x54(%rbx), %ecx
decl %ecx
movslq %ecx, %rcx
imulq $-0x6db6db6d, %rcx, %rdx # imm = 0x92492493
shrq $0x20... | /hunter-packages[P]icu/source/i18n/calendar.cpp |
icu_63::Calendar::getActualMaximum(UCalendarDateFields, UErrorCode&) const | int32_t
Calendar::getActualMaximum(UCalendarDateFields field, UErrorCode& status) const
{
int32_t result;
switch (field) {
case UCAL_DATE:
{
if(U_FAILURE(status)) return 0;
Calendar *cal = clone();
if(!cal) { status = U_MEMORY_ALLOCATION_ERROR; return 0; }
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x15, %esi
ja 0xeaa89
movl $0x35fe80, %eax # imm = 0x35FE80
btl %ebp, %eax
jae 0xea99a
movq (%rbx), %rax
movq 0x80(%rax), %rax
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq... | /hunter-packages[P]icu/source/i18n/calendar.cpp |
icu_63::Calendar::prepareGetActual(UCalendarDateFields, signed char, UErrorCode&) | void Calendar::prepareGetActual(UCalendarDateFields field, UBool isMinimum, UErrorCode &status)
{
set(UCAL_MILLISECONDS_IN_DAY, 0);
switch (field) {
case UCAL_YEAR:
case UCAL_EXTENDED_YEAR:
set(UCAL_DAY_OF_YEAR, getGreatestMinimum(UCAL_DAY_OF_YEAR));
break;
case UCAL_YEAR_WOY:
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movl $0x15, %esi
xorl %edx, %edx
callq 0xe7cac
leal -0x1(%rbx), %eax
cmpl $0x7, %eax
ja 0xeaca7
leaq 0x10da9c(%rip), %rcx # 0x1f86e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x100(... | /hunter-packages[P]icu/source/i18n/calendar.cpp |
calendar_cleanup() | U_CDECL_BEGIN
static UBool calendar_cleanup(void) {
#if !UCONFIG_NO_SERVICE
if (gService) {
delete gService;
gService = NULL;
}
gServiceInitOnce.reset();
#endif
return TRUE;
} | movq 0x247fe2(%rip), %rdi # 0x332dd0
testq %rdi, %rdi
je 0xeae09
pushq %rax
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x247fcb(%rip) # 0x332dd0
addq $0x8, %rsp
xorl %eax, %eax
xchgl %eax, 0x247fc7(%rip) # 0x332dd8
movb $0x1, %al
retq
| /hunter-packages[P]icu/source/i18n/calendar.cpp |
icu_63::BasicCalendarFactory::updateVisibleIDs(icu_63::Hashtable&, UErrorCode&) const | virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const
{
if (U_SUCCESS(status)) {
for(int32_t i=0;gCalTypes[i] != NULL;i++) {
UnicodeString id((UChar)0x40); /* '@' a variant character */
id.append(UNICODE_STRING_SIMPLE("calendar="));
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
cmpl $0x0, (%rdx)
jg 0xeb2c9
movq %rdx, %rbx
xorl %r15d, %r15d
leaq 0x68(%rsp), %r12
leaq 0x28(%rsp), %r13
movq %r12, %rdi
movl $0x40, %esi
callq 0x1c8a36
leaq 0x10e230(%rip), %rax # 0x1f941c... | /hunter-packages[P]icu/source/i18n/calendar.cpp |
void icu_63::UnifiedCache::get<icu_63::SharedCalendar>(icu_63::CacheKey<icu_63::SharedCalendar> const&, void const*, icu_63::SharedCalendar const*&, UErrorCode&) const | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%r8)
jle 0xeb6c3
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %rcx
leaq 0xc(%rsp), %r12
movl $0x0, (%r12)
leaq 0x10(%rsp), %r15
movq $0x0, (%r15)
movq %r15, %rdx
movq %r12, %r8
callq 0x1c0d50
movq (%r15), %r15
cmpl $0x0, (%r12)
jg 0xeb710
movq %... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::LocaleCacheKey<icu_63::SharedCalendar>::operator==(icu_63::CacheKeyBase const&) const | virtual UBool operator == (const CacheKeyBase &other) const {
// reflexive
if (this == &other) {
return TRUE;
}
if (!CacheKey<T>::operator == (other)) {
return FALSE;
}
// We know this and other are of same class because operator== on
// CacheKey re... | pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
je 0xeb848
movq %rsi, %rbx
movq %rdi, %r14
callq 0xeb880
testb %al, %al
je 0xeb84c
addq $0x10, %r14
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18cf14
movb $0x1, %al
jmp 0xeb84e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq... | /hunter-packages[P]icu/source/common/unifiedcache.h |
icu_63::ChineseCalendar::handleComputeMonthStart(int, int, signed char) const | int32_t ChineseCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const {
ChineseCalendar *nonConstThis = (ChineseCalendar*)this; // cast away const
// If the month is out of range, adjust it into range, and
// modify the extended year value accordingly.
if (month < 0 || m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0x8(%rsp)
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0xc, %edx
jb 0xebcf0
cvtsi2sd %r14d, %xmm0
leaq 0x10(%rsp), %r14
movsd %xmm0, (%r14)
movsd 0x10d7b7(%rip), %xmm1 # 0x1f9490
movq %r14, %rdi
callq 0xef438
cvtt... | /hunter-packages[P]icu/source/i18n/chnsecal.cpp |
icu_63::ChineseCalendar::roll(UCalendarDateFields, int, UErrorCode&) | void ChineseCalendar::roll(UCalendarDateFields field, int32_t amount, UErrorCode& status) {
switch (field) {
case UCAL_MONTH:
if (amount != 0) {
int32_t dom = get(UCAL_DAY_OF_MONTH, status);
if (U_FAILURE(status)) break;
int32_t day = get(UCAL_JULIAN_DAY, status) - kE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, %r14d
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0xebf1b
testl %r14d, %r14d
je 0xebf0c
movq %rbx, %rdi
movl $0x5, %esi
movq %r12, %rdx
callq 0xe7c06
cmpl $0x0, (%r12)
jg 0xebf0c
movl %eax, %ebp
movq %rbx, %rdi
movl $0x14, %... | /hunter-packages[P]icu/source/i18n/chnsecal.cpp |
icu_63::IslamicCalendar::handleComputeFields(int, UErrorCode&) | void IslamicCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status) {
int32_t year, month, dayOfMonth, dayOfYear;
int32_t startDate;
int32_t days = julianDay - CIVIL_EPOC;
if (cType == CIVIL || cType == TBLA) {
if(cType == TBLA) {
days = julianDay - ASTRONOMICAL_EPOC;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r12d
movq %rdi, %rbx
leal -0x1dbb18(%r12), %r13d
movl 0x264(%rdi), %eax
xorl %ebp, %ebp
cmpq $0x3, %rax
ja 0xf1a52
movq %rdx, %r14
leaq 0x108b0e(%rip), %rcx # 0x1fa420
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
... | /hunter-packages[P]icu/source/i18n/islamcal.cpp |
icu_63::IslamicCalendar::initializeSystemDefaultCentury() | U_CFUNC void U_CALLCONV
IslamicCalendar::initializeSystemDefaultCentury()
{
// initialize systemDefaultCentury and systemDefaultCenturyYear based
// on the current time. They'll be set to 80 years before
// the current time.
UErrorCode status = U_ZERO_ERROR;
IslamicCalendar calendar(Locale("@calend... | pushq %r14
pushq %rbx
subq $0x358, %rsp # imm = 0x358
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0x108f28(%rip), %rsi # 0x1fabb8
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x18ca4a
leaq 0xf0(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq... | /hunter-packages[P]icu/source/i18n/islamcal.cpp |
icu_63::init(UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rdi)
jg 0xf1ebe
pushq %rbx
movq %rdi, %rbx
movl 0x2410b9(%rip), %eax # 0x332ef0
cmpl $0x2, %eax
je 0xf1e73
leaq 0x2410ad(%rip), %rdi # 0x332ef0
callq 0x1c035f
testb %al, %al
je 0xf1e73
leaq 0x108d82(%rip), %rdi # 0x1fabd5
callq 0xd93c0
testq %rax, %rax
je 0xf1e81
leaq 0x108d6c(%rip), %rsi # 0x1... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::JapaneseCalendar::getDefaultMonthInYear(int) | int32_t JapaneseCalendar::getDefaultMonthInYear(int32_t eyear)
{
int32_t era = internalGetEra();
// TODO do we assume we can trust 'era'? What if it is denormalized?
int32_t month = 0;
// Find out if we are at the edge of an era
int32_t eraStart[3] = { 0,0,0 };
UErrorCode status = U_ZERO_ERR... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq (%rdi), %rax
callq *0x190(%rax)
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
movl %ebp, 0x8(%r14)
movq $0x0, (%r14)
leaq 0xc(%rsp), %rcx
movl %ebp, (%rcx)
movq 0x240f33(%rip), %rdi # 0x332ee8
movl %eax, %esi
movq %r14, %rdx
callq 0x113e22
movl 0x4(%r14)... | /hunter-packages[P]icu/source/i18n/japancal.cpp |
arrayEqual(void const*, void const*, int) | static UBool arrayEqual(const void *a1, const void *a2, int32_t size) {
if (a1 == NULL && a2 == NULL) {
return TRUE;
}
if ((a1 != NULL && a2 == NULL) || (a1 == NULL && a2 != NULL)) {
return FALSE;
}
if (a1 == a2) {
return TRUE;
}
return (uprv_memcmp(a1, a2, size) == ... | movb $0x1, %al
movq %rdi, %rcx
orq %rsi, %rcx
je 0xf34b7
testq %rdi, %rdi
setne %cl
testq %rsi, %rsi
setne %r8b
xorb %cl, %r8b
je 0xf34b8
xorl %eax, %eax
retq
cmpq %rsi, %rdi
je 0xf34b7
pushq %rax
movslq %edx, %rdx
callq 0xd9320
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
| /hunter-packages[P]icu/source/i18n/olsontz.cpp |
icu_63::OlsonTimeZone::getPreviousTransition(double, signed char, icu_63::TimeZoneTransition&) const | UBool
OlsonTimeZone::getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
UErrorCode status = U_ZERO_ERROR;
checkTransitionRules(status);
if (U_FAILURE(status)) {
return FALSE;
}
if (finalZone != NULL) {
if (inclusive && base == firstFinalTZTransiti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
leaq 0x24(%rsp), %r15
movl $0x0, (%r15)
movq %r15, %rsi
callq 0xf34d0
cmpl $0x0, (%r15)
jle 0xf3fe3
xorl %ebp, %ebp
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r... | /hunter-packages[P]icu/source/i18n/olsontz.cpp |
icu_63::PersianCalendar::handleComputeMonthStart(int, int, signed char) const | int32_t PersianCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /*useMonth*/) const {
// If the month is out of range, adjust it into range, and
// modify the extended year value accordingly.
if (month < 0 || month > 11) {
eyear += ClockMath::floorDivide(month, 12, month);
}... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edx, 0x4(%rsp)
cmpl $0xc, %edx
jb 0xf4604
cvtsi2sd %edx, %xmm0
leaq 0x4(%rsp), %rsi
movl $0xc, %edi
callq 0xef3f4
addl %ebx, %eax
movl %eax, %ebx
imull $0x16d, %ebx, %r14d # imm = 0x16D
leal 0x15(,%rbx,8), %edi
movl $0x21, %esi
callq 0xef3c8
addl %r14d, %eax
ad... | /hunter-packages[P]icu/source/i18n/persncal.cpp |
icu_63::RuleBasedTimeZone::copyRules(icu_63::UVector*) | UVector*
RuleBasedTimeZone::copyRules(UVector* source) {
if (source == NULL) {
return NULL;
}
UErrorCode ec = U_ZERO_ERROR;
int32_t size = source->size();
UVector *rules = new UVector(size, ec);
if (U_FAILURE(ec)) {
return NULL;
}
int32_t i;
for (i = 0; i < size; i++)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0xf4adc
movq %rsi, %r14
movl $0x0, 0xc(%rsp)
movl 0x8(%rsi), %ebp
movl $0x28, %edi
callq 0x1cc4a8
movq %rax, %rbx
testq %rax, %rax
je 0xf4a6d
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1e2e78
cmpl $0x0, 0xc(%rs... | /hunter-packages[P]icu/source/i18n/rbtz.cpp |
icu_63::RuleBasedTimeZone::complete(UErrorCode&) | TimeZoneRule*
RuleBasedTimeZone::findRuleInFinal(UDate date, UBool local,
int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const {
if (fFinalRules == NULL) {
return NULL;
}
AnnualTimeZoneRule* fr0 = (AnnualTimeZoneRule*)fFinalRules->elementAt(0);
AnnualT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
cmpl $0x0, (%rsi)
jg 0xf5133
movq %rdi, %r12
cmpb $0x0, 0x68(%rdi)
jne 0xf5133
movq %rsi, %rbx
movq 0x58(%r12), %rdi
testq %rdi, %rdi
je 0xf4b64
cmpl $0x2, 0x8(%rdi)
jne 0xf4f27
movq 0x48(%r12), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%r12),... | /hunter-packages[P]icu/source/i18n/rbtz.cpp |
icu_63::RuleBasedTimeZone::deleteTransitions() | void
RuleBasedTimeZone::deleteTransitions(void) {
if (fHistoricTransitions != NULL) {
while (!fHistoricTransitions->isEmpty()) {
Transition *trs = (Transition*)fHistoricTransitions->orphanElementAt(0);
uprv_free(trs);
}
delete fHistoricTransitions;
}
fHistoric... | pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0xf5298
cmpl $0x0, 0x8(%rdi)
je 0xf5292
xorl %esi, %esi
callq 0x1e35bc
movq %rax, %rdi
callq 0x186846
movq 0x60(%rbx), %rdi
jmp 0xf5277
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x60(%rbx)
popq %rbx
retq
| /hunter-packages[P]icu/source/i18n/rbtz.cpp |
icu_63::RuleBasedTimeZone::operator=(icu_63::RuleBasedTimeZone const&) | RuleBasedTimeZone&
RuleBasedTimeZone::operator=(const RuleBasedTimeZone& right) {
if (*this != right) {
BasicTimeZone::operator=(right);
deleteRules();
fInitialRule = right.fInitialRule->clone();
fHistoricRules = copyRules(right.fHistoricRules);
fFinalRules = copyRules(right.... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0xa8(%rax)
testb %al, %al
je 0xf53a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf88d4
movq %rbx, %rdi
callq 0xf52a2
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, 0x48(%rbx)
movq 0x50(%r14), %rsi
callq 0xf4a22
m... | /hunter-packages[P]icu/source/i18n/rbtz.cpp |
icu_63::RuleBasedTimeZone::useDaylightTime() const | UBool
RuleBasedTimeZone::useDaylightTime(void) const {
// Note: This implementation returns true when
// daylight saving time is used as of now or
// after the next transition.
UErrorCode status = U_ZERO_ERROR;
UDate now = uprv_getUTCtime() * U_MILLIS_PER_SECOND;
int32_t raw, dst;
getOffset(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x1c(%rsp), %r14
movl $0x0, (%r14)
callq 0x19a934
mulsd 0x103783(%rip), %xmm0 # 0x1f93d0
movq (%rbx), %rax
leaq 0x18(%rsp), %rdx
leaq 0x14(%rsp), %r15
movq %rbx, %rdi
movsd %xmm0, (%rsp)
xorl %esi, %esi
movq %r15, %rcx
movq %r14, %r8
callq *0x30(%... | /hunter-packages[P]icu/source/i18n/rbtz.cpp |
icu_63::RuleBasedTimeZone::getNextTransition(double, signed char, icu_63::TimeZoneTransition&) const | UBool
RuleBasedTimeZone::getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
UErrorCode status = U_ZERO_ERROR;
completeConst(status);
if (U_FAILURE(status)) {
return FALSE;
}
UDate transitionTime;
TimeZoneRule *fromRule, *toRule;
UBool found = findNext(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movsd %xmm0, (%rsp)
movq %rdi, %r14
leaq 0x24(%rsp), %r15
movl $0x0, (%r15)
movq %r15, %rsi
callq 0xf55f4
cmpl $0x0, (%r15)
jle 0xf6043
xorl %eax, %eax
jmp 0xf6091
movsbl %bpl, %esi
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
l... | /hunter-packages[P]icu/source/i18n/rbtz.cpp |
icu_63::RuleBasedTimeZone::findPrev(double, signed char, double&, icu_63::TimeZoneRule*&, icu_63::TimeZoneRule*&) const | UBool
RuleBasedTimeZone::findPrev(UDate base, UBool inclusive, UDate& transitionTime,
TimeZoneRule*& fromRule, TimeZoneRule*& toRule) const {
if (fHistoricTransitions == NULL) {
return FALSE;
}
UBool found = FALSE;
Transition result;
Transition *tzt = (Transition*... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r12
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0xf6315
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
xorl %esi, %esi
movsd %xmm0, (%rsp)
callq 0x1e3376
movsd (%rsp), %xmm0
movsd (%rax), %xmm1
testb %bpl, %bpl
... | /hunter-packages[P]icu/source/i18n/rbtz.cpp |
icu_63::RuleBasedTimeZone::getLocalDelta(int, int, int, int, int, int) const | int32_t
RuleBasedTimeZone::getLocalDelta(int32_t rawBefore, int32_t dstBefore, int32_t rawAfter, int32_t dstAfter,
int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const {
int32_t delta = 0;
int32_t offsetBefore = rawBefore + dstBefore;
int32_t offsetAfter = rawAfter + ds... | movl %esi, %eax
addl %edx, %eax
addl %r8d, %ecx
testl %r8d, %r8d
sete %dil
setne %r8b
testl %edx, %edx
setne %dl
sete %sil
andb %dil, %dl
andb %r8b, %sil
cmpl %eax, %ecx
jge 0xf64d5
movl 0x8(%rsp), %edi
movl %edi, %r8d
andl $0x3, %r8d
cmpl $0x1, %r8d
sete %r9b
testb %r9b, %dl
jne 0xf650c
cmpl $0x3, %r8d
sete %r9b
testb... | /hunter-packages[P]icu/source/i18n/rbtz.cpp |
icu_63::SimpleTimeZone::SimpleTimeZone(int, icu_63::UnicodeString const&, signed char, signed char, signed char, int, signed char, signed char, signed char, int, UErrorCode&) | SimpleTimeZone::SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID,
int8_t savingsStartMonth, int8_t savingsStartDay,
int8_t savingsStartDayOfWeek, int32_t savingsStartTime,
int8_t savingsEndMonth, int8_t savingsEndDay,
int8_t savingsEndDayOfWeek, int32_t savingsEndTime,
UErrorCode& status... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %esi, %r13d
movq %rdi, %rbx
movq 0x78(%rsp), %r14
movl 0x70(%rsp), %eax
movl %eax, 0x8(%rsp)
movb 0x68(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x60(%rsp), %bpl
movb 0x58(%... | /hunter-packages[P]icu/source/i18n/simpletz.cpp |
icu_63::SimpleTimeZone::SimpleTimeZone(int, icu_63::UnicodeString const&, signed char, signed char, signed char, int, icu_63::SimpleTimeZone::TimeMode, signed char, signed char, signed char, int, icu_63::SimpleTimeZone::TimeMode, int, UErrorCode&) | SimpleTimeZone::SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID,
int8_t savingsStartMonth, int8_t savingsStartDay,
int8_t savingsStartDayOfWeek, int32_t savingsStartTime,
TimeMode savingsStartTimeMode,
int8_t savingsEndMonth, int8_t savingsEndDay,
int8_t savingsEndDayOfWeek, int32_t sav... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movsbl 0x60(%rsp), %eax
movq %rax, 0x10(%rsp)
movsbl 0x68(%rsp), %eax
movq %rax, 0x8(%rsp)
movsbl 0x70(%rsp), %r13d
movq %rdx, %rsi
callq 0xe4842
leaq 0x1b... | /hunter-packages[P]icu/source/i18n/simpletz.cpp |
icu_63::SimpleTimeZone::setStartRule(int, int, int, int, icu_63::SimpleTimeZone::TimeMode, UErrorCode&) | void
SimpleTimeZone::setStartRule(int32_t month, int32_t dayOfWeekInMonth, int32_t dayOfWeek,
int32_t time, TimeMode mode, UErrorCode& status)
{
startMonth = (int8_t)month;
startDay = (int8_t)dayOfWeekInMonth;
startDayOfWeek = (int8_t)dayOfWeek;
startTime = ti... | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsp), %rax
movb %sil, 0x48(%rdi)
movb %dl, 0x49(%rdi)
movb %cl, 0x4a(%rdi)
movl %r8d, 0x4c(%rdi)
movl %r9d, 0x50(%rdi)
movq %rax, %rsi
callq 0xf6b32
movb $0x0, 0x78(%rbx)
popq %rbx
retq
nop
| /hunter-packages[P]icu/source/i18n/simpletz.cpp |
icu_63::SimpleTimeZone::getOffset(unsigned char, int, int, int, unsigned char, int, int, UErrorCode&) const | int32_t
SimpleTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
uint8_t dayOfWeek, int32_t millis,
int32_t /*monthLength*/, UErrorCode& status) const
{
// Check the month before calling Grego::monthLength(). This
// duplicates a test... | pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rsp), %r10
cmpl $0xc, %ecx
jb 0xf6e65
movl $0x1, (%r10)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
jmp 0xf6f15
movl 0x20(%rsp), %eax
testb $0x3, %dl
jne 0xf6eaf
imull $0xc28f5c29, %edx, %r11d # imm = 0xC28F5C29
addl $0x51eb850, %r11d # imm = 0x51EB8... | /hunter-packages[P]icu/source/i18n/simpletz.cpp |
icu_63::UnicodeString::compare(icu_63::UnicodeString const&) const | inline int8_t
UnicodeString::compare(const UnicodeString& text) const
{ return doCompare(0, length(), text, 0, text.length()); } | movq %rsi, %rcx
movzwl 0x8(%rdi), %eax
movzwl 0x8(%rsi), %esi
testb $0x1, %sil
jne 0x11a2ab
testw %si, %si
jns 0x11a2b0
movl 0xc(%rcx), %edx
jmp 0x11a2b6
notb %al
andb $0x1, %al
retq
movswl %si, %edx
sarl $0x5, %edx
xorl %r10d, %r10d
testl %edx, %edx
movl $0x0, %r8d
cmovsl %edx, %r8d
movl %edx, %r9d
subl %r8d, %r9d
cmp... | /hunter-packages[P]icu/source/common/unicode/unistr.h |
icu_63::NFFactory::create(icu_63::ICUServiceKey const&, icu_63::ICUService const*, UErrorCode&) const | virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const
{
if (handlesKey(key, status)) {
const LocaleKey& lkey = (const LocaleKey&)key;
Locale loc;
lkey.canonicalLocale(loc);
int32_t kind = lkey.kind();
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
movq %rcx, %rdx
callq *0x30(%rax)
testb %al, %al
je 0x11a3f4
movq %rsp, %r13
movq %r13, %rdi
callq 0x18c95a
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0... | /hunter-packages[P]icu/source/i18n/numfmt.cpp |
void icu_63::UnifiedCache::get<icu_63::SharedNumberFormat>(icu_63::CacheKey<icu_63::SharedNumberFormat> const&, void const*, icu_63::SharedNumberFormat const*&, UErrorCode&) const | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%r8)
jle 0x11a73f
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %rcx
leaq 0xc(%rsp), %r12
movl $0x0, (%r12)
leaq 0x10(%rsp), %r15
movq $0x0, (%r15)
movq %r15, %rdx
movq %r12, %r8
callq 0x1c0d50
movq (%r15), %r15
cmpl $0x0, (%r12)
jg 0x11a78c
movq... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::LocalizationInfo::indexForLocale(char16_t const*) const | int32_t
LocalizationInfo::indexForLocale(const UChar* locale) const {
for (int i = 0; i < getNumberOfDisplayLocales(); ++i) {
if (streq(locale, getLocaleName(i))) {
return i;
}
}
return -1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x28(%rax)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x11b636
xorl %ebp, %ebp
movq (%r15), %rax
movq %r15, %rdi
movl %ebp, %esi
callq *0x30(%rax)
cmpq %r14, %rax
je 0x11b634
testq %... | /hunter-packages[P]icu/source/i18n/rbnf.cpp |
icu_63::LocDataParser::doParse() | StringLocalizationInfo*
LocDataParser::doParse(void) {
skipWhitespace();
if (!checkInc(OPEN_ANGLE)) {
ERROR("Missing open angle");
} else {
VArray array(DeleteFn);
UBool mightHaveNext = TRUE;
int32_t requiredLength = -1;
while (mightHaveNext) {
mightHaveNe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
cmpq %rdx, %rcx
jae 0x11b770
movzwl 0x18(%rbx), %eax
cmpw $-0x1, %ax
jne 0x11b745
movzwl (%rcx), %eax
movzwl %ax, %edi
callq 0x19a23e
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
testb %al, %... | /hunter-packages[P]icu/source/i18n/rbnf.cpp |
icu_63::LocDataParser::nextString() | UChar*
LocDataParser::nextString() {
UChar* result = NULL;
skipWhitespace();
if (p < e) {
const UChar* terminators;
UChar c = *p;
UBool haveQuote = c == QUOTE || c == TICK;
if (haveQuote) {
inc();
terminators = c == QUOTE ? DQUOTE_STOPLIST : SQUOT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r14
cmpq %rcx, %r14
jae 0x11bd3e
movzwl 0x18(%rbx), %eax
cmpw $-0x1, %ax
jne 0x11bd13
movzwl (%r14), %eax
movzwl %ax, %edi
callq 0x19a23e
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %r14
testb %... | /hunter-packages[P]icu/source/i18n/rbnf.cpp |
icu_63::RuleBasedNumberFormat::RuleBasedNumberFormat(icu_63::UnicodeString const&, UParseError&, UErrorCode&) | RuleBasedNumberFormat::RuleBasedNumberFormat(const UnicodeString& description,
UParseError& perror,
UErrorCode& status)
: fRuleSets(NULL)
, ruleSetDescriptions(NULL)
, numRuleSets(0)
, defaultRuleSet(NULL)
, locale(Locale::getDefault())
, collator(NULL)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x118792
leaq 0x1949d1(%rip), %rax # 0x2b1520
movq %rax, (%rbx)
movq $0x0, 0x180(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x168(%rbx)
movl $0x0, 0x178(%rbx)
callq 0x18c88c
... | /hunter-packages[P]icu/source/i18n/rbnf.cpp |
icu_63::RuleBasedNumberFormat::RuleBasedNumberFormat(icu_63::RuleBasedNumberFormat const&) | RuleBasedNumberFormat::RuleBasedNumberFormat(const RuleBasedNumberFormat& rhs)
: NumberFormat(rhs)
, fRuleSets(NULL)
, ruleSetDescriptions(NULL)
, numRuleSets(0)
, defaultRuleSet(NULL)
, locale(rhs.locale)
, collator(NULL)
, decimalFormatSymbols(NULL)
, defaultInfinityRule(NULL)
, defaultNaNRule(NUL... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x11882c
leaq 0x1944ba(%rip), %rax # 0x2b1520
movq %rax, (%rbx)
movq $0x0, 0x180(%rbx)
movl $0x188, %esi # imm = 0x188
leaq (%rbx,%rsi), %r14
addq %r15, %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x168(%rbx)
movl $0x0,... | /hunter-packages[P]icu/source/i18n/rbnf.cpp |
icu_63::RuleBasedNumberFormat::getRuleSetDisplayName(int, icu_63::Locale const&) | UnicodeString
RuleBasedNumberFormat::getRuleSetDisplayName(int32_t index, const Locale& localeParam) {
if (localizations && index >= 0 && index < localizations->getNumberOfRuleSets()) {
UnicodeString localeName(localeParam.getBaseName(), -1, UnicodeString::kInvariant);
int32_t len = localeName.len... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r15
movq %rdi, %rbx
movq 0x298(%rsi), %rdi
testq %rdi, %rdi
sete %al
testl %edx, %edx
sets %cl
orb %al, %cl
jne 0x11d95a
movl %edx, %ebp
movq %rsi, %r14
movq (%rdi), %rax
callq *0x18(%rax)
cmpl %ebp, %eax
jle 0x11d95a
movq %r... | /hunter-packages[P]icu/source/i18n/rbnf.cpp |
icu_63::CollationLoader::loadFromLocale(UErrorCode&) | U_CAPI int32_t U_EXPORT2
ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
const char* keyword, const char* locale,
UBool* isAvailable, UErrorCode* status)
{
// N.B.: Resource name is "collations" but keyword is "collation"
return ures_g... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
cmpl $0x0, (%rsi)
jle 0x124c6a
xorl %ebx, %ebx
jmp 0x124d74
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf0(%rdi), %r15
movq %r15, %rdi
callq 0x18e3f0
leaq 0xd80eb(%rip), %rdi # 0x1fcd71
movq %rax, %rsi
movq %r14, %rdx
callq 0x1cf5d0
movq %rax, 0... | /hunter-packages[P]icu/source/i18n/ucol_res.cpp |
ucol_openAvailableLocales_63 | U_CAPI int32_t U_EXPORT2
ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
const char* keyword, const char* locale,
UBool* isAvailable, UErrorCode* status)
{
// N.B.: Resource name is "collations" but keyword is "collation"
return ures_g... | pushq %rbx
cmpl $0x0, (%rdi)
jle 0x12588a
xorl %eax, %eax
popq %rbx
retq
movq %rdi, %rbx
callq 0x12b614
testq %rax, %rax
je 0x1258a3
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1d6956
movl $0x7, (%rbx)
jmp 0x125886
| /hunter-packages[P]icu/source/i18n/ucol_res.cpp |
void icu_63::UnifiedCache::get<icu_63::CollationCacheEntry>(icu_63::CacheKey<icu_63::CollationCacheEntry> const&, void const*, icu_63::CollationCacheEntry const*&, UErrorCode&) const | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%r8)
jle 0x125d0d
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %rcx
leaq 0xc(%rsp), %r12
movl $0x0, (%r12)
leaq 0x10(%rsp), %r15
movq $0x0, (%r15)
movq %r15, %rdx
movq %r12, %r8
callq 0x1c0d50
movq (%r15), %r15
cmpl $0x0, (%r12)
jg 0x125d5a
movq... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
icu_63::FCDUIterCollationIterator::getOffset() const | int32_t
FCDUIterCollationIterator::getOffset() const {
if(state <= ITER_CHECK_BWD) {
return iter.getIndex(&iter, UITER_CURRENT);
} else if(state == ITER_IN_FCD_SEGMENT) {
return pos;
} else if(pos == 0) {
return start;
} else {
return limit;
}
} | movl 0x190(%rdi), %ecx
cmpl $0x1, %ecx
jg 0x126139
movq 0x188(%rdi), %rdi
movq 0x20(%rdi), %rax
movl $0x1, %esi
jmpq *%rax
movl 0x198(%rdi), %eax
cmpl $0x2, %ecx
je 0x12614e
testl %eax, %eax
je 0x12614f
movl 0x19c(%rdi), %eax
retq
movl 0x194(%rdi), %eax
retq
| /hunter-packages[P]icu/source/i18n/uitercollationiterator.cpp |
icu_63::FCDUIterCollationIterator::handleGetTrailSurrogate() | UChar
FCDUIterCollationIterator::handleGetTrailSurrogate() {
if(state <= ITER_IN_FCD_SEGMENT) {
UChar32 trail = iter.next(&iter);
if(U16_IS_TRAIL(trail)) {
if(state == ITER_IN_FCD_SEGMENT) { ++pos; }
} else if(trail >= 0) {
iter.previous(&iter);
}
retu... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, 0x190(%rdi)
jg 0x1265c0
movq 0x188(%rbx), %rdi
callq *0x48(%rdi)
movl %eax, %ebp
andl $0xfffffc00, %eax # imm = 0xFFFFFC00
cmpl $0xdc00, %eax # imm = 0xDC00
jne 0x1265db
cmpl $0x2, 0x190(%rbx)
jne 0x126629
incl 0x198(%rbx)
jmp 0x126629
movslq 0... | /hunter-packages[P]icu/source/i18n/uitercollationiterator.cpp |
icu_63::FCDUIterCollationIterator::switchToBackward() | void
FCDUIterCollationIterator::switchToBackward() {
U_ASSERT(state == ITER_CHECK_FWD ||
(state == ITER_IN_FCD_SEGMENT && pos == start) ||
(state >= IN_NORM_ITER_AT_LIMIT && pos == 0));
if(state == ITER_CHECK_FWD) {
// Turn around from forward checking.
limit = pos = it... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x190(%rdi), %eax
movl $0x1, %ebp
cmpl $0x3, %eax
je 0x126c78
cmpl $0x2, %eax
je 0x126c9f
testl %eax, %eax
jne 0x126c93
movq 0x188(%rbx), %rdi
movl $0x1, %esi
callq *0x20(%rdi)
movl %eax, 0x198(%rbx)
movl %eax, 0x19c(%rbx)
xorl %ebp, %ebp
cmpl 0x194(%rbx), %eax
setn... | /hunter-packages[P]icu/source/i18n/uitercollationiterator.cpp |
icu_63::FCDUTF16CollationIterator::FCDUTF16CollationIterator(icu_63::FCDUTF16CollationIterator const&, char16_t const*) | FCDUTF16CollationIterator::FCDUTF16CollationIterator(const FCDUTF16CollationIterator &other,
const UChar *newText)
: UTF16CollationIterator(other),
rawStart(newText),
segmentStart(newText + (other.segmentStart - other.rawStart)),
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x137f40
xorps %xmm0, %xmm0
movups %xmm0, 0x188(%rbx)
movq $0x0, 0x198(%rbx)
leaq 0x18ad87(%rip), %rax # 0x2b1ed0
movq %rax, (%rbx)
movq %r15, 0x1a0(%rbx)
movq 0x1a8(%r14), %rax
subq 0x1a0(%r14), %rax
addq %r15, %rax
movq %rax, 0x... | /hunter-packages[P]icu/source/i18n/utf16collationiterator.cpp |
icu_63::FCDUTF16CollationIterator::handleNextCE32(int&, UErrorCode&) | uint32_t
FCDUTF16CollationIterator::handleNextCE32(UChar32 &c, UErrorCode &errorCode) {
for(;;) {
if(checkDir > 0) {
if(pos == limit) {
c = U_SENTINEL;
return Collation::FALLBACK_CE32;
}
c = *pos++;
if(CollationFCD::hasTccc(c)) ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movb 0x208(%rdi), %al
testb %al, %al
jg 0x127494
leaq 0x190(%rbx), %r12
testb %al, %al
jne 0x127482
movq 0x190(%rbx), %rax
cmpq 0x198(%rbx), %rax
jne 0x127517
movq %rbx, %rdi
callq 0x1276a8
movb 0x208(%rbx), %al
testb... | /hunter-packages[P]icu/source/i18n/utf16collationiterator.cpp |
icu_63::FCDUTF16CollationIterator::previousSegment(UErrorCode&) | static
inline UBool U_FAILURE(UErrorCode code) { return (UBool)(code>U_ZERO_ERROR); } | cmpl $0x0, (%rsi)
jle 0x127a4e
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x190(%rdi), %r12
leaq 0x8(%rsp), %r15
movq %r12, (%r15)
movq 0x1a0(%rdi), %rsi
xorl %ebp, %ebp
movq 0x1c0(%rbx), %rdi
movq %r15, %rdx
callq 0x127d6a
movl %eax... | /hunter-packages[P]icu/source/common/unicode/utypes.h |
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.