name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> lest::to_string<std::__exception_ptr::exception_ptr, std::__exception_ptr::exception_ptr>(std::__exception_ptr::exception_ptr const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__exception_ptr::exception_ptr const&) | auto to_string( L const & lhs, std::string op, R const & rhs ) -> std::string
{
std::ostringstream os; os << to_string( lhs ) << " " << op << " " << to_string( rhs ); return os.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4380
movq %rsp, %rdi
movq %r12, %rsi
callq 0xbced9
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x4230
leaq 0x8c55(%rip), %rsi # 0xc5a3a
movq %rax, %rdi
callq 0x4260
movq %rax, %rdi
movq %r15, %rsi
callq 0x4230
leaq 0x8c3b(%rip), %rsi # 0xc5a3a
movq %rax, %rdi
callq 0x4260
movq %rax, %r15
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xbced9
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x4230
leaq 0x20(%rsp), %rdi
callq 0x4140
movq %rsp, %rdi
callq 0x4140
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x42a0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0xbce66
movq %rdx, (%rbx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0xbce6c
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq %rsp, %rdi
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x4140
leaq 0x40(%rsp), %rdi
callq 0x40a0
movq %rbx, %rax
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xbceb7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4140
jmp 0xbcebf
jmp 0xbcebc
movq %rax, %rbx
jmp 0xbcec7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4140
leaq 0x40(%rsp), %rdi
callq 0x40a0
movq %rbx, %rdi
callq 0x44a0
| /martinmoene[P]expected-lite/test/lest/lest.hpp |
std::enable_if<!is_streamable<std::__exception_ptr::exception_ptr>::value, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::type lest::make_string<std::__exception_ptr::exception_ptr>(std::__exception_ptr::exception_ptr const&) | auto make_string( T const & item ) -> ForNonStreamable<T, std::string>
{
return make_enum_string( item );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xbcfa9
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x18(%rsp), %rax
cmpq %rax, %rdx
je 0xbcf7a
movq %rdx, (%rbx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0xbcf80
movups (%rax), %xmm0
movups %xmm0, (%rcx)
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x4140
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /martinmoene[P]expected-lite/test/lest/lest.hpp |
lest::result lest::expression_lhs<nonstd::expected_lite::unexpected_type<int> const&>::operator!=<nonstd::expected_lite::unexpected_type<int>>(nonstd::expected_lite::unexpected_type<int> const&) | result operator> ( R const & rhs ) { return result{ lhs > rhs, to_string( lhs, ">" , rhs ) }; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movl (%r15), %eax
cmpl (%rdx), %eax
setne %bpl
leaq 0xa580(%rip), %rsi # 0xc80d2
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x4110
leaq 0x58(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%r12), %rdx
leaq 0x18(%rsp), %rax
cmpq %rax, %rdx
je 0xbdb8c
movq %rdx, 0x48(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x58(%rsp)
jmp 0xbdb92
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
leaq 0x48(%rsp), %rdx
movq %rcx, 0x8(%rdx)
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0xbddeb
leaq 0x78(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0xbdbe8
movq %rdx, 0x68(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x78(%rsp)
jmp 0xbdbee
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x30(%rsp), %rcx
leaq 0x68(%rsp), %rsi
movq %rax, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
movq %rcx, 0x8(%rsi)
movb $0x0, 0x38(%rsp)
leaq 0x90(%rsp), %r14
movb %bpl, -0x8(%r14)
movq %r14, %rdi
callq 0x4390
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0xbab34
movq %r14, %rdi
callq 0x4140
leaq 0x68(%rsp), %rdi
callq 0x4140
leaq 0x28(%rsp), %rdi
callq 0x4140
leaq 0x48(%rsp), %rdi
callq 0x4140
leaq 0x8(%rsp), %rdi
callq 0x4140
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x4140
jmp 0xbdc83
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4140
leaq 0x28(%rsp), %rdi
callq 0x4140
jmp 0xbdc9c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4140
leaq 0x8(%rsp), %rdi
callq 0x4140
movq %rbx, %rdi
callq 0x44a0
| /martinmoene[P]expected-lite/test/lest/lest.hpp |
std::enable_if<!(is_container<nonstd::expected_lite::expected<void, int>>::value || std::is_pointer<nonstd::expected_lite::expected<void, int>>::value), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::type lest::to_string<nonstd::expected_lite::expected<void, int>>(nonstd::expected_lite::expected<void, int> const&) | auto to_string( T const & item ) -> ForNonContainerNonPointer<T, std::string>
{
return make_string( item );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc1b66
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x18(%rsp), %rax
cmpq %rax, %rdx
je 0xc1b37
movq %rdx, (%rbx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0xc1b3d
movups (%rax), %xmm0
movups %xmm0, (%rcx)
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x4140
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /martinmoene[P]expected-lite/test/lest/lest.hpp |
lest::result lest::expression_lhs<nonstd::expected_lite::expected<int, char> const&>::operator==<nonstd::expected_lite::expected<int, char>>(nonstd::expected_lite::expected<int, char> const&) | result operator<=( R const & rhs ) { return result{ lhs <= rhs, to_string( lhs, "<=", rhs ) }; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rdx, %rsi
callq 0xc31f0
movl %eax, %ebp
movq (%r15), %r15
leaq 0x5d29(%rip), %rsi # 0xc7eb6
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x4110
leaq 0x58(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%r12), %rdx
leaq 0x18(%rsp), %rax
cmpq %rax, %rdx
je 0xc21c7
movq %rdx, 0x48(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x58(%rsp)
jmp 0xc21cd
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
leaq 0x48(%rsp), %rdx
movq %rcx, 0x8(%rdx)
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0xc3235
leaq 0x78(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0xc2223
movq %rdx, 0x68(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x78(%rsp)
jmp 0xc2229
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x30(%rsp), %rcx
leaq 0x68(%rsp), %rsi
movq %rax, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
movq %rcx, 0x8(%rsi)
movb $0x0, 0x38(%rsp)
leaq 0x90(%rsp), %r14
movb %bpl, -0x8(%r14)
movq %r14, %rdi
callq 0x4390
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0xbab34
movq %r14, %rdi
callq 0x4140
leaq 0x68(%rsp), %rdi
callq 0x4140
leaq 0x28(%rsp), %rdi
callq 0x4140
leaq 0x48(%rsp), %rdi
callq 0x4140
leaq 0x8(%rsp), %rdi
callq 0x4140
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x4140
jmp 0xc22be
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4140
leaq 0x28(%rsp), %rdi
callq 0x4140
jmp 0xc22d7
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4140
leaq 0x8(%rsp), %rdi
callq 0x4140
movq %rbx, %rdi
callq 0x44a0
nop
| /martinmoene[P]expected-lite/test/lest/lest.hpp |
lest::result lest::expression_lhs<nonstd::expected_lite::expected<int, char> const&>::operator==<nonstd::expected_lite::unexpected_type<char>>(nonstd::expected_lite::unexpected_type<char> const&) | result operator==( R const & rhs ) { return result{ lhs == rhs, to_string( lhs, "==", rhs ) }; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movb 0x4(%r15), %bpl
movb (%rdx), %al
cmpb %al, (%r15)
sete %r13b
leaq 0x5300(%rip), %rsi # 0xc7eb6
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0x4110
leaq 0x60(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%r12), %rdx
leaq 0x20(%rsp), %rax
cmpq %rax, %rdx
je 0xc2bf0
movq %rdx, 0x50(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x60(%rsp)
jmp 0xc2bf6
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rsp), %rcx
leaq 0x50(%rsp), %rdx
movq %rcx, 0x8(%rdx)
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0xc3679
notb %bpl
andb %r13b, %bpl
leaq 0x80(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0xc2c58
movq %rdx, 0x70(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x80(%rsp)
jmp 0xc2c5e
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x38(%rsp), %rcx
leaq 0x70(%rsp), %rsi
movq %rax, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
movq %rcx, 0x8(%rsi)
movb $0x0, 0x40(%rsp)
leaq 0x98(%rsp), %r14
movb %bpl, -0x8(%r14)
movq %r14, %rdi
callq 0x4390
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0xbab34
movq %r14, %rdi
callq 0x4140
leaq 0x70(%rsp), %rdi
callq 0x4140
leaq 0x30(%rsp), %rdi
callq 0x4140
leaq 0x50(%rsp), %rdi
callq 0x4140
leaq 0x10(%rsp), %rdi
callq 0x4140
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x4140
jmp 0xc2cf5
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x4140
leaq 0x30(%rsp), %rdi
callq 0x4140
jmp 0xc2d0e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4140
leaq 0x10(%rsp), %rdi
callq 0x4140
movq %rbx, %rdi
callq 0x44a0
| /martinmoene[P]expected-lite/test/lest/lest.hpp |
lest::result lest::expression_lhs<nonstd::expected_lite::unexpected_type<char> const&>::operator==<nonstd::expected_lite::expected<int, char>>(nonstd::expected_lite::expected<int, char> const&) | result operator!=( R const & rhs ) { return result{ lhs != rhs, to_string( lhs, "!=", rhs ) }; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movb 0x4(%rdx), %bpl
movb (%r15), %al
cmpb %al, (%rdx)
sete %r13b
leaq 0x515e(%rip), %rsi # 0xc7eb6
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0x4110
leaq 0x60(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%r12), %rdx
leaq 0x20(%rsp), %rax
cmpq %rax, %rdx
je 0xc2d92
movq %rdx, 0x50(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x60(%rsp)
jmp 0xc2d98
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rsp), %rcx
leaq 0x50(%rsp), %rdx
movq %rcx, 0x8(%rdx)
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0xc3a31
notb %bpl
andb %r13b, %bpl
leaq 0x80(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0xc2dfa
movq %rdx, 0x70(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x80(%rsp)
jmp 0xc2e00
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x38(%rsp), %rcx
leaq 0x70(%rsp), %rsi
movq %rax, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
movq %rcx, 0x8(%rsi)
movb $0x0, 0x40(%rsp)
leaq 0x98(%rsp), %r14
movb %bpl, -0x8(%r14)
movq %r14, %rdi
callq 0x4390
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0xbab34
movq %r14, %rdi
callq 0x4140
leaq 0x70(%rsp), %rdi
callq 0x4140
leaq 0x30(%rsp), %rdi
callq 0x4140
leaq 0x50(%rsp), %rdi
callq 0x4140
leaq 0x10(%rsp), %rdi
callq 0x4140
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x4140
jmp 0xc2e97
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x4140
leaq 0x30(%rsp), %rdi
callq 0x4140
jmp 0xc2eb0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4140
leaq 0x10(%rsp), %rdi
callq 0x4140
movq %rbx, %rdi
callq 0x44a0
| /martinmoene[P]expected-lite/test/lest/lest.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> lest::to_string<nonstd::expected_lite::expected<int, char>, nonstd::expected_lite::unexpected_type<char>>(nonstd::expected_lite::expected<int, char> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nonstd::expected_lite::unexpected_type<char> const&) | auto to_string( L const & lhs, std::string op, R const & rhs ) -> std::string
{
std::ostringstream os; os << to_string( lhs ) << " " << op << " " << to_string( rhs ); return os.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4380
movq %rsp, %rdi
movq %r12, %rsi
callq 0xbeb05
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x4230
leaq 0x237e(%rip), %rsi # 0xc5a3a
movq %rax, %rdi
callq 0x4260
movq %rax, %rdi
movq %r15, %rsi
callq 0x4230
leaq 0x2364(%rip), %rsi # 0xc5a3a
movq %rax, %rdi
callq 0x4260
movq %rax, %r15
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xc37b0
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x4230
leaq 0x20(%rsp), %rdi
callq 0x4140
movq %rsp, %rdi
callq 0x4140
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x42a0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0xc373d
movq %rdx, (%rbx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0xc3743
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq %rsp, %rdi
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x4140
leaq 0x40(%rsp), %rdi
callq 0x40a0
movq %rbx, %rax
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xc378e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4140
jmp 0xc3796
jmp 0xc3793
movq %rax, %rbx
jmp 0xc379e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4140
leaq 0x40(%rsp), %rdi
callq 0x40a0
movq %rbx, %rdi
callq 0x44a0
| /martinmoene[P]expected-lite/test/lest/lest.hpp |
main | int main(int argc, char ** argv)
{
LogManager::Add(new LogStdout());
MyClass C;
C.Test();
LogManager::RemoveAll();
return 0;
} | pushq %rbx
subq $0x20, %rsp
movl $0x8, %edi
callq 0x10c0
movq 0x2d8e(%rip), %rcx # 0x3fe0
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rax, %rdi
callq 0x1110
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x12c2
movq %rbx, %rdi
callq 0x133c
callq 0x1080
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1294
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12ba
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10d0
movq %rbx, %rdi
callq 0x1120
| /mistralol[P]liblogger/tests/proxylogger.cpp |
MyClass::MyClass() | MyClass() :
ProxyLogger("TESTPROXY")
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd26(%rip), %rsi # 0x2004
leaq 0xd28(%rip), %rdx # 0x200d
movq %rsp, %r14
movq %r14, %rdi
callq 0x1478
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10e0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1311
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1334
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10d0
movq %rbx, %rdi
callq 0x1120
| /mistralol[P]liblogger/tests/proxylogger.cpp |
MyClass::Test() | void Test() {
LogDebug("Debug Logging #1");
LogDebug("Debug Logging #%d", 2);
LogInfo("Info Logging #1");
LogInfo("Info Logging #%d", 2);
LogNotice("Notice Logging #1");
LogNotice("%s Logging #2", "Notice");
LogWarning("Warning!!!!!!");
LogWarning("Warning!!!!!! #%d", 2);
LogError("This is an Error");
LogError("This is an Error %d", 2);
LogError("Something Critical happened");
LogError("Something Critical happened %s", "Really BAD!");
LogAlert("Alert Alert");
LogAlert("Alert Alert %s", "Alert");
LogCritical("TestLog Critical!");
LogEmergency("TestLog Emergency!");
} | pushq %rbx
movq %rdi, %rbx
leaq 0xcf1(%rip), %rsi # 0x2038
xorl %eax, %eax
callq 0x10f0
leaq 0xcf4(%rip), %rsi # 0x2049
movq %rbx, %rdi
movl $0x2, %edx
xorl %eax, %eax
callq 0x10f0
leaq 0xcf0(%rip), %rsi # 0x205b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1050
leaq 0xcef(%rip), %rsi # 0x206b
movq %rbx, %rdi
movl $0x2, %edx
xorl %eax, %eax
callq 0x1050
leaq 0xcea(%rip), %rsi # 0x207c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1060
leaq 0xceb(%rip), %rsi # 0x208e
leaq 0xcf2(%rip), %rdx # 0x209c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1060
leaq 0xce8(%rip), %rsi # 0x20a3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
leaq 0xce5(%rip), %rsi # 0x20b1
movq %rbx, %rdi
movl $0x2, %edx
xorl %eax, %eax
callq 0x1030
leaq 0xce1(%rip), %rsi # 0x20c3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1070
leaq 0xce1(%rip), %rsi # 0x20d4
movq %rbx, %rdi
movl $0x2, %edx
xorl %eax, %eax
callq 0x1070
leaq 0xcdf(%rip), %rsi # 0x20e8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1070
leaq 0xcea(%rip), %rsi # 0x2104
leaq 0xd02(%rip), %rdx # 0x2123
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1070
leaq 0xcfd(%rip), %rsi # 0x212f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
leaq 0xcf8(%rip), %rsi # 0x213b
leaq 0xceb(%rip), %rdx # 0x2135
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
leaq 0xcef(%rip), %rsi # 0x214a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0xcf0(%rip), %rsi # 0x215c
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x10b0
nop
| /mistralol[P]liblogger/tests/proxylogger.cpp |
booster::ptime::from_number(double) | static ptime from_number(double d)
{
double sec = floor(d);
double subsec = d-sec;
long long seconds = static_cast<long long>(sec);
int nano = static_cast<int>(floor(subsec * 1e9));
if(nano < 0) nano = 0;
if(nano >= one_e9) nano = one_e9-1;
return ptime(seconds,nano);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, (%rsp)
callq 0x5b540
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
cvttsd2si %xmm0, %r14
mulsd 0x4d00b(%rip), %xmm1 # 0xab008
movapd %xmm1, %xmm0
callq 0x5b540
cvttsd2si %xmm0, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl $0x3b9ac9ff, %eax # imm = 0x3B9AC9FF
cmpl %eax, %ecx
cmovgel %eax, %ecx
leaq 0x8(%rsp), %rbx
movq %r14, (%rbx)
movl %ecx, 0x8(%rbx)
movq %rbx, %rdi
callq 0x59b10
movq (%rbx), %rax
movl 0x8(%rbx), %edx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /artyom-beilis[P]cppcms/booster/./booster/posix_time.h |
booster::backtrace::backtrace(unsigned long) | backtrace(size_t frames_no = default_stack_size)
{
if(frames_no == 0)
return;
frames_.resize(frames_no,0);
int size = stack_trace::trace(&frames_.front(),frames_no);
frames_.resize(size);
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x74755(%rip), %rax # 0xd2bc0
addq $0x10, %rax
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
testq %rsi, %rsi
je 0x5e4b8
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rbx
movq %rsp, %rdx
movq $0x0, (%rdx)
movq %rbx, %rdi
callq 0x58040
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x57a80
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x59a80
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x5e4c2
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5e4d2
callq 0x59580
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/./booster/backtrace.h |
booster::intrusive_ptr<booster::callable<void (std::error_code const&)>>::~intrusive_ptr() | ~intrusive_ptr()
{
if(p_ != 0) intrusive_ptr_release(p_);
} | pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x5f3e9
leaq 0x8(%rbx), %rdi
callq 0x59e20
testq %rax, %rax
je 0x5f3eb
popq %rbx
retq
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x8(%rax)
movq %rax, %rdi
callq 0x5f195
nop
| /artyom-beilis[P]cppcms/booster/./booster/intrusive_ptr.h |
booster::aio::endpoint::path[abi:cxx11]() const | std::string endpoint::path() const
{
if(family()!=pf_unix)
throw_invalid();
return d->sa.un.sun_path;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x57fe0
testl %eax, %eax
jne 0x5f837
movq (%r14), %r15
leaq 0xa(%r15), %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x57e60
leaq (%r15,%rax), %rdx
addq $0xa, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x57c80
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x59070
| /artyom-beilis[P]cppcms/booster/lib/aio/src/endpoint.cpp |
booster::aio::event_loop_impl::post(booster::callback<void (std::error_code const&)> const&, std::error_code const&) | void post(event_handler const &h,booster::system::error_code const &e)
{
lock_guard l(data_mutex_);
dispatch_queue_.push_back(completion_handler(h,e));
if(polling_)
wake();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movq %rsp, %r12
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
movq %r12, %rdi
callq 0x587e0
movb $0x1, 0x8(%r12)
movq (%r15), %rdi
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x5fe55
addq $0x8, %rdi
callq 0x57ae0
movups (%r14), %xmm0
leaq 0x10(%rsp), %rsi
movups %xmm0, 0x8(%rsi)
movq $0x0, 0x18(%rsi)
movq 0x72e27(%rip), %rax # 0xd2c98
movq %rax, 0x20(%rsi)
leaq 0x58(%rbx), %rdi
callq 0x5a340
leaq 0x10(%rsp), %rdi
callq 0x59a50
cmpb $0x1, 0x3d(%rbx)
jne 0x5fe9a
addq $0x34, %rbx
movq %rbx, %rdi
callq 0x5bab0
movq %rsp, %rdi
callq 0x5b1f0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5feb0
movq %rax, %rbx
jmp 0x5fec2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x59a50
movq %rsp, %rdi
callq 0x5b1f0
movq %rbx, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/io_service.cpp |
booster::aio::reactor::poll(booster::aio::reactor::event*, int, int, std::error_code&) | int reactor::poll(reactor::event *events,int n,int timeout,system::error_code &e)
{
int error = 0;
int r=impl_->poll(events,n,timeout,error);
if(error)
e=system::error_code(error,syscat);
return r;
} | pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
movq (%rdi), %rdi
movq (%rdi), %rax
movq %r14, %r8
callq *0x8(%rax)
movl (%r14), %ecx
testl %ecx, %ecx
je 0x62b5d
movq 0x72df9(%rip), %rdx # 0xd5950
movl %ecx, (%rbx)
movq %rdx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/aio/src/reactor.cpp |
booster::aio::epoll_reactor::select(int, int, int&) | virtual void select(native_type fd,int flags,int &error)
{
if(!check(fd,error))
return;
if(events_[fd]!=0 && flags==0)
write_flag(fd,EPOLL_CTL_DEL,0,error);
else if(events_[fd]==0 && flags!=0)
write_flag(fd,EPOLL_CTL_ADD,to_poll_events(flags),error);
else if(events_[fd]!=flags)
write_flag(fd,EPOLL_CTL_MOD,to_poll_events(flags),error);
events_[fd]=flags;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r12
leaq 0x8(%rdi), %r14
movq %r14, %rdi
movq %rcx, %rdx
callq 0x58ee0
testb %al, %al
je 0x6424d
movslq %ebp, %r13
movq (%r14), %rax
movl (%rax,%r13,4), %eax
testl %eax, %eax
sete %cl
testl %ebx, %ebx
setne %dl
orb %cl, %dl
jne 0x641fc
movq %r12, %rdi
movl %ebp, %esi
movl $0x2, %edx
xorl %ecx, %ecx
jmp 0x6423e
testl %eax, %eax
setne %cl
testl %ebx, %ebx
sete %dl
orb %cl, %dl
jne 0x64223
movl %ebx, %eax
andl $0x1, %eax
movl %ebx, %ecx
andl $0x2, %ecx
leal (%rax,%rcx,2), %ecx
movq %r12, %rdi
movl %ebp, %esi
movl $0x1, %edx
jmp 0x6423e
cmpl %ebx, %eax
je 0x64246
movl %ebx, %eax
andl $0x1, %eax
movl %ebx, %ecx
andl $0x2, %ecx
leal (%rax,%rcx,2), %ecx
movq %r12, %rdi
movl %ebp, %esi
movl $0x3, %edx
movq %r15, %r8
callq 0x59e30
movq (%r14), %rax
movl %ebx, (%rax,%r13,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /artyom-beilis[P]cppcms/booster/lib/aio/src/reactor.cpp |
booster::aio::epoll_reactor::poll(booster::aio::reactor::event*, int, int, int&) | virtual int poll(reactor::event *events,int n,int timeout,int &error)
{
struct epoll_event fds[128] = {};
if (n >128) n=128;
int size = 0;
size = ::epoll_wait(pollfd_,fds,n,timeout);
if(size < 0) {
error = errno;
return -1;
}
int read = 0;
for(int i=0;i<size;i++) {
events[read].events = to_user_events(fds[i].events);
events[read].fd = fds[i].data.fd;
read ++;
}
return read;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x618, %rsp # imm = 0x618
movq %r8, 0x8(%rsp)
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x10(%rsp), %r14
xorl %ebp, %ebp
movl $0x600, %edx # imm = 0x600
movq %r14, %rdi
xorl %esi, %esi
callq 0x583d0
movl $0x80, %edx
cmpl %edx, %r12d
cmovll %r12d, %edx
movl 0x20(%r13), %edi
movq %r14, %rsi
movl %r15d, %ecx
callq 0x58000
testl %eax, %eax
js 0x642fc
je 0x6430f
movl %eax, %ecx
leaq 0x14(%rsp), %rdx
xorl %esi, %esi
movl -0x4(%rdx), %edi
movl %edi, %r8d
andl $0x1, %r8d
movl %edi, %r9d
shrl %r9d
andl $0x2, %r9d
leal (%r9,%r8), %r10d
testb $0x1a, %dil
leal 0x4(%r9,%r8), %edi
cmovel %r10d, %edi
movl %edi, 0x4(%rbx,%rsi,8)
movl (%rdx), %edi
movl %edi, (%rbx,%rsi,8)
incq %rsi
addq $0xc, %rdx
cmpq %rsi, %rcx
jne 0x642be
movl %eax, %ebp
jmp 0x6430f
callq 0x57130
movl (%rax), %eax
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x618, %rsp # imm = 0x618
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/aio/src/reactor.cpp |
booster::aio::base_fast_reactor::check(int, int&) | bool check(int fd,int &error)
{
if(fd < 0) {
error=EINVAL;
return false;
}
if(fd >= int(events_.size())) {
events_.resize(fd+1,0);
}
return true;
} | pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
testl %esi, %esi
js 0x64557
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x2, %rax
cmpl %ebx, %eax
jg 0x6455d
leal 0x1(%rbx), %esi
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
callq 0x580d0
jmp 0x6455d
movl $0x16, (%rdx)
testl %ebx, %ebx
setns %al
addq $0x10, %rsp
popq %rbx
retq
| /artyom-beilis[P]cppcms/booster/lib/aio/src/reactor.cpp |
booster::aio::impl::select_interrupter::notify() | void select_interrupter::notify()
{
#ifdef BOOSTER_WIN32
char c='A';
::send(write_,&c,1,0);
#else
for(;;) {
char c='A';
if(::write(write_,&c,1) < 0 && errno==EINTR)
continue;
break;
}
#endif
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rsi
movb $0x41, (%rsi)
movl 0x4(%rdi), %edi
movl $0x1, %edx
callq 0x57b30
testq %rax, %rax
jns 0x64723
callq 0x57130
movq %rax, %r14
leaq 0xf(%rsp), %r15
cmpl $0x4, (%r14)
jne 0x64723
movb $0x41, 0xf(%rsp)
movl 0x4(%rbx), %edi
movl $0x1, %edx
movq %r15, %rsi
callq 0x57b30
testq %rax, %rax
js 0x64703
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/aio/src/select_iterrupter.cpp |
booster::aio::basic_io_device::set_non_blocking(bool) | void basic_io_device::set_non_blocking(bool nonblocking)
{
system::error_code e;
set_non_blocking(nonblocking,e);
if(e) throw system::system_error(e);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
callq 0x58480
movq %rax, 0x8(%r15)
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x59f40
movl (%r15), %ebp
testl %ebp, %ebp
jne 0x64b3b
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x58050
movq %rax, %rbx
movq 0x10(%rsp), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x58130
movq 0x6de8a(%rip), %rsi # 0xd29e8
movq 0x6e373(%rip), %rdx # 0xd2ed8
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/basic_io_device.cpp |
booster::aio::basic_io_device::dont_block(booster::callback<void (std::error_code const&, unsigned long)> const&) | bool basic_io_device::dont_block(io_handler const &h)
{
if(nonblocking_was_set_)
return true;
system::error_code e;
set_non_blocking(true,e);
if(e) {
get_io_service().post(h,e,0);
return false;
}
nonblocking_was_set_ = true;
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movb $0x1, %bpl
cmpb $0x0, 0x15(%rdi)
jne 0x64c0f
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
callq 0x58480
movq %rax, 0x8(%r15)
movq %r14, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x59f40
cmpl $0x0, (%r15)
sete %bpl
je 0x64c0a
movq %r14, %rdi
callq 0x5a040
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x57b20
jmp 0x64c0f
movb $0x1, 0x15(%r14)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /artyom-beilis[P]cppcms/booster/lib/aio/src/basic_io_device.cpp |
booster::aio::basic_io_device::dont_block(booster::callback<void (std::error_code const&)> const&) | bool basic_io_device::dont_block(event_handler const &h)
{
if(nonblocking_was_set_)
return true;
system::error_code e;
set_non_blocking(true,e);
if(e) {
get_io_service().post(h,e);
return false;
}
nonblocking_was_set_ = true;
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movb $0x1, %bpl
cmpb $0x0, 0x15(%rdi)
jne 0x64c83
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
callq 0x58480
movq %rax, 0x8(%r15)
movq %r14, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x59f40
cmpl $0x0, (%r15)
sete %bpl
je 0x64c7e
movq %r14, %rdi
callq 0x5a040
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x58d50
jmp 0x64c83
movb $0x1, 0x15(%r14)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /artyom-beilis[P]cppcms/booster/lib/aio/src/basic_io_device.cpp |
booster::aio::basic_socket::open(booster::aio::family_type, booster::aio::socket_type) | void basic_socket::open(family_type d,socket_type t)
{
system::error_code e;
open(d,t,e);
if(e)
throw system::system_error(e);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
callq 0x58480
movq %rax, 0x8(%r15)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
movq %r15, %rcx
callq 0x5c0d0
movl (%r15), %ebp
testl %ebp, %ebp
jne 0x64df1
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x58050
movq %rax, %rbx
movq 0x10(%rsp), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x58130
movq 0x6dbd4(%rip), %rsi # 0xd29e8
movq 0x6e0bd(%rip), %rdx # 0xd2ed8
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/basic_socket.cpp |
booster::aio::basic_socket::local_endpoint(std::error_code&) | endpoint basic_socket::local_endpoint(system::error_code &e)
{
std::vector<char> endpoint_raw_(1000,0);
sockaddr *sa = reinterpret_cast<sockaddr *>(&endpoint_raw_.front());
socklen_t len = endpoint_raw_.size();
if(::getsockname(native(),sa,&len) < 0)
e=geterror();
endpoint ep;
ep.raw(sa,len);
return ep;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x3e8, %edi # imm = 0x3E8
callq 0x596b0
movq %rax, %rbx
movl $0x3e8, %edx # imm = 0x3E8
movq %rax, %rdi
xorl %esi, %esi
callq 0x583d0
movl $0x3e8, 0x4(%rsp) # imm = 0x3E8
movq %r12, %rdi
callq 0x57490
leaq 0x4(%rsp), %rdx
movl %eax, %edi
movq %rbx, %rsi
callq 0x59480
testl %eax, %eax
jns 0x64e9b
callq 0x57130
movl (%rax), %eax
movq 0x70b2c(%rip), %rcx # 0xd59c0
movl %eax, (%r15)
movq %rcx, 0x8(%r15)
movq %r14, %rdi
callq 0x5b020
movl 0x4(%rsp), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58980
movq %rbx, %rdi
callq 0x59580
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x5a810
jmp 0x64ed9
movq %rax, %r15
movq %rbx, %rdi
callq 0x59580
movq %r15, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/aio/src/basic_socket.cpp |
booster::aio::basic_socket::local_endpoint() | endpoint basic_socket::local_endpoint()
{
system::error_code e;
endpoint ep=local_endpoint(e);
if(e) throw system::system_error(e);
return ep;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
callq 0x58480
movq %rax, 0x8(%r15)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5a610
movl (%r15), %ebp
testl %ebp, %ebp
jne 0x64f32
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x58050
movq %rax, %r14
movq 0x10(%rsp), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x58130
movq 0x6da93(%rip), %rsi # 0xd29e8
movq 0x6df7c(%rip), %rdx # 0xd2ed8
movq %r14, %rdi
callq 0x5b600
movq %rax, %r15
jmp 0x64f74
movq %rax, %r15
movq %r14, %rdi
callq 0x58a30
movq %rbx, %rdi
callq 0x5a810
movq %r15, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/basic_socket.cpp |
booster::aio::basic_socket::remote_endpoint(std::error_code&) | endpoint basic_socket::remote_endpoint(system::error_code &e)
{
std::vector<char> endpoint_raw_(1000,0);
sockaddr *sa = reinterpret_cast<sockaddr *>(&endpoint_raw_.front());
socklen_t len = endpoint_raw_.size();
endpoint ep;
if(::getpeername(native(),sa,&len) < 0)
e=geterror();
else
ep.raw(sa,len);
return ep;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x3e8, %edi # imm = 0x3E8
callq 0x596b0
movq %rax, %rbx
movl $0x3e8, %edx # imm = 0x3E8
movq %rax, %rdi
xorl %esi, %esi
callq 0x583d0
movl $0x3e8, 0x4(%rsp) # imm = 0x3E8
movq %r14, %rdi
callq 0x5b020
movq %r12, %rdi
callq 0x57490
leaq 0x4(%rsp), %rdx
movl %eax, %edi
movq %rbx, %rsi
callq 0x58ae0
testl %eax, %eax
js 0x64fed
movl 0x4(%rsp), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58980
jmp 0x65002
callq 0x57130
movl (%rax), %eax
movq 0x709c5(%rip), %rcx # 0xd59c0
movl %eax, (%r15)
movq %rcx, 0x8(%r15)
movq %rbx, %rdi
callq 0x59580
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x65029
movq %rax, %r15
movq %r14, %rdi
callq 0x5a810
movq %rbx, %rdi
callq 0x59580
movq %r15, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/aio/src/basic_socket.cpp |
booster::aio::basic_socket::get_option(booster::aio::basic_socket::integer_option_type, std::error_code&) | int basic_socket::get_option(integer_option_type opt,system::error_code &e)
{
int value = 0;
socklen_t len = sizeof(value);
#ifdef BOOSTER_WIN32
char *ptr = reinterpret_cast<char *>(&value);
#else
int *ptr = &value;
#endif
int res = 0;
switch(opt) {
case receive_buffer_size:
res=::getsockopt(native(),SOL_SOCKET,SO_RCVBUF,ptr,&len);
break;
case send_buffer_size:
res=::getsockopt(native(),SOL_SOCKET,SO_SNDBUF,ptr,&len);
break;
default:
;
}
if(res < 0) {
e=geterror();
return false;
}
return value;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl $0x0, 0x8(%rsp)
movl $0x4, 0xc(%rsp)
xorl %ebx, %ebx
testl %esi, %esi
je 0x651e9
cmpl $0x1, %esi
jne 0x6522a
movl $0x7, %ebp
jmp 0x651ee
movl $0x8, %ebp
callq 0x57490
leaq 0x8(%rsp), %rcx
leaq 0xc(%rsp), %r8
movl %eax, %edi
movl $0x1, %esi
movl %ebp, %edx
callq 0x58bc0
testl %eax, %eax
js 0x65215
movl 0x8(%rsp), %ebx
jmp 0x6522a
callq 0x57130
movl (%rax), %eax
movq 0x7079d(%rip), %rcx # 0xd59c0
movl %eax, (%r14)
movq %rcx, 0x8(%r14)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/aio/src/basic_socket.cpp |
booster::aio::basic_socket::get_option(booster::aio::basic_socket::integer_option_type) | int basic_socket::get_option(integer_option_type opt)
{
system::error_code e;
int res = get_option(opt,e);
if(e) throw system::system_error(e);
return res;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
callq 0x58480
movq %rax, 0x8(%r15)
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x598e0
movl (%r15), %ebp
testl %ebp, %ebp
jne 0x65279
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x58050
movq %rax, %rbx
movq 0x10(%rsp), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x58130
movq 0x6d74c(%rip), %rsi # 0xd29e8
movq 0x6dc35(%rip), %rdx # 0xd2ed8
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/basic_socket.cpp |
booster::aio::basic_socket::get_option(booster::aio::basic_socket::boolean_option_type) | bool basic_socket::get_option(boolean_option_type opt)
{
system::error_code e;
bool res = get_option(opt,e);
if(e) throw system::system_error(e);
return res;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
callq 0x58480
movq %rax, 0x8(%r15)
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x572a0
movl (%r15), %ebp
testl %ebp, %ebp
jne 0x654c1
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x58050
movq %rax, %rbx
movq 0x10(%rsp), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x58130
movq 0x6d504(%rip), %rsi # 0xd29e8
movq 0x6d9ed(%rip), %rdx # 0xd2ed8
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/basic_socket.cpp |
booster::aio::stream_socket::shutdown(booster::aio::stream_socket::how_type, std::error_code&) | void stream_socket::shutdown(how_type how,system::error_code &e)
{
#ifndef SHUT_RDWR
#define SHUT_RDWR SD_BOTH
#endif
#ifndef SHUT_WR
#define SHUT_WR SD_SEND
#endif
#ifndef SHUT_RD
#define SHUT_RD SD_RECEIVE
#endif
int method = 0;
switch(how) {
case shut_rd: method = SHUT_RD; break;
case shut_wr: method = SHUT_WR; break;
case shut_rdwr: method = SHUT_RDWR; break;
}
int res = ::shutdown(native(),method);
if(res < 0)
e=geterror();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
xorl %eax, %eax
cmpl $0x1, %esi
sete %al
cmpl $0x2, %esi
cmovnel %eax, %ebp
callq 0x57490
movl %eax, %edi
movl %ebp, %esi
callq 0x5a6d0
testl %eax, %eax
jns 0x65ac2
callq 0x57130
movl (%rax), %eax
movq 0x6ff24(%rip), %rcx # 0xd59e0
movl %eax, (%rbx)
movq %rcx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/aio/src/stream_socket.cpp |
booster::aio::stream_socket::writev(booster::aio::const_buffer const&) | int stream_socket::writev(const_buffer const &b)
{
static const unsigned max_vec_size = 16;
const_buffer::buffer_data_type data = b.get();
unsigned size=0;
#ifndef BOOSTER_WIN32
struct iovec vec[max_vec_size];
for(;size < max_vec_size && size < data.second;size++) {
vec[size].iov_base = const_cast<char *>(data.first[size].ptr);
vec[size].iov_len = data.first[size].size;
}
for(;;) {
int ret = ::writev(native(),vec,size);
if(ret >= 0)
return ret;
if(ret < 0 && errno==EINTR)
continue;
return ret;
}
#else // Win32
WSABUF vec[max_vec_size];
for(;size < max_vec_size && size < data.second;size++) {
vec[size].buf = const_cast<char *>(data.first[size].ptr);
vec[size].len = data.first[size].size;
}
DWORD send=0;
int res = ::WSASend(native(),vec,size,&send,0,0,0);
if(res == 0)
return send;
return -1;
#endif
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x1, %eax
je 0x65cba
testl %eax, %eax
je 0x65cb5
movq 0x18(%rsi), %rax
movq 0x20(%rsi), %rcx
subq %rax, %rcx
je 0x65cb5
sarq $0x4, %rcx
jmp 0x65cc6
xorl %r14d, %r14d
jmp 0x65d01
addq $0x8, %rsi
movl $0x1, %ecx
movq %rsi, %rax
decq %rcx
cmpq $0xf, %rcx
movl $0xf, %r14d
cmovbq %rcx, %r14
movl %r14d, %ecx
shll $0x4, %ecx
addq $0x10, %rcx
xorl %edx, %edx
movq (%rax,%rdx), %rsi
movq %rsi, (%rsp,%rdx)
movq 0x8(%rax,%rdx), %rsi
movq %rsi, 0x8(%rsp,%rdx)
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x65ce3
incl %r14d
movq %rsp, %r15
movq %rbx, %rdi
callq 0x57490
movl %eax, %edi
movq %r15, %rsi
movl %r14d, %edx
callq 0x58330
movq %rax, %r12
testl %r12d, %r12d
jns 0x65d2b
callq 0x57130
cmpl $0x4, (%rax)
je 0x65d04
movl %r12d, %eax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/aio/src/stream_socket.cpp |
booster::aio::stream_socket::write_some(booster::aio::const_buffer const&) | size_t stream_socket::write_some(const_buffer const &buffer)
{
system::error_code e;
size_t r=write_some(buffer,e);
if(e)
throw system::system_error(e);
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
callq 0x58480
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x59500
movl (%r15), %ebp
testl %ebp, %ebp
jne 0x65e0d
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x58050
movq %rax, %rbx
movq 0x10(%rsp), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x58130
movq 0x6cbb8(%rip), %rsi # 0xd29e8
movq 0x6d0a1(%rip), %rdx # 0xd2ed8
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/stream_socket.cpp |
booster::aio::stream_socket::connect(booster::aio::endpoint const&, std::error_code&) | void stream_socket::connect(endpoint const &ep,system::error_code &e)
{
endpoint::native_address_type address = ep.raw();
#ifndef BOOSTER_WIN32
for(;;) {
int res = ::connect(native(),address.first,address.second);
if(res < 0 && errno==EINTR)
continue;
if(res < 0) {
e=geterror();
return;
}
break;
}
#else
if(::connect(native(),address.first,address.second) < 0)
e=geterror();
#endif
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5b230
movq %rax, %r15
movl %edx, %ebp
movq %r14, %rdi
callq 0x57490
movl %eax, %edi
movq %r15, %rsi
movl %ebp, %edx
callq 0x59030
testl %eax, %eax
jns 0x65e9d
callq 0x57130
movl (%rax), %eax
cmpl $0x4, %eax
je 0x65e6c
movq 0x6fb49(%rip), %rcx # 0xd59e0
movl %eax, (%rbx)
movq %rcx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /artyom-beilis[P]cppcms/booster/lib/aio/src/stream_socket.cpp |
booster::aio::stream_socket::write(booster::aio::const_buffer const&) | size_t stream_socket::write(const_buffer const &buf)
{
system::error_code e;
size_t n=write(buf,e);
if(e)
throw system::system_error(e);
return n;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
callq 0x58480
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5a480
movl (%r15), %ebp
testl %ebp, %ebp
jne 0x6621d
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x58050
movq %rax, %rbx
movq 0x10(%rsp), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x58130
movq 0x6c7a8(%rip), %rsi # 0xd29e8
movq 0x6cc91(%rip), %rdx # 0xd2ed8
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/stream_socket.cpp |
booster::aio::stream_socket::async_connect(booster::aio::endpoint const&, booster::callback<void (std::error_code const&)> const&) | void stream_socket::async_connect(endpoint const &ep,event_handler const &h)
{
if(!dont_block(h))
return;
system::error_code e;
connect(ep,e);
if(e && would_block(e)) {
async_connector::pointer connector(new async_connector(h,this));
on_writeable(std::move(connector));
}
else {
get_io_service().post(h,e);
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x57920
testb %al, %al
je 0x666ef
leaq 0x10(%rsp), %r12
movl $0x0, (%r12)
callq 0x58480
movq %rax, 0x8(%r12)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5a540
cmpl $0x0, (%r12)
je 0x666d7
leaq 0x10(%rsp), %rdi
callq 0x583c0
testb %al, %al
je 0x666d7
movl $0x20, %edi
callq 0x596b0
movq %rax, %r15
movq 0x6c642(%rip), %r13 # 0xd2cb8
addq $0x10, %r13
movq %r13, (%rax)
movq %rax, %r12
addq $0x8, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x58880
leaq 0x68d0b(%rip), %rax # 0xcf3a0
movq %rax, (%r15)
movq (%r14), %rdi
movq %rdi, 0x10(%r15)
testq %rdi, %rdi
je 0x666ad
addq $0x8, %rdi
callq 0x57ae0
movq %rbx, 0x18(%r15)
movq %r15, 0x8(%rsp)
movq %r12, %rdi
callq 0x57ae0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x57c70
leaq 0x8(%rsp), %rdi
callq 0x5bbe0
jmp 0x666ef
movq %rbx, %rdi
callq 0x5a040
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x58d50
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r13, (%r15)
movq %r12, %rdi
callq 0x583a0
jmp 0x66724
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5bbe0
jmp 0x6672c
movq %rax, %rbx
jmp 0x6672c
movq %rax, %rbx
movq %r15, %rdi
callq 0x59580
movq %rbx, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/stream_socket.cpp |
booster::aio::stream_socket::async_read(booster::aio::mutable_buffer const&, booster::callback<void (std::error_code const&, unsigned long)> const&) | void stream_socket::async_read(mutable_buffer const &buffer,io_handler const &h)
{
if(!dont_block(h))
return;
reader_all::pointer r(new reader_all(this,buffer,h));
r->run();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq %rdx, %rsi
callq 0x57510
testb %al, %al
je 0x668ee
movl $0x58, %edi
callq 0x596b0
movq %rax, %rbx
movq 0x6c549(%rip), %r14 # 0xd2cb8
addq $0x10, %r14
movq %r14, (%rax)
leaq 0x8(%rax), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x58880
leaq 0x68c54(%rip), %rax # 0xcf3e0
movq %rax, (%rbx)
movups (%r13), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x10(%r13), %rax
movq %rax, 0x20(%rbx)
leaq 0x28(%rbx), %rbp
addq $0x18, %r13
movq %rbp, %rdi
movq %r13, %rsi
callq 0x58fa0
movq $0x0, 0x40(%rbx)
movq %r12, 0x48(%rbx)
movq (%r15), %rdi
movq %rdi, 0x50(%rbx)
testq %rdi, %rdi
movq (%rsp), %r13
je 0x667d8
addq $0x8, %rdi
callq 0x57ae0
leaq 0x10(%rbx), %r15
movq %r13, %rdi
callq 0x57ae0
leaq 0x8(%rsp), %r12
movl $0x0, (%r12)
callq 0x58480
movq %rax, 0x8(%r12)
movq 0x48(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5a220
addq %rax, 0x40(%rbx)
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x59460
movq 0x28(%rsp), %rax
movq %rax, 0x10(%r15)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%r15)
movq 0x28(%rbx), %rdi
movups 0x30(%rsp), %xmm0
movups %xmm0, 0x28(%rbx)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
testq %rdi, %rdi
je 0x66870
callq 0x59580
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x66870
callq 0x59580
cmpl $0x0, (%r15)
je 0x668c5
cmpl $0x0, 0x8(%rsp)
je 0x6688b
leaq 0x8(%rsp), %rdi
callq 0x583c0
testb %al, %al
je 0x668c5
movq 0x48(%rbx), %r15
movq %r13, %rdi
callq 0x57ae0
movq %rbx, 0x18(%rsp)
movq %r13, %rdi
callq 0x57ae0
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x5a000
leaq 0x18(%rsp), %rdi
callq 0x5bbe0
movq %rbx, %rdi
callq 0x6695e
jmp 0x668e6
movq 0x48(%rbx), %rdi
callq 0x5a040
movq %rbx, %rsi
addq $0x50, %rsi
movq 0x40(%rbx), %rcx
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x57b20
movq %rbx, %rdi
callq 0x6695e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x5bbe0
jmp 0x6690f
movq %rax, %r15
movq %rbx, %rdi
callq 0x6695e
jmp 0x6694d
movq %rax, %r15
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x6692f
callq 0x59580
jmp 0x6692f
movq %rax, %r15
movq %r14, (%rbx)
movq (%rsp), %rdi
callq 0x583a0
jmp 0x66940
movq %rax, %r15
movq %rbx, %rdi
callq 0x59580
jmp 0x66955
movq %rax, %r15
movq %rbx, %rdi
callq 0x6695e
movq %r15, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/aio/src/stream_socket.cpp |
booster::aio::stream_socket::bytes_readable() | size_t stream_socket::bytes_readable()
{
booster::system::error_code e;
size_t r = bytes_readable(e);
if(e)
throw booster::system::system_error(e);
return r;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0x0, (%r14)
callq 0x58480
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b640
movl (%r14), %ebp
testl %ebp, %ebp
jne 0x66ccd
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x40, %edi
callq 0x58050
movq %rax, %rbx
movq 0x8(%rsp), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x58130
movq 0x6bcf8(%rip), %rsi # 0xd29e8
movq 0x6c1e1(%rip), %rdx # 0xd2ed8
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/stream_socket.cpp |
booster::aio::socket_pair(booster::aio::stream_socket&, booster::aio::stream_socket&) | void socket_pair(stream_socket &s1,stream_socket &s2)
{
#ifdef BOOSTER_AIO_NO_PF_UNIX
acceptor a;
a.open(pf_inet);
a.set_option(acceptor::reuse_address,true);
a.bind(endpoint("127.0.0.1",0));
a.listen(1);
s1.open(pf_inet);
s1.connect(a.local_endpoint());
a.accept(s2);
a.close();
#else
int fds[2];
if(::socketpair(AF_UNIX,SOCK_STREAM,0,fds) < 0)
throw system::system_error(geterror());
s1.assign(fds[0]);
s2.assign(fds[1]);
#endif
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rcx
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x592b0
testl %eax, %eax
js 0x66d6d
movl (%rsp), %esi
movq %r14, %rdi
callq 0x58fb0
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x58fb0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x40, %edi
callq 0x58050
movq %rax, %rbx
callq 0x57130
movl (%rax), %esi
movq 0x6ec58(%rip), %rdx # 0xd59e0
movq %rbx, %rdi
callq 0x58130
movq 0x6bc51(%rip), %rsi # 0xd29e8
movq 0x6c13a(%rip), %rdx # 0xd2ed8
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/aio/src/stream_socket.cpp |
booster::aio::(anonymous namespace)::writer_some::operator()(std::error_code const&) | void operator()(system::error_code const &e)
{
if(e) {
h(e,0);
}
else {
system::error_code err;
size_t n=sock->write_some(buf,err);
if(n==0 && err && basic_io_device::would_block(err))
sock->on_writeable(pointer(this));
else
h(err,n);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x66e68
addq $0x10, %rbx
movq %rbx, %rdi
xorl %edx, %edx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5a2c0
leaq 0x10(%rsp), %r14
movl $0x0, (%r14)
callq 0x58480
movq %rax, 0x8(%r14)
movq 0x48(%rbx), %rdi
leaq 0x18(%rbx), %rsi
movq %r14, %rdx
callq 0x59500
movq %rax, %r14
testq %rax, %rax
jne 0x66ee8
cmpl $0x0, 0x10(%rsp)
je 0x66ee8
leaq 0x10(%rsp), %rdi
callq 0x583c0
testb %al, %al
je 0x66ee8
movq 0x48(%rbx), %r14
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x57ae0
movq %rbx, 0x8(%rsp)
movq %r15, %rdi
callq 0x57ae0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x57c70
leaq 0x8(%rsp), %rdi
callq 0x5bbe0
movq %rbx, %rdi
callq 0x66404
jmp 0x66efc
addq $0x10, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5a2c0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5bbe0
jmp 0x66f18
movq %rax, %r14
movq %rbx, %rdi
callq 0x66404
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/stream_socket.cpp |
booster::aio::(anonymous namespace)::reader_all::operator()(std::error_code const&) | void operator()(system::error_code const &e)
{
if(e) {
h(e,count);
}
else {
system::error_code err;
size_t n=self->read_some(buf,err);
count+=n;
buf+=n;
if(buf.empty() || (err && !basic_io_device::would_block(err))) {
h(err,count);
}
else {
self->on_readable(intrusive_ptr<reader_all>(this));
}
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x67270
movq 0x40(%rbx), %rdx
addq $0x50, %rbx
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5a2c0
movq %rsp, %r15
movl $0x0, (%r15)
callq 0x58480
movq %rax, 0x8(%r15)
movq 0x48(%rbx), %rdi
leaq 0x10(%rbx), %r14
movq %r14, %rsi
movq %r15, %rdx
callq 0x5a220
addq %rax, 0x40(%rbx)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x59460
movq 0x10(%r15), %rax
movq %rax, 0x20(%rbx)
movups (%r15), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x28(%rbx), %rdi
movups 0x18(%r15), %xmm0
movups %xmm0, 0x28(%rbx)
movq 0x28(%r15), %rax
movq %rax, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq $0x0, 0x28(%r15)
testq %rdi, %rdi
je 0x672fb
callq 0x59580
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x672fb
callq 0x59580
cmpl $0x0, (%r14)
je 0x67351
cmpl $0x0, (%rsp)
je 0x67313
movq %rsp, %rdi
callq 0x583c0
testb %al, %al
je 0x67351
movq 0x48(%rbx), %r14
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x57ae0
movq %rbx, 0x10(%rsp)
movq %r15, %rdi
callq 0x57ae0
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x5a000
leaq 0x10(%rsp), %rdi
callq 0x5bbe0
movq %rbx, %rdi
callq 0x6695e
jmp 0x67364
movq 0x40(%rbx), %rdx
addq $0x50, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5a2c0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5bbe0
jmp 0x67380
movq %rax, %r14
movq %rbx, %rdi
callq 0x6695e
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/aio/src/stream_socket.cpp |
booster::log::sinks::syslog::syslog(int, int) | syslog::syslog(int opts,int facility) :
d(new data())
{
d->log_was_opened = true;
openlog(NULL,opts,facility);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movq 0x68c2a(%rip), %rax # 0xd2968
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movl $0x28, %edi
callq 0x596b0
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%r15)
movb $0x1, 0x20(%rax)
xorl %edi, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0x59280
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5b3d0
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/log/src/log.cpp |
booster::log::sinks::syslog::syslog(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int) | syslog::syslog(std::string const &id,int opts,int facility) :
d(new data())
{
d->id = id;
d->log_was_opened = true;
openlog(d->id.c_str(),opts,facility);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movq 0x68bb6(%rip), %rax # 0xd2968
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movl $0x28, %edi
callq 0x596b0
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
xorl %ecx, %ecx
movb %cl, 0x10(%rax)
movb %cl, 0x20(%rax)
movq %rax, 0x8(%r12)
movq %rax, %rdi
movq %r15, %rsi
callq 0x58370
movq (%rbx), %rax
movb $0x1, 0x20(%rax)
movq (%rax), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x59280
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5b3d0
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/log/src/log.cpp |
booster::log::sinks::syslog::syslog() | syslog::syslog() : d(new data())
{
} | pushq %rbx
movq %rdi, %rbx
movq 0x68b3f(%rip), %rax # 0xd2968
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x28, %edi
callq 0x596b0
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
xorl %ecx, %ecx
movb %cl, 0x10(%rax)
movb %cl, 0x20(%rax)
movq %rax, 0x8(%rbx)
popq %rbx
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/log/src/log.cpp |
booster::hold_ptr<booster::log::sinks::syslog::data>::~hold_ptr() | ~hold_ptr()
{
if(ptr_) delete ptr_;
} | pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x6a16b
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x6a162
callq 0x59580
movq %rbx, %rdi
popq %rbx
jmp 0x59580
popq %rbx
retq
nop
| /artyom-beilis[P]cppcms/booster/./booster/hold_ptr.h |
booster::streambuf::~streambuf() | streambuf::~streambuf()
{
} | pushq %rbx
movq %rdi, %rbx
movq 0x68511(%rip), %rax # 0xd2b38
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x6a640
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x80(%rbx)
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x6a659
callq 0x59580
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x6a667
callq 0x59580
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x6a675
callq 0x59580
movq 0x68494(%rip), %rax # 0xd2b10
addq $0x10, %rax
movq %rax, (%rbx)
addq $0x38, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x5a8f0
| /artyom-beilis[P]cppcms/booster/lib/iostreams/src/streambuf.cpp |
booster::streambuf::overflow(int) | int streambuf::overflow(int c)
{
if(pptr()==pbase()) {
buffer_out_.resize(buffer_size_+1,0);
setp(&buffer_out_.front(),&buffer_out_.front()+buffer_size_);
if(c!=EOF) {
sputc(c);
}
return 0;
}
std::streamsize n=pptr() - pbase();
std::streamsize real_size = n;
if(c!=EOF) {
*pptr()=c;
real_size++;
}
if(real_size > 0) {
size_t res = device().write(pbase(),real_size);
if(std::streamsize(res) != real_size) {
pbump(res);
return EOF;
}
}
pbump(-n);
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq %rax, %r15
subq 0x20(%rdi), %r15
je 0x6a701
movq %r15, %r14
cmpl $-0x1, %ebp
je 0x6a6ca
movb %bpl, (%rax)
leaq 0x1(%r15), %r14
testq %r14, %r14
jle 0x6a747
movq %rbx, %rdi
callq 0x594c0
movq 0x20(%rbx), %rsi
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rdx
callq *0x8(%rcx)
movq 0x28(%rbx), %rcx
cmpq %r14, %rax
je 0x6a74b
cltq
addq %rax, %rcx
movq %rcx, 0x28(%rbx)
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jmp 0x6a75b
leaq 0x40(%rbx), %rdi
movq 0x70(%rbx), %rsi
incq %rsi
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
callq 0x58fc0
movq 0x40(%rbx), %rax
movq 0x70(%rbx), %rcx
leaq (%rax,%rcx), %rdx
movq %rax, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movq %rdx, 0x30(%rbx)
xorl %r14d, %r14d
cmpl $-0x1, %ebp
je 0x6a75b
testq %rcx, %rcx
jle 0x6a769
movb %bpl, (%rax)
incq 0x28(%rbx)
jmp 0x6a75b
movq 0x28(%rbx), %rcx
negl %r15d
movslq %r15d, %rax
addq %rcx, %rax
movq %rax, 0x28(%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
jmp 0x6a75b
| /artyom-beilis[P]cppcms/booster/lib/iostreams/src/streambuf.cpp |
booster::streambuf::underflow() | int streambuf::underflow()
{
if(buffer_in_.empty() || buffer_in_.size() > buffer_size_)
buffer_in_.resize(buffer_size_);
char *buf_ptr = &buffer_in_.front();
std::streamsize n=device().read(buf_ptr,buffer_in_.size());
setg(buf_ptr,buf_ptr,buf_ptr+n);
if(n==0)
return EOF;
return *buf_ptr;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %r14
movq 0x60(%rdi), %rax
cmpq %rax, %r14
je 0x6a80e
subq %r14, %rax
movq 0x70(%rbx), %rsi
cmpq %rsi, %rax
ja 0x6a812
jmp 0x6a821
movq 0x70(%rbx), %rsi
leaq 0x58(%rbx), %r14
movq %r14, %rdi
callq 0x5b720
movq (%r14), %r14
movq %rbx, %rdi
callq 0x594c0
movq 0x60(%rbx), %rdx
subq 0x58(%rbx), %rdx
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
callq *(%rcx)
leaq (%r14,%rax), %rcx
movq %r14, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rcx, 0x18(%rbx)
movsbl (%r14), %edx
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
orl %edx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /artyom-beilis[P]cppcms/booster/lib/iostreams/src/streambuf.cpp |
booster::streambuf::device(std::unique_ptr<booster::io_device, std::default_delete<booster::io_device>>) | void streambuf::device(std::unique_ptr<io_device> d)
{
reset_device();
device_unique_ptr_=std::move(d);
device_ = device_unique_ptr_.get();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x80(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rbx)
testq %rdi, %rdi
je 0x6a96a
movq (%rdi), %rax
callq *0x20(%rax)
movq (%r14), %rax
movq $0x0, (%r14)
movq 0x80(%rbx), %rdi
movq %rax, 0x80(%rbx)
testq %rdi, %rdi
je 0x6a994
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x80(%rbx), %rax
movq %rax, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/iostreams/src/streambuf.cpp |
booster::stack_trace::get_symbol[abi:cxx11](void*) | std::string get_symbol(void *ptr)
{
if(!ptr)
return std::string();
std::ostringstream res;
res.imbue(std::locale::classic());
res << ptr<<": ";
Dl_info info = Dl_info();
if(dladdr(ptr,&info) == 0) {
res << "???";
}
else {
if(info.dli_sname) {
int status = 0;
char *demangled = abi::__cxa_demangle(info.dli_sname,0,0,&status);
if(demangled) {
res << demangled;
free(demangled);
}
else {
res << info.dli_sname;
}
}
else {
res << "???";
}
unsigned offset = (char *)ptr - (char *)info.dli_saddr;
res << std::hex <<" + 0x" << offset ;
if(info.dli_fname)
res << " in " << info.dli_fname;
}
return res.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, %rbx
testq %rsi, %rsi
je 0x6afc3
movq %rsi, %r14
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x5a4f0
movq (%r15), %rax
movq -0x18(%rax), %r15
callq 0x5a500
leaq (%rsp,%r15), %rsi
addq $0x38, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x577e0
movq %rsp, %rdi
callq 0x5a8f0
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x58cc0
leaq 0x4062f(%rip), %rsi # 0xab57f
movl $0x2, %edx
movq %rax, %rdi
callq 0x59d10
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %r14, %rdi
callq 0x57ff0
testl %eax, %eax
je 0x6afdb
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x6aff6
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
xorl %esi, %esi
xorl %edx, %edx
callq 0x59200
movq %rax, %r15
testq %rax, %rax
je 0x6b00e
movq %r15, %rdi
callq 0x57e60
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x59d10
movq %r15, %rdi
callq 0x59f70
jmp 0x6b04e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x6b117
leaq 0x409b5(%rip), %rsi # 0xab997
leaq 0x38(%rsp), %rdi
movl $0x3, %edx
callq 0x59d10
jmp 0x6b0ec
leaq 0x4099a(%rip), %rsi # 0xab997
leaq 0x38(%rsp), %rdi
movl $0x3, %edx
callq 0x59d10
jmp 0x6b04e
movq 0x20(%rsp), %r15
testq %r15, %r15
je 0x6b032
movq %r15, %rdi
callq 0x57e60
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x59d10
jmp 0x6b04e
movq 0x38(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x38, %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x5b560
movq 0x28(%rsp), %r15
leaq 0x38(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x50(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x50(%rsp,%rax)
leaq 0x40927(%rip), %rsi # 0xab99b
movl $0x5, %edx
callq 0x59d10
subl %r15d, %r14d
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x58900
cmpq $0x0, 0x10(%rsp)
je 0x6b0ec
leaq 0x40904(%rip), %rsi # 0xab9a1
leaq 0x38(%rsp), %rdi
movl $0x4, %edx
callq 0x59d10
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x6b0d0
movq %r14, %rdi
callq 0x57e60
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x59d10
jmp 0x6b0ec
movq 0x38(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x38, %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x5b560
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x5b100
movq 0x67bc8(%rip), %rsi # 0xd2cc8
leaq 0x38(%rsp), %rdi
callq 0x58310
leaq 0xa8(%rsp), %rdi
callq 0x57a70
movq %rbx, %rax
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6b12d
jmp 0x6b12d
jmp 0x6b12d
movq %rax, %rbx
movq 0x67b91(%rip), %rsi # 0xd2cc8
leaq 0x38(%rsp), %rdi
callq 0x58310
leaq 0xa8(%rsp), %rdi
callq 0x57a70
movq %rbx, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/backtrace/src/backtrace.cpp |
booster::stack_trace::write_symbols(void* const*, int, std::ostream&) | void write_symbols(void *const *addresses,int size,std::ostream &out)
{
for(int i=0;i<size;i++) {
std::string tmp = get_symbol(addresses[i]);
if(!tmp.empty()) {
out << tmp << '\n';
}
}
out << std::flush;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
testl %esi, %esi
jle 0x6b292
movq %rdi, %r14
leaq 0x18(%rsp), %r13
movl %esi, %ebp
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
callq 0x59d40
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x6b27b
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x59d10
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0x7(%rsp), %rsi
callq 0x59d10
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6b28a
callq 0x59580
incq %r12
cmpq %r12, %rbp
jne 0x6b241
movq %rbx, %rdi
callq 0x58910
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6b2bb
callq 0x59580
movq %rbx, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/backtrace/src/backtrace.cpp |
booster::locale::conv::impl::normalize_encoding[abi:cxx11](char const*) | std::string normalize_encoding(char const *ccharset)
{
std::string charset;
charset.reserve(std::strlen(ccharset));
while(*ccharset!=0) {
char c=*ccharset++;
if('0' <= c && c<= '9')
charset+=c;
else if('a' <=c && c <='z')
charset+=c;
else if('A' <=c && c <='Z')
charset+=char(c-'A'+'a');
}
return charset;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x57e60
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5afd0
movb (%r14), %al
testb %al, %al
je 0x6b5b5
incq %r14
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
setb %cl
leal -0x61(%rax), %edx
cmpb $0x1a, %dl
setb %dl
orb %cl, %dl
jne 0x6b5a0
leal -0x41(%rax), %ecx
cmpb $0x19, %cl
ja 0x6b5ab
orb $0x20, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x59120
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x6b580
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6b5c0
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6b5d0
callq 0x59580
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/encoding/codepage.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> booster::locale::conv::impl::convert_to<char>(char const*, char const*, char const*, booster::locale::conv::method_type) | std::basic_string<CharType> convert_to(
char const *begin,
char const *end,
char const *charset,
method_type how)
{
std::unique_ptr<converter_to_utf<CharType> > cvt;
#ifdef BOOSTER_LOCALE_WITH_ICONV
cvt.reset(new iconv_to_utf<CharType>());
if(cvt->open(charset,how))
return cvt->convert(begin,end);
#endif
#ifdef BOOSTER_LOCALE_WITH_ICU
cvt.reset(new uconv_to_utf<CharType>());
if(cvt->open(charset,how))
return cvt->convert(begin,end);
#endif
#ifdef BOOSTER_LOCALE_WITH_WCONV
cvt.reset(new wconv_to_utf<CharType>());
if(cvt->open(charset,how))
return cvt->convert(begin,end);
#endif
throw invalid_charset_error(charset);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %r15d
movq %rcx, %rbp
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r14
movl $0x18, %edi
callq 0x596b0
movq %rax, %r13
movq $0x0, 0x10(%rax)
movq 0x67422(%rip), %rax # 0xd2b08
addq $0x10, %rax
movq %rax, (%r13)
movq $-0x1, 0x8(%r13)
leaq 0x8(%r13), %rdi
leaq 0x402dc(%rip), %rsi # 0xab9dd
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x586a0
testb %al, %al
je 0x6b727
movq (%r13), %rax
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
callq *0x8(%rax)
jmp 0x6b77f
movl $0x18, %edi
callq 0x596b0
movq %rax, %rbx
movq 0x67465(%rip), %rax # 0xd2ba0
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq (%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq (%rbx), %rax
movq %rbx, %r13
movq %rbx, %rdi
movq %rbp, %rsi
movl %r15d, %edx
callq *(%rax)
testb %al, %al
je 0x6b79b
movq (%rbx), %rax
movq %rbx, %r13
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
callq *0x8(%rax)
movq (%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %r14
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rbp, %rsi
callq 0x57c90
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x578a0
xorl %ebp, %ebp
movq 0x67205(%rip), %rsi # 0xd29d8
movq 0x6779e(%rip), %rdx # 0xd2f78
movq %r14, %rdi
callq 0x5b600
movq %rax, %r15
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b7f8
callq 0x59580
testb %bpl, %bpl
jne 0x6b802
jmp 0x6b812
movq %rax, %r15
movq %r14, %rdi
callq 0x58a30
jmp 0x6b812
movq %rax, %r15
movq %r13, %rbx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r15, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/encoding/codepage.cpp |
std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> booster::locale::conv::impl::convert_to<wchar_t>(char const*, char const*, char const*, booster::locale::conv::method_type) | std::basic_string<CharType> convert_to(
char const *begin,
char const *end,
char const *charset,
method_type how)
{
std::unique_ptr<converter_to_utf<CharType> > cvt;
#ifdef BOOSTER_LOCALE_WITH_ICONV
cvt.reset(new iconv_to_utf<CharType>());
if(cvt->open(charset,how))
return cvt->convert(begin,end);
#endif
#ifdef BOOSTER_LOCALE_WITH_ICU
cvt.reset(new uconv_to_utf<CharType>());
if(cvt->open(charset,how))
return cvt->convert(begin,end);
#endif
#ifdef BOOSTER_LOCALE_WITH_WCONV
cvt.reset(new wconv_to_utf<CharType>());
if(cvt->open(charset,how))
return cvt->convert(begin,end);
#endif
throw invalid_charset_error(charset);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %r15d
movq %rcx, %rbp
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r14
movl $0x18, %edi
callq 0x596b0
movq %rax, %r13
movq $0x0, 0x10(%rax)
movq 0x67472(%rip), %rax # 0xd2e48
addq $0x10, %rax
movq %rax, (%r13)
movq $-0x1, 0x8(%r13)
leaq 0x8(%r13), %rdi
leaq 0x3fff2(%rip), %rsi # 0xab9e3
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x586a0
testb %al, %al
je 0x6ba17
movq (%r13), %rax
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
callq *0x8(%rax)
jmp 0x6ba6f
movl $0x18, %edi
callq 0x596b0
movq %rax, %rbx
movq 0x66fd5(%rip), %rax # 0xd2a00
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq (%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq (%rbx), %rax
movq %rbx, %r13
movq %rbx, %rdi
movq %rbp, %rsi
movl %r15d, %edx
callq *(%rax)
testb %al, %al
je 0x6ba8b
movq (%rbx), %rax
movq %rbx, %r13
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
callq *0x8(%rax)
movq (%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %r14
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rbp, %rsi
callq 0x57c90
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x578a0
xorl %ebp, %ebp
movq 0x66f15(%rip), %rsi # 0xd29d8
movq 0x674ae(%rip), %rdx # 0xd2f78
movq %r14, %rdi
callq 0x5b600
movq %rax, %r15
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bae8
callq 0x59580
testb %bpl, %bpl
jne 0x6baf2
jmp 0x6bb02
movq %rax, %r15
movq %r14, %rdi
callq 0x58a30
jmp 0x6bb02
movq %rax, %r15
movq %r13, %rbx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r15, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/encoding/codepage.cpp |
booster::locale::conv::conversion_error::conversion_error() | conversion_error() : booster::runtime_error("Conversion failed") {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3fa77(%rip), %rsi # 0xab9ab
leaq 0x3fa81(%rip), %rdx # 0xab9bc
movq %rsp, %r14
movq %r14, %rdi
callq 0x57c80
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ad60
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6bf5f
callq 0x59580
movq 0x66b4a(%rip), %rax # 0xd2ab0
leaq 0x10(%rax), %rcx
movq %rcx, (%rbx)
addq $0x38, %rax
movq %rax, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6bf90
callq 0x59580
movq %rbx, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/./booster/locale/encoding_errors.h |
booster::locale::impl_icu::icu_std_converter<char, 1>::uconv::uconv(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, booster::locale::impl_icu::cpcvt_type) | uconv(std::string const &charset,cpcvt_type cvt_type=cvt_skip)
{
UErrorCode err=U_ZERO_ERROR;
cvt_ = ucnv_open(charset.c_str(),&err);
if(!cvt_ || U_FAILURE(err)) {
if(cvt_)
ucnv_close(cvt_);
throw conv::invalid_charset_error(charset);
}
try {
if(cvt_type==cvt_skip) {
ucnv_setFromUCallBack(cvt_,UCNV_FROM_U_CALLBACK_SKIP,0,0,0,&err);
check_and_throw_icu_error(err);
err=U_ZERO_ERROR;
ucnv_setToUCallBack(cvt_,UCNV_TO_U_CALLBACK_SKIP,0,0,0,&err);
check_and_throw_icu_error(err);
}
else {
ucnv_setFromUCallBack(cvt_,UCNV_FROM_U_CALLBACK_STOP,0,0,0,&err);
check_and_throw_icu_error(err);
err=U_ZERO_ERROR;
ucnv_setToUCallBack(cvt_,UCNV_TO_U_CALLBACK_STOP,0,0,0,&err);
check_and_throw_icu_error(err);
}
}
catch(...) { ucnv_close(cvt_) ; throw; }
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq (%r14), %rdi
callq 0x5a580
movq %rax, (%rbx)
testq %rax, %rax
je 0x6c56b
cmpl $0x0, 0x4(%rsp)
jg 0x6c563
testl %ebp, %ebp
je 0x6c503
movq 0x666e1(%rip), %rsi # 0xd2b48
leaq 0x4(%rsp), %r9
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5b4c0
movl 0x4(%rsp), %ebp
testl %ebp, %ebp
jg 0x6c5c2
leaq 0x4(%rsp), %r9
movl $0x0, (%r9)
movq (%rbx), %rdi
movq 0x66623(%rip), %rsi # 0xd2ac0
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x59530
movl 0x4(%rsp), %ebp
testl %ebp, %ebp
jle 0x6c558
movl $0x30, %edi
callq 0x58050
movq %rax, %r15
movl %ebp, %edi
callq 0x59fa0
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
movq %rax, %rsi
callq 0x57c90
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x665f4(%rip), %rsi # 0xd2ae8
movq 0x66a7d(%rip), %rdx # 0xd2f78
movq %r15, %rdi
callq 0x5b600
movq 0x66a66(%rip), %rsi # 0xd2f70
leaq 0x4(%rsp), %r9
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5b4c0
movl 0x4(%rsp), %ebp
testl %ebp, %ebp
jg 0x6c610
leaq 0x4(%rsp), %r9
movl $0x0, (%r9)
movq (%rbx), %rdi
movq 0x663f0(%rip), %rsi # 0xd2930
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x59530
movl 0x4(%rsp), %ebp
testl %ebp, %ebp
jg 0x6c65e
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x589e0
movl $0x30, %edi
callq 0x58050
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x57cc0
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x578a0
xorl %ebp, %ebp
movq 0x6642a(%rip), %rsi # 0xd29d8
movq 0x669c3(%rip), %rdx # 0xd2f78
movq %rbx, %rdi
callq 0x5b600
jmp 0x6c728
movl $0x30, %edi
callq 0x58050
movq %rax, %r15
movl %ebp, %edi
callq 0x59fa0
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
movq %rax, %rsi
callq 0x57c90
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x664e7(%rip), %rsi # 0xd2ae8
movq 0x66970(%rip), %rdx # 0xd2f78
movq %r15, %rdi
callq 0x5b600
movl $0x30, %edi
callq 0x58050
movq %rax, %r15
movl %ebp, %edi
callq 0x59fa0
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
movq %rax, %rsi
callq 0x57c90
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x66499(%rip), %rsi # 0xd2ae8
movq 0x66922(%rip), %rdx # 0xd2f78
movq %r15, %rdi
callq 0x5b600
movl $0x30, %edi
callq 0x58050
movq %rax, %r15
movl %ebp, %edi
callq 0x59fa0
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
movq %rax, %rsi
callq 0x57c90
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x6644b(%rip), %rsi # 0xd2ae8
movq 0x668d4(%rip), %rdx # 0xd2f78
movq %r15, %rdi
callq 0x5b600
jmp 0x6c6b8
jmp 0x6c6dd
jmp 0x6c6b8
jmp 0x6c6dd
jmp 0x6c6b8
jmp 0x6c6dd
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c6ce
callq 0x59580
testb %bpl, %bpl
jne 0x6c6e0
jmp 0x6c713
jmp 0x6c6dd
jmp 0x6c6dd
jmp 0x6c6dd
jmp 0x6c6dd
movq %rax, %r14
movq %r15, %rdi
callq 0x58a30
jmp 0x6c713
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x6c6fc
callq 0x59580
testb %bpl, %bpl
jne 0x6c706
jmp 0x6c730
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
jmp 0x6c730
movq %rax, %r14
movq %r14, %rdi
callq 0x57d10
movq (%rbx), %rdi
callq 0x589e0
callq 0x5ab20
movq %rax, %r14
callq 0x5b340
movq %r14, %rdi
callq 0x5b810
movq %rax, %rdi
callq 0x5f195
| /artyom-beilis[P]cppcms/booster/lib/locale/src/encoding/../icu/uconv.h |
booster::locale::impl_icu::icu_std_converter<char, 1>::icu(char const*, char const*) const | icu::UnicodeString icu(char_type const *vb,char_type const *ve) const
{
char const *begin=reinterpret_cast<char const *>(vb);
char const *end=reinterpret_cast<char const *>(ve);
uconv cvt(charset_,cvt_type_);
UErrorCode err=U_ZERO_ERROR;
icu::UnicodeString tmp(begin,end-begin,cvt.cvt(),err);
check_and_throw_icu_error(err);
return tmp;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movl 0x28(%rsi), %edx
addq $0x8, %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x5be90
leaq 0x4(%rsp), %r8
movl $0x0, (%r8)
subl %r15d, %r14d
movq (%r12), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x5aed0
movl 0x4(%rsp), %ebp
testl %ebp, %ebp
jg 0x6c842
movq 0x8(%rsp), %rdi
callq 0x589e0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %r14
movl %ebp, %edi
callq 0x59fa0
leaq 0x10(%rsp), %rdi
leaq 0x3(%rsp), %rdx
movq %rax, %rsi
callq 0x57c90
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x66267(%rip), %rsi # 0xd2ae8
movq 0x666f0(%rip), %rdx # 0xd2f78
movq %r14, %rdi
callq 0x5b600
movq %rax, %r15
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c8a6
callq 0x59580
testb %bpl, %bpl
jne 0x6c8b2
jmp 0x6c8ba
jmp 0x6c8af
movq %rax, %r15
movq %r14, %rdi
callq 0x58a30
movq %rbx, %rdi
callq 0x5a310
jmp 0x6c8c9
jmp 0x6c8db
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0x589e0
movq %r15, %rdi
callq 0x5b810
movq %rax, %rdi
callq 0x5f195
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/encoding/../icu/uconv.h |
booster::locale::impl_icu::icu_std_converter<wchar_t, 4>::std[abi:cxx11](icu_70::UnicodeString const&) const | string_type std(icu::UnicodeString const &str) const
{
string_type tmp;
tmp.resize(str.length());
UChar32 *ptr=reinterpret_cast<UChar32 *>(&tmp[0]);
#ifdef __SUNPRO_CC
int len=0;
#else
::int32_t len=0;
#endif
UErrorCode code=U_ZERO_ERROR;
u_strToUTF32(ptr,tmp.size(),&len,str.getBuffer(),str.length(),&code);
check_and_throw_icu_error(code);
tmp.resize(len);
return tmp;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movswl 0x8(%rdx), %eax
testw %ax, %ax
jns 0x6d6df
movl 0xc(%r14), %eax
jmp 0x6d6e2
sarl $0x5, %eax
movslq %eax, %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5bc20
movq (%rbx), %rdi
movl %r15d, 0xc(%rsp)
movl %r15d, 0x8(%rsp)
movzwl 0x8(%r14), %eax
testb $0x11, %al
jne 0x6d716
testb $0x2, %al
jne 0x6d712
movq 0x18(%r14), %r15
jmp 0x6d716
leaq 0xa(%r14), %r15
movq 0x8(%rbx), %rsi
testw %ax, %ax
jns 0x6d725
movl 0xc(%r14), %r8d
jmp 0x6d72d
movswl %ax, %r8d
sarl $0x5, %r8d
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %r9
movq %r15, %rcx
callq 0x5ac80
movl 0x8(%rsp), %ebp
testl %ebp, %ebp
jg 0x6d766
movslq 0xc(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5bc20
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %r14
movl %ebp, %edi
callq 0x59fa0
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x57c90
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x65343(%rip), %rsi # 0xd2ae8
movq 0x657cc(%rip), %rdx # 0xd2f78
movq %r14, %rdi
callq 0x5b600
movq %rax, %r15
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d7ca
callq 0x59580
testb %bpl, %bpl
jne 0x6d7d6
jmp 0x6d7e5
jmp 0x6d7d3
movq %rax, %r15
movq %r14, %rdi
callq 0x58a30
jmp 0x6d7e5
jmp 0x6d7e2
movq %rax, %r15
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6d7f2
callq 0x59580
movq %r15, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/encoding/../icu/uconv.h |
booster::locale::calendar::calendar() | calendar::calendar() :
tz_(time_zone::global()),
impl_(std::use_facet<calendar_facet>(std::locale()).create_calendar())
{
impl_->set_timezone(tz_);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x5c080
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x58df0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5c080
movq %r15, %rdi
callq 0x599d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x28(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x5a8f0
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x50(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x6e16e
movq (%rdi), %rax
callq *0x70(%rax)
jmp 0x6e16e
movq %rax, %r14
jmp 0x6e180
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5a8f0
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x6e180
callq 0x59580
movq %rbx, %rdi
callq 0x5a8f0
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::calendar::~calendar() | calendar::~calendar()
{
} | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x6e1a3
movq (%rdi), %rax
callq *0x70(%rax)
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x6e1b5
callq 0x59580
movq %rbx, %rdi
popq %rbx
jmp 0x5a8f0
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::calendar::calendar(booster::locale::calendar const&) | calendar::calendar(calendar const &other) :
locale_(other.locale_),
tz_(other.tz_),
impl_(other.impl_->clone())
{
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x586b0
leaq 0x8(%rbx), %r14
leaq 0x18(%rbx), %r12
movq %r12, 0x8(%rbx)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x57cc0
movq 0x28(%r15), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x6e21e
callq 0x59580
jmp 0x6e21e
movq %rax, %r15
movq %rbx, %rdi
callq 0x5a8f0
movq %r15, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::calendar::operator=(booster::locale::calendar const&) | calendar const &calendar::operator = (calendar const &other)
{
if(this !=&other) {
impl_.reset(other.impl_->clone());
locale_ = other.locale_;
tz_ = other.tz_;
}
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x6e278
movq %rsi, %r14
movq 0x28(%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r15
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x6e259
movq (%rdi), %rax
callq *0x70(%rax)
movq %r15, 0x28(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x59ac0
addq $0x8, %r14
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x58370
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::calendar::get_time_zone[abi:cxx11]() const | std::string calendar::get_time_zone() const
{
return tz_;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x57cc0
movq %rbx, %rax
popq %rbx
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::date_time() | date_time::date_time() :
impl_(std::use_facet<calendar_facet>(std::locale()).create_calendar())
{
impl_->set_timezone(time_zone::global());
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5c080
movq %r14, %rdi
callq 0x599d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x5a8f0
movq (%rbx), %r14
leaq 0x8(%rsp), %rdi
callq 0x58df0
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x50(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e3af
callq 0x59580
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e3d2
callq 0x59580
jmp 0x6e3d2
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6e3ef
movq (%rdi), %rax
callq *0x70(%rax)
jmp 0x6e3ef
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5a8f0
movq %r14, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::operator=(booster::locale::date_time const&) | date_time const &date_time::operator = (date_time const &other)
{
if(this != &other) {
date_time tmp(other);
swap(tmp);
}
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x6e511
movq %rsp, %r14
movq %r14, %rdi
callq 0x59b30
movq (%r14), %rax
movq (%rbx), %rcx
movq %rcx, (%r14)
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x5b2d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::time(double) | void date_time::time(double v)
{
double dseconds = floor(v);
int64_t seconds = static_cast<int64_t>(dseconds);
double fract = v - dseconds;
int nano = static_cast<int>(fract * 1e9);
if(nano < 0)
nano = 0;
else if(nano >999999999)
nano = 999999999;
posix_time ptime;
ptime.seconds = seconds;
ptime.nanoseconds = nano;
impl_->set_time(ptime);
} | pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x5b540
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x3c9ad(%rip), %xmm1 # 0xab008
cvttsd2si %xmm1, %eax
movl $0x3b9ac9ff, %ecx # imm = 0x3B9AC9FF
cmpl %ecx, %eax
cmovll %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
cvttsd2si %xmm0, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
movl %eax, 0x8(%rsi)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x20, %rsp
popq %rbx
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::date_time(booster::locale::date_time_period_set const&) | date_time::date_time(date_time_period_set const &s) :
impl_(std::use_facet<calendar_facet>(std::locale()).create_calendar())
{
impl_->set_timezone(time_zone::global());
for(unsigned i=0;i<s.size();i++) {
impl_->set_value(s[i].type.mark(),s[i].value);
}
impl_->normalize();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x5c080
movq %r15, %rdi
callq 0x599d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, (%rbx)
movq %rsp, %rdi
callq 0x5a8f0
movq (%rbx), %r15
movq %rsp, %rdi
callq 0x58df0
movq (%r15), %rax
movq %rsp, %rsi
movq %r15, %rdi
callq *0x50(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e78d
callq 0x59580
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x5ba50
movl %r15d, %r15d
movq (%rbx), %r12
cmpq %r15, %rax
jbe 0x6e7cf
movq %r14, %rdi
movq %r15, %rsi
callq 0x5bb30
movl (%rax), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x5bb30
movl 0x4(%rax), %edx
movq (%r12), %rax
movq %r12, %rdi
movl %ebp, %esi
callq *0x8(%rax)
incl %r15d
jmp 0x6e790
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e80f
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6e812
callq 0x59580
jmp 0x6e812
jmp 0x6e80f
movq %rax, %r14
movq %rsp, %rdi
callq 0x5a8f0
jmp 0x6e820
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6e820
movq (%rdi), %rax
callq *0x70(%rax)
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::date_time(booster::locale::date_time_period_set const&, booster::locale::calendar const&) | date_time::date_time(date_time_period_set const &s,calendar const &cal) :
impl_(cal.impl_->clone())
{
for(unsigned i=0;i<s.size();i++) {
impl_->set_value(s[i].type.mark(),s[i].value);
}
impl_->normalize();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, (%rbx)
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x5ba50
movl %r15d, %r15d
movq (%rbx), %r12
cmpq %r15, %rax
jbe 0x6e884
movq %r14, %rdi
movq %r15, %rsi
callq 0x5bb30
movl (%rax), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x5bb30
movl 0x4(%rax), %edx
movq (%r12), %rax
movq %r12, %rdi
movl %ebp, %esi
callq *0x8(%rax)
incl %r15d
jmp 0x6e845
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e899
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6e8aa
movq (%rdi), %rax
callq *0x70(%rax)
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::operator=(booster::locale::date_time_period_set const&) | date_time const &date_time::operator=(date_time_period_set const &s)
{
for(unsigned i=0;i<s.size();i++)
impl_->set_value(s[i].type.mark(),s[i].value);
impl_->normalize();
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5ba50
testq %rax, %rax
je 0x6e916
movl $0x1, %r13d
xorl %r15d, %r15d
movq (%rbx), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x5bb30
movl (%rax), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x5bb30
movl 0x4(%rax), %edx
movq (%r12), %rax
movq %r12, %rdi
movl %ebp, %esi
callq *0x8(%rax)
movl %r13d, %r15d
movq %r14, %rdi
callq 0x5ba50
incl %r13d
cmpq %r15, %rax
ja 0x6e8d9
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::operator+=(booster::locale::date_time_period_set const&) | date_time const &date_time::operator+=(date_time_period_set const &v)
{
for(unsigned i=0;i<v.size();i++) {
*this+=v[i];
}
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5ba50
testq %rax, %rax
je 0x6eb67
movl $0x1, %ebp
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5bb30
movq (%rbx), %rdi
movl (%rax), %esi
movl 0x4(%rax), %ecx
movq (%rdi), %rax
xorl %edx, %edx
callq *0x40(%rax)
movl %ebp, %r15d
movq %r14, %rdi
callq 0x5ba50
incl %ebp
cmpq %r15, %rax
ja 0x6eb3a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::operator-=(booster::locale::date_time_period_set const&) | date_time const &date_time::operator-=(date_time_period_set const &v)
{
for(unsigned i=0;i<v.size();i++) {
*this-=v[i];
}
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5ba50
testq %rax, %rax
je 0x6ebff
movl $0x1, %ebp
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5bb30
movq (%rbx), %rdi
movl (%rax), %esi
xorl %ecx, %ecx
subl 0x4(%rax), %ecx
movq (%rdi), %rax
xorl %edx, %edx
callq *0x40(%rax)
movl %ebp, %r15d
movq %r14, %rdi
callq 0x5ba50
incl %ebp
cmpq %r15, %rax
ja 0x6ebd0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::operator>>=(booster::locale::date_time_period_set const&) | date_time const &date_time::operator>>=(date_time_period_set const &v)
{
for(unsigned i=0;i<v.size();i++) {
*this>>=v[i];
}
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5ba50
testq %rax, %rax
je 0x6ed32
movl $0x1, %ebp
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5bb30
movq (%rbx), %rdi
movl (%rax), %esi
xorl %ecx, %ecx
subl 0x4(%rax), %ecx
movq (%rdi), %rax
movl $0x1, %edx
callq *0x40(%rax)
movl %ebp, %r15d
movq %r14, %rdi
callq 0x5ba50
incl %ebp
cmpq %r15, %rax
ja 0x6ed00
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::operator==(booster::locale::date_time const&) const | bool date_time::operator==(date_time const &other) const
{
return compare(impl_->get_time(),other.impl_->get_time()) == 0;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, %r14
movl %edx, %ebp
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpq %rax, %r14
sete %cl
cmpl %edx, %ebp
sete %al
andb %cl, %al
popq %rbx
popq %r14
popq %rbp
retq
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::operator!=(booster::locale::date_time const&) const | bool date_time::operator!=(date_time const &other) const
{
return !(*this==other);
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, %r14
movl %edx, %ebp
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpq %rax, %r14
setne %cl
cmpl %edx, %ebp
setne %al
orb %cl, %al
popq %rbx
popq %r14
popq %rbp
retq
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time::operator>=(booster::locale::date_time const&) const | bool date_time::operator>=(date_time const &other) const
{
return !(*this<other);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, %r15
movl %edx, %ebx
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpq %rax, %r15
jge 0x6ee26
xorl %eax, %eax
jmp 0x6ee30
setg %cl
cmpl %edx, %ebx
setae %al
orb %cl, %al
popq %rbx
popq %r14
popq %r15
retq
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::time_zone::global(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string global(std::string const &new_id)
{
booster::unique_lock<booster::mutex> lock(tz_mutex());
std::string id = tz_id();
tz_id() = new_id;
return id;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6aaf2(%rip), %rax # 0xd9a20
movq %rsp, %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x59de0
movb $0x1, 0x8(%r15)
callq 0x57170
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq 0x6aaef(%rip), %rsi # 0xd9a48
movq 0x6aaf0(%rip), %rdx # 0xd9a50
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x57cc0
callq 0x57170
leaq 0x6aad1(%rip), %rdi # 0xd9a48
movq %r14, %rsi
callq 0x58370
movq %rsp, %rdi
callq 0x57ab0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6efa9
callq 0x59580
jmp 0x6efa9
movq %rax, %r14
movq %rsp, %rdi
callq 0x57ab0
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/date_time.cpp |
booster::locale::date_time_period_set::operator[](unsigned long) const | date_time_period const &operator[](size_t n) const
{
if(n >= size())
throw booster::out_of_range("Invalid index to date_time_period");
if(n < 4)
return basic_[n];
else
return periods_[n-4];
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5ba50
cmpq %rbx, %rax
jbe 0x6f07e
cmpq $0x4, %rbx
leaq (%r14,%rbx,8), %rcx
movq 0x20(%r14), %rax
leaq -0x20(%rax,%rbx,8), %rax
cmovbq %rcx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3cc65(%rip), %rsi # 0xabd00
leaq 0x3cc7f(%rip), %rdx # 0xabd21
leaq 0x8(%rsp), %rdi
callq 0x57c80
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x599f0
xorl %ebp, %ebp
movq 0x63d3b(%rip), %rsi # 0xd2e00
movq 0x63cdc(%rip), %rdx # 0xd2da8
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6f0e6
callq 0x59580
testb %bpl, %bpl
jne 0x6f0f0
jmp 0x6f0f8
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/./booster/locale/date_time.h |
booster::locale::impl::ios_prop<booster::locale::ios_info>::get(std::ios_base&) | static Property &get(std::ios_base &ios)
{
int id=get_id();
if(!has(ios))
set(Property(),ios);
return *static_cast<Property *>(ios.pword(id));
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x5c020
movl %eax, %ebp
movq %rbx, %rdi
callq 0x587d0
testb %al, %al
jne 0x7033c
movq %rsp, %r14
movq %r14, %rdi
callq 0x581f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x59d80
movq %rsp, %rdi
callq 0x59fd0
cmpl %ebp, 0xc0(%rbx)
jbe 0x70354
movslq %ebp, %rax
shlq $0x4, %rax
addq 0xc8(%rbx), %rax
jmp 0x70360
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x57fa0
movq (%rax), %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59fd0
movq %rbx, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/ios_prop.h |
booster::locale::gnu_gettext::mo_file::value(int) const | pair_type value(int id) const
{
uint32_t len = get(translations_offset_ + id*8);
uint32_t off = get(translations_offset_ + id*8 + 4);
if(off >= file_size_ || off + len >= file_size_)
throw booster::runtime_error("Bad mo-file format");
return pair_type(&data_[off],&data_[off]+len);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leal (,%r14,8), %esi
addl 0x4(%rdi), %esi
callq 0x5a380
movl %eax, %ebp
movl 0x4(%rbx), %eax
leal (%rax,%r14,8), %esi
addl $0x4, %esi
movq %rbx, %rdi
callq 0x5a380
movl %eax, %ecx
movl %eax, %eax
movq 0x18(%rbx), %rdx
cmpq %rax, %rdx
jbe 0x76938
addl %ebp, %ecx
cmpq %rcx, %rdx
jbe 0x76938
addq 0x10(%rbx), %rax
movl %ebp, %edx
addq %rax, %rdx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x358d1(%rip), %rsi # 0xac226
leaq 0x358dc(%rip), %rdx # 0xac238
leaq 0x8(%rsp), %rdi
callq 0x57c80
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x5c169(%rip), %rsi # 0xd2ae8
movq 0x5c5f2(%rip), %rdx # 0xd2f78
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x769a0
callq 0x59580
testb %bpl, %bpl
jne 0x769aa
jmp 0x769b2
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/message.cpp |
booster::locale::gnu_gettext::converter<char>::converter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | converter(std::string out_enc,std::string in_enc) :
out_(out_enc),
in_(in_enc)
{
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x57cc0
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x57cc0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x76a99
callq 0x59580
movq %r14, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/message.cpp |
booster::locale::gnu_gettext::message_key<char>::message_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | message_key(string_type const &c = string_type()) :
c_context_(0),
c_key_(0)
{
size_t pos = c.find(char_type(4));
if(pos == string_type::npos) {
key_ = c;
}
else {
context_ = c.substr(0,pos);
key_ = c.substr(pos+1);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rbp
movq %rbp, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq %rsi, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x5a370
cmpq $-0x1, %rax
je 0x76b6a
movq %rax, %r12
movq %r13, (%rsp)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x59810
leaq 0x8(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5a060
movq (%r13), %rdi
leaq 0x18(%rsp), %r13
cmpq %r13, %rdi
je 0x76b31
callq 0x59580
incq %r12
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq $-0x1, %rcx
callq 0x59810
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5a060
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x76b75
callq 0x59580
jmp 0x76b75
movq %r14, %rdi
movq %r15, %rsi
callq 0x58370
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, (%rsp)
jmp 0x76b8c
jmp 0x76b8c
movq %rax, %r15
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x76b9c
callq 0x59580
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x76baa
callq 0x59580
movq %r15, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/message.cpp |
booster::locale::gnu_gettext::mo_message<char>::convert_encoding_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string convert_encoding_name(std::string const &in)
{
std::string result;
for(unsigned i=0;i<in.size();i++) {
char c=in[i];
if('A' <= c && c<='Z')
c=c-'A' + 'a';
else if(('a' <= c && c<='z') || ('0' <= c && c<='9'))
;
else
continue;
result+=c;
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x76ce4
movq %rdx, %r14
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%r14), %rdx
movb (%rdx,%rcx), %cl
leal -0x41(%rcx), %edx
cmpb $0x19, %dl
ja 0x76cb3
orb $0x20, %cl
jmp 0x76ccc
leal -0x61(%rcx), %edx
cmpb $0x1a, %dl
setae %dl
leal -0x30(%rcx), %esi
cmpb $0xa, %sil
setae %sil
testb %sil, %dl
jne 0x76cdb
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x59120
movq 0x8(%r14), %rax
movl %ebp, %ecx
incl %ebp
cmpq %rcx, %rax
ja 0x76ca0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x76d02
callq 0x59580
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/message.cpp |
booster::locale::gnu_gettext::mo_file::init() | void init()
{
// Read all format sizes
size_=get(8);
keys_offset_=get(12);
translations_offset_=get(16);
hash_size_=get(20);
hash_offset_=get(24);
} | pushq %rbx
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5a380
movl %eax, %eax
movq %rax, 0x40(%rbx)
movq %rbx, %rdi
movl $0xc, %esi
callq 0x5a380
movl %eax, (%rbx)
movq %rbx, %rdi
movl $0x10, %esi
callq 0x5a380
movl %eax, 0x4(%rbx)
movq %rbx, %rdi
movl $0x14, %esi
callq 0x5a380
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x18, %esi
callq 0x5a380
movl %eax, 0xc(%rbx)
popq %rbx
retq
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/message.cpp |
booster::locale::gnu_gettext::mo_file::get(unsigned int) const | uint32_t get(unsigned offset) const
{
uint32_t tmp;
if(offset > file_size_ - 4) {
throw booster::runtime_error("Bad mo-file format");
}
memcpy(&tmp,data_ + offset,4);
convert(tmp);
return tmp;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %eax
movq 0x18(%rdi), %rcx
addq $-0x4, %rcx
cmpq %rax, %rcx
jb 0x76f20
movq 0x10(%rdi), %rcx
movl (%rcx,%rax), %ecx
movl %ecx, %eax
cmpb $0x0, 0x38(%rdi)
bswapl %eax
cmovnel %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x352e9(%rip), %rsi # 0xac226
leaq 0x352f4(%rip), %rdx # 0xac238
leaq 0x8(%rsp), %rdi
callq 0x57c80
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x5bb81(%rip), %rsi # 0xd2ae8
movq 0x5c00a(%rip), %rdx # 0xd2f78
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x76f88
callq 0x59580
testb %bpl, %bpl
jne 0x76f92
jmp 0x76f9a
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/shared/message.cpp |
booster::intrusive_ptr<booster::details::key>::~intrusive_ptr() | ~intrusive_ptr()
{
if(p_ != 0) intrusive_ptr_release(p_);
} | pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x7fa2b
leaq 0x8(%rbx), %rdi
callq 0x59e20
testq %rax, %rax
je 0x7fa2d
popq %rbx
retq
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x8(%rax)
movq %rax, %rdi
callq 0x5f195
nop
| /artyom-beilis[P]cppcms/booster/./booster/intrusive_ptr.h |
booster::locale::impl_icu::collate_impl<wchar_t>::do_transform[abi:cxx11](booster::locale::collator_base::level_type, wchar_t const*, wchar_t const*) const | std::basic_string<CharType> do_transform(level_type level,CharType const *b,CharType const *e) const
{
std::vector<uint8_t> tmp = do_basic_transform(level,b,e);
return std::basic_string<CharType>(tmp.begin(),tmp.end());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x573a0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x59d30
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x80019
callq 0x59580
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x80035
callq 0x59580
movq %rbx, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/collator.cpp |
booster::locale::impl_icu::collate_impl<wchar_t>::do_hash(booster::locale::collator_base::level_type, wchar_t const*, wchar_t const*) const | long do_hash(level_type level,CharType const *b,CharType const *e) const
{
std::vector<uint8_t> tmp = do_basic_transform(level,b,e);
tmp.push_back(0);
return gnu_gettext::pj_winberger_hash_function(reinterpret_cast<char *>(&tmp.front()));
} | pushq %rbx
subq $0x20, %rsp
movq %rcx, %r8
movq %rdx, %rcx
movl %esi, %edx
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x573a0
movb $0x0, 0x7(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x80074
movb $0x0, (%rsi)
incq 0x10(%rsp)
jmp 0x80083
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x57d00
movq 0x8(%rsp), %rdi
movb (%rdi), %cl
xorl %ebx, %ebx
testb %cl, %cl
je 0x800b9
leaq 0x1(%rdi), %rax
shll $0x4, %ebx
movzbl %cl, %ecx
addl %ebx, %ecx
movl %ecx, %edx
shrl $0x18, %edx
andl $-0x10, %edx
andl $0xfffffff, %ecx # imm = 0xFFFFFFF
movl %ecx, %ebx
xorl %edx, %ebx
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x80094
movl %ebx, %ebx
callq 0x59580
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x800d9
callq 0x59580
movq %rbx, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/collator.cpp |
booster::locale::impl_icu::collate_impl<wchar_t>::get_collator(booster::locale::collator_base::level_type) const | icu::Collator *get_collator(level_type ilevel) const
{
int l = limit(ilevel);
static const icu::Collator::ECollationStrength levels[level_count] =
{
icu::Collator::PRIMARY,
icu::Collator::SECONDARY,
icu::Collator::TERTIARY,
icu::Collator::QUATERNARY,
icu::Collator::IDENTICAL
};
icu::Collator *col = collates_[l].get();
if(col)
return col;
UErrorCode status=U_ZERO_ERROR;
collates_[l].reset(icu::Collator::createInstance(locale_,status));
if(U_FAILURE(status))
throw booster::runtime_error(std::string("Creation of collate failed:") + u_errorName(status));
collates_[l]->setStrength(levels[l]);
return collates_[l].get();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
cmpl $0x4, %esi
movl $0x4, %eax
cmovbl %esi, %eax
xorl %r12d, %r12d
testl %esi, %esi
cmovnsl %eax, %r12d
movq 0x100(%rdi,%r12,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x8022b
leaq (%r14,%r12,8), %rbx
addq $0x100, %rbx # imm = 0x100
leaq 0xc(%rsp), %r15
movl $0x0, (%r15)
addq $0x20, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x5ab60
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5c0f0
cmpl $0x0, (%r15)
jg 0x80238
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rax), %rdi
movq 0x52b7f(%rip), %rax # 0xd2d90
movl (%rax,%r12,4), %esi
movq (%rdi), %rax
callq *0x98(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rax), %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2cedf(%rip), %rsi # 0xad134
leaq 0x2cef3(%rip), %rdx # 0xad14f
leaq 0x10(%rsp), %rdi
callq 0x57c80
movl 0xc(%rsp), %edi
callq 0x59fa0
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x5be30
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x8029f
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x802ac
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
movq 0x8(%rax), %rdx
leaq 0x30(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x5280c(%rip), %rsi # 0xd2ae8
movq 0x52c95(%rip), %rdx # 0xd2f78
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x802fd
callq 0x59580
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x8030c
callq 0x59580
testb %bpl, %bpl
jne 0x8032a
jmp 0x80332
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x8032a
callq 0x59580
jmp 0x8032a
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/collator.cpp |
booster::locale::impl_icu::collate_impl<wchar_t>::do_basic_transform(booster::locale::collator_base::level_type, wchar_t const*, wchar_t const*) const | std::vector<uint8_t> do_basic_transform(level_type level,CharType const *b,CharType const *e) const
{
icu::UnicodeString str=cvt_.icu(b,e);
std::vector<uint8_t> tmp;
tmp.resize(str.length());
icu::Collator *collate = get_collator(level);
int len = collate->getSortKey(str,&tmp[0],tmp.size());
if(len > int(tmp.size())) {
tmp.resize(len);
collate->getSortKey(str,&tmp[0],tmp.size());
}
else
tmp.resize(len);
return tmp;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x5a1e0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movswl 0x8(%r15), %eax
testw %ax, %ax
jns 0x80381
movl 0x14(%rsp), %eax
jmp 0x80384
sarl $0x5, %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x59910
movq %r14, %rdi
movl %ebp, %esi
callq 0x5a680
movq %rax, %r14
movq (%rbx), %rdx
movl 0x8(%rbx), %ecx
subl %edx, %ecx
movq (%rax), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x108(%rax)
movl 0x8(%rbx), %ecx
subl (%rbx), %ecx
movslq %eax, %rsi
cmpl %ecx, %eax
jle 0x803e4
movq %rbx, %rdi
callq 0x59910
movq (%rbx), %rdx
movl 0x8(%rbx), %ecx
subl %edx, %ecx
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x108(%rax)
jmp 0x803ec
movq %rbx, %rdi
callq 0x59910
leaq 0x8(%rsp), %rdi
callq 0x5a310
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x80408
jmp 0x80408
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x80418
callq 0x59580
leaq 0x8(%rsp), %rdi
callq 0x5a310
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/collator.cpp |
booster::locale::impl_icu::create_convert(std::locale const&, booster::locale::impl_icu::cdata const&, unsigned int) | std::locale create_convert(std::locale const &in,cdata const &cd,character_facet_type type)
{
switch(type) {
case char_facet:
#ifdef WITH_CASE_MAPS
if(cd.utf8)
return std::locale(in,new utf8_converter_impl(cd));
#endif
return std::locale(in,new converter_impl<char>(cd));
case wchar_t_facet:
return std::locale(in,new converter_impl<wchar_t>(cd));
#ifdef BOOSTER_HAS_CHAR16_T
case char16_t_facet:
return std::locale(in,new converter_impl<char16_t>(cd));
#endif
#ifdef BOOSTER_HAS_CHAR32_T
case char32_t_facet:
return std::locale(in,new converter_impl<char32_t>(cd));
#endif
default:
return in;
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, %ecx
je 0x804ea
cmpl $0x1, %ecx
jne 0x80512
cmpb $0x1, 0x100(%r12)
jne 0x8051f
movl $0x38, %edi
callq 0x596b0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x59630
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5bdc0
jmp 0x80545
movl $0x110, %edi # imm = 0x110
callq 0x596b0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x5a450
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x58d10
jmp 0x80545
movq %rbx, %rdi
movq %r14, %rsi
callq 0x586b0
jmp 0x80545
movl $0x110, %edi # imm = 0x110
callq 0x596b0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x5b500
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5b2f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x80558
jmp 0x80558
movq %rax, %rbx
movq %r15, %rdi
callq 0x59580
movq %rbx, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/conversion.cpp |
booster::locale::impl_icu::raii_casemap::raii_casemap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | raii_casemap(std::string const &locale_id) :
map_(0)
{
UErrorCode err=U_ZERO_ERROR;
map_ = ucasemap_open(locale_id.c_str(),0,&err);
check_and_throw_icu_error(err);
if(!map_)
throw booster::runtime_error("Failed to create UCaseMap");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq $0x0, (%rdi)
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
movq (%rsi), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x59790
movq %rax, (%rbx)
movl (%r14), %ebp
testl %ebp, %ebp
jg 0x80a2d
testq %rax, %rax
je 0x80a7b
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %rbx
movl %ebp, %edi
callq 0x59fa0
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
movq %rax, %rsi
callq 0x57c90
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x5207c(%rip), %rsi # 0xd2ae8
movq 0x52505(%rip), %rdx # 0xd2f78
movq %rbx, %rdi
callq 0x5b600
movl $0x30, %edi
callq 0x58050
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c820(%rip), %rsi # 0xad2b8
leaq 0x2c832(%rip), %rdx # 0xad2d1
leaq 0x8(%rsp), %rdi
callq 0x57c80
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x52026(%rip), %rsi # 0xd2ae8
movq 0x524af(%rip), %rdx # 0xd2f78
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x80af3
jmp 0x80af8
jmp 0x80b01
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x80af8
callq 0x59580
testb %bpl, %bpl
jne 0x80b04
jmp 0x80b0c
jmp 0x80b01
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/conversion.cpp |
booster::locale::impl_icu::utf8_converter_impl::~utf8_converter_impl() | utf8_converter_impl(cdata const &d) :
locale_id_(d.locale.getName()),
map_(locale_id_)
{
} | pushq %rbx
movq %rdi, %rbx
movq 0x51d8b(%rip), %rax # 0xd28e8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
callq 0x57840
movq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x80b7f
callq 0x59580
movq %rbx, %rdi
callq 0x57720
movq %rbx, %rdi
popq %rbx
jmp 0x59580
movq %rax, %rdi
callq 0x5f195
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/conversion.cpp |
booster::locale::impl_icu::utf8_converter_impl::convert[abi:cxx11](booster::locale::converter_base::conversion_type, char const*, char const*, int) const | virtual std::string convert(converter_base::conversion_type how,char const *begin,char const *end,int flags = 0) const
{
if(how == converter_base::normalization) {
icu_std_converter<char> cvt("UTF-8");
icu::UnicodeString str=cvt.icu(begin,end);
normalize_string(str,flags);
return cvt.std(str);
}
switch(how)
{
case converter_base::upper_case:
return map_.convert(ucasemap_utf8ToUpper,begin,end);
case converter_base::lower_case:
return map_.convert(ucasemap_utf8ToLower,begin,end);
case converter_base::title_case:
{
// Non-const method, so need to create a separate map
raii_casemap map(locale_id_);
return map.convert(ucasemap_utf8ToTitle,begin,end);
}
case converter_base::case_folding:
return map_.convert(ucasemap_utf8FoldCase,begin,end);
default:
return std::string(begin,end-begin);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
cmpl $0x4, %edx
ja 0x80ccb
movl %edx, %eax
leaq 0x2c672(%rip), %rcx # 0xad234
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %r9d, %ebp
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2adfe(%rip), %rsi # 0xab9dd
leaq 0x2adfc(%rip), %rdx # 0xab9e2
movq %rsp, %rdi
callq 0x57c80
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0x57e90
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x80c0b
callq 0x59580
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x5ba20
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0x8056b
leaq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x59310
leaq 0x20(%rsp), %rdi
callq 0x5a310
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x80ce0
callq 0x59580
jmp 0x80ce0
addq $0x10, %rsi
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x5ad80
movq 0x51eef(%rip), %rdx # 0xd2b68
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0x58d80
movq 0x20(%rsp), %rdi
callq 0x57840
jmp 0x80ce0
addq $0x30, %rsi
movq 0x5233f(%rip), %rdx # 0xd2fe0
jmp 0x80cbb
addq $0x30, %rsi
movq 0x51dca(%rip), %rdx # 0xd2a78
jmp 0x80cbb
addq $0x30, %rsi
movq 0x51f4d(%rip), %rdx # 0xd2c08
movq %rbx, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x58e70
jmp 0x80ce0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x57c80
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x80d31
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
jne 0x80d3f
jmp 0x80d44
jmp 0x80d1c
movq %rax, %rbx
jmp 0x80d44
movq %rax, %rbx
movq 0x20(%rsp), %rdi
callq 0x57840
jmp 0x80d44
movq %rax, %rdi
callq 0x5f195
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5a310
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x80d44
callq 0x59580
movq %rbx, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/conversion.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> booster::locale::impl_icu::raii_casemap::convert<int (*)(UCaseMap const*, char*, int, char const*, int, UErrorCode*)>(int (*)(UCaseMap const*, char*, int, char const*, int, UErrorCode*), char const*, char const*) const | std::string convert(Conv func,char const *begin,char const *end) const
{
std::vector<char> buf((end-begin)*11/10+1);
UErrorCode err=U_ZERO_ERROR;
int size = func(map_,&buf.front(),buf.size(),begin,end-begin,&err);
if(err == U_BUFFER_OVERFLOW_ERROR) {
err = U_ZERO_ERROR;
buf.resize(size+1);
size = func(map_,&buf.front(),buf.size(),begin,end-begin,&err);
}
check_and_throw_icu_error(err);
return std::string(&buf.front(),size);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
subq %rcx, %r15
leaq (%r15,%r15,4), %rax
leaq (%r15,%rax,2), %rax
movabsq $0x6666666666666667, %rcx # imm = 0x6666666666666667
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
leaq (%rdx,%rax), %rsi
incq %rsi
leaq 0x10(%rsp), %rbp
leaq 0x28(%rsp), %rdx
movq %rbp, %rdi
callq 0x58a00
leaq 0x8(%rsp), %r9
movl $0x0, (%r9)
movq (%r13), %rdi
movq (%rbp), %rsi
movl 0x8(%rbp), %edx
subl %esi, %edx
movq %r12, %rcx
movl %r15d, %r8d
callq *%r14
movl 0x8(%rsp), %ebp
cmpl $0xf, %ebp
jne 0x80e08
movl $0x0, 0x8(%rsp)
incl %eax
movslq %eax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x5b720
movq (%r13), %rdi
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %edx
subl %esi, %edx
leaq 0x8(%rsp), %r9
movq %r12, %rcx
movl %r15d, %r8d
callq *%r14
movl 0x8(%rsp), %ebp
testl %ebp, %ebp
jg 0x80e47
movq 0x10(%rsp), %rsi
movslq %eax, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x57c80
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x80e35
callq 0x59580
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %rbx
movl %ebp, %edi
callq 0x59fa0
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x57c90
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x51c62(%rip), %rsi # 0xd2ae8
movq 0x520eb(%rip), %rdx # 0xd2f78
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x80eab
callq 0x59580
testb %bpl, %bpl
jne 0x80eb7
jmp 0x80ec6
jmp 0x80eb4
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
jmp 0x80ec6
jmp 0x80ec3
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x80ed5
callq 0x59580
movq %r14, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/conversion.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> booster::locale::impl_icu::raii_casemap::convert<int (*)(UCaseMap*, char*, int, char const*, int, UErrorCode*)>(int (*)(UCaseMap*, char*, int, char const*, int, UErrorCode*), char const*, char const*) const | std::string convert(Conv func,char const *begin,char const *end) const
{
std::vector<char> buf((end-begin)*11/10+1);
UErrorCode err=U_ZERO_ERROR;
int size = func(map_,&buf.front(),buf.size(),begin,end-begin,&err);
if(err == U_BUFFER_OVERFLOW_ERROR) {
err = U_ZERO_ERROR;
buf.resize(size+1);
size = func(map_,&buf.front(),buf.size(),begin,end-begin,&err);
}
check_and_throw_icu_error(err);
return std::string(&buf.front(),size);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
subq %rcx, %r15
leaq (%r15,%r15,4), %rax
leaq (%r15,%rax,2), %rax
movabsq $0x6666666666666667, %rcx # imm = 0x6666666666666667
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
leaq (%rdx,%rax), %rsi
incq %rsi
leaq 0x10(%rsp), %rbp
leaq 0x28(%rsp), %rdx
movq %rbp, %rdi
callq 0x58a00
leaq 0x8(%rsp), %r9
movl $0x0, (%r9)
movq (%r13), %rdi
movq (%rbp), %rsi
movl 0x8(%rbp), %edx
subl %esi, %edx
movq %r12, %rcx
movl %r15d, %r8d
callq *%r14
movl 0x8(%rsp), %ebp
cmpl $0xf, %ebp
jne 0x80f9a
movl $0x0, 0x8(%rsp)
incl %eax
movslq %eax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x5b720
movq (%r13), %rdi
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %edx
subl %esi, %edx
leaq 0x8(%rsp), %r9
movq %r12, %rcx
movl %r15d, %r8d
callq *%r14
movl 0x8(%rsp), %ebp
testl %ebp, %ebp
jg 0x80fd9
movq 0x10(%rsp), %rsi
movslq %eax, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x57c80
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x80fc7
callq 0x59580
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %rbx
movl %ebp, %edi
callq 0x59fa0
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x57c90
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x5ad60
xorl %ebp, %ebp
movq 0x51ad0(%rip), %rsi # 0xd2ae8
movq 0x51f59(%rip), %rdx # 0xd2f78
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8103d
callq 0x59580
testb %bpl, %bpl
jne 0x81049
jmp 0x81058
jmp 0x81046
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
jmp 0x81058
jmp 0x81055
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x81067
callq 0x59580
movq %r14, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/conversion.cpp |
booster::locale::impl_icu::converter_impl<char>::convert[abi:cxx11](booster::locale::converter_base::conversion_type, char const*, char const*, int) const | virtual string_type convert(converter_base::conversion_type how,char_type const *begin,char_type const *end,int flags = 0) const
{
icu_std_converter<char_type> cvt(encoding_);
icu::UnicodeString str=cvt.icu(begin,end);
switch(how) {
case converter_base::normalization:
normalize_string(str,flags);
break;
case converter_base::upper_case:
str.toUpper(locale_);
break;
case converter_base::lower_case:
str.toLower(locale_);
break;
case converter_base::title_case:
str.toTitle(0,locale_);
break;
case converter_base::case_folding:
str.foldCase();
break;
default:
;
}
return cvt.std(str);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r9d, 0x4(%rsp)
movq %r8, %r12
movq %rcx, %r13
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0xf0(%rsi), %rsi
movq 0xf8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x57cc0
leaq 0x68(%rsp), %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x57e90
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x811f7
callq 0x59580
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x5ba20
cmpl $0x4, %r15d
ja 0x8127c
movl %r15d, %eax
leaq 0x2c044(%rip), %rcx # 0xad260
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x28(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x8056b
jmp 0x8127c
addq $0x10, %r14
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x5bb20
jmp 0x8127c
addq $0x10, %r14
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x58670
jmp 0x8127c
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x5b0a0
jmp 0x8127c
addq $0x10, %r14
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x588b0
leaq 0x68(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x59310
leaq 0x28(%rsp), %rdi
callq 0x5a310
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x812ae
callq 0x59580
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x812e4
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
jmp 0x812f0
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5a310
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x812fa
callq 0x59580
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/conversion.cpp |
booster::locale::impl_icu::converter_impl<wchar_t>::convert[abi:cxx11](booster::locale::converter_base::conversion_type, wchar_t const*, wchar_t const*, int) const | virtual string_type convert(converter_base::conversion_type how,char_type const *begin,char_type const *end,int flags = 0) const
{
icu_std_converter<char_type> cvt(encoding_);
icu::UnicodeString str=cvt.icu(begin,end);
switch(how) {
case converter_base::normalization:
normalize_string(str,flags);
break;
case converter_base::upper_case:
str.toUpper(locale_);
break;
case converter_base::lower_case:
str.toLower(locale_);
break;
case converter_base::title_case:
str.toTitle(0,locale_);
break;
case converter_base::case_folding:
str.foldCase();
break;
default:
;
}
return cvt.std(str);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r13
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %r12
leaq 0x68(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq 0xf0(%rsi), %rsi
movq 0xf8(%r14), %rdx
addq %rsi, %rdx
leaq 0x58(%rsp), %rbp
movq %rbp, %rdi
callq 0x57cc0
movl $0x0, 0x8(%rsp)
movq (%rbp), %rdi
cmpq %rbx, %rdi
je 0x813e3
callq 0x59580
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rdx
movq 0x10(%rsp), %rcx
callq 0x5a1e0
cmpl $0x4, %r15d
ja 0x8146a
movl %r15d, %eax
leaq 0x2be6a(%rip), %rcx # 0xad274
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x8056b
jmp 0x8146a
addq $0x10, %r14
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x5bb20
jmp 0x8146a
addq $0x10, %r14
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x58670
jmp 0x8146a
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x5b0a0
jmp 0x8146a
addq $0x10, %r14
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x588b0
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x59170
leaq 0x18(%rsp), %rdi
callq 0x5a310
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5a310
movq %rbx, %rdi
callq 0x5b810
nopl (%rax)
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/conversion.cpp |
booster::locale::impl_icu::to_icu(booster::locale::period::marks::period_mark) | static UCalendarDateFields to_icu(period::marks::period_mark f)
{
using namespace period::marks;
switch(f) {
case era: return UCAL_ERA;
case year: return UCAL_YEAR;
case extended_year: return UCAL_EXTENDED_YEAR;
case month: return UCAL_MONTH;
case day: return UCAL_DATE;
case day_of_year: return UCAL_DAY_OF_YEAR;
case day_of_week: return UCAL_DAY_OF_WEEK;
case day_of_week_in_month: return UCAL_DAY_OF_WEEK_IN_MONTH;
case day_of_week_local: return UCAL_DOW_LOCAL;
case hour: return UCAL_HOUR_OF_DAY;
case hour_12: return UCAL_HOUR;
case am_pm: return UCAL_AM_PM;
case minute: return UCAL_MINUTE;
case second: return UCAL_SECOND;
case week_of_year: return UCAL_WEEK_OF_YEAR;
case week_of_month: return UCAL_WEEK_OF_MONTH;
default:
throw booster::invalid_argument("Invalid date_time period type");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
decl %edi
cmpl $0x10, %edi
jae 0x815e3
movl %edi, %eax
leaq 0x2beab(%rip), %rcx # 0xad480
movl (%rcx,%rax,4), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x58050
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2bd8f(%rip), %rsi # 0xad38f
leaq 0x2bda5(%rip), %rdx # 0xad3ac
leaq 0x8(%rsp), %rdi
callq 0x57c80
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5bf20
xorl %ebp, %ebp
movq 0x512ae(%rip), %rsi # 0xd28d8
movq 0x516bf(%rip), %rdx # 0xd2cf0
movq %rbx, %rdi
callq 0x5b600
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8164b
callq 0x59580
testb %bpl, %bpl
jne 0x81655
jmp 0x8165d
movq %rax, %r14
movq %rbx, %rdi
callq 0x58a30
movq %r14, %rdi
callq 0x5b810
nop
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/date_time.cpp |
booster::locale::impl_icu::icu_calendar_facet::icu_calendar_facet(booster::locale::impl_icu::cdata const&, unsigned long) | icu_calendar_facet(cdata const &d,size_t refs = 0) :
calendar_facet(refs),
data_(d)
{
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
testq %rdx, %rdx
setne %al
movl %eax, 0x8(%rdi)
movq 0x51965(%rip), %rax # 0xd2fe8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x10(%rdi), %r15
movq %r15, %rdi
callq 0x57860
leaq 0xf0(%rbx), %rdi
leaq 0x100(%rbx), %rax
movq %rax, 0xf0(%rbx)
movq 0xe0(%r14), %rsi
movq 0xe8(%r14), %rdx
addq %rsi, %rdx
callq 0x57cc0
movb 0x100(%r14), %al
movb %al, 0x110(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x57f20
jmp 0x816e4
movq %rax, %r14
movq %rbx, %rdi
callq 0x57720
movq %r14, %rdi
callq 0x5b810
| /artyom-beilis[P]cppcms/booster/lib/locale/src/icu/date_time.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.