name
string | code
string | asm
string | file
string |
|---|---|---|---|
mbedtls_sha1_finish
|
void mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] )
{
uint32_t last, padn;
uint32_t high, low;
unsigned char msglen[8];
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT32_BE( high, msglen, 0 );
PUT_UINT32_BE( low, msglen, 4 );
last = ctx->total[0] & 0x3F;
padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
mbedtls_sha1_update( ctx, sha1_padding, padn );
mbedtls_sha1_update( ctx, msglen, 8 );
PUT_UINT32_BE( ctx->state[0], output, 0 );
PUT_UINT32_BE( ctx->state[1], output, 4 );
PUT_UINT32_BE( ctx->state[2], output, 8 );
PUT_UINT32_BE( ctx->state[3], output, 12 );
PUT_UINT32_BE( ctx->state[4], output, 16 );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x1d, %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shll $0x3, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x18, %eax
movb %al, -0x28(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x10, %eax
movb %al, -0x27(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
movb %al, -0x26(%rbp)
movl -0x1c(%rbp), %eax
movb %al, -0x25(%rbp)
movl -0x20(%rbp), %eax
shrl $0x18, %eax
movb %al, -0x24(%rbp)
movl -0x20(%rbp), %eax
shrl $0x10, %eax
movb %al, -0x23(%rbp)
movl -0x20(%rbp), %eax
shrl $0x8, %eax
movb %al, -0x22(%rbp)
movl -0x20(%rbp), %eax
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
cmpl $0x38, -0x14(%rbp)
jae 0x11605
movl $0x38, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x11610
movl $0x78, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %edx
leaq 0x1b90a(%rip), %rsi # 0x2cf30
callq 0x11440
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0x11440
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xa(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xb(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xd(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xe(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xf(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x11(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x12(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x13(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
|
/Dragonchang[P]https_client/mbedtls/library/sha1.c
|
mbedtls_sha512_finish
|
void mbedtls_sha512_finish( mbedtls_sha512_context *ctx, unsigned char output[64] )
{
size_t last, padn;
uint64_t high, low;
unsigned char msglen[16];
high = ( ctx->total[0] >> 61 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT64_BE( high, msglen, 0 );
PUT_UINT64_BE( low, msglen, 8 );
last = (size_t)( ctx->total[0] & 0x7F );
padn = ( last < 112 ) ? ( 112 - last ) : ( 240 - last );
mbedtls_sha512_update( ctx, sha512_padding, padn );
mbedtls_sha512_update( ctx, msglen, 16 );
PUT_UINT64_BE( ctx->state[0], output, 0 );
PUT_UINT64_BE( ctx->state[1], output, 8 );
PUT_UINT64_BE( ctx->state[2], output, 16 );
PUT_UINT64_BE( ctx->state[3], output, 24 );
PUT_UINT64_BE( ctx->state[4], output, 32 );
PUT_UINT64_BE( ctx->state[5], output, 40 );
if( ctx->is384 == 0 )
{
PUT_UINT64_BE( ctx->state[6], output, 48 );
PUT_UINT64_BE( ctx->state[7], output, 56 );
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq $0x3d, %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x3, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shlq $0x3, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
shrq $0x38, %rax
movb %al, -0x40(%rbp)
movq -0x28(%rbp), %rax
shrq $0x30, %rax
movb %al, -0x3f(%rbp)
movq -0x28(%rbp), %rax
shrq $0x28, %rax
movb %al, -0x3e(%rbp)
movq -0x28(%rbp), %rax
shrq $0x20, %rax
movb %al, -0x3d(%rbp)
movq -0x28(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x3c(%rbp)
movq -0x28(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x3b(%rbp)
movq -0x28(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x3a(%rbp)
movq -0x28(%rbp), %rax
movb %al, -0x39(%rbp)
movq -0x30(%rbp), %rax
shrq $0x38, %rax
movb %al, -0x38(%rbp)
movq -0x30(%rbp), %rax
shrq $0x30, %rax
movb %al, -0x37(%rbp)
movq -0x30(%rbp), %rax
shrq $0x28, %rax
movb %al, -0x36(%rbp)
movq -0x30(%rbp), %rax
shrq $0x20, %rax
movb %al, -0x35(%rbp)
movq -0x30(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x34(%rbp)
movq -0x30(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x33(%rbp)
movq -0x30(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x32(%rbp)
movq -0x30(%rbp), %rax
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x7f, %rax
movq %rax, -0x18(%rbp)
cmpq $0x70, -0x18(%rbp)
jae 0x1526a
movl $0x70, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x15277
movl $0xf0, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x183b2(%rip), %rsi # 0x2d640
callq 0x15030
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x10, %edx
callq 0x15030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shrq $0x38, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shrq $0x30, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shrq $0x28, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x38, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x30, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x28, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xa(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xb(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xd(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xe(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xf(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x38, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x30, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x11(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x28, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x12(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x13(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x14(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x15(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x16(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x17(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
shrq $0x38, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
shrq $0x30, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x19(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
shrq $0x28, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1a(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1b(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1d(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1e(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1f(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
shrq $0x38, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
shrq $0x30, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x21(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
shrq $0x28, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x22(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x23(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x24(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x25(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x26(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x27(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
shrq $0x38, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
shrq $0x30, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x29(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
shrq $0x28, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2a(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2b(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2c(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2d(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2e(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2f(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xd0(%rax)
jne 0x157d5
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x38, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x30, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x31(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x28, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x32(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x33(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x34(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x35(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x36(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x37(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x38, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x30, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x39(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x28, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3a(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3b(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3c(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3d(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3e(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3f(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/Dragonchang[P]https_client/mbedtls/library/sha512.c
|
mbedtls_asn1_get_int
|
int mbedtls_asn1_get_int( unsigned char **p,
const unsigned char *end,
int *val )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
return( ret );
if( len == 0 || len > sizeof( int ) || ( **p & 0x80 ) != 0 )
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
*val = 0;
while( len-- > 0 )
{
*val = ( *val << 8 ) | **p;
(*p)++;
}
return( 0 );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x2, %ecx
callq 0x15cb0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x15dfa
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15e76
cmpq $0x0, -0x30(%rbp)
je 0x15e1c
cmpq $0x4, -0x30(%rbp)
ja 0x15e1c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x15e25
movl $0xffffff9c, -0x4(%rbp) # imm = 0xFFFFFF9C
jmp 0x15e76
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x30(%rbp)
cmpq $0x0, %rax
jbe 0x15e6f
movq -0x20(%rbp), %rax
movl (%rax), %ecx
shll $0x8, %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
orl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x15e2f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
|
/Dragonchang[P]https_client/mbedtls/library/asn1parse.c
|
mbedtls_asn1_get_sequence_of
|
int mbedtls_asn1_get_sequence_of( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_sequence *cur,
int tag)
{
int ret;
size_t len;
mbedtls_asn1_buf *buf;
/* Get main sequence tag */
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
return( ret );
if( *p + len != end )
return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
while( *p < end )
{
buf = &(cur->buf);
buf->tag = **p;
if( ( ret = mbedtls_asn1_get_tag( p, end, &buf->len, tag ) ) != 0 )
return( ret );
buf->p = *p;
*p += buf->len;
/* Allocate and assign next pointer */
if( *p < end )
{
cur->next = (mbedtls_asn1_sequence*)mbedtls_calloc( 1,
sizeof( mbedtls_asn1_sequence ) );
if( cur->next == NULL )
return( MBEDTLS_ERR_ASN1_ALLOC_FAILED );
cur = cur->next;
}
}
/* Set final sequence entry's next pointer to NULL */
cur->next = NULL;
if( *p != end )
return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
return( 0 );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x30, %ecx
callq 0x15cb0
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
je 0x160a0
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x161a9
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x160bd
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x161a9
jmp 0x160bf
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x16180
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x8, %rdx
movl -0x24(%rbp), %ecx
callq 0x15cb0
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
je 0x16113
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x161a9
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x1617b
movl $0x1, %edi
movl $0x20, %esi
callq 0x80f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1616f
movl $0xffffff96, -0x4(%rbp) # imm = 0xFFFFFF96
jmp 0x161a9
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x160bf
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x161a2
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x161a9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/Dragonchang[P]https_client/mbedtls/library/asn1parse.c
|
mbedtls_mpi_safe_cond_assign
|
int mbedtls_mpi_safe_cond_assign( mbedtls_mpi *X, const mbedtls_mpi *Y, unsigned char assign )
{
int ret = 0;
size_t i;
/* make sure assign is 0 or 1 in a time-constant manner */
assign = (assign | (unsigned char)-assign) >> 7;
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, Y->n ) );
X->s = X->s * ( 1 - assign ) + Y->s * assign;
for( i = 0; i < Y->n; i++ )
X->p[i] = X->p[i] * ( 1 - assign ) + Y->p[i] * assign;
for( ; i < X->n; i++ )
X->p[i] *= ( 1 - assign );
cleanup:
return( ret );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movzbl -0x11(%rbp), %eax
movzbl -0x11(%rbp), %edx
xorl %ecx, %ecx
subl %edx, %ecx
movzbl %cl, %ecx
orl %ecx, %eax
sarl $0x7, %eax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x16600
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x169b1
jmp 0x16a8f
jmp 0x169b3
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movzbl -0x11(%rbp), %edx
movl $0x1, %eax
subl %edx, %eax
imull %eax, %ecx
movq -0x10(%rbp), %rax
movl (%rax), %eax
movzbl -0x11(%rbp), %edx
imull %edx, %eax
addl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x16a4c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movzbl -0x11(%rbp), %ecx
movl $0x1, %eax
subl %ecx, %eax
cltq
imulq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl -0x11(%rbp), %ecx
imulq %rcx, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x169e4
jmp 0x16a4e
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x16a8d
movzbl -0x11(%rbp), %ecx
movl $0x1, %eax
subl %ecx, %eax
movslq %eax, %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
imulq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x16a4e
jmp 0x16a8f
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/Dragonchang[P]https_client/mbedtls/library/bignum.c
|
mbedtls_mpi_bitlen
|
size_t mbedtls_mpi_bitlen( const mbedtls_mpi *X )
{
size_t i, j;
if( X->n == 0 )
return( 0 );
for( i = X->n - 1; i > 0; i-- )
if( X->p[i] != 0 )
break;
j = biL - mbedtls_clz( X->p[i] );
return( ( i * biL ) + j );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16f11
movq $0x0, -0x8(%rbp)
jmp 0x16f81
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x16f4d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x16f3d
jmp 0x16f4d
jmp 0x16f3f
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x16f21
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x16f90
movq %rax, %rcx
movl $0x40, %eax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shlq $0x6, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/Dragonchang[P]https_client/mbedtls/library/bignum.c
|
mbedtls_mpi_add_int
|
int mbedtls_mpi_add_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
return( mbedtls_mpi_add_mpi( X, A, &_B ) );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x173f7
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x173ff
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdx
movl $0x1, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %ecx, %eax
movl %eax, -0x30(%rbp)
movq $0x1, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x187c0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/Dragonchang[P]https_client/mbedtls/library/bignum.c
|
mpi_write_hlp
|
static int mpi_write_hlp( mbedtls_mpi *X, int radix, char **p )
{
int ret;
mbedtls_mpi_uint r;
if( radix < 2 || radix > 16 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, radix ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_div_int( X, NULL, X, radix ) );
if( mbedtls_mpi_cmp_int( X, 0 ) != 0 )
MBEDTLS_MPI_CHK( mpi_write_hlp( X, radix, p ) );
if( r < 10 )
*(*p)++ = (char)( r + 0x30 );
else
*(*p)++ = (char)( r + 0x37 );
cleanup:
return( ret );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x2, -0x14(%rbp)
jl 0x1774f
cmpl $0x10, -0x14(%rbp)
jle 0x1775b
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x1781d
jmp 0x1775d
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x198d0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x1777b
jmp 0x17817
jmp 0x1777d
jmp 0x1777f
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x19780
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x1779e
jmp 0x17817
jmp 0x177a0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x18310
cmpl $0x0, %eax
je 0x177d2
jmp 0x177b4
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x17730
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x177ce
jmp 0x17817
jmp 0x177d0
jmp 0x177d2
cmpq $0xa, -0x30(%rbp)
jae 0x177f8
movq -0x30(%rbp), %rax
addq $0x30, %rax
movb %al, %cl
movq -0x20(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
jmp 0x17815
movq -0x30(%rbp), %rax
addq $0x37, %rax
movb %al, %cl
movq -0x20(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
jmp 0x17817
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/Dragonchang[P]https_client/mbedtls/library/bignum.c
|
mbedtls_mpi_cmp_mpi
|
int mbedtls_mpi_cmp_mpi( const mbedtls_mpi *X, const mbedtls_mpi *Y )
{
size_t i, j;
for( i = X->n; i > 0; i-- )
if( X->p[i - 1] != 0 )
break;
for( j = Y->n; j > 0; j-- )
if( Y->p[j - 1] != 0 )
break;
if( i == 0 && j == 0 )
return( 0 );
if( i > j ) return( X->s );
if( j > i ) return( -Y->s );
if( X->s > 0 && Y->s < 0 ) return( 1 );
if( Y->s > 0 && X->s < 0 ) return( -1 );
for( ; i > 0; i-- )
{
if( X->p[i - 1] > Y->p[i - 1] ) return( X->s );
if( X->p[i - 1] < Y->p[i - 1] ) return( -X->s );
}
return( 0 );
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x181b8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x181a8
jmp 0x181b8
jmp 0x181aa
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x18188
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x181f4
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x181e4
jmp 0x181f4
jmp 0x181e6
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x181c4
cmpq $0x0, -0x20(%rbp)
jne 0x1820e
cmpq $0x0, -0x28(%rbp)
jne 0x1820e
movl $0x0, -0x4(%rbp)
jmp 0x1830b
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x18226
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1830b
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x18240
movq -0x18(%rbp), %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x1830b
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x1825e
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x1825e
movl $0x1, -0x4(%rbp)
jmp 0x1830b
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x1827c
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x1827c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1830b
jmp 0x1827e
cmpq $0x0, -0x20(%rbp)
jbe 0x18304
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
jbe 0x182ba
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1830b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x182f1
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x1830b
jmp 0x182f3
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1827e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
|
/Dragonchang[P]https_client/mbedtls/library/bignum.c
|
mbedtls_mpi_mod_int
|
int mbedtls_mpi_mod_int( mbedtls_mpi_uint *r, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
size_t i;
mbedtls_mpi_uint x, y, z;
if( b == 0 )
return( MBEDTLS_ERR_MPI_DIVISION_BY_ZERO );
if( b < 0 )
return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
/*
* handle trivial cases
*/
if( b == 1 )
{
*r = 0;
return( 0 );
}
if( b == 2 )
{
*r = A->p[0] & 1;
return( 0 );
}
/*
* general case
*/
for( i = A->n, y = 0; i > 0; i-- )
{
x = A->p[i - 1];
y = ( y << biH ) | ( x >> biH );
z = y / b;
y -= z * b;
x <<= biH;
y = ( y << biH ) | ( x >> biH );
z = y / b;
y -= z * b;
}
/*
* If A is negative, then the current y represents a negative value.
* Flipping it to the positive side.
*/
if( A->s < 0 && y != 0 )
y = b - y;
*r = y;
return( 0 );
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x198f3
movl $0xfffffff4, -0x4(%rbp) # imm = 0xFFFFFFF4
jmp 0x19a45
cmpq $0x0, -0x20(%rbp)
jge 0x19906
movl $0xfffffff6, -0x4(%rbp) # imm = 0xFFFFFFF6
jmp 0x19a45
cmpq $0x1, -0x20(%rbp)
jne 0x19924
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x19a45
cmpq $0x2, -0x20(%rbp)
jne 0x1994d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
andq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x19a45
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x19a17
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
shlq $0x20, %rax
movq -0x30(%rbp), %rcx
shrq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
imulq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
shlq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
shlq $0x20, %rax
movq -0x30(%rbp), %rcx
shrq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
imulq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x19961
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x19a33
cmpq $0x0, -0x38(%rbp)
je 0x19a33
movq -0x20(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
/Dragonchang[P]https_client/mbedtls/library/bignum.c
|
mbedtls_cipher_info_from_values
|
const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id,
int key_bitlen,
const mbedtls_cipher_mode_t mode )
{
const mbedtls_cipher_definition_t *def;
for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
if( def->info->base->cipher == cipher_id &&
def->info->key_bitlen == (unsigned) key_bitlen &&
def->info->mode == mode )
return( def->info );
return( NULL );
}
|
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1cc7c(%rip), %rax # 0x38bc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1bfa4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1bf94
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x1bf94
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x1bf94
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1bfac
jmp 0x1bf96
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x1bf48
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/Dragonchang[P]https_client/mbedtls/library/cipher.c
|
mbedtls_cipher_setup
|
int mbedtls_cipher_setup( mbedtls_cipher_context_t *ctx, const mbedtls_cipher_info_t *cipher_info )
{
if( NULL == cipher_info || NULL == ctx )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
if( NULL == ( ctx->cipher_ctx = cipher_info->base->ctx_alloc_func() ) )
return( MBEDTLS_ERR_CIPHER_ALLOC_FAILED );
ctx->cipher_info = cipher_info;
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
/*
* Ignore possible errors caused by a cipher mode that doesn't use padding
*/
#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
(void) mbedtls_cipher_set_padding_mode( ctx, MBEDTLS_PADDING_PKCS7 );
#else
(void) mbedtls_cipher_set_padding_mode( ctx, MBEDTLS_PADDING_NONE );
#endif
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
return( 0 );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1c0a0
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1c0a9
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0x1c0fc
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x80c0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
callq *0x40(%rax)
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x1c0df
movl $0xffff9e80, -0x4(%rbp) # imm = 0xFFFF9E80
jmp 0x1c0fc
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1c110
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/Dragonchang[P]https_client/mbedtls/library/cipher.c
|
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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1c4ff
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x1c4ff
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jne 0x1c50b
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0x1c9b7
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1c9c0
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0x1c59d
movq -0x20(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x1c548
movl $0xffff9d80, -0x4(%rbp) # imm = 0xFFFF9D80
jmp 0x1c9b7
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %esi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1c591
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c9b7
movl $0x0, -0x4(%rbp)
jmp 0x1c9b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x6, 0x4(%rax)
jne 0x1c5d6
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x21110
movl %eax, -0x4(%rbp)
jmp 0x1c9b7
xorl %eax, %eax
cmpq -0x40(%rbp), %rax
jne 0x1c5ea
movl $0xffff9c80, -0x4(%rbp) # imm = 0xFFFF9C80
jmp 0x1c9b7
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x1c61d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x1c611
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x40(%rbp)
cmpq $0x0, %rdx
je 0x1c61d
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0x1c9b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, 0x4(%rax)
jne 0x1c868
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x1c655
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq 0x30(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x1c674
movq -0x10(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x1c6ad
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq 0x30(%rdx), %rcx
cmpq %rcx, %rax
jae 0x1c6ad
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8140
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1c9b7
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x30(%rcx), %rax
je 0x1c779
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
subq 0x30(%rcx), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x8140
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %esi
movq -0x40(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x38, %rcx
movq -0x10(%rbp), %r8
addq $0x20, %r8
movq -0x28(%rbp), %r9
callq *%rax
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1c738
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c9b7
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x48(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x1c7fd
xorl %eax, %eax
cmpq -0x40(%rbp), %rax
jne 0x1c795
movl $0xffff9c80, -0x4(%rbp) # imm = 0xFFFF9C80
jmp 0x1c9b7
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x40(%rbp)
movq %rdx, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x1c7be
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x1c7be
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
subq -0x48(%rbp), %rax
addq %rax, %rsi
movq -0x48(%rbp), %rdx
callq 0x8140
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1c85c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %esi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x38, %rcx
movq -0x18(%rbp), %r8
movq -0x28(%rbp), %r9
callq *%rax
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1c84e
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c9b7
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1c9b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x3, 0x4(%rax)
jne 0x1c8e2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %esi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x30, %rcx
movq -0x10(%rbp), %r8
addq $0x38, %r8
movq -0x18(%rbp), %r9
movq -0x28(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1c8cb
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c9b7
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1c9b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x5, 0x4(%rax)
jne 0x1c957
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x30, %rdx
movq -0x10(%rbp), %rcx
addq $0x38, %rcx
movq -0x10(%rbp), %r8
addq $0x20, %r8
movq -0x18(%rbp), %r9
movq -0x28(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1c943
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c9b7
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1c9b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x7, 0x4(%rax)
jne 0x1c9b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1c99c
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c9b7
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1c9b7
movl $0xffff9f80, -0x4(%rbp) # imm = 0xFFFF9F80
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
|
/Dragonchang[P]https_client/mbedtls/library/cipher.c
|
mbedtls_cipher_finish
|
int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx,
unsigned char *output, size_t *olen )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
*olen = 0;
if( MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
MBEDTLS_MODE_CTR == ctx->cipher_info->mode ||
MBEDTLS_MODE_GCM == ctx->cipher_info->mode ||
MBEDTLS_MODE_STREAM == ctx->cipher_info->mode )
{
return( 0 );
}
if( MBEDTLS_MODE_ECB == ctx->cipher_info->mode )
{
if( ctx->unprocessed_len != 0 )
return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
return( 0 );
}
#if defined(MBEDTLS_CIPHER_MODE_CBC)
if( MBEDTLS_MODE_CBC == ctx->cipher_info->mode )
{
int ret = 0;
if( MBEDTLS_ENCRYPT == ctx->operation )
{
/* check for 'no padding' mode */
if( NULL == ctx->add_padding )
{
if( 0 != ctx->unprocessed_len )
return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
return( 0 );
}
ctx->add_padding( ctx->unprocessed_data, mbedtls_cipher_get_iv_size( ctx ),
ctx->unprocessed_len );
}
else if( mbedtls_cipher_get_block_size( ctx ) != ctx->unprocessed_len )
{
/*
* For decrypt operations, expect a full block,
* or an empty block if no padding
*/
if( NULL == ctx->add_padding && 0 == ctx->unprocessed_len )
return( 0 );
return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
}
/* cipher block */
if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
ctx->operation, mbedtls_cipher_get_block_size( ctx ), ctx->iv,
ctx->unprocessed_data, output ) ) )
{
return( ret );
}
/* Set output size for decryption */
if( MBEDTLS_DECRYPT == ctx->operation )
return ctx->get_padding( output, mbedtls_cipher_get_block_size( ctx ),
olen );
/* Set output size for encryption */
*olen = mbedtls_cipher_get_block_size( ctx );
return( 0 );
}
#else
((void) output);
#endif /* MBEDTLS_CIPHER_MODE_CBC */
return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1ca2f
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x1ca2f
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1ca3b
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0x1cc76
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x3, %eax
cmpl 0x4(%rcx), %eax
je 0x1ca8a
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x5, %eax
cmpl 0x4(%rcx), %eax
je 0x1ca8a
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x6, %eax
cmpl 0x4(%rcx), %eax
je 0x1ca8a
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x7, %eax
cmpl 0x4(%rcx), %eax
jne 0x1ca96
movl $0x0, -0x4(%rbp)
jmp 0x1cc76
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %eax
cmpl 0x4(%rcx), %eax
jne 0x1caca
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1cabe
movl $0xffff9d80, -0x4(%rbp) # imm = 0xFFFF9D80
jmp 0x1cc76
movl $0x0, -0x4(%rbp)
jmp 0x1cc76
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x2, %eax
cmpl 0x4(%rcx), %eax
jne 0x1cc6f
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rcx
movl $0x1, %eax
cmpl 0xc(%rcx), %eax
jne 0x1cb5e
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
jne 0x1cb24
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x30(%rcx), %rax
je 0x1cb18
movl $0xffff9d80, -0x4(%rbp) # imm = 0xFFFF9D80
jmp 0x1cc76
movl $0x0, -0x4(%rbp)
jmp 0x1cc76
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1cc80
movq -0x38(%rbp), %rdi
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rsi
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rdx
callq *%rax
jmp 0x1cba5
movq -0x10(%rbp), %rdi
callq 0x1c9c0
movl %eax, %eax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
je 0x1cba3
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
jne 0x1cb97
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x30(%rcx), %rax
jne 0x1cb97
movl $0x0, -0x4(%rbp)
jmp 0x1cc76
movl $0xffff9d80, -0x4(%rbp) # imm = 0xFFFF9D80
jmp 0x1cc76
jmp 0x1cba5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c9c0
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %esi
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq -0x10(%rbp), %rcx
addq $0x38, %rcx
movq -0x10(%rbp), %r8
addq $0x20, %r8
movq -0x18(%rbp), %r9
callq *%rax
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1cc11
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1cc76
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0xc(%rcx), %eax
jne 0x1cc52
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c9c0
movq -0x60(%rbp), %rdi
movl %eax, %ecx
movq -0x58(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %esi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x1cc76
movq -0x10(%rbp), %rdi
callq 0x1c9c0
movl %eax, %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1cc76
movl $0xffff9f80, -0x4(%rbp) # imm = 0xFFFF9F80
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
|
/Dragonchang[P]https_client/mbedtls/library/cipher.c
|
mbedtls_cipher_write_tag
|
int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
unsigned char *tag, size_t tag_len )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == tag )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( MBEDTLS_ENCRYPT != ctx->operation )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
return mbedtls_gcm_finish( (mbedtls_gcm_context *) ctx->cipher_ctx, tag, tag_len );
return( 0 );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1d26f
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x1d26f
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x1d278
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0x1d2c1
movq -0x10(%rbp), %rcx
movl $0x1, %eax
cmpl 0xc(%rcx), %eax
je 0x1d28f
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0x1d2c1
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x6, %eax
cmpl 0x4(%rcx), %eax
jne 0x1d2ba
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x21380
movl %eax, -0x4(%rbp)
jmp 0x1d2c1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/Dragonchang[P]https_client/mbedtls/library/cipher.c
|
mbedtls_md5_self_test
|
int mbedtls_md5_self_test( int verbose )
{
int i;
unsigned char md5sum[16];
for( i = 0; i < 7; i++ )
{
if( verbose != 0 )
mbedtls_printf( " MD5 test #%d: ", i + 1 );
mbedtls_md5( md5_test_buf[i], md5_test_buflen[i], md5sum );
if( memcmp( md5sum, md5_test_sum[i], 16 ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( 1 );
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
return( 0 );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x7, -0xc(%rbp)
jge 0x239c5
cmpl $0x0, -0x8(%rbp)
je 0x23926
movl -0xc(%rbp), %esi
addl $0x1, %esi
leaq 0xc051(%rip), %rdi # 0x2f970
movb $0x0, %al
callq 0x8090
movslq -0xc(%rbp), %rax
leaq 0xc05f(%rip), %rdi # 0x2f990
imulq $0x51, %rax, %rax
addq %rax, %rdi
movslq -0xc(%rbp), %rcx
leaq 0xc28d(%rip), %rax # 0x2fbd0
movslq (%rax,%rcx,4), %rsi
leaq -0x20(%rbp), %rdx
callq 0x23890
leaq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rdx
leaq 0xc291(%rip), %rcx # 0x2fbf0
shlq $0x4, %rdx
addq %rdx, %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x239a1
cmpl $0x0, -0x8(%rbp)
je 0x23998
leaq 0x98b1(%rip), %rdi # 0x2d242
movb $0x0, %al
callq 0x8090
movl $0x1, -0x4(%rbp)
jmp 0x239e0
cmpl $0x0, -0x8(%rbp)
je 0x239b5
leaq 0x8f43(%rip), %rdi # 0x2c8f1
movb $0x0, %al
callq 0x8090
jmp 0x239b7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x23902
cmpl $0x0, -0x8(%rbp)
je 0x239d9
leaq 0xc981(%rip), %rdi # 0x30353
movb $0x0, %al
callq 0x8090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
/Dragonchang[P]https_client/mbedtls/library/md5.c
|
BamTools::Internal::BamReaderPrivate::LoadReferenceData()
|
bool BamReaderPrivate::LoadReferenceData()
{
// get number of reference sequences
char buffer[sizeof(uint32_t)];
m_stream.Read(buffer, sizeof(uint32_t));
uint32_t numberRefSeqs = BamTools::UnpackUnsignedInt(buffer);
if (m_isBigEndian) BamTools::SwapEndian_32(numberRefSeqs);
m_references.reserve((int)numberRefSeqs);
// iterate over all references in header
for (unsigned int i = 0; i != numberRefSeqs; ++i) {
// get length of reference name
m_stream.Read(buffer, sizeof(uint32_t));
uint32_t refNameLength = BamTools::UnpackUnsignedInt(buffer);
if (m_isBigEndian) BamTools::SwapEndian_32(refNameLength);
RaiiBuffer refName(refNameLength);
// get reference name and reference sequence length
m_stream.Read(refName.Buffer, refNameLength);
m_stream.Read(buffer, sizeof(int32_t));
int32_t refLength = BamTools::UnpackSignedInt(buffer);
if (m_isBigEndian) BamTools::SwapEndian_32(refLength);
// store data for reference
RefData aReference;
aReference.RefName = static_cast<std::string>((const char*)refName.Buffer);
aReference.RefLength = refLength;
m_references.push_back(aReference);
}
// return success
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r13
leaq 0x1e8(%rdi), %r14
leaq 0xc(%rsp), %r15
pushq $0x4
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4b21a
movl (%r15), %eax
movl %eax, %ebx
bswapl %ebx
cmpb $0x0, 0x40(%r13)
cmovel %eax, %ebx
leaq 0x28(%r13), %rdi
movslq %ebx, %rsi
movq %rdi, 0x28(%rsp)
callq 0x4a1d4
movq %r13, 0x20(%rsp)
subl $0x1, %ebx
jb 0x498f4
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4b21a
movl 0xc(%rsp), %eax
movq %r15, %r12
movl %eax, %r15d
bswapl %r15d
movq %r13, %rbp
cmpb $0x0, 0x40(%r13)
cmovel %eax, %r15d
movq %r15, %rdi
callq 0x36030
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x36230
movq %r13, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %r15
pushq $0x4
popq %r12
callq 0x4b21a
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4b21a
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpb $0x1, 0x40(%rbp)
jne 0x49867
leaq 0x8(%rsp), %rdi
callq 0x4a269
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
movb $0x0, 0x40(%rsp)
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
leaq 0x30(%rsp), %r13
movq %r13, %rsi
callq 0x365e0
andl $0x0, 0x70(%rsp)
movq %r13, %rdi
callq 0x368a8
movq 0x10(%rsp), %rsi
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0x36170
movq %rbp, %rdi
movq %r13, %rsi
callq 0x36500
movq %r13, %rdi
callq 0x368a8
movl 0x8(%rsp), %eax
movl %eax, 0x70(%rsp)
movq 0x28(%rsp), %rdi
movq %rbp, %rsi
callq 0x4a292
movq %rbp, %rdi
callq 0x368a8
leaq 0x10(%rsp), %rdi
callq 0x484d0
movq 0x20(%rsp), %r13
jmp 0x497da
movb $0x1, %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x49919
jmp 0x49911
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x368a8
jmp 0x49923
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x484d0
movq %rbx, %rdi
callq 0x367b0
nop
|
/alok123t[P]HyINDEL/external/bamtools/src/api/internal/bam/BamReader_p.cpp
|
main
|
int main(int argc, char ** argv)
{
// Instantiate Argengine and give it the raw argument data.
Argengine ae(argc, argv);
// Add a minimal dummy option "foo".
ae.addOption(
{ "foo" }, [] {
std::cout << "Foo enabled!" << std::endl;
});
// Add a minimal dummy option "bar".
ae.addOption(
{ "bar" }, [] {
std::cout << "Bar enabled!" << std::endl;
});
// Set "foo" and "bar" as conflicting options.
ae.addConflictingOptions({ "foo", "bar" });
// Parse the arguments and store possible error to variable error.
Argengine::Error error;
ae.parse(error);
// Check error and print the possible error message.
if (error.code != Argengine::Error::Code::Ok) {
std::cerr << error.message << std::endl
<< std::endl;
ae.printHelp(); // Print the auto-generated help.
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x160, %rsp # imm = 0x160
movq %rsi, %rdx
movl %edi, %esi
leaq 0x8(%rsp), %rdi
movl $0x1, %ecx
callq 0x20e0
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xcd4(%rip), %rsi # 0x3004
leaq 0xcd0(%rip), %rdx # 0x3007
leaq 0x10(%rsp), %rdi
callq 0x29f2
leaq 0x130(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x7(%rsp), %rcx
leaq 0x6(%rsp), %r8
movl $0x1, %edx
callq 0x28ec
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
leaq 0x4c3(%rip), %rax # 0x2834
movq %rax, 0x88(%rsp)
leaq 0x4f8(%rip), %rax # 0x2878
movq %rax, 0x80(%rsp)
leaq 0xc0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xca7(%rip), %rdx # 0x3042
leaq 0xb0(%rsp), %rdi
movq %rdx, %rsi
callq 0x29f2
leaq 0x8(%rsp), %rdi
leaq 0x130(%rsp), %rsi
leaq 0x70(%rsp), %rdx
leaq 0xb0(%rsp), %r8
xorl %ecx, %ecx
callq 0x2050
movq 0xb0(%rsp), %rdi
cmpq %r15, %rdi
je 0x23e9
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x2140
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x2405
leaq 0x70(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x130(%rsp), %rdi
callq 0x297a
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x2429
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2140
leaq 0x10(%rsp), %rdi
movq %r14, (%rdi)
leaq 0xbd0(%rip), %rsi # 0x3008
leaq 0xbcc(%rip), %rdx # 0x300b
callq 0x29f2
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x7(%rsp), %rcx
leaq 0x6(%rsp), %r8
movl $0x1, %edx
callq 0x28ec
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
leaq 0x41c(%rip), %rax # 0x2890
movq %rax, 0x68(%rsp)
leaq 0x454(%rip), %rax # 0x28d4
movq %rax, 0x60(%rsp)
leaq 0xa0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xbaa(%rip), %rdx # 0x3042
leaq 0x90(%rsp), %rdi
movq %rdx, %rsi
callq 0x29f2
leaq 0x8(%rsp), %rdi
leaq 0x100(%rsp), %rsi
leaq 0x50(%rsp), %rdx
leaq 0x90(%rsp), %r8
xorl %ecx, %ecx
callq 0x2050
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x24e6
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x2140
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x24ff
leaq 0x50(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x100(%rsp), %rdi
callq 0x297a
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x2523
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2140
leaq 0x10(%rsp), %r15
movq %r14, (%r15)
leaq 0xad2(%rip), %rsi # 0x3004
leaq 0xace(%rip), %rdx # 0x3007
movq %r15, %rdi
callq 0x29f2
leaq 0x30(%rsp), %r14
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xab1(%rip), %rsi # 0x3008
leaq 0xaad(%rip), %rdx # 0x300b
movq %r14, %rdi
callq 0x29f2
leaq 0xd0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x7(%rsp), %rcx
leaq 0x6(%rsp), %r8
movl $0x2, %edx
callq 0x28ec
leaq 0x8(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x2110
leaq 0xd0(%rsp), %rdi
callq 0x297a
movq $-0x40, %rbx
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x25c3
movq (%r12), %rsi
incq %rsi
callq 0x2140
addq $-0x20, %r12
addq $0x20, %rbx
jne 0x25ad
leaq 0x28(%rsp), %r14
movl $0x0, -0x18(%r14)
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x21a0
cmpl $0x0, 0x10(%rsp)
je 0x267b
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x29df(%rip), %rdi # 0x4ff0
callq 0x2160
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movl $0x1, %ebx
leaq 0x8(%rsp), %rdi
callq 0x2070
jmp 0x267d
xorl %ebx, %ebx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x2694
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2140
leaq 0x8(%rsp), %rdi
callq 0x20a0
movl %ebx, %eax
addq $0x160, %rsp # imm = 0x160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x27e7
jmp 0x27e7
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x297a
jmp 0x26d0
movq %rax, %rbx
xorl %r13d, %r13d
movq 0x30(%rsp,%r13), %rdi
leaq (%r12,%r13), %rax
cmpq %rdi, %rax
je 0x26ec
movq (%rax), %rsi
incq %rsi
callq 0x2140
addq $-0x20, %r13
cmpq $-0x40, %r13
jne 0x26d3
movb $0x1, %al
jmp 0x2709
movq %rax, %rbx
xorl %eax, %eax
jmp 0x2709
movq %rax, %rbx
xorl %eax, %eax
movq %r15, %r14
cmpq %r14, %r15
sete %cl
orb %al, %cl
jne 0x2822
addq $-0x10, %r14
leaq 0x10(%rsp), %r15
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x2734
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x20(%r14), %rax
addq $-0x10, %r14
cmpq %r15, %r14
movq %rax, %r14
jne 0x2720
jmp 0x2822
movq %rax, %rbx
movq 0x90(%rsp), %rdi
cmpq %r15, %rdi
je 0x276e
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x276e
movq %rax, %rbx
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x2787
leaq 0x50(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x100(%rsp), %rdi
jmp 0x27e0
jmp 0x27e7
jmp 0x27ef
jmp 0x2803
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
cmpq %r15, %rdi
je 0x27bc
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x27bc
movq %rax, %rbx
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x27d8
leaq 0x70(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x130(%rsp), %rdi
callq 0x297a
jmp 0x27f2
movq %rax, %rdi
callq 0x296e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x2822
movq 0x20(%rsp), %rsi
jmp 0x281a
movq %rax, %rbx
jmp 0x2822
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x2822
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2140
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x21b0
|
/juzzlin[P]Argengine/src/examples/ex2/ex2.cpp
|
select_wrapper
|
int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset. IOW Winsock
* select() can not be used to sleep without a single fd_set.
*/
if(!nfds) {
Sleep((1000*tv->tv_sec) + (DWORD)(((double)tv->tv_usec)/1000.0));
return 0;
}
#endif
return select(nfds, rd, wr, exc, tv);
}
|
testl %edi, %edi
jns 0x10a0
pushq %rax
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
|
/mitls[P]mitls-curl/tests/libtest/first.c
|
select_wrapper
|
int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset. IOW Winsock
* select() can not be used to sleep without a single fd_set.
*/
if(!nfds) {
Sleep((1000*tv->tv_sec) + (DWORD)(((double)tv->tv_usec)/1000.0));
return 0;
}
#endif
return select(nfds, rd, wr, exc, tv);
}
|
testl %edi, %edi
jns 0x10d0
pushq %rax
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
|
/devkitPro[P]curl/tests/libtest/first.c
|
hexdump
|
char *hexdump(const unsigned char *buffer, size_t len)
{
static char dump[200 * 3 + 1];
char *p = dump;
size_t i;
if(len > 200)
return NULL;
for(i = 0; i<len; i++, p += 3)
msnprintf(p, 4, "%02x ", buffer[i]);
return dump;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0xc8, %rsi
jbe 0x1bb7
xorl %ebx, %ebx
jmp 0x1c01
movq %rsi, %r14
testq %rsi, %rsi
je 0x1bfa
movq %rdi, %r15
leaq 0x2547(%rip), %rbx # 0x4110
leaq 0x795(%rip), %r12 # 0x2365
xorl %ebp, %ebp
movq %rbx, %r13
movzbl (%r15,%rbp), %ecx
movl $0x4, %esi
movq %r13, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1070
incq %rbp
addq $0x3, %r13
cmpq %rbp, %r14
jne 0x1bd5
jmp 0x1c01
leaq 0x250f(%rip), %rbx # 0x4110
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/devkitPro[P]curl/tests/libtest/first.c
|
main
|
int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour by the C library in order to test for undesired side
* effects that could cause in libcurl.
*/
#ifdef HAVE_SETLOCALE
setlocale(LC_ALL, "");
#endif
if(argc< 2) {
fprintf(stderr, "Pass URL as argument please\n");
return 1;
}
test_argc = argc;
test_argv = argv;
if(argc>2)
libtest_arg2 = argv[2];
if(argc>3)
libtest_arg3 = argv[3];
URL = argv[1]; /* provide this to the rest */
fprintf(stderr, "URL: %s\n", URL);
result = test(URL);
#ifdef USE_NSS
if(PR_Initialized())
/* prevent valgrind from reporting possibly lost memory (fd cache, ...) */
PR_Cleanup();
#endif
return result;
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x717(%rip), %rsi # 0x2339
movl $0x6, %edi
callq 0x10a0
cmpl $0x1, %ebp
jg 0x1c55
movq 0x23a8(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0x729(%rip), %rsi # 0x236b
xorl %eax, %eax
callq 0x1140
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebp, 0x2711(%rip) # 0x436c
movq %rbx, 0x270e(%rip) # 0x4370
cmpl $0x2, %ebp
je 0x1c72
movq 0x10(%rbx), %rax
movq %rax, 0x248e(%rip) # 0x4100
cmpl $0x4, %ebp
jl 0x1c82
movq 0x18(%rbx), %rax
movq %rax, 0x2486(%rip) # 0x4108
movq 0x8(%rbx), %rbx
movq 0x2353(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0x6f1(%rip), %rsi # 0x2388
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1140
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12bc
nop
|
/devkitPro[P]curl/tests/libtest/first.c
|
tutil_tvdiff
|
long tutil_tvdiff(struct timeval newer, struct timeval older)
{
return (long)(newer.tv_sec-older.tv_sec)*1000+
(long)(newer.tv_usec-older.tv_usec)/1000;
}
|
movq %rsi, %rax
subq %rdx, %rdi
subq %rcx, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
imulq $0x3e8, %rdi, %rcx # imm = 0x3E8
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rdx, %rax
addq %rcx, %rax
retq
|
/devkitPro[P]curl/tests/libtest/testutil.c
|
curlx_ultosi
|
int curlx_ultosi(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_SINT);
return (int)(ulnum & (unsigned long) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
}
|
movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
|
/devkitPro[P]curl/lib/warnless.c
|
curlx_uztosi
|
int curlx_uztosi(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SINT);
return (int)(uznum & (size_t) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
}
|
movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
|
/devkitPro[P]curl/lib/warnless.c
|
graph::isEdge(restaurant*, restaurant*)
|
bool graph::isEdge(restaurant *from, restaurant *to)
{
if (v.find(mapper[from]) == v.end() || v.find(mapper[to]) == v.end())
{
return false;
}
vector<pair<int, int>> adj = theGraph[mapper[from]];
for (int i = 0; i < adj.size(); i++)
{
if (adj[i].first == mapper[to])
{
return true;
}
}
return false;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x88(%rbp)
addq $0x68, %rdi
leaq -0x18(%rbp), %rsi
callq 0x17040
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x170d0
movq -0x80(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
callq 0x17110
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x170a0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x71(%rbp)
jne 0x1655a
movq -0x80(%rbp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x90(%rbp)
addq $0x68, %rdi
leaq -0x20(%rbp), %rsi
callq 0x17040
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x170d0
movq -0x80(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x38, %rdi
callq 0x17110
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x170a0
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x16563
jmp 0x1656c
movb $0x0, -0x1(%rbp)
jmp 0x16647
movq -0x80(%rbp), %rdi
addq $0x68, %rdi
leaq -0x18(%rbp), %rsi
callq 0x17040
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x17190
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x17220
movl $0x0, -0x5c(%rbp)
movslq -0x5c(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x17310
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x16633
movslq -0x5c(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x17330
movq -0x80(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0xa4(%rbp)
addq $0x68, %rdi
leaq -0x20(%rbp), %rsi
callq 0x17040
movq %rax, -0xa0(%rbp)
jmp 0x165ee
movl -0xa4(%rbp), %eax
movq -0xa0(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x16623
movb $0x1, -0x1(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0x1663e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xb4d0
jmp 0x16655
jmp 0x16625
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x1659c
movb $0x0, -0x1(%rbp)
movl $0x1, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xb4d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x34e0
nop
|
/mmhobi7[P]UPick/graph.cpp
|
graph::getAdjacent(restaurant*)
|
vector<restaurant *> graph::getAdjacent(restaurant *vertex)
{
vector<restaurant *> adj;
if (v.find(mapper[vertex]) == v.end())
{
return adj;
}
vector<pair<int, int>> list = theGraph[mapper[vertex]];
for (int i = 0; i < list.size(); i++)
{
// find vertex to add
int key = list[i].first;
if (v.find(key) != v.end())
{
adj.push_back(reverseMapper[key]);
}
}
sort(adj.begin(), adj.end());
return adj;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x146a0
movq -0xa0(%rbp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x98(%rbp)
addq $0x68, %rdi
leaq -0x18(%rbp), %rsi
callq 0x17040
movq %rax, -0x90(%rbp)
jmp 0x168b7
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdi
callq 0x170d0
movq %rax, -0xb8(%rbp)
jmp 0x168d3
movq -0xa0(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
callq 0x17110
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x170a0
testb $0x1, %al
jne 0x16905
jmp 0x16926
movb $0x1, -0x19(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x16ab1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x16ad3
movq -0xa0(%rbp), %rdi
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
addq $0x68, %rdi
leaq -0x18(%rbp), %rsi
callq 0x17040
movq %rax, -0xc0(%rbp)
jmp 0x1694d
movq -0xc0(%rbp), %rsi
movq -0xc8(%rbp), %rdi
callq 0x17190
movq %rax, -0xd0(%rbp)
jmp 0x16969
movq -0xd0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x17220
jmp 0x1697b
movl $0x0, -0x64(%rbp)
movslq -0x64(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x17310
movq %rax, %rcx
movq -0xd8(%rbp), %rax
cmpq %rcx, %rax
jae 0x16a68
movslq -0x64(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x17330
movq -0xa0(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x68(%rbp)
addq $0x38, %rdi
leaq -0x68(%rbp), %rsi
callq 0x170d0
movq %rax, -0xe0(%rbp)
jmp 0x169d8
movq -0xa0(%rbp), %rdi
movq -0xe0(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x38, %rdi
callq 0x17110
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x17350
testb $0x1, %al
jne 0x16a0a
jmp 0x16a58
movq -0xa0(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x68(%rbp), %rsi
callq 0x17070
movq %rax, -0xe8(%rbp)
jmp 0x16a2a
movq -0xe8(%rbp), %rsi
movq -0xb0(%rbp), %rdi
callq 0x10270
jmp 0x16a3f
jmp 0x16a58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xb4d0
jmp 0x16ad3
jmp 0x16a5a
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x16982
movq -0xb0(%rbp), %rdi
callq 0x14de0
movq -0xb0(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x14c70
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x17380
jmp 0x16a9d
movb $0x1, -0x19(%rbp)
movl $0x1, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xb4d0
testb $0x1, -0x19(%rbp)
jne 0x16ac3
movq -0xb0(%rbp), %rdi
callq 0x57c0
movq -0xa8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x57c0
movq -0x30(%rbp), %rdi
callq 0x34e0
nopl (%rax,%rax)
|
/mmhobi7[P]UPick/graph.cpp
|
smf::MidiMessage::isSoftOff() const
|
bool MidiMessage::isSoftOff(void) const {
if (!isSoft()) {
return false;
}
if (getP2() < 64) {
return true;
} else {
return false;
}
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x1f980
testb %al, %al
je 0x1f9fc
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
movb $0x1, %al
cmpq $0x3, %rdx
jb 0x1f9fe
cmpb $0x40, 0x2(%rcx)
setb %al
jmp 0x1f9fe
xorl %eax, %eax
popq %rbx
retq
|
/craigsapp[P]midifile/src/MidiMessage.cpp
|
smf::MidiMessage::isLyricText() const
|
bool MidiMessage::isLyricText(void) const {
if (!isMetaMessage()) {
return false;
} else if ((*this)[1] != 0x05) {
return false;
} else {
return true;
}
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x1f7f8
testb %al, %al
je 0x1fb1f
movq (%rbx), %rax
cmpb $0x5, 0x1(%rax)
sete %al
jmp 0x1fb21
xorl %eax, %eax
popq %rbx
retq
nop
|
/craigsapp[P]midifile/src/MidiMessage.cpp
|
smf::MidiMessage::setCommand(int, int, int)
|
void MidiMessage::setCommand(int value, int p1, int p2) {
this->resize(3);
(*this)[0] = (uchar)value;
(*this)[1] = (uchar)p1;
(*this)[2] = (uchar)p2;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
pushq $0x3
popq %rsi
callq 0x1e97e
movq (%r15), %rax
movb %r14b, (%rax)
movq (%r15), %rax
movb %bpl, 0x1(%rax)
movq (%r15), %rax
movb %bl, 0x2(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/craigsapp[P]midifile/src/MidiMessage.cpp
|
smf::Binasc::processVlvWord(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
|
int Binasc::processVlvWord(std::ostream& out, const std::string& word,
int lineNum) {
if (word.size() < 2) {
std::cerr << "Error on line: " << lineNum
<< ": 'v' needs to be followed immediately by a decimal digit"
<< std::endl;
return 0;
}
if (!isdigit(word[1])) {
std::cerr << "Error on line: " << lineNum
<< ": 'v' needs to be followed immediately by a decimal digit"
<< std::endl;
return 0;
}
ulong value = atoi(&word[1]);
uchar byte[5];
byte[0] = (value >> 28) & 0x7f;
byte[1] = (value >> 21) & 0x7f;
byte[2] = (value >> 14) & 0x7f;
byte[3] = (value >> 7) & 0x7f;
byte[4] = (value >> 0) & 0x7f;
int i;
int flag = 0;
for (i=0; i<4; i++) {
if (byte[i] != 0) {
flag = 1;
}
if (flag) {
byte[i] |= 0x80;
}
}
for (i=0; i<5; i++) {
if (byte[i] >= 0x80 || i == 4) {
out << byte[i];
}
}
return 1;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
cmpq $0x1, 0x8(%rdx)
jbe 0x234cf
movq (%rdx), %rdi
movsbl 0x1(%rdi), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0x234cf
movq %rsi, %rbx
incq %rdi
callq 0x16450
movl %eax, %ecx
sarl $0x1c, %ecx
andb $0x7f, %cl
movb %cl, 0xb(%rsp)
movl %eax, %ecx
shrl $0x15, %ecx
andb $0x7f, %cl
movb %cl, 0xc(%rsp)
movl %eax, %ecx
shrl $0xe, %ecx
andb $0x7f, %cl
movb %cl, 0xd(%rsp)
movl %eax, %ecx
shrl $0x7, %ecx
andb $0x7f, %cl
movb %cl, 0xe(%rsp)
andb $0x7f, %al
movb %al, 0xf(%rsp)
xorl %eax, %eax
pushq $0x1
popq %rbp
xorl %ecx, %ecx
cmpq $0x4, %rax
je 0x23510
movb 0xb(%rsp,%rax), %dl
testb %dl, %dl
cmovnel %ebp, %ecx
testl %ecx, %ecx
je 0x234ca
orb $-0x80, %dl
movb %dl, 0xb(%rsp,%rax)
incq %rax
jmp 0x234b0
movq 0x13b1a(%rip), %rdi # 0x36ff0
leaq 0x7e3e(%rip), %rsi # 0x2b31b
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x7e38(%rip), %rsi # 0x2b32b
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
callq 0x16160
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $-0x5
popq %r14
testq %r14, %r14
je 0x23505
movb 0x10(%rsp,%r14), %al
testb %al, %al
setns %cl
incq %r14
sete %dl
notb %dl
testb %cl, %dl
jne 0x23514
movsbl %al, %esi
movq %rbx, %rdi
callq 0x162e0
jmp 0x23514
|
/craigsapp[P]midifile/src/Binasc.cpp
|
smf::Binasc::processMidiPitchBendWord(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
|
int Binasc::processMidiPitchBendWord(std::ostream& out, const std::string& word,
int lineNum) {
if (word.size() < 2) {
std::cerr << "Error on line: " << lineNum
<< ": 'p' needs to be followed immediately by "
<< "a floating-point number" << std::endl;
return 0;
}
if (!(isdigit(word[1]) || word[1] == '.' || word[1] == '-'
|| word[1] == '+')) {
std::cerr << "Error on line: " << lineNum
<< ": 'p' needs to be followed immediately by "
<< "a floating-point number" << std::endl;
return 0;
}
double value = strtod(&word[1], NULL);
if (value > 1.0) {
value = 1.0;
}
if (value < -1.0) {
value = -1.0;
}
int intval = (int)(((1 << 13)-0.5) * (value + 1.0) + 0.5);
uchar LSB = intval & 0x7f;
uchar MSB = (intval >> 7) & 0x7f;
out << LSB << MSB;
return 1;
}
|
pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebp
cmpq $0x1, 0x8(%rdx)
ja 0x23592
movq 0x13aa1(%rip), %rdi # 0x36ff0
leaq 0x7dc5(%rip), %rsi # 0x2b31b
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x7e3c(%rip), %rsi # 0x2b3a8
movq %rax, %rdi
callq 0x16290
leaq 0x7e15(%rip), %rsi # 0x2b390
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
callq 0x16160
xorl %eax, %eax
jmp 0x2361b
movq %rsi, %rbx
movq (%rdx), %rdi
movb 0x1(%rdi), %al
movsbl %al, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jb 0x235bd
cmpb $0x2e, %al
ja 0x23548
movzbl %al, %eax
movabsq $0x680000000000, %rcx # imm = 0x680000000000
btq %rax, %rcx
jae 0x23548
incq %rdi
xorl %esi, %esi
callq 0x16200
movsd 0x5e39(%rip), %xmm1 # 0x29408
movapd %xmm1, %xmm2
minsd %xmm0, %xmm2
movsd 0x5e09(%rip), %xmm0 # 0x293e8
maxsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd 0x6fb1(%rip), %xmm0 # 0x2a5a0
addsd 0x5e09(%rip), %xmm0 # 0x29400
cvttsd2si %xmm0, %esi
movl %esi, %ebp
shrl $0x7, %ebp
andl $0x7f, %esi
movq %rbx, %rdi
callq 0x162e0
andl $0x7f, %ebp
movq %rax, %rdi
movl %ebp, %esi
callq 0x162e0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/craigsapp[P]midifile/src/Binasc.cpp
|
smf::Binasc::processDecimalWord(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
|
int Binasc::processDecimalWord(std::ostream& out, const std::string& word,
int lineNum) {
int length = (int)word.size(); // length of ascii binary number
int byteCount = -1; // number of bytes to output
int quoteIndex = -1; // index of decimal specifier
int signIndex = -1; // index of any sign for number
int periodIndex = -1; // index of period for floating point
int endianIndex = -1; // index of little endian specifier
int i = 0;
// make sure that all characters are valid
for (i=0; i<length; i++) {
switch (word[i]) {
case '\'':
if (quoteIndex != -1) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "extra quote in decimal number" << std::endl;
return 0;
} else {
quoteIndex = i;
}
break;
case '-':
if (signIndex != -1) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "cannot have more than two minus signs in number"
<< std::endl;
return 0;
} else {
signIndex = i;
}
if (i == 0 || word[i-1] != '\'') {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "minus sign must immediately follow quote mark" << std::endl;
return 0;
}
break;
case '.':
if (quoteIndex == -1) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "cannot have decimal marker before quote" << std::endl;
return 0;
}
if (periodIndex != -1) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "extra period in decimal number" << std::endl;
return 0;
} else {
periodIndex = i;
}
break;
case 'u':
case 'U':
if (quoteIndex != -1) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "cannot have endian specified after quote" << std::endl;
return 0;
}
if (endianIndex != -1) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "extra \"u\" in decimal number" << std::endl;
return 0;
} else {
endianIndex = i;
}
break;
case '8':
case '1': case '2': case '3': case '4':
if (quoteIndex == -1 && byteCount != -1) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "invalid byte specificaton before quote in "
<< "decimal number" << std::endl;
return 0;
} else if (quoteIndex == -1) {
byteCount = word[i] - '0';
}
break;
case '0': case '5': case '6': case '7': case '9':
if (quoteIndex == -1) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "cannot have numbers before quote in decimal number"
<< std::endl;
return 0;
}
break;
default:
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "Invalid character in decimal number"
" (character number " << i <<")" << std::endl;
return 0;
}
}
// there must be a quote character to indicate a decimal number
// and there must be a decimal number after the quote
if (quoteIndex == -1) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "there must be a quote to signify a decimal number" << std::endl;
return 0;
} else if (quoteIndex == length - 1) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "there must be a decimal number after the quote" << std::endl;
return 0;
}
// 8 byte decimal output can only occur if reading a double number
if (periodIndex == -1 && byteCount == 8) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "only floating-point numbers can use 8 bytes" << std::endl;
return 0;
}
// default size for floating point numbers is 4 bytes
if (periodIndex != -1) {
if (byteCount == -1) {
byteCount = 4;
}
}
// process any floating point numbers possibilities
if (periodIndex != -1) {
double doubleOutput = atof(&word[quoteIndex+1]);
float floatOutput = (float)doubleOutput;
switch (byteCount) {
case 4:
if (endianIndex == -1) {
writeBigEndianFloat(out, floatOutput);
} else {
writeLittleEndianFloat(out, floatOutput);
}
return 1;
break;
case 8:
if (endianIndex == -1) {
writeBigEndianDouble(out, doubleOutput);
} else {
writeLittleEndianDouble(out, doubleOutput);
}
return 1;
break;
default:
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "floating-point numbers can be only 4 or 8 bytes" << std::endl;
return 0;
}
}
// process any integer decimal number possibilities
// default integer size is one byte, if size is not specified, then
// the number must be in the one byte range and cannot overflow
// the byte if the size of the decimal number is not specified
if (byteCount == -1) {
if (signIndex != -1) {
long tempLong = atoi(&word[quoteIndex + 1]);
if (tempLong > 127 || tempLong < -128) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "Decimal number out of range from -128 to 127" << std::endl;
return 0;
}
char charOutput = (char)tempLong;
out << charOutput;
return 1;
} else {
ulong tempLong = (ulong)atoi(&word[quoteIndex + 1]);
uchar ucharOutput = (uchar)tempLong;
if (tempLong > 255) { // || (tempLong < 0)) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "Decimal number out of range from 0 to 255" << std::endl;
return 0;
}
out << ucharOutput;
return 1;
}
}
// left with an integer number with a specified number of bytes
switch (byteCount) {
case 1:
if (signIndex != -1) {
long tempLong = atoi(&word[quoteIndex + 1]);
char charOutput = (char)tempLong;
out << charOutput;
return 1;
} else {
ulong tempLong = (ulong)atoi(&word[quoteIndex + 1]);
uchar ucharOutput = (uchar)tempLong;
out << ucharOutput;
return 1;
}
break;
case 2:
if (signIndex != -1) {
long tempLong = atoi(&word[quoteIndex + 1]);
short shortOutput = (short)tempLong;
if (endianIndex == -1) {
writeBigEndianShort(out, shortOutput);
} else {
writeLittleEndianShort(out, shortOutput);
}
return 1;
} else {
ulong tempLong = (ulong)atoi(&word[quoteIndex + 1]);
ushort ushortOutput = (ushort)tempLong;
if (endianIndex == -1) {
writeBigEndianUShort(out, ushortOutput);
} else {
writeLittleEndianUShort(out, ushortOutput);
}
return 1;
}
break;
case 3:
{
if (signIndex != -1) {
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "negative decimal numbers cannot be stored in 3 bytes"
<< std::endl;
return 0;
}
ulong tempLong = (ulong)atoi(&word[quoteIndex + 1]);
uchar byte1 = (uchar)((tempLong & 0x00ff0000) >> 16);
uchar byte2 = (uchar)((tempLong & 0x0000ff00) >> 8);
uchar byte3 = (uchar)((tempLong & 0x000000ff));
if (endianIndex == -1) {
out << byte1;
out << byte2;
out << byte3;
} else {
out << byte3;
out << byte2;
out << byte1;
}
return 1;
}
break;
case 4:
if (signIndex != -1) {
long tempLong = atoi(&word[quoteIndex + 1]);
if (endianIndex == -1) {
writeBigEndianLong(out, tempLong);
} else {
writeLittleEndianLong(out, tempLong);
}
return 1;
} else {
ulong tempuLong = (ulong)atoi(&word[quoteIndex + 1]);
if (endianIndex == -1) {
writeBigEndianULong(out, tempuLong);
} else {
writeLittleEndianULong(out, tempuLong);
}
return 1;
}
break;
default:
std::cerr << "Error on line " << lineNum << " at token: " << word
<< std::endl;
std::cerr << "invalid byte count specification for decimal number" << std::endl;
return 0;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, (%rsp)
movl 0x8(%rdx), %esi
xorl %r15d, %r15d
testl %esi, %esi
movl $0x0, %r8d
cmovgl %esi, %r8d
movq (%rdx), %rax
pushq $-0x1
popq %r9
leaq 0x719e(%rip), %r10 # 0x2a8e0
movl %r9d, %r12d
movl %r9d, %edi
movl %r9d, %r13d
movl %r9d, %edx
movl %r9d, %ecx
cmpq %r15, %r8
je 0x2381a
movzbl (%rax,%r15), %r11d
leal -0x27(%r11), %r14d
cmpl $0x12, %r14d
ja 0x237a0
movslq (%r10,%r14,4), %r14
addq %r10, %r14
jmpq *%r14
cmpl $-0x1, %edx
jne 0x23812
jmp 0x23922
cmpl $-0x1, %edx
jne 0x2378f
cmpl $-0x1, %ecx
jne 0x238c5
cmpl $-0x1, %edx
jne 0x23812
addl $-0x30, %r11d
movl %r9d, %edx
movl %r11d, %ecx
jmp 0x23812
cmpl $0x55, %r11d
je 0x237b0
cmpl $0x75, %r11d
jne 0x23b05
cmpl $-0x1, %edx
jne 0x23a1b
cmpl $-0x1, %r12d
jne 0x23a69
movl %r15d, %r12d
movl %r9d, %edx
jmp 0x23812
cmpl $-0x1, %edx
je 0x23bbe
cmpl $-0x1, %edi
jne 0x23c5a
movl %r15d, %edi
jmp 0x23812
cmpl $-0x1, %edx
jne 0x23c0c
movl %r15d, %edx
jmp 0x23812
cmpl $-0x1, %r13d
jne 0x23b70
testq %r15, %r15
je 0x23ab7
cmpb $0x27, -0x1(%rax,%r15)
jne 0x23ab7
movl %r15d, %r13d
incq %r15
jmp 0x23751
cmpl $-0x1, %edx
je 0x23877
decl %esi
cmpl %esi, %edx
jne 0x23970
movq 0x137c0(%rip), %r14 # 0x36ff0
leaq 0x75e8(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x75de(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7797(%rip), %rsi # 0x2b009
jmp 0x23f50
movq 0x13772(%rip), %r14 # 0x36ff0
leaq 0x759a(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x7590(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7717(%rip), %rsi # 0x2afd7
jmp 0x23f50
movq 0x13724(%rip), %r14 # 0x36ff0
leaq 0x754c(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x7542(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7634(%rip), %rsi # 0x2af42
movq %r14, %rdi
callq 0x16290
leaq 0x76dd(%rip), %rsi # 0x2affa
jmp 0x23b68
movq 0x136c7(%rip), %r14 # 0x36ff0
leaq 0x74ef(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x74e5(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7602(%rip), %rsi # 0x2af6d
jmp 0x23f50
cmpl $-0x1, %edi
jne 0x239c8
cmpl $0x8, %ecx
jne 0x239c8
movq 0x1366f(%rip), %r14 # 0x36ff0
leaq 0x7497(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x748d(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7675(%rip), %rsi # 0x2b038
jmp 0x23f50
cmpl $-0x1, %edi
je 0x23ca8
cmpl $-0x1, %ecx
pushq $0x4
popq %r15
cmovnel %ecx, %r15d
movslq %edx, %rcx
leaq (%rax,%rcx), %rdi
incq %rdi
callq 0x16340
cmpl $0x8, %r15d
je 0x23d35
cmpl $0x4, %r15d
jne 0x23d49
cvtsd2ss %xmm0, %xmm0
cmpl $-0x1, %r12d
je 0x23d97
movq (%rsp), %rdi
callq 0x2543e
jmp 0x23e4d
movq 0x135ce(%rip), %r14 # 0x36ff0
leaq 0x73f6(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x73ec(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7499(%rip), %rsi # 0x2aefd
jmp 0x23f50
movq 0x13580(%rip), %r14 # 0x36ff0
leaq 0x73a8(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x739e(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7474(%rip), %rsi # 0x2af26
jmp 0x23f50
movq 0x13532(%rip), %r14 # 0x36ff0
leaq 0x735a(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x7350(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7388(%rip), %rsi # 0x2ae88
jmp 0x23f50
movq 0x134e4(%rip), %r14 # 0x36ff0
leaq 0x730c(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x7302(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7452(%rip), %rsi # 0x2afa0
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %r15d, %esi
callq 0x16500
leaq 0x6573(%rip), %rsi # 0x2a0db
movq %rax, %rdi
jmp 0x23f53
movq 0x13479(%rip), %r14 # 0x36ff0
leaq 0x72a1(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x7297(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x729f(%rip), %rsi # 0x2ae58
jmp 0x23f50
movq 0x1342b(%rip), %r14 # 0x36ff0
leaq 0x7253(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x7249(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x72af(%rip), %rsi # 0x2aeb6
jmp 0x23f50
movq 0x133dd(%rip), %r14 # 0x36ff0
leaq 0x7205(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x71fb(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x71e5(%rip), %rsi # 0x2ae3a
jmp 0x23f50
movq 0x1338f(%rip), %r14 # 0x36ff0
leaq 0x71b7(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x71ad(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x723b(%rip), %rsi # 0x2aede
jmp 0x23f50
incl %ecx
cmpl $0x5, %ecx
ja 0x23db3
leaq 0x6c72(%rip), %rsi # 0x2a92c
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
movslq %edx, %rcx
leaq (%rax,%rcx), %rdi
incq %rdi
callq 0x16450
cmpl $-0x1, %r13d
je 0x23efc
movsbl %al, %ecx
cmpl %eax, %ecx
je 0x23e41
movq 0x13302(%rip), %r14 # 0x36ff0
leaq 0x712a(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x7120(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7364(%rip), %rsi # 0x2b094
jmp 0x23f50
cmpl $-0x1, %r12d
je 0x23da5
movq (%rsp), %rdi
callq 0x25520
jmp 0x23e4d
movq 0x132a0(%rip), %r14 # 0x36ff0
leaq 0x70c8(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x70be(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x72d2(%rip), %rsi # 0x2b064
jmp 0x23f50
movq (%rsp), %rdi
callq 0x253f4
jmp 0x23e4d
movq (%rsp), %rdi
callq 0x25488
jmp 0x23e4d
movq 0x13236(%rip), %r14 # 0x36ff0
leaq 0x705e(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x7054(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7324(%rip), %rsi # 0x2b120
jmp 0x23f50
movslq %edx, %rcx
leaq (%rax,%rcx), %rdi
incq %rdi
callq 0x16450
cmpl $-0x1, %r13d
je 0x23ee1
movswl %ax, %esi
cmpl $-0x1, %r12d
je 0x23fcf
movq (%rsp), %rdi
callq 0x255de
jmp 0x23e4d
movslq %edx, %rcx
leaq (%rax,%rcx), %rdi
incq %rdi
callq 0x16450
movsbl %al, %esi
movq (%rsp), %rdi
callq 0x162e0
pushq $0x1
popq %rax
jmp 0x23f62
cmpl $-0x1, %r13d
je 0x23f71
movq 0x1318a(%rip), %r14 # 0x36ff0
leaq 0x6fb2(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x6fa8(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7243(%rip), %rsi # 0x2b0eb
jmp 0x23f50
movslq %edx, %rcx
leaq (%rax,%rcx), %rdi
incq %rdi
callq 0x16450
movslq %eax, %rsi
cmpl $-0x1, %r13d
je 0x23fbb
cmpl $-0x1, %r12d
je 0x23fdd
movq (%rsp), %rdi
callq 0x256b2
jmp 0x23e4d
movzwl %ax, %esi
cmpl $-0x1, %r12d
je 0x23feb
movq (%rsp), %rdi
callq 0x25634
jmp 0x23e4d
cmpl $0x100, %eax # imm = 0x100
jb 0x23e41
movq 0x130e2(%rip), %r14 # 0x36ff0
leaq 0x6f0a(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x6f00(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x7171(%rip), %rsi # 0x2b0c1
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
callq 0x16160
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %edx, %rcx
leaq (%rax,%rcx), %rdi
incq %rdi
callq 0x16450
movl %eax, %ebx
movl %eax, %ebp
shrl $0x10, %ebp
movl %eax, %r15d
shrl $0x8, %r15d
cmpl $-0x1, %r12d
je 0x23ff9
movsbl %bl, %esi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x162e0
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x162e0
movsbl %bpl, %esi
movq %rbx, %rdi
jmp 0x23e48
cmpl $-0x1, %r12d
je 0x24020
movq (%rsp), %rdi
callq 0x2575e
jmp 0x23e4d
movq (%rsp), %rdi
callq 0x255b6
jmp 0x23e4d
movq (%rsp), %rdi
callq 0x2565e
jmp 0x23e4d
movq (%rsp), %rdi
callq 0x25608
jmp 0x23e4d
movsbl %bpl, %esi
movq (%rsp), %r14
movq %r14, %rdi
callq 0x162e0
movsbl %r15b, %esi
movq %r14, %rdi
callq 0x162e0
movsbl %bl, %esi
movq %r14, %rdi
jmp 0x23e48
movq (%rsp), %rdi
callq 0x2570a
jmp 0x23e4d
|
/craigsapp[P]midifile/src/Binasc.cpp
|
smf::Binasc::processHexWord(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
|
int Binasc::processHexWord(std::ostream& out, const std::string& word,
int lineNum) {
int length = (int)word.size();
uchar outputByte;
if (length > 2) {
std::cerr << "Error on line " << lineNum << " at token: " << word << std::endl;
std::cerr << "Size of hexadecimal number is too large. Max is ff." << std::endl;
return 0;
}
if (!isxdigit(word[0]) || (length == 2 && !isxdigit(word[1]))) {
std::cerr << "Error on line " << lineNum << " at token: " << word << std::endl;
std::cerr << "Invalid character in hexadecimal number." << std::endl;
return 0;
}
outputByte = (uchar)strtol(word.c_str(), (char**)NULL, 16);
out << outputByte;
return 1;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movl 0x8(%rdx), %r12d
cmpl $0x3, %r12d
jl 0x24405
movq 0x12c32(%rip), %r14 # 0x36ff0
leaq 0x6a5a(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x6a50(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x6d54(%rip), %rsi # 0x2b154
jmp 0x24492
movq %rsi, %r14
movq (%rbx), %r15
movsbl (%r15), %edi
callq 0x160c0
testl %eax, %eax
je 0x24449
cmpl $0x2, %r12d
jne 0x2442c
movsbl 0x1(%r15), %edi
callq 0x160c0
testl %eax, %eax
je 0x24449
pushq $0x10
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x163e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x162e0
pushq $0x1
popq %rax
jmp 0x244a4
movq 0x12ba0(%rip), %r14 # 0x36ff0
leaq 0x69c8(%rip), %rsi # 0x2ae1f
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x69be(%rip), %rsi # 0x2ae2e
movq %rax, %rdi
callq 0x16290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16250
movq %rax, %rdi
callq 0x16160
leaq 0x6cf7(%rip), %rsi # 0x2b189
movq %r14, %rdi
callq 0x16290
movq %rax, %rdi
callq 0x16160
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/craigsapp[P]midifile/src/Binasc.cpp
|
smf::Binasc::keyToPitchName[abi:cxx11](int)
|
std::string Binasc::keyToPitchName(int key) {
int pc = key % 12;
int octave = key / 12 - 1;
std::stringstream output;
switch (pc) {
case 0: output << "C"; break;
case 1: output << "C#"; break;
case 2: output << "D"; break;
case 3: output << "D#"; break;
case 4: output << "E"; break;
case 5: output << "F"; break;
case 6: output << "F#"; break;
case 7: output << "G"; break;
case 8: output << "G#"; break;
case 9: output << "A"; break;
case 10: output << "A#"; break;
case 11: output << "B"; break;
}
output << octave;
return output.str().c_str();
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movl %esi, %eax
movq %rdi, %rbx
pushq $0xc
popq %rcx
cltd
idivl %ecx
movl %edx, %r14d
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x161e0
cmpl $0xc, %r14d
jae 0x2537c
movl %r14d, %eax
leaq 0x5675(%rip), %rcx # 0x2a9e0
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x38(%rsp), %rdi
callq 0x16290
decl %ebp
leaq 0x38(%rsp), %rdi
movl %ebp, %esi
callq 0x16500
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x16480
movq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x16140
leaq 0x8(%rsp), %rdi
callq 0x165f0
leaq 0x28(%rsp), %rdi
callq 0x161f0
movq %rbx, %rax
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x165f0
jmp 0x253e2
jmp 0x253df
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x161f0
movq %rbx, %rdi
callq 0x16520
|
/craigsapp[P]midifile/src/Binasc.cpp
|
smf::Binasc::writeBigEndianULong(std::ostream&, unsigned long)
|
std::ostream& Binasc::writeBigEndianULong(std::ostream& out, ulong value) {
union { char bytes[4]; long ul; } data;
data.ul = value;
out << data.bytes[3];
out << data.bytes[2];
out << data.bytes[1];
out << data.bytes[0];
return out;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl %r14d, %ebp
shrl $0x8, %ebp
movl %r14d, %r15d
shrl $0x10, %r15d
sarl $0x18, %esi
callq 0x162e0
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x162e0
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x162e0
movsbl %r14b, %esi
movq %rbx, %rdi
callq 0x162e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/craigsapp[P]midifile/src/Binasc.cpp
|
smf::MidiEvent::linkEvent(smf::MidiEvent*)
|
void MidiEvent::linkEvent(MidiEvent* mev) {
if (mev->m_eventlink != NULL) {
// unlink other event if it is linked to something else;
mev->unlinkEvent();
}
// if this is already linked to something else, then unlink:
if (m_eventlink != NULL) {
m_eventlink->unlinkEvent();
}
unlinkEvent();
mev->m_eventlink = this;
m_eventlink = mev;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x30(%rsi)
je 0x25ab9
movq %rbx, %rdi
callq 0x25a8c
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x25ac7
callq 0x25a8c
movq %r14, %rdi
callq 0x25a8c
movq %r14, 0x30(%rbx)
movq %rbx, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/craigsapp[P]midifile/src/MidiEvent.cpp
|
njoy::ENDFtk::section::DerivedRedundant::DerivedRedundant(double, double, std::vector<double, std::allocator<double>>&&, std::vector<int, std::allocator<int>>&&)
|
DerivedRedundant( double e1, double e2,
std::vector< double >&& coefficients,
std::vector< int >&& reactions )
try :
list_(
ListRecord( e1, e2, 0, 0, coefficients.size(),
generateList( std::move( coefficients ),
std::move( reactions ) ) ) ) {
} catch ( std::exception& e ) {
Log::info( "Encountered error while constructing DerivedRedundant component" );
throw;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r14
leaq 0x18(%rsp), %rdi
callq 0x1d6d8
subq %r15, %r14
sarq $0x3, %r14
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movq %r14, (%rbx)
movq %rdx, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x1cf20
movq %rbx, %rdi
callq 0x17210
leaq 0x7cebe(%rip), %rdi # 0x99dcc
callq 0x1d84a
callq 0x17930
movq %rax, %rbx
callq 0x17a50
movq %rbx, %rdi
callq 0x17b50
movq %rax, %rdi
callq 0x1cdbb
|
/njoy[P]ENDFtk/src/ENDFtk/section/DerivedRedundant/src/ctor.hpp
|
njoy::ENDFtk::section::Type<31>::Type<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(njoy::ENDFtk::HeadRecord&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, long&, int)
|
Type( HEAD& head,
Iterator& begin,
const Iterator& end,
long& lineNumber,
int MAT )
try:
Base( head, MAT, 31 ),
reactions_(
readSequence< ReactionBlock >( begin, end, lineNumber,
MAT, 31, head.MT(), head.N2() ) ) {
readSEND(begin, end, lineNumber, MAT, 31 );
} catch( std::exception& e ) {
Log::info( "Trouble while reading section {} of File 31 of Material {}",
head.MT(), MAT );
throw e;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r15
movl %r9d, %edx
movl $0x1f, %ecx
callq 0x30db4
addq $0x18, %r15
movl (%r14), %eax
movl 0x38(%r14), %r10d
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movl %ebx, %r8d
movl $0x1f, %r9d
pushq %rax
pushq %r10
callq 0x30e82
addq $0x10, %rsp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebx, %ecx
movl $0x1f, %r8d
callq 0x30f1a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r13
movq %rax, %r12
movq %r15, %rdi
callq 0x1d1b4
jmp 0x1d3b5
movq %rdx, %r13
movq %rax, %r12
cmpl $0x1, %r13d
jne 0x1d40b
movq %r12, %rdi
callq 0x17210
movl 0x38(%r14), %esi
leaq 0x7d51c(%rip), %rdi # 0x9a8ea
movl %ebx, %edx
callq 0x31104
movl $0x8, %edi
callq 0x172c0
movq 0xc0b52(%rip), %rcx # 0xddf38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xc0bc4(%rip), %rsi # 0xddfb8
movq 0xc0be5(%rip), %rdx # 0xddfe0
movq %rax, %rdi
callq 0x17af0
movq %rax, %r12
callq 0x17a50
movq %r12, %rdi
callq 0x17b50
movq %rax, %rdi
callq 0x1cdbb
nop
|
/njoy[P]ENDFtk/src/ENDFtk/section/31/src/ctor.hpp
|
njoy::ENDFtk::tree::Section::Section<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(njoy::ENDFtk::HeadRecord const&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, long&)
|
Section( const HEAD& head, BufferIterator begin,
BufferIterator& position, const BufferIterator& end,
long& lineNumber )
try: Section( head.MAT(), head.MF(), head.MT(),
std::string( begin, findEnd( position, end, lineNumber ) ) ) {}
catch( std::exception& e ) {
Log::info( "Trouble encountered while constructing an ENDF tree section" );
Log::info( "Current position: MAT{} MF{} MT{} at line {}",
head.MAT(), head.MF(), head.MT(), lineNumber );
throw e;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movsd 0x30(%rsi), %xmm0
movaps %xmm0, 0x20(%rsp)
movl 0x38(%rsi), %ebp
movq %rcx, %rdi
movq %r8, %rsi
movq %r9, %rdx
callq 0x34418
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsp, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x30720
movaps 0x20(%rsp), %xmm0
movlps %xmm0, (%r15)
movl %ebp, 0x8(%r15)
leaq 0x20(%r15), %rax
movq %rax, 0x10(%r15)
movq (%rsp), %rcx
cmpq %r13, %rcx
je 0x1d495
movq %rcx, 0x10(%r15)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%r15)
jmp 0x1d49d
movups (%r13), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%r15)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d4b7
movq %rax, %r15
cmpl $0x1, %edx
jne 0x1d524
movq %r15, %rdi
callq 0x17210
leaq 0x7d997(%rip), %rdi # 0x9ae65
callq 0x1d84a
movl 0x30(%r14), %esi
movl 0x34(%r14), %edx
movl 0x38(%r14), %ecx
movq (%rbx), %r8
leaq 0x7d9b8(%rip), %rdi # 0x9aea1
callq 0x34480
movl $0x8, %edi
callq 0x172c0
movq 0xc0a39(%rip), %rcx # 0xddf38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xc0aab(%rip), %rsi # 0xddfb8
movq 0xc0acc(%rip), %rdx # 0xddfe0
movq %rax, %rdi
callq 0x17af0
movq %rax, %r15
callq 0x17a50
movq %r15, %rdi
callq 0x17b50
movq %rax, %rdi
callq 0x1cdbb
|
/njoy[P]ENDFtk/src/ENDFtk/tree/Section/src/ctor.hpp
|
fmt::v9::appender fmt::v9::detail::default_arg_formatter<char>::operator()<void const*>(void const*)
|
auto operator()(T value) -> iterator {
return write<Char>(out, value);
}
|
subq $0x18, %rsp
movq (%rdi), %rdi
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movb $0x0, 0x8(%rdx)
movw $0x0, 0x9(%rdx)
movl $0x20, 0xb(%rdx)
movb $0x1, 0xf(%rdx)
xorl %ecx, %ecx
callq 0x24ce1
addq $0x18, %rsp
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
void fmt::v9::detail::buffer<char>::append<char>(char const*, char const*)
|
void buffer<T>::append(const U* begin, const U* end) {
while (begin != end) {
auto count = to_unsigned(end - begin);
try_reserve(size_ + count);
auto free_cap = capacity_ - size_;
if (free_cap < count) count = free_cap;
std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count));
size_ += count;
begin += count;
}
}
|
cmpq %rdx, %rsi
je 0x1e568
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movq %rbx, %r13
subq %r14, %r13
leaq (%rdi,%r13), %rsi
movq 0x18(%r15), %r12
cmpq %rsi, %r12
jae 0x1e52e
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq 0x10(%r15), %rdi
movq 0x18(%r15), %r12
subq %rdi, %r12
cmpq %r13, %r12
cmovaeq %r13, %r12
testq %r12, %r12
je 0x1e550
addq 0x8(%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x17a40
movq 0x10(%r15), %rdi
addq %r12, %rdi
movq %rdi, 0x10(%r15)
addq %r12, %r14
cmpq %rbx, %r14
jne 0x1e50b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, unsigned __int128, 0>(fmt::v9::appender, unsigned __int128)
|
FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(abs_value);
auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
auto it = reserve(out, size);
if (auto ptr = to_pointer<Char>(it, size)) {
if (negative) *ptr++ = static_cast<Char>('-');
format_decimal<Char>(ptr, abs_value, num_digits);
return out;
}
if (negative) *it++ = static_cast<Char>('-');
it = format_decimal<Char>(it, abs_value, num_digits).end;
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1e966
movslq %eax, %rdx
movq 0x10(%rbx), %rcx
addq %rcx, %rdx
cmpq %rdx, 0x18(%rbx)
jb 0x1ea5c
movq %rdx, 0x10(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1ea5c
addq %rcx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %eax, %ecx
callq 0x1e899
jmp 0x1ea80
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %eax, %ecx
callq 0x1e899
movq %r12, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x1e4d8
movq %rax, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
bool fmt::v9::detail::write_int_localized<fmt::v9::appender, unsigned long, char>(fmt::v9::appender&, unsigned long, unsigned int, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref)
|
auto write_int_localized(OutputIt& out, UInt value, unsigned prefix,
const basic_format_specs<Char>& specs, locale_ref loc)
-> bool {
auto grouping = digit_grouping<Char>(loc);
out = write_int_localized(out, value, prefix, specs, grouping);
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r8, %rsi
movl $0x1, %edx
callq 0x1f258
movq (%rbx), %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %r12, %r8
callq 0x1f346
movq %rax, (%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f222
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17610
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f24f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b50
nop
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::fill<fmt::v9::appender, char>(fmt::v9::appender, unsigned long, fmt::v9::detail::fill_t<char> const&)
|
FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n,
const fill_t<Char>& fill) -> OutputIt {
auto fill_size = fill.size();
if (fill_size == 1) return detail::fill_n(it, n, fill[0]);
auto data = fill.data();
for (size_t i = 0; i < n; ++i)
it = copy_str<Char>(data, data + fill_size, it);
return it;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzbl 0x4(%rdx), %r12d
cmpq $0x1, %r12
jne 0x1f5c6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f5f0
testq %r14, %r14
je 0x1f5e1
addq %rbx, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1e4f0
decq %r14
jne 0x1f5ce
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::fill_n<fmt::v9::appender, unsigned long, char>(fmt::v9::appender, unsigned long, char const&)
|
FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)
-> OutputIt {
for (Size i = 0; i < count; ++i) *out++ = value;
return out;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x1f633
movq %rdx, %rbx
movq %rsi, %r15
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%r14)
jae 0x1f621
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rsi
movb (%rbx), %cl
movq 0x8(%r14), %rdx
movq %rsi, 0x10(%r14)
movb %cl, (%rdx,%rax)
decq %r15
jne 0x1f603
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned int>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned int>, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref)::'lambda0'(fmt::v9::appender)>(char, int, unsigned int, fmt::v9::basic_format_specs<fmt::v9::appender> const&, unsigned int)::'lambda'(fmt::v9::appender)&>(fmt::v9::appender, fmt::v9::basic_format_specs<unsigned int> const&, unsigned long, unsigned long, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned int>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned int>, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref)::'lambda0'(fmt::v9::appender)>(char, int, unsigned int, fmt::v9::basic_format_specs<fmt::v9::appender> const&, unsigned int)::'lambda'(fmt::v9::appender)&)
|
FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
// Shifts are encoded as string literals because static constexpr is not
// supported in constexpr functions.
auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
size_t left_padding = padding >> shifts[specs.align];
size_t right_padding = padding - left_padding;
auto it = reserve(out, size + padding * specs.fill.size());
if (left_padding != 0) it = fill(it, left_padding, specs.fill);
it = f(it);
if (right_padding != 0) it = fill(it, right_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x7b5b8(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %r13
addq $0xb, %rbx
testq %r15, %r15
je 0x1fa11
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f591
movq %rax, %r13
movl $0xffffff, %ebp # imm = 0xFFFFFF
andl (%r12), %ebp
je 0x1fa56
movq 0x10(%r13), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%r13)
jae 0x1fa3b
movq (%r13), %rax
movq %r13, %rdi
callq *(%rax)
movq 0x10(%r13), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%r13), %rcx
movq %rsi, 0x10(%r13)
movb %bpl, (%rcx,%rax)
movl %ebp, %eax
shrl $0x8, %eax
cmpl $0x100, %ebp # imm = 0x100
movl %eax, %ebp
jae 0x1fa1c
movq 0x10(%r12), %rsi
leaq 0xe(%rsp), %rdx
movb $0x30, (%rdx)
movq %r13, %rdi
callq 0x1f5f0
movl 0x18(%r12), %ecx
movl 0x1c(%r12), %esi
movslq %esi, %rdx
movb 0x20(%r12), %r8b
movq 0x10(%rax), %rdi
addq %rdi, %rsi
cmpq %rsi, 0x18(%rax)
jb 0x1fad5
movq %rsi, 0x10(%rax)
movq 0x8(%rax), %r9
testq %r9, %r9
je 0x1fad5
leaq 0x7a537(%rip), %r10 # 0x99fd5
leaq 0x7a541(%rip), %rsi # 0x99fe6
testb %r8b, %r8b
cmovneq %r10, %rsi
addq %rdx, %rdi
leaq (%r9,%rdi), %rdx
decq %rdx
movl %ecx, %edi
movl %ecx, %r8d
andl $0xf, %r8d
movb (%rsi,%r8), %r8b
movb %r8b, (%rdx)
shrl $0x4, %edi
decq %rdx
cmpl $0x10, %ecx
movl %edi, %ecx
jae 0x1fab8
jmp 0x1fb26
leaq (%rsp,%rdx), %rsi
addq $0xf, %rsi
leaq 0x7a4f1(%rip), %r9 # 0x99fd5
leaq 0x7a4fb(%rip), %rdi # 0x99fe6
testb %r8b, %r8b
cmovneq %r9, %rdi
addq %rsp, %rdx
addq $0xe, %rdx
movl %ecx, %r8d
movl %ecx, %r9d
andl $0xf, %r9d
movb (%rdi,%r9), %r9b
movb %r9b, (%rdx)
shrl $0x4, %r8d
decq %rdx
cmpl $0xf, %ecx
movl %r8d, %ecx
ja 0x1fafc
leaq 0xf(%rsp), %rdi
movq %rax, %rdx
callq 0x1e4d8
cmpq %r15, %r14
je 0x1fb3c
subq %r15, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1f591
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
char fmt::v9::detail::write_padded<(fmt::v9::align::type)1, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_bytes<(fmt::v9::align::type)1, char, fmt::v9::appender>(fmt::v9::appender, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_specs<char> const&)::'lambda'(fmt::v9::appender)&>(char, fmt::v9::basic_format_specs<fmt::v9::appender> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::write_bytes<(fmt::v9::align::type)1, char, fmt::v9::appender>(fmt::v9::appender, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_specs<char> const&)::'lambda'(fmt::v9::appender)&)
|
FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
// Shifts are encoded as string literals because static constexpr is not
// supported in constexpr functions.
auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
size_t left_padding = padding >> shifts[specs.align];
size_t right_padding = padding - left_padding;
auto it = reserve(out, size + padding * specs.fill.size());
if (left_padding != 0) it = fill(it, left_padding, specs.fill);
it = f(it);
if (right_padding != 0) it = fill(it, right_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x7ac04(%rip), %rcx # 0x9afa5
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r13
movq %rdi, %r12
addq $0xb, %rbx
testq %r15, %r15
je 0x203ca
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f591
movq %rax, %r12
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x1e4f0
cmpq %r15, %r14
jne 0x203ef
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
subq %r15, %r14
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1f591
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, float, 0>(fmt::v9::appender, float)
|
FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
if (is_constant_evaluated())
return write(out, value, basic_format_specs<Char>());
if (const_check(!is_supported_floating_point(value))) return out;
auto fspecs = float_specs();
if (detail::signbit(value)) {
fspecs.sign = sign::minus;
value = -value;
}
constexpr auto specs = basic_format_specs<Char>();
using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
using uint = typename dragonbox::float_info<floaty>::carrier_uint;
uint mask = exponent_mask<floaty>();
if ((bit_cast<uint>(value) & mask) == mask)
return write_nonfinite(out, std::isnan(value), specs, fspecs);
auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
return write_float(out, dec, specs, fspecs, {});
}
|
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movd %xmm0, %eax
testl %eax, %eax
jns 0x20432
movl $0x100, 0xc(%rsp) # imm = 0x100
pxor 0x78c5e(%rip), %xmm0 # 0x99090
movups 0x78d27(%rip), %xmm1 # 0x99160
movaps %xmm1, 0x10(%rsp)
movd %xmm0, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpl $0x7f800000, %eax # imm = 0x7F800000
jl 0x2047a
xorl %esi, %esi
ucomiss %xmm0, %xmm0
setp %sil
movabsq $-0x100000000, %rdx # imm = 0xFFFFFFFF00000000
movabsq $0x100000020000000, %rcx # imm = 0x100000020000000
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
callq 0x204a2
jmp 0x2049c
callq 0x4c60f
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x2060c
addq $0x30, %rsp
popq %rbx
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::write_nonfinite<char, fmt::v9::appender>(fmt::v9::appender, bool, fmt::v9::basic_format_specs<char>, fmt::v9::detail::float_specs const&)
|
FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan,
basic_format_specs<Char> specs,
const float_specs& fspecs) -> OutputIt {
auto str =
isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf");
constexpr size_t str_size = 3;
auto sign = fspecs.sign;
auto size = str_size + (sign ? 1 : 0);
// Replace '0'-padding with space for non-finite values.
const bool is_zero_fill =
specs.fill.size() == 1 && *specs.fill.data() == static_cast<Char>('0');
if (is_zero_fill) specs.fill[0] = static_cast<Char>(' ');
return write_padded(out, specs, size, [=](reserve_iterator<OutputIt> it) {
if (sign) *it++ = detail::sign<Char>(sign);
return copy_str<Char>(str, str + str_size, it);
});
}
|
subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movl 0x4(%r8), %eax
movabsq $-0xffffff01000000, %rdx # imm = 0xFF000000FF000000
andq %rcx, %rdx
movabsq $0x100000030000000, %rcx # imm = 0x100000030000000
cmpq %rcx, %rdx
jne 0x204d5
movb $0x20, 0x13(%rsp)
btl $0x10, %eax
leaq 0x79b1b(%rip), %rcx # 0x99ffb
leaq 0x79b10(%rip), %rdx # 0x99ff7
cmovaeq %rcx, %rdx
leaq 0x79b11(%rip), %rcx # 0x9a003
leaq 0x79b06(%rip), %r9 # 0x99fff
cmovaeq %rcx, %r9
testb %sil, %sil
cmovneq %rdx, %r9
shrl $0x8, %eax
cmpb $0x1, %al
movl $0x4, %ecx
sbbq $0x0, %rcx
leaq 0x18(%rsp), %r8
movb %al, (%r8)
movq %r9, 0x8(%r8)
leaq 0x8(%rsp), %rsi
movq %rcx, %rdx
callq 0x20530
addq $0x28, %rsp
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)
|
FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
const basic_format_specs<Char>& specs,
float_specs fspecs, locale_ref loc)
-> OutputIt {
auto significand = f.significand;
int significand_size = get_significand_size(f);
const Char zero = static_cast<Char>('0');
auto sign = fspecs.sign;
size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
using iterator = reserve_iterator<OutputIt>;
Char decimal_point =
fspecs.locale ? detail::decimal_point<Char>(loc) : static_cast<Char>('.');
int output_exp = f.exponent + significand_size - 1;
auto use_exp_format = [=]() {
if (fspecs.format == float_format::exp) return true;
if (fspecs.format != float_format::general) return false;
// Use the fixed notation if the exponent is in [exp_lower, exp_upper),
// e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
const int exp_lower = -4, exp_upper = 16;
return output_exp < exp_lower ||
output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper);
};
if (use_exp_format()) {
int num_zeros = 0;
if (fspecs.showpoint) {
num_zeros = fspecs.precision - significand_size;
if (num_zeros < 0) num_zeros = 0;
size += to_unsigned(num_zeros);
} else if (significand_size == 1) {
decimal_point = Char();
}
auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
int exp_digits = 2;
if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;
size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
char exp_char = fspecs.upper ? 'E' : 'e';
auto write = [=](iterator it) {
if (sign) *it++ = detail::sign<Char>(sign);
// Insert a decimal point after the first digit and add an exponent.
it = write_significand(it, significand, significand_size, 1,
decimal_point);
if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero);
*it++ = static_cast<Char>(exp_char);
return write_exponent<Char>(output_exp, it);
};
return specs.width > 0 ? write_padded<align::right>(out, specs, size, write)
: base_iterator(out, write(reserve(out, size)));
}
int exp = f.exponent + significand_size;
if (f.exponent >= 0) {
// 1234e5 -> 123400000[.0+]
size += to_unsigned(f.exponent);
int num_zeros = fspecs.precision - exp;
abort_fuzzing_if(num_zeros > 5000);
if (fspecs.showpoint) {
++size;
if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 1;
if (num_zeros > 0) size += to_unsigned(num_zeros);
}
auto grouping = Grouping(loc, fspecs.locale);
size += to_unsigned(grouping.count_separators(exp));
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = detail::sign<Char>(sign);
it = write_significand<Char>(it, significand, significand_size,
f.exponent, grouping);
if (!fspecs.showpoint) return it;
*it++ = decimal_point;
return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
});
} else if (exp > 0) {
// 1234e-2 -> 12.34[0+]
int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0;
size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
auto grouping = Grouping(loc, fspecs.locale);
size += to_unsigned(grouping.count_separators(significand_size));
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = detail::sign<Char>(sign);
it = write_significand(it, significand, significand_size, exp,
decimal_point, grouping);
return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
});
}
// 1234e-6 -> 0.001234
int num_zeros = -exp;
if (significand_size == 0 && fspecs.precision >= 0 &&
fspecs.precision < num_zeros) {
num_zeros = fspecs.precision;
}
bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint;
size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros);
return write_padded<align::right>(out, specs, size, [&](iterator it) {
if (sign) *it++ = detail::sign<Char>(sign);
*it++ = zero;
if (!pointy) return it;
*it++ = decimal_point;
it = detail::fill_n(it, num_zeros, zero);
return write_significand<Char>(it, significand, significand_size);
});
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r14
movq %rdi, %r9
movq %rcx, 0x68(%rsp)
movl (%rsi), %r11d
movl %r11d, 0xc(%rsp)
movl %r11d, %eax
orl $0x1, %eax
bsrl %eax, %eax
leaq 0x7ab20(%rip), %rcx # 0x9b160
movq %r11, %r15
addq (%rcx,%rax,8), %r15
shrq $0x20, %r15
movl %r15d, 0x8(%rsp)
movb $0x30, 0x3(%rsp)
movq %r14, %r13
shrq $0x20, %r13
movq %r14, %r12
shrq $0x28, %r12
movb %r12b, 0x2(%rsp)
cmpb $0x1, %r12b
movl %r15d, %ecx
sbbl $-0x1, %ecx
btl $0x11, %r13d
movb $0x2e, %al
jae 0x206bd
movq %r8, %rdi
movq %rdx, 0x58(%rsp)
movq %r9, %rbp
movq %r14, 0x60(%rsp)
movq %rcx, 0x48(%rsp)
movq %rsi, %rbx
movq %r8, 0x50(%rsp)
movq %r11, %r14
callq 0x4cdd8
movq %r14, %r11
movq 0x50(%rsp), %r8
movq %rbx, %rsi
movq 0x48(%rsp), %rcx
movq 0x60(%rsp), %r14
movq %rbp, %r9
movq 0x58(%rsp), %rdx
movb %al, 0x1(%rsp)
movl 0x4(%rsi), %edi
leal (%rdi,%r15), %ebx
cmpb $0x1, %r13b
je 0x20723
movzbl %r13b, %r10d
testl %r10d, %r10d
jne 0x206ee
testl %r14d, %r14d
movl $0x10, %r10d
cmovgl %r14d, %r10d
cmpl $-0x3, %ebx
jl 0x20723
cmpl %r10d, %ebx
jg 0x20723
movl %ebx, 0x1c(%rsp)
testl %edi, %edi
js 0x20801
addq %rdi, %rcx
subl %ebx, %r14d
movl %r14d, 0x4(%rsp)
btl $0x13, %r13d
movq %r9, 0x10(%rsp)
jb 0x2089f
movq %rsi, %rbp
movq %rcx, %r14
movq %rdx, %r15
jmp 0x208dc
leal (%rdi,%r15), %r8d
decl %r8d
btl $0x13, %r13d
jb 0x20744
xorl %edi, %edi
cmpl $0x1, %r15d
jne 0x20753
movb $0x0, 0x1(%rsp)
xorl %eax, %eax
xorl %edi, %edi
jmp 0x20753
subl %r15d, %r14d
xorl %edi, %edi
testl %r14d, %r14d
cmovgl %r14d, %edi
addq %rdi, %rcx
btl $0x10, %r13d
setae %sil
shlb $0x5, %sil
orb $0x45, %sil
movb %r12b, 0x70(%rsp)
movl %r11d, 0x74(%rsp)
movl %r15d, 0x78(%rsp)
movb %al, 0x7c(%rsp)
movl %edi, 0x80(%rsp)
movb $0x30, 0x84(%rsp)
movb %sil, 0x85(%rsp)
movl %r8d, 0x88(%rsp)
cmpl $0x0, (%rdx)
jle 0x207ef
cmpb $0x1, %al
movl $0x3, %eax
sbbq $0x0, %rax
movl $0x1, %esi
subl %ebx, %esi
testl %ebx, %ebx
cmovlel %esi, %r8d
xorl %esi, %esi
cmpl $0x3e8, %r8d # imm = 0x3E8
setge %sil
addq $0x3, %rsi
cmpl $0x64, %r8d
movl $0x2, %edi
cmovgeq %rsi, %rdi
addq %rax, %rcx
addq %rdi, %rcx
leaq 0x70(%rsp), %r8
movq %r9, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x20cd9
jmp 0x20aea
leaq 0x70(%rsp), %rdi
movq %r9, %rsi
callq 0x20b2a
jmp 0x20aea
testl %ebx, %ebx
jle 0x209ae
movq %rcx, %rbp
movq %r9, 0x10(%rsp)
movq %rdx, %r12
movl %r13d, %eax
shll $0xc, %eax
sarl $0x1f, %eax
subl %r15d, %r14d
xorl %ebx, %ebx
andl %eax, %r14d
movl %r14d, 0x4(%rsp)
cmovlel %ebx, %r14d
shrl $0x11, %r13d
andl $0x1, %r13d
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r8, %rsi
movl %r13d, %edx
callq 0x1f258
cmpb $0x0, 0x20(%r15)
je 0x209ea
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %r9
movq 0x28(%rsp), %rdx
addq %r9, %rdx
xorl %eax, %eax
movq %r12, %rsi
cmpq %rdx, %r9
je 0x20885
movb (%r9), %dil
leal -0x7f(%rdi), %r8d
cmpb $-0x7e, %r8b
jb 0x209ef
incq %r9
jmp 0x2088c
movb -0x1(%rdx), %dil
movq %rdx, %r9
movsbl %dil, %edi
addl %edi, %ebx
cmpl %ecx, %ebx
jge 0x209ef
incq %rax
jmp 0x2086a
incq %rcx
testl %r14d, %r14d
setg %al
cmpb $0x2, %r13b
sete %dil
orb %al, %dil
je 0x208bf
testl %r14d, %r14d
jg 0x208cd
jmp 0x20715
movl $0x1, 0x4(%rsp)
movl $0x1, %r14d
movq %rsi, %rbp
movq %rdx, %r15
movl %r14d, %eax
addq %rax, %rcx
movq %rcx, %r14
shrl $0x11, %r13d
andl $0x1, %r13d
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r8, %rsi
movl %r13d, %edx
callq 0x1f258
xorl %r10d, %r10d
cmpb $0x0, 0x20(%r12)
je 0x20946
movq 0x20(%rsp), %r9
movq 0x28(%rsp), %rdx
addq %r9, %rdx
xorl %eax, %eax
movq %r15, %rsi
movq %r14, %rcx
cmpq %rdx, %r9
je 0x2092e
movb (%r9), %dil
leal -0x7f(%rdi), %r8d
cmpb $-0x7e, %r8b
jb 0x2094e
incq %r9
jmp 0x20935
movb -0x1(%rdx), %dil
movq %rdx, %r9
movsbl %dil, %edi
addl %edi, %r10d
cmpl %ebx, %r10d
jge 0x2094e
incq %rax
jmp 0x20917
xorl %eax, %eax
movq %r15, %rsi
movq %r14, %rcx
addq %rax, %rcx
leaq 0x2(%rsp), %rax
leaq 0x70(%rsp), %r8
movq %rax, (%r8)
leaq 0xc(%rsp), %rax
movq %rax, 0x8(%r8)
leaq 0x8(%rsp), %rax
movq %rax, 0x10(%r8)
movq %rbp, 0x18(%r8)
movq %r12, 0x20(%r8)
leaq 0x68(%rsp), %rax
movq %rax, 0x28(%r8)
leaq 0x1(%rsp), %rax
movq %rax, 0x30(%r8)
leaq 0x4(%rsp), %rax
movq %rax, 0x38(%r8)
leaq 0x3(%rsp), %rax
movq %rax, 0x40(%r8)
movq 0x10(%rsp), %rdi
movq %rcx, %rdx
callq 0x20f0d
jmp 0x20a4f
negl %ebx
cmpl %ebx, %r14d
movl %ebx, %eax
cmovll %r14d, %eax
testl %r14d, %r14d
cmovsl %ebx, %eax
testq %r15, %r15
cmovnel %ebx, %eax
movl %eax, 0x20(%rsp)
setne %dil
testl %eax, %eax
setne %sil
orb %dil, %sil
cmpb $0x1, %sil
jne 0x20a73
movb $0x1, 0x4(%rsp)
jmp 0x20a8f
xorl %eax, %eax
movq %r12, %rsi
movl %r14d, %ecx
addq %rbp, %rcx
addq %rax, %rcx
incq %rcx
leaq 0x2(%rsp), %rax
leaq 0x70(%rsp), %r8
movq %rax, (%r8)
leaq 0xc(%rsp), %rax
movq %rax, 0x8(%r8)
leaq 0x8(%rsp), %rax
movq %rax, 0x10(%r8)
leaq 0x1c(%rsp), %rax
movq %rax, 0x18(%r8)
leaq 0x1(%rsp), %rax
movq %rax, 0x20(%r8)
movq %r15, 0x28(%r8)
leaq 0x4(%rsp), %rax
movq %rax, 0x30(%r8)
leaq 0x3(%rsp), %rax
movq %rax, 0x38(%r8)
movq 0x10(%rsp), %rdi
movq %rcx, %rdx
callq 0x21203
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20aed
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x17610
jmp 0x20aed
andl $0x80000, %r13d # imm = 0x80000
movl %r13d, %esi
shrl $0x13, %esi
movb %sil, 0x4(%rsp)
movl $0x1, %esi
testl %r13d, %r13d
je 0x20a94
movl $0x2, %esi
addl %eax, %esi
addq %rsi, %rcx
leaq 0x2(%rsp), %rax
leaq 0x70(%rsp), %r8
movq %rax, (%r8)
leaq 0x3(%rsp), %rax
movq %rax, 0x8(%r8)
leaq 0x4(%rsp), %rax
movq %rax, 0x10(%r8)
leaq 0x1(%rsp), %rax
movq %rax, 0x18(%r8)
leaq 0x20(%rsp), %rax
movq %rax, 0x20(%r8)
leaq 0xc(%rsp), %rax
movq %rax, 0x28(%r8)
leaq 0x8(%rsp), %rax
movq %rax, 0x30(%r8)
movq %r9, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x21549
movq %rax, %rbx
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20b04
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20b22
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::fill_n<fmt::v9::appender, int, char>(fmt::v9::appender, int, char const&)
|
FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)
-> OutputIt {
for (Size i = 0; i < count; ++i) *out++ = value;
return out;
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testl %esi, %esi
jle 0x20d9b
movq %rdx, %rbx
movl %esi, %ebp
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%r14)
jae 0x20d8a
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq 0x10(%r14), %rax
leaq 0x1(%rax), %rsi
movb (%rbx), %cl
movq 0x8(%r14), %rdx
movq %rsi, 0x10(%r14)
movb %cl, (%rdx,%rax)
decl %ebp
jne 0x20d6c
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda0'(fmt::v9::appender)&>(fmt::v9::detail::dragonbox::decimal_fp<float>, fmt::v9::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda0'(fmt::v9::appender)&)
|
FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
// Shifts are encoded as string literals because static constexpr is not
// supported in constexpr functions.
auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
size_t left_padding = padding >> shifts[specs.align];
size_t right_padding = padding - left_padding;
auto it = reserve(out, size + padding * specs.fill.size());
if (left_padding != 0) it = fill(it, left_padding, specs.fill);
it = f(it);
if (right_padding != 0) it = fill(it, right_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x7a06e(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
testq %r15, %r15
je 0x20f5b
movq %rsi, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f591
movq %rax, %rsi
movq %r12, %rdi
callq 0x20f90
cmpq %r15, %r14
jne 0x20f74
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
subq %r15, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f591
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::basic_memory_buffer<char, 500ul, std::allocator<char>>::grow(unsigned long)
|
FMT_CONSTEXPR20 void basic_memory_buffer<T, SIZE, Allocator>::grow(
size_t size) {
detail::abort_fuzzing_if(size > 5000);
const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
size_t old_capacity = this->capacity();
size_t new_capacity = old_capacity + old_capacity / 2;
if (size > new_capacity)
new_capacity = size;
else if (new_capacity > max_size)
new_capacity = size > max_size ? size : max_size;
T* old_data = this->data();
T* new_data =
std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
// The following code doesn't throw, so the raw pointer above doesn't leak.
std::uninitialized_copy(old_data, old_data + this->size(),
detail::make_checked(new_data, new_capacity));
this->set(new_data, new_capacity);
// deallocate must not throw according to the standard, but even if it does,
// the buffer already uses the new storage and will deallocate it in
// destructor.
if (old_data != store_) alloc_.deallocate(old_data, old_capacity);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq %rbx, %r15
shrq %r15
addq %rbx, %r15
cmpq %rsi, %r15
jb 0x211a4
testq %r15, %r15
jns 0x211ac
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, %rsi
cmovbeq %rax, %rsi
movq %rsi, %r15
testq %rsi, %rsi
js 0x211fe
movq 0x8(%r14), %r12
movq %r15, %rdi
callq 0x175e0
movq %rax, %r13
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x211cf
movq %r13, %rdi
movq %r12, %rsi
callq 0x17a40
movq %r13, 0x8(%r14)
movq %r15, 0x18(%r14)
addq $0x20, %r14
cmpq %r14, %r12
je 0x211f4
movq %r12, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x17610
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x171b0
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda1'(fmt::v9::appender)&>(fmt::v9::detail::dragonbox::decimal_fp<float>, fmt::v9::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda1'(fmt::v9::appender)&)
|
FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
// Shifts are encoded as string literals because static constexpr is not
// supported in constexpr functions.
auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
size_t left_padding = padding >> shifts[specs.align];
size_t right_padding = padding - left_padding;
auto it = reserve(out, size + padding * specs.fill.size());
if (left_padding != 0) it = fill(it, left_padding, specs.fill);
it = f(it);
if (right_padding != 0) it = fill(it, right_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x79d75(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %r13
addq $0xb, %rbx
testq %r15, %r15
je 0x21254
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f591
movq %rax, %r13
movq (%r12), %rax
movzbl (%rax), %eax
testq %rax, %rax
je 0x21296
leaq 0x79d43(%rip), %rcx # 0x9afaa
movb (%rax,%rcx), %bpl
movq 0x10(%r13), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%r13)
jae 0x2128a
movq (%r13), %rax
movq %r13, %rdi
callq *(%rax)
movq 0x10(%r13), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%r13), %rcx
movq %rsi, 0x10(%r13)
movb %bpl, (%rcx,%rax)
movq 0x8(%r12), %rax
movq 0x10(%r12), %rcx
movl (%rax), %esi
movl (%rcx), %edx
movq 0x18(%r12), %rax
movl (%rax), %ecx
movq 0x20(%r12), %rax
movsbl (%rax), %r8d
movq 0x28(%r12), %r9
movq %r13, %rdi
callq 0x2130c
movq 0x30(%r12), %rcx
movl (%rcx), %esi
testl %esi, %esi
jle 0x212d9
movq 0x38(%r12), %rdx
movq %rax, %rdi
callq 0x20d5c
cmpq %r15, %r14
jne 0x212ed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
subq %r15, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f591
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::write_significand<fmt::v9::appender, char, unsigned int, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, unsigned int, int, int, char, fmt::v9::detail::digit_grouping<char> const&)
|
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
int significand_size, int integral_size,
Char decimal_point,
const Grouping& grouping) -> OutputIt {
if (!grouping.separator()) {
return write_significand(out, significand, significand_size, integral_size,
decimal_point);
}
auto buffer = basic_memory_buffer<Char>();
write_significand(buffer_appender<Char>(buffer), significand,
significand_size, integral_size, decimal_point);
grouping.apply(
out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
return detail::copy_str_noinline<Char>(buffer.data() + integral_size,
buffer.end(), out);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movl %ecx, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x20(%r9)
je 0x213b2
movq %r9, %r14
leaq 0x30(%rsp), %r13
movq $0x0, -0x10(%r13)
leaq 0xb6dac(%rip), %rax # 0xd80f0
movq %rax, -0x20(%r13)
movq %r13, -0x18(%r13)
movq $0x1f4, -0x8(%r13) # imm = 0x1F4
movslq %ebp, %r15
testb %r8b, %r8b
je 0x21410
movslq %edx, %rcx
leaq (%rsp,%rcx), %r12
addq $0x6, %r12
subl %ebp, %ecx
cmpl $0x2, %ecx
jl 0x2141f
movl %ecx, %edx
shrl %edx
incl %edx
leaq 0x78b3d(%rip), %r9 # 0x99ec0
movq %r12, %rdi
movl %esi, %eax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
shrq $0x25, %rax
imull $0x64, %eax, %r10d
subl %r10d, %esi
movzwl (%r9,%rsi,2), %esi
movw %si, -0x2(%rdi)
addq $-0x2, %rdi
decl %edx
movl %eax, %esi
cmpl $0x1, %edx
ja 0x21386
jmp 0x21424
testb %r8b, %r8b
je 0x214b2
movslq %edx, %rax
leaq (%rsp,%rax), %r14
addq $0x11, %r14
subl %ebp, %edx
cmpl $0x2, %edx
jl 0x214c1
movl %edx, %ecx
shrl %ecx
incl %ecx
leaq 0x78ae2(%rip), %r9 # 0x99ec0
movq %r14, %rdi
movl %esi, %eax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
shrq $0x25, %rax
imull $0x64, %eax, %r10d
subl %r10d, %esi
movzwl (%r9,%rsi,2), %esi
movw %si, -0x2(%rdi)
addq $-0x2, %rdi
decl %ecx
movl %eax, %esi
cmpl $0x1, %ecx
ja 0x213e1
jmp 0x214c6
leaq 0x5(%rsp), %rdi
callq 0x1e470
movq %rdx, %r12
jmp 0x2145d
movl %esi, %eax
movq %r12, %rdi
testb $0x1, %cl
je 0x2144a
movl %eax, %ecx
movl $0xcccccccd, %edx # imm = 0xCCCCCCCD
imulq %rcx, %rdx
shrq $0x23, %rdx
leal (%rdx,%rdx), %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
orb $0x30, %al
movb %al, -0x1(%rdi)
decq %rdi
movl %edx, %eax
movb %r8b, -0x1(%rdi)
decq %rdi
subq %r15, %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x1e470
leaq 0x5(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r12, %rsi
callq 0x1e4d8
movq 0x18(%rsp), %rdx
movl %ebp, %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f63c
movq 0x18(%rsp), %rsi
addq %rsi, %r15
addq 0x20(%rsp), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1e4d8
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x21515
movq 0x28(%rsp), %rsi
callq 0x17610
jmp 0x21515
leaq 0x10(%rsp), %rdi
callq 0x1e470
movq %rdx, %r14
jmp 0x21502
movl %esi, %eax
movq %r14, %rdi
testb $0x1, %dl
je 0x214ec
movl %eax, %ecx
movl $0xcccccccd, %edx # imm = 0xCCCCCCCD
imulq %rcx, %rdx
shrq $0x23, %rdx
leal (%rdx,%rdx), %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
orb $0x30, %al
movb %al, -0x1(%rdi)
decq %rdi
movl %edx, %eax
movb %r8b, -0x1(%rdi)
decq %rdi
movslq %ebp, %rcx
subq %rcx, %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x1e470
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1e4d8
movq %rax, %rbx
movq %rbx, %rax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x21541
movq 0x28(%rsp), %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda2'(fmt::v9::appender)&>(fmt::v9::detail::dragonbox::decimal_fp<float>, fmt::v9::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda2'(fmt::v9::appender)&)
|
FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
// Shifts are encoded as string literals because static constexpr is not
// supported in constexpr functions.
auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
size_t left_padding = padding >> shifts[specs.align];
size_t right_padding = padding - left_padding;
auto it = reserve(out, size + padding * specs.fill.size());
if (left_padding != 0) it = fill(it, left_padding, specs.fill);
it = f(it);
if (right_padding != 0) it = fill(it, right_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x79a32(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
testq %r15, %r15
je 0x21597
movq %rsi, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f591
movq %rax, %rsi
movq %r12, %rdi
callq 0x215cc
cmpq %r15, %r14
jne 0x215b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
subq %r15, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f591
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, double, 0>(fmt::v9::appender, double)
|
FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
if (is_constant_evaluated())
return write(out, value, basic_format_specs<Char>());
if (const_check(!is_supported_floating_point(value))) return out;
auto fspecs = float_specs();
if (detail::signbit(value)) {
fspecs.sign = sign::minus;
value = -value;
}
constexpr auto specs = basic_format_specs<Char>();
using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
using uint = typename dragonbox::float_info<floaty>::carrier_uint;
uint mask = exponent_mask<floaty>();
if ((bit_cast<uint>(value) & mask) == mask)
return write_nonfinite(out, std::isnan(value), specs, fspecs);
auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
return write_float(out, dec, specs, fspecs, {});
}
|
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq %xmm0, %rax
testq %rax, %rax
jns 0x216fd
movl $0x100, 0xc(%rsp) # imm = 0x100
pxor 0x779a3(%rip), %xmm0 # 0x990a0
movups 0x77a5c(%rip), %xmm1 # 0x99160
movaps %xmm1, 0x10(%rsp)
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x2174f
xorl %esi, %esi
ucomisd %xmm0, %xmm0
setp %sil
movabsq $-0x100000000, %rdx # imm = 0xFFFFFFFF00000000
movabsq $0x100000020000000, %rcx # imm = 0x100000020000000
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
callq 0x204a2
jmp 0x21774
callq 0x4c878
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
movq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x2177a
addq $0x30, %rsp
popq %rbx
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::detail::dragonbox::decimal_fp<double> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda0'(fmt::v9::appender)&>(fmt::v9::detail::dragonbox::decimal_fp<double>, fmt::v9::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda0'(fmt::v9::appender)&)
|
FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
// Shifts are encoded as string literals because static constexpr is not
// supported in constexpr functions.
auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
size_t left_padding = padding >> shifts[specs.align];
size_t right_padding = padding - left_padding;
auto it = reserve(out, size + padding * specs.fill.size());
if (left_padding != 0) it = fill(it, left_padding, specs.fill);
it = f(it);
if (right_padding != 0) it = fill(it, right_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x79092(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
testq %r15, %r15
je 0x21f37
movq %rsi, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f591
movq %rax, %rsi
movq %r12, %rdi
callq 0x21f6c
cmpq %r15, %r14
jne 0x21f50
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
subq %r15, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f591
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::write_significand<char, fmt::v9::appender, unsigned long, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, unsigned long, int, int, fmt::v9::detail::digit_grouping<char> const&)
|
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
int significand_size, int exponent,
const Grouping& grouping) -> OutputIt {
if (!grouping.separator()) {
out = write_significand<Char>(out, significand, significand_size);
return detail::fill_n(out, exponent, static_cast<Char>('0'));
}
auto buffer = memory_buffer();
write_significand<char>(appender(buffer), significand, significand_size);
detail::fill_n(appender(buffer), exponent, '0');
return grouping.apply(out, string_view(buffer.data(), buffer.size()));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movl %ecx, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x20(%r8)
je 0x220e3
movq %r8, %r14
leaq 0x40(%rsp), %r15
movq $0x0, -0x10(%r15)
leaq 0xb6078(%rip), %rax # 0xd80f0
movq %rax, -0x20(%r15)
movq %r15, -0x18(%r15)
movq $0x1f4, -0x8(%r15) # imm = 0x1F4
movq %rsp, %rdi
callq 0x1e6c0
movq %rsp, %rdi
leaq 0x20(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1e4d8
movq %rsp, %rdx
movb $0x30, (%rdx)
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0x20d5c
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f63c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x22114
movq 0x38(%rsp), %rsi
callq 0x17610
jmp 0x22114
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x1e6c0
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x1e4d8
movb $0x30, (%r14)
leaq 0x20(%rsp), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x20d5c
movq %rax, %rbx
movq %rbx, %rax
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x22127
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x2213e
movq 0x38(%rsp), %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::detail::dragonbox::decimal_fp<double> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda1'(fmt::v9::appender)&>(fmt::v9::detail::dragonbox::decimal_fp<double>, fmt::v9::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda1'(fmt::v9::appender)&)
|
FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
// Shifts are encoded as string literals because static constexpr is not
// supported in constexpr functions.
auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
size_t left_padding = padding >> shifts[specs.align];
size_t right_padding = padding - left_padding;
auto it = reserve(out, size + padding * specs.fill.size());
if (left_padding != 0) it = fill(it, left_padding, specs.fill);
it = f(it);
if (right_padding != 0) it = fill(it, right_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x78e32(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %r13
addq $0xb, %rbx
testq %r15, %r15
je 0x22197
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f591
movq %rax, %r13
movq (%r12), %rax
movzbl (%rax), %eax
testq %rax, %rax
je 0x221d9
leaq 0x78e00(%rip), %rcx # 0x9afaa
movb (%rax,%rcx), %bpl
movq 0x10(%r13), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%r13)
jae 0x221cd
movq (%r13), %rax
movq %r13, %rdi
callq *(%rax)
movq 0x10(%r13), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%r13), %rcx
movq %rsi, 0x10(%r13)
movb %bpl, (%rcx,%rax)
movq 0x8(%r12), %rax
movq 0x10(%r12), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
movq 0x18(%r12), %rax
movl (%rax), %ecx
movq 0x20(%r12), %rax
movsbl (%rax), %r8d
movq 0x28(%r12), %r9
movq %r13, %rdi
callq 0x22250
movq 0x30(%r12), %rcx
movl (%rcx), %esi
testl %esi, %esi
jle 0x2221d
movq 0x38(%r12), %rdx
movq %rax, %rdi
callq 0x20d5c
cmpq %r15, %r14
jne 0x22231
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
subq %r15, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f591
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::write_significand<fmt::v9::appender, char, unsigned long, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, unsigned long, int, int, char, fmt::v9::detail::digit_grouping<char> const&)
|
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
int significand_size, int integral_size,
Char decimal_point,
const Grouping& grouping) -> OutputIt {
if (!grouping.separator()) {
return write_significand(out, significand, significand_size, integral_size,
decimal_point);
}
auto buffer = basic_memory_buffer<Char>();
write_significand(buffer_appender<Char>(buffer), significand,
significand_size, integral_size, decimal_point);
grouping.apply(
out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
return detail::copy_str_noinline<Char>(buffer.data() + integral_size,
buffer.end(), out);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movl %ecx, %ebp
movl %edx, %ecx
movq %rdi, %rbx
cmpb $0x0, 0x20(%r9)
je 0x22313
movq %r9, %r14
leaq 0x40(%rsp), %r13
movq $0x0, -0x10(%r13)
leaq 0xb5e66(%rip), %rax # 0xd80f0
movq %rax, -0x20(%r13)
movq %r13, -0x18(%r13)
movq $0x1f4, -0x8(%r13) # imm = 0x1F4
movslq %ebp, %r15
testb %r8b, %r8b
je 0x22388
movq %rbx, %r13
movslq %ecx, %r9
leaq (%rsp,%r9), %r12
incq %r12
subl %ebp, %r9d
cmpl $0x2, %r9d
jl 0x22397
movl %r9d, %r10d
shrl %r10d
incl %r10d
leaq 0x77bf0(%rip), %r11 # 0x99ec0
movabsq $0x28f5c28f5c28f5c3, %rbx # imm = 0x28F5C28F5C28F5C3
movq %r12, %rdi
movq %rsi, %rax
shrq $0x2, %rax
mulq %rbx
movq %rdx, %rcx
shrq $0x2, %rcx
imulq $0x64, %rcx, %rax
subq %rax, %rsi
movzwl (%r11,%rsi,2), %eax
movw %ax, -0x2(%rdi)
addq $-0x2, %rdi
decl %r10d
movq %rcx, %rsi
cmpl $0x1, %r10d
ja 0x222dd
jmp 0x2239d
testb %r8b, %r8b
je 0x2243e
movq %rbx, %r15
movslq %ecx, %rax
leaq (%rsp,%rax), %r14
addq $0x21, %r14
subl %ebp, %ecx
cmpl $0x2, %ecx
jl 0x2244f
movl %ecx, %r10d
shrl %r10d
incl %r10d
leaq 0x77b7b(%rip), %r11 # 0x99ec0
movabsq $0x28f5c28f5c28f5c3, %rbx # imm = 0x28F5C28F5C28F5C3
movq %r14, %rdi
movq %rsi, %rax
shrq $0x2, %rax
mulq %rbx
movq %rdx, %r9
shrq $0x2, %r9
imulq $0x64, %r9, %rax
subq %rax, %rsi
movzwl (%r11,%rsi,2), %eax
movw %ax, -0x2(%rdi)
addq $-0x2, %rdi
decl %r10d
movq %r9, %rsi
cmpl $0x1, %r10d
ja 0x22352
jmp 0x22455
movq %rsp, %rdi
movl %ecx, %edx
callq 0x1e6c0
movq %rdx, %r12
jmp 0x223e7
movq %rsi, %rcx
movq %r12, %rdi
testb $0x1, %r9b
movq %r13, %rbx
je 0x223ce
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdx
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
subl %eax, %ecx
orb $0x30, %cl
movb %cl, -0x1(%rdi)
decq %rdi
movq %rdx, %rcx
leaq 0x40(%rsp), %r13
movb %r8b, -0x1(%rdi)
decq %rdi
subq %r15, %rdi
movq %rcx, %rsi
movl %ebp, %edx
callq 0x1e6c0
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
movq %r12, %rsi
callq 0x1e4d8
movq 0x28(%rsp), %rdx
movl %ebp, %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f63c
movq 0x28(%rsp), %rsi
addq %rsi, %r15
addq 0x30(%rsp), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1e4d8
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x224b2
movq 0x38(%rsp), %rsi
callq 0x17610
jmp 0x224b2
leaq 0x20(%rsp), %rdi
movl %ecx, %edx
callq 0x1e6c0
movq %rdx, %r14
jmp 0x2249f
movq %rsi, %r9
movq %r14, %rdi
testb $0x1, %cl
movq %r15, %rbx
je 0x22488
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %r9, %rax
mulq %rcx
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
subl %eax, %r9d
orb $0x30, %r9b
movb %r9b, -0x1(%rdi)
decq %rdi
movq %rdx, %r9
movb %r8b, -0x1(%rdi)
decq %rdi
movslq %ebp, %rax
subq %rax, %rdi
movq %r9, %rsi
movl %ebp, %edx
callq 0x1e6c0
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1e4d8
movq %rax, %rbx
movq %rbx, %rax
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x224de
movq 0x38(%rsp), %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::detail::dragonbox::decimal_fp<double> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda2'(fmt::v9::appender)&>(fmt::v9::detail::dragonbox::decimal_fp<double>, fmt::v9::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda2'(fmt::v9::appender)&)
|
FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
// Shifts are encoded as string literals because static constexpr is not
// supported in constexpr functions.
auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
size_t left_padding = padding >> shifts[specs.align];
size_t right_padding = padding - left_padding;
auto it = reserve(out, size + padding * specs.fill.size());
if (left_padding != 0) it = fill(it, left_padding, specs.fill);
it = f(it);
if (right_padding != 0) it = fill(it, right_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x78a95(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
testq %r15, %r15
je 0x22534
movq %rsi, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f591
movq %rax, %rsi
movq %r12, %rdi
callq 0x2256a
cmpq %r15, %r14
jne 0x2254d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
subq %r15, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f591
nop
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::detail::float_specs fmt::v9::detail::parse_float_type_spec<fmt::v9::detail::error_handler, char>(fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::error_handler&&)
|
FMT_CONSTEXPR auto parse_float_type_spec(const basic_format_specs<Char>& specs,
ErrorHandler&& eh = {})
-> float_specs {
auto result = float_specs();
result.showpoint = specs.alt;
result.locale = specs.localized;
switch (specs.type) {
case presentation_type::none:
result.format = float_format::general;
break;
case presentation_type::general_upper:
result.upper = true;
FMT_FALLTHROUGH;
case presentation_type::general_lower:
result.format = float_format::general;
break;
case presentation_type::exp_upper:
result.upper = true;
FMT_FALLTHROUGH;
case presentation_type::exp_lower:
result.format = float_format::exp;
result.showpoint |= specs.precision != 0;
break;
case presentation_type::fixed_upper:
result.upper = true;
FMT_FALLTHROUGH;
case presentation_type::fixed_lower:
result.format = float_format::fixed;
result.showpoint |= specs.precision != 0;
break;
case presentation_type::hexfloat_upper:
result.upper = true;
FMT_FALLTHROUGH;
case presentation_type::hexfloat_lower:
result.format = float_format::hex;
break;
default:
eh.on_error("invalid type specifier");
break;
}
return result;
}
|
movzbl 0x8(%rdi), %edx
cmpq $0xe, %rdx
ja 0x229b8
movzwl 0x9(%rdi), %eax
movl %eax, %ecx
shrl $0x7, %ecx
andl $0x1, %ecx
movl %ecx, %esi
shll $0x13, %esi
shll $0x9, %eax
andl $0x20000, %eax # imm = 0x20000
orl %esi, %eax
leaq 0x768ac(%rip), %rsi # 0x99204
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
orl $0x10000, %eax # imm = 0x10000
orl $0x3, %eax
jmp 0x229b3
orl $0x10000, %eax # imm = 0x10000
jmp 0x229b3
orl $0x10000, %eax # imm = 0x10000
xorl %edx, %edx
cmpl $0x0, 0x4(%rdi)
setne %dl
movzwl %cx, %ecx
orl %edx, %ecx
shll $0x13, %ecx
andl $0x7fffd, %eax # imm = 0x7FFFD
addl %ecx, %eax
addl $0x2, %eax
jmp 0x229b3
orl $0x10000, %eax # imm = 0x10000
xorl %edx, %edx
cmpl $0x0, 0x4(%rdi)
setne %dl
movzwl %cx, %ecx
orl %edx, %ecx
shll $0x13, %ecx
andl $0x7fffe, %eax # imm = 0x7FFFE
addl %ecx, %eax
incl %eax
shlq $0x20, %rax
retq
pushq %rax
leaq 0x775d4(%rip), %rdi # 0x99f94
callq 0x4b89e
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/core.h
|
char fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_bytes<(fmt::v9::align::type)2, char, fmt::v9::appender>(fmt::v9::appender, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_specs<char> const&)::'lambda'(fmt::v9::appender)&>(char, fmt::v9::basic_format_specs<fmt::v9::appender> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::write_bytes<(fmt::v9::align::type)2, char, fmt::v9::appender>(fmt::v9::appender, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_specs<char> const&)::'lambda'(fmt::v9::appender)&)
|
FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
// Shifts are encoded as string literals because static constexpr is not
// supported in constexpr functions.
auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
size_t left_padding = padding >> shifts[specs.align];
size_t right_padding = padding - left_padding;
auto it = reserve(out, size + padding * specs.fill.size());
if (left_padding != 0) it = fill(it, left_padding, specs.fill);
it = f(it);
if (right_padding != 0) it = fill(it, right_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x7822e(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r13
movq %rdi, %r12
addq $0xb, %rbx
testq %r15, %r15
je 0x22d9b
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f591
movq %rax, %r12
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x1e4f0
cmpq %r15, %r14
jne 0x22dc0
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
subq %r15, %r14
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1f591
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::detail::bigint::divmod_assign(fmt::v9::detail::bigint const&)
|
FMT_CONSTEXPR20 int divmod_assign(const bigint& divisor) {
FMT_ASSERT(this != &divisor, "");
if (compare(*this, divisor) < 0) return 0;
FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
align(divisor);
int quotient = 0;
do {
subtract_aligned(divisor);
++quotient;
} while (compare(*this, divisor) >= 0);
return quotient;
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x23893
testl %eax, %eax
js 0x2388a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23e7a
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23f1c
incl %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23893
testl %eax, %eax
jns 0x2386c
jmp 0x2388c
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::detail::compare(fmt::v9::detail::bigint const&, fmt::v9::detail::bigint const&)
|
constexpr auto size() const noexcept -> size_t { return size_; }
|
movq 0x10(%rdi), %r8
movl 0xa8(%rdi), %eax
addl %r8d, %eax
movl 0x10(%rsi), %ecx
movl 0xa8(%rsi), %edx
addl %ecx, %edx
cmpl %edx, %eax
jne 0x238e9
movl %r8d, %edx
subl %ecx, %r8d
xorl %eax, %eax
testl %r8d, %r8d
cmovgl %r8d, %eax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
cmpl %edx, %eax
jge 0x238f1
decl %ecx
movl -0x4(%rdi,%rdx,4), %r8d
decq %rdx
movl (%rsi,%rcx,4), %r9d
cmpl %r9d, %r8d
je 0x238c6
xorl %eax, %eax
cmpl %r8d, %r9d
adcl $-0x1, %eax
orl $0x1, %eax
retq
setg %al
movzbl %al, %eax
jmp 0x238fe
xorl %eax, %eax
cmpl %edx, %ecx
je 0x23905
xorl %eax, %eax
cmpl %edx, %ecx
setl %al
leal -0x1(,%rax,2), %eax
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/core.h
|
fmt::v9::basic_memory_buffer<unsigned int, 32ul, std::allocator<unsigned int>>::grow(unsigned long)
|
FMT_CONSTEXPR20 void basic_memory_buffer<T, SIZE, Allocator>::grow(
size_t size) {
detail::abort_fuzzing_if(size > 5000);
const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
size_t old_capacity = this->capacity();
size_t new_capacity = old_capacity + old_capacity / 2;
if (size > new_capacity)
new_capacity = size;
else if (new_capacity > max_size)
new_capacity = size > max_size ? size : max_size;
T* old_data = this->data();
T* new_data =
std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
// The following code doesn't throw, so the raw pointer above doesn't leak.
std::uninitialized_copy(old_data, old_data + this->size(),
detail::make_checked(new_data, new_capacity));
this->set(new_data, new_capacity);
// deallocate must not throw according to the standard, but even if it does,
// the buffer already uses the new storage and will deallocate it in
// destructor.
if (old_data != store_) alloc_.deallocate(old_data, old_capacity);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
addq $0xa0, %rdi
movq 0x18(%r14), %rbx
movq %rbx, %r15
shrq %r15
addq %rbx, %r15
cmpq %rsi, %r15
jae 0x23930
movq %rsi, %r15
jmp 0x2394a
movq %r15, %rax
shrq $0x3d, %rax
je 0x2394a
movabsq $0x1fffffffffffffff, %r15 # imm = 0x1FFFFFFFFFFFFFFF
cmpq %r15, %rsi
cmovaq %rsi, %r15
movq 0x8(%r14), %r12
movq %r15, %rsi
xorl %edx, %edx
callq 0x239a6
movq %rax, %r13
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x23973
shlq $0x2, %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x17a40
movq %r13, 0x8(%r14)
movq %r15, 0x18(%r14)
addq $0x20, %r14
cmpq %r14, %r12
je 0x2399c
shlq $0x2, %rbx
movq %r12, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x17610
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned __int128>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned __int128>, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref)::'lambda2'(fmt::v9::appender)>(char, int, unsigned int, fmt::v9::basic_format_specs<fmt::v9::appender> const&, unsigned __int128)::'lambda'(fmt::v9::appender)&>(fmt::v9::appender, fmt::v9::basic_format_specs<unsigned __int128> const&, unsigned long, unsigned long, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned __int128>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned __int128>, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref)::'lambda2'(fmt::v9::appender)>(char, int, unsigned int, fmt::v9::basic_format_specs<fmt::v9::appender> const&, unsigned __int128)::'lambda'(fmt::v9::appender)&)
|
FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
size_t padding = spec_width > width ? spec_width - width : 0;
// Shifts are encoded as string literals because static constexpr is not
// supported in constexpr functions.
auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
size_t left_padding = padding >> shifts[specs.align];
size_t right_padding = padding - left_padding;
auto it = reserve(out, size + padding * specs.fill.size());
if (left_padding != 0) it = fill(it, left_padding, specs.fill);
it = f(it);
if (right_padding != 0) it = fill(it, right_padding, specs.fill);
return base_iterator(out, it);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x731fb(%rip), %rcx # 0x9afa0
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %r13
addq $0xb, %rbx
testq %r15, %r15
je 0x27dce
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1f591
movq %rax, %r13
movl $0xffffff, %ebp # imm = 0xFFFFFF
andl (%r12), %ebp
je 0x27e13
movq 0x10(%r13), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%r13)
jae 0x27df8
movq (%r13), %rax
movq %r13, %rdi
callq *(%rax)
movq 0x10(%r13), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%r13), %rcx
movq %rsi, 0x10(%r13)
movb %bpl, (%rcx,%rax)
movl %ebp, %eax
shrl $0x8, %eax
cmpl $0x100, %ebp # imm = 0x100
movl %eax, %ebp
jae 0x27dd9
movq 0x10(%r12), %rsi
movq %rsp, %rdx
movb $0x30, (%rdx)
movq %r13, %rdi
callq 0x1f5f0
movq 0x20(%r12), %rdx
movq 0x28(%r12), %rcx
movl 0x30(%r12), %r8d
movslq %r8d, %rdi
movq 0x10(%rax), %rsi
addq %rsi, %r8
cmpq %r8, 0x18(%rax)
jb 0x27e8d
movq %r8, 0x10(%rax)
movq 0x8(%rax), %r8
testq %r8, %r8
je 0x27e8d
addq %rdi, %rsi
addq %r8, %rsi
decq %rsi
movq %rcx, %rdi
movl %edx, %r8d
andb $0x7, %r8b
orb $0x30, %r8b
movq %rcx, %r9
shldq $0x3d, %rdx, %r9
movb %r8b, (%rsi)
shrq $0x3, %rdi
decq %rsi
cmpq $0x8, %rdx
sbbq $0x0, %rcx
movq %r9, %rdx
movq %rdi, %rcx
jae 0x27e5e
jmp 0x27edb
leaq (%rsp,%rdi), %rsi
addq %rsp, %rdi
decq %rdi
movl $0x7, %r8d
movq %rcx, %r9
movl %edx, %r10d
andb $0x7, %r10b
orb $0x30, %r10b
movb %r10b, (%rdi)
movq %rcx, %r10
shldq $0x3d, %rdx, %r10
shrq $0x3, %r9
decq %rdi
cmpq %rdx, %r8
movl $0x0, %edx
sbbq %rcx, %rdx
movq %r10, %rdx
movq %r9, %rcx
jb 0x27ea0
movq %rsp, %rdi
movq %rax, %rdx
callq 0x1e4d8
cmpq %r15, %r14
je 0x27ef1
subq %r15, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1f591
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
|
spdlog::logger::logger<std::shared_ptr<spdlog::sinks::sink> const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<spdlog::sinks::sink> const*, std::shared_ptr<spdlog::sinks::sink> const*)
|
logger(std::string name, It begin, It end)
: name_(std::move(name))
, sinks_(begin, end)
{}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x9aba1(%rip), %rax # 0xd8518
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq (%rsi), %rdi
leaq 0x10(%rsi), %rax
cmpq %rax, %rdi
je 0x3d99f
movq %rdi, 0x8(%rbx)
movq (%rax), %rdi
movq %rdi, 0x18(%rbx)
jmp 0x3d9a6
movups (%rax), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rsi), %rdi
movq %rdi, 0x10(%rbx)
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
leaq 0x28(%rbx), %rdi
leaq 0xf(%rsp), %rax
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x3da46
movabsq $0x600000002, %rax # imm = 0x600000002
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0xa8(%rbx)
movups %xmm0, 0xb8(%rbx)
movq $0x0, 0xc8(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x81(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
je 0x3da3d
movq (%r15), %rsi
incq %rsi
callq 0x17610
movq %r14, %rdi
callq 0x17b50
nop
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/logger.h
|
spdlog::sinks::base_sink<std::mutex>::log(spdlog::details::log_msg const&)
|
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg)
{
std::lock_guard<Mutex> lock(mutex_);
sink_it_(msg);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x17950
testl %eax, %eax
jne 0x3dba8
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x30(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x174c0
movl %eax, %edi
callq 0x17400
movq %rax, %r14
movq %rbx, %rdi
callq 0x174c0
movq %r14, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h
|
spdlog::sinks::base_sink<std::mutex>::set_pattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern)
{
std::lock_guard<Mutex> lock(mutex_);
set_pattern_(pattern);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x17950
testl %eax, %eax
jne 0x3dc40
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x174c0
movl %eax, %edi
callq 0x17400
movq %rax, %r14
movq %rbx, %rdi
callq 0x174c0
movq %r14, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h
|
spdlog::sinks::base_sink<std::mutex>::set_formatter(std::unique_ptr<spdlog::formatter, std::default_delete<spdlog::formatter>>)
|
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
{
std::lock_guard<Mutex> lock(mutex_);
set_formatter_(std::move(sink_formatter));
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x17950
testl %eax, %eax
jne 0x3dcbf
movq (%r15), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq $0x0, (%r15)
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3dca4
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x174c0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x17400
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3dcd9
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x174c0
movq %r14, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h
|
spdlog::sinks::base_sink<std::mutex>::set_pattern_(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern)
{
set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3dd91
movq (%r14), %rax
movq $0x0, (%r14)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3dd34
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x3dd51
leaq 0x8(%rsp), %rdi
callq 0x408d4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3dd6c
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x3dd89
leaq 0x8(%rsp), %rdi
callq 0x408d4
movq %rbx, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h
|
spdlog::details::circular_q<spdlog::details::log_msg_buffer>::copy_moveable(spdlog::details::circular_q<spdlog::details::log_msg_buffer>&&)
|
void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT
{
max_items_ = other.max_items_;
head_ = other.head_;
tail_ = other.tail_;
overrun_counter_ = other.overrun_counter_;
v_ = std::move(other.v_);
// put &&other in disabled, but valid state
other.max_items_ = 0;
other.head_ = other.tail_ = 0;
other.overrun_counter_ = 0;
}
|
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movq 0x30(%rdi), %rax
movups 0x20(%rsi), %xmm0
movups 0x20(%rdi), %xmm1
movups %xmm0, 0x20(%rdi)
movq 0x30(%rsi), %rcx
movq %rcx, 0x30(%rdi)
movq %rsp, %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi)
movq $0x0, 0x30(%rsi)
callq 0x3e752
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/circular_q.h
|
spdlog::details::S_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&)
|
void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_sec, dest);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movl (%rdx), %r14d
cmpq $0x63, %r14
ja 0x449f8
movzbl %r14b, %eax
imull $0xcd, %eax, %r15d
shrl $0xb, %r15d
leal (%r15,%r15), %eax
leal (%rax,%rax,4), %eax
subb %al, %r14b
orb $0x30, %r15b
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x449bc
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb %r15b, (%rcx,%rax)
orb $0x30, %r14b
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x449ea
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb %r14b, (%rcx,%rax)
jmp 0x44a3a
movq %rsp, %r8
movq %r14, (%r8)
movq 0x10(%rbx), %rax
leaq 0x18(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x93f7a(%rip), %rax # 0xd8990
addq $0x10, %rax
movq %rax, (%rdi)
movq %rbx, 0x20(%rdi)
leaq 0x5a1ff(%rip), %rsi # 0x9ec27
movl $0x5, %edx
movl $0x1, %ecx
xorl %r9d, %r9d
callq 0x1df93
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h
|
spdlog::details::F_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&)
|
void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
auto ns = fmt_helper::time_fraction<std::chrono::nanoseconds>(msg.time);
const size_t field_size = 9;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad9(static_cast<size_t>(ns.count()), dest);
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x18(%rsi), %r14
movabsq $0x112e0be826d694b3, %rdx # imm = 0x112E0BE826D694B3
movq %r14, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
imulq $0x3b9aca00, %rdx, %rax # imm = 0x3B9ACA00
subq %rax, %r14
movq %r14, %rax
orq $0x1, %rax
bsrq %rax, %rax
leaq 0x56626(%rip), %rdx # 0x9b260
movzbl (%rdx,%rax), %eax
leaq 0x5665b(%rip), %rdx # 0x9b2a0
cmpq (%rdx,%rax,8), %r14
movq %rcx, %rbx
sbbl $0x0, %eax
cmpl $0x8, %eax
ja 0x44c89
movl $0x9, %ebp
subl %eax, %ebp
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x44c79
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb $0x30, (%rcx,%rax)
decl %ebp
jne 0x44c5b
leaq 0x15(%rsp), %rsi
leaq 0x5522b(%rip), %rcx # 0x99ec0
cmpq $0x64, %r14
jb 0x44cd8
movabsq $0x28f5c28f5c28f5c3, %rdi # imm = 0x28F5C28F5C28F5C3
movq %r14, %rax
shrq $0x2, %rax
mulq %rdi
shrq $0x2, %rdx
imulq $0x64, %rdx, %rax
movq %r14, %r8
subq %rax, %r8
movzwl (%rcx,%r8,2), %eax
movw %ax, -0x2(%rsi)
addq $-0x2, %rsi
cmpq $0x270f, %r14 # imm = 0x270F
movq %rdx, %r14
ja 0x44ca5
jmp 0x44cdb
movq %r14, %rdx
cmpq $0x9, %rdx
ja 0x44cec
orb $0x30, %dl
movb %dl, -0x1(%rsi)
decq %rsi
jmp 0x44cf8
movzwl (%rcx,%rdx,2), %eax
movw %ax, -0x2(%rsi)
addq $-0x2, %rsi
leaq 0x15(%rsp), %rdx
movq %rsi, 0x3(%rdx)
movq %rbx, %rdi
callq 0x1e4f0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h
|
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::set_color_mode(spdlog::color_mode)
|
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
{
switch (mode)
{
case color_mode::always:
should_do_colors_ = true;
return;
case color_mode::automatic:
should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal();
return;
case color_mode::never:
should_do_colors_ = false;
return;
default:
should_do_colors_ = false;
}
}
|
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x46439
cmpl $0x2, %esi
je 0x46435
cmpl $0x1, %esi
jne 0x46435
movq 0x1c0(%rbx), %rdi
callq 0x3a001
testb %al, %al
je 0x46435
callq 0x39f1f
jmp 0x4643b
xorl %eax, %eax
jmp 0x4643b
movb $0x1, %al
movb %al, 0x1d0(%rbx)
popq %rbx
retq
nop
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h
|
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::set_formatter(std::unique_ptr<spdlog::formatter, std::default_delete<spdlog::formatter>>)
|
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x1c8(%rdi), %rbx
movq %rbx, %rdi
callq 0x17950
testl %eax, %eax
jne 0x4691e
movq (%r15), %rax
movq $0x0, (%r15)
movq 0x1d8(%r14), %rdi
movq %rax, 0x1d8(%r14)
testq %rdi, %rdi
je 0x46911
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x174c0
movl %eax, %edi
callq 0x17400
nop
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h
|
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::set_color_mode(spdlog::color_mode)
|
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
{
switch (mode)
{
case color_mode::always:
should_do_colors_ = true;
return;
case color_mode::automatic:
should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal();
return;
case color_mode::never:
should_do_colors_ = false;
return;
default:
should_do_colors_ = false;
}
}
|
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x46e9f
cmpl $0x2, %esi
je 0x46e9b
cmpl $0x1, %esi
jne 0x46e9b
movq 0x1c0(%rbx), %rdi
callq 0x3a001
testb %al, %al
je 0x46e9b
callq 0x39f1f
jmp 0x46ea1
xorl %eax, %eax
jmp 0x46ea1
movb $0x1, %al
movb %al, 0x1d0(%rbx)
popq %rbx
retq
nop
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h
|
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::to_string_[abi:cxx11](fmt::v9::basic_string_view<char> const&)
|
SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv)
{
return std::string(sv.data(), sv.size());
}
|
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rdi), %rcx
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rcx, (%rdi)
movq %rax, %rsi
callq 0x37b20
movq %rbx, %rax
popq %rbx
retq
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h
|
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::log(spdlog::details::log_msg const&)
|
SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
{
// Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead.
std::lock_guard<mutex_t> lock(mutex_);
msg.color_range_start = 0;
msg.color_range_end = 0;
memory_buf_t formatted;
formatter_->format(msg, formatted);
if (should_do_colors_ && msg.color_range_end > msg.color_range_start)
{
// before color range
print_range_(formatted, 0, msg.color_range_start);
// in color range
print_ccode_(colors_[static_cast<size_t>(msg.level)]);
print_range_(formatted, msg.color_range_start, msg.color_range_end);
print_ccode_(reset);
// after color range
print_range_(formatted, msg.color_range_end, formatted.size());
}
else // no color
{
print_range_(formatted, 0, formatted.size());
}
fflush(target_file_);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsi)
leaq 0x20(%rsp), %r15
movq $0x0, -0x10(%r15)
leaq 0x910f3(%rip), %rax # 0xd8060
addq $0x10, %rax
movq %rax, -0x20(%r15)
movq %r15, -0x18(%r15)
movq $0xfa, -0x8(%r15)
movq 0x1d8(%rdi), %rdi
movq (%rdi), %rax
movq %rsp, %rdx
callq *0x10(%rax)
cmpb $0x1, 0x1d0(%rbx)
jne 0x4703e
movq 0x28(%r14), %rdx
cmpq %rdx, 0x30(%r14)
jbe 0x4703e
movq 0x8(%rsp), %rdi
movq 0x1c0(%rbx), %rcx
movl $0x1, %esi
callq 0x17c50
movslq 0x10(%r14), %rax
shlq $0x5, %rax
movq 0x1e0(%rbx,%rax), %rdi
movq 0x1e8(%rbx,%rax), %rdx
movq 0x1c0(%rbx), %rcx
movl $0x1, %esi
callq 0x17c50
movq 0x28(%r14), %rax
movq 0x30(%r14), %rdx
movq 0x8(%rsp), %rdi
addq %rax, %rdi
subq %rax, %rdx
movq 0x1c0(%rbx), %rcx
movl $0x1, %esi
callq 0x17c50
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
movq 0x1c0(%rbx), %rcx
movl $0x1, %esi
callq 0x17c50
movq 0x30(%r14), %rax
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
addq %rax, %rdi
subq %rax, %rdx
jmp 0x47048
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x1c0(%rbx), %rcx
movl $0x1, %esi
callq 0x17c50
movq 0x1c0(%rbx), %rdi
callq 0x17750
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x47079
movq 0x18(%rsp), %rsi
callq 0x17610
addq $0x120, %rsp # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4709d
movq 0x18(%rsp), %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b50
nop
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h
|
std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt<spdlog::synchronous_factory>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spdlog::color_mode)
|
SPDLOG_INLINE std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, color_mode mode)
{
return Factory::template create<sinks::stdout_color_sink_mt>(logger_name, mode);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl %edx, (%r14)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f42a
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x47392
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x47360
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17610
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x47389
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b50
nop
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/stdout_color_sinks-inl.h
|
std::shared_ptr<spdlog::logger> spdlog::stdout_color_st<spdlog::async_factory_impl<(spdlog::async_overflow_policy)0>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spdlog::color_mode)
|
SPDLOG_INLINE std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, color_mode mode)
{
return Factory::template create<sinks::stdout_color_sink_st>(logger_name, mode);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %r14
movl %edx, (%r14)
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f42a
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x47ca6
movaps (%rsp), %xmm0
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movups %xmm0, (%rbx)
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x47c75
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x17610
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x47c9e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/stdout_color_sinks-inl.h
|
std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::async_factory_impl<(spdlog::async_overflow_policy)0>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spdlog::color_mode)
|
SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode)
{
return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %r14
movl %edx, (%r14)
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1f42a
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4825a
movaps (%rsp), %xmm0
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movups %xmm0, (%rbx)
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x48229
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x17610
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x48252
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/stdout_color_sinks-inl.h
|
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::~ansicolor_sink()
|
~ansicolor_sink() override = default;
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x918bf(%rip), %rax # 0xd9dc0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x2b0(%rdi), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rax
movq -0x10(%r14,%r15), %rdi
cmpq %rdi, %rax
je 0x4852b
movq (%rax), %rsi
incq %rsi
callq 0x17610
addq $-0x20, %r15
cmpq $-0xe0, %r15
jne 0x48512
movq 0x1d8(%rbx), %rdi
testq %rdi, %rdi
je 0x4854a
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x1d8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink.h
|
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::~ansicolor_sink()
|
~ansicolor_sink() override = default;
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x9187d(%rip), %rax # 0xd9e00
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x2b0(%rdi), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rax
movq -0x10(%r14,%r15), %rdi
cmpq %rdi, %rax
je 0x485ad
movq (%rax), %rsi
incq %rsi
callq 0x17610
addq $-0x20, %r15
cmpq $-0xe0, %r15
jne 0x48594
movq 0x1d8(%rbx), %rdi
testq %rdi, %rdi
je 0x485cc
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x1d8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink.h
|
spdlog::details::mpmc_blocking_queue<spdlog::details::async_msg>::mpmc_blocking_queue(unsigned long)
|
explicit mpmc_blocking_queue(size_t max_items)
: q_(max_items)
{}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r13d, %r13d
movq %r13, 0x20(%rdi)
leaq 0x28(%rdi), %rbx
movq %rbx, %rdi
callq 0x178d0
leaq 0x58(%r12), %r14
movq %r14, %rdi
callq 0x178d0
incq %r15
movq %r15, 0x88(%r12)
leaq 0xa8(%r12), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%r12)
movq %r13, 0xa0(%r12)
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x4b4c2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x17ba0
movq %rbx, %rdi
callq 0x17ba0
movq %r15, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/mpmc_blocking_q.h
|
spdlog::details::mpmc_blocking_queue<spdlog::details::async_msg>::dequeue_for(spdlog::details::async_msg&, std::chrono::duration<long, std::ratio<1l, 1000l>>)
|
bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
{
{
std::unique_lock<std::mutex> lock(queue_mutex_);
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
{
return false;
}
popped_item = std::move(q_.front());
q_.pop_front();
}
pop_cv_.notify_one();
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %rdx, (%r15)
leaq 0x8(%rsp), %r12
movq %rdi, (%r12)
movb $0x0, 0x8(%r12)
movq %r12, %rdi
callq 0x4b64e
movb $0x1, 0x8(%r12)
leaq 0x28(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x4b79e
movl %eax, %ebp
testb %al, %al
je 0x4b13b
imulq $0x198, 0x90(%rbx), %rsi # imm = 0x198
addq 0xa8(%rbx), %rsi
movq %r14, %rdi
callq 0x4b74c
movq 0x90(%rbx), %rax
incq %rax
xorl %edx, %edx
divq 0x88(%rbx)
movq %rdx, 0x90(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x4b638
addq $0x58, %rbx
movq %rbx, %rdi
callq 0x172d0
jmp 0x4b145
leaq 0x8(%rsp), %rdi
callq 0x4b638
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4b638
movq %rbx, %rdi
callq 0x17b50
nop
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/details/mpmc_blocking_q.h
|
fmt::v9::vsystem_error(int, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_args<fmt::v9::basic_format_context<fmt::v9::appender, char>>)
|
FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
format_args args) {
auto ec = std::error_code(error_code, std::generic_category());
return std::system_error(ec, vformat(format_str, args));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movl %esi, 0x4(%rsp)
movq %rdi, %r14
callq 0x172f0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbp, %r8
callq 0x4baef
movq %r14, %rdi
movl 0x4(%rsp), %esi
movq %rbx, %rdx
leaq 0x8(%rsp), %rcx
callq 0x4c234
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4bab7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17610
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4bae7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h
|
fmt::v9::vformat[abi:cxx11](fmt::v9::basic_string_view<char>, fmt::v9::basic_format_args<fmt::v9::basic_format_context<fmt::v9::appender, char>>)
|
FMT_FUNC std::string vformat(string_view fmt, format_args args) {
// Don't optimize the "{}" case to keep the binary size small and because it
// can be better optimized in fmt::format anyway.
auto buffer = memory_buffer();
detail::vformat_to(buffer, fmt, args);
return to_string(buffer);
}
|
pushq %r14
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq $0x0, -0x10(%r14)
leaq 0x8c5d0(%rip), %rax # 0xd80e0
addq $0x10, %rax
movq %rax, -0x20(%r14)
movq %r14, -0x18(%r14)
movq $0x1f4, -0x8(%r14) # imm = 0x1F4
movq %rsp, %rdi
xorl %r9d, %r9d
callq 0x1df93
movq 0x8(%rsp), %rsi
leaq 0x10(%rbx), %rax
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x37b20
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4bb5f
movq 0x18(%rsp), %rsi
callq 0x17610
movq %rbx, %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4bb84
movq 0x18(%rsp), %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h
|
fmt::v9::detail::utf8_to_utf16::utf8_to_utf16(fmt::v9::basic_string_view<char>)
|
FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) {
for_each_codepoint(s, [this](uint32_t cp, string_view) {
if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8"));
if (cp <= 0xFFFF) {
buffer_.push_back(static_cast<wchar_t>(cp));
} else {
cp -= 0x10000;
buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
}
return true;
});
buffer_.push_back(0);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x10(%rdi)
leaq 0x8e6df(%rip), %rax # 0xda290
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x1f4, 0x18(%rdi) # imm = 0x1F4
movq %rsi, %rax
cmpq $0x4, %rdx
jb 0x4bbf3
leaq (%r14,%r15), %r13
addq $-0x3, %r13
movq %r14, %rax
cmpq %r13, %rax
jae 0x4bbf3
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4c04a
testq %rax, %rax
jne 0x4bbdc
jmp 0x4bc35
addq %r15, %r14
subq %rax, %r14
je 0x4bc35
xorl %ecx, %ecx
leaq 0x8(%rsp), %r15
movl %ecx, 0x3(%r15)
movl %ecx, (%r15)
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x174f0
movq %r15, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4c04a
testq %rax, %rax
je 0x4bc35
movq %rax, %rcx
subq %r15, %rcx
cmpq %r14, %rcx
jl 0x4bc1a
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x4bc53
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movl $0x0, (%rcx,%rax,4)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4bc74
jmp 0x4bc74
movq %rax, %r14
movq 0x8(%rbx), %rdi
cmpq %r12, %rdi
je 0x4bc8d
movq 0x18(%rbx), %rsi
shlq $0x2, %rsi
callq 0x17610
movq %r14, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h
|
fmt::v9::detail::thousands_sep_result<wchar_t> fmt::v9::detail::thousands_sep_impl<wchar_t>(fmt::v9::detail::locale_ref)
|
FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
auto grouping = facet.grouping();
auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
return {std::move(grouping), thousands_sep};
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
testq %rsi, %rsi
je 0x4ce52
callq 0x173b0
jmp 0x4ce57
callq 0x17c90
movq %rsp, %rdi
callq 0x179a0
movq %rax, %r14
movq %rsp, %rdi
callq 0x178e0
movq (%r14), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
cmpq $0x0, 0x8(%r15)
je 0x4ce8b
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
jmp 0x4ce8d
xorl %eax, %eax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x10(%rsp), %rdx
movq -0x10(%rdx), %rsi
cmpq %rdx, %rsi
je 0x4ceb0
movq %rsi, (%rbx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x4ceb6
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movl %eax, 0x20(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4cefa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x17610
jmp 0x4cefa
movq %rax, %rbx
movq %rsp, %rdi
callq 0x178e0
movq %rbx, %rdi
callq 0x17b50
|
/njoy[P]ENDFtk/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h
|
N_VInvTestLocal_ManyVector
|
sunbooleantype MVAPPEND(N_VInvTestLocal)(N_Vector x, N_Vector z)
{
SUNFunctionBegin(x->sunctx);
sunindextype i;
sunbooleantype val, subval;
/* initialize output*/
val = SUNTRUE;
for (i = 0; i < MANYVECTOR_NUM_SUBVECS(x); i++)
{
/* check for nvinvtestlocal in subvector */
if (MANYVECTOR_SUBVEC(x, i)->ops->nvinvtestlocal)
{
subval = N_VInvTestLocal(MANYVECTOR_SUBVEC(x, i), MANYVECTOR_SUBVEC(z, i));
SUNCheckLastErrNoRet();
val = (val && subval);
/* otherwise, call nvinvtest and accumulate to overall val */
}
else
{
subval = N_VInvTest(MANYVECTOR_SUBVEC(x, i), MANYVECTOR_SUBVEC(z, i));
SUNCheckLastErrNoRet();
val = (val && subval);
}
}
return (val);
}
|
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x1, 0x14(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jge 0x474f
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x160(%rax)
je 0x46e1
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3110
movl %eax, 0x10(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0xf(%rsp)
je 0x46d2
cmpl $0x0, 0x10(%rsp)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
jmp 0x473a
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x32a0
movl %eax, 0x10(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0xe(%rsp)
je 0x472d
cmpl $0x0, 0x10(%rsp)
setne %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
jmp 0x473c
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x464d
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
|
/opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c
|
N_VConstrMaskLocal_ManyVector
|
sunbooleantype MVAPPEND(N_VConstrMaskLocal)(N_Vector c, N_Vector x, N_Vector m)
{
SUNFunctionBegin(x->sunctx);
sunindextype i;
sunbooleantype val, subval;
/* initialize output*/
val = SUNTRUE;
for (i = 0; i < MANYVECTOR_NUM_SUBVECS(x); i++)
{
/* check for nvconstrmasklocal in subvector */
if (MANYVECTOR_SUBVEC(x, i)->ops->nvconstrmasklocal)
{
subval = N_VConstrMaskLocal(MANYVECTOR_SUBVEC(c, i),
MANYVECTOR_SUBVEC(x, i),
MANYVECTOR_SUBVEC(m, i));
SUNCheckLastErrNoRet();
val = (val && subval);
/* otherwise, call nvconstrmask and accumulate to overall val */
}
else
{
subval = N_VConstrMask(MANYVECTOR_SUBVEC(c, i), MANYVECTOR_SUBVEC(x, i),
MANYVECTOR_SUBVEC(m, i));
SUNCheckLastErrNoRet();
val = (val && subval);
}
}
return (val);
}
|
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x1, 0xc(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jge 0x48be
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x168(%rax)
je 0x483b
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x3200
movl %eax, 0x8(%rsp)
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
movb %al, 0x7(%rsp)
je 0x482c
cmpl $0x0, 0x8(%rsp)
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
jmp 0x48a9
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x3340
movl %eax, 0x8(%rsp)
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
movb %al, 0x6(%rsp)
je 0x489c
cmpl $0x0, 0x8(%rsp)
setne %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
jmp 0x48ab
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4792
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
|
/opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c
|
N_VMinQuotientLocal_ManyVector
|
sunrealtype MVAPPEND(N_VMinQuotientLocal)(N_Vector num, N_Vector denom)
{
SUNFunctionBegin(num->sunctx);
sunindextype i;
sunrealtype min, lmin;
/* initialize output*/
min = SUN_BIG_REAL;
for (i = 0; i < MANYVECTOR_NUM_SUBVECS(num); i++)
{
/* check for nvminquotientlocal in subvector */
if (MANYVECTOR_SUBVEC(num, i)->ops->nvminquotientlocal)
{
lmin = N_VMinQuotientLocal(MANYVECTOR_SUBVEC(num, i),
MANYVECTOR_SUBVEC(denom, i));
SUNCheckLastErrNoRet();
min = (min < lmin) ? min : lmin;
/* otherwise, call nvmin and accumulate to overall min */
}
else
{
lmin = N_VMinQuotient(MANYVECTOR_SUBVEC(num, i),
MANYVECTOR_SUBVEC(denom, i));
SUNCheckLastErrNoRet();
min = (min < lmin) ? min : lmin;
}
}
return (min);
}
|
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movsd 0x270c(%rip), %xmm0 # 0x7000
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jge 0x4a2d
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x170(%rax)
je 0x49ab
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3180
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4991
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x499d
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x4a18
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x31c0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4a00
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x4a0c
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x4a1a
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x4903
movsd 0x20(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
|
/opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c
|
N_VLinearCombination_ManyVector
|
SUNErrCode MVAPPEND(N_VLinearCombination)(int nvec, sunrealtype* c, N_Vector* X,
N_Vector z)
{
SUNFunctionBegin(z->sunctx);
sunindextype i, j;
N_Vector* Xsub;
/* create array of nvec N_Vector pointers for reuse within loop */
Xsub = NULL;
Xsub = (N_Vector*)malloc(nvec * sizeof(N_Vector));
SUNAssert(Xsub, SUN_ERR_MALLOC_FAIL);
/* perform operation by calling N_VLinearCombination for each subvector */
for (i = 0; i < MANYVECTOR_NUM_SUBVECS(z); i++)
{
/* for each subvector, create the array of subvectors of X */
for (j = 0; j < nvec; j++) { Xsub[j] = MANYVECTOR_SUBVEC(X[j], i); }
/* now call N_VLinearCombination for this array of subvectors */
SUNCheckCall(N_VLinearCombination(nvec, c, Xsub, MANYVECTOR_SUBVEC(z, i)));
}
/* clean up and return */
free(Xsub);
return SUN_SUCCESS;
}
|
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movslq 0x44(%rsp), %rdi
shlq $0x3, %rdi
callq 0x3220
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jge 0x4b2f
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq 0x44(%rsp), %rcx
cmpq %rcx, %rax
jge 0x4af4
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4aa9
movl 0x44(%rsp), %edi
movq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
callq 0x31a0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4a8a
movq 0x8(%rsp), %rdi
callq 0x3040
xorl %eax, %eax
addq $0x48, %rsp
retq
|
/opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c
|
N_VScaleAddMulti_ManyVector
|
SUNErrCode MVAPPEND(N_VScaleAddMulti)(int nvec, sunrealtype* a, N_Vector x,
N_Vector* Y, N_Vector* Z)
{
SUNFunctionBegin(x->sunctx);
sunindextype i, j;
N_Vector *Ysub, *Zsub;
/* create arrays of nvec N_Vector pointers for reuse within loop */
Ysub = Zsub = NULL;
Ysub = (N_Vector*)malloc(nvec * sizeof(N_Vector));
SUNAssert(Ysub, SUN_ERR_MALLOC_FAIL);
Zsub = (N_Vector*)malloc(nvec * sizeof(N_Vector));
SUNAssert(Zsub, SUN_ERR_MALLOC_FAIL);
/* perform operation by calling N_VScaleAddMulti for each subvector */
for (i = 0; i < MANYVECTOR_NUM_SUBVECS(x); i++)
{
/* for each subvector, create the array of subvectors of Y and Z */
for (j = 0; j < nvec; j++)
{
Ysub[j] = MANYVECTOR_SUBVEC(Y[j], i);
Zsub[j] = MANYVECTOR_SUBVEC(Z[j], i);
}
/* now call N_VScaleAddMulti for this array of subvectors */
SUNCheckCall(N_VScaleAddMulti(nvec, a, MANYVECTOR_SUBVEC(x, i), Ysub, Zsub));
}
/* clean up and return */
free(Ysub);
free(Zsub);
return SUN_SUCCESS;
}
|
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movslq 0x54(%rsp), %rdi
shlq $0x3, %rdi
callq 0x3220
movq %rax, 0x10(%rsp)
movslq 0x54(%rsp), %rdi
shlq $0x3, %rdi
callq 0x3220
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jge 0x4c81
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movslq 0x54(%rsp), %rcx
cmpq %rcx, %rax
jge 0x4c41
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4bca
movl 0x54(%rsp), %edi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x3100
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x4bab
movq 0x10(%rsp), %rdi
callq 0x3040
movq 0x8(%rsp), %rdi
callq 0x3040
xorl %eax, %eax
addq $0x58, %rsp
retq
nopl (%rax)
|
/opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c
|
N_VDotProdMulti_ManyVector
|
SUNErrCode MVAPPEND(N_VDotProdMulti)(int nvec, N_Vector x, N_Vector* Y,
sunrealtype* dotprods)
{
SUNFunctionBegin(x->sunctx);
sunindextype i;
/* call N_VDotProdLocal for each <x,Y[i]> pair */
for (i = 0; i < nvec; i++)
{
dotprods[i] = N_VDotProdLocal(x, Y[i]);
SUNCheckLastErr();
}
#ifdef MANYVECTOR_BUILD_WITH_MPI
/* accumulate totals and return */
if (MANYVECTOR_COMM(x) != MPI_COMM_NULL)
{
SUNCheckMPICall(MPI_Allreduce(MPI_IN_PLACE, dotprods, nvec, MPI_SUNREALTYPE,
MPI_SUM, MANYVECTOR_COMM(x)));
}
#endif
/* return with success */
return SUN_SUCCESS;
}
|
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movslq 0x34(%rsp), %rcx
cmpq %rcx, %rax
jge 0x4d14
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3070
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4cce
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
|
/opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c
|
N_VWrmsNormVectorArray_ManyVector
|
SUNErrCode MVAPPEND(N_VWrmsNormVectorArray)(int nvec, N_Vector* X, N_Vector* W,
sunrealtype* nrm)
{
SUNFunctionBegin(X[0]->sunctx);
sunindextype i;
SUNAssert(nvec > 0, SUN_ERR_ARG_OUTOFRANGE);
/* call N_VWSqrSumLocal for each (X[i],W[i]) pair */
for (i = 0; i < nvec; i++)
{
nrm[i] = N_VWSqrSumLocal(X[i], W[i]);
SUNCheckLastErr();
}
/* accumulate totals */
#ifdef MANYVECTOR_BUILD_WITH_MPI
if (MANYVECTOR_COMM(X[0]) != MPI_COMM_NULL)
{
SUNCheckMPICall(MPI_Allreduce(MPI_IN_PLACE, nrm, nvec, MPI_SUNREALTYPE,
MPI_SUM, MANYVECTOR_COMM(X[0])));
}
#endif
/* finish off WRMS norms and return */
for (i = 0; i < nvec; i++)
{
nrm[i] = SUNRsqrt(nrm[i] / (MANYVECTOR_GLOBLENGTH(X[i])));
}
return SUN_SUCCESS;
}
|
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movslq 0x34(%rsp), %rcx
cmpq %rcx, %rax
jge 0x4da0
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x31e0
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4d51
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movslq 0x34(%rsp), %rcx
cmpq %rcx, %rax
jge 0x4e54
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
cvtsi2sdq 0x8(%rax), %xmm0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x4df9
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
jmp 0x4e2d
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
cvtsi2sdq 0x8(%rax), %xmm1
divsd %xmm1, %xmm0
callq 0x32f0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4da9
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
|
/opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c
|
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.