name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
mbedtls_cipher_auth_encrypt | int mbedtls_cipher_auth_encrypt( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len,
const unsigned char *ad, size_t ad_len,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen,
unsigned char *tag, size_t tag_len )
{
#if defined(MBEDTLS_GCM_C)
if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
{
*olen = ilen;
return( mbedtls_gcm_crypt_and_tag( ctx->cipher_ctx, MBEDTLS_GCM_ENCRYPT, ilen,
iv, iv_len, ad, ad_len, input, output,
tag_len, tag ) );
}
#endif /* MBEDTLS_GCM_C */
#if defined(MBEDTLS_CCM_C)
if( MBEDTLS_MODE_CCM == ctx->cipher_info->mode )
{
*olen = ilen;
return( mbedtls_ccm_encrypt_and_tag( ctx->cipher_ctx, ilen,
iv, iv_len, ad, ad_len, input, output,
tag, tag_len ) );
}
#endif /* MBEDTLS_CCM_C */
return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rax
movq %r8, %r10
movq %rcx, %r9
movq %rdx, %r8
movq %rsi, %rcx
movq 0x50(%rsp), %rbx
movq 0x48(%rsp), %r14
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %r11
movq 0x30(%rsp), %rdx
movq (%rdi), %r15
movl 0x4(%r15), %ebp
cmpl $0x8, %ebp
je 0x7a4e
cmpl $0x6, %ebp
jne 0x7a75
movq %rdx, (%rsi)
movq 0x50(%rdi), %rdi
subq $0x8, %rsp
pushq $0x1
popq %rsi
pushq %r14
pushq %rbx
pushq %r11
pushq %rax
pushq %r10
callq 0x62ff
addq $0x38, %rsp
jmp 0x7a7e
movq %rdx, (%rsi)
movq 0x50(%rdi), %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
movq %r10, %r9
pushq %rbx
pushq %r14
pushq %r11
pushq %rax
callq 0xc30c
addq $0x28, %rsp
jmp 0x7a7e
movl $0xffff9f80, %eax # imm = 0xFFFF9F80
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/cipher.c |
mbedtls_cipher_auth_decrypt | int mbedtls_cipher_auth_decrypt( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len,
const unsigned char *ad, size_t ad_len,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen,
const unsigned char *tag, size_t tag_len )
{
#if defined(MBEDTLS_GCM_C)
if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
{
int ret;
*olen = ilen;
ret = mbedtls_gcm_auth_decrypt( ctx->cipher_ctx, ilen,
iv, iv_len, ad, ad_len,
tag, tag_len, input, output );
if( ret == MBEDTLS_ERR_GCM_AUTH_FAILED )
ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
return( ret );
}
#endif /* MBEDTLS_GCM_C */
#if defined(MBEDTLS_CCM_C)
if( MBEDTLS_MODE_CCM == ctx->cipher_info->mode )
{
int ret;
*olen = ilen;
ret = mbedtls_ccm_auth_decrypt( ctx->cipher_ctx, ilen,
iv, iv_len, ad, ad_len,
input, output, tag, tag_len );
if( ret == MBEDTLS_ERR_CCM_AUTH_FAILED )
ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
return( ret );
}
#endif /* MBEDTLS_CCM_C */
return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r10
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq 0x50(%rsp), %rbx
movq 0x48(%rsp), %r11
movq 0x40(%rsp), %r15
movq 0x38(%rsp), %r14
movq 0x30(%rsp), %rsi
movq (%rdi), %rax
movl 0x4(%rax), %ebp
cmpl $0x8, %ebp
je 0x7ae7
movl $0xffff9f80, %eax # imm = 0xFFFF9F80
cmpl $0x6, %ebp
jne 0x7b0b
movq %rsi, (%r15)
movq 0x50(%rdi), %rdi
pushq %r14
pushq %r10
pushq %rbx
pushq %r11
callq 0x637e
addq $0x20, %rsp
movl %eax, %ecx
cmpl $-0x12, %eax
jmp 0x7b03
movq %rsi, (%r15)
movq 0x50(%rdi), %rdi
pushq %rbx
pushq %r11
pushq %r14
pushq %r10
callq 0xc7cb
addq $0x20, %rsp
movl %eax, %ecx
cmpl $-0xf, %eax
movl $0xffff9d00, %eax # imm = 0xFFFF9D00
cmovnel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /project-everest[P]mbedtls/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
pushq $0x1
popq %rdi
movl $0x108, %esi # imm = 0x108
callq 0x40f0
movq %rax, %rbx
testq %rax, %rax
je 0x7c2b
movq %rbx, %rdi
callq 0xaafc
movq %rbx, %rax
popq %rbx
retq
| /project-everest[P]mbedtls/library/cipher_wrap.c |
des3_ctx_alloc | static void * des3_ctx_alloc( void )
{
mbedtls_des3_context *des3;
des3 = mbedtls_calloc( 1, sizeof( mbedtls_des3_context ) );
if( des3 == NULL )
return( NULL );
mbedtls_des3_init( des3 );
return( des3 );
} | pushq %rbx
pushq $0x1
popq %rdi
movl $0x180, %esi # imm = 0x180
callq 0x40f0
movq %rax, %rbx
testq %rax, %rax
je 0x7d84
movq %rbx, %rdi
callq 0x7de9
movq %rbx, %rax
popq %rbx
retq
| /project-everest[P]mbedtls/library/cipher_wrap.c |
mbedtls_des_setkey | void mbedtls_des_setkey( uint32_t SK[32], const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
uint32_t X, Y, T;
GET_UINT32_BE( X, key, 0 );
GET_UINT32_BE( Y, key, 4 );
/*
* Permuted Choice 1
*/
T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4);
T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T );
X = (LHs[ (X ) & 0xF] << 3) | (LHs[ (X >> 8) & 0xF ] << 2)
| (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ] )
| (LHs[ (X >> 5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6)
| (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4);
Y = (RHs[ (Y >> 1) & 0xF] << 3) | (RHs[ (Y >> 9) & 0xF ] << 2)
| (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ] )
| (RHs[ (Y >> 4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6)
| (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4);
X &= 0x0FFFFFFF;
Y &= 0x0FFFFFFF;
/*
* calculate subkeys
*/
for( i = 0; i < 16; i++ )
{
if( i < 2 || i == 8 || i == 15 )
{
X = ((X << 1) | (X >> 27)) & 0x0FFFFFFF;
Y = ((Y << 1) | (Y >> 27)) & 0x0FFFFFFF;
}
else
{
X = ((X << 2) | (X >> 26)) & 0x0FFFFFFF;
Y = ((Y << 2) | (Y >> 26)) & 0x0FFFFFFF;
}
*SK++ = ((X << 4) & 0x24000000) | ((X << 28) & 0x10000000)
| ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000)
| ((X << 6) & 0x01000000) | ((X << 9) & 0x00200000)
| ((X >> 1) & 0x00100000) | ((X << 10) & 0x00040000)
| ((X << 2) & 0x00020000) | ((X >> 10) & 0x00010000)
| ((Y >> 13) & 0x00002000) | ((Y >> 4) & 0x00001000)
| ((Y << 6) & 0x00000800) | ((Y >> 1) & 0x00000400)
| ((Y >> 14) & 0x00000200) | ((Y ) & 0x00000100)
| ((Y >> 5) & 0x00000020) | ((Y >> 10) & 0x00000010)
| ((Y >> 3) & 0x00000008) | ((Y >> 18) & 0x00000004)
| ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001);
*SK++ = ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000)
| ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000)
| ((X >> 2) & 0x02000000) | ((X << 1) & 0x01000000)
| ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000)
| ((X << 3) & 0x00080000) | ((X >> 6) & 0x00040000)
| ((X << 15) & 0x00020000) | ((X >> 4) & 0x00010000)
| ((Y >> 2) & 0x00002000) | ((Y << 8) & 0x00001000)
| ((Y >> 14) & 0x00000808) | ((Y >> 9) & 0x00000400)
| ((Y ) & 0x00000200) | ((Y << 7) & 0x00000100)
| ((Y >> 7) & 0x00000020) | ((Y >> 3) & 0x00000011)
| ((Y << 2) & 0x00000004) | ((Y >> 21) & 0x00000002);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, -0x8(%rsp)
movzbl (%rsi), %ecx
movl %ecx, %eax
shll $0x18, %eax
movzbl 0x1(%rsi), %edx
shll $0x10, %edx
orl %eax, %edx
movzbl 0x2(%rsi), %eax
shll $0x8, %eax
movzbl 0x3(%rsi), %r8d
orl %edx, %r8d
orl %eax, %r8d
movl 0x4(%rsi), %edx
bswapl %edx
movl %edx, %eax
shrl $0x4, %eax
xorl %r8d, %eax
andl $0xf0f0f0f, %eax # imm = 0xF0F0F0F
movl %eax, %esi
xorl %r8d, %esi
shll $0x4, %eax
xorl %edx, %eax
andl $0x10101010, %r8d # imm = 0x10101010
andl $0xefefefef, %eax # imm = 0xEFEFEFEF
orl %r8d, %eax
movl %esi, %edx
andl $0xf, %edx
leaq 0x69cf(%rip), %r8 # 0xe8b0
movl (%r8,%rdx,4), %edx
shll $0x3, %edx
movl %esi, %r9d
shrl $0x6, %r9d
andl $0x3c, %r9d
movl (%r9,%r8), %r9d
shll $0x2, %r9d
orl %edx, %r9d
movl %esi, %edx
shrl $0xe, %edx
andl $0x3c, %edx
movl (%rdx,%r8), %edx
addl %edx, %edx
orl %r9d, %edx
movl %esi, %r9d
shrl $0x16, %r9d
andl $0x3c, %r9d
orl (%r9,%r8), %edx
movl %esi, %r9d
shrl $0x3, %r9d
andl $0x3c, %r9d
movl (%r9,%r8), %r9d
shll $0x7, %r9d
movl %esi, %r10d
shrl $0xb, %r10d
andl $0x3c, %r10d
movl (%r10,%r8), %r10d
shll $0x6, %r10d
orl %r9d, %r10d
shrl $0x13, %esi
andl $0x3c, %esi
movl (%rsi,%r8), %esi
shll $0x5, %esi
orl %r10d, %esi
shrl $0x5, %ecx
movl (%r8,%rcx,4), %r10d
shll $0x4, %r10d
orl %esi, %r10d
movl %eax, %esi
andl $0x1e, %esi
leaq 0x697f(%rip), %rcx # 0xe8f0
movl (%rcx,%rsi,2), %esi
shll $0x3, %esi
movl %eax, %r8d
shrl $0x7, %r8d
andl $0x3c, %r8d
movl (%r8,%rcx), %r8d
shll $0x2, %r8d
orl %esi, %r8d
movl %eax, %esi
shrl $0xf, %esi
andl $0x3c, %esi
movl (%rsi,%rcx), %esi
addl %esi, %esi
orl %r8d, %esi
movl %eax, %r8d
shrl $0x17, %r8d
andl $0x3c, %r8d
orl (%r8,%rcx), %esi
orl %edx, %r10d
movl %eax, %edx
shrl $0x2, %edx
andl $0x3c, %edx
movl (%rdx,%rcx), %edx
shll $0x7, %edx
movl %eax, %r8d
shrl $0xa, %r8d
andl $0x3c, %r8d
movl (%r8,%rcx), %r8d
shll $0x6, %r8d
orl %edx, %r8d
movl %eax, %edx
shrl $0x12, %edx
andl $0x3c, %edx
movl (%rdx,%rcx), %edx
shll $0x5, %edx
orl %r8d, %edx
shrl $0x1c, %eax
movl (%rcx,%rax,4), %r9d
shll $0x4, %r9d
orl %edx, %r9d
orl %esi, %r9d
movl $0xfffffff, %eax # imm = 0xFFFFFFF
andl %eax, %r10d
andl %eax, %r9d
xorl %r8d, %r8d
cmpl $0x10, %r8d
ja 0x82c3
movl $0xffffffe, %ebx # imm = 0xFFFFFFE
movl $0x8103, %eax # imm = 0x8103
btl %r8d, %eax
movl $0x1, %eax
movl $0x1b, %edx
jae 0x82bd
movl %r10d, %r15d
movl %eax, %ecx
shll %cl, %r15d
movl %edx, %ecx
shrl %cl, %r10d
movl %r15d, %r12d
andl %ebx, %r12d
movl %r12d, %r13d
orl %r10d, %r13d
movl %r9d, %r11d
movl %eax, %ecx
shll %cl, %r11d
movl %edx, %ecx
shrl %cl, %r9d
andl %r11d, %ebx
movl %ebx, %eax
orl %r9d, %eax
movl %r12d, %ecx
shll $0x4, %ecx
andl $0x24000000, %ecx # imm = 0x24000000
andl $0x1, %r10d
shll $0x1c, %r10d
orl %ecx, %r10d
movl %r15d, %ecx
shll $0xe, %ecx
movl $0x8000000, %edx # imm = 0x8000000
andl %edx, %ecx
orl %r10d, %ecx
movl %r13d, %edx
movl %r13d, %esi
shll $0x12, %esi
andl $0x2080000, %esi # imm = 0x2080000
orl %ecx, %esi
movl %r15d, %ecx
shll $0x6, %ecx
andl $0x1000000, %ecx # imm = 0x1000000
orl %esi, %ecx
movl %r15d, %esi
shll $0x9, %esi
andl $0x200000, %esi # imm = 0x200000
orl %ecx, %esi
movl %r15d, %r10d
shrl %r10d
movl $0x100000, %ecx # imm = 0x100000
andl %ecx, %r10d
orl %esi, %r10d
shll $0xa, %edx
movl %edx, %ecx
movl $0x40000, %esi # imm = 0x40000
andl %esi, %ecx
leal (,%r12,4), %esi
movl $0x20000, %edi # imm = 0x20000
andl %edi, %esi
orl %ecx, %esi
movl %r15d, %ecx
shrl $0xa, %ecx
movl $0x10000, %edi # imm = 0x10000
andl %edi, %ecx
orl %esi, %ecx
movl %eax, %esi
andl $0x20, %esi
shll $0x6, %esi
movl %r11d, %ebp
shrl %ebp
movl $0x400, %edi # imm = 0x400
andl %edi, %ebp
orl %esi, %ebp
shrl $0xe, %ebx
movl %ebx, %r14d
movl $0x200, %esi # imm = 0x200
andl %esi, %r14d
orl %ebp, %r14d
movl %r11d, %esi
andl $0x100, %esi # imm = 0x100
orl %ecx, %esi
movl %r11d, %ecx
shrl $0xd, %ecx
movl $0x2000, %edi # imm = 0x2000
andl %edi, %ecx
orl %ecx, %esi
movl %r11d, %ecx
shrl $0x4, %ecx
andl $0x1000, %ecx # imm = 0x1000
orl %ecx, %esi
movl %eax, %ecx
orl %r10d, %esi
movl %r11d, %r10d
shrl $0x5, %r10d
andl $0x20, %r10d
orl %r14d, %r10d
movl %r11d, %ebp
shrl $0xa, %ebp
andl $0x10, %ebp
orl %r10d, %ebp
shrl $0x3, %ecx
movl %ecx, %r10d
andl $0x8, %r10d
orl %ebp, %r10d
movl %r11d, %ebp
shrl $0x12, %ebp
andl $0x4, %ebp
orl %r10d, %ebp
orl %esi, %ebp
movl %r11d, %esi
shrl $0x1a, %esi
andl $0x2, %esi
movl %r11d, %r14d
shrl $0x18, %r14d
andl $0x1, %r14d
orl %esi, %r14d
movl %r13d, %r10d
orl %ebp, %r14d
movq -0x8(%rsp), %rdi
movl %r14d, (%rdi,%r8,8)
shll $0xf, %r10d
movl %r10d, %esi
andl $0x20000000, %esi # imm = 0x20000000
movl %r15d, %ebp
shll $0x11, %ebp
andl $0x10000000, %ebp # imm = 0x10000000
orl %esi, %ebp
movl $0x8000000, %esi # imm = 0x8000000
andl %esi, %edx
orl %ebp, %edx
movl %r13d, %esi
andl $0x10, %esi
shll $0x16, %esi
orl %edx, %esi
movl %r15d, %edx
shrl $0x2, %edx
andl $0x2000000, %edx # imm = 0x2000000
orl %esi, %edx
movl %r12d, %esi
andl $0x800000, %esi # imm = 0x800000
leal (%rdx,%rsi,2), %esi
movl %r13d, %edx
andl $0x20, %edx
shll $0x10, %edx
orl %esi, %edx
movl %r15d, %esi
shll $0xb, %esi
movl $0x100000, %ebp # imm = 0x100000
andl %ebp, %esi
shll $0x3, %r12d
andl $0x80000, %r12d # imm = 0x80000
orl %esi, %r12d
movl %r15d, %esi
shrl $0x6, %esi
movl $0x40000, %ebp # imm = 0x40000
andl %ebp, %esi
orl %r12d, %esi
movl $0x20000, %ebp # imm = 0x20000
andl %ebp, %r10d
orl %esi, %r10d
shrl $0x4, %r15d
movl $0x10000, %esi # imm = 0x10000
andl %esi, %r15d
orl %r10d, %r15d
andl $0x808, %ebx # imm = 0x808
movl %r11d, %r10d
shrl $0x9, %r10d
movl $0x400, %esi # imm = 0x400
andl %esi, %r10d
orl %ebx, %r10d
movl %r11d, %esi
movl $0x200, %ebx # imm = 0x200
andl %ebx, %esi
orl %r15d, %esi
movl %r11d, %ebx
shrl $0x2, %ebx
movl $0x2000, %ebp # imm = 0x2000
andl %ebp, %ebx
orl %ebx, %esi
movl %eax, %ebx
andl $0x10, %ebx
shll $0x8, %ebx
orl %ebx, %esi
orl %edx, %esi
movl %eax, %edx
andl $0x2, %edx
shll $0x7, %edx
orl %r10d, %edx
movl %r11d, %r10d
shrl $0x7, %r10d
andl $0x20, %r10d
orl %edx, %r10d
andl $0x11, %ecx
orl %r10d, %ecx
shll $0x2, %r9d
andl $0x4, %r9d
orl %ecx, %r9d
shrl $0x15, %r11d
andl $0x2, %r11d
orl %r9d, %r11d
orl %esi, %r11d
movl %r11d, 0x4(%rdi,%r8,8)
movl %r13d, %r10d
movl %eax, %r9d
incq %r8
jmp 0x8003
cmpl $0x10, %r8d
je 0x82d7
movl $0xffffffc, %ebx # imm = 0xFFFFFFC
movl $0x2, %eax
movl $0x1a, %edx
jmp 0x802b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/des.c |
mbedtls_des_setkey_dec | int mbedtls_des_setkey_dec( mbedtls_des_context *ctx, const unsigned char key[MBEDTLS_DES_KEY_SIZE] )
{
int i;
mbedtls_des_setkey( ctx->sk, key );
for( i = 0; i < 16; i += 2 )
{
SWAP( ctx->sk[i ], ctx->sk[30 - i] );
SWAP( ctx->sk[i + 1], ctx->sk[31 - i] );
}
return( 0 );
} | pushq %rbx
movq %rdi, %rbx
callq 0x7e78
leaq 0x7c(%rbx), %rax
xorl %ecx, %ecx
cmpq $0xf, %rcx
ja 0x8323
movl (%rbx,%rcx,4), %edx
movl -0x4(%rax), %esi
movl %esi, (%rbx,%rcx,4)
movl %edx, -0x4(%rax)
movl 0x4(%rbx,%rcx,4), %edx
movl (%rax), %esi
movl %esi, 0x4(%rbx,%rcx,4)
movl %edx, (%rax)
addq $0x2, %rcx
addq $-0x8, %rax
jmp 0x82fb
xorl %eax, %eax
popq %rbx
retq
| /project-everest[P]mbedtls/library/des.c |
des3_set2key | static void des3_set2key( uint32_t esk[96],
uint32_t dsk[96],
const unsigned char key[MBEDTLS_DES_KEY_SIZE*2] )
{
int i;
mbedtls_des_setkey( esk, key );
mbedtls_des_setkey( dsk + 32, key + 8 );
for( i = 0; i < 32; i += 2 )
{
dsk[i ] = esk[30 - i];
dsk[i + 1] = esk[31 - i];
esk[i + 32] = dsk[62 - i];
esk[i + 33] = dsk[63 - i];
esk[i + 64] = esk[i ];
esk[i + 65] = esk[i + 1];
dsk[i + 64] = dsk[i ];
dsk[i + 65] = dsk[i + 1];
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x7e78
leaq 0x80(%rbx), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0x7e78
pushq $0x40
popq %rax
pushq $0x1f
popq %rcx
leaq -0x40(%rax), %rdx
cmpq $0x1f, %rdx
ja 0x83dc
movl -0x4(%r14,%rcx,4), %edx
movl %edx, -0x100(%rbx,%rax,4)
movl (%r14,%rcx,4), %edx
movl %edx, -0xfc(%rbx,%rax,4)
movl 0x7c(%rbx,%rcx,4), %edx
movl %edx, -0x80(%r14,%rax,4)
movl 0x80(%rbx,%rcx,4), %edx
movl %edx, -0x7c(%r14,%rax,4)
movq -0x100(%r14,%rax,4), %rdx
movq %rdx, (%r14,%rax,4)
movq -0x100(%rbx,%rax,4), %rdx
movq %rdx, (%rbx,%rax,4)
addq $0x2, %rax
addq $-0x2, %rcx
jmp 0x8384
popq %rbx
popq %r14
popq %r15
retq
| /project-everest[P]mbedtls/library/des.c |
des3_set3key | static void des3_set3key( uint32_t esk[96],
uint32_t dsk[96],
const unsigned char key[24] )
{
int i;
mbedtls_des_setkey( esk, key );
mbedtls_des_setkey( dsk + 32, key + 8 );
mbedtls_des_setkey( esk + 64, key + 16 );
for( i = 0; i < 32; i += 2 )
{
dsk[i ] = esk[94 - i];
dsk[i + 1] = esk[95 - i];
esk[i + 32] = dsk[62 - i];
esk[i + 33] = dsk[63 - i];
dsk[i + 64] = esk[30 - i];
dsk[i + 65] = esk[31 - i];
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x7e78
leaq 0x80(%rbx), %rdi
leaq 0x8(%r15), %rsi
callq 0x7e78
leaq 0x100(%r14), %rdi
addq $0x10, %r15
movq %r15, %rsi
callq 0x7e78
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x1f, %rcx
ja 0x84db
movl 0x178(%r14,%rax), %edx
movl %edx, (%rbx,%rcx,4)
movl 0x17c(%r14,%rax), %edx
movl %edx, 0x4(%rbx,%rcx,4)
movl 0xf8(%rbx,%rax), %edx
movl %edx, 0x80(%r14,%rcx,4)
movl 0xfc(%rbx,%rax), %edx
movl %edx, 0x84(%r14,%rcx,4)
movl 0x78(%r14,%rax), %edx
movl %edx, 0x100(%rbx,%rcx,4)
movl 0x7c(%r14,%rax), %edx
movl %edx, 0x104(%rbx,%rcx,4)
addq $0x2, %rcx
addq $-0x8, %rax
jmp 0x847e
popq %rbx
popq %r14
popq %r15
retq
| /project-everest[P]mbedtls/library/des.c |
mbedtls_aes_setkey_dec | int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int i, j, ret;
mbedtls_aes_context cty;
uint32_t *RK;
uint32_t *SK;
mbedtls_aes_init( &cty );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
if( aes_padlock_ace == -1 )
aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
if( aes_padlock_ace )
ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
else
#endif
ctx->rk = RK = ctx->buf;
/* Also checks keybits */
if( ( ret = mbedtls_aes_setkey_enc( &cty, key, keybits ) ) != 0 )
goto exit;
ctx->nr = cty.nr;
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
{
mbedtls_aesni_inverse_key( (unsigned char *) ctx->rk,
(const unsigned char *) cty.rk, ctx->nr );
goto exit;
}
#endif
SK = cty.rk + cty.nr * 4;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
{
for( j = 0; j < 4; j++, SK++ )
{
*RK++ = AES_RT0( FSb[ ( *SK ) & 0xFF ] ) ^
AES_RT1( FSb[ ( *SK >> 8 ) & 0xFF ] ) ^
AES_RT2( FSb[ ( *SK >> 16 ) & 0xFF ] ) ^
AES_RT3( FSb[ ( *SK >> 24 ) & 0xFF ] );
}
}
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
exit:
mbedtls_aes_free( &cty );
return( ret );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movl $0x120, %edx # imm = 0x120
movq %r12, %rdi
xorl %esi, %esi
callq 0x40c0
leaq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x91b7
movl %eax, %ebx
testl %eax, %eax
jne 0x98d8
movl 0x8(%rsp), %eax
movl %eax, (%r14)
movl $0x2000000, %edi # imm = 0x2000000
callq 0x6b2c
testl %eax, %eax
je 0x97f0
movq 0x8(%r14), %rdi
movq 0x10(%rsp), %rsi
movl (%r14), %edx
callq 0x6d1f
jmp 0x98d8
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movl 0x10(%rax), %ecx
movl %ecx, 0x10(%r14)
movl 0x14(%rax), %ecx
movl %ecx, 0x14(%r14)
movl 0x18(%rax), %ecx
movl %ecx, 0x18(%r14)
movl 0x1c(%rax), %edx
leaq 0x20(%r14), %rcx
movl %edx, 0x1c(%r14)
movl (%r14), %edx
leaq 0xca11(%rip), %rsi # 0x16240
leaq 0xcb0a(%rip), %rdi # 0x16340
movl $0xff, %r8d
leaq 0xcefd(%rip), %r9 # 0x16740
leaq 0xd2f6(%rip), %r10 # 0x16b40
leaq 0xd6ef(%rip), %r11 # 0x16f40
cmpl $0x2, %edx
jl 0x98c2
decl %edx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpl $0x4, %r15d
je 0x98b6
movl (%rax,%r15,4), %r12d
movzbl %r12b, %r13d
movzbl (%r13,%rsi), %r13d
movl %r12d, %ebp
shrl $0x8, %ebp
andl %r8d, %ebp
movzbl (%rbp,%rsi), %ebp
movl (%r9,%rbp,4), %ebp
xorl (%rdi,%r13,4), %ebp
movl %r12d, %r13d
shrl $0x10, %r13d
andl %r8d, %r13d
movzbl (%r13,%rsi), %r13d
xorl (%r10,%r13,4), %ebp
shrl $0x18, %r12d
movzbl (%r12,%rsi), %r12d
xorl (%r11,%r12,4), %ebp
movl %ebp, (%rcx,%r15,4)
incq %r15
addq $-0x4, %r14
jmp 0x985e
subq %r14, %rcx
subq %r14, %rax
addq $-0x20, %rax
jmp 0x9851
movl (%rax), %edx
movl %edx, (%rcx)
movl 0x4(%rax), %edx
movl %edx, 0x4(%rcx)
movl 0x8(%rax), %edx
movl %edx, 0x8(%rcx)
movl 0xc(%rax), %eax
movl %eax, 0xc(%rcx)
leaq 0x8(%rsp), %rdi
callq 0x9198
movl %ebx, %eax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_internal_aes_encrypt | int mbedtls_internal_aes_encrypt( 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, input, 4 ); X1 ^= *RK++;
GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
{
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
}
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
X0 = *RK++ ^ \
( (uint32_t) FSb[ ( Y0 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
X1 = *RK++ ^ \
( (uint32_t) FSb[ ( Y1 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
X2 = *RK++ ^ \
( (uint32_t) FSb[ ( Y2 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
X3 = *RK++ ^ \
( (uint32_t) FSb[ ( Y3 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
PUT_UINT32_LE( X0, output, 0 );
PUT_UINT32_LE( X1, output, 4 );
PUT_UINT32_LE( X2, output, 8 );
PUT_UINT32_LE( X3, output, 12 );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
movl (%rax), %r8d
movl 0x4(%rax), %r9d
xorl (%rsi), %r8d
xorl 0x4(%rsi), %r9d
movq %rdx, -0x8(%rsp)
movl 0x8(%rax), %r11d
xorl 0x8(%rsi), %r11d
movl 0xc(%rax), %edx
xorl 0xc(%rsi), %edx
movl (%rdi), %ecx
sarl %ecx
addq $0x2c, %rax
movl $0xff, %ebp
leaq 0xda07(%rip), %r10 # 0x17340
movl $0x3fc, %r14d # imm = 0x3FC
leaq 0xddfa(%rip), %rbx # 0x17740
leaq 0xe1f3(%rip), %rdi # 0x17b40
leaq 0xe5ec(%rip), %rsi # 0x17f40
cmpl $0x2, %ecx
jl 0x9adc
movl %ecx, -0x14(%rsp)
movl %r8d, %ecx
andl %ebp, %ecx
movl (%r10,%rcx,4), %r12d
xorl -0x1c(%rax), %r12d
movl %r9d, %ecx
shrl $0x8, %ecx
andl %ebp, %ecx
xorl (%rbx,%rcx,4), %r12d
movl %r11d, %ecx
shrl $0xe, %ecx
andl %r14d, %ecx
xorl (%rcx,%rdi), %r12d
movl %edx, %ecx
shrl $0x18, %ecx
xorl (%rsi,%rcx,4), %r12d
movl %r9d, %ecx
andl %ebp, %ecx
movl (%r10,%rcx,4), %r13d
xorl -0x18(%rax), %r13d
movl %r11d, %ecx
shrl $0x8, %ecx
andl %ebp, %ecx
xorl (%rbx,%rcx,4), %r13d
movl %edx, %ecx
shrl $0xe, %ecx
andl %r14d, %ecx
xorl (%rcx,%rdi), %r13d
movl %r8d, %ecx
shrl $0x18, %ecx
xorl (%rsi,%rcx,4), %r13d
movl %r11d, %ecx
andl %ebp, %ecx
movl (%r10,%rcx,4), %ecx
xorl -0x14(%rax), %ecx
movl %edx, %r15d
shrl $0x8, %r15d
andl %ebp, %r15d
xorl (%rbx,%r15,4), %ecx
movl %r8d, %r15d
shrl $0xe, %r15d
andl %r14d, %r15d
xorl (%r15,%rdi), %ecx
movl %r9d, %r15d
shrl $0x18, %r15d
xorl (%rsi,%r15,4), %ecx
andl %ebp, %edx
movl (%r10,%rdx,4), %r15d
xorl -0x10(%rax), %r15d
shrl $0x8, %r8d
andl %ebp, %r8d
xorl (%rbx,%r8,4), %r15d
shrl $0xe, %r9d
andl %r14d, %r9d
xorl (%r9,%rdi), %r15d
shrl $0x18, %r11d
xorl (%rsi,%r11,4), %r15d
movl %r12d, %edx
andl %ebp, %edx
movl (%r10,%rdx,4), %r8d
xorl -0xc(%rax), %r8d
movl %r13d, %edx
shrl $0x8, %edx
andl %ebp, %edx
xorl (%rbx,%rdx,4), %r8d
movl %ecx, %edx
shrl $0xe, %edx
andl %r14d, %edx
xorl (%rdx,%rdi), %r8d
movl %r15d, %edx
shrl $0x18, %edx
xorl (%rsi,%rdx,4), %r8d
movl %r13d, %edx
andl %ebp, %edx
movl (%r10,%rdx,4), %r9d
xorl -0x8(%rax), %r9d
movl %ecx, %edx
shrl $0x8, %edx
andl %ebp, %edx
xorl (%rbx,%rdx,4), %r9d
movl %r15d, %edx
shrl $0xe, %edx
andl %r14d, %edx
xorl (%rdx,%rdi), %r9d
movl %r12d, %edx
shrl $0x18, %edx
xorl (%rsi,%rdx,4), %r9d
movl %ecx, %edx
andl %ebp, %edx
movl (%r10,%rdx,4), %r11d
xorl -0x4(%rax), %r11d
movl %r15d, %edx
shrl $0x8, %edx
andl %ebp, %edx
xorl (%rbx,%rdx,4), %r11d
movl %r12d, %edx
shrl $0xe, %edx
andl %r14d, %edx
xorl (%rdx,%rdi), %r11d
movl %r13d, %edx
shrl $0x18, %edx
xorl (%rsi,%rdx,4), %r11d
andl %ebp, %r15d
movl (%r10,%r15,4), %edx
xorl (%rax), %edx
shrl $0x8, %r12d
andl %ebp, %r12d
xorl (%rbx,%r12,4), %edx
shrl $0xe, %r13d
andl %r14d, %r13d
xorl (%r13,%rdi), %edx
shrl $0x18, %ecx
xorl (%rsi,%rcx,4), %edx
movl -0x14(%rsp), %ecx
decl %ecx
addq $0x20, %rax
jmp 0x9954
movl $0xff, %esi
movl %r8d, %ecx
andl %esi, %ecx
movl (%r10,%rcx,4), %ebp
xorl -0x1c(%rax), %ebp
movl %r9d, %ecx
shrl $0x8, %ecx
andl %esi, %ecx
leaq 0xdc44(%rip), %rbx # 0x17740
xorl (%rbx,%rcx,4), %ebp
movl %r11d, %r14d
shrl $0xe, %r14d
movl $0x3fc, %ecx # imm = 0x3FC
andl %ecx, %r14d
leaq 0xe02b(%rip), %rdi # 0x17b40
xorl (%r14,%rdi), %ebp
movl %edx, %r14d
shrl $0x18, %r14d
leaq 0xe419(%rip), %rsi # 0x17f40
xorl (%rsi,%r14,4), %ebp
movl %r9d, %r14d
movl $0xff, %r13d
andl %r13d, %r14d
movl (%r10,%r14,4), %r12d
xorl -0x18(%rax), %r12d
movl %r11d, %r15d
shrl $0x8, %r15d
andl %r13d, %r15d
movl $0xff, %r14d
xorl (%rbx,%r15,4), %r12d
movl %edx, %r15d
shrl $0xe, %r15d
andl %ecx, %r15d
xorl (%r15,%rdi), %r12d
movl %r8d, %r15d
shrl $0x18, %r15d
xorl (%rsi,%r15,4), %r12d
movl %r11d, %r15d
andl %r14d, %r15d
movl (%r10,%r15,4), %r13d
xorl -0x14(%rax), %r13d
movl %edx, %r15d
shrl $0x8, %r15d
andl %r14d, %r15d
xorl (%rbx,%r15,4), %r13d
movq %rbx, %r14
movl %r8d, %r15d
shrl $0xe, %r15d
andl %ecx, %r15d
xorl (%r15,%rdi), %r13d
movl %r9d, %r15d
shrl $0x18, %r15d
xorl (%rsi,%r15,4), %r13d
movl $0xff, %ebx
andl %ebx, %edx
movl (%r10,%rdx,4), %r10d
xorl -0x10(%rax), %r10d
shrl $0x8, %r8d
andl %ebx, %r8d
xorl (%r14,%r8,4), %r10d
shrl $0xe, %r9d
andl %ecx, %r9d
xorl (%r9,%rdi), %r10d
shrl $0x18, %r11d
xorl (%rsi,%r11,4), %r10d
movl %ebp, %ecx
andl %ebx, %ecx
leaq 0xc664(%rip), %r8 # 0x16240
movzbl (%rcx,%r8), %edi
xorl -0xc(%rax), %edi
movl %r12d, %ecx
shrl $0x8, %ecx
andl %ebx, %ecx
movzbl (%rcx,%r8), %ecx
shll $0x8, %ecx
movl %r13d, %edx
shrl $0x10, %edx
andl %ebx, %edx
movzbl (%rdx,%r8), %edx
shll $0x10, %edx
orl %ecx, %edx
movl %r10d, %ecx
shrl $0x18, %ecx
movzbl (%rcx,%r8), %ecx
shll $0x18, %ecx
movl %r12d, %esi
andl %ebx, %esi
movzbl (%rsi,%r8), %esi
xorl -0x8(%rax), %esi
movl %esi, -0x14(%rsp)
orl %edx, %ecx
movl %r13d, %r11d
shrl $0x8, %r11d
andl %ebx, %r11d
movl %r10d, %r15d
shrl $0x10, %r15d
andl %ebx, %r15d
movl %r13d, %edx
andl %ebx, %edx
movzbl (%rdx,%r8), %edx
xorl -0x4(%rax), %edx
movl %edx, -0xc(%rsp)
movl %r10d, %edx
shrl $0x8, %edx
andl %ebx, %edx
andl %ebx, %r10d
movzbl (%r10,%r8), %esi
xorl (%rax), %esi
movl %esi, -0x10(%rsp)
movq %rbp, %r9
movl %ebp, %r10d
shrl $0x10, %r10d
andl %ebx, %r10d
movl %ebp, %eax
shrl $0x8, %r9d
andl %ebx, %r9d
movl %r12d, %r14d
shrl $0x10, %r12d
andl %ebx, %r12d
xorl %edi, %ecx
movzbl (%r11,%r8), %esi
movzbl (%r15,%r8), %r11d
shrl $0x18, %eax
movzbl (%rax,%r8), %eax
movzbl (%rdx,%r8), %r15d
movzbl (%r10,%r8), %ebp
shrl $0x18, %r14d
movzbl (%r14,%r8), %ebx
movzbl (%r9,%r8), %r10d
movzbl (%r12,%r8), %r14d
shrl $0x18, %r13d
movzbl (%r13,%r8), %r8d
movq -0x8(%rsp), %rdx
movb %dil, (%rdx)
movb %ch, 0x1(%rdx)
movl %ecx, %edi
shrl $0x10, %edi
movb %dil, 0x2(%rdx)
shrl $0x18, %ecx
movb %cl, 0x3(%rdx)
shll $0x8, %esi
shll $0x10, %r11d
orl %esi, %r11d
shll $0x18, %eax
orl %r11d, %eax
movl -0x14(%rsp), %ecx
xorl %ecx, %eax
movb %cl, 0x4(%rdx)
movb %ah, 0x5(%rdx)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x6(%rdx)
shrl $0x18, %eax
movb %al, 0x7(%rdx)
shll $0x8, %r15d
shll $0x10, %ebp
orl %r15d, %ebp
shll $0x18, %ebx
orl %ebp, %ebx
movl -0xc(%rsp), %eax
xorl %eax, %ebx
movb %al, 0x8(%rdx)
movb %bh, 0x9(%rdx)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0xa(%rdx)
shrl $0x18, %ebx
movb %bl, 0xb(%rdx)
shll $0x8, %r10d
shll $0x10, %r14d
orl %r10d, %r14d
movl %r8d, %ecx
shll $0x18, %ecx
orl %r14d, %ecx
movl -0x10(%rsp), %eax
xorl %eax, %ecx
movb %al, 0xc(%rdx)
movb %ch, 0xd(%rdx)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0xe(%rdx)
shrl $0x18, %ecx
movb %cl, 0xf(%rdx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_internal_aes_decrypt | int mbedtls_internal_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, input, 4 ); X1 ^= *RK++;
GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
{
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
}
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
X0 = *RK++ ^ \
( (uint32_t) RSb[ ( Y0 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
X1 = *RK++ ^ \
( (uint32_t) RSb[ ( Y1 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
X2 = *RK++ ^ \
( (uint32_t) RSb[ ( Y2 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
X3 = *RK++ ^ \
( (uint32_t) RSb[ ( Y3 ) & 0xFF ] ) ^
( (uint32_t) RSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
PUT_UINT32_LE( X0, output, 0 );
PUT_UINT32_LE( X1, output, 4 );
PUT_UINT32_LE( X2, output, 8 );
PUT_UINT32_LE( X3, output, 12 );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
movl (%rax), %ecx
movl 0x4(%rax), %r8d
xorl (%rsi), %ecx
xorl 0x4(%rsi), %r8d
movq %rdx, -0x8(%rsp)
movl 0x8(%rax), %r11d
xorl 0x8(%rsi), %r11d
movl 0xc(%rax), %r15d
xorl 0xc(%rsi), %r15d
movl (%rdi), %edx
sarl %edx
addq $0x2c, %rax
movl $0xff, %ebp
leaq 0xc593(%rip), %r10 # 0x16340
movl $0x3fc, %r14d # imm = 0x3FC
leaq 0xc986(%rip), %rbx # 0x16740
leaq 0xd17f(%rip), %rdi # 0x16f40
cmpl $0x2, %edx
jl 0x9f61
movl %ecx, %esi
andl %ebp, %esi
movl (%r10,%rsi,4), %r12d
xorl -0x1c(%rax), %r12d
movl %r15d, %esi
shrl $0x8, %esi
andl %ebp, %esi
xorl (%rbx,%rsi,4), %r12d
movl %r11d, %esi
shrl $0xe, %esi
andl %r14d, %esi
movl %edx, -0x18(%rsp)
leaq 0xcd4a(%rip), %rdx # 0x16b40
xorl (%rsi,%rdx), %r12d
movl %r8d, %esi
shrl $0x18, %esi
xorl (%rdi,%rsi,4), %r12d
movl %r8d, %esi
andl %ebp, %esi
movl (%r10,%rsi,4), %r13d
xorl -0x18(%rax), %r13d
movl %ecx, %esi
shrl $0x8, %esi
andl %ebp, %esi
xorl (%rbx,%rsi,4), %r13d
movl %r15d, %esi
shrl $0xe, %esi
andl %r14d, %esi
xorl (%rsi,%rdx), %r13d
movl %r11d, %esi
shrl $0x18, %esi
xorl (%rdi,%rsi,4), %r13d
movl %r11d, %esi
andl %ebp, %esi
movl (%r10,%rsi,4), %esi
xorl -0x14(%rax), %esi
movl %r8d, %r9d
shrl $0x8, %r9d
andl %ebp, %r9d
xorl (%rbx,%r9,4), %esi
movl %ecx, %r9d
shrl $0xe, %r9d
andl %r14d, %r9d
xorl (%r9,%rdx), %esi
movl %r15d, %r9d
shrl $0x18, %r9d
xorl (%rdi,%r9,4), %esi
andl %ebp, %r15d
movl (%r10,%r15,4), %r15d
xorl -0x10(%rax), %r15d
shrl $0x8, %r11d
andl %ebp, %r11d
xorl (%rbx,%r11,4), %r15d
shrl $0xe, %r8d
andl %r14d, %r8d
xorl (%r8,%rdx), %r15d
shrl $0x18, %ecx
xorl (%rdi,%rcx,4), %r15d
movl %r12d, %ecx
andl %ebp, %ecx
movl (%r10,%rcx,4), %ecx
xorl -0xc(%rax), %ecx
movl %r15d, %r8d
shrl $0x8, %r8d
andl %ebp, %r8d
xorl (%rbx,%r8,4), %ecx
movl %esi, %r8d
shrl $0xe, %r8d
andl %r14d, %r8d
xorl (%r8,%rdx), %ecx
movl %r13d, %r8d
shrl $0x18, %r8d
xorl (%rdi,%r8,4), %ecx
movl %r13d, %r8d
andl %ebp, %r8d
movl (%r10,%r8,4), %r8d
xorl -0x8(%rax), %r8d
movl %r12d, %r9d
shrl $0x8, %r9d
andl %ebp, %r9d
xorl (%rbx,%r9,4), %r8d
movl %r15d, %r9d
shrl $0xe, %r9d
andl %r14d, %r9d
xorl (%r9,%rdx), %r8d
movl %esi, %r9d
shrl $0x18, %r9d
xorl (%rdi,%r9,4), %r8d
movl %esi, %r9d
andl %ebp, %r9d
movl (%r10,%r9,4), %r11d
xorl -0x4(%rax), %r11d
movl %r13d, %r9d
shrl $0x8, %r9d
andl %ebp, %r9d
xorl (%rbx,%r9,4), %r11d
movl %r12d, %r9d
shrl $0xe, %r9d
andl %r14d, %r9d
xorl (%r9,%rdx), %r11d
movl %r15d, %r9d
shrl $0x18, %r9d
xorl (%rdi,%r9,4), %r11d
andl %ebp, %r15d
movl (%r10,%r15,4), %r15d
xorl (%rax), %r15d
shrl $0x8, %esi
andl %ebp, %esi
xorl (%rbx,%rsi,4), %r15d
shrl $0xe, %r13d
andl %r14d, %r13d
xorl (%r13,%rdx), %r15d
movl -0x18(%rsp), %edx
shrl $0x18, %r12d
xorl (%rdi,%r12,4), %r15d
decl %edx
addq $0x20, %rax
jmp 0x9dc1
movl $0xff, %ebp
movl %ecx, %esi
andl %ebp, %esi
movl (%r10,%rsi,4), %ebx
xorl -0x1c(%rax), %ebx
movl %r15d, %esi
shrl $0x8, %esi
andl %ebp, %esi
leaq 0xc7c0(%rip), %r14 # 0x16740
xorl (%r14,%rsi,4), %ebx
movl %r11d, %r9d
shrl $0xe, %r9d
movl $0x3fc, %esi # imm = 0x3FC
andl %esi, %r9d
leaq 0xcba6(%rip), %rdx # 0x16b40
xorl (%r9,%rdx), %ebx
movl %r8d, %r9d
shrl $0x18, %r9d
leaq 0xcf94(%rip), %rdi # 0x16f40
xorl (%rdi,%r9,4), %ebx
movq %rbx, %r13
movl %r8d, %r9d
andl %ebp, %r9d
movl (%r10,%r9,4), %ebx
xorl -0x18(%rax), %ebx
movl %ecx, %r9d
shrl $0x8, %r9d
andl %ebp, %r9d
xorl (%r14,%r9,4), %ebx
movl %r15d, %r9d
shrl $0xe, %r9d
andl %esi, %r9d
xorl (%r9,%rdx), %ebx
movl %r11d, %r9d
shrl $0x18, %r9d
xorl (%rdi,%r9,4), %ebx
movl %r11d, %r9d
andl %ebp, %r9d
movl (%r10,%r9,4), %r12d
xorl -0x14(%rax), %r12d
movl %r8d, %r9d
shrl $0x8, %r9d
andl %ebp, %r9d
xorl (%r14,%r9,4), %r12d
movl %ecx, %r9d
shrl $0xe, %r9d
andl %esi, %r9d
xorl (%r9,%rdx), %r12d
movl %r15d, %r9d
shrl $0x18, %r9d
xorl (%rdi,%r9,4), %r12d
andl %ebp, %r15d
movl (%r10,%r15,4), %r10d
xorl -0x10(%rax), %r10d
shrl $0x8, %r11d
andl %ebp, %r11d
xorl (%r14,%r11,4), %r10d
shrl $0xe, %r8d
andl %esi, %r8d
xorl (%r8,%rdx), %r10d
shrl $0x18, %ecx
xorl (%rdi,%rcx,4), %r10d
movl %r13d, %ecx
andl %ebp, %ecx
leaq 0xe2f0(%rip), %r8 # 0x18340
movzbl (%rcx,%r8), %edi
xorl -0xc(%rax), %edi
movl %r10d, %ecx
shrl $0x8, %ecx
andl %ebp, %ecx
movzbl (%rcx,%r8), %ecx
shll $0x8, %ecx
movl %r12d, %edx
shrl $0x10, %edx
andl %ebp, %edx
movzbl (%rdx,%r8), %edx
shll $0x10, %edx
orl %ecx, %edx
movl %ebx, %ecx
shrl $0x18, %ecx
movzbl (%rcx,%r8), %ecx
shll $0x18, %ecx
movl %ebx, %esi
andl %ebp, %esi
movzbl (%rsi,%r8), %esi
xorl -0x8(%rax), %esi
movl %esi, -0x18(%rsp)
orl %edx, %ecx
movl %r13d, %r11d
movq %r13, -0x10(%rsp)
shrl $0x8, %r11d
andl %ebp, %r11d
movl %r10d, %r15d
shrl $0x10, %r15d
movl %r12d, %edx
andl %ebp, %edx
movzbl (%rdx,%r8), %edx
xorl -0x4(%rax), %edx
movl %edx, -0x14(%rsp)
movl %r10d, %edx
andl %ebp, %r10d
movzbl (%r10,%r8), %r9d
xorl (%rax), %r9d
andl %ebp, %r15d
movl %ebx, %r14d
shrl $0x8, %r14d
andl %ebp, %r14d
shrl $0x10, %r13d
andl %ebp, %r13d
movl %r12d, %eax
shrl $0x8, %r12d
andl %ebp, %r12d
shrl $0x10, %ebx
andl %ebp, %ebx
xorl %edi, %ecx
movzbl (%r11,%r8), %esi
movzbl (%r15,%r8), %r10d
shrl $0x18, %eax
movzbl (%rax,%r8), %eax
movzbl (%r14,%r8), %r15d
movzbl (%r13,%r8), %r14d
shrl $0x18, %edx
movzbl (%rdx,%r8), %edx
movzbl (%r12,%r8), %r12d
movzbl (%rbx,%r8), %r11d
movq -0x10(%rsp), %rbx
shrl $0x18, %ebx
movzbl (%rbx,%r8), %ebx
movq -0x8(%rsp), %rbp
movb %dil, (%rbp)
movb %ch, 0x1(%rbp)
movl %ecx, %edi
shrl $0x10, %edi
movb %dil, 0x2(%rbp)
shrl $0x18, %ecx
movb %cl, 0x3(%rbp)
shll $0x8, %esi
shll $0x10, %r10d
orl %esi, %r10d
shll $0x18, %eax
orl %r10d, %eax
movl -0x18(%rsp), %ecx
xorl %ecx, %eax
movb %cl, 0x4(%rbp)
movb %ah, 0x5(%rbp)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x6(%rbp)
shrl $0x18, %eax
movb %al, 0x7(%rbp)
shll $0x8, %r15d
shll $0x10, %r14d
orl %r15d, %r14d
shll $0x18, %edx
orl %r14d, %edx
movl -0x14(%rsp), %eax
xorl %eax, %edx
movb %al, 0x8(%rbp)
movb %dh, 0x9(%rbp)
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0xa(%rbp)
shrl $0x18, %edx
movb %dl, 0xb(%rbp)
shll $0x8, %r12d
shll $0x10, %r11d
orl %r12d, %r11d
shll $0x18, %ebx
orl %r11d, %ebx
xorl %r9d, %ebx
movb %r9b, 0xc(%rbp)
movb %bh, 0xd(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0xe(%rbp)
shrl $0x18, %ebx
movb %bl, 0xf(%rbp)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_crypt_ecb | int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
return( mbedtls_aesni_crypt_ecb( ctx, mode, input, output ) );
#endif
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
if( aes_padlock_ace )
{
if( mbedtls_padlock_xcryptecb( ctx, mode, input, output ) == 0 )
return( 0 );
// If padlock data misaligned, we just fall back to
// unaccelerated mode
//
}
#endif
if( mode == MBEDTLS_AES_ENCRYPT )
return( mbedtls_internal_aes_encrypt( ctx, input, output ) );
else
return( mbedtls_internal_aes_decrypt( ctx, input, output ) );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x2000000, %edi # imm = 0x2000000
callq 0x6b2c
movq %r15, %rdi
testl %eax, %eax
je 0xa214
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6b5b
movq %r14, %rsi
movq %rbx, %rdx
cmpl $0x1, %ebp
jne 0xa226
callq 0x98f6
jmp 0xa22b
callq 0x9d6a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_aes_crypt_cfb8 | int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
unsigned char c;
unsigned char ov[17];
while( length-- )
{
memcpy( ov, iv, 16 );
mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
if( mode == MBEDTLS_AES_DECRYPT )
ov[16] = *input;
c = *output++ = (unsigned char)( iv[0] ^ *input++ );
if( mode == MBEDTLS_AES_ENCRYPT )
ov[16] = c;
memcpy( iv, ov + 1, 16 );
}
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
xorl %r14d, %r14d
cmpq %r14, %r12
je 0xa44b
movups (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r13, %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %r15, %rcx
callq 0xa1da
testl %ebp, %ebp
movq (%rsp), %rax
movzbl (%rax,%r14), %eax
movzbl %bl, %ecx
cmovel %eax, %ecx
movb (%r15), %dl
xorb %al, %dl
cmpl $0x1, %ebp
movq 0x8(%rsp), %rax
movb %dl, (%rax,%r14)
movzbl %dl, %ebx
cmovnel %ecx, %ebx
leaq 0x11(%rsp), %rcx
movq (%rcx), %rax
movq 0x7(%rcx), %rcx
movq %rcx, 0x7(%r15)
movq %rax, (%r15)
movb %bl, 0xf(%r15)
incq %r14
jmp 0xa3e8
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/aes.c |
mbedtls_arc4_self_test | int mbedtls_arc4_self_test( int verbose )
{
int i, ret = 0;
unsigned char ibuf[8];
unsigned char obuf[8];
mbedtls_arc4_context ctx;
mbedtls_arc4_init( &ctx );
for( i = 0; i < 3; i++ )
{
if( verbose != 0 )
mbedtls_printf( " ARC4 test #%d: ", i + 1 );
memcpy( ibuf, arc4_test_pt[i], 8 );
mbedtls_arc4_setup( &ctx, arc4_test_key[i], 8 );
mbedtls_arc4_crypt( &ctx, 8, ibuf, obuf );
if( memcmp( obuf, arc4_test_ct[i], 8 ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
exit:
mbedtls_arc4_free( &ctx );
return( ret );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %edi, %ebx
leaq 0x10(%rsp), %r14
movl $0x108, %edx # imm = 0x108
movq %r14, %rdi
xorl %esi, %esi
callq 0x40c0
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r15
leaq 0x4a89(%rip), %r12 # 0xf690
xorl %r13d, %r13d
cmpq $0x18, %r13
je 0xac7f
testl %ebx, %ebx
je 0xac24
leaq 0x4a15(%rip), %rdi # 0xf630
movl %ebp, %esi
xorl %eax, %eax
callq 0x4090
leaq 0x4a25(%rip), %rax # 0xf650
movq (%r13,%rax), %rax
movq %rax, (%rsp)
leaq 0x4a35(%rip), %rax # 0xf670
leaq (%rax,%r13), %rsi
movq %r14, %rdi
pushq $0x8
popq %rdx
callq 0xab27
movq %r14, %rdi
pushq $0x8
popq %rsi
movq %rsp, %rdx
movq %r15, %rcx
callq 0xab81
movq 0x8(%rsp), %rax
cmpq (%r13,%r12), %rax
jne 0xac8f
testl %ebx, %ebx
je 0xac77
leaq 0x2bcd(%rip), %rdi # 0xd83f
callq 0x4060
incl %ebp
addq $0x8, %r13
jmp 0xac0a
xorl %ebp, %ebp
testl %ebx, %ebx
je 0xaca2
pushq $0xa
popq %rdi
callq 0x4040
jmp 0xaca2
pushq $0x1
popq %rbp
testl %ebx, %ebx
je 0xaca2
leaq 0x6510(%rip), %rdi # 0x111ad
callq 0x4060
leaq 0x10(%rsp), %rdi
callq 0xab08
movl %ebp, %eax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/arc4.c |
blowfish_enc | static void blowfish_enc( mbedtls_blowfish_context *ctx, uint32_t *xl, uint32_t *xr )
{
uint32_t Xl, Xr, temp;
short i;
Xl = *xl;
Xr = *xr;
for( i = 0; i < MBEDTLS_BLOWFISH_ROUNDS; ++i )
{
Xl = Xl ^ ctx->P[i];
Xr = F( ctx, Xl ) ^ Xr;
temp = Xl;
Xl = Xr;
Xr = temp;
}
temp = Xl;
Xl = Xr;
Xr = temp;
Xr = Xr ^ ctx->P[MBEDTLS_BLOWFISH_ROUNDS];
Xl = Xl ^ ctx->P[MBEDTLS_BLOWFISH_ROUNDS + 1];
*xl = Xl;
*xr = Xr;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
movl (%rdx), %r12d
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0xae7a
movl %eax, %ebp
xorl (%r15,%r13,4), %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0xb150
xorl %r12d, %eax
incq %r13
movl %ebp, %r12d
jmp 0xae59
xorl 0x40(%r15), %eax
xorl 0x44(%r15), %r12d
movl %r12d, (%r14)
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/blowfish.c |
mbedtls_camellia_setkey_dec | int mbedtls_camellia_setkey_dec( mbedtls_camellia_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int idx, ret;
size_t i;
mbedtls_camellia_context cty;
uint32_t *RK;
uint32_t *SK;
mbedtls_camellia_init( &cty );
/* Also checks keybits */
if( ( ret = mbedtls_camellia_setkey_enc( &cty, key, keybits ) ) != 0 )
goto exit;
ctx->nr = cty.nr;
idx = ( ctx->nr == 4 );
RK = ctx->rk;
SK = cty.rk + 24 * 2 + 8 * idx * 2;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
for( i = 22 + 8 * idx, SK -= 6; i > 0; i--, SK -= 4 )
{
*RK++ = *SK++;
*RK++ = *SK++;
}
SK -= 2;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
exit:
mbedtls_camellia_free( &cty );
return( ret );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movl $0x114, %edx # imm = 0x114
movq %r15, %rdi
xorl %esi, %esi
callq 0x40c0
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xb1b7
movl %eax, %ebp
testl %eax, %eax
jne 0xb954
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
xorl %ecx, %ecx
cmpl $0x4, %eax
sete %cl
leal 0x16(,%rcx,8), %eax
shll $0x6, %ecx
movups 0xc8(%rsp,%rcx), %xmm0
movups %xmm0, 0x4(%rbx)
addq $0x14, %rbx
subq $0x1, %rax
jb 0xb94c
movq 0x18(%rsp,%rax,8), %rcx
movq %rcx, (%rbx)
addq $0x8, %rbx
jmp 0xb938
movups 0x10(%rsp,%rax,8), %xmm0
movups %xmm0, (%rbx)
leaq 0x4(%rsp), %rdi
callq 0xb198
movl %ebp, %eax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/camellia.c |
mbedtls_camellia_crypt_ecb | int mbedtls_camellia_crypt_ecb( mbedtls_camellia_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
int NR;
uint32_t *RK, X[4];
( (void) mode );
NR = ctx->nr;
RK = ctx->rk;
GET_UINT32_BE( X[0], input, 0 );
GET_UINT32_BE( X[1], input, 4 );
GET_UINT32_BE( X[2], input, 8 );
GET_UINT32_BE( X[3], input, 12 );
X[0] ^= *RK++;
X[1] ^= *RK++;
X[2] ^= *RK++;
X[3] ^= *RK++;
while( NR ) {
--NR;
camellia_feistel( X, RK, X + 2 );
RK += 2;
camellia_feistel( X + 2, RK, X );
RK += 2;
camellia_feistel( X, RK, X + 2 );
RK += 2;
camellia_feistel( X + 2, RK, X );
RK += 2;
camellia_feistel( X, RK, X + 2 );
RK += 2;
camellia_feistel( X + 2, RK, X );
RK += 2;
if( NR ) {
FL(X[0], X[1], RK[0], RK[1]);
RK += 2;
FLInv(X[2], X[3], RK[0], RK[1]);
RK += 2;
}
}
X[2] ^= *RK++;
X[3] ^= *RK++;
X[0] ^= *RK++;
X[1] ^= *RK++;
PUT_UINT32_BE( X[2], output, 0 );
PUT_UINT32_BE( X[3], output, 4 );
PUT_UINT32_BE( X[0], output, 8 );
PUT_UINT32_BE( X[1], output, 12 );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movl (%rdi), %r13d
movl (%rdx), %eax
movl 0x4(%rdx), %ecx
bswapl %eax
bswapl %ecx
movl 0x8(%rdx), %esi
leaq 0x8(%rsp), %r15
xorl 0x4(%rdi), %eax
movl 0xc(%rdx), %edx
movl %eax, -0x8(%r15)
xorl 0x8(%rdi), %ecx
bswapl %esi
movl %ecx, -0x4(%r15)
xorl 0xc(%rdi), %esi
bswapl %edx
movl %esi, (%r15)
xorl 0x10(%rdi), %edx
addq $0x14, %r14
movl %edx, 0x4(%r15)
movq %rsp, %r12
movl %r13d, %ebp
subl $0x1, %ebp
jb 0xba76
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb7fc
leaq 0x8(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xb7fc
leaq 0x10(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0xb7fc
leaq 0x18(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xb7fc
leaq 0x20(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0xb7fc
leaq 0x28(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xb7fc
cmpl $0x1, %r13d
jne 0xba30
addq $0x30, %r14
jmp 0xba6e
movl (%rsp), %eax
movl 0x30(%r14), %ecx
andl %eax, %ecx
roll %ecx
xorl 0x4(%rsp), %ecx
movl 0xc(%rsp), %edx
movl %ecx, 0x4(%rsp)
orl 0x34(%r14), %ecx
xorl %eax, %ecx
movl %ecx, (%rsp)
movl 0x3c(%r14), %eax
orl %edx, %eax
xorl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
andl 0x38(%r14), %eax
roll %eax
xorl %edx, %eax
movl %eax, 0xc(%rsp)
addq $0x40, %r14
movl %ebp, %r13d
jmp 0xb9c2
movq 0x8(%rsp), %rdx
xorq (%r14), %rdx
movq %rdx, 0x8(%rsp)
movl (%rsp), %ecx
movl 0x4(%rsp), %eax
xorl 0x8(%r14), %ecx
xorl 0xc(%r14), %eax
movq %rdx, %xmm0
movl %edx, %esi
shrl $0x18, %esi
movb %sil, (%rbx)
movl %edx, %esi
shrl $0x10, %esi
movb %sil, 0x1(%rbx)
movb %dh, 0x2(%rbx)
movb %dl, 0x3(%rbx)
pshufd $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movd %xmm0, %edx
movl %edx, %esi
shrl $0x18, %esi
movb %sil, 0x4(%rbx)
movl %edx, %esi
shrl $0x10, %esi
movb %sil, 0x5(%rbx)
movb %dh, 0x6(%rbx)
movb %dl, 0x7(%rbx)
movl %ecx, %edx
shrl $0x18, %edx
movb %dl, 0x8(%rbx)
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, 0x9(%rbx)
movb %ch, 0xa(%rbx)
movb %cl, 0xb(%rbx)
movl %eax, %ecx
shrl $0x18, %ecx
movb %cl, 0xc(%rbx)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0xd(%rbx)
movb %ah, 0xe(%rbx)
movb %al, 0xf(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /project-everest[P]mbedtls/library/camellia.c |
mbedtls_camellia_self_test | int mbedtls_camellia_self_test( int verbose )
{
int i, j, u, v;
unsigned char key[32];
unsigned char buf[64];
unsigned char src[16];
unsigned char dst[16];
#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char iv[16];
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
size_t offset, len;
unsigned char nonce_counter[16];
unsigned char stream_block[16];
#endif
mbedtls_camellia_context ctx;
memset( key, 0, 32 );
for( j = 0; j < 6; j++ ) {
u = j >> 1;
v = j & 1;
if( verbose != 0 )
mbedtls_printf( " CAMELLIA-ECB-%3d (%s): ", 128 + u * 64,
(v == MBEDTLS_CAMELLIA_DECRYPT) ? "dec" : "enc");
for( i = 0; i < CAMELLIA_TESTS_ECB; i++ ) {
memcpy( key, camellia_test_ecb_key[u][i], 16 + 8 * u );
if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
mbedtls_camellia_setkey_dec( &ctx, key, 128 + u * 64 );
memcpy( src, camellia_test_ecb_cipher[u][i], 16 );
memcpy( dst, camellia_test_ecb_plain[i], 16 );
} else { /* MBEDTLS_CAMELLIA_ENCRYPT */
mbedtls_camellia_setkey_enc( &ctx, key, 128 + u * 64 );
memcpy( src, camellia_test_ecb_plain[i], 16 );
memcpy( dst, camellia_test_ecb_cipher[u][i], 16 );
}
mbedtls_camellia_crypt_ecb( &ctx, v, src, buf );
if( memcmp( buf, dst, 16 ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* CBC mode
*/
for( j = 0; j < 6; j++ )
{
u = j >> 1;
v = j & 1;
if( verbose != 0 )
mbedtls_printf( " CAMELLIA-CBC-%3d (%s): ", 128 + u * 64,
( v == MBEDTLS_CAMELLIA_DECRYPT ) ? "dec" : "enc" );
memcpy( src, camellia_test_cbc_iv, 16 );
memcpy( dst, camellia_test_cbc_iv, 16 );
memcpy( key, camellia_test_cbc_key[u], 16 + 8 * u );
if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
mbedtls_camellia_setkey_dec( &ctx, key, 128 + u * 64 );
} else {
mbedtls_camellia_setkey_enc( &ctx, key, 128 + u * 64 );
}
for( i = 0; i < CAMELLIA_TESTS_CBC; i++ ) {
if( v == MBEDTLS_CAMELLIA_DECRYPT ) {
memcpy( iv , src, 16 );
memcpy( src, camellia_test_cbc_cipher[u][i], 16 );
memcpy( dst, camellia_test_cbc_plain[i], 16 );
} else { /* MBEDTLS_CAMELLIA_ENCRYPT */
memcpy( iv , dst, 16 );
memcpy( src, camellia_test_cbc_plain[i], 16 );
memcpy( dst, camellia_test_cbc_cipher[u][i], 16 );
}
mbedtls_camellia_crypt_cbc( &ctx, v, 16, iv, src, buf );
if( memcmp( buf, dst, 16 ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
if( verbose != 0 )
mbedtls_printf( "\n" );
#if defined(MBEDTLS_CIPHER_MODE_CTR)
/*
* CTR mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
v = i & 1;
if( verbose != 0 )
mbedtls_printf( " CAMELLIA-CTR-128 (%s): ",
( v == MBEDTLS_CAMELLIA_DECRYPT ) ? "dec" : "enc" );
memcpy( nonce_counter, camellia_test_ctr_nonce_counter[u], 16 );
memcpy( key, camellia_test_ctr_key[u], 16 );
offset = 0;
mbedtls_camellia_setkey_enc( &ctx, key, 128 );
if( v == MBEDTLS_CAMELLIA_DECRYPT )
{
len = camellia_test_ctr_len[u];
memcpy( buf, camellia_test_ctr_ct[u], len );
mbedtls_camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
buf, buf );
if( memcmp( buf, camellia_test_ctr_pt[u], len ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
}
else
{
len = camellia_test_ctr_len[u];
memcpy( buf, camellia_test_ctr_pt[u], len );
mbedtls_camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block,
buf, buf );
if( memcmp( buf, camellia_test_ctr_ct[u], len ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#endif /* MBEDTLS_CIPHER_MODE_CTR */
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movl %edi, %ebp
pxor %xmm0, %xmm0
leaq 0x80(%rsp), %rax
movdqa %xmm0, (%rax)
movdqa %xmm0, 0x10(%rax)
leaq 0x504f(%rip), %r14 # 0x10d90
leaq 0x4ab8(%rip), %r15 # 0x10800
xorl %r12d, %r12d
movl %edi, 0xc(%rsp)
cmpl $0x6, %r12d
je 0xbee8
movl %r12d, %ebx
shrl %ebx
movl %ebx, %r13d
shll $0x6, %r13d
subl $-0x80, %r13d
testl %ebp, %ebp
je 0xbd94
testb $0x1, %r12b
leaq 0x1aa0(%rip), %rdx # 0xd818
leaq 0x1a9d(%rip), %rax # 0xd81c
cmoveq %rax, %rdx
leaq 0x5286(%rip), %rdi # 0x11010
movl %r13d, %esi
xorl %eax, %eax
callq 0x4090
movl %r13d, 0x1c(%rsp)
movq %r12, 0x10(%rsp)
shrq %r12
movq %r12, %r13
shlq $0x6, %r13
addq %r14, %r13
shlq $0x5, %r12
addq %r15, %r12
movq %r12, 0x50(%rsp)
movl %ebx, %eax
leal 0x10(,%rbx,8), %ecx
movq %rcx, 0x58(%rsp)
shlq $0x5, %rax
addq %r15, %rax
movq %rax, 0x48(%rsp)
xorl %r14d, %r14d
xorl %r12d, %r12d
leaq 0x10(%r14), %rbp
cmpq $0x30, %rbp
je 0xbeb9
leaq (,%r14,2), %rsi
addq %r13, %rsi
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq 0x58(%rsp), %rdx
callq 0x4140
testb $0x1, 0x10(%rsp)
jne 0xbe3e
leaq 0xf4(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movl 0x1c(%rsp), %edx
callq 0xb8d4
movq 0x50(%rsp), %rax
movaps (%rax,%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x51b7(%rip), %rax # 0x10ff0
addq %rax, %r14
jmp 0xbe72
leaq 0xf4(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movl 0x1c(%rsp), %edx
callq 0xb1b7
leaq 0x5194(%rip), %rax # 0x10ff0
movaps (%r14,%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movq %r12, %r14
shlq $0x4, %r14
addq 0x48(%rsp), %r14
incq %r12
movaps (%r14), %xmm0
movaps %xmm0, 0x30(%rsp)
movq %rbx, %rdi
leaq 0x20(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
callq 0xb96e
movdqa 0xb0(%rsp), %xmm0
pcmpeqb 0x30(%rsp), %xmm0
pmovmskb %xmm0, %eax
movq %rbp, %r14
cmpl $0xffff, %eax # imm = 0xFFFF
je 0xbdd7
jmp 0xc09a
movl 0xc(%rsp), %ebp
testl %ebp, %ebp
je 0xbecd
leaq 0x1977(%rip), %rdi # 0xd83f
callq 0x4060
movq 0x10(%rsp), %r12
incq %r12
leaq 0x4eb4(%rip), %r14 # 0x10d90
leaq 0x491d(%rip), %r15 # 0x10800
jmp 0xbd4f
testl %ebp, %ebp
je 0xbef4
pushq $0xa
popq %rdi
callq 0x4040
leaq 0x4f55(%rip), %r13 # 0x10e50
leaq 0xf4(%rsp), %r12
xorl %eax, %eax
cmpl $0x6, %eax
je 0xc0c4
movl %eax, %ebx
shrl %ebx
movq %rax, 0x10(%rsp)
movl %eax, %r14d
andl $0x1, %r14d
testl %ebp, %ebp
je 0xbf4d
movl %ebx, %esi
shll $0x6, %esi
subl $-0x80, %esi
testl %r14d, %r14d
leaq 0x18e4(%rip), %rdx # 0xd818
leaq 0x18e1(%rip), %rax # 0xd81c
cmoveq %rax, %rdx
leaq 0x50e4(%rip), %rdi # 0x1102a
xorl %eax, %eax
callq 0x4090
movdqa 0x32bb(%rip), %xmm0 # 0xf210
movdqa %xmm0, 0x20(%rsp)
movdqa %xmm0, 0x30(%rsp)
movl %ebx, %r15d
movq %r15, %rsi
shlq $0x5, %rsi
addq %r13, %rsi
leal 0x10(,%rbx,8), %edx
leaq 0x80(%rsp), %r13
movq %r13, %rdi
callq 0x4140
shll $0x6, %ebx
subl $-0x80, %ebx
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %edx
testl %r14d, %r14d
jne 0xbf9f
callq 0xb8d4
jmp 0xbfa4
callq 0xb1b7
movq 0x10(%rsp), %rax
shrq %rax
imulq $0x30, %rax, %rbx
leaq 0x48a9(%rip), %rax # 0x10860
addq %rax, %rbx
imulq $0x30, %r15, %rbp
xorl %eax, %eax
xorl %r13d, %r13d
leaq 0x10(%rax), %r15
cmpq $0x40, %r15
je 0xc072
testl %r14d, %r14d
jne 0xbff5
movaps 0x20(%rsp), %xmm0
movaps %xmm0, 0x70(%rsp)
movaps (%rbx,%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x4900(%rip), %rcx # 0x108f0
addq %rcx, %rax
jmp 0xc023
movaps 0x30(%rsp), %xmm0
movaps %xmm0, 0x70(%rsp)
leaq 0x48ea(%rip), %rcx # 0x108f0
movaps (%rax,%rcx), %xmm0
movaps %xmm0, 0x20(%rsp)
movq %r13, %rax
shlq $0x4, %rax
leaq 0x4843(%rip), %rcx # 0x10860
addq %rcx, %rax
addq %rbp, %rax
incq %r13
movaps (%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movq %r12, %rdi
movl %r14d, %esi
pushq $0x10
popq %rdx
leaq 0x70(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0xb0(%rsp), %r9
callq 0xbb0c
movdqa 0xb0(%rsp), %xmm0
pcmpeqb 0x30(%rsp), %xmm0
pmovmskb %xmm0, %ecx
movq %r15, %rax
cmpl $0xffff, %ecx # imm = 0xFFFF
je 0xbfc3
jmp 0xc09a
movl 0xc(%rsp), %ebp
testl %ebp, %ebp
je 0xc086
leaq 0x17be(%rip), %rdi # 0xd83f
callq 0x4060
movq 0x10(%rsp), %rax
incq %rax
leaq 0x4dbb(%rip), %r13 # 0x10e50
jmp 0xbf05
pushq $0x1
popq %rbx
cmpl $0x0, 0xc(%rsp)
je 0xc0b0
leaq 0x5102(%rip), %rdi # 0x111ad
callq 0x4060
movl %ebx, %eax
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %r14d
testl %ebp, %ebp
je 0xc0d3
pushq $0xa
popq %rdi
callq 0x4040
leaq 0xf4(%rsp), %r15
xorl %r13d, %r13d
cmpl $0x6, %r13d
je 0xc237
testl %r14d, %r14d
je 0xc111
testb $0x1, %r13b
leaq 0x1720(%rip), %rsi # 0xd818
leaq 0x171d(%rip), %rax # 0xd81c
cmoveq %rax, %rsi
leaq 0x4f3a(%rip), %rdi # 0x11044
xorl %eax, %eax
callq 0x4090
movl %r13d, %eax
shrl %eax
movl %eax, %r12d
movq %r12, %rax
shlq $0x4, %rax
leaq 0x47f9(%rip), %rcx # 0x10920
movaps (%rax,%rcx), %xmm0
movaps %xmm0, 0x60(%rsp)
leaq 0x4819(%rip), %rcx # 0x10950
movdqa (%rax,%rcx), %xmm0
movdqa %xmm0, 0x80(%rsp)
andq $0x0, 0x40(%rsp)
movq %r15, %rdi
leaq 0x80(%rsp), %rsi
movl $0x80, %edx
callq 0xb1b7
leaq 0x4819(%rip), %rax # 0x10980
movslq (%rax,%r12,4), %rbx
imulq $0x30, %r12, %r12
testb $0x1, %r13b
jne 0xc1c0
leaq 0x4d34(%rip), %rax # 0x10eb0
leaq (%rax,%r12), %rsi
leaq 0xb0(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x4140
movq %rbp, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x40(%rsp), %rdx
leaq 0x60(%rsp), %rcx
leaq 0xa0(%rsp), %r8
movq %rbp, %r9
callq 0xbc85
leaq 0x4d82(%rip), %rax # 0x10f40
jmp 0xc209
leaq 0x4d79(%rip), %rax # 0x10f40
leaq (%rax,%r12), %rsi
leaq 0xb0(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x4140
movq %rbp, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x40(%rsp), %rdx
leaq 0x60(%rsp), %rcx
leaq 0xa0(%rsp), %r8
movq %rbp, %r9
callq 0xbc85
leaq 0x4ca7(%rip), %rax # 0x10eb0
addq %rax, %r12
movq %rbp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x4170
testl %eax, %eax
jne 0xc24f
testl %r14d, %r14d
je 0xc22f
leaq 0x1615(%rip), %rdi # 0xd83f
callq 0x4060
incl %r13d
jmp 0xc0de
xorl %ebx, %ebx
testl %r14d, %r14d
je 0xc0b0
pushq $0xa
popq %rdi
callq 0x4040
jmp 0xc0b0
pushq $0x1
popq %rbx
testl %r14d, %r14d
jne 0xc0a4
jmp 0xc0b0
| /project-everest[P]mbedtls/library/camellia.c |
mbedtls_ccm_setkey | int mbedtls_ccm_setkey( mbedtls_ccm_context *ctx,
mbedtls_cipher_id_t cipher,
const unsigned char *key,
unsigned int keybits )
{
int ret;
const mbedtls_cipher_info_t *cipher_info;
cipher_info = mbedtls_cipher_info_from_values( cipher, keybits, MBEDTLS_MODE_ECB );
if( cipher_info == NULL )
return( MBEDTLS_ERR_CCM_BAD_INPUT );
if( cipher_info->block_size != 16 )
return( MBEDTLS_ERR_CCM_BAD_INPUT );
mbedtls_cipher_free( &ctx->cipher_ctx );
if( ( ret = mbedtls_cipher_setup( &ctx->cipher_ctx, cipher_info ) ) != 0 )
return( ret );
if( ( ret = mbedtls_cipher_setkey( &ctx->cipher_ctx, key, keybits,
MBEDTLS_ENCRYPT ) ) != 0 )
{
return( ret );
}
return( 0 );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
pushq $0x1
popq %rdx
movl %esi, %edi
movl %ecx, %esi
callq 0x7052
movq %rax, %r12
pushq $-0xd
popq %rax
testq %r12, %r12
je 0xc2c2
cmpl $0x10, 0x20(%r12)
jne 0xc2c2
movq %r15, %rdi
callq 0x709b
movq %r15, %rdi
movq %r12, %rsi
callq 0x70cb
testl %eax, %eax
je 0xc2ce
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7186
| /project-everest[P]mbedtls/library/ccm.c |
List<NameSingletonPair>::Get(long) const | Item& List<Item>::Get(long index) const {
if (_count <= _size) {
return _items[index];
} else {
throw std::out_of_range("Index out of range in List::Get");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
cmpq 0x8(%rdi), %rax
jg 0x1589
shlq $0x4, %rsi
addq (%rdi), %rsi
movq %rsi, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1040
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xaf1(%rip), %rsi # 0x2097
leaq 0xb09(%rip), %rdx # 0x20b6
leaq 0x8(%rsp), %rdi
callq 0x160c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x10f0
xorl %ebp, %ebp
movq 0x2a08(%rip), %rsi # 0x3fd8
movq 0x29f9(%rip), %rdx # 0x3fd0
movq %rbx, %rdi
callq 0x1110
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x15f1
callq 0x10a0
testb %bpl, %bpl
jne 0x15fb
jmp 0x1603
movq %rax, %r14
movq %rbx, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1120
nop
| /BartVandewoestyne[P]Design-Patterns-GoF/Creational_Patterns/Singleton/registry_of_singletons/../../../Foundation_Classes/List.cpp |
main | int main()
{
// TODO: commenting this line in shows that it is still possible to
// create instances of MySingleton using its default constructor. If
// we try to avoid that by making the MySingleton() constructor protected
// instead of public, then the line
// static MySingleton theSingleton;
// in MySingleton.cpp gives an error at compile time:
// error C2248: 'MySingleton::MySingleton': cannot access protected member declared in class 'MySingleton'
//MySingleton foo;
Singleton* mySingleton= MySingleton::Instance();
Singleton::Register("MySingleton", mySingleton);
Singleton* singleton = Singleton::Instance();
} | pushq %rax
callq 0x1340
leaq 0x96e(%rip), %rdi # 0x201f
movq %rax, %rsi
callq 0x148e
callq 0x1340
xorl %eax, %eax
popq %rcx
retq
| /BartVandewoestyne[P]Design-Patterns-GoF/Creational_Patterns/Singleton/registry_of_singletons/main.cpp |
ObjectList::hit(Ray const&, double, double, Hit&) const | bool ObjectList::hit(const Ray& r, double t_min, double t_max, Hit& rec) const {
Hit temp_hit;
bool hit_something = false;
double t_curr = t_max;
for (const auto& object : objects_) {
if (object->hit(r, t_min, t_curr, temp_hit) && temp_hit.t_ < t_curr) {
hit_something = true;
t_curr = temp_hit.t_;
rec = temp_hit;
}
}
return hit_something;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x18(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x58(%rsp)
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, 0x30(%rsp)
movapd %xmm0, 0x40(%rsp)
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %r15
cmpq %r15, %r12
je 0x7352
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x40(%rdx), %rax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x20(%rsp), %r13
movq (%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movsd 0x18(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r13, %rdx
callq *(%rax)
testb %al, %al
je 0x7343
movsd 0x68(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7343
movb 0x50(%rsp), %al
movb %al, 0x30(%rbx)
movaps 0x20(%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
movapd 0x30(%rsp), %xmm1
movaps 0x40(%rsp), %xmm2
movups %xmm2, 0x20(%rbx)
movupd %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rbx)
movq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x7392
movsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x48(%rbx)
movb $0x1, %bpl
addq $0x10, %r12
cmpq %r15, %r12
jne 0x72c3
jmp 0x7354
xorl %ebp, %ebp
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x7363
callq 0x73d8
andb $0x1, %bpl
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x738a
callq 0x73d8
movq %rbx, %rdi
callq 0x6330
| /pshriwise[P]openmc_render/src/geom.cpp |
gen_color(Vec3, int) | std::array<uint8_t, 3> gen_color( Color pixel_color, int n_samples) {
double r = pixel_color.x();
double g = pixel_color.y();
double b = pixel_color.z();
// Divide by the total number of samples per pixel
auto rcp_samples = 1.0 / n_samples;
r *= rcp_samples;
g *= rcp_samples;
b *= rcp_samples;
// Gamma correction: adjusting for perceived brightness vs. linear brightness
r = std::pow(r, RCP_GAMMA);
g = std::pow(g, RCP_GAMMA);
b = std::pow(b, RCP_GAMMA);
const double color_min = 0.0;
const double color_max = 0.999;
return {static_cast<uint8_t>(RGB_MAX * clamp(r, color_min, color_max)),
static_cast<uint8_t>(RGB_MAX * clamp(g, color_min, color_max)),
static_cast<uint8_t>(RGB_MAX * clamp(b, color_min, color_max))};
} | subq $0x18, %rsp
cvtsi2sd %edi, %xmm0
movsd 0x5bc8(%rip), %xmm1 # 0xd020
divsd %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x28(%rsp), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%rsp)
mulsd 0x30(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x5bbf(%rip), %xmm1 # 0xd048
callq 0x6320
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
movsd 0x5ba7(%rip), %xmm1 # 0xd048
callq 0x6320
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x5b8f(%rip), %xmm1 # 0xd048
callq 0x6320
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
maxsd 0x10(%rsp), %xmm2
movsd 0x5b7c(%rip), %xmm3 # 0xd050
movapd %xmm3, %xmm4
minsd %xmm2, %xmm4
movsd 0x5b74(%rip), %xmm2 # 0xd058
mulsd %xmm2, %xmm4
cvttsd2si %xmm4, %eax
xorpd %xmm4, %xmm4
maxsd (%rsp), %xmm4
movapd %xmm3, %xmm5
minsd %xmm4, %xmm5
mulsd %xmm2, %xmm5
cvttsd2si %xmm5, %ecx
maxsd %xmm0, %xmm1
minsd %xmm1, %xmm3
mulsd %xmm2, %xmm3
cvttsd2si %xmm3, %edx
shll $0x10, %edx
movl $0xff, %esi
andl %esi, %ecx
shll $0x8, %ecx
orl %edx, %ecx
andl %esi, %eax
orl %ecx, %eax
addq $0x18, %rsp
retq
| /pshriwise[P]openmc_render/src/color.cpp |
void spdlog::logger::log_<int>(spdlog::source_loc, spdlog::level::level_enum, fmt::v9::basic_string_view<char>, int&&) | void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&... args)
{
bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled)
{
return;
}
SPDLOG_TRY
{
memory_buf_t buf;
#ifdef SPDLOG_USE_STD_FORMAT
fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(std::forward<Args>(args)...));
#else
fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(std::forward<Args>(args)...));
#endif
details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
log_it_(log_msg, log_enabled, traceback_enabled);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %r8, %r13
movq %rcx, 0x28(%rsp)
movq %rdx, %r12
movl %esi, %ebp
movl 0x40(%rdi), %ebx
cmpl %esi, %ebx
setg %r15b
movq %rdi, 0x20(%rsp)
addq $0x68, %rdi
callq 0x3575c
movl %eax, %r14d
xorb $0x1, %al
testb %al, %r15b
jne 0x2f1ae
leaq 0xb0(%rsp), %rax
andq $0x0, -0x10(%rax)
leaq 0xa30ef(%rip), %rcx # 0xd2200
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0xfa, -0x8(%rax)
movl (%r13), %eax
leaq 0x30(%rsp), %r8
movq %rax, (%r8)
leaq 0x90(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r12, %rsi
movq 0x28(%rsp), %rdx
callq 0x24a3e
movq 0x20(%rsp), %r15
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq 0x98(%rsp), %r8
movq 0xa0(%rsp), %r9
leaq 0x1f0(%rsp), %r12
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq 0x30(%rsp), %rdi
movl %ebp, %ecx
callq 0x36acc
xorl %edx, %edx
cmpl %ebp, %ebx
setle %dl
movzbl %r14b, %ecx
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x3707c
leaq 0x90(%rsp), %rdi
callq 0x2ea1e
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f0(%rsp), %r12
jmp 0x2f1ca
movq %rdx, %r14
movq %rax, %r15
leaq 0x90(%rsp), %rdi
callq 0x2ea1e
movq %r15, %rdi
callq 0x17260
cmpl $0x2, %r14d
jne 0x2f28f
movq (%r12), %rbx
testq %rbx, %rbx
je 0x2f248
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movl 0x8(%r12), %ecx
leaq 0x90(%rsp), %r8
movq %rax, (%r8)
movq %rbx, 0x10(%r8)
movq %rcx, 0x20(%r8)
leaq 0x57674(%rip), %rsi # 0x86894
leaq 0x30(%rsp), %rdi
pushq $0xb
popq %rdx
movl $0x1cc, %ecx # imm = 0x1CC
callq 0x4604b
leaq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x3724e
leaq 0x30(%rsp), %rdi
jmp 0x2f280
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rax, %rsi
callq 0x23a20
leaq 0x90(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x3724e
leaq 0x90(%rsp), %rdi
callq 0x17d68
callq 0x17af0
jmp 0x2f1ae
leaq 0x5723f(%rip), %rsi # 0x864d5
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x23a20
leaq 0x90(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x3724e
leaq 0x90(%rsp), %rdi
callq 0x17d68
callq 0x179e0
jmp 0x2f2ef
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x17d68
jmp 0x2f2f2
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x2f301
jmp 0x2f308
movq %rax, %rbx
callq 0x17af0
jmp 0x2f310
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x17d68
jmp 0x2f30b
movq %rax, %rbx
callq 0x17af0
movq %rbx, %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x23a5b
| /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/logger.h |
fast_float::adjusted_mantissa fast_float::digit_comp<double, char>(fast_float::parsed_number_string_t<char>&, fast_float::adjusted_mantissa) | inline FASTFLOAT_CONSTEXPR20
adjusted_mantissa digit_comp(parsed_number_string_t<UC>& num, adjusted_mantissa am) noexcept {
// remove the invalid exponent bias
am.power2 -= invalid_am_bias;
int32_t sci_exp = scientific_exponent(num);
size_t max_digits = binary_format<T>::max_digits();
size_t digits = 0;
bigint bigmant;
parse_mantissa(bigmant, num, max_digits, digits);
// can't underflow, since digits is at most max_digits.
int32_t exponent = sci_exp + 1 - int32_t(digits);
if (exponent >= 0) {
return positive_digit_comp<T>(bigmant, exponent);
} else {
return negative_digit_comp<T>(bigmant, am, exponent);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movl (%rdi), %ebx
incl %ebx
movl $0x2710, %ecx # imm = 0x2710
cmpq $0x270f, %rax # imm = 0x270F
jbe 0x3128c
xorl %edx, %edx
divq %rcx
addl $0x4, %ebx
jmp 0x3127a
pushq $0x64
popq %rcx
cmpq $0x63, %rax
jbe 0x3129f
xorl %edx, %edx
divq %rcx
addl $0x2, %ebx
jmp 0x3128f
pushq $0xa
popq %rcx
cmpq $0xa, %rax
jb 0x312b1
xorl %edx, %edx
divq %rcx
incl %ebx
jmp 0x312a2
leaq 0x8(%rsp), %r12
andq $0x0, (%r12)
leaq 0x10(%rsp), %r13
movl $0x1f8, %edx # imm = 0x1F8
movq %r13, %rdi
xorl %esi, %esi
callq 0x173d0
movl $0x301, %edx # imm = 0x301
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x3133e
subl (%r12), %ebx
js 0x312f6
leaq 0x10(%rsp), %rdi
movl %ebx, %esi
callq 0x317f0
jmp 0x3130d
addl $0x8000, %ebp # imm = 0x8000
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x318ba
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /njoy[P]ENDFtk/build_O2/_deps/fast_float-src/include/fast_float/digit_comparison.h |
std::shared_ptr<spdlog::async_logger> spdlog::async_factory_impl<(spdlog::async_overflow_policy)0>::create<spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_nullmutex>, spdlog::color_mode&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, spdlog::color_mode&) | static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args)
{
auto ®istry_inst = details::registry::instance();
// create global thread pool if not already exists..
auto &mutex = registry_inst.tp_mutex();
std::lock_guard<std::recursive_mutex> tp_lock(mutex);
auto tp = registry_inst.get_tp();
if (tp == nullptr)
{
tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
registry_inst.set_tp(tp);
}
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
registry_inst.initialize_logger(new_logger);
return new_logger;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
callq 0x34970
movq %rax, %r15
movq %rax, %rdi
callq 0x35e02
movq %rax, %rbp
movq %rax, %rdi
callq 0x3c82a
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x35d6e
cmpq $0x0, 0x28(%rsp)
jne 0x42670
movq %rbp, 0x8(%rsp)
leaq 0x14(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x49f30(%rip), %rsi # 0x8c550
leaq 0x18(%rsp), %rdi
callq 0x43832
leaq 0x28(%rsp), %rbp
leaq 0x18(%rsp), %rsi
movq %rbp, %rdi
callq 0x3c83e
leaq 0x20(%rsp), %rdi
callq 0x24624
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3b67e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x35d38
leaq 0x50(%rsp), %rdi
callq 0x24624
movq 0x8(%rsp), %rbp
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x42f4b
leaq 0x14(%rsp), %r8
andl $0x0, (%r8)
leaq 0x18(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
movq %r12, %rsi
callq 0x43dad
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43d9a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x349e0
leaq 0x40(%rsp), %rdi
callq 0x24624
leaq 0x20(%rsp), %rdi
callq 0x24624
leaq 0x30(%rsp), %rdi
callq 0x24624
movq %rbp, %rdi
callq 0x17570
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x50(%rsp), %rdi
jmp 0x42727
jmp 0x42733
movq %rbp, 0x8(%rsp)
movq %rax, %r15
leaq 0x40(%rsp), %rdi
callq 0x24624
addq $0x8, %r14
movq %r14, %rdi
callq 0x24624
jmp 0x42722
movq %rbp, 0x8(%rsp)
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x24624
jmp 0x42736
movq %rbp, 0x8(%rsp)
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0x24624
jmp 0x4274a
movq %rbp, 0x8(%rsp)
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0x17570
movq %r15, %rdi
callq 0x17be0
| /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/async.h |
mbedtls_cipher_update | int mbedtls_cipher_update( mbedtls_cipher_context_t *ctx, const unsigned char *input,
size_t ilen, unsigned char *output, size_t *olen )
{
int ret;
size_t block_size = 0;
if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
*olen = 0;
block_size = mbedtls_cipher_get_block_size( ctx );
if( ctx->cipher_info->mode == MBEDTLS_MODE_ECB )
{
if( ilen != block_size )
return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
*olen = ilen;
if( 0 != ( ret = ctx->cipher_info->base->ecb_func( ctx->cipher_ctx,
ctx->operation, input, output ) ) )
{
return( ret );
}
return( 0 );
}
#if defined(MBEDTLS_GCM_C)
if( ctx->cipher_info->mode == MBEDTLS_MODE_GCM )
{
*olen = ilen;
return mbedtls_gcm_update( (mbedtls_gcm_context *) ctx->cipher_ctx, ilen, input,
output );
}
#endif
if ( 0 == block_size )
{
return MBEDTLS_ERR_CIPHER_INVALID_CONTEXT;
}
if( input == output &&
( ctx->unprocessed_len != 0 || ilen % block_size ) )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
if( ctx->cipher_info->mode == MBEDTLS_MODE_CBC )
{
size_t copy_len = 0;
/*
* If there is not enough data for a full block, cache it.
*/
if( ( ctx->operation == MBEDTLS_DECRYPT &&
ilen <= block_size - ctx->unprocessed_len ) ||
( ctx->operation == MBEDTLS_ENCRYPT &&
ilen < block_size - ctx->unprocessed_len ) )
{
memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
ilen );
ctx->unprocessed_len += ilen;
return( 0 );
}
/*
* Process cached data first
*/
if( 0 != ctx->unprocessed_len )
{
copy_len = block_size - ctx->unprocessed_len;
memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
copy_len );
if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
ctx->operation, block_size, ctx->iv,
ctx->unprocessed_data, output ) ) )
{
return( ret );
}
*olen += block_size;
output += block_size;
ctx->unprocessed_len = 0;
input += copy_len;
ilen -= copy_len;
}
/*
* Cache final, incomplete block
*/
if( 0 != ilen )
{
if( 0 == block_size )
{
return MBEDTLS_ERR_CIPHER_INVALID_CONTEXT;
}
copy_len = ilen % block_size;
if( copy_len == 0 && ctx->operation == MBEDTLS_DECRYPT )
copy_len = block_size;
memcpy( ctx->unprocessed_data, &( input[ilen - copy_len] ),
copy_len );
ctx->unprocessed_len += copy_len;
ilen -= copy_len;
}
/*
* Process remaining full blocks
*/
if( ilen )
{
if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
ctx->operation, ilen, ctx->iv, input, output ) ) )
{
return( ret );
}
*olen += ilen;
}
return( 0 );
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
if( ctx->cipher_info->mode == MBEDTLS_MODE_CFB )
{
if( 0 != ( ret = ctx->cipher_info->base->cfb_func( ctx->cipher_ctx,
ctx->operation, ilen, &ctx->unprocessed_len, ctx->iv,
input, output ) ) )
{
return( ret );
}
*olen = ilen;
return( 0 );
}
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
if( ctx->cipher_info->mode == MBEDTLS_MODE_CTR )
{
if( 0 != ( ret = ctx->cipher_info->base->ctr_func( ctx->cipher_ctx,
ilen, &ctx->unprocessed_len, ctx->iv,
ctx->unprocessed_data, input, output ) ) )
{
return( ret );
}
*olen = ilen;
return( 0 );
}
#endif /* MBEDTLS_CIPHER_MODE_CTR */
#if defined(MBEDTLS_CIPHER_MODE_STREAM)
if( ctx->cipher_info->mode == MBEDTLS_MODE_STREAM )
{
if( 0 != ( ret = ctx->cipher_info->base->stream_func( ctx->cipher_ctx,
ilen, input, output ) ) )
{
return( ret );
}
*olen = ilen;
return( 0 );
}
#endif /* MBEDTLS_CIPHER_MODE_STREAM */
return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0xffff9f00, %ebp # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x7ba8
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbx
movq %rdi, %r12
movq (%rdi), %rcx
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x7bb9
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
movq $0x0, (%r14)
movl 0x4(%rcx), %esi
cmpl $0x6, %esi
je 0x7c08
movl 0x20(%rcx), %edi
cmpl $0x1, %esi
jne 0x7c2c
movl $0xffff9d80, %ebp # imm = 0xFFFF9D80
cmpq %rbx, %rdi
jne 0x7ba8
movq %rbx, (%r14)
movq 0x28(%rcx), %rax
movq 0x8(%rax), %rax
movq 0x50(%r12), %rdi
movl 0xc(%r12), %esi
movq %r15, %rdx
movq %r13, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rbx, (%r14)
movq 0x50(%r12), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa0f5
testq %rdi, %rdi
je 0x7cba
cmpq %r13, %r15
je 0x7cc4
movl $0xffff9f80, %ebp # imm = 0xFFFF9F80
addl $-0x2, %esi
cmpl $0x5, %esi
ja 0x7ba8
leaq 0x945a(%rip), %rax # 0x110b0
movslq (%rax,%rsi,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movl 0xc(%r12), %eax
cmpl $0x1, %eax
je 0x7c87
testl %eax, %eax
jne 0x7d62
movq %rdi, %rcx
subq 0x30(%r12), %rcx
cmpq %rbx, %rcx
jae 0x7c98
cmpl $0x1, %eax
jne 0x7d62
movq %rdi, %rax
subq 0x30(%r12), %rax
cmpq %rbx, %rax
jbe 0x7d62
movq 0x30(%r12), %rax
leaq (%r12,%rax), %rdi
addq $0x20, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4140
addq %rbx, 0x30(%r12)
jmp 0x7d5b
movl $0xffff9c80, %ebp # imm = 0xFFFF9C80
jmp 0x7ba8
cmpq $0x0, 0x30(%r12)
jne 0x7ba8
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
testq %rdx, %rdx
jne 0x7ba8
jmp 0x7c3e
movq 0x28(%rcx), %rax
movq 0x50(%r12), %rdi
leaq 0x30(%r12), %rdx
leaq 0x38(%r12), %rcx
addq $0x20, %r12
movq %r13, (%rsp)
movq %rbx, %rsi
movq %r12, %r8
movq %r15, %r9
callq *0x20(%rax)
jmp 0x7d4d
movq 0x28(%rcx), %rax
movq 0x50(%r12), %rdi
movl 0xc(%r12), %esi
leaq 0x30(%r12), %rcx
addq $0x38, %r12
movq %r13, (%rsp)
movq %rbx, %rdx
movq %r12, %r8
movq %r15, %r9
callq *0x18(%rax)
jmp 0x7d4d
movq 0x28(%rcx), %rax
movq 0x50(%r12), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *0x28(%rax)
testl %eax, %eax
je 0x7d58
movl %eax, %ebp
jmp 0x7ba8
movq %rbx, (%r14)
xorl %ebp, %ebp
jmp 0x7ba8
movq 0x30(%r12), %rax
testq %rax, %rax
je 0x7de1
movq %rdi, %rdx
subq %rax, %rdx
leaq 0x20(%r12), %rcx
movq %rcx, 0x10(%rsp)
movq %rdi, %rbp
leaq (%r12,%rax), %rdi
addq $0x20, %rdi
movq %r15, %rsi
movq %rdx, 0x18(%rsp)
callq 0x4140
movq (%r12), %rax
movq 0x28(%rax), %rax
movq 0x50(%r12), %rdi
movl 0xc(%r12), %esi
leaq 0x38(%r12), %rcx
movq %rbp, 0x20(%rsp)
movq %rbp, %rdx
movq 0x10(%rsp), %r8
movq %r13, %r9
callq *0x10(%rax)
testl %eax, %eax
jne 0x7d51
movq 0x20(%rsp), %rdi
addq %rdi, (%r14)
addq %rdi, %r13
movq $0x0, 0x30(%r12)
movq 0x18(%rsp), %rax
addq %rax, %r15
subq %rax, %rbx
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x7e23
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
testq %rdx, %rdx
jne 0x7e01
xorl %edx, %edx
cmpl $0x0, 0xc(%r12)
cmoveq %rdi, %rdx
leaq 0x20(%r12), %rdi
subq %rdx, %rbx
leaq (%r15,%rbx), %rsi
movq %rdx, 0x10(%rsp)
callq 0x4140
movq 0x10(%rsp), %rax
addq %rax, 0x30(%r12)
jmp 0x7e25
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x7ba8
movq (%r12), %rax
movq 0x28(%rax), %rax
movq 0x50(%r12), %rdi
movl 0xc(%r12), %esi
addq $0x38, %r12
movq %rbx, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r13, %r9
callq *0x10(%rax)
testl %eax, %eax
jne 0x7d51
addq %rbx, (%r14)
jmp 0x7ba8
| /Dragonchang[P]https_client/mbedtls/library/cipher.c |
blowfish_ctx_alloc | static void * blowfish_ctx_alloc( void )
{
mbedtls_blowfish_context *ctx;
ctx = mbedtls_calloc( 1, sizeof( mbedtls_blowfish_context ) );
if( ctx == NULL )
return( NULL );
mbedtls_blowfish_init( ctx );
return( ctx );
} | pushq %rbx
movl $0x1, %edi
movl $0x1048, %esi # imm = 0x1048
callq 0x40f0
testq %rax, %rax
je 0x8607
movq %rax, %rbx
movq %rax, %rdi
callq 0xcc4c
jmp 0x8609
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
| /Dragonchang[P]https_client/mbedtls/library/cipher_wrap.c |
mbedtls_des_crypt_ecb | int mbedtls_des_crypt_ecb( mbedtls_des_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 < 8; i++ )
{
DES_ROUND( Y, X );
DES_ROUND( X, Y );
}
DES_FP( Y, X );
PUT_UINT32_BE( Y, output, 0 );
PUT_UINT32_BE( X, output, 4 );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x10(%rsp)
movq %rdi, -0x8(%rsp)
movl (%rsi), %ecx
movl 0x4(%rsi), %eax
bswapl %ecx
bswapl %eax
movl %ecx, %edx
shrl $0x4, %edx
xorl %eax, %edx
andl $0xf0f0f0f, %edx # imm = 0xF0F0F0F
xorl %edx, %eax
shll $0x4, %edx
xorl %ecx, %edx
movl %edx, %esi
shrl $0x10, %esi
movzwl %ax, %ecx
xorl %esi, %ecx
xorl %ecx, %eax
shll $0x10, %ecx
xorl %edx, %ecx
movl %eax, %edx
shrl $0x2, %edx
xorl %ecx, %edx
andl $0x33333333, %edx # imm = 0x33333333
xorl %edx, %ecx
shll $0x2, %edx
xorl %eax, %edx
movl %edx, %ebp
shrl $0x8, %ebp
xorl %ecx, %ebp
andl $0xff00ff, %ebp # imm = 0xFF00FF
xorl %ebp, %ecx
shll $0x8, %ebp
xorl %edx, %ebp
roll %ebp
movl %ebp, %eax
xorl %ecx, %eax
andl $0xaaaaaaaa, %eax # imm = 0xAAAAAAAA
xorl %eax, %ebp
xorl %ecx, %eax
roll %eax
xorl %ecx, %ecx
movl $0xfc, %r13d
movq -0x8(%rsp), %r8
leaq 0x87e6(%rip), %r11 # 0x11740
leaq 0x88df(%rip), %rbx # 0x11840
leaq 0x89d8(%rip), %r14 # 0x11940
leaq 0x8ad1(%rip), %r15 # 0x11a40
leaq 0x8bca(%rip), %r12 # 0x11b40
movl %ebp, %edx
movl (%r8,%rcx), %ebp
xorl %edx, %ebp
movl %edx, %edi
movl %ebp, %edx
andl $0x3f, %edx
movl %ebp, %esi
shrl $0x6, %esi
andl %r13d, %esi
leaq 0x85ac(%rip), %r9 # 0x11540
xorl (%r9,%rdx,4), %eax
movl %ebp, %edx
shrl $0xe, %edx
andl %r13d, %edx
shrl $0x16, %ebp
andl %r13d, %ebp
leaq 0x8693(%rip), %r10 # 0x11640
xorl (%rsi,%r10), %eax
movl %edi, %esi
movl %edi, %r10d
roll $0x1c, %esi
xorl 0x4(%r8,%rcx), %esi
xorl (%rdx,%r11), %eax
movl %esi, %edx
andl $0x3f, %edx
xorl (%rbp,%rbx), %eax
movl %esi, %ebp
shrl $0x6, %ebp
andl %r13d, %ebp
xorl (%r14,%rdx,4), %eax
movl %esi, %edx
shrl $0xe, %edx
andl %r13d, %edx
shrl $0x16, %esi
andl %r13d, %esi
xorl (%rbp,%r15), %eax
xorl (%rdx,%r12), %eax
leaq 0x8c4b(%rip), %rdi # 0x11c40
xorl (%rsi,%rdi), %eax
movl 0x8(%r8,%rcx), %esi
xorl %eax, %esi
movl %esi, %edx
andl $0x3f, %edx
movl (%r9,%rdx,4), %ebp
movl %esi, %edx
shrl $0x6, %edx
andl %r13d, %edx
leaq 0x8629(%rip), %r9 # 0x11640
xorl (%rdx,%r9), %ebp
movl %esi, %edx
shrl $0xe, %edx
andl %r13d, %edx
shrl $0x16, %esi
andl %r13d, %esi
xorl (%rdx,%r11), %ebp
movl %eax, %edx
roll $0x1c, %edx
xorl 0xc(%r8,%rcx), %edx
xorl (%rsi,%rbx), %ebp
movl %edx, %esi
andl $0x3f, %esi
xorl (%r14,%rsi,4), %ebp
movl %edx, %esi
shrl $0x6, %esi
andl %r13d, %esi
xorl (%rsi,%r15), %ebp
movl %edx, %esi
shrl $0xe, %esi
andl %r13d, %esi
xorl (%rsi,%r12), %ebp
shrl $0x16, %edx
andl %r13d, %edx
xorl (%rdx,%rdi), %ebp
xorl %r10d, %ebp
addq $0x10, %rcx
cmpl $0x80, %ecx
jne 0x8f76
rorl %ebp
movl %ebp, %ecx
xorl %eax, %ecx
andl $0xaaaaaaaa, %ecx # imm = 0xAAAAAAAA
xorl %ecx, %ebp
xorl %eax, %ecx
rorl %ecx
movl %ecx, %edx
shrl $0x8, %edx
xorl %ebp, %edx
andl $0xff00ff, %edx # imm = 0xFF00FF
xorl %edx, %ebp
shll $0x8, %edx
xorl %ecx, %edx
movl %edx, %eax
shrl $0x2, %eax
xorl %ebp, %eax
andl $0x33333333, %eax # imm = 0x33333333
xorl %eax, %ebp
shll $0x2, %eax
xorl %edx, %eax
movl %ebp, %ecx
shrl $0x10, %ecx
movzwl %ax, %edx
xorl %ecx, %edx
xorl %edx, %eax
shll $0x10, %edx
xorl %ebp, %edx
movl %edx, %ecx
shrl $0x4, %ecx
xorl %eax, %ecx
andl $0xf0f0f0f, %ecx # imm = 0xF0F0F0F
xorl %ecx, %eax
shll $0x4, %ecx
xorl %edx, %ecx
movl %ecx, %edx
shrl $0x18, %edx
movq -0x10(%rsp), %rsi
movb %dl, (%rsi)
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, 0x1(%rsi)
movb %ch, 0x2(%rsi)
movb %cl, 0x3(%rsi)
movl %eax, %ecx
shrl $0x18, %ecx
movb %cl, 0x4(%rsi)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x5(%rsi)
movb %ah, 0x6(%rsi)
movb %al, 0x7(%rsi)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/des.c |
mbedtls_blowfish_crypt_ecb | int mbedtls_blowfish_crypt_ecb( mbedtls_blowfish_context *ctx,
int mode,
const unsigned char input[MBEDTLS_BLOWFISH_BLOCKSIZE],
unsigned char output[MBEDTLS_BLOWFISH_BLOCKSIZE] )
{
uint32_t X0, X1;
GET_UINT32_BE( X0, input, 0 );
GET_UINT32_BE( X1, input, 4 );
if( mode == MBEDTLS_BLOWFISH_DECRYPT )
{
blowfish_dec( ctx, &X0, &X1 );
}
else /* MBEDTLS_BLOWFISH_ENCRYPT */
{
blowfish_enc( ctx, &X0, &X1 );
}
PUT_UINT32_BE( X0, output, 0 );
PUT_UINT32_BE( X1, output, 4 );
return( 0 );
} | pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %ecx
bswapl %ecx
movl %ecx, 0xc(%rsp)
movl 0x4(%rdx), %eax
bswapl %eax
movl %eax, 0x8(%rsp)
testl %esi, %esi
je 0xce5b
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xcdbe
jmp 0xcec5
movl $0x12, %edx
movl $0xff, %esi
movl %eax, %r8d
movl %ecx, %eax
xorl -0x4(%rdi,%rdx,4), %eax
movl %eax, %r9d
movl %eax, %r10d
shrl $0x18, %r10d
movl %eax, %ecx
shrl $0xe, %ecx
andl $0x3fc, %ecx # imm = 0x3FC
movl 0x448(%rdi,%rcx), %ecx
addl 0x48(%rdi,%r10,4), %ecx
andl %esi, %r9d
movl %eax, %r10d
shrl $0x8, %r10d
andl %esi, %r10d
xorl 0x848(%rdi,%r10,4), %ecx
addl 0xc48(%rdi,%r9,4), %ecx
xorl %r8d, %ecx
decq %rdx
cmpq $0x2, %rdx
ja 0xce65
xorl 0x4(%rdi), %ecx
xorl (%rdi), %eax
movl %eax, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movl 0xc(%rsp), %eax
bswapl %eax
movl %eax, (%rbx)
movl 0x8(%rsp), %eax
bswapl %eax
movl %eax, 0x4(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
| /Dragonchang[P]https_client/mbedtls/library/blowfish.c |
mbedtls_camellia_crypt_cbc | int mbedtls_camellia_crypt_cbc( mbedtls_camellia_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[16];
if( length % 16 )
return( MBEDTLS_ERR_CAMELLIA_INVALID_INPUT_LENGTH );
if( mode == MBEDTLS_CAMELLIA_DECRYPT )
{
while( length > 0 )
{
memcpy( temp, input, 16 );
mbedtls_camellia_crypt_ecb( ctx, mode, input, output );
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
memcpy( iv, temp, 16 );
input += 16;
output += 16;
length -= 16;
}
}
else
{
while( length > 0 )
{
for( i = 0; i < 16; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
mbedtls_camellia_crypt_ecb( ctx, mode, output, output );
memcpy( iv, output, 16 );
input += 16;
output += 16;
length -= 16;
}
}
return( 0 );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movl $0xffffffda, %eax # imm = 0xFFFFFFDA
testb $0xf, %r12b
jne 0xdbc1
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r13
testl %esi, %esi
je 0xdb7c
testq %r12, %r12
je 0xdbbf
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
cmpq $0x10, %rax
jne 0xdb43
movq %r13, %rdi
movq %rbx, %rdx
movq %rbx, %rcx
callq 0xd953
movups (%rbx), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jne 0xdb41
jmp 0xdbbf
testq %r12, %r12
je 0xdbbf
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq %r13, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xd953
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
cmpq $0x10, %rax
jne 0xdb99
movaps (%rsp), %xmm0
movups %xmm0, (%r15)
addq $0x10, %r14
addq $0x10, %rbx
addq $-0x10, %r12
jne 0xdb81
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /Dragonchang[P]https_client/mbedtls/library/camellia.c |
mbedtls_ccm_setkey | int mbedtls_ccm_setkey( mbedtls_ccm_context *ctx,
mbedtls_cipher_id_t cipher,
const unsigned char *key,
unsigned int keybits )
{
int ret;
const mbedtls_cipher_info_t *cipher_info;
cipher_info = mbedtls_cipher_info_from_values( cipher, keybits, MBEDTLS_MODE_ECB );
if( cipher_info == NULL )
return( MBEDTLS_ERR_CCM_BAD_INPUT );
if( cipher_info->block_size != 16 )
return( MBEDTLS_ERR_CCM_BAD_INPUT );
mbedtls_cipher_free( &ctx->cipher_ctx );
if( ( ret = mbedtls_cipher_setup( &ctx->cipher_ctx, cipher_info ) ) != 0 )
return( ret );
if( ( ret = mbedtls_cipher_setkey( &ctx->cipher_ctx, key, keybits,
MBEDTLS_ENCRYPT ) ) != 0 )
{
return( ret );
}
return( 0 );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %edi
movl %ecx, %esi
movl $0x1, %edx
callq 0x7923
movq %rax, %r12
movl $0xfffffff3, %eax # imm = 0xFFFFFFF3
testq %r12, %r12
je 0xe2b9
cmpl $0x10, 0x20(%r12)
jne 0xe2b9
movq %r15, %rdi
callq 0x7978
movq %r15, %rdi
movq %r12, %rsi
callq 0x79a5
testl %eax, %eax
je 0xe2c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a63
| /Dragonchang[P]https_client/mbedtls/library/ccm.c |
mbedtls_ccm_auth_decrypt | int mbedtls_ccm_auth_decrypt( mbedtls_ccm_context *ctx, size_t length,
const unsigned char *iv, size_t iv_len,
const unsigned char *add, size_t add_len,
const unsigned char *input, unsigned char *output,
const unsigned char *tag, size_t tag_len )
{
int ret;
unsigned char check_tag[16];
unsigned char i;
int diff;
if( ( ret = ccm_auth_crypt( ctx, CCM_DECRYPT, length,
iv, iv_len, add, add_len,
input, output, check_tag, tag_len ) ) != 0 )
{
return( ret );
}
/* Check tag in "constant-time" */
for( diff = 0, i = 0; i < tag_len; i++ )
diff |= tag[i] ^ check_tag[i];
if( diff != 0 )
{
mbedtls_zeroize( output, length );
return( MBEDTLS_ERR_CCM_AUTH_FAILED );
}
return( 0 );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %rax
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rbx
movq 0x48(%rsp), %r15
movq 0x38(%rsp), %r14
subq $0x8, %rsp
leaq 0x8(%rsp), %r10
movl $0x1, %esi
movq %rbx, %rdx
pushq %r15
pushq %r10
pushq %r14
pushq 0x50(%rsp)
pushq %rax
callq 0xe333
addq $0x30, %rsp
testl %eax, %eax
jne 0xe87b
testq %r15, %r15
je 0xe879
movq 0x40(%rsp), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movb (%rsp,%rcx), %sil
xorb (%rax,%rcx), %sil
movzbl %sil, %esi
orl %esi, %edx
incq %rcx
movzbl %cl, %esi
cmpq %r15, %rsi
jb 0xe841
testl %edx, %edx
je 0xe879
movl $0xfffffff1, %eax # imm = 0xFFFFFFF1
testq %rbx, %rbx
je 0xe87b
xorl %ecx, %ecx
movb $0x0, (%r14,%rcx)
incq %rcx
cmpq %rcx, %rbx
jne 0xe86a
jmp 0xe87b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /Dragonchang[P]https_client/mbedtls/library/ccm.c |
mbedtls_ccm_self_test | int mbedtls_ccm_self_test( int verbose )
{
mbedtls_ccm_context ctx;
unsigned char out[32];
size_t i;
int ret;
mbedtls_ccm_init( &ctx );
if( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES, key, 8 * sizeof key ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( " CCM: setup failed" );
return( 1 );
}
for( i = 0; i < NB_TESTS; i++ )
{
if( verbose != 0 )
mbedtls_printf( " CCM-AES #%u: ", (unsigned int) i + 1 );
ret = mbedtls_ccm_encrypt_and_tag( &ctx, msg_len[i],
iv, iv_len[i], ad, add_len[i],
msg, out,
out + msg_len[i], tag_len[i] );
if( ret != 0 ||
memcmp( out, res[i], msg_len[i] + tag_len[i] ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
ret = mbedtls_ccm_auth_decrypt( &ctx, msg_len[i],
iv, iv_len[i], ad, add_len[i],
res[i], out,
res[i] + msg_len[i], tag_len[i] );
if( ret != 0 ||
memcmp( out, msg, msg_len[i] ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
mbedtls_ccm_free( &ctx );
if( verbose != 0 )
mbedtls_printf( "\n" );
return( 0 );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edi, %ebx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
leaq 0x602e(%rip), %rdx # 0x148f0
movl $0x2, %esi
movl $0x80, %ecx
callq 0xe26f
testl %eax, %eax
je 0xe8f5
movl $0x1, %ebp
testl %ebx, %ebx
je 0xea6b
leaq 0x6147(%rip), %rdi # 0x14a30
xorl %eax, %eax
callq 0x4090
jmp 0xea6b
leaq 0x60d4(%rip), %r14 # 0x149d0
movl $0x1, %ebp
leaq 0x10(%rsp), %r13
xorl %r15d, %r15d
movl %ebx, (%rsp)
testl %ebx, %ebx
je 0xe920
leaq 0x612d(%rip), %rdi # 0x14a44
movl %ebp, %esi
xorl %eax, %eax
callq 0x4090
movl %ebp, 0x4(%rsp)
leaq 0x5fd5(%rip), %rax # 0x14900
movq (%r15,%rax), %r12
leaq 0x5ffa(%rip), %rax # 0x14930
movq (%r15,%rax), %r8
leaq 0x602f(%rip), %rax # 0x14970
movq (%r15,%rax), %r10
leaq (%rsp,%r12), %rax
addq $0x10, %rax
leaq 0x605c(%rip), %rcx # 0x149b0
movq (%r15,%rcx), %rbp
subq $0x8, %rsp
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
movq %r12, %rdx
leaq 0x5fab(%rip), %rcx # 0x14918
movq %r8, 0x10(%rsp)
leaq 0x5fd7(%rip), %r9 # 0x14950
pushq %rbp
pushq %rax
pushq %r13
leaq 0x600c(%rip), %rax # 0x14990
pushq %rax
movq %r10, %rbx
pushq %r10
callq 0xe333
addq $0x30, %rsp
testl %eax, %eax
jne 0xea54
leaq (%r12,%rbp), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x4170
testl %eax, %eax
jne 0xea54
leaq (%r14,%r12), %rax
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
leaq 0x5f53(%rip), %rdx # 0x14918
movq 0x8(%rsp), %rcx
leaq 0x5f7f(%rip), %r8 # 0x14950
movq %rbx, %r9
pushq %rbp
pushq %rax
pushq %r13
pushq %r14
callq 0xe7e8
addq $0x20, %rsp
testl %eax, %eax
jne 0xea54
movq %r13, %rdi
leaq 0x5f9f(%rip), %rsi # 0x14990
movq %r12, %rdx
callq 0x4170
testl %eax, %eax
jne 0xea54
movl (%rsp), %ebx
testl %ebx, %ebx
je 0xea10
leaq 0x3403(%rip), %rdi # 0x11e0e
callq 0x4060
addq $0x8, %r15
addq $0x20, %r14
movl 0x4(%rsp), %ebp
incl %ebp
cmpq $0x18, %r15
jne 0xe90c
leaq 0x30(%rsp), %rdi
callq 0x7978
xorl %eax, %eax
movb $0x0, 0x30(%rsp,%rax)
incq %rax
cmpq $0x58, %rax
jne 0xea34
xorl %ebp, %ebp
testl %ebx, %ebx
je 0xea6b
movl $0xa, %edi
callq 0x4040
jmp 0xea6b
movl $0x1, %ebp
cmpl $0x0, (%rsp)
je 0xea6b
leaq 0x5fd7(%rip), %rdi # 0x14a3d
callq 0x4060
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /Dragonchang[P]https_client/mbedtls/library/ccm.c |
swapBytes(unsigned char*, int) | void swapBytes(unsigned char* var, int size)
{
int i = 0;
int j = size - 1;
char c;
while (i < j) {
c = var[i]; var[i] = var[j]; var[j] = c;
i++, j--;
}
} | cmpl $0x2, %esi
jl 0x12946
movl %esi, %eax
addq $-0x2, %rax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
movb 0x1(%rdi,%rax), %sil
movb %sil, (%rdi,%rcx)
movb %dl, 0x1(%rdi,%rax)
incq %rcx
leaq -0x1(%rax), %rdx
cmpq %rax, %rcx
movq %rdx, %rax
jl 0x12927
retq
| /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenio::save_edges(char*) | void tetgenio::save_edges(char* filebasename)
{
FILE *fout;
char outedgefilename[FILENAMESIZE];
int i;
sprintf(outedgefilename, "%s.edge", filebasename);
printf("Saving edges to %s\n", outedgefilename);
fout = fopen(outedgefilename, "w");
fprintf(fout, "%d %d\n", numberofedges, edgemarkerlist != NULL ? 1 : 0);
for (i = 0; i < numberofedges; i++) {
fprintf(fout, "%d %4d %4d", i + firstnumber, edgelist[i * 2],
edgelist[i * 2 + 1]);
if (edgemarkerlist != NULL) {
fprintf(fout, " %d", edgemarkerlist[i]);
}
fprintf(fout, "\n");
}
fclose(fout);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x400, %rsp # imm = 0x400
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x5fa8a(%rip), %rsi # 0x736e1
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x8060
leaq 0x5fa7e(%rip), %rdi # 0x736e9
movq %r14, %rsi
xorl %eax, %eax
callq 0x8050
leaq 0x5f9b5(%rip), %rsi # 0x73631
movq %r14, %rdi
callq 0x8250
movq %rax, %r14
movl 0x138(%rbx), %edx
xorl %ecx, %ecx
cmpq $0x0, 0x120(%rbx)
setne %cl
leaq 0x5f99a(%rip), %rsi # 0x7363b
movq %rax, %rdi
xorl %eax, %eax
callq 0x82e0
cmpl $0x0, 0x138(%rbx)
jle 0x13d20
leaq 0x5fa42(%rip), %r15 # 0x736fd
leaq 0x62c7d(%rip), %r12 # 0x7693f
xorl %r13d, %r13d
movl (%rbx), %edx
addl %r13d, %edx
movq 0x118(%rbx), %rax
movl (%rax,%r13,8), %ecx
movl 0x4(%rax,%r13,8), %r8d
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x82e0
movq 0x120(%rbx), %rax
testq %rax, %rax
je 0x13d04
movl (%rax,%r13,4), %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x82e0
movl $0xa, %edi
movq %r14, %rsi
callq 0x8270
incq %r13
movslq 0x138(%rbx), %rax
cmpq %rax, %r13
jl 0x13cc5
movq %r14, %rdi
callq 0x81e0
addq $0x400, %rsp # imm = 0x400
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenbehavior::usage() | void tetgenbehavior::usage()
{
printf("TetGen\n");
printf("A Quality Tetrahedral Mesh Generator and 3D Delaunay ");
printf("Triangulator\n");
printf("Version 1.5\n");
printf("May 31, 2014\n");
printf("\n");
printf("Copyright (C) 2002 - 2014\n");
printf("\n");
printf("What Can TetGen Do?\n");
printf("\n");
printf(" TetGen generates Delaunay tetrahedralizations, constrained\n");
printf(" Delaunay tetrahedralizations, and quality tetrahedral meshes.\n");
printf("\n");
printf("Command Line Syntax:\n");
printf("\n");
printf(" Below is the basic command line syntax of TetGen with a list of ");
printf("short\n");
printf(" descriptions. Underscores indicate that numbers may optionally\n");
printf(" follow certain switches. Do not leave any space between a ");
printf("switch\n");
printf(" and its numeric parameter. \'input_file\' contains input data\n");
printf(" depending on the switches you supplied which may be a ");
printf(" piecewise\n");
printf(" linear complex or a list of nodes. File formats and detailed\n");
printf(" description of command line switches are found in user's ");
printf("manual.\n");
printf("\n");
syntax();
printf("\n");
printf("Examples of How to Use TetGen:\n");
printf("\n");
printf(" \'tetgen object\' reads vertices from object.node, and writes ");
printf("their\n Delaunay tetrahedralization to object.1.node, ");
printf("object.1.ele\n (tetrahedra), and object.1.face");
printf(" (convex hull faces).\n");
printf("\n");
printf(" \'tetgen -p object\' reads a PLC from object.poly or object.");
printf("smesh (and\n possibly object.node) and writes its constrained ");
printf("Delaunay\n tetrahedralization to object.1.node, object.1.ele, ");
printf("object.1.face,\n");
printf(" (boundary faces) and object.1.edge (boundary edges).\n");
printf("\n");
printf(" \'tetgen -pq1.414a.1 object\' reads a PLC from object.poly or\n");
printf(" object.smesh (and possibly object.node), generates a mesh ");
printf("whose\n tetrahedra have radius-edge ratio smaller than 1.414 and ");
printf("have volume\n of 0.1 or less, and writes the mesh to ");
printf("object.1.node, object.1.ele,\n object.1.face, and object.1.edge\n");
printf("\n");
printf("Please send bugs/comments to Hang Si <si@wias-berlin.de>\n");
terminatetetgen(NULL, 0);
} | pushq %rax
leaq 0x632f8(%rip), %rdi # 0x778cc
callq 0x8320
leaq 0x5f21e(%rip), %rdi # 0x737fe
xorl %eax, %eax
callq 0x8050
leaq 0x632e5(%rip), %rdi # 0x778d3
callq 0x8320
leaq 0x632e6(%rip), %rdi # 0x778e0
callq 0x8320
leaq 0x632e6(%rip), %rdi # 0x778ec
callq 0x8320
movl $0xa, %edi
callq 0x82a0
leaq 0x632dd(%rip), %rdi # 0x778f9
callq 0x8320
movl $0xa, %edi
callq 0x82a0
leaq 0x632e1(%rip), %rdi # 0x77913
callq 0x8320
movl $0xa, %edi
callq 0x82a0
leaq 0x632df(%rip), %rdi # 0x77927
callq 0x8320
leaq 0x63310(%rip), %rdi # 0x77964
callq 0x8320
movl $0xa, %edi
callq 0x82a0
leaq 0x6333a(%rip), %rdi # 0x779a4
callq 0x8320
movl $0xa, %edi
callq 0x82a0
leaq 0x5f1b4(%rip), %rdi # 0x73834
xorl %eax, %eax
callq 0x8050
leaq 0x6332b(%rip), %rdi # 0x779b9
callq 0x8320
leaq 0x63325(%rip), %rdi # 0x779bf
callq 0x8320
leaq 0x5f1d1(%rip), %rdi # 0x73877
xorl %eax, %eax
callq 0x8050
leaq 0x6334c(%rip), %rdi # 0x77a00
callq 0x8320
leaq 0x63347(%rip), %rdi # 0x77a07
callq 0x8320
leaq 0x5f1e9(%rip), %rdi # 0x738b5
xorl %eax, %eax
callq 0x8050
leaq 0x6336c(%rip), %rdi # 0x77a46
callq 0x8320
leaq 0x6336c(%rip), %rdi # 0x77a52
callq 0x8320
leaq 0x5f1fc(%rip), %rdi # 0x738ee
xorl %eax, %eax
callq 0x8050
leaq 0x63392(%rip), %rdi # 0x77a92
callq 0x8320
movl $0xa, %edi
callq 0x82a0
callq 0x14426
movl $0xa, %edi
callq 0x82a0
leaq 0x63375(%rip), %rdi # 0x77a9a
callq 0x8320
movl $0xa, %edi
callq 0x82a0
leaq 0x5f1ef(%rip), %rdi # 0x7392a
xorl %eax, %eax
callq 0x8050
leaq 0x5f220(%rip), %rdi # 0x73969
xorl %eax, %eax
callq 0x8050
leaq 0x5f249(%rip), %rdi # 0x739a0
xorl %eax, %eax
callq 0x8050
leaq 0x63354(%rip), %rdi # 0x77ab9
callq 0x8320
movl $0xa, %edi
callq 0x82a0
leaq 0x5f254(%rip), %rdi # 0x739cf
xorl %eax, %eax
callq 0x8050
leaq 0x5f283(%rip), %rdi # 0x73a0c
xorl %eax, %eax
callq 0x8050
leaq 0x5f2b4(%rip), %rdi # 0x73a4b
xorl %eax, %eax
callq 0x8050
leaq 0x6332a(%rip), %rdi # 0x77acf
callq 0x8320
leaq 0x6332d(%rip), %rdi # 0x77ade
callq 0x8320
movl $0xa, %edi
callq 0x82a0
leaq 0x6334e(%rip), %rdi # 0x77b15
callq 0x8320
leaq 0x5f2b7(%rip), %rdi # 0x73a8a
xorl %eax, %eax
callq 0x8050
leaq 0x5f2e6(%rip), %rdi # 0x73ac7
xorl %eax, %eax
callq 0x8050
leaq 0x5f31a(%rip), %rdi # 0x73b09
xorl %eax, %eax
callq 0x8050
leaq 0x63356(%rip), %rdi # 0x77b53
callq 0x8320
movl $0xa, %edi
callq 0x82a0
leaq 0x63380(%rip), %rdi # 0x77b93
callq 0x8320
movl $0x4, %edi
callq 0x80d0
movl $0x0, (%rax)
movq 0x6b781(%rip), %rsi # 0x7ffb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x8350
nop
| /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenmesh::memorypool::traverse() | void* tetgenmesh::memorypool::traverse()
{
void *newitem;
uintptr_t alignptr;
// Stop upon exhausting the list of items.
if (pathitem == nextitem) {
return (void *) NULL;
}
// Check whether any untraversed items remain in the current block.
if (pathitemsleft == 0) {
// Find the next block.
pathblock = (void **) *pathblock;
// Find the first item in the block. Increment by the size of (void *).
alignptr = (uintptr_t) (pathblock + 1);
// Align with item on an `alignbytes'-byte boundary.
pathitem = (void *)
(alignptr + (uintptr_t) alignbytes -
(alignptr % (uintptr_t) alignbytes));
// Set the number of items left in the current block.
pathitemsleft = itemsperblock;
}
newitem = pathitem;
// Find the next item in the block.
pathitem = (void *) ((uintptr_t) pathitem + itembytes);
pathitemsleft--;
return newitem;
} | movq 0x28(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
je 0x163c9
movl 0x54(%rdi), %eax
testl %eax, %eax
jne 0x163b7
movq 0x20(%rdi), %rax
movq (%rax), %rax
movq %rax, 0x20(%rdi)
movslq 0x30(%rdi), %rsi
leaq (%rsi,%rax), %rcx
addq $0x8, %rcx
addq $0x8, %rax
xorl %edx, %edx
divq %rsi
subq %rdx, %rcx
movl 0x3c(%rdi), %eax
movslq 0x34(%rdi), %rdx
addq %rcx, %rdx
movq %rdx, 0x28(%rdi)
decl %eax
movl %eax, 0x54(%rdi)
jmp 0x163cb
xorl %ecx, %ecx
movq %rcx, %rax
retq
nop
| /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenmesh::incircle3d(double*, double*, double*, double*) | REAL tetgenmesh::incircle3d(point pa, point pb, point pc, point pd)
{
REAL area2[2], n1[3], n2[3], c[3];
REAL sign, r, d;
// Calculate the areas of the two triangles [a, b, c] and [b, a, d].
facenormal(pa, pb, pc, n1, 1, NULL);
area2[0] = dot(n1, n1);
facenormal(pb, pa, pd, n2, 1, NULL);
area2[1] = dot(n2, n2);
if (area2[0] > area2[1]) {
// Choose [a, b, c] as the base triangle.
circumsphere(pa, pb, pc, NULL, c, &r);
d = distance(c, pd);
} else {
// Choose [b, a, d] as the base triangle.
if (area2[1] > 0) {
circumsphere(pb, pa, pd, NULL, c, &r);
d = distance(c, pc);
} else {
// The four points are collinear. This case only happens on the boundary.
return 0; // Return "not inside".
}
}
sign = d - r;
if (fabs(sign) / r < b->epsilon) {
sign = 0;
}
return sign;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x18(%rsp)
xorl %ebx, %ebx
movq %rbx, (%rsp)
leaq 0x90(%rsp), %rbp
movq %rbp, %r8
movl $0x1, %r9d
callq 0x183c8
movaps (%rbp), %xmm0
movaps %xmm0, 0x30(%rsp)
movups 0x8(%rbp), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x10(%rbp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq %rbx, (%rsp)
leaq 0x70(%rsp), %rbp
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %rbp, %r8
movl $0x1, %r9d
callq 0x183c8
movapd 0x20(%rsp), %xmm0
movhpd 0x8(%rbp), %xmm0 # xmm0 = xmm0[0],mem[0]
mulpd %xmm0, %xmm0
movapd %xmm0, %xmm1
movapd 0x30(%rsp), %xmm0
movhpd (%rbp), %xmm0 # xmm0 = xmm0[0],mem[0]
mulpd %xmm0, %xmm0
addpd %xmm1, %xmm0
movapd %xmm0, %xmm1
movapd 0x40(%rsp), %xmm0
movhpd 0x10(%rbp), %xmm0 # xmm0 = xmm0[0],mem[0]
mulpd %xmm0, %xmm0
addpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
ucomisd %xmm1, %xmm0
jbe 0x1918e
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x50(%rsp), %rbp
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
movq %rbp, %r9
callq 0x1923c
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
subsd (%rbp), %xmm0
subsd 0x8(%rbp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
jmp 0x191e2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x1922a
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x50(%rsp), %rbp
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rbp, %r9
callq 0x1923c
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
subsd (%rbp), %xmm0
subsd 0x8(%rbp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq %r15, %r14
movsd 0x10(%r14), %xmm1
subsd 0x60(%rsp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm1
movsd 0x10(%rsp), %xmm2
subsd %xmm2, %xmm1
movapd 0x59564(%rip), %xmm0 # 0x72770
andpd %xmm1, %xmm0
divsd %xmm2, %xmm0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpltsd 0x140(%rax), %xmm0
andnpd %xmm1, %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenmesh::orthosphere(double*, double*, double*, double*, double, double, double, double, double*, double*) | bool tetgenmesh::orthosphere(REAL* pa, REAL* pb, REAL* pc, REAL* pd,
REAL aheight, REAL bheight, REAL cheight,
REAL dheight, REAL* orthocent, REAL* radius)
{
REAL A[4][4], rhs[4], D;
int indx[4];
// Set the coefficient matrix A (4 x 4).
A[0][0] = 1.0; A[0][1] = pa[0]; A[0][2] = pa[1]; A[0][3] = pa[2];
A[1][0] = 1.0; A[1][1] = pb[0]; A[1][2] = pb[1]; A[1][3] = pb[2];
A[2][0] = 1.0; A[2][1] = pc[0]; A[2][2] = pc[1]; A[2][3] = pc[2];
A[3][0] = 1.0; A[3][1] = pd[0]; A[3][2] = pd[1]; A[3][3] = pd[2];
// Set the right hand side vector (4 x 1).
rhs[0] = 0.5 * aheight;
rhs[1] = 0.5 * bheight;
rhs[2] = 0.5 * cheight;
rhs[3] = 0.5 * dheight;
// Solve the 4 by 4 equations use LU decomposition with partial pivoting
// and backward and forward substitute..
if (!lu_decmp(A, 4, indx, &D, 0)) {
if (radius != (REAL *) NULL) *radius = 0.0;
return false;
}
lu_solve(A, 4, indx, rhs, 0);
if (orthocent != (REAL *) NULL) {
orthocent[0] = rhs[1];
orthocent[1] = rhs[2];
orthocent[2] = rhs[3];
}
if (radius != (REAL *) NULL) {
// rhs[0] = - rheight / 2;
// rheight = - 2 * rhs[0];
// = r[0]^2 + r[1]^2 + r[2]^2 - radius^2
// radius^2 = r[0]^2 + r[1]^2 + r[2]^2 -rheight
// = r[0]^2 + r[1]^2 + r[2]^2 + 2 * rhs[0]
*radius = sqrt(rhs[1] * rhs[1] + rhs[2] * rhs[2] + rhs[3] * rhs[3]
+ 2.0 * rhs[0]);
}
return true;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %r9, %rbx
movq %rsi, %rax
movq 0xe0(%rsp), %r14
movabsq $0x3ff0000000000000, %rdi # imm = 0x3FF0000000000000
leaq 0x40(%rsp), %rsi
movq %rdi, (%rsi)
movups (%rax), %xmm4
movups %xmm4, 0x8(%rsi)
movsd 0x10(%rax), %xmm4
movsd %xmm4, 0x18(%rsi)
movq %rdi, 0x20(%rsi)
movups (%rdx), %xmm4
movups %xmm4, 0x28(%rsi)
movsd 0x10(%rdx), %xmm4
movsd %xmm4, 0x38(%rsi)
movq %rdi, 0x40(%rsi)
movups (%rcx), %xmm4
movups %xmm4, 0x48(%rsi)
movsd 0x10(%rcx), %xmm4
movsd %xmm4, 0x58(%rsi)
movq %rdi, 0x60(%rsi)
movups (%r8), %xmm4
movups %xmm4, 0x68(%rsi)
movsd 0x10(%r8), %xmm4
movsd %xmm4, 0x78(%rsi)
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movapd 0x58541(%rip), %xmm1 # 0x72780
mulpd %xmm1, %xmm0
movapd %xmm0, (%rsp)
unpcklpd %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0]
mulpd %xmm1, %xmm2
movapd %xmm2, 0x10(%rsp)
leaq 0x20(%rsp), %rcx
leaq 0x38(%rsp), %r8
movl $0x4, %edx
xorl %r9d, %r9d
callq 0x18cce
movl %eax, %ebp
testb %al, %al
je 0x1a2ed
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movl $0x4, %edx
xorl %r9d, %r9d
callq 0x18f08
testq %rbx, %rbx
je 0x1a2a5
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rbx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
testq %r14, %r14
je 0x1a302
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
movsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
addsd %xmm0, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1a2f8
sqrtsd %xmm0, %xmm0
jmp 0x1a2fd
xorpd %xmm0, %xmm0
testq %r14, %r14
jne 0x1a2fd
jmp 0x1a302
callq 0x8150
movsd %xmm0, (%r14)
movl %ebp, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenmesh::finddirection(tetgenmesh::triface*, double*) | enum tetgenmesh::interresult
tetgenmesh::finddirection(triface* searchtet, point endpt)
{
triface neightet;
point pa, pb, pc, pd;
enum {HMOVE, RMOVE, LMOVE} nextmove;
REAL hori, rori, lori;
int t1ver;
int s;
// The origin is fixed.
pa = org(*searchtet);
if ((point) searchtet->tet[7] == dummypoint) {
// A hull tet. Choose the neighbor of its base face.
decode(searchtet->tet[3], *searchtet);
// Reset the origin to be pa.
if ((point) searchtet->tet[4] == pa) {
searchtet->ver = 11;
} else if ((point) searchtet->tet[5] == pa) {
searchtet->ver = 3;
} else if ((point) searchtet->tet[6] == pa) {
searchtet->ver = 7;
} else {
searchtet->ver = 0;
}
}
pb = dest(*searchtet);
// Check whether the destination or apex is 'endpt'.
if (pb == endpt) {
// pa->pb is the search edge.
return ACROSSVERT;
}
pc = apex(*searchtet);
if (pc == endpt) {
// pa->pc is the search edge.
eprevesymself(*searchtet);
return ACROSSVERT;
}
// Walk through tets around pa until the right one is found.
while (1) {
pd = oppo(*searchtet);
// Check whether the opposite vertex is 'endpt'.
if (pd == endpt) {
// pa->pd is the search edge.
esymself(*searchtet);
enextself(*searchtet);
return ACROSSVERT;
}
// Check if we have entered outside of the domain.
if (pd == dummypoint) {
// This is possible when the mesh is non-convex.
if (nonconvex) {
return ACROSSFACE; // return ACROSSSUB; // Hit a bounday.
} else {
terminatetetgen(this, 2);
}
}
// Now assume that the base face abc coincides with the horizon plane,
// and d lies above the horizon. The search point 'endpt' may lie
// above or below the horizon. We test the orientations of 'endpt'
// with respect to three planes: abc (horizon), bad (right plane),
// and acd (left plane).
hori = orient3d(pa, pb, pc, endpt);
rori = orient3d(pb, pa, pd, endpt);
lori = orient3d(pa, pc, pd, endpt);
// Now decide the tet to move. It is possible there are more than one
// tets are viable moves. Is so, randomly choose one.
if (hori > 0) {
if (rori > 0) {
if (lori > 0) {
// Any of the three neighbors is a viable move.
s = randomnation(3);
if (s == 0) {
nextmove = HMOVE;
} else if (s == 1) {
nextmove = RMOVE;
} else {
nextmove = LMOVE;
}
} else {
// Two tets, below horizon and below right, are viable.
if (randomnation(2)) {
nextmove = HMOVE;
} else {
nextmove = RMOVE;
}
}
} else {
if (lori > 0) {
// Two tets, below horizon and below left, are viable.
if (randomnation(2)) {
nextmove = HMOVE;
} else {
nextmove = LMOVE;
}
} else {
// The tet below horizon is chosen.
nextmove = HMOVE;
}
}
} else {
if (rori > 0) {
if (lori > 0) {
// Two tets, below right and below left, are viable.
if (randomnation(2)) {
nextmove = RMOVE;
} else {
nextmove = LMOVE;
}
} else {
// The tet below right is chosen.
nextmove = RMOVE;
}
} else {
if (lori > 0) {
// The tet below left is chosen.
nextmove = LMOVE;
} else {
// 'endpt' lies either on the plane(s) or across face bcd.
if (hori == 0) {
if (rori == 0) {
// pa->'endpt' is COLLINEAR with pa->pb.
return ACROSSVERT;
}
if (lori == 0) {
// pa->'endpt' is COLLINEAR with pa->pc.
eprevesymself(*searchtet); // [a,c,d]
return ACROSSVERT;
}
// pa->'endpt' crosses the edge pb->pc.
return ACROSSEDGE;
}
if (rori == 0) {
if (lori == 0) {
// pa->'endpt' is COLLINEAR with pa->pd.
esymself(*searchtet); // face bad.
enextself(*searchtet); // face [a,d,b]
return ACROSSVERT;
}
// pa->'endpt' crosses the edge pb->pd.
esymself(*searchtet); // face bad.
enextself(*searchtet); // face adb
return ACROSSEDGE;
}
if (lori == 0) {
// pa->'endpt' crosses the edge pc->pd.
eprevesymself(*searchtet); // [a,c,d]
return ACROSSEDGE;
}
// pa->'endpt' crosses the face bcd.
return ACROSSFACE;
}
}
}
// Move to the next tet, fix pa as its origin.
if (nextmove == RMOVE) {
fnextself(*searchtet);
} else if (nextmove == LMOVE) {
eprevself(*searchtet);
fnextself(*searchtet);
enextself(*searchtet);
} else { // HMOVE
fsymself(*searchtet);
enextself(*searchtet);
}
pb = dest(*searchtet);
pc = apex(*searchtet);
} // while (1)
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq (%rsi), %rsi
movslq 0x8(%rbx), %rcx
leaq 0x56354(%rip), %rdx # 0x80270
movslq (%rdx,%rcx,4), %rdx
movq (%rsi,%rdx,8), %r13
movq 0x38(%rsi), %rdx
movq %rdi, (%rsp)
cmpq 0x118(%rdi), %rdx
jne 0x29f6b
movq 0x18(%rsi), %rsi
andq $-0x10, %rsi
movq %rsi, (%rbx)
cmpq %r13, 0x20(%rsi)
je 0x29f5c
cmpq %r13, 0x28(%rsi)
je 0x29f63
xorl %edx, %edx
cmpq %r13, 0x30(%rsi)
movl $0x7, %ecx
cmovnel %edx, %ecx
jmp 0x29f68
movl $0xb, %ecx
jmp 0x29f68
movl $0x3, %ecx
movl %ecx, 0x8(%rbx)
movslq %ecx, %rcx
leaq 0x5632b(%rip), %rax # 0x802a0
movslq (%rax,%rcx,4), %rdx
movq (%rsi,%rdx,8), %rbp
movl $0x7, %eax
cmpq %r12, %rbp
je 0x2a282
leaq 0x5633e(%rip), %rax # 0x802d0
movslq (%rax,%rcx,4), %rdx
movq (%rsi,%rdx,8), %r14
cmpq %r12, %r14
je 0x2a270
leaq 0x56356(%rip), %rax # 0x80300
movslq (%rax,%rcx,4), %rdx
movq (%rsi,%rdx,8), %r15
cmpq %r12, %r15
je 0x2a256
movq (%rsp), %rax
cmpq 0x118(%rax), %r15
je 0x2a291
movq %r13, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x60eb8
movsd %xmm0, 0x10(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x60eb8
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x60eb8
movsd 0x10(%rsp), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x2a098
movsd 0x8(%rsp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x2a0f7
movq (%rsp), %rsi
imulq $0x556, 0x1a0(%rsi), %rcx # imm = 0x556
addq $0x24d69, %rcx # imm = 0x24D69
movq %rcx, %rax
movabsq $0x5dfc995681872319, %rdx # imm = 0x5DFC995681872319
mulq %rdx
shrq $0x12, %rdx
imulq $0xae529, %rdx, %rax # imm = 0xAE529
subq %rax, %rcx
ucomisd %xmm1, %xmm0
movq %rcx, 0x1a0(%rsi)
jbe 0x2a19b
movl %ecx, %eax
movl $0xaaaaaaab, %edx # imm = 0xAAAAAAAB
imulq %rdx, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %eax
subl %eax, %ecx
je 0x2a1dd
cmpl $0x1, %ecx
je 0x2a1a0
jmp 0x2a150
movsd 0x8(%rsp), %xmm3
ucomisd %xmm1, %xmm3
jbe 0x2a146
ucomisd %xmm1, %xmm0
jbe 0x2a1a0
movq (%rsp), %rsi
imulq $0x556, 0x1a0(%rsi), %rcx # imm = 0x556
addq $0x24d69, %rcx # imm = 0x24D69
movq %rcx, %rax
movabsq $0x5dfc995681872319, %rdx # imm = 0x5DFC995681872319
mulq %rdx
shrq $0x12, %rdx
imulq $0xae529, %rdx, %rax # imm = 0xAE529
subq %rax, %rcx
movq %rcx, 0x1a0(%rsi)
testb $0x1, %cl
je 0x2a150
jmp 0x2a1a0
ucomisd %xmm1, %xmm0
jbe 0x2a1dd
movq (%rsp), %rsi
imulq $0x556, 0x1a0(%rsi), %rcx # imm = 0x556
addq $0x24d69, %rcx # imm = 0x24D69
movq %rcx, %rax
movabsq $0x5dfc995681872319, %rdx # imm = 0x5DFC995681872319
mulq %rdx
shrq $0x12, %rdx
imulq $0xae529, %rdx, %rax # imm = 0xAE529
subq %rax, %rcx
movq %rcx, 0x1a0(%rsi)
testb $0x1, %cl
je 0x2a150
jmp 0x2a1dd
ucomisd %xmm1, %xmm0
jbe 0x2a2c4
movslq 0x8(%rbx), %rax
leaq 0x56565(%rip), %rcx # 0x806c0
movslq (%rcx,%rax,4), %rcx
movl %ecx, 0x8(%rbx)
movq (%rbx), %rax
leaq 0x56884(%rip), %rdx # 0x809f0
movslq (%rdx,%rcx,4), %rdx
movq (%rax,%rdx,8), %rax
movl %eax, %edx
andl $0xf, %edx
movl %edx, 0x8(%rbx)
andq $-0x10, %rax
movq %rax, (%rbx)
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq 0x5688e(%rip), %rsi # 0x80a20
addq %rsi, %rcx
movslq (%rcx,%rdx,4), %rcx
jmp 0x2a210
testb $0x1, %cl
jne 0x2a1dd
movslq 0x8(%rbx), %rcx
movq (%rbx), %rax
leaq 0x56842(%rip), %rdx # 0x809f0
movslq (%rdx,%rcx,4), %rdx
movq (%rax,%rdx,8), %rax
movl %eax, %edx
andl $0xf, %edx
movl %edx, 0x8(%rbx)
andq $-0x10, %rax
movq %rax, (%rbx)
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq 0x5684c(%rip), %rsi # 0x80a20
addq %rsi, %rcx
leaq (%rcx,%rdx,4), %rcx
jmp 0x2a21e
movslq 0x8(%rbx), %rax
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rdx
andl $0x3, %eax
movq (%rcx,%rax,8), %rax
movl %eax, %ecx
andl $0xf, %ecx
movl %ecx, 0x8(%rbx)
andq $-0x10, %rax
movq %rax, (%rbx)
shlq $0x4, %rdx
leaq 0x565a7(%rip), %rsi # 0x807b0
addq %rsi, %rdx
movslq (%rdx,%rcx,4), %rcx
movl %ecx, 0x8(%rbx)
leaq 0x56476(%rip), %rdx # 0x80690
leaq (%rdx,%rcx,4), %rcx
movslq (%rcx), %rcx
movl %ecx, 0x8(%rbx)
leaq 0x56075(%rip), %rdx # 0x802a0
movslq (%rdx,%rcx,4), %rdx
movq (%rax,%rdx,8), %rbp
leaq 0x56096(%rip), %rdx # 0x802d0
movslq (%rdx,%rcx,4), %rdx
movq (%rax,%rdx,8), %r14
leaq 0x560b7(%rip), %rdx # 0x80300
movslq (%rdx,%rcx,4), %rdx
movq (%rax,%rdx,8), %r15
jmp 0x29fb2
leaq 0x55fe3(%rip), %rax # 0x80240
movslq (%rax,%rcx,4), %rax
movl %eax, 0x8(%rbx)
leaq 0x56425(%rip), %rcx # 0x80690
movl (%rcx,%rax,4), %eax
jmp 0x2a27a
leaq 0x564a9(%rip), %rax # 0x80720
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rbx)
movl $0x7, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x9, %eax
movq (%rsp), %rcx
cmpl $0x0, 0x188(%rcx)
jne 0x2a282
movl $0x4, %edi
callq 0x80d0
movl $0x2, (%rax)
movq 0x55cf6(%rip), %rsi # 0x7ffb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x8350
ucomisd %xmm1, %xmm2
jne 0x2a2f4
jp 0x2a2f4
ucomisd %xmm1, %xmm3
jne 0x2a2d4
jnp 0x2a27d
ucomisd %xmm1, %xmm0
movl $0x7, %eax
jne 0x2a346
jp 0x2a346
movslq 0x8(%rbx), %rdx
leaq 0x56434(%rip), %rcx # 0x80720
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x8(%rbx)
jmp 0x2a282
ucomisd %xmm1, %xmm3
jne 0x2a32d
jp 0x2a32d
cmpeqsd %xmm1, %xmm0
movq %xmm0, %rax
movslq 0x8(%rbx), %rdx
leaq 0x55f2f(%rip), %rcx # 0x80240
movslq (%rcx,%rdx,4), %rcx
movl %ecx, 0x8(%rbx)
leaq 0x56371(%rip), %rdx # 0x80690
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x8(%rbx)
addl $0x8, %eax
jmp 0x2a282
ucomisd %xmm1, %xmm0
jne 0x2a350
jp 0x2a350
movslq 0x8(%rbx), %rax
leaq 0x563e0(%rip), %rcx # 0x80720
movl (%rcx,%rax,4), %eax
movl %eax, 0x8(%rbx)
movl $0x8, %eax
jmp 0x2a282
movl $0x9, %eax
jmp 0x2a282
| /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
tetgenmesh::hilbert_split(double**, int, int, int, double, double, double, double, double, double) | int tetgenmesh::hilbert_split(point* vertexarray,int arraysize,int gc0,int gc1,
REAL bxmin, REAL bxmax, REAL bymin, REAL bymax,
REAL bzmin, REAL bzmax)
{
point swapvert;
int axis, d;
REAL split;
int i, j;
// Find the current splitting axis. 'axis' is a value 0, or 1, or 2, which
// correspoding to x-, or y- or z-axis.
axis = (gc0 ^ gc1) >> 1;
// Calulate the split position along the axis.
if (axis == 0) {
split = 0.5 * (bxmin + bxmax);
} else if (axis == 1) {
split = 0.5 * (bymin + bymax);
} else { // == 2
split = 0.5 * (bzmin + bzmax);
}
// Find the direction (+1 or -1) of the axis. If 'd' is +1, the direction
// of the axis is to the positive of the axis, otherwise, it is -1.
d = ((gc0 & (1<<axis)) == 0) ? 1 : -1;
// Partition the vertices into left- and right-arrays such that left points
// have Hilbert indices lower than the right points.
i = 0;
j = arraysize - 1;
// Partition the vertices into left- and right-arrays.
if (d > 0) {
do {
for (; i < arraysize; i++) {
if (vertexarray[i][axis] >= split) break;
}
for (; j >= 0; j--) {
if (vertexarray[j][axis] < split) break;
}
// Is the partition finished?
if (i == (j + 1)) break;
// Swap i-th and j-th vertices.
swapvert = vertexarray[i];
vertexarray[i] = vertexarray[j];
vertexarray[j] = swapvert;
// Continue patitioning the array;
} while (true);
} else {
do {
for (; i < arraysize; i++) {
if (vertexarray[i][axis] <= split) break;
}
for (; j >= 0; j--) {
if (vertexarray[j][axis] > split) break;
}
// Is the partition finished?
if (i == (j + 1)) break;
// Swap i-th and j-th vertices.
swapvert = vertexarray[i];
vertexarray[i] = vertexarray[j];
vertexarray[j] = swapvert;
// Continue patitioning the array;
} while (true);
}
return i;
} | pushq %rbx
xorl %ecx, %r8d
movl %r8d, %eax
sarl %eax
cmpl $0x1, %r8d
ja 0x2a879
addsd %xmm1, %xmm0
jmp 0x2a890
cmpl $0x1, %eax
jne 0x2a888
addsd %xmm3, %xmm2
movapd %xmm2, %xmm0
jmp 0x2a890
addsd %xmm5, %xmm4
movapd %xmm4, %xmm0
mulsd 0x47798(%rip), %xmm0 # 0x72030
leal -0x1(%rdx), %r8d
btl %eax, %ecx
movslq %eax, %rcx
movslq %edx, %rdi
jae 0x2a926
xorl %eax, %eax
cmpl %edx, %eax
jge 0x2a8d7
movslq %eax, %r10
leaq (%rsi,%r10,8), %r9
movq %rdi, %r11
subq %r10, %r11
xorl %r10d, %r10d
movq (%r9,%r10,8), %rbx
ucomisd (%rbx,%rcx,8), %xmm0
jae 0x2a8d4
incq %r10
cmpq %r10, %r11
jne 0x2a8bd
movl %edx, %eax
jmp 0x2a8d7
addl %r10d, %eax
testl %r8d, %r8d
js 0x2a901
movl %r8d, %r8d
movq (%rsi,%r8,8), %r9
movsd (%r9,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x2a901
leaq -0x1(%r8), %r9
testq %r8, %r8
movq %r9, %r8
jg 0x2a8df
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
leal 0x1(%r8), %r9d
cmpl %r9d, %eax
je 0x2a9a1
movslq %eax, %r9
movq (%rsi,%r9,8), %r10
movslq %r8d, %r11
movq (%rsi,%r11,8), %rbx
movq %rbx, (%rsi,%r9,8)
movq %r10, (%rsi,%r11,8)
jmp 0x2a8a9
xorl %eax, %eax
cmpl %edx, %eax
jge 0x2a95a
movslq %eax, %r10
leaq (%rsi,%r10,8), %r9
movq %rdi, %r11
subq %r10, %r11
xorl %r10d, %r10d
movq (%r9,%r10,8), %rbx
movsd (%rbx,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jae 0x2a957
incq %r10
cmpq %r10, %r11
jne 0x2a93c
movl %edx, %eax
jmp 0x2a95a
addl %r10d, %eax
testl %r8d, %r8d
js 0x2a980
movl %r8d, %r8d
movq (%rsi,%r8,8), %r9
ucomisd (%r9,%rcx,8), %xmm0
ja 0x2a980
leaq -0x1(%r8), %r9
testq %r8, %r8
movq %r9, %r8
jg 0x2a962
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
leal 0x1(%r8), %r9d
cmpl %r9d, %eax
je 0x2a9a1
movslq %eax, %r9
movq (%rsi,%r9,8), %r10
movslq %r8d, %r11
movq (%rsi,%r11,8), %rbx
movq %rbx, (%rsi,%r9,8)
movq %r10, (%rsi,%r11,8)
jmp 0x2a928
popq %rbx
retq
nop
| /AhmedElbossily[P]Open-cell-Foam-Model-Generation-Using-3-D-Voronoi-diagram/tetgen/tetgen.cxx |
doctest::detail::MessageBuilder::log() | bool MessageBuilder::log() {
m_string = getTlsOssResult();
DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);
const bool isWarn = m_severity & assertType::is_warn;
// warn is just a message in this context so we don't treat it as an assert
if(!isWarn) {
addAssert(m_severity);
addFailedAssert(m_severity);
}
return isDebuggerActive() && !getContextOptions()->no_breaks && !isWarn &&
(g_cs->currentTest == nullptr || !g_cs->currentTest->m_no_breaks); // break into debugger
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x88c0
cmpb $0x0, 0x17(%rbx)
jns 0xb664
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb664
callq 0x65e0
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x2fe7d(%rip), %rax # 0x3b4f8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xb6a0
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
addq $0x8, %r14
jmp 0xb689
movl 0x24(%rbx), %ebp
testb $0x1, %bpl
jne 0xb701
movl $0xb8, %r14d
addq 0x2fe42(%rip), %r14 # 0x3b4f8
cmpb $0x0, %fs:-0x10
je 0xb740
movq %fs:-0x18, %rax
shlq $0x6, %rax
lock
incl (%r14,%rax)
testb $0x1, 0x24(%rbx)
jne 0xb701
movl $0x8b8, %ebx # imm = 0x8B8
addq 0x2fe13(%rip), %rbx # 0x3b4f8
cmpb $0x0, %fs:-0x10
je 0xb74a
movq %fs:-0x18, %rax
shlq $0x6, %rax
lock
incl (%rbx,%rax)
callq 0xa9d6
testb %al, %al
je 0xb72f
xorl %eax, %eax
testb $0x1, %bpl
jne 0xb731
movq 0x2fddf(%rip), %rcx # 0x3b4f8
cmpb $0x0, 0x79(%rcx)
jne 0xb731
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0xb73c
movb 0x39(%rax), %al
xorb $0x1, %al
jmp 0xb731
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0xb731
callq 0x6a4a
jmp 0xb6c1
callq 0x6a6c
jmp 0xb6f0
nop
| /taskflow[P]taskflow/3rd-party/doctest/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_case_skipped(doctest::TestCaseData const&) | void test_case_skipped(const TestCaseData& in) override {
if(opt.no_skipped_summary == false) {
test_case_start_impl(in);
xml.writeAttribute("skipped", "true");
xml.endElement();
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x78(%rdi), %rax
cmpb $0x0, 0x7f(%rax)
jne 0x157e3
movq %rdi, %rbx
callq 0x163b6
addq $0x8, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x17239(%rip), %rsi # 0x2c9da
leaq 0x17239(%rip), %rdx # 0x2c9e1
movq %rsp, %r14
movq %r14, %rdi
callq 0x26b5e
leaq 0x14dcc(%rip), %rdx # 0x2a586
movq %rbx, %rdi
movq %r14, %rsi
callq 0x160ec
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x157db
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x64c0
movq %rbx, %rdi
callq 0x15860
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x15806
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x64c0
movq %rbx, %rdi
callq 0x6860
| /taskflow[P]taskflow/3rd-party/doctest/doctest.h |
doctest::(anonymous namespace)::operator<<(std::ostream&, doctest::(anonymous namespace)::XmlEncode const&) | std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
xmlEncode.encodeTo( os );
return os;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x15ec8
movq %rsi, %r14
xorl %r15d, %r15d
leaq 0x159f8(%rip), %r13 # 0x2b68e
movq %rsp, %r12
leaq 0x159de(%rip), %rbp # 0x2b67e
movq (%r14), %rax
movb (%rax,%r15), %dl
addq %r15, %rax
movzbl %dl, %esi
cmpl $0x3b, %esi
jg 0x15cd0
cmpl $0x22, %esi
je 0x15d0d
cmpl $0x26, %esi
jne 0x15ce7
movl $0x5, %edx
movq %rbx, %rdi
leaq 0x159b8(%rip), %rsi # 0x2b683
jmp 0x15d57
cmpl $0x3e, %esi
je 0x15d21
cmpl $0x3c, %esi
jne 0x15ce7
movl $0x4, %edx
movq %rbx, %rdi
movq %rbp, %rsi
jmp 0x15d57
cmpb $0x9, %dl
jb 0x15d03
leal -0xe(%rdx), %edi
cmpb $0x12, %dil
setae %dil
cmpb $0x7f, %dl
setne %r8b
testb %dil, %r8b
jne 0x15d44
movq %rbx, %rdi
callq 0x15f23
jmp 0x15d5c
cmpl $0x1, 0x20(%r14)
jne 0x15d49
movl $0x6, %edx
movq %rbx, %rdi
movq %r13, %rsi
jmp 0x15d57
cmpq $0x3, %r15
jb 0x15d49
cmpb $0x5d, -0x1(%rax)
jne 0x15d49
cmpb $0x5d, -0x2(%rax)
jne 0x15d49
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x15947(%rip), %rsi # 0x2b689
jmp 0x15d57
cmpb $0x7e, %dl
ja 0x15d71
movb %dl, (%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6550
incq %r15
movq 0x8(%r14), %rcx
cmpq %rcx, %r15
jb 0x15ca0
jmp 0x15ec8
addb $0x8, %dl
cmpb $-0x39, %dl
jbe 0x15d03
movl %esi, %edi
andl $-0x20, %edi
cmpl $0xc0, %edi
je 0x15d9b
movl %esi, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x15da5
movl $0x3, %r13d
jmp 0x15da1
movl $0x2, %r13d
xorl %edx, %edx
jmp 0x15dbe
movl %esi, %edx
andl $-0x8, %edx
cmpl $0xf0, %edx
jne 0x15eda
movl $0x4, %r13d
movb $0x1, %dl
leaq (%r15,%r13), %r9
decq %r9
cmpq %rcx, %r9
jae 0x15eb4
movl $0x1f, %ecx
cmpl $0xc0, %edi
je 0x15e09
movl %esi, %r8d
andl $-0x10, %r8d
movl $0xf, %ecx
cmpl $0xe0, %r8d
je 0x15e09
movl %esi, %r8d
andl $-0x8, %r8d
movl $0x7, %ecx
cmpl $0xf0, %r8d
jne 0x15ef4
movq %r9, 0x10(%rsp)
andl %esi, %ecx
movb $0x1, %r9b
movl $0x1, %r10d
movl %ecx, %r8d
movzbl (%rax,%r10), %ecx
movl %ecx, %r11d
andl $-0x40, %r11d
cmpl $0x80, %r11d
sete %r11b
andb %r11b, %r9b
shll $0x6, %r8d
andl $0x3f, %ecx
orl %r8d, %ecx
incq %r10
cmpq %r10, %r13
jne 0x15e19
cmpl $0xc0, %edi
setne %al
cmpl $0x800, %r8d # imm = 0x800
setb %dil
testb %r9b, %r9b
je 0x15eb4
cmpl $0x80, %r8d
jb 0x15eb4
andb %dil, %al
jne 0x15eb4
addl $0xfffff7ff, %ecx # imm = 0xFFFFF7FF
cmpl $0xf7ff, %ecx # imm = 0xF7FF
setb %al
testb %al, %dl
jne 0x15eb4
cmpl $0x10ffff, %r8d # imm = 0x10FFFF
ja 0x15eb4
movq (%r14), %rax
movb (%rax,%r15), %al
movb %al, (%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6550
incq %r15
decq %r13
jne 0x15e8b
movq 0x10(%rsp), %r15
jmp 0x15ebc
movq %rbx, %rdi
callq 0x15f23
leaq 0x157cb(%rip), %r13 # 0x2b68e
jmp 0x15d5c
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x157b7(%rip), %rsi # 0x2b698
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x66b0
movq %rbx, %rdi
callq 0x15fd6
leaq 0x1579d(%rip), %rsi # 0x2b698
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x66b0
movq %rbx, %rdi
callq 0x15fd6
jmp 0x15f10
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6948
movq %rbx, %rdi
callq 0x6860
| /taskflow[P]taskflow/3rd-party/doctest/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::file_line_to_stream(char const*, int, char const*) | virtual void file_line_to_stream(const char* file, int line,
const char* tail = "") {
s << Color::LightGrey << skipPathFromFilename(file) << (opt.gnu_file_line ? ":" : "(")
<< (opt.no_line_numbers ? 0 : line) // 0 or the real num depending on the option
<< (opt.gnu_file_line ? ":" : "):") << tail;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq %r15, %rdi
movl $0x17, %esi
callq 0x8f2b
movq %r12, %rdi
callq 0x93b9
testq %rax, %rax
je 0x1ab16
movq %rax, %r12
movq %rax, %rdi
callq 0x61b0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x6550
jmp 0x1ab2e
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x67f0
movq 0x60(%r14), %rax
leaq 0x1092e(%rip), %r12 # 0x2b467
leaq 0x10dd5(%rip), %rsi # 0x2b915
cmpb $0x0, 0x7b(%rax)
cmovneq %r12, %rsi
movl $0x1, %edx
movq %r15, %rdi
callq 0x6550
movq 0x60(%r14), %rax
xorl %ecx, %ecx
cmpb $0x0, 0x7d(%rax)
cmovnel %ecx, %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x6830
movq %rax, %r15
movq 0x60(%r14), %rax
movzbl 0x7b(%rax), %eax
leaq 0x10d99(%rip), %rsi # 0x2b917
testq %rax, %rax
cmovneq %r12, %rsi
movl $0x2, %edx
subq %rax, %rdx
movq %r15, %rdi
callq 0x6550
testq %rbx, %rbx
je 0x1abb8
movq %rbx, %rdi
callq 0x61b0
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6550
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x67f0
| /taskflow[P]taskflow/3rd-party/doctest/doctest.h |
tf::NonblockingNotifierV2::commit_wait(tf::NonblockingNotifierV2::Waiter*) | void commit_wait(Waiter* w) {
#if __cplusplus >= TF_CPP20
w->state.store(Waiter::kNotSignaled, std::memory_order_relaxed);
#else
w->state = Waiter::kNotSignaled;
#endif
const uint64_t me = (w - &_waiters[0]) | w->epoch;
uint64_t state = _state.load(std::memory_order_seq_cst);
for (;;) {
//_check_state(state, true);
uint64_t newstate;
if ((state & kSignalMask) != 0) {
// Consume the signal and return immediately.
newstate = state - kWaiterInc - kSignalInc;
} else {
// Remove this thread from pre-wait counter and add to the waiter stack.
newstate = ((state & kWaiterMask) - kWaiterInc) | me;
w->next.store(state & (kStackMask | kEpochMask), std::memory_order_relaxed);
}
//_check_state(newstate);
if (_state.compare_exchange_weak(state, newstate, std::memory_order_acq_rel)) {
if ((state & kSignalMask) == 0) {
w->epoch += kEpochInc;
_park(w);
}
return;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x3fff0000000, %rdi # imm = 0x3FFF0000000
movl $0x0, 0x68(%rsi)
movq %rsi, %r12
subq 0x8(%r14), %r12
sarq $0x7, %r12
orq 0x8(%rsi), %r12
movq (%r14), %r15
movabsq $-0x3ffffffc001, %r13 # imm = 0xFFFFFC0000003FFF
testq %rdi, %r15
je 0x20faa
leaq -0x10004000(%r15), %rcx
jmp 0x20fc6
movl %r15d, %ecx
andl $0xfffc000, %ecx # imm = 0xFFFC000
addq $-0x4000, %rcx # imm = 0xC000
orq %r12, %rcx
movq %r15, %rax
andq %r13, %rax
movq %rax, (%rbx)
movq %r15, %rax
lock
cmpxchgq %rcx, (%r14)
sete %bpl
movq %rax, %r15
jne 0x20f9c
testq %rdi, %r15
jne 0x21002
movq 0x8(%rbx), %rax
addq %rdi, %rax
addq $0x10000000, %rax # imm = 0x10000000
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2119a
movabsq $0x3fff0000000, %rdi # imm = 0x3FFF0000000
testb %bpl, %bpl
je 0x20f9c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /taskflow[P]taskflow/taskflow/core/nonblocking_notifier.hpp |
tf::TFProfManager::TFProfManager() | inline TFProfManager::TFProfManager() :
_fpath {get_env(TF_ENABLE_PROFILER)} {
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa140(%rip), %rsi # 0x2b356
leaq 0xa14b(%rip), %rdx # 0x2b368
movq %rsp, %r14
movq %r14, %rdi
callq 0x26b5e
movq (%r14), %rdi
callq 0x65b0
testq %rax, %rax
leaq 0x942f(%rip), %r14 # 0x2a669
cmovneq %rax, %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x61b0
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26b5e
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x21272
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x64c0
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x212a8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x64c0
movq %rbx, %rdi
callq 0x6860
| /taskflow[P]taskflow/taskflow/core/observer.hpp |
tf::TFProfObserver::dump(std::ostream&) const | inline void TFProfObserver::dump(std::ostream& os) const {
using namespace std::chrono;
size_t first;
for(first = 0; first<_timeline.segments.size(); ++first) {
if(_timeline.segments[first].size() > 0) {
break;
}
}
// not timeline data to dump
if(first == _timeline.segments.size()) {
os << "{}\n";
return;
}
os << "{\"executor\":\"" << _timeline.uid << "\",\"data\":[";
bool comma = false;
for(size_t w=first; w<_timeline.segments.size(); w++) {
for(size_t l=0; l<_timeline.segments[w].size(); l++) {
if(_timeline.segments[w][l].empty()) {
continue;
}
if(comma) {
os << ',';
}
else {
comma = true;
}
os << "{\"worker\":" << w << ",\"level\":" << l << ",\"data\":[";
for(size_t i=0; i<_timeline.segments[w][l].size(); ++i) {
const auto& s = _timeline.segments[w][l][i];
if(i) os << ',';
// span
os << "{\"span\":["
<< duration_cast<microseconds>(s.beg - _timeline.origin).count()
<< ","
<< duration_cast<microseconds>(s.end - _timeline.origin).count()
<< "],";
// name
os << "\"name\":\"";
if(s.name.empty()) {
os << w << '_' << i;
}
else {
os << s.name;
}
os << "\",";
// e.g., category "type": "Condition Task"
os << "\"type\":\"" << to_string(s.type) << "\"";
os << "}";
}
os << "]}";
}
}
os << "]}\n";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %rbp
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rax
cmpq %rcx, %rdx
je 0x2168d
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
addq $0x8, %rcx
xorl %r15d, %r15d
movq (%rcx), %rsi
cmpq -0x8(%rcx), %rsi
jne 0x21690
incq %r15
addq $0x18, %rcx
cmpq %r15, %rdx
jne 0x21673
movq %rdx, %r15
jmp 0x21690
xorl %r15d, %r15d
cmpq %rax, %r15
jne 0x216a1
leaq 0x9d9b(%rip), %rsi # 0x2b437
jmp 0x21a59
leaq 0x9d93(%rip), %rsi # 0x2b43b
movl $0xd, %edx
movq %rbx, %rdi
callq 0x6550
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq 0x62e0
leaq 0x9d81(%rip), %rsi # 0x2b449
movl $0xa, %edx
movq %rax, %rdi
callq 0x6550
movq 0x20(%rbp), %rax
subq 0x18(%rbp), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
leaq 0x9d98(%rip), %rsi # 0x2b48e
cmpq %rax, %r15
jae 0x21a59
xorl %r14d, %r14d
movq %rbp, 0x30(%rsp)
movq 0x18(%rbp), %rcx
leaq (%r15,%r15,2), %rdx
movq (%rcx,%rdx,8), %rax
movq %rdx, 0x10(%rsp)
cmpq %rax, 0x8(%rcx,%rdx,8)
je 0x21a26
xorl %r12d, %r12d
movq %r15, 0x18(%rsp)
leaq (%r12,%r12,2), %rdx
movq (%rax,%rdx,8), %rcx
movq %rdx, 0x20(%rsp)
cmpq 0x8(%rax,%rdx,8), %rcx
je 0x219ee
movb $0x1, %al
testb $0x1, %r14b
je 0x21765
movb $0x2c, 0xd(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xd(%rsp), %rsi
callq 0x6550
movl %r14d, %eax
movb %al, 0xc(%rsp)
movl $0xa, %edx
movq %rbx, %rdi
leaq 0x9cdc(%rip), %rsi # 0x2b454
callq 0x6550
movq %rbx, %rdi
movq %r15, %rsi
callq 0x62e0
movq %rax, %r13
movl $0x9, %edx
movq %rax, %rdi
leaq 0x9cc5(%rip), %rsi # 0x2b45f
callq 0x6550
movq %r13, %rdi
movq %r12, 0x28(%rsp)
movq %r12, %rsi
callq 0x62e0
movl $0x9, %edx
movq %rax, %rdi
leaq 0x9c8c(%rip), %rsi # 0x2b44a
callq 0x6550
movq 0x18(%rbp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %r14
cmpq %r14, 0x8(%rax,%rcx,8)
je 0x219c6
movl $0x30, %r12d
xorl %r13d, %r13d
testq %r13, %r13
je 0x21809
movb $0x2c, 0xe(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xe(%rsp), %rsi
callq 0x6550
movl $0x9, %edx
movq %rbx, %rdi
leaq 0x9c51(%rip), %rsi # 0x2b469
callq 0x6550
movq -0x8(%r14,%r12), %rax
subq 0x10(%rbp), %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x7, %rdx
addq %rdx, %rsi
movq %rbx, %rdi
callq 0x6460
movq %rbp, %r15
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
leaq 0x9c22(%rip), %rsi # 0x2b480
callq 0x6550
movq (%r14,%r12), %rax
subq 0x10(%r15), %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x7, %rdx
addq %rdx, %rsi
movq %rbp, %rdi
callq 0x6460
movl $0x2, %edx
movq %rax, %rdi
leaq 0x9bd6(%rip), %rsi # 0x2b473
callq 0x6550
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x9bc5(%rip), %rsi # 0x2b476
callq 0x6550
movq -0x28(%r14,%r12), %rdx
testq %rdx, %rdx
je 0x218cf
movq -0x30(%r14,%r12), %rsi
movq %rbx, %rdi
callq 0x6550
jmp 0x218fe
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0x62e0
movb $0x5f, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0xf(%rsp), %rsi
callq 0x6550
movq %rax, %rdi
movq %r13, %rsi
callq 0x62e0
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x9b72(%rip), %rsi # 0x2b47f
callq 0x6550
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x9b61(%rip), %rsi # 0x2b482
callq 0x6550
movl -0x10(%r14,%r12), %eax
leaq 0x9b9a(%rip), %rbp # 0x2b4cc
cmpq $0x6, %rax
ja 0x21943
leaq 0x18ed1(%rip), %rcx # 0x3a810
movq (%rcx,%rax,8), %rbp
movq %rbp, %rdi
callq 0x61b0
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x6550
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x9fdd(%rip), %rsi # 0x2b945
callq 0x6550
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x9b10(%rip), %rsi # 0x2b48c
callq 0x6550
incq %r13
movq 0x30(%rsp), %rbp
movq 0x18(%rbp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %r14
movq 0x8(%rax,%rcx,8), %rax
subq %r14, %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rax
addq $0x38, %r12
cmpq %rax, %r13
jb 0x217ed
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x9ab6(%rip), %rsi # 0x2b48b
callq 0x6550
movb 0xc(%rsp), %sil
movl %esi, %r14d
movq 0x18(%rsp), %r15
movq 0x28(%rsp), %r12
jmp 0x219f1
movl %r14d, %esi
incq %r12
movq 0x18(%rbp), %rcx
movq 0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %rax
movq 0x8(%rcx,%rdx,8), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %rcx, %r12
jb 0x2172b
jmp 0x21a29
movl %r14d, %esi
incq %r15
movq 0x20(%rbp), %rax
subq 0x18(%rbp), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movl %esi, %r14d
cmpq %rax, %r15
jb 0x21707
leaq 0x9a35(%rip), %rsi # 0x2b48e
movl $0x3, %edx
movq %rbx, %rdi
callq 0x6550
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /taskflow[P]taskflow/taskflow/core/observer.hpp |
tf::TFProfObserver::summary(std::ostream&) const | inline void TFProfObserver::summary(std::ostream& os) const {
using namespace std::chrono;
Summary summary;
std::optional<observer_stamp_t> view_beg, view_end;
// find the first non-empty worker
size_t first;
for(first = 0; first<_timeline.segments.size(); ++first) {
if(_timeline.segments[first].size() > 0) {
break;
}
}
// not timeline data to dump
if(first == _timeline.segments.size()) {
goto end_of_summary;
}
for(size_t w=first; w<_timeline.segments.size(); w++) {
for(size_t l=0; l<_timeline.segments[w].size(); l++) {
if(_timeline.segments[w][l].empty()) {
continue;
}
// worker w at level l
WorkerSummary ws;
ws.id = w;
ws.level = l;
ws.count = _timeline.segments[w][l].size();
// scan all tasks at level l
for(size_t i=0; i<_timeline.segments[w][l].size(); ++i) {
// update the entire span
auto& s = _timeline.segments[w][l][i];
view_beg = view_beg ? (std::min)(*view_beg, s.beg) : s.beg;
view_end = view_end ? (std::max)(*view_end, s.end) : s.end;
// update the task summary
size_t t = duration_cast<microseconds>(s.end - s.beg).count();
auto& x = summary.tsum[static_cast<int>(s.type)];
x.count += 1;
x.total_span += t;
x.min_span = (x.count == 1) ? t : (std::min)(t, x.min_span);
x.max_span = (x.count == 1) ? t : (std::max)(t, x.max_span);
// update the worker summary
ws.total_span += t;
ws.min_span = (i == 0) ? t : (std::min)(t, ws.min_span);
ws.max_span = (i == 0) ? t : (std::max)(t, ws.max_span);
auto&y = ws.tsum[static_cast<int>(s.type)];
y.count += 1;
y.total_span += t;
y.min_span = (y.count == 1) ? t : (std::min)(t, y.min_span);
y.max_span = (y.count == 1) ? t : (std::max)(t, y.max_span);
// update the delay
//if(i) {
// size_t d = duration_cast<nanoseconds>(
// s.beg - _timeline.segments[w][l][i-1].end
// ).count();
// ws.total_delay += d;
// ws.min_delay = (i == 1) ? d : std::min(ws.min_delay, d);
// ws.max_delay = (i == 1) ? d : std::max(ws.max_delay, d);
//}
}
summary.wsum.push_back(ws);
}
}
end_of_summary:
size_t view = 0;
if(view_beg && view_end) {
view = duration_cast<microseconds>(*view_end - *view_beg).count();
}
os << "==Observer " << _timeline.uid << ": "
<< num_workers() << " workers completed "
<< num_tasks() << " tasks in "
<< view << " us\n";
summary.dump(os);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
xorps %xmm0, %xmm0
movups %xmm0, 0x160(%rsp,%rax)
addq $0x20, %rax
cmpq $0xe0, %rax
jne 0x21a92
xorps %xmm0, %xmm0
movups %xmm0, 0x240(%rsp)
movq $0x0, 0x250(%rsp)
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rax
cmpq %rcx, %rdx
je 0x21b0d
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
addq $0x8, %rcx
xorl %edi, %edi
movq (%rcx), %rsi
cmpq -0x8(%rcx), %rsi
jne 0x21b0f
incq %rdi
addq $0x18, %rcx
cmpq %rdi, %rdx
jne 0x21af3
movq %rdx, %rdi
jmp 0x21b0f
xorl %edi, %edi
cmpq %rax, %rdi
je 0x21ea3
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rax, %rdi
jae 0x21ea3
movq %rbx, 0x28(%rsp)
leaq 0x18(%rsp), %rax
movq (%rax), %rbp
leaq 0x20(%rsp), %rax
movq (%rax), %r15
movq %r14, %rdx
leaq 0x80(%rsp), %r14
movq $0x0, 0x10(%rsp)
leaq 0x38(%rsp), %r12
xorl %ebx, %ebx
movq %rdx, 0x8(%rsp)
movq 0x18(%rdx), %rax
movq %rdi, 0x30(%rsp)
leaq (%rdi,%rdi,2), %rcx
movq (%rax,%rcx,8), %rdx
cmpq %rdx, 0x8(%rax,%rcx,8)
je 0x21e2c
movq %rcx, 0x40(%rsp)
leaq (%rax,%rcx,8), %rcx
xorl %r8d, %r8d
movl %ebx, %eax
leaq (%r8,%r8,2), %rsi
movq (%rdx,%rsi,8), %rdi
cmpq 0x8(%rdx,%rsi,8), %rdi
movq %r8, 0x48(%rsp)
je 0x21d9b
leaq 0x60(%rsp), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdx)
movups %xmm0, (%rdx)
movl $0x30, %edx
movups %xmm0, 0x50(%rsp,%rdx)
addq $0x20, %rdx
cmpq $0x110, %rdx # imm = 0x110
jne 0x21bc6
movq 0x30(%rsp), %rdx
movq %rdx, 0x50(%rsp)
movq %r8, 0x58(%rsp)
movq (%rcx), %rdx
movq (%rdx,%rsi,8), %rcx
movq 0x8(%rdx,%rsi,8), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
movabsq $0x6db6db6db6db6db7, %rdi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdi, %rsi
movq %rsi, 0x60(%rsp)
cmpq %rcx, %rdx
je 0x21d9f
movq 0x68(%rsp), %rdi
cmpq $0x1, %rsi
adcq $0x0, %rsi
addq $0x30, %rcx
xorl %r8d, %r8d
leaq -0x8(%rcx), %rdx
movb $0x1, %bl
testb $0x1, 0x10(%rsp)
je 0x21c46
cmpq %r15, (%rdx)
jl 0x21c4e
leaq 0x20(%rsp), %rdx
jmp 0x21c4e
movb $0x1, %r9b
movq %r9, 0x10(%rsp)
movq (%rdx), %r15
movq %r15, 0x20(%rsp)
movq %rcx, %rdx
testb $0x1, %al
je 0x21c6c
movq %rcx, %rdx
cmpq (%rcx), %rbp
jl 0x21c6a
leaq 0x18(%rsp), %rdx
movl %eax, %ebx
movq (%rdx), %rbp
movq %rbp, 0x18(%rsp)
movq (%rcx), %rax
subq -0x8(%rcx), %rax
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
movq %rdx, 0x38(%rsp)
movslq -0x10(%rcx), %rax
shlq $0x5, %rax
leaq (%rsp,%rax), %r9
addq $0x160, %r9 # imm = 0x160
movq (%r9), %r10
leaq 0x1(%r10), %r11
movq %r11, (%r9)
addq %rdx, 0x8(%r9)
movq %r12, %r11
testq %r10, %r10
je 0x21cd3
cmpq %rdx, 0x10(%r9)
jb 0x21ccf
movq %r12, %r11
jmp 0x21cd3
leaq 0x10(%r9), %r11
movq (%r11), %r11
movq %r11, 0x10(%r9)
movq %r12, %r11
testq %r10, %r10
je 0x21cf1
cmpq 0x18(%r9), %rdx
jb 0x21ced
movq %r12, %r11
jmp 0x21cf1
leaq 0x18(%r9), %r11
movq (%r11), %r10
movq %r10, 0x18(%r9)
addq %rdx, %rdi
movq %rdi, 0x68(%rsp)
testq %r8, %r8
je 0x21d27
movq 0x70(%rsp), %r9
cmpq %rdx, %r9
jb 0x21d14
movq 0x38(%rsp), %r9
movq %r9, 0x70(%rsp)
leaq 0x78(%rsp), %r9
cmpq 0x78(%rsp), %rdx
jae 0x21d2c
jmp 0x21d2f
movq %rdx, 0x70(%rsp)
movq %r12, %r9
movq (%r9), %r9
movq %r9, 0x78(%rsp)
movq (%r14,%rax), %r9
leaq 0x1(%r9), %r10
movq %r10, (%r14,%rax)
addq %rdx, 0x8(%r14,%rax)
addq %r14, %rax
movq %r12, %r10
testq %r9, %r9
je 0x21d62
cmpq %rdx, 0x10(%rax)
jb 0x21d5e
movq %r12, %r10
jmp 0x21d62
leaq 0x10(%rax), %r10
movq (%r10), %r10
movq %r10, 0x10(%rax)
movq %r12, %r10
testq %r9, %r9
je 0x21d80
cmpq 0x18(%rax), %rdx
jb 0x21d7c
movq %r12, %r10
jmp 0x21d80
leaq 0x18(%rax), %r10
movq (%r10), %rdx
movq %rdx, 0x18(%rax)
incq %r8
addq $0x38, %rcx
movl %ebx, %eax
cmpq %r8, %rsi
jne 0x21c2d
jmp 0x21da1
movl %eax, %ebx
jmp 0x21ded
movl %eax, %ebx
movq 0x248(%rsp), %r13
cmpq 0x250(%rsp), %r13
je 0x21dd6
movl $0x110, %edx # imm = 0x110
movq %r13, %rdi
leaq 0x50(%rsp), %rsi
callq 0x63a0
addq $0x110, %r13 # imm = 0x110
movq %r13, 0x248(%rsp)
jmp 0x21deb
leaq 0x240(%rsp), %rdi
movq %r13, %rsi
leaq 0x50(%rsp), %rdx
callq 0x22778
movl %ebx, %eax
movq 0x48(%rsp), %r8
incq %r8
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x40(%rsp), %rdx
leaq (%rcx,%rdx,8), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rsi
cmpq %rsi, %r8
jb 0x21b9a
movq 0x8(%rsp), %rdx
movq 0x20(%rdx), %rax
subq 0x18(%rdx), %rax
movq 0x30(%rsp), %rdi
incq %rdi
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rax, %rdi
jb 0x21b70
xorl %r13d, %r13d
testb $0x1, 0x10(%rsp)
je 0x22074
testb $0x1, %bl
movq 0x28(%rsp), %rbx
movq 0x8(%rsp), %r14
je 0x21ea6
movq 0x18(%rsp), %rax
subq 0x20(%rsp), %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %r13
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %r13
addq %rax, %r13
jmp 0x21ea6
xorl %r13d, %r13d
leaq 0x9629(%rip), %rsi # 0x2b4d6
movl $0xb, %edx
movq %rbx, %rdi
callq 0x6550
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x62e0
movq %rax, %r12
leaq 0xad23(%rip), %rsi # 0x2cbf3
movl $0x2, %edx
movq %rax, %rdi
callq 0x6550
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
subq %rax, %rcx
je 0x21f25
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x8, %rax
xorl %esi, %esi
movq -0x8(%rax), %rdx
xorl %edi, %edi
cmpq (%rax), %rdx
setne %dil
addq %rdi, %rsi
addq $0x18, %rax
decq %rcx
jne 0x21f0a
jmp 0x21f27
xorl %esi, %esi
movq %r12, %rdi
callq 0x62e0
movq %rax, %r12
leaq 0x95a9(%rip), %rsi # 0x2b4e2
movl $0x13, %edx
movq %rax, %rdi
callq 0x6550
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
subq %rax, %rcx
je 0x21fd0
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movabsq $0x6db6db6db6db6db7, %rdi # imm = 0x6DB6DB6DB6DB6DB7
xorl %esi, %esi
leaq (%rdx,%rdx,2), %r9
movq (%rax,%r9,8), %r8
movq 0x8(%rax,%r9,8), %r9
subq %r8, %r9
je 0x21fc6
sarq $0x3, %r9
movabsq $-0x5555555555555555, %r10 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r10, %r9
cmpq $0x1, %r9
adcq $0x0, %r9
addq $0x8, %r8
movq (%r8), %r10
subq -0x8(%r8), %r10
sarq $0x3, %r10
imulq %rdi, %r10
addq %r10, %rsi
addq $0x18, %r8
decq %r9
jne 0x21fab
incq %rdx
cmpq %rcx, %rdx
jne 0x21f7b
jmp 0x21fd2
xorl %esi, %esi
movq %r12, %rdi
callq 0x62e0
movq %rax, %r14
leaq 0x9512(%rip), %rsi # 0x2b4f6
movl $0xa, %edx
movq %rax, %rdi
callq 0x6550
movq %r14, %rdi
movq %r13, %rsi
callq 0x62e0
leaq 0x94fe(%rip), %rsi # 0x2b501
movl $0x4, %edx
movq %rax, %rdi
callq 0x6550
leaq 0x160(%rsp), %rdi
movq %rbx, %rsi
callq 0x2291a
leaq 0x50(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6550
leaq 0x160(%rsp), %rdi
movq %rbx, %rsi
callq 0x22ce2
movq 0x240(%rsp), %rdi
testq %rdi, %rdi
je 0x22062
movq 0x250(%rsp), %rsi
subq %rdi, %rsi
callq 0x64c0
addq $0x258, %rsp # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rsp), %rbx
movq 0x8(%rsp), %r14
jmp 0x21ea6
jmp 0x22085
movq %rax, %rbx
movq 0x240(%rsp), %rdi
testq %rdi, %rdi
je 0x220a5
movq 0x250(%rsp), %rsi
subq %rdi, %rsi
callq 0x64c0
movq %rbx, %rdi
callq 0x6860
nop
| /taskflow[P]taskflow/taskflow/core/observer.hpp |
long tf::Serializer<std::basic_ofstream<char, std::char_traits<char>>, long>::_save<std::vector<tf::Timeline, std::allocator<tf::Timeline>> const&, (void*)0>(std::vector<tf::Timeline, std::allocator<tf::Timeline>> const&) | SizeType Serializer<Stream, SizeType>::_save(T&& t) {
using U = std::decay_t<T>;
auto sz = _save(make_size_tag(t.size()));
if constexpr (std::is_arithmetic_v<typename U::value_type>) {
_stream.write(
reinterpret_cast<const char*>(t.data()),
t.size() * sizeof(typename U::value_type)
);
sz += t.size() * sizeof(typename U::value_type);
} else {
for(auto&& item : t) {
sz += _save(item);
}
}
return sz;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
movq %rsp, %rsi
movq %rcx, (%rsi)
movq (%rdi), %rdi
movl $0x8, %r14d
movl $0x8, %edx
callq 0x6600
movq (%r12), %r15
movq 0x8(%r12), %r12
cmpq %r12, %r15
je 0x22493
movl $0x8, %r14d
leaq 0x8(%r15), %rdx
leaq 0x10(%r15), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x224a2
addq %rax, %r14
addq $0x28, %r15
cmpq %r12, %r15
jne 0x22474
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /taskflow[P]taskflow/taskflow/core/../utility/serializer.hpp |
long tf::Serializer<std::basic_ofstream<char, std::char_traits<char>>, long>::_save<std::vector<std::vector<std::vector<tf::Segment, std::allocator<tf::Segment>>, std::allocator<std::vector<tf::Segment, std::allocator<tf::Segment>>>>, std::allocator<std::vector<std::vector<tf::Segment, std::allocator<tf::Segment>>, std::allocator<std::vector<tf::Segment, std::allocator<tf::Segment>>>>>> const&, (void*)0>(std::vector<std::vector<std::vector<tf::Segment, std::allocator<tf::Segment>>, std::allocator<std::vector<tf::Segment, std::allocator<tf::Segment>>>>, std::allocator<std::vector<std::vector<tf::Segment, std::allocator<tf::Segment>>, std::allocator<std::vector<tf::Segment, std::allocator<tf::Segment>>>>>> const&) | SizeType Serializer<Stream, SizeType>::_save(T&& t) {
using U = std::decay_t<T>;
auto sz = _save(make_size_tag(t.size()));
if constexpr (std::is_arithmetic_v<typename U::value_type>) {
_stream.write(
reinterpret_cast<const char*>(t.data()),
t.size() * sizeof(typename U::value_type)
);
sz += t.size() * sizeof(typename U::value_type);
} else {
for(auto&& item : t) {
sz += _save(item);
}
}
return sz;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %rsp, %rsi
movq %rcx, (%rsi)
movq (%rdi), %rdi
movl $0x8, %r14d
movl $0x8, %edx
callq 0x6600
movq (%r12), %r15
movq 0x8(%r12), %r12
cmpq %r12, %r15
je 0x2255d
movl $0x8, %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2256c
addq %rax, %r14
addq $0x18, %r15
cmpq %r12, %r15
jne 0x22546
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /taskflow[P]taskflow/taskflow/core/../utility/serializer.hpp |
long tf::Serializer<std::basic_ofstream<char, std::char_traits<char>>, long>::_save<std::vector<std::vector<tf::Segment, std::allocator<tf::Segment>>, std::allocator<std::vector<tf::Segment, std::allocator<tf::Segment>>>> const&, (void*)0>(std::vector<std::vector<tf::Segment, std::allocator<tf::Segment>>, std::allocator<std::vector<tf::Segment, std::allocator<tf::Segment>>>> const&) | SizeType Serializer<Stream, SizeType>::_save(T&& t) {
using U = std::decay_t<T>;
auto sz = _save(make_size_tag(t.size()));
if constexpr (std::is_arithmetic_v<typename U::value_type>) {
_stream.write(
reinterpret_cast<const char*>(t.data()),
t.size() * sizeof(typename U::value_type)
);
sz += t.size() * sizeof(typename U::value_type);
} else {
for(auto&& item : t) {
sz += _save(item);
}
}
return sz;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %rsp, %rsi
movq %rcx, (%rsi)
movq (%rdi), %rdi
movl $0x8, %r14d
movl $0x8, %edx
callq 0x6600
movq (%r12), %r15
movq 0x8(%r12), %r12
cmpq %r12, %r15
je 0x225d7
movl $0x8, %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x225e6
addq %rax, %r14
addq $0x18, %r15
cmpq %r12, %r15
jne 0x225c0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /taskflow[P]taskflow/taskflow/core/../utility/serializer.hpp |
long tf::Serializer<std::basic_ofstream<char, std::char_traits<char>>, long>::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, tf::TaskType const&, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, tf::TaskType const&, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&) | SizeType Serializer<Stream, SizeType>::operator() (T&&... items) {
return (_save(std::forward<T>(items)) + ...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
callq 0x226f6
movq %rax, %rbx
movl (%r13), %eax
leaq 0x8(%rsp), %r13
movl %eax, (%r13)
movq (%r15), %rdi
movl $0x4, %edx
movq %r13, %rsi
callq 0x6600
movq (%r12), %rax
movq %rax, (%r13)
movq (%r15), %rdi
leaq 0x8(%rsp), %r12
movl $0x8, %edx
movq %r12, %rsi
callq 0x6600
movq (%r14), %rax
movq %rax, (%r12)
movq (%r15), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x6600
addq $0x14, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /taskflow[P]taskflow/taskflow/core/../utility/serializer.hpp |
long tf::Serializer<std::basic_ofstream<char, std::char_traits<char>>, long>::_save<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, (void*)0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | SizeType Serializer<Stream, SizeType>::_save(T&& t) {
using U = std::decay_t<T>;
auto sz = _save(make_size_tag(t.size()));
_stream.write(
reinterpret_cast<const char*>(t.data()),
t.size()*sizeof(typename U::value_type)
);
return sz + t.size()*sizeof(typename U::value_type);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq (%rdi), %rdi
movl $0x8, %edx
callq 0x6600
movq (%r14), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x6600
movq 0x8(%rbx), %rax
addq $0x8, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /taskflow[P]taskflow/taskflow/core/../utility/serializer.hpp |
tf::TFProfObserver::Summary::dump_tsum(std::ostream&) const | inline void TFProfObserver::Summary::dump_tsum(std::ostream& os) const {
// task summary
size_t type_w{10}, count_w{5}, time_w{9}, avg_w{8}, min_w{8}, max_w{8};
std::for_each(tsum.begin(), tsum.end(), [&](const auto& i){
if(i.count == 0) return;
count_w = (std::max)(count_w, std::to_string(i.count).size());
});
std::for_each(tsum.begin(), tsum.end(), [&](const auto& i){
if(i.count == 0) return;
time_w = (std::max)(time_w, std::to_string(i.total_span).size());
});
std::for_each(tsum.begin(), tsum.end(), [&](const auto& i){
if(i.count == 0) return;
avg_w = (std::max)(time_w, std::to_string(i.avg_span()).size());
});
std::for_each(tsum.begin(), tsum.end(), [&](const auto& i){
if(i.count == 0) return;
min_w = (std::max)(min_w, std::to_string(i.min_span).size());
});
std::for_each(tsum.begin(), tsum.end(), [&](const auto& i){
if(i.count == 0) return;
max_w = (std::max)(max_w, std::to_string(i.max_span).size());
});
os << std::setw(type_w) << "-Task-"
<< std::setw(count_w+2) << "Count"
<< std::setw(time_w+2) << "Time (us)"
<< std::setw(avg_w+2) << "Avg (us)"
<< std::setw(min_w+2) << "Min (us)"
<< std::setw(max_w+2) << "Max (us)"
<< '\n';
for(size_t i=0; i<TASK_TYPES.size(); i++) {
if(tsum[i].count == 0) {
continue;
}
os << std::setw(type_w) << to_string(TASK_TYPES[i])
<< std::setw(count_w+2) << tsum[i].count
<< std::setw(time_w+2) << tsum[i].total_span
<< std::setw(avg_w+2) << std::to_string(tsum[i].avg_span())
<< std::setw(min_w+2) << tsum[i].min_span
<< std::setw(max_w+2) << tsum[i].max_span
<< '\n';
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x200000000, %r13 # imm = 0x200000000
leaq 0x20(%rsp), %rax
movq $0x5, (%rax)
movq %rax, %rdx
leaq 0x50(%rsp), %r15
movq $0x9, (%r15)
movl $0x8, %eax
leaq 0x48(%rsp), %rbp
movq %rax, (%rbp)
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
leaq 0xe0(%rdi), %r12
movq %r12, %rsi
callq 0x2333f
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x23436
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x2352f
movq %r14, %rdi
movq %r12, %rsi
leaq 0x10(%rsp), %rdx
callq 0x2362f
movq %r14, %rdi
movq %r12, %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdx
callq 0x23728
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xa, 0x10(%rbx,%rax)
leaq 0x8b2d(%rip), %rsi # 0x2b506
movl $0x6, %edx
movq %rbx, %rdi
callq 0x6550
leaq 0x20(%rsp), %rax
movl (%rax), %eax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addl $0x2, %eax
cltq
movq %rax, 0x10(%rbx,%rcx)
leaq 0x8b08(%rip), %rsi # 0x2b50d
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6550
movl (%r15), %eax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addl $0x2, %eax
cltq
movq %rax, 0x10(%rbx,%rcx)
leaq 0x8ae6(%rip), %rsi # 0x2b513
movl $0x9, %edx
movq %rbx, %rdi
callq 0x6550
movl (%rbp), %eax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addl $0x2, %eax
cltq
movq %rax, 0x10(%rbx,%rcx)
leaq 0x8ac8(%rip), %rsi # 0x2b51d
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6550
leaq 0x10(%rsp), %rax
movl (%rax), %eax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addl $0x2, %eax
cltq
movq %rax, 0x10(%rbx,%rcx)
leaq 0x8aa5(%rip), %rsi # 0x2b526
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6550
movl (%r12), %eax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addl $0x2, %eax
cltq
movq %rax, 0x10(%rbx,%rcx)
leaq 0x8a85(%rip), %rsi # 0x2b52f
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6550
leaq 0x28(%rsp), %r15
movb $0xa, (%r15)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6550
xorl %ebp, %ebp
cmpq $0x0, (%r14,%rbp,8)
je 0x22c9e
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xa, 0x10(%rbx,%rax)
leaq 0xa2b0(%rip), %rax # 0x2cda4
movl (%rbp,%rax), %eax
leaq 0x89cd(%rip), %r12 # 0x2b4cc
cmpq $0x6, %rax
ja 0x22b10
leaq 0x17d04(%rip), %rcx # 0x3a810
movq (%rcx,%rax,8), %r12
movq %r12, %rdi
callq 0x61b0
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x6550
movq 0x20(%rsp), %rax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
shlq $0x20, %rax
addq %r13, %rax
sarq $0x20, %rax
movq %rax, 0x10(%rbx,%rcx)
movq (%r14,%rbp,8), %rsi
movq %rbx, %rdi
callq 0x62e0
movq 0x50(%rsp), %rcx
movq (%rax), %rdx
movq -0x18(%rdx), %rdx
shlq $0x20, %rcx
addq %r13, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%rax,%rdx)
movq 0x8(%r14,%rbp,8), %rsi
movq %rax, %rdi
callq 0x62e0
movq %rax, %r12
movq 0x48(%rsp), %rax
movq (%r12), %rcx
movq -0x18(%rcx), %rcx
shlq $0x20, %rax
addq %r13, %rax
sarq $0x20, %rax
movq %rax, 0x10(%r12,%rcx)
movq (%r14,%rbp,8), %rax
movq 0x8(%r14,%rbp,8), %rcx
testq %rcx, %rcx
js 0x22bac
cvtsi2ss %rcx, %xmm0
jmp 0x22bc1
movq %rcx, %rdx
shrq %rdx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
testq %rax, %rax
js 0x22bcd
cvtsi2ss %rax, %xmm1
jmp 0x22be2
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movl $0x3a, %edx
movq %r15, %rdi
movq 0x18357(%rip), %rsi # 0x3af50
leaq 0x8938(%rip), %rcx # 0x2b538
movb $0x1, %al
callq 0x2389c
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0x6550
movq 0x10(%rsp), %rcx
movq (%rax), %rdx
movq -0x18(%rdx), %rdx
shlq $0x20, %rcx
addq %r13, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%rax,%rdx)
movq 0x10(%r14,%rbp,8), %rsi
movq %rax, %rdi
callq 0x62e0
movq 0x18(%rsp), %rcx
movq (%rax), %rdx
movq -0x18(%rdx), %rdx
shlq $0x20, %rcx
addq %r13, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%rax,%rdx)
movq 0x18(%r14,%rbp,8), %rsi
movq %rax, %rdi
callq 0x62e0
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0xf(%rsp), %rsi
callq 0x6550
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x22c9e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x64c0
addq $0x4, %rbp
cmpq $0x1c, %rbp
jne 0x22ad2
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x22cda
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x64c0
movq %rbx, %rdi
callq 0x6860
| /taskflow[P]taskflow/taskflow/core/observer.hpp |
tf::TFProfObserver::Summary::dump_wsum(std::ostream&) const | inline void TFProfObserver::Summary::dump_wsum(std::ostream& os) const {
// task summary
size_t w_w{10}, t_w{10}, l_w{5}, c_w{5}, d_w{9}, avg_w{8}, min_w{8}, max_w{8};
std::for_each(wsum.begin(), wsum.end(), [&](const auto& i){
if(i.count == 0) return;
l_w = (std::max)(l_w, std::to_string(i.level).size());
});
std::for_each(wsum.begin(), wsum.end(), [&](const auto& i){
if(i.count == 0) return;
c_w = (std::max)(c_w, std::to_string(i.count).size());
});
std::for_each(wsum.begin(), wsum.end(), [&](const auto& i){
if(i.count == 0) return;
d_w = (std::max)(d_w, std::to_string(i.total_span).size());
});
std::for_each(wsum.begin(), wsum.end(), [&](const auto& i){
if(i.count == 0) return;
avg_w = (std::max)(avg_w, std::to_string(i.avg_span()).size());
});
std::for_each(wsum.begin(), wsum.end(), [&](const auto& i){
if(i.count == 0) return;
min_w = (std::max)(min_w, std::to_string(i.min_span).size());
});
std::for_each(wsum.begin(), wsum.end(), [&](const auto& i){
if(i.count == 0) return;
max_w = (std::max)(max_w, std::to_string(i.max_span).size());
});
os << std::setw(w_w) << "-Worker-"
<< std::setw(l_w+2) << "Level"
<< std::setw(t_w) << "Task"
<< std::setw(c_w+2) << "Count"
<< std::setw(d_w+2) << "Time (us)"
<< std::setw(avg_w+2) << "Avg (us)"
<< std::setw(min_w+2) << "Min (us)"
<< std::setw(max_w+2) << "Max (us)"
<< '\n';
for(const auto& ws : wsum) {
if(ws.count == 0) {
continue;
}
os << std::setw(w_w) << ws.id
<< std::setw(l_w+2) << ws.level;
bool first = true;
for(size_t i=0; i<TASK_TYPES.size(); i++) {
if(ws.tsum[i].count == 0) {
continue;
}
os << (first ? std::setw(t_w) : std::setw(w_w + l_w + 2 + t_w));
first = false;
os << to_string(TASK_TYPES[i])
<< std::setw(c_w+2) << ws.tsum[i].count
<< std::setw(d_w+2) << ws.tsum[i].total_span
<< std::setw(avg_w+2) << std::to_string(ws.tsum[i].avg_span())
<< std::setw(min_w+2) << ws.tsum[i].min_span
<< std::setw(max_w+2) << ws.tsum[i].max_span
<< '\n';
}
// per-worker summary
os << std::setw(w_w + l_w + t_w + c_w + 4) << ws.count
<< std::setw(d_w+2) << ws.total_span
<< std::setw(avg_w+2) << std::to_string(ws.avg_span())
<< std::setw(min_w+2) << ws.min_span
<< std::setw(max_w+2) << ws.max_span
<< '\n';
//for(size_t j=0; j<w_w+l_w+t_w+4; j++) os << ' ';
//for(size_t j=0; j<c_w+d_w+avg_w+min_w+max_w+8; j++) os << '-';
//os <<'\n';
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r13
movl $0x5, %eax
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, %rdx
leaq 0x40(%rsp), %r14
movq %rax, (%r14)
leaq 0x58(%rsp), %r12
movq $0x9, (%r12)
movl $0x8, %eax
leaq 0x50(%rsp), %r15
movq %rax, (%r15)
leaq 0x48(%rsp), %rbp
movq %rax, (%rbp)
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq 0xe0(%rdi), %rdi
movq 0xe8(%r13), %rsi
callq 0x239de
movq 0xe0(%r13), %rdi
movq 0xe8(%r13), %rsi
movq %r14, %rdx
callq 0x23adb
movq 0xe0(%r13), %rdi
movq 0xe8(%r13), %rsi
movq %r12, %rdx
callq 0x23bd6
movq 0xe0(%r13), %rdi
movq 0xe8(%r13), %rsi
movq %r15, %rdx
callq 0x23cd3
movq 0xe0(%r13), %rdi
movq 0xe8(%r13), %rsi
movq %rbp, %rdx
callq 0x23dd2
movq 0xe0(%r13), %rdi
movq 0xe8(%r13), %rsi
leaq 0x10(%rsp), %rdx
callq 0x23ecf
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl $0xa, %r14d
movq %r14, 0x10(%rbx,%rax)
leaq 0x8790(%rip), %rsi # 0x2b565
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6550
leaq 0x18(%rsp), %rax
movl (%rax), %eax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addl $0x2, %eax
cltq
movq %rax, 0x10(%rbx,%rcx)
leaq 0x876d(%rip), %rsi # 0x2b56e
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6550
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %r14, 0x10(%rbx,%rax)
leaq 0x8753(%rip), %rsi # 0x2b574
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6550
leaq 0x40(%rsp), %rax
movl (%rax), %eax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addl $0x2, %eax
cltq
movq %rax, 0x10(%rbx,%rcx)
leaq 0x86c0(%rip), %rsi # 0x2b50d
movl $0x5, %edx
movq %rbx, %rdi
callq 0x6550
movl (%r12), %eax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addl $0x2, %eax
cltq
movq %rax, 0x10(%rbx,%rcx)
leaq 0x869d(%rip), %rsi # 0x2b513
movl $0x9, %edx
movq %rbx, %rdi
callq 0x6550
movl (%r15), %eax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addl $0x2, %eax
cltq
movq %rax, 0x10(%rbx,%rcx)
leaq 0x867f(%rip), %rsi # 0x2b51d
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6550
movl (%rbp), %eax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addl $0x2, %eax
cltq
movq %rax, 0x10(%rbx,%rcx)
leaq 0x8660(%rip), %rsi # 0x2b526
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6550
leaq 0x10(%rsp), %rax
movl (%rax), %eax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addl $0x2, %eax
cltq
movq %rax, 0x10(%rbx,%rcx)
leaq 0x863d(%rip), %rsi # 0x2b52f
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6550
leaq 0x20(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6550
movq 0xe0(%r13), %r14
movq 0xe8(%r13), %rax
movq %rax, 0x60(%rsp)
cmpq %rax, %r14
je 0x23307
movabsq $0x200000000, %r15 # imm = 0x200000000
leaq 0xf(%rsp), %r13
cmpq $0x0, 0x10(%r14)
je 0x232f5
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xa, 0x10(%rbx,%rax)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x62e0
movq 0x18(%rsp), %rcx
movq (%rax), %rdx
movq -0x18(%rdx), %rdx
shlq $0x20, %rcx
addq %r15, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%rax,%rdx)
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x62e0
movb $0x1, %al
xorl %r12d, %r12d
cmpq $0x0, 0x30(%r14,%r12,8)
je 0x23174
movl 0x18(%rsp), %ecx
addl $0x16, %ecx
movslq %ecx, %rcx
movq (%rbx), %rdx
movq -0x18(%rdx), %rdx
testb $0x1, %al
movl $0xa, %eax
cmovneq %rax, %rcx
movq %rcx, 0x10(%rbx,%rdx)
leaq 0x9dde(%rip), %rax # 0x2cda4
movl (%r12,%rax), %eax
leaq 0x84fb(%rip), %rbp # 0x2b4cc
cmpq $0x6, %rax
ja 0x22fe2
leaq 0x17832(%rip), %rcx # 0x3a810
movq (%rcx,%rax,8), %rbp
movq %rbp, %rdi
callq 0x61b0
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x6550
movq 0x40(%rsp), %rax
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
shlq $0x20, %rax
addq %r15, %rax
sarq $0x20, %rax
movq %rax, 0x10(%rbx,%rcx)
movq 0x30(%r14,%r12,8), %rsi
movq %rbx, %rdi
callq 0x62e0
movq 0x58(%rsp), %rcx
movq (%rax), %rdx
movq -0x18(%rdx), %rdx
shlq $0x20, %rcx
addq %r15, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%rax,%rdx)
movq 0x38(%r14,%r12,8), %rsi
movq %rax, %rdi
callq 0x62e0
movq %rax, %rbp
movq 0x50(%rsp), %rax
movq (%rbp), %rcx
movq -0x18(%rcx), %rcx
shlq $0x20, %rax
addq %r15, %rax
sarq $0x20, %rax
movq %rax, 0x10(%rbp,%rcx)
movq 0x30(%r14,%r12,8), %rax
movq 0x38(%r14,%r12,8), %rcx
testq %rcx, %rcx
js 0x23080
cvtsi2ss %rcx, %xmm0
jmp 0x23095
movq %rcx, %rdx
shrq %rdx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
testq %rax, %rax
js 0x230a1
cvtsi2ss %rax, %xmm1
jmp 0x230b6
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movl $0x3a, %edx
leaq 0x20(%rsp), %rdi
movq 0x17e81(%rip), %rsi # 0x3af50
leaq 0x8462(%rip), %rcx # 0x2b538
movb $0x1, %al
callq 0x2389c
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbp, %rdi
callq 0x6550
movq 0x48(%rsp), %rcx
movq (%rax), %rdx
movq -0x18(%rdx), %rdx
shlq $0x20, %rcx
addq %r15, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%rax,%rdx)
movq 0x40(%r14,%r12,8), %rsi
movq %rax, %rdi
callq 0x62e0
movq 0x10(%rsp), %rcx
movq (%rax), %rdx
movq -0x18(%rdx), %rdx
shlq $0x20, %rcx
addq %r15, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%rax,%rdx)
movq 0x48(%r14,%r12,8), %rsi
movq %rax, %rdi
callq 0x62e0
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x6550
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x23172
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x64c0
xorl %eax, %eax
addq $0x4, %r12
cmpq $0x1c, %r12
jne 0x22f92
movl 0x18(%rsp), %eax
movl 0x40(%rsp), %ecx
movq (%rbx), %rdx
movq -0x18(%rdx), %rdx
addl %ecx, %eax
addl $0x18, %eax
cltq
movq %rax, 0x10(%rbx,%rdx)
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x62e0
movq 0x58(%rsp), %rcx
movq (%rax), %rdx
movq -0x18(%rdx), %rdx
shlq $0x20, %rcx
addq %r15, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%rax,%rdx)
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x62e0
movq %rax, %rbp
movq 0x50(%rsp), %rax
movq (%rbp), %rcx
movq -0x18(%rcx), %rcx
shlq $0x20, %rax
addq %r15, %rax
sarq $0x20, %rax
movq %rax, 0x10(%rbp,%rcx)
movq 0x18(%r14), %rax
testq %rax, %rax
js 0x23201
cvtsi2ss %rax, %xmm0
jmp 0x23216
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
movq 0x10(%r14), %rax
testq %rax, %rax
js 0x23226
cvtsi2ss %rax, %xmm1
jmp 0x2323b
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movl $0x3a, %edx
leaq 0x20(%rsp), %rdi
movq 0x17cfc(%rip), %rsi # 0x3af50
leaq 0x82dd(%rip), %rcx # 0x2b538
movb $0x1, %al
callq 0x2389c
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbp, %rdi
callq 0x6550
movq 0x48(%rsp), %rcx
movq (%rax), %rdx
movq -0x18(%rdx), %rdx
shlq $0x20, %rcx
addq %r15, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%rax,%rdx)
movq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x62e0
movq 0x10(%rsp), %rcx
movq (%rax), %rdx
movq -0x18(%rdx), %rdx
shlq $0x20, %rcx
addq %r15, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%rax,%rdx)
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x62e0
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x6550
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x232f5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x64c0
addq $0x110, %r14 # imm = 0x110
cmpq 0x60(%rsp), %r14
jne 0x22f3f
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x23318
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x23337
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x64c0
movq %rbx, %rdi
callq 0x6860
| /taskflow[P]taskflow/taskflow/core/observer.hpp |
tf::TFProfObserver::on_exit(tf::WorkerView, tf::TaskView) | inline void TFProfObserver::on_exit(WorkerView wv, TaskView tv) {
size_t w = wv.id();
assert(!_stacks[w].empty());
if(_stacks[w].size() > _timeline.segments[w].size()) {
_timeline.segments[w].resize(_stacks[w].size());
}
auto beg = _stacks[w].top();
_stacks[w].pop();
_timeline.segments[w][_stacks[w].size()].emplace_back(
tv.name(), tv.type(), beg, observer_stamp_t::clock::now()
);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq 0x30(%rdi), %rdx
leaq (%rax,%rax,4), %r15
shlq $0x4, %r15
movq 0x48(%rdx,%r15), %rcx
movq %rcx, %rdi
subq 0x28(%rdx,%r15), %rdi
shrq $0x3, %rdi
cmpq $0x1, %rcx
adcq $-0x1, %rdi
movq 0x18(%r14), %rcx
shlq $0x6, %rdi
movq 0x20(%rdx,%r15), %rsi
movq 0x30(%rdx,%r15), %r8
subq 0x38(%rdx,%r15), %r8
subq 0x10(%rdx,%r15), %rsi
sarq $0x3, %r8
sarq $0x3, %rsi
addq %r8, %rsi
addq %rdi, %rsi
leaq (%rax,%rax,2), %r12
movq 0x8(%rcx,%r12,8), %rax
subq (%rcx,%r12,8), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq %rdx, %rsi
jbe 0x2434f
leaq (%rcx,%r12,8), %rdi
callq 0x24742
movq 0x30(%r14), %rcx
leaq (%rcx,%r15), %rdi
movq 0x30(%rcx,%r15), %rax
cmpq 0x38(%rcx,%r15), %rax
jne 0x24370
movq 0x48(%rdi), %rcx
movl $0x200, %eax # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rax
movq %rax, (%rsp)
callq 0x24a06
movq 0x18(%r14), %rdx
movq 0x30(%r14), %rcx
movq 0x48(%rcx,%r15), %rdi
movq 0x28(%rcx,%r15), %r8
movq 0x30(%rcx,%r15), %rax
movq 0x38(%rcx,%r15), %r9
movq 0x10(%rcx,%r15), %r10
movq 0x20(%rcx,%r15), %rcx
movq (%rdx,%r12,8), %rdx
movzbl 0xc0(%rbx), %r11d
movl $0x7, %esi
cmpq $0x8, %r11
ja 0x243c5
leaq 0x5ebb(%rip), %rsi # 0x2a27c
movl (%rsi,%r11,4), %esi
addq $0x8, %rbx
subq %r10, %rcx
shrq $0x3, %rcx
subq %r9, %rax
shrq $0x3, %rax
movq %rdi, %r9
subq %r8, %r9
shrq $0x3, %r9
cmpq $0x1, %rdi
adcq $-0x1, %r9
leaq (%r9,%r9,2), %rdi
shlq $0x9, %rdi
addq %rdi, %rdx
leaq (%rax,%rax,2), %rax
leaq (%rdx,%rax,8), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %r14
leaq 0xc(%rsp), %r15
movl %esi, (%r15)
callq 0x6620
leaq 0x10(%rsp), %r8
movq %rax, (%r8)
movq %rsp, %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x247be
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /taskflow[P]taskflow/taskflow/core/observer.hpp |
dg::DGLLVMPointerAnalysis::getLLVMPointsTo(llvm::Value const*) | LLVMPointsToSet getLLVMPointsTo(const llvm::Value *val) override {
DGLLVMPointsToSet *pts;
if (auto *node = getPointsToNode(val)) {
if (node->pointsTo.empty()) {
pts = new DGLLVMPointsToSet(getUnknownPTSet());
} else {
pts = new DGLLVMPointsToSet(node->pointsTo);
}
} else {
pts = new DGLLVMPointsToSet(getUnknownPTSet());
}
return pts->toLLVMPointsToSet();
} | subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x70420
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x6e74f
movq 0x30(%rsp), %rdi
addq $0xb0, %rdi
callq 0x70460
testb $0x1, %al
jne 0x6e6f3
jmp 0x6e720
movl $0x30, %edi
callq 0x6c270
movq %rax, 0x18(%rsp)
callq 0x71450
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x71500
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x6e74d
movl $0x30, %edi
callq 0x6c270
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
movq 0x30(%rsp), %rsi
addq $0xb0, %rsi
callq 0x71500
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x6e77a
movl $0x30, %edi
callq 0x6c270
movq %rax, 0x8(%rsp)
callq 0x71450
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x71500
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x71540
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::DGLLVMPointerAnalysis::getLLVMPointsToChecked(llvm::Value const*) | std::pair<bool, LLVMPointsToSet>
getLLVMPointsToChecked(const llvm::Value *val) override {
DGLLVMPointsToSet *pts;
if (auto *node = getPointsToNode(val)) {
if (node->pointsTo.empty()) {
pts = new DGLLVMPointsToSet(getUnknownPTSet());
return {false, pts->toLLVMPointsToSet()};
}
pts = new DGLLVMPointsToSet(node->pointsTo);
return {true, pts->toLLVMPointsToSet()};
}
pts = new DGLLVMPointsToSet(getUnknownPTSet());
return {false, pts->toLLVMPointsToSet()};
} | subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x70420
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x6e8c0
movq 0x60(%rsp), %rdi
addq $0xb0, %rdi
callq 0x70460
testb $0x1, %al
jne 0x6e7fd
jmp 0x6e85f
movl $0x30, %edi
callq 0x6c270
movq %rax, 0x18(%rsp)
callq 0x71450
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x71500
movq 0x18(%rsp), %rax
movq %rax, 0x68(%rsp)
movb $0x0, 0x5f(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x71540
movq 0x20(%rsp), %rdi
leaq 0x5f(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x77c80
leaq 0x50(%rsp), %rdi
callq 0x77cc0
jmp 0x6e91d
movl $0x30, %edi
callq 0x6c270
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
movq 0x60(%rsp), %rsi
addq $0xb0, %rsi
callq 0x71500
movq 0x10(%rsp), %rax
movq %rax, 0x68(%rsp)
movb $0x1, 0x4f(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x71540
movq 0x20(%rsp), %rdi
leaq 0x4f(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x77c80
leaq 0x40(%rsp), %rdi
callq 0x77cc0
jmp 0x6e91d
movl $0x30, %edi
callq 0x6c270
movq %rax, 0x8(%rsp)
callq 0x71450
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x71500
movq 0x8(%rsp), %rax
movq %rax, 0x68(%rsp)
movb $0x0, 0x3f(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x71540
movq 0x20(%rsp), %rdi
leaq 0x3f(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x77c80
leaq 0x30(%rsp), %rdi
callq 0x77cc0
movq 0x28(%rsp), %rax
addq $0x88, %rsp
retq
nopw (%rax,%rax)
| /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::pta::PointerGraph::PointerGraph() | PointerGraph() {
// nodes[0] represents invalid node (the node with id 0)
nodes.emplace_back(nullptr);
// the first several nodes are special nodes. For now, we just replace
// them with nullptr, as those are created statically <-- FIXME!
nodes.emplace_back(nullptr);
nodes.emplace_back(nullptr);
nodes.emplace_back(nullptr);
assert(nodes.size() - 1 == PointerGraphReservedIDs::LAST_RESERVED_ID);
initStaticNodes();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
callq 0x6edd0
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
callq 0x6ede0
movq 0x8(%rsp), %rdi
movl $0x3, 0x40(%rdi)
addq $0x48, %rdi
callq 0x6edf0
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x6ee10
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x6ee20
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x6ee20
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq $0x0, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x6ee20
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq $0x0, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x6ee20
callq 0x6c310
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerGraph.h |
dg::pta::LLVMPointerGraphBuilder::getPointsToNodeOrNull(llvm::Value const*) | PSNode *getPointsToNodeOrNull(const llvm::Value *val) {
// if we have a mapping for this node (e.g. the original
// node was optimized away and replaced by mapping),
// return it
if (auto *mp = mapping.get(val))
return mp;
if (auto *nds = getNodes(val)) {
// otherwise get the representant of the built nodes
return nds->getRepresentant();
}
// not built!
return nullptr;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x98, %rdi
movq 0x20(%rsp), %rsi
callq 0x705e0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x70592
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x705c8
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x70660
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x705bf
movq 0x10(%rsp), %rdi
callq 0x706f0
movq %rax, 0x30(%rsp)
jmp 0x705c8
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerGraph.h |
dg::pta::LLVMPointerGraphBuilder::getNodes(llvm::Value const*) | PSNodesSeq *getNodes(const llvm::Value *val) {
auto it = nodes_map.find(val);
if (it == nodes_map.end())
return nullptr;
// the node corresponding to the real llvm value
// is always the last
return &it->second;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x188, %rdi # imm = 0x188
leaq 0x20(%rsp), %rsi
callq 0x70d60
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x188, %rdi # imm = 0x188
callq 0x70db0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x70d90
testb $0x1, %al
jne 0x706b9
jmp 0x706c4
movq $0x0, 0x30(%rsp)
jmp 0x706d7
leaq 0x18(%rsp), %rdi
callq 0x70de0
addq $0x8, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerGraph.h |
dg::DGLLVMPointerAnalysis::buildSubgraph() | void buildSubgraph() {
// run the analysis itself
assert(_builder && "Incorrectly constructed PTA, missing builder");
PS = _builder->buildLLVMPointerGraph();
if (!PS) {
llvm::errs() << "Pointer Subgraph was not built, aborting\n";
abort();
}
/*
pta::PointerGraphOptimizer optimizer(PS);
optimizer.run();
if (optimizer.getNumOfRemovedNodes() > 0)
_builder->composeMapping(std::move(optimizer.getMapping()));
llvm::errs() << "PS optimization removed " <<
optimizer.getNumOfRemovedNodes() << " nodes\n";
*/
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x88, %rdi
callq 0x70480
movq %rax, %rdi
callq 0x6c040
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x78(%rax)
cmpq $0x0, 0x78(%rax)
jne 0x784a3
callq 0x6c390
movq %rax, %rdi
leaq 0x1fd0b(%rip), %rsi # 0x981a4
callq 0x6d320
callq 0x6c3a0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::pta::PointerAnalysisFS::getMemoryObjects(dg::pta::PSNode*, dg::pta::Pointer const&, std::vector<dg::pta::MemoryObject*, std::allocator<dg::pta::MemoryObject*>>&) | void getMemoryObjects(PSNode *where, const Pointer &pointer,
std::vector<MemoryObject *> &objects) override {
MemoryMapT *mm = where->getData<MemoryMapT>();
assert(mm && "Node does not have memory map");
auto I = mm->find(pointer.target);
if (I != mm->end()) {
objects.push_back(I->second.get());
}
// if we haven't found any memory object, but this psnode
// is a write to memory, create a new one, so that
// the write has something to write to
if (objects.empty() && canChangeMM(where)) {
MemoryObject *mo = new MemoryObject(pointer.target);
mm->emplace(pointer.target, std::unique_ptr<MemoryObject>(mo));
objects.push_back(mo);
}
} | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x7a800
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x7a850
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x7a830
testb $0x1, %al
jne 0x78999
jmp 0x789cd
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x7a8b0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x7a8d0
movq 0x20(%rsp), %rdi
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x7a880
movq 0x68(%rsp), %rdi
callq 0x7a8e0
testb $0x1, %al
jne 0x789e0
jmp 0x78a75
movq 0x78(%rsp), %rdi
callq 0x7a930
testb $0x1, %al
jne 0x789f3
jmp 0x78a75
movl $0x38, %edi
callq 0x6c270
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq (%rax), %rsi
callq 0x7a9a0
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x7aa20
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x7a9d0
movq %rax, 0x28(%rsp)
movb %dl, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x7a0e0
movq 0x68(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7aa50
addq $0x88, %rsp
retq
nopl (%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::pta::PointerAnalysisFS::beforeProcessed(dg::pta::PSNode*) | bool beforeProcessed(PSNode *n) override {
MemoryMapT *mm = n->getData<MemoryMapT>();
if (mm)
return false;
// on these nodes the memory map can change
if (needsMerge(n)) {
mm = createMM();
// if this is the root of the entry procedure,
// we must propagate the points-to information
// from the globals initialization
if (n == PG->getEntry()->getRoot()) {
mergeGlobalsState(mm, PG->getGlobals());
}
} else {
// this node can not change the memory map,
// so just add a pointer from the predecessor
// to this map
PSNode *pred = n->getSinglePredecessor();
mm = pred->getData<MemoryMapT>();
assert(mm && "No memory map in the predecessor");
}
assert(mm && "Did not create the MM");
// memory map initialized, set it as data,
// so that we won't initialize it again
n->setData<MemoryMapT>(mm);
return true;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x78abd
movb $0x0, 0x47(%rsp)
jmp 0x78b71
movq 0x30(%rsp), %rdi
callq 0x7c1b0
testb $0x1, %al
jne 0x78acd
jmp 0x78b33
movq 0x18(%rsp), %rdi
callq 0x7c230
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x38(%rax), %rdi
callq 0x7c2a0
movq %rax, %rdi
callq 0x7c2b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x78b31
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x38(%rax), %rdi
callq 0x7c360
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x7c2c0
jmp 0x78b59
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x7c380
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
movq 0x28(%rsp), %rsi
callq 0x7c3a0
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::pta::PointerAnalysisFS::afterProcessed(dg::pta::PSNode*) | bool afterProcessed(PSNode *n) override {
bool changed = false;
PointsToSetT *overwritten = nullptr;
MemoryMapT *mm = n->getData<MemoryMapT>();
// we must have the memory map, we created it
// in the beforeProcessed method
assert(mm && "Do not have memory map");
// every store that stores to a memory allocated
// not in a loop is a strong update
// FIXME: memcpy can be strong update too
if (n->getType() == PSNodeType::STORE) {
if (!pointsToAllocationInLoop(n->getOperand(1)))
overwritten = &n->getOperand(1)->pointsTo;
}
// merge information from predecessors if there's
// more of them (if there's just one predecessor
// and this is not a store, the memory map couldn't
// change, so we don't have to do that)
if (needsMerge(n)) {
for (PSNode *p : n->predecessors()) {
if (MemoryMapT *pm = p->getData<MemoryMapT>()) {
// merge pm to mm (but only if pm was already created)
changed |= mergeMaps(mm, pm, overwritten);
}
}
// interprocedural stuff - merge information from calls
if (auto *CR = PSNodeCallRet::get(n)) {
for (auto *p : CR->getReturns()) {
if (MemoryMapT *pm = p->getData<MemoryMapT>()) {
// merge pm to mm (but only if pm was already created)
changed |= mergeMaps(mm, pm, overwritten);
}
}
}
if (auto *E = PSNodeEntry::get(n)) {
for (auto *p : E->getCallers()) {
if (MemoryMapT *pm = p->getData<MemoryMapT>()) {
// merge pm to mm (but only if pm was already created)
changed |= mergeMaps(mm, pm, overwritten);
}
}
}
}
return changed;
} | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
movq $0x0, 0x98(%rsp)
movq 0xa8(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x90(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x7b680
cmpl $0x3, %eax
jne 0x78c1e
movq 0xa8(%rsp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x7e9b0
movq %rax, %rdi
callq 0x7e8e0
testb $0x1, %al
jne 0x78c1c
movq 0xa8(%rsp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x7e9b0
addq $0xb0, %rax
movq %rax, 0x98(%rsp)
jmp 0x78c1e
movq 0xa8(%rsp), %rdi
callq 0x7c1b0
testb $0x1, %al
jne 0x78c34
jmp 0x78ec9
movq 0xa8(%rsp), %rdi
addq $0x8, %rdi
callq 0x7e9e0
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x7c9f0
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x7ca20
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x7ca50
testb $0x1, %al
jne 0x78c8f
jmp 0x78d0f
leaq 0x80(%rsp), %rdi
callq 0x7ca90
movq (%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x78cfb
movq 0x90(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x7caa0
andb $0x1, %al
movzbl %al, %ecx
movb 0xa7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
jmp 0x78cfd
leaq 0x80(%rsp), %rdi
callq 0x7cbf0
jmp 0x78c74
movq 0xa8(%rsp), %rdi
callq 0x7e9f0
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x78deb
movq 0x60(%rsp), %rdi
callq 0x7ea30
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x7c9f0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x7ca20
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x7ca50
testb $0x1, %al
jne 0x78d6f
jmp 0x78de9
leaq 0x50(%rsp), %rdi
callq 0x7ca90
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x78dd8
movq 0x90(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x7caa0
andb $0x1, %al
movzbl %al, %ecx
movb 0xa7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
jmp 0x78dda
leaq 0x50(%rsp), %rdi
callq 0x7cbf0
jmp 0x78d5a
jmp 0x78deb
movq 0xa8(%rsp), %rdi
callq 0x7ea50
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x78ec7
movq 0x30(%rsp), %rdi
callq 0x7ea90
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7c9f0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7ca20
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x7ca50
testb $0x1, %al
jne 0x78e4b
jmp 0x78ec5
leaq 0x20(%rsp), %rdi
callq 0x7ca90
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x78eb4
movq 0x90(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x7caa0
andb $0x1, %al
movzbl %al, %ecx
movb 0xa7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
jmp 0x78eb6
leaq 0x20(%rsp), %rdi
callq 0x7cbf0
jmp 0x78e36
jmp 0x78ec7
jmp 0x78ec9
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
nopw (%rax,%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::DGLLVMPointerAnalysisImpl<dg::pta::PointerAnalysisFS>::functionPointerCall(dg::pta::PSNode*, dg::pta::PSNode*) | bool functionPointerCall(PSNode *callsite, PSNode *called) override {
using namespace pta;
const llvm::Function *F = llvm::dyn_cast<llvm::Function>(
called->getUserData<llvm::Value>());
// with vararg it may happen that we get pointer that
// is not to function, so just bail out here in that case
if (!F)
return false;
if (F->isDeclaration()) {
if (builder->threads()) {
if (F->getName() == "pthread_create") {
builder->insertPthreadCreateByPtrCall(callsite);
return true;
}
if (F->getName() == "pthread_join") {
builder->insertPthreadJoinByPtrCall(callsite);
return true;
}
}
}
if (!LLVMPointerGraphBuilder::callIsCompatible(callsite, called)) {
return false;
}
builder->insertFunctionCall(callsite, called);
// call the original handler that works on generic graphs
PTType::functionPointerCall(callsite, called);
#ifndef NDEBUG
// check the graph after rebuilding, but do not check for connectivity,
// because we can call a function that will disconnect the graph
if (!builder->validateSubgraph(true)) {
llvm::errs() << "Pointer Subgraph is broken!\n";
llvm::errs() << "This happend after building this function called "
"via pointer: "
<< F->getName() << "\n";
abort();
}
#endif // NDEBUG
return true; // we changed the graph
} | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
addq $0x8, %rdi
callq 0x77900
movq %rax, %rdi
callq 0x7f8f0
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x78faa
movb $0x0, 0x77(%rsp)
jmp 0x790ee
movq 0x50(%rsp), %rdi
callq 0x6c370
testb $0x1, %al
jne 0x78fbd
jmp 0x790a0
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x7f930
testb $0x1, %al
jne 0x78fd7
jmp 0x7909e
movq 0x50(%rsp), %rdi
callq 0x6c360
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x1f1e7(%rip), %rsi # 0x981de
callq 0x6d010
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x7f950
testb $0x1, %al
jne 0x7901b
jmp 0x7903b
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
movq 0x60(%rsp), %rsi
callq 0x6c2b0
movb $0x1, 0x77(%rsp)
jmp 0x790ee
movq 0x50(%rsp), %rdi
callq 0x6c360
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x1f192(%rip), %rsi # 0x981ed
callq 0x6d010
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x7f950
testb $0x1, %al
jne 0x7907f
jmp 0x7909c
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
movq 0x60(%rsp), %rsi
callq 0x6c3f0
movb $0x1, 0x77(%rsp)
jmp 0x790ee
jmp 0x7909e
jmp 0x790a0
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x6c110
testb $0x1, %al
jne 0x790ba
movb $0x0, 0x77(%rsp)
jmp 0x790ee
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x6c140
movq 0x8(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x793f0
movb $0x1, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopl (%rax)
| /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::pta::PointerAnalysisFS::canChangeMM(dg::pta::PSNode*) | static bool canChangeMM(PSNode *n) {
switch (n->getType()) {
case PSNodeType::STORE:
case PSNodeType::MEMCPY:
case PSNodeType::CALL_FUNCPTR:
// a call via function pointer needs to
// have its own memory map as we dont know
// how the graph will look like after the
// call yet
return true;
case PSNodeType::CALL_RETURN:
// return from function that was called via function
// pointer must have its own memory map from the
// same reason why CALL_FUNCPTR nodes need its
// own memory map
assert(n->getPairedNode());
return n->getPairedNode()->getType() == PSNodeType::CALL_FUNCPTR;
default:
return false;
}
return false;
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x7b680
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x11, %eax
ja 0x7a98c
movq (%rsp), %rax
leaq 0x1d6dc(%rip), %rcx # 0x98038
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, 0x17(%rsp)
jmp 0x7a991
movq 0x8(%rsp), %rdi
callq 0x7b6a0
movq %rax, %rdi
callq 0x7b680
cmpl $0x9, %eax
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x7a991
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::pta::PointerAnalysisFS::mergeMaps(std::map<dg::pta::PSNode*, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>, std::less<dg::pta::PSNode*>, std::allocator<std::pair<dg::pta::PSNode* const, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>>>>*, std::map<dg::pta::PSNode*, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>, std::less<dg::pta::PSNode*>, std::allocator<std::pair<dg::pta::PSNode* const, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>>>>*, dg::pta::PointerIdPointsToSet*) | static bool mergeMaps(MemoryMapT *mm, MemoryMapT *from,
PointsToSetT *overwritten) {
bool changed = false;
for (auto &it : *from) {
PSNode *fromTarget = it.first;
std::unique_ptr<MemoryObject> &toMo = (*mm)[fromTarget];
if (toMo == nullptr)
toMo.reset(new MemoryObject(fromTarget));
changed |= mergeObjects(fromTarget, toMo.get(), it.second.get(),
overwritten);
}
return changed;
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movb $0x0, 0x5f(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x7cc40
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x7a850
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7a830
testb $0x1, %al
jne 0x7caf8
jmp 0x7cbda
leaq 0x48(%rsp), %rdi
callq 0x7cc70
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7cc90
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7cd90
testb $0x1, %al
jne 0x7cb3c
jmp 0x7cb71
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x38, %edi
callq 0x6c270
movq %rax, %rdi
movq %rdi, 0x20(%rsp)
movq 0x30(%rsp), %rsi
callq 0x7a9a0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7cdc0
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7a8d0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a8d0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
movq 0x60(%rsp), %rcx
callq 0x7cdf0
andb $0x1, %al
movzbl %al, %ecx
movb 0x5f(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x5f(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x7cfe0
jmp 0x7cae0
movb 0x5f(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::pta::PointerAnalysisFS::mergeObjects(dg::pta::PSNode*, dg::pta::MemoryObject*, dg::pta::MemoryObject*, dg::pta::PointerIdPointsToSet*) | static bool mergeObjects(PSNode *node, MemoryObject *to, MemoryObject *from,
PointsToSetT *overwritten) {
bool changed = false;
for (auto &fromIt : from->pointsTo) {
if (overwritten && overwritten->count(Pointer(node, fromIt.first)))
continue;
auto &S = to->pointsTo[fromIt.first];
for (const auto &ptr : fromIt.second)
changed |= S.add(ptr);
}
return changed;
} | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
movq 0xb0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0x7d8c0
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rdi
callq 0x7d8f0
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x7d920
testb $0x1, %al
jne 0x7ce7b
jmp 0x7cfcd
leaq 0x90(%rsp), %rdi
callq 0x7d940
movq %rax, 0x80(%rsp)
xorl %eax, %eax
cmpq $0x0, 0xa8(%rsp)
movb %al, 0xf(%rsp)
je 0x7ceed
movq 0xa8(%rsp), %rax
movq %rax, (%rsp)
movq 0xc0(%rsp), %rsi
movq 0x80(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x71590
movq (%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x71b20
cmpq $0x0, %rax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x7cef7
jmp 0x7cefc
jmp 0x7cfbb
movq 0xb8(%rsp), %rdi
addq $0x8, %rdi
movq 0x80(%rsp), %rsi
callq 0x7d960
movq %rax, 0x60(%rsp)
movq 0x80(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x77620
movq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x77970
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x77a10
testb $0x1, %al
jne 0x7cf5e
jmp 0x7cfb9
leaq 0x40(%rsp), %rdi
callq 0x778c0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x71880
andb $0x1, %al
movzbl %al, %ecx
movb 0xa7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x779a0
jmp 0x7cf49
jmp 0x7cfbb
leaq 0x90(%rsp), %rdi
callq 0x7da50
jmp 0x7ce5d
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xc8, %rsp
retq
nop
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFS.h |
dg::pta::PointerAnalysisFI::getMemoryObjects(dg::pta::PSNode*, dg::pta::Pointer const&, std::vector<dg::pta::MemoryObject*, std::allocator<dg::pta::MemoryObject*>>&) | void getMemoryObjects(PSNode *where, const Pointer &pointer,
std::vector<MemoryObject *> &objects) override {
// irrelevant in flow-insensitive
(void) where;
PSNode *n = pointer.target;
// we want to have memory in allocation sites
if (n->getType() == PSNodeType::CAST || n->getType() == PSNodeType::GEP)
n = n->getOperand(0);
else if (n->getType() == PSNodeType::CONSTANT) {
assert(n->pointsTo.size() == 1);
n = (*n->pointsTo.begin()).target;
}
if (n->getType() == PSNodeType::FUNCTION)
return;
assert(n->getType() == PSNodeType::ALLOC ||
n->getType() == PSNodeType::UNKNOWN_MEM);
MemoryObject *mo = n->getData<MemoryObject>();
if (!mo) {
mo = new MemoryObject(n);
memory_objects.emplace_back(mo);
n->setData<MemoryObject>(mo);
}
objects.push_back(mo);
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x7b680
cmpl $0x6, %eax
je 0x7fd2d
movq 0x40(%rsp), %rdi
callq 0x7b680
cmpl $0x4, %eax
jne 0x7fd46
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7e9b0
movq %rax, 0x40(%rsp)
jmp 0x7fd8b
movq 0x40(%rsp), %rdi
callq 0x7b680
cmpl $0x12, %eax
jne 0x7fd89
movq 0x40(%rsp), %rsi
addq $0xb0, %rsi
leaq 0x18(%rsp), %rdi
callq 0x77620
leaq 0x18(%rsp), %rdi
callq 0x778c0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x7fd8b
movq 0x40(%rsp), %rdi
callq 0x7b680
cmpl $0x7, %eax
jne 0x7fd9c
jmp 0x7fe13
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0x808e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x7fe04
movl $0x38, %edi
callq 0x6c270
movq %rax, %rdi
movq %rdi, (%rsp)
movq 0x40(%rsp), %rsi
callq 0x7a9a0
movq (%rsp), %rax
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x88, %rdi
leaq 0x10(%rsp), %rsi
callq 0x808f0
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rsi
callq 0x80960
movq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7aa50
addq $0x68, %rsp
retq
nopl (%rax,%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFI.h |
dg::DGLLVMPointerAnalysisImpl<dg::pta::PointerAnalysisFI>::handleFork(dg::pta::PSNode*, dg::pta::PSNode*) | bool handleFork(PSNode *forkNode, PSNode *called) override {
using namespace llvm;
using namespace dg::pta;
assert(called->getType() == PSNodeType::FUNCTION &&
"The called value is not a function");
PSNodeFork *fork = PSNodeFork::get(forkNode);
builder->addFunctionToFork(called, fork);
#ifndef NDEBUG
// check the graph after rebuilding, but do not check for connectivity,
// because we can call a function that will disconnect the graph
if (!builder->validateSubgraph(true)) {
const llvm::Function *F = llvm::cast<llvm::Function>(
called->getUserData<llvm::Value>());
llvm::errs() << "Pointer Subgraph is broken!\n";
llvm::errs() << "This happend after building this function spawned "
"in a thread: "
<< F->getName() << "\n";
abort();
}
#endif // NDEBUG
return true;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x7fb70
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0xa0(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x6c1d0
movb $0x1, %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::pta::PointerAnalysisFI::~PointerAnalysisFI() | void preprocessGEPs() {
// if a node is in a loop (a scc that has more than one node),
// then every GEP that is also stored to the same memory afterwards
// in the loop will end up with Offset::UNKNOWN after some
// number of iterations (in FI analysis), so we can do that right now
// and save iterations
assert(getPG() && "Must have PG");
for (const auto &sg : getPG()->getSubgraphs()) {
for (const auto &loop : sg->getLoops()) {
for (PSNode *n : loop) {
if (PSNodeGep *gep = PSNodeGep::get(n))
gep->setOffset(Offset::UNKNOWN);
}
}
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x3080e(%rip), %rax # 0xb09c8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x88, %rdi
callq 0x80770
movq 0x8(%rsp), %rdi
callq 0x794a0
addq $0x18, %rsp
retq
nopl (%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFI.h |
dg::pta::PointerAnalysisFI::preprocessGEPs() | void preprocessGEPs() {
// if a node is in a loop (a scc that has more than one node),
// then every GEP that is also stored to the same memory afterwards
// in the loop will end up with Offset::UNKNOWN after some
// number of iterations (in FI analysis), so we can do that right now
// and save iterations
assert(getPG() && "Must have PG");
for (const auto &sg : getPG()->getSubgraphs()) {
for (const auto &loop : sg->getLoops()) {
for (PSNode *n : loop) {
if (PSNodeGep *gep = PSNodeGep::get(n))
gep->setOffset(Offset::UNKNOWN);
}
}
}
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x6d670
movq %rax, %rdi
callq 0x80ee0
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x80ef0
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x80f20
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x80f50
testb $0x1, %al
jne 0x80dc6
jmp 0x80edb
leaq 0x60(%rsp), %rdi
callq 0x80f90
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x80fa0
movq %rax, %rdi
callq 0x80fb0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x80ff0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x81020
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x81050
testb $0x1, %al
jne 0x80e22
jmp 0x80eca
leaq 0x40(%rsp), %rdi
callq 0x81090
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7c9f0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7ca20
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x7ca50
testb $0x1, %al
jne 0x80e6e
jmp 0x80eb9
leaq 0x20(%rsp), %rdi
callq 0x7ca90
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x810a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x80eab
movq 0x8(%rsp), %rdi
movq 0x30145(%rip), %rax # 0xb0fe8
movq (%rax), %rsi
callq 0x810e0
jmp 0x80ead
leaq 0x20(%rsp), %rdi
callq 0x7cbf0
jmp 0x80e59
jmp 0x80ebb
leaq 0x40(%rsp), %rdi
callq 0x81130
jmp 0x80e0a
jmp 0x80ecc
leaq 0x60(%rsp), %rdi
callq 0x81150
jmp 0x80dae
addq $0x78, %rsp
retq
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFI.h |
dg::pta::PointerAnalysisFSInv::beforeProcessed(dg::pta::PSNode*) | bool beforeProcessed(PSNode *n) override {
MemoryMapT *mm = n->getData<MemoryMapT>();
if (mm)
return false;
// on these nodes the memory map can change
if (needsMerge(n)) { // root node
mm = createMM();
// if this is the root of the entry procedure,
// we must propagate the points-to information
// from the globals initialization
if (n == PG->getEntry()->getRoot()) {
mergeGlobalsState(mm, PG->getGlobals());
}
} else {
// this node can not change the memory map,
// so just add a pointer from the predecessor
// to this map
PSNode *pred = n->getSinglePredecessor();
mm = pred->getData<MemoryMapT>();
assert(mm && "No memory map in the predecessor");
}
assert(mm && "Did not create the MM");
// memory map initialized, set it as data,
// so that we won't initialize it again
n->setData<MemoryMapT>(mm);
return true;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x8138d
movb $0x0, 0x47(%rsp)
jmp 0x81441
movq 0x30(%rsp), %rdi
callq 0x81870
testb $0x1, %al
jne 0x8139d
jmp 0x81403
movq 0x18(%rsp), %rdi
callq 0x7c230
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x38(%rax), %rdi
callq 0x7c2a0
movq %rax, %rdi
callq 0x7c2b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x81401
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x38(%rax), %rdi
callq 0x7c360
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x7c2c0
jmp 0x81429
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x7c380
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
movq 0x28(%rsp), %rsi
callq 0x7c3a0
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::DGLLVMPointerAnalysisImpl<dg::pta::PointerAnalysisFSInv>::handleFork(dg::pta::PSNode*, dg::pta::PSNode*) | bool handleFork(PSNode *forkNode, PSNode *called) override {
using namespace llvm;
using namespace dg::pta;
assert(called->getType() == PSNodeType::FUNCTION &&
"The called value is not a function");
PSNodeFork *fork = PSNodeFork::get(forkNode);
builder->addFunctionToFork(called, fork);
#ifndef NDEBUG
// check the graph after rebuilding, but do not check for connectivity,
// because we can call a function that will disconnect the graph
if (!builder->validateSubgraph(true)) {
const llvm::Function *F = llvm::cast<llvm::Function>(
called->getUserData<llvm::Value>());
llvm::errs() << "Pointer Subgraph is broken!\n";
llvm::errs() << "This happend after building this function spawned "
"in a thread: "
<< F->getName() << "\n";
abort();
}
#endif // NDEBUG
return true;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x7fb70
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0xa0(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x6c1d0
movb $0x1, %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /mchalupa[P]dg/include/dg/llvm/PointerAnalysis/PointerAnalysis.h |
dg::pta::PointerAnalysisFSInv::handleUninitialized(std::map<dg::pta::PSNode*, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>, std::less<dg::pta::PSNode*>, std::allocator<std::pair<dg::pta::PSNode* const, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>>>>*, std::map<dg::pta::PSNode*, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>, std::less<dg::pta::PSNode*>, std::allocator<std::pair<dg::pta::PSNode* const, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>>>>*) | bool handleUninitialized(MemoryMapT *mm, MemoryMapT *pm) {
bool changed = false;
for (auto &it : *mm) {
auto pmit = pm->find(it.first);
if (pmit == pm->end()) {
for (auto &mit : *it.second) {
if (mit.first.isUnknown())
continue; // FIXME: we are optimistic here...
changed |= it.second->addPointsTo(mit.first,
Pointer{INVALIDATED, 0});
}
continue;
}
/* check the initialization of memory objects
auto *pmo = pmit->second.get();
for (auto &mit : *it.second) {
if (pmo->find(mit.first) != pmo->end())
continue;
if (mit.first.isUnknown())
continue; // FIXME: we are optimistic here...
changed |= it.second->addPointsTo(mit.first,
Pointer{INVALIDATED, 0});
}
*/
}
return changed;
} | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movb $0x0, 0x8f(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x7cc40
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x7a850
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x7a830
testb $0x1, %al
jne 0x81be3
jmp 0x81d46
leaq 0x78(%rsp), %rdi
callq 0x7cc70
movq %rax, 0x68(%rsp)
movq 0x90(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x7a800
movq %rax, 0x60(%rsp)
movq 0x90(%rsp), %rdi
callq 0x7a850
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x7ac30
testb $0x1, %al
jne 0x81c33
jmp 0x81d35
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
callq 0x83860
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x82260
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x82290
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7d920
testb $0x1, %al
jne 0x81c7c
jmp 0x81d33
leaq 0x48(%rsp), %rdi
callq 0x7d940
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x71990
testb $0x1, %al
jne 0x81c9b
jmp 0x81ca0
jmp 0x81d24
movq 0x68(%rsp), %rdi
addq $0x8, %rdi
callq 0x83890
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x2f2fc(%rip), %rax # 0xb0fc0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71570
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x71590
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x838a0
andb $0x1, %al
movzbl %al, %ecx
movb 0x8f(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x8f(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x7da50
jmp 0x81c64
jmp 0x81d37
jmp 0x81d37
leaq 0x78(%rsp), %rdi
callq 0x7cfe0
jmp 0x81bcb
movb 0x8f(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::containsRemovableLocals(dg::pta::PSNode*, dg::pta::PointerIdPointsToSet&) | static bool containsRemovableLocals(PSNode *where, PointsToSetT &S) {
for (const auto &ptr : S) {
if (ptr.isNull() || ptr.isUnknown() || ptr.isInvalidated())
continue;
if (PSNodeAlloc *alloc = PSNodeAlloc::get(ptr.target)) {
if (isLocal(alloc, where) && knownInstance(alloc))
return true;
}
}
return false;
} | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x77620
movq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x77970
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x77a10
testb $0x1, %al
jne 0x8230e
jmp 0x823b3
leaq 0x40(%rsp), %rdi
callq 0x778c0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x77aa0
testb $0x1, %al
jne 0x82358
movq 0x20(%rsp), %rdi
callq 0x77ac0
testb $0x1, %al
jne 0x82358
movq 0x20(%rsp), %rdi
callq 0x77a80
testb $0x1, %al
jne 0x82358
jmp 0x8235a
jmp 0x823a4
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x82540
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x823a2
movq 0x8(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x82580
testb $0x1, %al
jne 0x82389
jmp 0x823a0
movq 0x8(%rsp), %rdi
callq 0x82600
testb $0x1, %al
jne 0x82399
jmp 0x823a0
movb $0x1, 0x77(%rsp)
jmp 0x823b8
jmp 0x823a2
jmp 0x823a4
leaq 0x40(%rsp), %rdi
callq 0x779a0
jmp 0x822f6
movb $0x0, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::replaceLocalsWithInv(dg::pta::PSNode*, dg::pta::PointerIdPointsToSet&) | static void replaceLocalsWithInv(PSNode *where, PointsToSetT &S1) {
PointsToSetT S;
for (const auto &ptr : S1) {
if (ptr.isNull() || ptr.isUnknown() || ptr.isInvalidated())
continue;
if (PSNodeAlloc *alloc = PSNodeAlloc::get(ptr.target)) {
// if this is not local pointer or it is,
// but we do not know which instance is being destroyed,
// then keep the pointer
if (!isLocal(alloc, where) || !knownInstance(alloc))
S.add(ptr);
}
}
S.add(INVALIDATED, 0);
S1.swap(S);
} | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x7e5c0
movq 0xa8(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x77620
movq 0x68(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x77970
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x77a10
testb $0x1, %al
jne 0x82434
jmp 0x824e2
leaq 0x50(%rsp), %rdi
callq 0x778c0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x77aa0
testb $0x1, %al
jne 0x8247e
movq 0x30(%rsp), %rdi
callq 0x77ac0
testb $0x1, %al
jne 0x8247e
movq 0x30(%rsp), %rdi
callq 0x77a80
testb $0x1, %al
jne 0x8247e
jmp 0x82480
jmp 0x824d3
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x82540
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x824d1
movq 0x18(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x82580
testb $0x1, %al
jne 0x824b2
jmp 0x824c0
movq 0x18(%rsp), %rdi
callq 0x82600
testb $0x1, %al
jne 0x824cf
movq 0x30(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x71880
jmp 0x824d1
jmp 0x824d3
leaq 0x50(%rsp), %rdi
callq 0x779a0
jmp 0x8241c
movq 0x2ead7(%rip), %rax # 0xb0fc0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71570
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x82620
movq 0xa8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x82670
leaq 0x70(%rsp), %rdi
callq 0x715f0
addq $0xb8, %rsp
retq
nopw (%rax,%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::invalidateMemory(dg::pta::PSNode*, dg::pta::PSNode*, bool) | static bool invalidateMemory(PSNode *node, PSNode *pred,
bool is_free = false) {
MemoryMapT *pmm = pred->getData<MemoryMapT>();
if (!pmm) {
// predecessor was not processed yet
return false;
}
MemoryMapT *mm = node->getData<MemoryMapT>();
assert(mm && "Node does not have memory map");
bool changed = false;
PSNode *operand = node->getOperand(0);
PSNode *strong_update = nullptr;
// if we call e.g. free(load p), then the contents of
// the memory pointed by p will point
// to invalidated memory (we can do this when we
// know precisely what is the memory).
if (is_free) {
strong_update = moFromFreeToOverwrite(operand);
if (strong_update)
changed |= overwriteMOFromFree(mm, strong_update);
}
for (auto &I : *pmm) {
assert(I.first && "nullptr as target");
if (isInvalidTarget(I.first))
continue;
// strong update on this variable?
if (strong_update == I.first)
continue;
// get or create a memory object for this target
MemoryObject *mo = getOrCreateMO(mm, I.first);
MemoryObject *pmo = I.second.get();
// Remove references to invalidated memory from mo
// if the invalidated object is just one.
// Otherwise, add the invalidated pointer to the points-to sets
// (strong vs. weak update) as we do not know which
// object is actually being invalidated.
for (auto &it : *mo) {
if (invStrongUpdate(operand)) { // strong update
const auto &ptr = *(operand->pointsTo.begin());
if (ptr.isUnknown())
changed |= it.second.add(INVALIDATED, 0);
else if (ptr.isNull() || ptr.isInvalidated())
continue;
else if (it.second.pointsToTarget(ptr.target)) {
replaceTargetWithInv(it.second, ptr.target);
assert(!it.second.pointsToTarget(ptr.target));
changed = true;
}
} else { // weak update
for (const auto &ptr : operand->pointsTo) {
if (ptr.isNull() || ptr.isInvalidated())
continue;
// invalidate on unknown memory yields invalidate for
// each element
if (ptr.isUnknown() ||
it.second.pointsToTarget(ptr.target)) {
changed |= it.second.add(INVALIDATED, 0);
}
}
}
}
// merge pointers from pmo to mo, but skip
// the pointers that may point to the freed memory
for (auto &it : *pmo) {
PointsToSetT &predS = it.second;
if (predS.empty()) // keep the map clean
continue;
PointsToSetT &S = mo->pointsTo[it.first];
// merge pointers from the previous states
// but do not include the pointers
// that may point to freed memory.
// These must be replaced with invalidated.
for (const auto &ptr : predS) {
if (ptr.isValid() && // if the ptr is null or unkown,
// we want to copy it
operand->pointsTo.pointsToTarget(ptr.target)) {
if (!invStrongUpdate(operand)) {
// we still want to copy the original pointer
// if we cannot perform strong update
// on this invalidated memory
changed |= S.add(ptr);
}
changed |= S.add(INVALIDATED, 0);
} else {
// this is a pointer to some memory that was not
// invalidated, so merge it into the points-to set
changed |= S.add(ptr);
}
}
assert(!S.empty());
}
}
return changed;
} | subq $0x1e8, %rsp # imm = 0x1E8
movb %dl, %al
movq %rdi, 0x1d8(%rsp)
movq %rsi, 0x1d0(%rsp)
andb $0x1, %al
movb %al, 0x1cf(%rsp)
movq 0x1d0(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x1c0(%rsp)
cmpq $0x0, 0x1c0(%rsp)
jne 0x82783
movb $0x0, 0x1e7(%rsp)
jmp 0x82ec9
movq 0x1d8(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a7f0
movq %rax, 0x1b8(%rsp)
movb $0x0, 0x1b7(%rsp)
movq 0x1d8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7e9b0
movq %rax, 0x1a8(%rsp)
movq $0x0, 0x1a0(%rsp)
testb $0x1, 0x1cf(%rsp)
je 0x82830
movq 0x1a8(%rsp), %rdi
callq 0x82ee0
movq %rax, 0x1a0(%rsp)
cmpq $0x0, 0x1a0(%rsp)
je 0x8282e
movq 0x1b8(%rsp), %rdi
movq 0x1a0(%rsp), %rsi
callq 0x82fa0
andb $0x1, %al
movzbl %al, %ecx
movb 0x1b7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x1b7(%rsp)
jmp 0x82830
movq 0x1c0(%rsp), %rax
movq %rax, 0x198(%rsp)
movq 0x198(%rsp), %rdi
callq 0x7cc40
movq %rax, 0x190(%rsp)
movq 0x198(%rsp), %rdi
callq 0x7a850
movq %rax, 0x188(%rsp)
leaq 0x190(%rsp), %rdi
leaq 0x188(%rsp), %rsi
callq 0x7a830
testb $0x1, %al
jne 0x82888
jmp 0x82eb9
leaq 0x190(%rsp), %rdi
callq 0x7cc70
movq %rax, 0x180(%rsp)
movq 0x180(%rsp), %rax
movq (%rax), %rdi
callq 0x82190
testb $0x1, %al
jne 0x828b3
jmp 0x828b8
jmp 0x82ea7
movq 0x1a0(%rsp), %rax
movq 0x180(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x828d2
jmp 0x82ea7
movq 0x1b8(%rsp), %rdi
movq 0x180(%rsp), %rax
movq (%rax), %rsi
callq 0x821e0
movq %rax, 0x178(%rsp)
movq 0x180(%rsp), %rdi
addq $0x8, %rdi
callq 0x7a8d0
movq %rax, 0x170(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0x168(%rsp)
movq 0x168(%rsp), %rdi
callq 0x82260
movq %rax, 0x160(%rsp)
movq 0x168(%rsp), %rdi
callq 0x82290
movq %rax, 0x158(%rsp)
leaq 0x160(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0x7d920
testb $0x1, %al
jne 0x82963
jmp 0x82c49
leaq 0x160(%rsp), %rdi
callq 0x7d940
movq %rax, 0x150(%rsp)
movq 0x1a8(%rsp), %rdi
callq 0x83110
testb $0x1, %al
jne 0x8298e
jmp 0x82ace
movq 0x1a8(%rsp), %rsi
addq $0xb0, %rsi
leaq 0x120(%rsp), %rdi
callq 0x77620
leaq 0x120(%rsp), %rdi
callq 0x778c0
movq %rax, 0x138(%rsp)
movq %rdx, 0x140(%rsp)
leaq 0x138(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0x148(%rsp), %rdi
callq 0x77ac0
testb $0x1, %al
jne 0x829ea
jmp 0x82a56
movq 0x150(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x2e5be(%rip), %rax # 0xb0fc0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x118(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71570
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x118(%rsp), %rdx
callq 0x82620
andb $0x1, %al
movzbl %al, %ecx
movb 0x1b7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x1b7(%rsp)
jmp 0x82ac9
movq 0x148(%rsp), %rdi
callq 0x77aa0
testb $0x1, %al
jne 0x82a7a
movq 0x148(%rsp), %rdi
callq 0x77a80
testb $0x1, %al
jne 0x82a7a
jmp 0x82a7f
jmp 0x82c37
movq 0x150(%rsp), %rdi
addq $0x8, %rdi
movq 0x148(%rsp), %rax
movq (%rax), %rsi
callq 0x77700
testb $0x1, %al
jne 0x82aa1
jmp 0x82ac5
movq 0x150(%rsp), %rdi
addq $0x8, %rdi
movq 0x148(%rsp), %rax
movq (%rax), %rsi
callq 0x831d0
movb $0x1, 0x1b7(%rsp)
jmp 0x82ac7
jmp 0x82ac9
jmp 0x82c35
movq 0x1a8(%rsp), %rax
addq $0xb0, %rax
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rsi
leaq 0xf8(%rsp), %rdi
callq 0x77620
movq 0x110(%rsp), %rsi
leaq 0xe0(%rsp), %rdi
callq 0x77970
leaq 0xf8(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x77a10
testb $0x1, %al
jne 0x82b2c
jmp 0x82c33
leaq 0xf8(%rsp), %rdi
callq 0x778c0
movq %rax, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
leaq 0xc8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rdi
callq 0x77aa0
testb $0x1, %al
jne 0x82b7d
movq 0xd8(%rsp), %rdi
callq 0x77a80
testb $0x1, %al
jne 0x82b7d
jmp 0x82b82
jmp 0x82c21
movq 0xd8(%rsp), %rdi
callq 0x77ac0
testb $0x1, %al
jne 0x82bb5
movq 0x150(%rsp), %rdi
addq $0x8, %rdi
movq 0xd8(%rsp), %rax
movq (%rax), %rsi
callq 0x77700
testb $0x1, %al
jne 0x82bb5
jmp 0x82c1f
movq 0x150(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x2e3f3(%rip), %rax # 0xb0fc0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
leaq 0xc0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71570
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0xc0(%rsp), %rdx
callq 0x82620
andb $0x1, %al
movzbl %al, %ecx
movb 0x1b7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x1b7(%rsp)
jmp 0x82c21
leaq 0xf8(%rsp), %rdi
callq 0x779a0
jmp 0x82b0e
jmp 0x82c35
jmp 0x82c37
leaq 0x160(%rsp), %rdi
callq 0x7da50
jmp 0x82945
movq 0x170(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x82260
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x82290
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x7d920
testb $0x1, %al
jne 0x82ca1
jmp 0x82ea5
leaq 0xb0(%rsp), %rdi
callq 0x7d940
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0x70460
testb $0x1, %al
jne 0x82cdd
jmp 0x82ce2
jmp 0x82e93
movq 0x178(%rsp), %rdi
addq $0x8, %rdi
movq 0xa0(%rsp), %rsi
callq 0x7d960
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x77620
movq 0x88(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x77970
leaq 0x70(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x77a10
testb $0x1, %al
jne 0x82d4f
jmp 0x82e91
leaq 0x70(%rsp), %rdi
callq 0x778c0
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x77a40
testb $0x1, %al
jne 0x82d80
jmp 0x82e4c
movq 0x1a8(%rsp), %rdi
addq $0xb0, %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rsi
callq 0x77700
testb $0x1, %al
jne 0x82da5
jmp 0x82e4c
movq 0x1a8(%rsp), %rdi
callq 0x83110
testb $0x1, %al
jne 0x82dea
movq 0x90(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x71880
andb $0x1, %al
movzbl %al, %ecx
movb 0x1b7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x1b7(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x2e1c2(%rip), %rax # 0xb0fc0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71570
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x82620
andb $0x1, %al
movzbl %al, %ecx
movb 0x1b7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x1b7(%rsp)
jmp 0x82e80
movq 0x90(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x71880
andb $0x1, %al
movzbl %al, %ecx
movb 0x1b7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x1b7(%rsp)
jmp 0x82e82
leaq 0x70(%rsp), %rdi
callq 0x779a0
jmp 0x82d37
jmp 0x82e93
leaq 0xb0(%rsp), %rdi
callq 0x7da50
jmp 0x82c83
jmp 0x82ea7
leaq 0x190(%rsp), %rdi
callq 0x7cfe0
jmp 0x8286a
movb 0x1b7(%rsp), %al
andb $0x1, %al
movb %al, 0x1e7(%rsp)
movb 0x1e7(%rsp), %al
andb $0x1, %al
addq $0x1e8, %rsp # imm = 0x1E8
retq
nopw (%rax,%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::moFromFreeToOverwrite(dg::pta::PSNode*) | static PSNode *moFromFreeToOverwrite(PSNode *operand) {
// Bail out if the operand has no pointers yet,
// otherwise we can add invalidated imprecisely
// (the rest of invalidateMemory would not perform strong update)
if (operand->pointsTo.empty())
return nullptr;
// invalidate(p) translates to
// 1 = load x
// ...
// invalidate(1)
// Get objects where x may point to. If this object is only one,
// then we know that this object will point to invalid memory
// (no what is its state).
PSNode *strippedOp = operand->stripCasts();
if (strippedOp->getType() == PSNodeType::LOAD) {
// get the pointer to the memory that holds the pointers
// that are being freed
PSNode *loadOp = strippedOp->getOperand(0);
if (invStrongUpdate(loadOp)) {
return (*(loadOp->pointsTo.begin())).target;
}
}
return nullptr;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
addq $0xb0, %rdi
callq 0x70460
testb $0x1, %al
jne 0x82f00
jmp 0x82f0e
movq $0x0, 0x40(%rsp)
jmp 0x82f90
movq 0x38(%rsp), %rdi
callq 0x832e0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7b680
cmpl $0x2, %eax
jne 0x82f87
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7e9b0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x83110
testb $0x1, %al
jne 0x82f53
jmp 0x82f85
movq 0x28(%rsp), %rsi
addq $0xb0, %rsi
movq %rsp, %rdi
callq 0x77620
movq %rsp, %rdi
callq 0x778c0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x82f90
jmp 0x82f87
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::overwriteMOFromFree(std::map<dg::pta::PSNode*, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>, std::less<dg::pta::PSNode*>, std::allocator<std::pair<dg::pta::PSNode* const, std::unique_ptr<dg::pta::MemoryObject, std::default_delete<dg::pta::MemoryObject>>>>>*, dg::pta::PSNode*) | static bool overwriteMOFromFree(MemoryMapT *mm, PSNode *target) {
// if we know exactly which memory object
// is being used for freeing the memory,
// we can set it to invalidated
auto *mo = getOrCreateMO(mm, target);
if (mo->pointsTo.size() == 1) {
auto &S = mo->pointsTo[0];
if (S.size() == 1 && (*S.begin()).target == INVALIDATED) {
return false; // no update
}
}
mo->pointsTo.clear();
mo->pointsTo[0].add(INVALIDATED, 0);
return true;
} | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x821e0
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
addq $0x8, %rdi
callq 0x83330
cmpq $0x1, %rax
jne 0x83081
movq 0x78(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
leaq 0x68(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71570
movq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x83340
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x778b0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
movb %al, 0x2f(%rsp)
jne 0x8306b
movq 0x70(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x77620
leaq 0x40(%rsp), %rdi
callq 0x778c0
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq 0x2df5f(%rip), %rcx # 0xb0fc0
cmpq (%rcx), %rax
sete %al
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x83075
jmp 0x8307f
movb $0x0, 0x97(%rsp)
jmp 0x830f8
jmp 0x83081
movq 0x78(%rsp), %rdi
addq $0x8, %rdi
callq 0x83430
movq 0x78(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71570
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x83340
movq %rax, 0x10(%rsp)
movq 0x2defa(%rip), %rax # 0xb0fc0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71570
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x82620
movb $0x1, 0x97(%rsp)
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
nopl (%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::pta::PointerAnalysisFSInv::invStrongUpdate(dg::pta::PSNode const*) | static bool invStrongUpdate(const PSNode *operand) {
// If we are freeing memory through node that
// points to precisely known valid memory that is not allocated
// on a loop, we can do strong update.
//
// TODO: we can do strong update also on must-aliases
// of the invalidated pointer. That is, e.g. for
// free(p), we may do strong update for q if q is must-alias
// of p (no matter the size of p's and q's points-to sets)
if (operand->pointsTo.size() != 1)
return false;
const auto &ptr = *(operand->pointsTo.begin());
return !ptr.offset.isUnknown() && !isInvalidTarget(ptr.target) &&
knownInstance(ptr.target);
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
addq $0xb0, %rdi
callq 0x778b0
cmpq $0x1, %rax
je 0x8313a
movb $0x0, 0x47(%rsp)
jmp 0x831be
movq 0x38(%rsp), %rsi
addq $0xb0, %rsi
leaq 0x8(%rsp), %rdi
callq 0x77620
leaq 0x8(%rsp), %rdi
callq 0x778c0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x71990
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x831b4
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x82190
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x831b4
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x82600
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
| /mchalupa[P]dg/include/dg/PointerAnalysis/PointerAnalysisFSInv.h |
dg::llvmdg::LazyLLVMCallGraph::_initializeAddressTaken() | void _initializeAddressTaken() {
assert(!_address_taken_initialized);
_address_taken_initialized = true;
for (auto &F : *_module) {
if (F.isDeclaration())
continue;
if (funHasAddressTaken(&F)) {
_address_taken.push_back(&F);
}
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movb $0x1, 0xa0(%rax)
movq 0x40(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x86db0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x86de0
testb $0x1, %al
jne 0x895e5
jmp 0x89643
leaq 0x20(%rsp), %rdi
callq 0x86e00
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x6c370
testb $0x1, %al
jne 0x89604
jmp 0x89606
jmp 0x89637
movq 0x10(%rsp), %rdi
callq 0x86200
testb $0x1, %al
jne 0x89616
jmp 0x89635
movq (%rsp), %rdi
addq $0x88, %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x89650
jmp 0x89637
leaq 0x20(%rsp), %rdi
callq 0x87280
jmp 0x895d0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| /mchalupa[P]dg/include/dg/llvm/CallGraph/CallGraph.h |
dg::GenericCallGraph<llvm::Function const*>::FuncNode::addCall(dg::GenericCallGraph<llvm::Function const*>::FuncNode*) | bool addCall(FuncNode *x) {
if (calls(x))
return false;
_calls.push_back(x);
if (!x->isCalledBy(this))
x->_callers.push_back(this);
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rsi
callq 0x8ca80
testb $0x1, %al
jne 0x8be57
jmp 0x8be5e
movb $0x0, 0x27(%rsp)
jmp 0x8bea3
movq (%rsp), %rdi
addq $0x8, %rdi
leaq 0x10(%rsp), %rsi
callq 0x8cab0
movq (%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x8cb20
testb $0x1, %al
jne 0x8be9e
movq (%rsp), %rax
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x8cb50
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
| /mchalupa[P]dg/include/dg/CallGraph/CallGraph.h |
trie_insert | void trie_insert(struct trie_node *root, struct trie_node *new, const unsigned int lvl)
{
if (new->len < root->len)
swap_nodes(root, new);
if (is_left_child(&new->prefix, lvl)) {
if (!root->lchild)
return add_child_node(root, new, LEFT);
return trie_insert(root->lchild, new, lvl + 1);
}
if (!root->rchild)
return add_child_node(root, new, RIGHT);
trie_insert(root->rchild, new, lvl + 1);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movb 0x38(%rdi), %al
cmpb %al, 0x38(%rsi)
jae 0x225c
movl 0x10(%r14), %ecx
movl %ecx, 0x30(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x30(%r14), %rcx
movups (%rbx), %xmm0
movups %xmm0, (%r14)
movl 0x10(%rbx), %edx
movl %edx, 0x10(%r14)
movb 0x38(%rbx), %dl
movb %dl, 0x38(%r14)
movq 0x30(%rbx), %rdx
movq %rdx, 0x30(%r14)
movl 0x30(%rsp), %edx
movl %edx, 0x10(%rbx)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rbx)
movb %al, 0x38(%rbx)
movq %rcx, 0x30(%rbx)
movzbl %bpl, %edx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq 0x3528
movl 0x10(%r15), %eax
movl %eax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x34d0
testb %al, %al
je 0x229d
movq 0x20(%r14), %rdi
testq %rdi, %rdi
jne 0x22a6
movq %rbx, 0x20(%r14)
jmp 0x22b8
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x22b4
incl %ebp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x21ec
jmp 0x22bc
movq %rbx, 0x18(%r14)
movq %r14, 0x28(%rbx)
movq %fs:0x28, %rax
cmpq 0x50(%rsp), %rax
jne 0x22d7
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x20c0
| /rtrlib[P]rtrlib/./rtrlib/pfx/trie/trie.c |
trie_lookup | struct trie_node *trie_lookup(const struct trie_node *root, const struct lrtr_ip_addr *prefix, const uint8_t mask_len,
unsigned int *lvl)
{
while (root) {
if (root->len <= mask_len && lrtr_ip_addr_equal(lrtr_ip_addr_get_bits(&root->prefix, 0, root->len),
lrtr_ip_addr_get_bits(prefix, 0, root->len)))
return (struct trie_node *)root;
if (is_left_child(prefix, *lvl))
root = root->lchild;
else
root = root->rchild;
(*lvl)++;
}
return NULL;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %fs:0x28, %rax
movq %rax, 0x80(%rsp)
testq %rdi, %rdi
je 0x23b1
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x68(%rsp), %r12
leaq 0x38(%rsp), %r13
movb 0x38(%rbx), %al
cmpb %bpl, %al
ja 0x2373
movzbl %al, %ecx
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3528
movzbl 0x38(%rbx), %ecx
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3528
movl 0x48(%rsp), %eax
movl %eax, 0x28(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x10(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x3591
testb %al, %al
jne 0x23b3
movzbl (%r14), %edx
movq %r12, %rdi
movq %r15, %rsi
movl $0x1, %ecx
callq 0x3528
movl 0x78(%rsp), %eax
movl %eax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x34d0
movzbl %al, %eax
movq 0x18(%rbx,%rax,8), %rbx
incl (%r14)
testq %rbx, %rbx
jne 0x231c
xorl %ebx, %ebx
movq %fs:0x28, %rax
cmpq 0x80(%rsp), %rax
jne 0x23db
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20c0
| /rtrlib[P]rtrlib/./rtrlib/pfx/trie/trie.c |
trie_lookup_exact | struct trie_node *trie_lookup_exact(struct trie_node *root_node, const struct lrtr_ip_addr *prefix,
const uint8_t mask_len, unsigned int *lvl, bool *found)
{
*found = false;
while (root_node) {
if (*lvl > 0 && root_node->len > mask_len) {
(*lvl)--;
return root_node->parent;
}
if (root_node->len == mask_len && lrtr_ip_addr_equal(root_node->prefix, *prefix)) {
*found = true;
return root_node;
}
if (is_left_child(prefix, *lvl)) {
if (!root_node->lchild)
return root_node;
root_node = root_node->lchild;
} else {
if (!root_node->rchild)
return root_node;
root_node = root_node->rchild;
}
(*lvl)++;
}
return NULL;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movb $0x0, (%r8)
testq %rdi, %rdi
je 0x242e
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movl (%rcx), %eax
testl %eax, %eax
setne %cl
movb 0x38(%rdi), %dl
cmpb %bpl, %dl
seta %sil
testb %sil, %cl
je 0x2436
movq %r14, %rcx
jmp 0x24e1
xorl %r14d, %r14d
jmp 0x24e9
movq %r8, %r15
leaq 0x30(%rsp), %r13
cmpb %bpl, %dl
jne 0x2487
movl 0x10(%r12), %eax
movl %eax, 0x40(%rsp)
movups (%r12), %xmm0
movaps %xmm0, 0x30(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x28(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movl 0x10(%r14), %eax
movl %eax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0x3591
testb %al, %al
jne 0x250b
movl (%rbx), %eax
movzbl %al, %edx
movq %r13, %rdi
movq %r12, %rsi
movl $0x1, %ecx
callq 0x3528
movl 0x40(%rsp), %eax
movl %eax, 0x10(%rsp)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x34d0
testb %al, %al
je 0x24ba
movq 0x20(%r14), %rcx
jmp 0x24be
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0x24e9
movl (%rbx), %eax
movq %rcx, %r14
incl %eax
movl %eax, (%rbx)
movb 0x38(%rcx), %dl
je 0x243e
movq %rcx, %r14
cmpb %bpl, %dl
jbe 0x243e
decl %eax
movl %eax, (%rbx)
movq 0x28(%rcx), %r14
movq %fs:0x28, %rax
cmpq 0x50(%rsp), %rax
jne 0x2511
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, (%r15)
jmp 0x24e9
callq 0x20c0
| /rtrlib[P]rtrlib/./rtrlib/pfx/trie/trie.c |
trie_remove | struct trie_node *trie_remove(struct trie_node *root, const struct lrtr_ip_addr *prefix, const uint8_t mask_len,
const unsigned int lvl)
{
/* If the node has no children we can simply remove it
* If the node has children, we swap the node with the child that
* has the smaller prefix length and drop the child.
*/
if (prefix_is_same(root, prefix, mask_len)) {
void *tmp;
if (trie_is_leaf(root)) {
deref_node(root);
return root;
}
/* swap with the left child and drop the child */
if (root->lchild && (!root->rchild || root->lchild->len < root->rchild->len)) {
tmp = root->data;
replace_node_data(root, root->lchild);
root->lchild->data = tmp;
return trie_remove(root->lchild, &root->lchild->prefix, root->lchild->len, lvl + 1);
}
/* swap with the right child and drop the child */
tmp = root->data;
replace_node_data(root, root->rchild);
root->rchild->data = tmp;
return trie_remove(root->rchild, &root->rchild->prefix, root->rchild->len, lvl + 1);
}
if (is_left_child(prefix, lvl)) {
if (!root->lchild)
return NULL;
return trie_remove(root->lchild, prefix, mask_len, lvl + 1);
}
if (!root->rchild)
return NULL;
return trie_remove(root->rchild, prefix, mask_len, lvl + 1);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
cmpb %bpl, 0x38(%rdi)
jne 0x2634
movl 0x10(%r15), %eax
movl %eax, 0x40(%rsp)
movups (%r15), %xmm0
movaps %xmm0, 0x30(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x28(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movl 0x10(%r14), %eax
movl %eax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0x3591
testb %al, %al
je 0x2634
leaq 0x38(%r14), %rcx
movq 0x18(%r14), %r12
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x25a9
testq %r12, %r12
je 0x25a4
movb 0x38(%rax), %dl
cmpb 0x38(%r12), %dl
jae 0x25b2
movq %rax, %r12
jmp 0x25b2
testq %r12, %r12
je 0x26b1
movq 0x30(%r14), %rax
movups (%r12), %xmm0
movups %xmm0, (%r14)
movl 0x10(%r12), %edx
movl %edx, 0x10(%r14)
leaq 0x38(%r12), %r15
movb 0x38(%r12), %bpl
movb %bpl, (%rcx)
movq 0x30(%r12), %rcx
movq %rcx, 0x30(%r14)
movq %rax, 0x30(%r12)
incl %ebx
movl 0x10(%r12), %eax
movl %eax, 0x40(%rsp)
movups (%r12), %xmm0
movaps %xmm0, 0x30(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x28(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movl 0x10(%r12), %eax
movl %eax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
callq 0x3591
movq %r12, %r14
movq %r15, %rcx
movq %r12, %r15
testb %al, %al
jne 0x2588
jmp 0x2637
movq %r14, %r12
movzbl %bl, %edx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %ecx
callq 0x3528
movl 0x10(%r14), %eax
movl %eax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0x34d0
testb %al, %al
je 0x266f
movq 0x20(%r12), %rdi
jmp 0x2674
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x268e
incl %ebx
movzbl %bpl, %edx
movq %r15, %rsi
movl %ebx, %ecx
callq 0x2516
movq %rax, %r14
jmp 0x2691
xorl %r14d, %r14d
movq %fs:0x28, %rax
cmpq 0x48(%rsp), %rax
jne 0x26ce
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x2691
xorl %ecx, %ecx
cmpq %r14, 0x20(%rax)
sete %cl
movq $0x0, 0x18(%rax,%rcx,8)
jmp 0x2691
callq 0x20c0
| /rtrlib[P]rtrlib/./rtrlib/pfx/trie/trie.c |
main | int main(void)
{
trie_test();
printf("Test successful\n");
return EXIT_SUCCESS;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %fs:0x28, %rax
movq %rax, 0x130(%rsp)
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0xd0(%rsp), %r14
movb $0x10, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x28(%r14)
leaq 0x27d5(%rip), %rdi # 0x5004
movq %r14, %rsi
callq 0x362f
movups (%r14), %xmm0
leaq 0x110(%rsp), %rsi
movaps %xmm0, (%rsi)
movl 0x10(%r14), %eax
movl %eax, 0x10(%rsi)
movq %r14, %rdi
movl $0x10, %edx
movq %rbx, %rcx
callq 0x22dc
testq %rax, %rax
je 0x2e3f
leaq 0x2797(%rip), %rsi # 0x5004
movq %rax, %rdi
callq 0x36a8
testb %al, %al
je 0x2e5e
leaq 0x282c(%rip), %rdi # 0x50b0
leaq 0x110(%rsp), %rbx
movq %rbx, %rsi
callq 0x362f
leaq 0xd0(%rsp), %rdi
leaq 0xc(%rsp), %rcx
movq %rbx, %rsi
movl $0x10, %edx
callq 0x22dc
testq %rax, %rax
je 0x2e7d
leaq 0x2746(%rip), %rsi # 0x5004
movq %rax, %rdi
callq 0x36a8
testb %al, %al
je 0x2e9c
leaq 0x90(%rsp), %rbx
movb $0x10, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
leaq 0x27d1(%rip), %r14 # 0x50bd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x362f
leaq 0xd0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x21ec
leaq 0x110(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x362f
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
movq %r15, %rdi
movq %r12, %rsi
movl $0x10, %edx
callq 0x22dc
testq %rax, %rax
je 0x2ebb
leaq 0x2773(%rip), %rsi # 0x50bd
movq %rax, %rdi
callq 0x36a8
testb %al, %al
je 0x2eda
cmpq %rbx, 0xe8(%rsp)
jne 0x2ef9
leaq 0x50(%rsp), %rbx
movb $0x10, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
leaq 0x2787(%rip), %r14 # 0x510a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x362f
leaq 0xd0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x21ec
leaq 0x110(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x362f
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
movq %r15, %rdi
movq %r12, %rsi
movl $0x10, %edx
callq 0x22dc
testq %rax, %rax
je 0x2f18
leaq 0x2729(%rip), %rsi # 0x510a
movq %rax, %rdi
callq 0x36a8
testb %al, %al
je 0x2f37
cmpq %rbx, 0xf0(%rsp)
jne 0x2f56
leaq 0x10(%rsp), %rbx
movb $0x18, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
leaq 0x273d(%rip), %r14 # 0x5157
movq %r14, %rdi
movq %rbx, %rsi
callq 0x362f
leaq 0xd0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x21ec
leaq 0x110(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x362f
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
movq %r15, %rdi
movq %rbx, %rsi
movl $0x18, %edx
callq 0x22dc
testq %rax, %rax
je 0x2f75
leaq 0x26df(%rip), %rsi # 0x5157
movq %rax, %rdi
callq 0x36a8
testb %al, %al
je 0x2f94
leaq 0x2575(%rip), %rsi # 0x5004
leaq 0xd0(%rsp), %rdi
callq 0x36a8
testb %al, %al
je 0x2fb3
cmpb $0x10, 0x108(%rsp)
jne 0x2fd2
movq 0xf0(%rsp), %rdi
leaq 0x2649(%rip), %rsi # 0x510a
callq 0x36a8
testb %al, %al
je 0x2ff1
movq 0xf0(%rsp), %rax
cmpb $0x10, 0x38(%rax)
jne 0x3010
movq 0xe8(%rsp), %rdi
leaq 0x25ce(%rip), %rsi # 0x50bd
callq 0x36a8
testb %al, %al
je 0x302f
movq 0xe8(%rsp), %rax
cmpb $0x10, 0x38(%rax)
jne 0x304e
movq 0x20(%rax), %rdi
leaq 0x263e(%rip), %rsi # 0x5157
callq 0x36a8
testb %al, %al
je 0x306d
movq 0xe8(%rsp), %rax
movq 0x20(%rax), %rax
cmpb $0x18, 0x38(%rax)
jne 0x308c
leaq 0x257a(%rip), %rdi # 0x50bd
leaq 0x110(%rsp), %rbx
movq %rbx, %rsi
callq 0x362f
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
leaq 0xd0(%rsp), %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x22dc
testq %rax, %rax
je 0x30ab
leaq 0x253a(%rip), %rsi # 0x50bd
movq %rax, %rdi
callq 0x36a8
testb %al, %al
je 0x30ca
leaq 0x2719(%rip), %rdi # 0x52b3
leaq 0x110(%rsp), %rbx
movq %rbx, %rsi
callq 0x362f
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
leaq 0xd0(%rsp), %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x22dc
testq %rax, %rax
je 0x30e9
leaq 0x24e3(%rip), %rsi # 0x50bd
movq %rax, %rdi
callq 0x36a8
testb %al, %al
je 0x3108
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0x26c3(%rip), %rdi # 0x52bf
leaq 0x110(%rsp), %r14
movq %r14, %rsi
callq 0x362f
leaq 0xd0(%rsp), %rdi
leaq 0xb(%rsp), %r15
movq %r14, %rsi
movl $0x10, %edx
movq %rbx, %rcx
movq %r15, %r8
callq 0x23e0
cmpb $0x1, (%r15)
je 0x3127
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0x250f(%rip), %rdi # 0x5157
leaq 0x110(%rsp), %r14
movq %r14, %rsi
callq 0x362f
leaq 0xd0(%rsp), %rdi
leaq 0xb(%rsp), %r15
movq %r14, %rsi
movl $0x18, %edx
movq %rbx, %rcx
movq %r15, %r8
callq 0x23e0
cmpb $0x0, (%r15)
je 0x3146
leaq 0x24ce(%rip), %rsi # 0x5157
movq %rax, %rdi
callq 0x36a8
testb %al, %al
je 0x3165
leaq 0x241d(%rip), %rdi # 0x50bd
leaq 0x110(%rsp), %rbx
movq %rbx, %rsi
callq 0x362f
leaq 0xd0(%rsp), %rdi
movq %rbx, %rsi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x2516
testq %rax, %rax
je 0x3184
leaq 0x232d(%rip), %rsi # 0x5004
leaq 0xd0(%rsp), %rdi
callq 0x36a8
testb %al, %al
je 0x31a3
movq 0xf0(%rsp), %rdi
leaq 0x240f(%rip), %rsi # 0x510a
callq 0x36a8
testb %al, %al
je 0x31c2
movq 0xe8(%rsp), %rdi
leaq 0x2440(%rip), %rsi # 0x5157
callq 0x36a8
testb %al, %al
je 0x31e1
movq 0xe8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x3200
leaq 0x23cc(%rip), %rdi # 0x510a
leaq 0x110(%rsp), %rbx
movq %rbx, %rsi
callq 0x362f
leaq 0xd0(%rsp), %rdi
movq %rbx, %rsi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x2516
testq %rax, %rax
je 0x321f
movq 0xe8(%rsp), %rdi
leaq 0x23da(%rip), %rsi # 0x5157
callq 0x36a8
testb %al, %al
je 0x323e
cmpq $0x0, 0xf0(%rsp)
jne 0x325d
leaq 0x2264(%rip), %rdi # 0x5004
leaq 0x110(%rsp), %rbx
movq %rbx, %rsi
callq 0x362f
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x2516
movq %rax, %rbx
leaq 0x2383(%rip), %rsi # 0x5157
movq %r14, %rdi
callq 0x36a8
testb %al, %al
je 0x327c
testq %rbx, %rbx
je 0x329b
cmpq $0x0, 0xf0(%rsp)
jne 0x32ba
cmpq $0x0, 0xe8(%rsp)
jne 0x32d9
leaq 0x2545(%rip), %rdi # 0x5357
callq 0x20d0
movq %fs:0x28, %rax
cmpq 0x130(%rsp), %rax
jne 0x32f8
xorl %eax, %eax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x21ca(%rip), %rdi # 0x5010
leaq 0x21ca(%rip), %rsi # 0x5017
leaq 0x2217(%rip), %rcx # 0x506b
movl $0x2f, %edx
callq 0x2080
leaq 0x221b(%rip), %rdi # 0x5080
leaq 0x21ab(%rip), %rsi # 0x5017
leaq 0x21f8(%rip), %rcx # 0x506b
movl $0x30, %edx
callq 0x2080
leaq 0x218c(%rip), %rdi # 0x5010
leaq 0x218c(%rip), %rsi # 0x5017
leaq 0x21d9(%rip), %rcx # 0x506b
movl $0x34, %edx
callq 0x2080
leaq 0x21dd(%rip), %rdi # 0x5080
leaq 0x216d(%rip), %rsi # 0x5017
leaq 0x21ba(%rip), %rcx # 0x506b
movl $0x35, %edx
callq 0x2080
leaq 0x214e(%rip), %rdi # 0x5010
leaq 0x214e(%rip), %rsi # 0x5017
leaq 0x219b(%rip), %rcx # 0x506b
movl $0x47, %edx
callq 0x2080
leaq 0x21e8(%rip), %rdi # 0x50c9
leaq 0x212f(%rip), %rsi # 0x5017
leaq 0x217c(%rip), %rcx # 0x506b
movl $0x48, %edx
callq 0x2080
leaq 0x21f9(%rip), %rdi # 0x50f9
leaq 0x2110(%rip), %rsi # 0x5017
leaq 0x215d(%rip), %rcx # 0x506b
movl $0x49, %edx
callq 0x2080
leaq 0x20f1(%rip), %rdi # 0x5010
leaq 0x20f1(%rip), %rsi # 0x5017
leaq 0x213e(%rip), %rcx # 0x506b
movl $0x5c, %edx
callq 0x2080
leaq 0x21d8(%rip), %rdi # 0x5116
leaq 0x20d2(%rip), %rsi # 0x5017
leaq 0x211f(%rip), %rcx # 0x506b
movl $0x5d, %edx
callq 0x2080
leaq 0x21e9(%rip), %rdi # 0x5146
leaq 0x20b3(%rip), %rsi # 0x5017
leaq 0x2100(%rip), %rcx # 0x506b
movl $0x5e, %edx
callq 0x2080
leaq 0x2094(%rip), %rdi # 0x5010
leaq 0x2094(%rip), %rsi # 0x5017
leaq 0x20e1(%rip), %rcx # 0x506b
movl $0x73, %edx
callq 0x2080
leaq 0x21c8(%rip), %rdi # 0x5163
leaq 0x2075(%rip), %rsi # 0x5017
leaq 0x20c2(%rip), %rcx # 0x506b
movl $0x74, %edx
callq 0x2080
leaq 0x21d9(%rip), %rdi # 0x5193
leaq 0x2056(%rip), %rsi # 0x5017
leaq 0x20a3(%rip), %rcx # 0x506b
movl $0x76, %edx
callq 0x2080
leaq 0x21e5(%rip), %rdi # 0x51be
leaq 0x2037(%rip), %rsi # 0x5017
leaq 0x2084(%rip), %rcx # 0x506b
movl $0x77, %edx
callq 0x2080
leaq 0x21d3(%rip), %rdi # 0x51cb
leaq 0x2018(%rip), %rsi # 0x5017
leaq 0x2065(%rip), %rcx # 0x506b
movl $0x7a, %edx
callq 0x2080
leaq 0x21e7(%rip), %rdi # 0x51fe
leaq 0x1ff9(%rip), %rsi # 0x5017
leaq 0x2046(%rip), %rcx # 0x506b
movl $0x7b, %edx
callq 0x2080
leaq 0x21dd(%rip), %rdi # 0x5213
leaq 0x1fda(%rip), %rsi # 0x5017
leaq 0x2027(%rip), %rcx # 0x506b
movl $0x7d, %edx
callq 0x2080
leaq 0x21f1(%rip), %rdi # 0x5246
leaq 0x1fbb(%rip), %rsi # 0x5017
leaq 0x2008(%rip), %rcx # 0x506b
movl $0x7e, %edx
callq 0x2080
leaq 0x21e7(%rip), %rdi # 0x525b
leaq 0x1f9c(%rip), %rsi # 0x5017
leaq 0x1fe9(%rip), %rcx # 0x506b
movl $0x80, %edx
callq 0x2080
leaq 0x2203(%rip), %rdi # 0x5296
leaq 0x1f7d(%rip), %rsi # 0x5017
leaq 0x1fca(%rip), %rcx # 0x506b
movl $0x81, %edx
callq 0x2080
leaq 0x1f5e(%rip), %rdi # 0x5010
leaq 0x1f5e(%rip), %rsi # 0x5017
leaq 0x1fab(%rip), %rcx # 0x506b
movl $0x86, %edx
callq 0x2080
leaq 0x1ff8(%rip), %rdi # 0x50c9
leaq 0x1f3f(%rip), %rsi # 0x5017
leaq 0x1f8c(%rip), %rcx # 0x506b
movl $0x87, %edx
callq 0x2080
leaq 0x1f20(%rip), %rdi # 0x5010
leaq 0x1f20(%rip), %rsi # 0x5017
leaq 0x1f6d(%rip), %rcx # 0x506b
movl $0x8d, %edx
callq 0x2080
leaq 0x1fba(%rip), %rdi # 0x50c9
leaq 0x1f01(%rip), %rsi # 0x5017
leaq 0x1f4e(%rip), %rcx # 0x506b
movl $0x8e, %edx
callq 0x2080
leaq 0x219b(%rip), %rdi # 0x52c9
leaq 0x1ee2(%rip), %rsi # 0x5017
leaq 0x1f2f(%rip), %rcx # 0x506b
movl $0x94, %edx
callq 0x2080
leaq 0x217d(%rip), %rdi # 0x52ca
leaq 0x1ec3(%rip), %rsi # 0x5017
leaq 0x1f10(%rip), %rcx # 0x506b
movl $0x9a, %edx
callq 0x2080
leaq 0x1ff7(%rip), %rdi # 0x5163
leaq 0x1ea4(%rip), %rsi # 0x5017
leaq 0x1ef1(%rip), %rcx # 0x506b
movl $0x9b, %edx
callq 0x2080
leaq 0x1e85(%rip), %rdi # 0x5010
leaq 0x1e85(%rip), %rsi # 0x5017
leaq 0x1ed2(%rip), %rcx # 0x506b
movl $0xa5, %edx
callq 0x2080
leaq 0x1fe9(%rip), %rdi # 0x5193
leaq 0x1e66(%rip), %rsi # 0x5017
leaq 0x1eb3(%rip), %rcx # 0x506b
movl $0xa6, %edx
callq 0x2080
leaq 0x2002(%rip), %rdi # 0x51cb
leaq 0x1e47(%rip), %rsi # 0x5017
leaq 0x1e94(%rip), %rcx # 0x506b
movl $0xa7, %edx
callq 0x2080
leaq 0x20e8(%rip), %rdi # 0x52d0
leaq 0x1e28(%rip), %rsi # 0x5017
leaq 0x1e75(%rip), %rcx # 0x506b
movl $0xa8, %edx
callq 0x2080
leaq 0x20fc(%rip), %rdi # 0x5303
leaq 0x1e09(%rip), %rsi # 0x5017
leaq 0x1e56(%rip), %rcx # 0x506b
movl $0xa9, %edx
callq 0x2080
leaq 0x1dea(%rip), %rdi # 0x5010
leaq 0x1dea(%rip), %rsi # 0x5017
leaq 0x1e37(%rip), %rcx # 0x506b
movl $0xb3, %edx
callq 0x2080
leaq 0x208b(%rip), %rdi # 0x52d0
leaq 0x1dcb(%rip), %rsi # 0x5017
leaq 0x1e18(%rip), %rcx # 0x506b
movl $0xb4, %edx
callq 0x2080
leaq 0x20b2(%rip), %rdi # 0x5316
leaq 0x1dac(%rip), %rsi # 0x5017
leaq 0x1df9(%rip), %rcx # 0x506b
movl $0xb5, %edx
callq 0x2080
leaq 0x209e(%rip), %rdi # 0x5321
leaq 0x1d8d(%rip), %rsi # 0x5017
leaq 0x1dda(%rip), %rcx # 0x506b
movl $0xbd, %edx
callq 0x2080
leaq 0x1d6e(%rip), %rdi # 0x5010
leaq 0x1d6e(%rip), %rsi # 0x5017
leaq 0x1dbb(%rip), %rcx # 0x506b
movl $0xbe, %edx
callq 0x2080
leaq 0x2055(%rip), %rdi # 0x5316
leaq 0x1d4f(%rip), %rsi # 0x5017
leaq 0x1d9c(%rip), %rcx # 0x506b
movl $0xbf, %edx
callq 0x2080
leaq 0x206c(%rip), %rdi # 0x534c
leaq 0x1d30(%rip), %rsi # 0x5017
leaq 0x1d7d(%rip), %rcx # 0x506b
movl $0xc0, %edx
callq 0x2080
callq 0x20c0
nopl (%rax)
| /rtrlib[P]rtrlib/tests/test_trie.c |
testing::internal::TypedExpectation<void ()>::GetCurrentAction(testing::internal::FunctionMockerBase<void ()> const*, std::tuple<> const&) const | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
g_gmock_mutex.AssertHeld();
const int count = call_count();
Assert(count >= 1, __FILE__, __LINE__,
"call_count() is <= 0 when GetCurrentAction() is "
"called - this should never happen.");
const int action_count = static_cast<int>(untyped_actions_.size());
if (action_count > 0 && !repeated_action_specified_ &&
count > action_count) {
// If there is at least one WillOnce() and no WillRepeatedly(),
// we warn the user when the WillOnce() clauses ran out.
::std::stringstream ss;
DescribeLocationTo(&ss);
ss << "Actions ran out in " << source_text() << "...\n"
<< "Called " << count << " times, but only "
<< action_count << " WillOnce()"
<< (action_count == 1 ? " is" : "s are") << " specified - ";
mocker->DescribeDefaultActionTo(args, &ss);
Log(kWarning, ss.str(), 1);
}
return count <= action_count ?
*static_cast<const Action<F>*>(untyped_actions_[count - 1]) :
repeated_action();
} | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x218(%rbp)
leaq 0x8ef2f(%rip), %rdi # 0x109a18
callq 0x77aa0
movq -0x218(%rbp), %rdi
callq 0x7ae80
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
testl %eax, %eax
setg %al
movb %al, -0x209(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0x72c70
movq -0x208(%rbp), %rdx
leaq 0x58fb8(%rip), %rsi # 0xd3ae1
leaq -0x40(%rbp), %rdi
callq 0x729a0
jmp 0x7ab34
movb -0x209(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x58f0a(%rip), %rsi # 0xd3a51
movl $0x487, %edx # imm = 0x487
leaq -0x40(%rbp), %rcx
callq 0x78d70
jmp 0x7ab57
leaq -0x40(%rbp), %rdi
callq 0x72de8
leaq -0x41(%rbp), %rdi
callq 0x726b0
movq -0x218(%rbp), %rdi
addq $0x88, %rdi
callq 0x7aeb0
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x58(%rbp)
jle 0x7ae17
movq -0x218(%rbp), %rax
testb $0x1, 0xa1(%rax)
jne 0x7ae17
movl -0x1c(%rbp), %eax
cmpl -0x58(%rbp), %eax
jle 0x7ae17
leaq -0x1e0(%rbp), %rdi
callq 0x72420
xorl %eax, %eax
leaq -0x1e0(%rbp), %rcx
cmpq $0x0, %rcx
movq %rax, -0x220(%rbp)
je 0x7abdd
leaq -0x1e0(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x220(%rbp)
movq -0x218(%rbp), %rdi
movq -0x220(%rbp), %rsi
callq 0x79b90
jmp 0x7abf2
leaq -0x1d0(%rbp), %rdi
leaq 0x58f34(%rip), %rsi # 0xd3b34
callq 0x725c0
movq %rax, -0x228(%rbp)
jmp 0x7ac0e
movq -0x218(%rbp), %rdi
callq 0x79c30
movq -0x228(%rbp), %rdi
movq %rax, %rsi
callq 0x725c0
movq %rax, -0x230(%rbp)
jmp 0x7ac32
movq -0x230(%rbp), %rdi
leaq 0x58c58(%rip), %rsi # 0xd3898
callq 0x725c0
movq %rax, -0x238(%rbp)
jmp 0x7ac4e
movq -0x238(%rbp), %rdi
leaq 0x58eec(%rip), %rsi # 0xd3b48
callq 0x725c0
movq %rax, -0x240(%rbp)
jmp 0x7ac6a
movq -0x240(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x72c30
movq %rax, -0x248(%rbp)
jmp 0x7ac82
movq -0x248(%rbp), %rdi
leaq 0x58ec0(%rip), %rsi # 0xd3b50
callq 0x725c0
movq %rax, -0x250(%rbp)
jmp 0x7ac9e
movq -0x250(%rbp), %rdi
movl -0x58(%rbp), %esi
callq 0x72c30
movq %rax, -0x258(%rbp)
jmp 0x7acb6
movq -0x258(%rbp), %rdi
leaq 0x58e9e(%rip), %rsi # 0xd3b62
callq 0x725c0
movq %rax, -0x260(%rbp)
jmp 0x7acd2
movq -0x260(%rbp), %rdi
movl -0x58(%rbp), %eax
subl $0x1, %eax
leaq 0x58e88(%rip), %rax # 0xd3b6e
leaq 0x58e85(%rip), %rsi # 0xd3b72
cmoveq %rax, %rsi
callq 0x725c0
movq %rax, -0x268(%rbp)
jmp 0x7acff
movq -0x268(%rbp), %rdi
leaq 0x58e6b(%rip), %rsi # 0xd3b78
callq 0x725c0
jmp 0x7ad14
movq -0x10(%rbp), %rax
movq %rax, -0x280(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x278(%rbp)
xorl %eax, %eax
leaq -0x1e0(%rbp), %rcx
cmpq $0x0, %rcx
movq %rax, -0x270(%rbp)
je 0x7ad52
leaq -0x1e0(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x270(%rbp)
movq -0x278(%rbp), %rsi
movq -0x280(%rbp), %rdi
movq -0x270(%rbp), %rdx
callq 0x79100
jmp 0x7ad6e
leaq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x725b0
jmp 0x7ad83
leaq -0x200(%rbp), %rsi
movl $0x1, %edx
movl %edx, %edi
callq 0xc4300
jmp 0x7ad98
leaq -0x200(%rbp), %rdi
callq 0x72de8
leaq -0x1e0(%rbp), %rdi
callq 0x72480
jmp 0x7ae17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7add5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x72de8
leaq -0x41(%rbp), %rdi
callq 0x726b0
jmp 0x7ae6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7ae09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x72de8
leaq -0x1e0(%rbp), %rdi
callq 0x72480
jmp 0x7ae6a
movl -0x1c(%rbp), %eax
cmpl -0x58(%rbp), %eax
jg 0x7ae47
movq -0x218(%rbp), %rdi
addq $0x88, %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x7aed0
movq (%rax), %rax
movq %rax, -0x288(%rbp)
jmp 0x7ae5a
movq -0x218(%rbp), %rdi
callq 0x7aef0
movq %rax, -0x288(%rbp)
movq -0x288(%rbp), %rax
addq $0x290, %rsp # imm = 0x290
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x72c60
nopw %cs:(%rax,%rax)
nopl (%rax)
| /DanRuta[P]webassembly-workflow/test/googletest/googlemock/include/gmock/gmock-spec-builders.h |
testing::internal::FunctionMockerBase<int (int, int)>::DescribeDefaultActionTo(std::tuple<int, int> const&, std::ostream*) const | void DescribeDefaultActionTo(const ArgumentTuple& args,
::std::ostream* os) const {
const OnCallSpec<F>* const spec = FindOnCallSpec(args);
if (spec == NULL) {
*os << (internal::type_equals<Result, void>::value ?
"returning directly.\n" :
"returning default value.\n");
} else {
*os << "taking default action specified at:\n"
<< FormatFileLocation(spec->file(), spec->line()) << "\n";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7bc00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7c731
movq -0x18(%rbp), %rdi
leaq 0x5750e(%rip), %rsi # 0xd3c35
callq 0x725c0
jmp 0x7c7b5
movq -0x18(%rbp), %rdi
leaq 0x570a0(%rip), %rsi # 0xd37dc
callq 0x725c0
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
callq 0x79210
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rdi
callq 0x79230
movq -0x70(%rbp), %rsi
movl %eax, %edx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x94050
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x72540
movq %rax, -0x58(%rbp)
jmp 0x7c781
movq -0x58(%rbp), %rdi
leaq 0x5a4be(%rip), %rsi # 0xd6c4a
callq 0x725c0
jmp 0x7c793
leaq -0x40(%rbp), %rdi
callq 0x72de8
jmp 0x7c7b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x72de8
jmp 0x7c7bb
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x72c60
nopw %cs:(%rax,%rax)
nop
| /DanRuta[P]webassembly-workflow/test/googletest/googlemock/include/gmock/gmock-spec-builders.h |
testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop[abi:cxx11](int) | std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
return os_stack_trace_getter()->CurrentStackTrace(
static_cast<int>(GTEST_FLAG(stack_trace_depth)),
skip_count + 1
// Skips the user-specified number of frames plus this function
// itself.
); // NOLINT
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8cf40
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl 0x7ec74(%rip), %edx # 0x109808
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movq (%rsi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::AssertionResult::AssertionResult(testing::AssertionResult const&) | AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_),
message_(other.message_.get() != NULL ?
new ::std::string(*other.message_) :
static_cast< ::std::string*>(NULL)) {
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x808f0
movb $0x0, -0x19(%rbp)
cmpq $0x0, %rax
je 0x8d783
movl $0x20, %edi
callq 0x725e0
movq %rax, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xa75d0
movq %rax, -0x40(%rbp)
jmp 0x8d76a
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x72250
jmp 0x8d779
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x8d78b
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x8d78b
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xa75f0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x8d7b2
jmp 0x8d7c0
movq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x72600
jmp 0x8d7c2
movq -0x28(%rbp), %rdi
callq 0x72c60
nopl (%rax,%rax)
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::CalculateOptimalEdits(std::vector<unsigned long, std::allocator<unsigned long>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
const std::vector<size_t>& right) {
std::vector<std::vector<double> > costs(
left.size() + 1, std::vector<double>(right.size() + 1));
std::vector<std::vector<EditType> > best_move(
left.size() + 1, std::vector<EditType>(right.size() + 1));
// Populate for empty right.
for (size_t l_i = 0; l_i < costs.size(); ++l_i) {
costs[l_i][0] = static_cast<double>(l_i);
best_move[l_i][0] = kRemove;
}
// Populate for empty left.
for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) {
costs[0][r_i] = static_cast<double>(r_i);
best_move[0][r_i] = kAdd;
}
for (size_t l_i = 0; l_i < left.size(); ++l_i) {
for (size_t r_i = 0; r_i < right.size(); ++r_i) {
if (left[l_i] == right[r_i]) {
// Found a match. Consume it.
costs[l_i + 1][r_i + 1] = costs[l_i][r_i];
best_move[l_i + 1][r_i + 1] = kMatch;
continue;
}
const double add = costs[l_i + 1][r_i];
const double remove = costs[l_i][r_i + 1];
const double replace = costs[l_i][r_i];
if (add < remove && add < replace) {
costs[l_i + 1][r_i + 1] = add + 1;
best_move[l_i + 1][r_i + 1] = kAdd;
} else if (remove < add && remove < replace) {
costs[l_i + 1][r_i + 1] = remove + 1;
best_move[l_i + 1][r_i + 1] = kRemove;
} else {
// We make replace a little more expensive than add/remove to lower
// their priority.
costs[l_i + 1][r_i + 1] = replace + 1.00001;
best_move[l_i + 1][r_i + 1] = kReplace;
}
}
}
// Reconstruct the best path. We do it in reverse order.
std::vector<EditType> best_path;
for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {
EditType move = best_move[l_i][r_i];
best_path.push_back(move);
l_i -= move != kAdd;
r_i -= move != kRemove;
}
std::reverse(best_path.begin(), best_path.end());
return best_path;
} | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x128(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa76c0
incq %rax
movq %rax, -0x118(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa76c0
incq %rax
movq %rax, -0x110(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xa76e0
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0xa7700
jmp 0x8d9c7
leaq -0x5d(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0xa7770
movq -0x118(%rbp), %rsi
movq -0x130(%rbp), %rcx
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0xa7790
jmp 0x8d9f4
leaq -0x5d(%rbp), %rdi
callq 0xa7810
leaq -0x48(%rbp), %rdi
callq 0xa7830
leaq -0x49(%rbp), %rdi
callq 0xa7890
movq -0x10(%rbp), %rdi
callq 0xa76c0
incq %rax
movq %rax, -0x148(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa76c0
incq %rax
movq %rax, -0x140(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0xa78b0
movq -0x140(%rbp), %rsi
movq -0x138(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0xa78d0
jmp 0x8da64
leaq -0x92(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0xa7940
movq -0x148(%rbp), %rsi
movq -0x150(%rbp), %rcx
leaq -0x78(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0xa7960
jmp 0x8da97
leaq -0x92(%rbp), %rdi
callq 0xa79e0
leaq -0x90(%rbp), %rdi
callq 0xa7a00
leaq -0x91(%rbp), %rdi
callq 0xa7a60
movq $0x0, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa7a80
movq %rax, %rcx
movq -0x158(%rbp), %rax
cmpq %rcx, %rax
jae 0x8dc00
movaps 0x47329(%rip), %xmm1 # 0xd4e20
movq -0xa0(%rbp), %xmm0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x47325(%rip), %xmm1 # 0xd4e30
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x160(%rbp)
movq -0xa0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xa7ab0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa7ad0
movsd -0x160(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0xa0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xa7af0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa7b10
movl $0x2, (%rax)
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0x8dac6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8dbaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x5d(%rbp), %rdi
callq 0xa7810
leaq -0x48(%rbp), %rdi
callq 0xa7830
leaq -0x49(%rbp), %rdi
callq 0xa7890
jmp 0x8e226
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8dbef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x92(%rbp), %rdi
callq 0xa79e0
leaq -0x90(%rbp), %rdi
callq 0xa7a00
leaq -0x91(%rbp), %rdi
callq 0xa7a60
jmp 0x8e21d
movq $0x1, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x168(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa7ab0
movq %rax, %rdi
callq 0xa7b30
movq %rax, %rcx
movq -0x168(%rbp), %rax
cmpq %rcx, %rax
jae 0x8dcd4
movaps 0x471d8(%rip), %xmm1 # 0xd4e20
movq -0xa8(%rbp), %xmm0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x471d4(%rip), %xmm1 # 0xd4e30
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x170(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa7ab0
movq %rax, %rdi
movq -0xa8(%rbp), %rsi
callq 0xa7ad0
movsd -0x170(%rbp), %xmm0
movsd %xmm0, (%rax)
leaq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa7af0
movq %rax, %rdi
movq -0xa8(%rbp), %rsi
callq 0xa7b10
movl $0x1, (%rax)
movq -0xa8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa8(%rbp)
jmp 0x8dc0b
movq $0x0, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x178(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa76c0
movq %rax, %rcx
movq -0x178(%rbp), %rax
cmpq %rcx, %rax
jae 0x8e097
movq $0x0, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa76c0
movq %rax, %rcx
movq -0x180(%rbp), %rax
cmpq %rcx, %rax
jae 0x8e07e
movq -0x10(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0xa7b50
movq (%rax), %rax
movq %rax, -0x188(%rbp)
movq -0x18(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0xa7b50
movq %rax, %rcx
movq -0x188(%rbp), %rax
cmpq (%rcx), %rax
jne 0x8de0b
movq -0xb0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xa7ab0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
callq 0xa7ad0
movsd (%rax), %xmm0
movsd %xmm0, -0x190(%rbp)
movq -0xb0(%rbp), %rsi
addq $0x1, %rsi
leaq -0x30(%rbp), %rdi
callq 0xa7ab0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
addq $0x1, %rsi
callq 0xa7ad0
movsd -0x190(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0xb0(%rbp), %rsi
addq $0x1, %rsi
leaq -0x78(%rbp), %rdi
callq 0xa7af0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
addq $0x1, %rsi
callq 0xa7b10
movl $0x0, (%rax)
jmp 0x8e067
movq -0xb0(%rbp), %rsi
addq $0x1, %rsi
leaq -0x30(%rbp), %rdi
callq 0xa7ab0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
callq 0xa7ad0
movsd (%rax), %xmm0
movsd %xmm0, -0xc0(%rbp)
movq -0xb0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xa7ab0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
addq $0x1, %rsi
callq 0xa7ad0
movsd (%rax), %xmm0
movsd %xmm0, -0xc8(%rbp)
movq -0xb0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xa7ab0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
callq 0xa7ad0
movsd (%rax), %xmm0
movsd %xmm0, -0xd0(%rbp)
movsd -0xc0(%rbp), %xmm1
movsd -0xc8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8df41
movsd -0xc0(%rbp), %xmm1
movsd -0xd0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8df41
movsd 0x46f3c(%rip), %xmm0 # 0xd4e08
addsd -0xc0(%rbp), %xmm0
movsd %xmm0, -0x198(%rbp)
movq -0xb0(%rbp), %rsi
addq $0x1, %rsi
leaq -0x30(%rbp), %rdi
callq 0xa7ab0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
addq $0x1, %rsi
callq 0xa7ad0
movsd -0x198(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0xb0(%rbp), %rsi
addq $0x1, %rsi
leaq -0x78(%rbp), %rdi
callq 0xa7af0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
addq $0x1, %rsi
callq 0xa7b10
movl $0x1, (%rax)
jmp 0x8e065
movsd -0xc8(%rbp), %xmm1
movsd -0xc0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8dfeb
movsd -0xc8(%rbp), %xmm1
movsd -0xd0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8dfeb
movsd 0x46e8f(%rip), %xmm0 # 0xd4e08
addsd -0xc8(%rbp), %xmm0
movsd %xmm0, -0x1a0(%rbp)
movq -0xb0(%rbp), %rsi
addq $0x1, %rsi
leaq -0x30(%rbp), %rdi
callq 0xa7ab0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
addq $0x1, %rsi
callq 0xa7ad0
movsd -0x1a0(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0xb0(%rbp), %rsi
addq $0x1, %rsi
leaq -0x78(%rbp), %rdi
callq 0xa7af0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
addq $0x1, %rsi
callq 0xa7b10
movl $0x2, (%rax)
jmp 0x8e063
movsd 0x46e0d(%rip), %xmm0 # 0xd4e00
addsd -0xd0(%rbp), %xmm0
movsd %xmm0, -0x1a8(%rbp)
movq -0xb0(%rbp), %rsi
addq $0x1, %rsi
leaq -0x30(%rbp), %rdi
callq 0xa7ab0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
addq $0x1, %rsi
callq 0xa7ad0
movsd -0x1a8(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0xb0(%rbp), %rsi
addq $0x1, %rsi
leaq -0x78(%rbp), %rdi
callq 0xa7af0
movq %rax, %rdi
movq -0xb8(%rbp), %rsi
addq $0x1, %rsi
callq 0xa7b10
movl $0x3, (%rax)
jmp 0x8e065
jmp 0x8e067
movq -0xb8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb8(%rbp)
jmp 0x8dd14
jmp 0x8e080
movq -0xb0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb0(%rbp)
jmp 0x8dcdf
movq -0x128(%rbp), %rdi
movb $0x0, -0xd1(%rbp)
callq 0xa7b70
movq -0x10(%rbp), %rdi
callq 0xa76c0
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa76c0
movq %rax, -0xe8(%rbp)
movb $0x1, %al
cmpq $0x0, -0xe0(%rbp)
movb %al, -0x1a9(%rbp)
ja 0x8e0ed
cmpq $0x0, -0xe8(%rbp)
seta %al
movb %al, -0x1a9(%rbp)
movb -0x1a9(%rbp), %al
testb $0x1, %al
jne 0x8e0fc
jmp 0x8e1a4
movq -0xe0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xa7af0
movq %rax, %rdi
movq -0xe8(%rbp), %rsi
callq 0xa7b10
movq -0x128(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0xec(%rbp)
leaq -0xec(%rbp), %rsi
callq 0xa7b90
jmp 0x8e138
cmpl $0x1, -0xec(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, %ecx
movq -0xe0(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xe0(%rbp)
cmpl $0x2, -0xec(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, %ecx
movq -0xe8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xe8(%rbp)
jmp 0x8e0ca
movq -0x128(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0xa7a00
leaq -0x78(%rbp), %rdi
callq 0xa7ca0
jmp 0x8e21d
movq -0x128(%rbp), %rdi
callq 0xa7c40
movq -0x128(%rbp), %rdi
movq %rax, -0xf8(%rbp)
callq 0xa7c70
movq %rax, -0x100(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x100(%rbp), %rsi
callq 0xa7c00
jmp 0x8e1df
movb $0x1, -0xd1(%rbp)
testb $0x1, -0xd1(%rbp)
jne 0x8e1fb
movq -0x128(%rbp), %rdi
callq 0xa7a00
leaq -0x78(%rbp), %rdi
callq 0xa7ca0
leaq -0x30(%rbp), %rdi
callq 0xa7d00
movq -0x120(%rbp), %rax
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xa7d00
movq -0x58(%rbp), %rdi
callq 0x72c60
nop
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::internal::ShouldUseColor(bool) | bool ShouldUseColor(bool stdout_is_tty) {
const char* const gtest_color = GTEST_FLAG(color).c_str();
if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
#if GTEST_OS_WINDOWS
// On Windows the TERM variable is usually not set, but the
// console there does support colors.
return stdout_is_tty;
#else
// On non-Windows platforms, we rely on the TERM variable.
const char* const term = posix::GetEnv("TERM");
const bool term_supports_color =
String::CStringEquals(term, "xterm") ||
String::CStringEquals(term, "xterm-color") ||
String::CStringEquals(term, "xterm-256color") ||
String::CStringEquals(term, "screen") ||
String::CStringEquals(term, "screen-256color") ||
String::CStringEquals(term, "tmux") ||
String::CStringEquals(term, "tmux-256color") ||
String::CStringEquals(term, "rxvt-unicode") ||
String::CStringEquals(term, "rxvt-unicode-256color") ||
String::CStringEquals(term, "linux") ||
String::CStringEquals(term, "cygwin");
return stdout_is_tty && term_supports_color;
#endif // GTEST_OS_WINDOWS
}
return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
String::CStringEquals(gtest_color, "1");
// We take "yes", "true", "t", and "1" as meaning "yes". If the
// value is neither one of these nor "auto", we treat it as "no" to
// be conservative.
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x2(%rbp)
leaq 0x74cb9(%rip), %rdi # 0x109790
callq 0x72240
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x417af(%rip), %rsi # 0xd629a
callq 0x904c0
testb $0x1, %al
jne 0x94af9
jmp 0x94c6f
leaq 0x41f4d(%rip), %rdi # 0xd6a4d
callq 0xab130
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x41f3e(%rip), %rsi # 0xd6a52
callq 0x8d000
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x94c4c
movq -0x18(%rbp), %rdi
leaq 0x41f24(%rip), %rsi # 0xd6a58
callq 0x8d000
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x94c4c
movq -0x18(%rbp), %rdi
leaq 0x41f10(%rip), %rsi # 0xd6a64
callq 0x8d000
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x94c4c
movq -0x18(%rbp), %rdi
leaq 0x41eff(%rip), %rsi # 0xd6a73
callq 0x8d000
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x94c4c
movq -0x18(%rbp), %rdi
leaq 0x41ee6(%rip), %rsi # 0xd6a7a
callq 0x8d000
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x94c4c
movq -0x18(%rbp), %rdi
leaq 0x41ed6(%rip), %rsi # 0xd6a8a
callq 0x8d000
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x94c4c
movq -0x18(%rbp), %rdi
leaq 0x41ebb(%rip), %rsi # 0xd6a8f
callq 0x8d000
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x94c4c
movq -0x18(%rbp), %rdi
leaq 0x41ead(%rip), %rsi # 0xd6a9d
callq 0x8d000
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x94c4c
movq -0x18(%rbp), %rdi
leaq 0x41e9e(%rip), %rsi # 0xd6aaa
callq 0x8d000
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x94c4c
movq -0x18(%rbp), %rdi
leaq 0x41e98(%rip), %rsi # 0xd6ac0
callq 0x8d000
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x94c4c
movq -0x18(%rbp), %rdi
leaq 0x41e82(%rip), %rsi # 0xd6ac6
callq 0x8d000
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
xorl %eax, %eax
testb $0x1, -0x2(%rbp)
movb %al, -0x1b(%rbp)
je 0x94c65
movb -0x19(%rbp), %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x94cde
movq -0x10(%rbp), %rdi
leaq 0x41e53(%rip), %rsi # 0xd6acd
callq 0x904c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1c(%rbp)
jne 0x94cd6
movq -0x10(%rbp), %rdi
leaq 0x41e3b(%rip), %rsi # 0xd6ad1
callq 0x904c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1c(%rbp)
jne 0x94cd6
movq -0x10(%rbp), %rdi
leaq 0x43552(%rip), %rsi # 0xd8204
callq 0x904c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1c(%rbp)
jne 0x94cd6
movq -0x10(%rbp), %rdi
leaq 0x428cb(%rip), %rsi # 0xd7599
callq 0x8d000
movb %al, -0x1c(%rbp)
movb -0x1c(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::internal::ShouldShard(char const*, char const*, bool) | bool ShouldShard(const char* total_shards_env,
const char* shard_index_env,
bool in_subprocess_for_death_test) {
if (in_subprocess_for_death_test) {
return false;
}
const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1);
const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1);
if (total_shards == -1 && shard_index == -1) {
return false;
} else if (total_shards == -1 && shard_index != -1) {
const Message msg = Message()
<< "Invalid environment variables: you have "
<< kTestShardIndex << " = " << shard_index
<< ", but have left " << kTestTotalShards << " unset.\n";
ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
fflush(stdout);
exit(EXIT_FAILURE);
} else if (total_shards != -1 && shard_index == -1) {
const Message msg = Message()
<< "Invalid environment variables: you have "
<< kTestTotalShards << " = " << total_shards
<< ", but have left " << kTestShardIndex << " unset.\n";
ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
fflush(stdout);
exit(EXIT_FAILURE);
} else if (shard_index < 0 || shard_index >= total_shards) {
const Message msg = Message()
<< "Invalid environment variables: we require 0 <= "
<< kTestShardIndex << " < " << kTestTotalShards
<< ", but you have " << kTestShardIndex << "=" << shard_index
<< ", " << kTestTotalShards << "=" << total_shards << ".\n";
ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
fflush(stdout);
exit(EXIT_FAILURE);
}
return total_shards > 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x95159
movb $0x0, -0x1(%rbp)
jmp 0x95746
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x95760
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x95760
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x95190
cmpl $-0x1, -0x24(%rbp)
jne 0x95190
movb $0x0, -0x1(%rbp)
jmp 0x95746
cmpl $-0x1, -0x20(%rbp)
jne 0x9532f
cmpl $-0x1, -0x24(%rbp)
je 0x9532f
leaq -0x38(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x8d200
movq -0xd8(%rbp), %rdi
leaq 0x41f68(%rip), %rsi # 0xd712a
callq 0xad4d0
movq %rax, -0xd0(%rbp)
jmp 0x951d0
movq -0xd0(%rbp), %rdi
leaq 0x401f2(%rip), %rsi # 0xd53d0
callq 0xa9ac0
movq %rax, -0xe0(%rbp)
jmp 0x951ec
movq -0xe0(%rbp), %rdi
leaq 0x41fe4(%rip), %rsi # 0xd71de
callq 0xa8050
movq %rax, -0xe8(%rbp)
jmp 0x95208
movq -0xe8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xa6f20
movq %rax, -0xf0(%rbp)
jmp 0x95221
movq -0xf0(%rbp), %rdi
leaq 0x41f24(%rip), %rsi # 0xd7153
callq 0xad510
movq %rax, -0xf8(%rbp)
jmp 0x9523d
movq -0xf8(%rbp), %rdi
leaq 0x40165(%rip), %rsi # 0xd53b0
callq 0xad550
movq %rax, -0x100(%rbp)
jmp 0x95259
movq -0x100(%rbp), %rdi
leaq 0x41efd(%rip), %rsi # 0xd7164
callq 0xad590
movq %rax, -0x108(%rbp)
jmp 0x95275
movq -0x108(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xad5d0
jmp 0x95287
leaq -0x38(%rbp), %rdi
callq 0x80580
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8d580
jmp 0x9529f
leaq -0x68(%rbp), %rdi
callq 0x72240
movq %rax, %rdx
leaq 0x41f32(%rip), %rsi # 0xd71e4
xorl %eax, %eax
movl $0x1, %edi
callq 0x94cf0
jmp 0x952c0
leaq -0x68(%rbp), %rdi
callq 0x72de8
movq 0x73ca8(%rip), %rax # 0x108f78
movq (%rax), %rdi
callq 0x727c0
jmp 0x952da
movl $0x1, %edi
callq 0x72810
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x80580
jmp 0x95754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x95321
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x72de8
leaq -0x30(%rbp), %rdi
callq 0x80580
jmp 0x95754
cmpl $-0x1, -0x20(%rbp)
je 0x954da
cmpl $-0x1, -0x24(%rbp)
jne 0x954da
leaq -0x78(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x8d200
movq -0x118(%rbp), %rdi
leaq 0x41dc9(%rip), %rsi # 0xd712a
callq 0xad4d0
movq %rax, -0x110(%rbp)
jmp 0x9536f
movq -0x110(%rbp), %rdi
leaq 0x40033(%rip), %rsi # 0xd53b0
callq 0xad550
movq %rax, -0x120(%rbp)
jmp 0x9538b
movq -0x120(%rbp), %rdi
leaq 0x41e45(%rip), %rsi # 0xd71de
callq 0xa8050
movq %rax, -0x128(%rbp)
jmp 0x953a7
movq -0x128(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa6f20
movq %rax, -0x130(%rbp)
jmp 0x953c0
movq -0x130(%rbp), %rdi
leaq 0x41d85(%rip), %rsi # 0xd7153
callq 0xad510
movq %rax, -0x138(%rbp)
jmp 0x953dc
movq -0x138(%rbp), %rdi
leaq 0x3ffe6(%rip), %rsi # 0xd53d0
callq 0xa9ac0
movq %rax, -0x140(%rbp)
jmp 0x953f8
movq -0x140(%rbp), %rdi
leaq 0x41d5e(%rip), %rsi # 0xd7164
callq 0xad590
movq %rax, -0x148(%rbp)
jmp 0x95414
movq -0x148(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0xad5d0
jmp 0x95426
leaq -0x78(%rbp), %rdi
callq 0x80580
leaq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x8d580
jmp 0x95441
leaq -0x98(%rbp), %rdi
callq 0x72240
movq %rax, %rdx
leaq 0x41d8d(%rip), %rsi # 0xd71e4
xorl %eax, %eax
movl $0x1, %edi
callq 0x94cf0
jmp 0x95465
leaq -0x98(%rbp), %rdi
callq 0x72de8
movq 0x73b00(%rip), %rax # 0x108f78
movq (%rax), %rdi
callq 0x727c0
jmp 0x95482
movl $0x1, %edi
callq 0x72810
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x80580
jmp 0x95754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x954cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x72de8
leaq -0x70(%rbp), %rdi
callq 0x80580
jmp 0x95754
cmpl $0x0, -0x24(%rbp)
jl 0x954ec
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x95734
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x8d200
movq -0x158(%rbp), %rdi
leaq 0x41c60(%rip), %rsi # 0xd716d
callq 0xad6b0
movq %rax, -0x150(%rbp)
jmp 0x9551b
movq -0x150(%rbp), %rdi
leaq 0x3fea7(%rip), %rsi # 0xd53d0
callq 0xa9ac0
movq %rax, -0x160(%rbp)
jmp 0x95537
movq -0x160(%rbp), %rdi
leaq 0x41c58(%rip), %rsi # 0xd719d
callq 0xa8050
movq %rax, -0x168(%rbp)
jmp 0x95553
movq -0x168(%rbp), %rdi
leaq 0x3fe4f(%rip), %rsi # 0xd53b0
callq 0xad550
movq %rax, -0x170(%rbp)
jmp 0x9556f
movq -0x170(%rbp), %rdi
leaq 0x41c24(%rip), %rsi # 0xd71a1
callq 0xa8100
movq %rax, -0x178(%rbp)
jmp 0x9558b
movq -0x178(%rbp), %rdi
leaq 0x3fe37(%rip), %rsi # 0xd53d0
callq 0xa9ac0
movq %rax, -0x180(%rbp)
jmp 0x955a7
movq -0x180(%rbp), %rdi
leaq 0x426e1(%rip), %rsi # 0xd7c96
callq 0xa6ee0
movq %rax, -0x188(%rbp)
jmp 0x955c3
movq -0x188(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xa6f20
movq %rax, -0x190(%rbp)
jmp 0x955dc
movq -0x190(%rbp), %rdi
leaq 0x436ff(%rip), %rsi # 0xd8ce9
callq 0xa8200
movq %rax, -0x198(%rbp)
jmp 0x955f8
movq -0x198(%rbp), %rdi
leaq 0x3fdaa(%rip), %rsi # 0xd53b0
callq 0xad550
movq %rax, -0x1a0(%rbp)
jmp 0x95614
movq -0x1a0(%rbp), %rdi
leaq 0x42674(%rip), %rsi # 0xd7c96
callq 0xa6ee0
movq %rax, -0x1a8(%rbp)
jmp 0x95630
movq -0x1a8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa6f20
movq %rax, -0x1b0(%rbp)
jmp 0x95649
movq -0x1b0(%rbp), %rdi
leaq 0x41535(%rip), %rsi # 0xd6b8c
callq 0xa8200
movq %rax, -0x1b8(%rbp)
jmp 0x95665
movq -0x1b8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0xad5d0
jmp 0x9567a
leaq -0xa8(%rbp), %rdi
callq 0x80580
leaq -0xc8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x8d580
jmp 0x9569b
leaq -0xc8(%rbp), %rdi
callq 0x72240
movq %rax, %rdx
leaq 0x41b33(%rip), %rsi # 0xd71e4
xorl %eax, %eax
movl $0x1, %edi
callq 0x94cf0
jmp 0x956bf
leaq -0xc8(%rbp), %rdi
callq 0x72de8
movq 0x738a6(%rip), %rax # 0x108f78
movq (%rax), %rdi
callq 0x727c0
jmp 0x956dc
movl $0x1, %edi
callq 0x72810
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x80580
jmp 0x95754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x95726
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x72de8
leaq -0xa0(%rbp), %rdi
callq 0x80580
jmp 0x95754
jmp 0x95736
jmp 0x95738
jmp 0x9573a
cmpl $0x1, -0x20(%rbp)
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1c0, %rsp # imm = 0x1C0
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x72c60
nopl (%rax)
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestCase const&) | void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(COLOR_GREEN, "[----------] ");
printf("%s from %s", counts.c_str(), test_case.name());
if (test_case.type_param() == NULL) {
printf("\n");
} else {
printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
}
fflush(stdout);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8cf10
movl %eax, %esi
leaq 0x41b62(%rip), %rdx # 0xd7504
leaq 0x408c9(%rip), %rcx # 0xd6272
leaq -0x30(%rbp), %rdi
callq 0x95aa0
leaq 0x411f9(%rip), %rsi # 0xd6bb2
xorl %eax, %eax
movl $0x2, %edi
callq 0x94cf0
jmp 0x959c7
leaq -0x30(%rbp), %rdi
callq 0x72240
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xab230
movq %rax, -0x48(%rbp)
jmp 0x959e3
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rsi
leaq 0x411ef(%rip), %rdi # 0xd6be1
xorl %eax, %eax
callq 0x72090
jmp 0x959fb
movq -0x10(%rbp), %rdi
callq 0xab250
movq %rax, -0x58(%rbp)
jmp 0x95a0a
movq -0x58(%rbp), %rax
cmpq $0x0, %rax
jne 0x95a3d
leaq 0x4122f(%rip), %rdi # 0xd6c4a
xorl %eax, %eax
callq 0x72090
jmp 0x95a24
jmp 0x95a69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x72de8
jmp 0x95a89
movq -0x10(%rbp), %rdi
callq 0xab250
movq %rax, -0x60(%rbp)
jmp 0x95a4c
movq -0x60(%rbp), %rdx
leaq 0x41195(%rip), %rdi # 0xd6bec
leaq 0x3f934(%rip), %rsi # 0xd5392
xorl %eax, %eax
callq 0x72090
jmp 0x95a67
jmp 0x95a69
movq 0x73508(%rip), %rax # 0x108f78
movq (%rax), %rdi
callq 0x727c0
jmp 0x95a7a
leaq -0x30(%rbp), %rdi
callq 0x72de8
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x72c60
nopw %cs:(%rax,%rax)
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests(testing::UnitTest const&) | void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
const int failed_test_count = unit_test.failed_test_count();
if (failed_test_count == 0) {
return;
}
for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
const TestCase& test_case = *unit_test.GetTestCase(i);
if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
continue;
}
for (int j = 0; j < test_case.total_test_count(); ++j) {
const TestInfo& test_info = *test_case.GetTestInfo(j);
if (!test_info.should_run() || test_info.result()->Passed()) {
continue;
}
ColoredPrintf(COLOR_RED, "[ FAILED ] ");
printf("%s.%s", test_case.name(), test_info.name());
PrintFullTestCommentIfPresent(test_info);
printf("\n");
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x960a0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x95f73
jmp 0x96096
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x960d0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x96096
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x96100
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xab3d0
testb $0x1, %al
jne 0x95fb5
jmp 0x95fc3
movq -0x18(%rbp), %rdi
callq 0x8ccf0
cmpl $0x0, %eax
jne 0x95fc8
jmp 0x96088
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8ceb0
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jge 0x96086
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x94700
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xab3f0
testb $0x1, %al
jne 0x9600a
jmp 0x96021
movq -0x28(%rbp), %rdi
callq 0xab2d0
movq %rax, %rdi
callq 0xab2f0
testb $0x1, %al
jne 0x96021
jmp 0x96023
jmp 0x96078
movl $0x1, %edi
leaq 0x40bea(%rip), %rsi # 0xd6c19
movb $0x0, %al
callq 0x94cf0
movq -0x18(%rbp), %rdi
callq 0xab230
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa9ec0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x40c15(%rip), %rdi # 0xd6c6f
movb $0x0, %al
callq 0x72090
movq -0x28(%rbp), %rdi
callq 0x94ea0
leaq 0x40bd9(%rip), %rdi # 0xd6c4a
movb $0x0, %al
callq 0x72090
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x95fcf
jmp 0x96088
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x95f7a
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| /DanRuta[P]webassembly-workflow/test/googletest/googletest/src/gtest.cc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.