name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
---|---|---|---|
ELFIO::note_section_accessor_template<ELFIO::section, &ELFIO::section::get_size() const>::add_note(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, unsigned int)
|
void add_note( Elf_Word type,
const std::string& name,
const char* desc,
Elf_Word descSize )
{
const endianness_convertor& convertor = elf_file.get_convertor();
int align = sizeof( Elf_Word );
Elf_Word nameLen = (Elf_Word)name.size() + 1;
Elf_Word nameLenConv = convertor( nameLen );
std::string buffer( reinterpret_cast<char*>( &nameLenConv ), align );
Elf_Word descSizeConv = convertor( descSize );
buffer.append( reinterpret_cast<char*>( &descSizeConv ), align );
type = convertor( type );
buffer.append( reinterpret_cast<char*>( &type ), align );
buffer.append( name );
buffer.append( 1, '\x00' );
const char pad[] = { '\0', '\0', '\0', '\0' };
if ( nameLen % align != 0 ) {
buffer.append( pad, (size_t)align - nameLen % align );
}
if ( desc != nullptr && descSize != 0 ) {
buffer.append( desc, descSize );
if ( descSize % align != 0 ) {
buffer.append( pad, (size_t)align - descSize % align );
}
}
note_start_positions.emplace_back( ( notes->*F_get_size )() );
notes->append_data( buffer );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebp
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movq (%rdi), %r14
movl 0x8(%rdx), %r13d
incl %r13d
movl %r13d, %eax
bswapl %eax
cmpb $0x0, 0x50(%r14)
cmovel %r13d, %eax
movq %rcx, 0x30(%rsp)
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movl %eax, (%rcx)
movq $0x4, -0x8(%rcx)
movb $0x0, 0x4(%rcx)
movl %r8d, %eax
bswapl %eax
cmovel %r8d, %eax
leaq 0x3c(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x10(%rsp), %rdi
pushq $0x4
popq %rdx
callq 0x3040
movl %r12d, %eax
bswapl %eax
cmpb $0x0, 0x50(%r14)
cmovel %r12d, %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x10(%rsp), %rdi
pushq $0x4
popq %rdx
callq 0x3040
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x32a0
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x3170
andl $0x0, 0x8(%rsp)
pushq $0x4
popq %r15
andl $0x3, %r13d
movq 0x30(%rsp), %r14
je 0x3d82
movl %r15d, %edx
subl %r13d, %edx
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3040
testq %r14, %r14
sete %al
testl %ebp, %ebp
sete %cl
orb %al, %cl
jne 0x3dba
movl %ebp, %edx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x3040
andl $0x3, %ebp
je 0x3dba
subl %ebp, %r15d
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x3040
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x98(%rax)
leaq 0x10(%rbx), %rdi
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
callq 0x8356
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
callq *0xe8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x30a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e07
jmp 0x3e07
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x3280
|
/serge1[P]ELFIO/elfio/elfio_note.hpp
|
ELFIO::elfio::save(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
bool save( const std::string& file_name )
{
std::ofstream stream;
stream.open( file_name.c_str(), std::ios::out | std::ios::binary );
if ( !stream ) {
return false;
}
return save( stream );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp # imm = 0x200
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x3260
movq (%r14), %rsi
pushq $0x14
popq %rdx
movq %r15, %rdi
callq 0x3030
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
je 0x3f06
xorl %ebx, %ebx
jmp 0x3f13
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x640c
movl %eax, %ebx
movq %rsp, %rdi
callq 0x3210
movl %ebx, %eax
addq $0x200, %rsp # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3210
movq %rbx, %rdi
callq 0x3280
nop
|
/serge1[P]ELFIO/elfio/elfio.hpp
|
ELFIO::elfio::create_header(unsigned char, unsigned char)
|
std::unique_ptr<elf_header> create_header( unsigned char file_class,
unsigned char encoding )
{
std::unique_ptr<elf_header> new_header;
if ( file_class == ELFCLASS64 ) {
new_header = std::unique_ptr<elf_header>(
new ( std::nothrow ) elf_header_impl<Elf64_Ehdr>(
&convertor, encoding, &addr_translator ) );
}
else if ( file_class == ELFCLASS32 ) {
new_header = std::unique_ptr<elf_header>(
new ( std::nothrow ) elf_header_impl<Elf32_Ehdr>(
&convertor, encoding, &addr_translator ) );
}
else {
return nullptr;
}
return new_header;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x1, %edx
je 0x3fe1
cmpl $0x2, %edx
jne 0x4011
movq 0xc008(%rip), %rsi # 0xffc0
pushq $0x58
popq %rdi
callq 0x32b0
testq %rax, %rax
je 0x4011
movq %rax, %r14
leaq 0x50(%r15), %rsi
addq $0x58, %r15
movzbl %bpl, %edx
movq %rax, %rdi
movq %r15, %rcx
callq 0x422e
jmp 0x4014
movq 0xbfd8(%rip), %rsi # 0xffc0
pushq $0x50
popq %rdi
callq 0x32b0
testq %rax, %rax
je 0x4011
movq %rax, %r14
leaq 0x50(%r15), %rsi
addq $0x58, %r15
movzbl %bpl, %edx
movq %rax, %rdi
movq %r15, %rcx
callq 0x42a6
jmp 0x4014
xorl %r14d, %r14d
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0xbf91(%rip), %rsi # 0xffc0
movq %r14, %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3280
nop
|
/serge1[P]ELFIO/elfio/elfio.hpp
|
ELFIO::elf_header_impl<ELFIO::Elf64_Ehdr>::elf_header_impl(ELFIO::endianness_convertor*, unsigned char, ELFIO::address_translator const*)
|
elf_header_impl( endianness_convertor* convertor,
unsigned char encoding,
const address_translator* translator )
: convertor( convertor ), translator( translator )
{
header.e_ident[EI_MAG0] = ELFMAG0;
header.e_ident[EI_MAG1] = ELFMAG1;
header.e_ident[EI_MAG2] = ELFMAG2;
header.e_ident[EI_MAG3] = ELFMAG3;
header.e_ident[EI_CLASS] = elf_header_impl_types<T>::file_class;
header.e_ident[EI_DATA] = encoding;
header.e_ident[EI_VERSION] = EV_CURRENT;
header.e_version = ( *convertor )( (Elf_Word)EV_CURRENT );
header.e_ehsize = ( sizeof( header ) );
header.e_ehsize = ( *convertor )( header.e_ehsize );
header.e_shstrndx = ( *convertor )( (Elf_Half)1 );
header.e_phentsize =
sizeof( typename elf_header_impl_types<T>::Phdr_type );
header.e_shentsize =
sizeof( typename elf_header_impl_types<T>::Shdr_type );
header.e_phentsize = ( *convertor )( header.e_phentsize );
header.e_shentsize = ( *convertor )( header.e_shentsize );
}
|
leaq 0xb62b(%rip), %rax # 0xf860
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq %rsi, 0x48(%rdi)
movq %rcx, 0x50(%rdi)
movl $0x464c457f, 0x8(%rdi) # imm = 0x464C457F
movb $0x2, 0xc(%rdi)
movb %dl, 0xd(%rdi)
movb $0x1, 0xe(%rdi)
cmpb $0x0, (%rsi)
movl $0x1000000, %eax # imm = 0x1000000
pushq $0x1
popq %rcx
cmovel %ecx, %eax
movl $0x4000, %edx # imm = 0x4000
pushq $0x40
popq %rsi
cmovnel %edx, %esi
movl %eax, 0x1c(%rdi)
movl $0x100, %eax # imm = 0x100
cmovel %ecx, %eax
movw %si, 0x3c(%rdi)
movw %ax, 0x46(%rdi)
movl $0x3800, %eax # imm = 0x3800
pushq $0x38
popq %rcx
cmovnel %eax, %ecx
movw %cx, 0x3e(%rdi)
movw %si, 0x42(%rdi)
retq
nop
|
/serge1[P]ELFIO/elfio/elfio_header.hpp
|
ELFIO::elf_header_impl<ELFIO::Elf32_Ehdr>::elf_header_impl(ELFIO::endianness_convertor*, unsigned char, ELFIO::address_translator const*)
|
elf_header_impl( endianness_convertor* convertor,
unsigned char encoding,
const address_translator* translator )
: convertor( convertor ), translator( translator )
{
header.e_ident[EI_MAG0] = ELFMAG0;
header.e_ident[EI_MAG1] = ELFMAG1;
header.e_ident[EI_MAG2] = ELFMAG2;
header.e_ident[EI_MAG3] = ELFMAG3;
header.e_ident[EI_CLASS] = elf_header_impl_types<T>::file_class;
header.e_ident[EI_DATA] = encoding;
header.e_ident[EI_VERSION] = EV_CURRENT;
header.e_version = ( *convertor )( (Elf_Word)EV_CURRENT );
header.e_ehsize = ( sizeof( header ) );
header.e_ehsize = ( *convertor )( header.e_ehsize );
header.e_shstrndx = ( *convertor )( (Elf_Half)1 );
header.e_phentsize =
sizeof( typename elf_header_impl_types<T>::Phdr_type );
header.e_shentsize =
sizeof( typename elf_header_impl_types<T>::Shdr_type );
header.e_phentsize = ( *convertor )( header.e_phentsize );
header.e_shentsize = ( *convertor )( header.e_shentsize );
}
|
leaq 0xb6fb(%rip), %rax # 0xf9a8
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
andl $0x0, 0x38(%rdi)
movq %rsi, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movl $0x464c457f, 0x8(%rdi) # imm = 0x464C457F
movb $0x1, %al
movb %al, 0xc(%rdi)
movb %dl, 0xd(%rdi)
movb %al, 0xe(%rdi)
cmpb $0x0, (%rsi)
movl $0x1000000, %eax # imm = 0x1000000
pushq $0x1
popq %rcx
cmovel %ecx, %eax
movl $0x3400, %edx # imm = 0x3400
pushq $0x34
popq %rsi
cmovnel %edx, %esi
movl %eax, 0x1c(%rdi)
movl $0x100, %eax # imm = 0x100
cmovel %ecx, %eax
movw %si, 0x30(%rdi)
movw %ax, 0x3a(%rdi)
movl $0x2000, %eax # imm = 0x2000
pushq $0x20
popq %rcx
cmovnel %eax, %ecx
movw %cx, 0x32(%rdi)
movl $0x2800, %eax # imm = 0x2800
pushq $0x28
popq %rcx
cmovnel %eax, %ecx
movw %cx, 0x36(%rdi)
retq
|
/serge1[P]ELFIO/elfio/elfio_header.hpp
|
ELFIO::address_translator::operator[](std::fpos<__mbstate_t>) const
|
std::streampos operator[]( std::streampos value ) const
{
if ( addr_translations.empty() ) {
return value;
}
for ( auto& t : addr_translations ) {
if ( ( t.start <= value ) && ( ( value - t.start ) < t.size ) ) {
return value - t.start + t.mapped_to;
}
}
return value;
}
|
movq %rsi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rsi
cmpq %rsi, %rcx
je 0x460d
cmpq %rsi, %rcx
je 0x460d
movq %rax, %rdi
subq (%rcx), %rdi
jl 0x45fe
cmpq 0x10(%rcx), %rdi
jl 0x4604
addq $0x30, %rcx
jmp 0x45eb
addq 0x20(%rcx), %rdi
xorl %edx, %edx
movq %rdi, %rax
retq
|
/serge1[P]ELFIO/elfio/elfio_utils.hpp
|
ELFIO::elf_header_impl<ELFIO::Elf32_Ehdr>::save(std::ostream&) const
|
bool save( std::ostream& stream ) const override
{
stream.seekp( ( *translator )[0] );
stream.write( reinterpret_cast<const char*>( &header ),
sizeof( header ) );
return stream.good();
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x45dc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3190
addq $0x8, %r14
pushq $0x34
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31d0
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/serge1[P]ELFIO/elfio/elfio_header.hpp
|
ELFIO::elfio::create_section()
|
section* create_section()
{
if ( auto file_class = get_class(); file_class == ELFCLASS64 ) {
sections_.emplace_back(
new ( std::nothrow ) section_impl<Elf64_Shdr>(
&convertor, &addr_translator, compression ) );
}
else if ( file_class == ELFCLASS32 ) {
sections_.emplace_back(
new ( std::nothrow ) section_impl<Elf32_Shdr>(
&convertor, &addr_translator, compression ) );
}
else {
sections_.pop_back();
return nullptr;
}
section* new_section = sections_.back().get();
new_section->set_index( static_cast<Elf_Half>( sections_.size() - 1 ) );
return new_section;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x4910
movq (%rdi), %rax
callq *0x20(%rax)
cmpb $0x1, %al
je 0x4921
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x4910
leaq 0x20(%rbx), %r14
movq 0xb6e8(%rip), %rsi # 0xffc0
movl $0xc0, %edi
callq 0x32b0
movq %rax, %r15
testq %rax, %rax
je 0x48fe
leaq 0x50(%rbx), %rsi
leaq 0x58(%rbx), %rdx
leaq 0x70(%rbx), %rcx
movq %r15, %rdi
callq 0x49ec
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, %rdi
callq 0x49b4
jmp 0x4962
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x4b1c
xorl %r14d, %r14d
jmp 0x4986
leaq 0x20(%rbx), %r14
movq 0xb694(%rip), %rsi # 0xffc0
movl $0xa8, %edi
callq 0x32b0
movq %rax, %r15
testq %rax, %rax
je 0x4952
leaq 0x50(%rbx), %rsi
leaq 0x58(%rbx), %rdx
leaq 0x70(%rbx), %rcx
movq %r15, %rdi
callq 0x4aa4
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, %rdi
callq 0x4a6c
movq 0x28(%rbx), %rax
movq -0x8(%rax), %r14
subl 0x20(%rbx), %eax
shrl $0x3, %eax
decl %eax
leaq 0x8(%rsp), %rsi
movw %ax, (%rsi)
movq (%r14), %rax
movq %r14, %rdi
callq *0x118(%rax)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/serge1[P]ELFIO/elfio/elfio.hpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::section_impl(ELFIO::endianness_convertor const*, ELFIO::address_translator const*, std::shared_ptr<ELFIO::compression_interface> const&)
|
section_impl( const endianness_convertor* convertor,
const address_translator* translator,
const std::shared_ptr<compression_interface>& compression )
: convertor( convertor ), translator( translator ),
compression( compression )
{
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb0e7(%rip), %rax # 0xfae0
movq %rax, (%rdi)
leaq 0x68(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x42(%rdi)
movq %rax, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
xorl %ebp, %ebp
movb %bpl, 0x68(%rdi)
movups %xmm0, 0x78(%rdi)
movq %rsi, 0x88(%rdi)
movq %rdx, 0x90(%rdi)
addq $0x98, %rdi
movq %rcx, %rsi
callq 0x54e4
movb %bpl, 0xa8(%rbx)
andq $0x0, 0xb0(%rbx)
andw $0x0, 0xb8(%rbx)
movb $0x1, 0xba(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/serge1[P]ELFIO/elfio/elfio_section.hpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(char const*, unsigned long)
|
void set_data( const char* raw_data, Elf_Xword size ) override
{
if ( get_type() != SHT_NOBITS ) {
data = std::unique_ptr<char[]>( new ( std::nothrow ) char[(size_t)size] );
if ( nullptr != data.get() && nullptr != raw_data ) {
data_size = size;
std::copy( raw_data, raw_data + size, data.get() );
}
else {
data_size = 0;
}
}
set_size( data_size );
if ( translator->empty() ) {
set_stream_size( (size_t)data_size );
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x8, %eax
je 0x4ff4
movq 0xb025(%rip), %rsi # 0xffc0
movq %r14, %rdi
callq 0x3250
leaq 0x78(%rbx), %rdi
movq %rsp, %r12
andq $0x0, (%r12)
movq %rax, %rsi
callq 0x5744
movq %r12, %rdi
callq 0x5518
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x4fec
movq %r14, 0x80(%rbx)
testq %r14, %r14
je 0x4ff4
movq %r15, %rsi
movq %r14, %rdx
callq 0x3230
jmp 0x4ff4
andq $0x0, 0x80(%rbx)
leaq 0x80(%rbx), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
movq 0x90(%rbx), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jne 0x502a
movq (%rbx), %rax
movq 0x80(%rbx), %rsi
movq %rbx, %rdi
callq *0x108(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/serge1[P]ELFIO/elfio/elfio_section.hpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::insert_data(unsigned long, char const*, unsigned long)
|
void
insert_data( Elf_Xword pos, const char* raw_data, Elf_Xword size ) override
{
if ( get_type() != SHT_NOBITS ) {
// Check for valid position
if ( pos > get_size() ) {
return; // Invalid position
}
// Check for integer overflow in size calculation
Elf_Xword new_size = get_size();
if ( size > std::numeric_limits<Elf_Xword>::max() - new_size ) {
return; // Size would overflow
}
new_size += size;
if ( new_size <= data_size ) {
char* d = data.get();
std::copy_backward( d + pos, d + get_size(),
d + get_size() + size );
std::copy( raw_data, raw_data + size, d + pos );
}
else {
// Calculate new size with overflow check
Elf_Xword new_data_size = data_size;
if ( new_data_size > std::numeric_limits<Elf_Xword>::max() / 2 ) {
return; // Multiplication would overflow
}
new_data_size *= 2;
if ( size > std::numeric_limits<Elf_Xword>::max() - new_data_size ) {
return; // Addition would overflow
}
new_data_size += size;
// Check if the size would overflow size_t
if (new_data_size > std::numeric_limits<size_t>::max()) {
return; // Size would overflow size_t
}
std::unique_ptr<char[]> new_data(
new (std::nothrow) char[(size_t)new_data_size]);
if ( nullptr != new_data ) {
char* d = data.get();
std::copy( d, d + pos, new_data.get() );
std::copy( raw_data, raw_data + size,
new_data.get() + pos );
std::copy( d + pos, d + get_size(),
new_data.get() + pos + size );
data = std::move( new_data );
data_size = new_data_size;
}
else {
return; // Allocation failed
}
}
set_size( new_size );
if ( translator->empty() ) {
set_stream_size( get_stream_size() + (size_t)size );
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x8, %eax
je 0x5263
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
cmpq %r15, %rax
jb 0x5263
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
addq %rbx, %rax
jb 0x5263
movq %rax, 0x10(%rsp)
movq 0x80(%r14), %r13
cmpq %r13, %rax
jbe 0x51be
testq %r13, %r13
js 0x5263
addq %r13, %r13
addq %rbx, %r13
jb 0x5263
movq 0xaea4(%rip), %rsi # 0xffc0
movq %r13, %rdi
callq 0x3250
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x5259
movq %rax, %rbp
movq 0x78(%r14), %rax
testq %r15, %r15
movq %rax, (%rsp)
je 0x5151
movq %rbp, %rdi
movq (%rsp), %rsi
movq %r15, %rdx
callq 0x3230
testq %rbx, %rbx
je 0x5167
addq %r15, %rbp
movq %rbp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3110
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
leaq 0x78(%r14), %r12
movq 0x8(%rsp), %rbp
subq %r15, %rax
movq (%rsp), %rsi
je 0x5199
addq %r15, %rsi
addq %rbp, %r15
addq %rbx, %r15
movq %r15, %rdi
movq %rax, %rdx
callq 0x3230
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5744
movq %r13, 0x80(%r14)
movq %r15, %rdi
callq 0x5518
jmp 0x5218
movq (%r14), %rax
movq 0x78(%r14), %rbp
leaq (%r15,%rbp), %rcx
movq %rcx, (%rsp)
movq %r14, %rdi
callq *0x98(%rax)
movq %rax, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
subq %r15, %r13
movq (%rsp), %r15
je 0x5205
addq %rax, %rbp
addq %rbx, %rbp
subq %r13, %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3230
testq %rbx, %rbx
je 0x5218
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3230
movq (%r14), %rax
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq *0xa0(%rax)
movq 0x90(%r14), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jne 0x5263
movq (%r14), %rax
movq %r14, %rdi
callq *0x100(%rax)
addq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x108(%rax)
jmp 0x5263
leaq 0x8(%rsp), %rdi
callq 0x5518
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5518
movq %rbx, %rdi
callq 0x3280
nop
|
/serge1[P]ELFIO/elfio/elfio_section.hpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::load(std::istream&, std::fpos<__mbstate_t>, bool)
|
bool load( std::istream& stream,
std::streampos header_offset,
bool is_lazy_ ) override
{
pstream = &stream;
is_lazy = is_lazy_;
if ( translator->empty() ) {
stream.seekg( 0, std::istream::end );
set_stream_size( size_t( stream.tellg() ) );
}
else {
set_stream_size( std::numeric_limits<size_t>::max() );
}
stream.seekg( ( *translator )[header_offset] );
stream.read( reinterpret_cast<char*>( &header ), sizeof( header ) );
if ( !( is_lazy || is_loaded ) ) {
bool ret = get_data();
if ( is_compressed() ) {
Elf_Xword size = get_size();
Elf_Xword uncompressed_size = 0;
auto decompressed_data = compression->inflate(
data.get(), convertor, size, uncompressed_size );
if ( decompressed_data != nullptr ) {
set_size( uncompressed_size );
data = std::move( decompressed_data );
}
}
return ret;
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movb %r8b, 0xb8(%rdi)
movq 0x90(%rdi), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x530a
pushq $-0x1
popq %rsi
jmp 0x5322
pushq $0x2
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x31e0
movq %r14, %rdi
callq 0x3270
movq %rax, %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x108(%rax)
movq 0x90(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x45dc
movq %r14, %rdi
movq %rax, %rsi
callq 0x31b0
leaq 0x10(%rbx), %rsi
pushq $0x40
popq %rdx
movq %r14, %rdi
callq 0x31a0
movb $0x1, %bpl
cmpb $0x0, 0xb8(%rbx)
jne 0x5401
cmpb $0x0, 0xb9(%rbx)
jne 0x5401
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xc0(%rax)
testq %rax, %rax
setne %bpl
movq %rbx, %rdi
callq 0x5758
testb %al, %al
je 0x5401
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
leaq 0x8(%rsp), %r9
andq $0x0, (%r9)
movq 0x98(%rbx), %rsi
movq 0x78(%rbx), %rdx
movq 0x88(%rbx), %rcx
movq (%rsi), %r10
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %r8
callq *0x10(%r10)
cmpq $0x0, (%r14)
je 0x53f9
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0xa0(%rax)
addq $0x78, %rbx
movq (%rsp), %rsi
andq $0x0, (%rsp)
movq %rbx, %rdi
callq 0x5744
movq %rsp, %rdi
callq 0x5518
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5518
movq %rbx, %rdi
callq 0x3280
nop
|
/serge1[P]ELFIO/elfio/elfio_section.hpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::save(std::ostream&, std::fpos<__mbstate_t>, std::fpos<__mbstate_t>)
|
void save( std::ostream& stream,
std::streampos header_offset,
std::streampos data_offset ) override
{
if ( 0 != get_index() ) {
header.sh_offset = decltype( header.sh_offset )( data_offset );
header.sh_offset = ( *convertor )( header.sh_offset );
}
save_header( stream, header_offset );
if ( get_type() != SHT_NOBITS && get_type() != SHT_NULL &&
get_size() != 0 && data != nullptr ) {
save_data( stream, data_offset );
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rax
callq *0x10(%rax)
testw %ax, %ax
je 0x5466
movq 0x88(%r12), %rax
movq %r14, %rcx
bswapq %rcx
cmpb $0x0, (%rax)
cmoveq %r14, %rcx
movq %rcx, 0x28(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x5788
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x8, %eax
je 0x54cd
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
testl %eax, %eax
je 0x54cd
movq (%r12), %rax
movq %r12, %rdi
callq *0x98(%rax)
testq %rax, %rax
je 0x54cd
cmpq $0x0, 0x78(%r12)
je 0x54cd
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x57b6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/serge1[P]ELFIO/elfio/elfio_section.hpp
|
ELFIO::section_impl<ELFIO::Elf64_Shdr>::save_data(std::ostream&, std::fpos<__mbstate_t>)
|
void save_data( std::ostream& stream, std::streampos data_offset )
{
adjust_stream_size( stream, data_offset );
if ( ( ( get_flags() & SHF_COMPRESSED ) ||
( get_flags() & SHF_RPX_DEFLATE ) ) &&
compression != nullptr ) {
Elf_Xword decompressed_size = get_size();
Elf_Xword compressed_size = 0;
auto compressed_ptr = compression->deflate(
data.get(), convertor, decompressed_size, compressed_size );
stream.write( compressed_ptr.get(), compressed_size );
}
else {
stream.write( get_data(), get_size() );
}
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x5897
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
btl $0xb, %eax
jb 0x57ee
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
btl $0x1b, %eax
jae 0x5852
cmpq $0x0, 0x98(%r14)
je 0x5852
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq 0x98(%r14), %rsi
movq 0x78(%r14), %rdx
movq 0x88(%r14), %rcx
movq (%rsi), %r10
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %r8
movq %r15, %r9
callq *0x18(%r10)
movq (%r14), %rsi
movq (%r15), %rdx
movq %rbx, %rdi
callq 0x31d0
movq %rsp, %rdi
callq 0x5518
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq %r14, %rdi
callq *0xc0(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x31d0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5518
movq %rbx, %rdi
callq 0x3280
|
/serge1[P]ELFIO/elfio/elfio_section.hpp
|
ELFIO::adjust_stream_size(std::ostream&, long)
|
inline void adjust_stream_size( std::ostream& stream, std::streamsize offset )
{
stream.seekp( 0, std::ios_base::end );
if ( stream.tellp() < offset ) {
std::streamsize size = offset - stream.tellp();
stream.write( std::string( size_t( size ), '\0' ).c_str(), size );
}
stream.seekp( offset );
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x3140
movq %r14, %rdi
callq 0x3120
cmpq %rbx, %rax
jge 0x5901
movq %r14, %rdi
callq 0x3120
movq %rbx, %r15
subq %rax, %r15
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3180
movq (%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x31d0
leaq 0x8(%rsp), %rdi
callq 0x30a0
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3190
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x3280
nop
|
/serge1[P]ELFIO/elfio/elfio_utils.hpp
|
ELFIO::section_impl<ELFIO::Elf32_Shdr>::get_data() const
|
const char* get_data() const override
{
// If data load failed, the stream is corrupt
// When lazy loading, attempts to call get_data() on it after initial load are useless
// When loading non-lazily, that load_data() will attempt to read data from
// the stream specified on load() call, which might be freed by this point
if ( !is_loaded && can_be_loaded ) {
bool res = load_data();
if ( !res ) {
can_be_loaded = false;
}
}
return data.get();
}
|
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xa1(%rdi)
jne 0x5bef
cmpb $0x1, 0xa2(%rbx)
jne 0x5bef
movq %rbx, %rdi
callq 0x6156
testb %al, %al
jne 0x5bef
movb $0x0, 0xa2(%rbx)
movq 0x60(%rbx), %rax
popq %rbx
retq
nop
|
/serge1[P]ELFIO/elfio/elfio_section.hpp
|
ELFIO::section_impl<ELFIO::Elf32_Shdr>::set_data(char const*, unsigned long)
|
void set_data( const char* raw_data, Elf_Xword size ) override
{
if ( get_type() != SHT_NOBITS ) {
data = std::unique_ptr<char[]>( new ( std::nothrow ) char[(size_t)size] );
if ( nullptr != data.get() && nullptr != raw_data ) {
data_size = size;
std::copy( raw_data, raw_data + size, data.get() );
}
else {
data_size = 0;
}
}
set_size( data_size );
if ( translator->empty() ) {
set_stream_size( (size_t)data_size );
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x8, %eax
je 0x5c8e
movq 0xa385(%rip), %rsi # 0xffc0
movq %r14, %rdi
callq 0x3250
leaq 0x60(%rbx), %rdi
movq %rsp, %r12
andq $0x0, (%r12)
movq %rax, %rsi
callq 0x5744
movq %r12, %rdi
callq 0x5518
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x5c89
movq %r14, 0x68(%rbx)
testq %r14, %r14
je 0x5c8e
movq %r15, %rsi
movq %r14, %rdx
callq 0x3230
jmp 0x5c8e
andq $0x0, 0x68(%rbx)
leaq 0x68(%rbx), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
movq 0x78(%rbx), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jne 0x5cbb
movq (%rbx), %rax
movq 0x68(%rbx), %rsi
movq %rbx, %rdi
callq *0x108(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/serge1[P]ELFIO/elfio/elfio_section.hpp
|
ELFIO::section_impl<ELFIO::Elf32_Shdr>::insert_data(unsigned long, char const*, unsigned long)
|
void
insert_data( Elf_Xword pos, const char* raw_data, Elf_Xword size ) override
{
if ( get_type() != SHT_NOBITS ) {
// Check for valid position
if ( pos > get_size() ) {
return; // Invalid position
}
// Check for integer overflow in size calculation
Elf_Xword new_size = get_size();
if ( size > std::numeric_limits<Elf_Xword>::max() - new_size ) {
return; // Size would overflow
}
new_size += size;
if ( new_size <= data_size ) {
char* d = data.get();
std::copy_backward( d + pos, d + get_size(),
d + get_size() + size );
std::copy( raw_data, raw_data + size, d + pos );
}
else {
// Calculate new size with overflow check
Elf_Xword new_data_size = data_size;
if ( new_data_size > std::numeric_limits<Elf_Xword>::max() / 2 ) {
return; // Multiplication would overflow
}
new_data_size *= 2;
if ( size > std::numeric_limits<Elf_Xword>::max() - new_data_size ) {
return; // Addition would overflow
}
new_data_size += size;
// Check if the size would overflow size_t
if (new_data_size > std::numeric_limits<size_t>::max()) {
return; // Size would overflow size_t
}
std::unique_ptr<char[]> new_data(
new (std::nothrow) char[(size_t)new_data_size]);
if ( nullptr != new_data ) {
char* d = data.get();
std::copy( d, d + pos, new_data.get() );
std::copy( raw_data, raw_data + size,
new_data.get() + pos );
std::copy( d + pos, d + get_size(),
new_data.get() + pos + size );
data = std::move( new_data );
data_size = new_data_size;
}
else {
return; // Allocation failed
}
}
set_size( new_size );
if ( translator->empty() ) {
set_stream_size( get_stream_size() + (size_t)size );
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x8, %eax
je 0x5eec
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
cmpq %r15, %rax
jb 0x5eec
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
addq %rbx, %rax
jb 0x5eec
movq %rax, 0x10(%rsp)
movq 0x68(%r14), %r13
cmpq %r13, %rax
jbe 0x5e4a
testq %r13, %r13
js 0x5eec
addq %r13, %r13
addq %rbx, %r13
jb 0x5eec
movq 0xa215(%rip), %rsi # 0xffc0
movq %r13, %rdi
callq 0x3250
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x5ee2
movq %rax, %rbp
movq 0x60(%r14), %rax
testq %r15, %r15
movq %rax, (%rsp)
je 0x5de0
movq %rbp, %rdi
movq (%rsp), %rsi
movq %r15, %rdx
callq 0x3230
testq %rbx, %rbx
je 0x5df6
addq %r15, %rbp
movq %rbp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3110
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
leaq 0x60(%r14), %r12
movq 0x8(%rsp), %rbp
subq %r15, %rax
movq (%rsp), %rsi
je 0x5e28
addq %r15, %rsi
addq %rbp, %r15
addq %rbx, %r15
movq %r15, %rdi
movq %rax, %rdx
callq 0x3230
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5744
movq %r13, 0x68(%r14)
movq %r15, %rdi
callq 0x5518
jmp 0x5ea4
movq (%r14), %rax
movq 0x60(%r14), %rbp
leaq (%r15,%rbp), %rcx
movq %rcx, (%rsp)
movq %r14, %rdi
callq *0x98(%rax)
movq %rax, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
subq %r15, %r13
movq (%rsp), %r15
je 0x5e91
addq %rax, %rbp
addq %rbx, %rbp
subq %r13, %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3230
testq %rbx, %rbx
je 0x5ea4
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3230
movq (%r14), %rax
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq *0xa0(%rax)
movq 0x78(%r14), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jne 0x5eec
movq (%r14), %rax
movq %r14, %rdi
callq *0x100(%rax)
addq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x108(%rax)
jmp 0x5eec
leaq 0x8(%rsp), %rdi
callq 0x5518
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5518
movq %rbx, %rdi
callq 0x3280
|
/serge1[P]ELFIO/elfio/elfio_section.hpp
|
ELFIO::section_impl<ELFIO::Elf32_Shdr>::load(std::istream&, std::fpos<__mbstate_t>, bool)
|
bool load( std::istream& stream,
std::streampos header_offset,
bool is_lazy_ ) override
{
pstream = &stream;
is_lazy = is_lazy_;
if ( translator->empty() ) {
stream.seekg( 0, std::istream::end );
set_stream_size( size_t( stream.tellg() ) );
}
else {
set_stream_size( std::numeric_limits<size_t>::max() );
}
stream.seekg( ( *translator )[header_offset] );
stream.read( reinterpret_cast<char*>( &header ), sizeof( header ) );
if ( !( is_lazy || is_loaded ) ) {
bool ret = get_data();
if ( is_compressed() ) {
Elf_Xword size = get_size();
Elf_Xword uncompressed_size = 0;
auto decompressed_data = compression->inflate(
data.get(), convertor, size, uncompressed_size );
if ( decompressed_data != nullptr ) {
set_size( uncompressed_size );
data = std::move( decompressed_data );
}
}
return ret;
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movb %r8b, 0xa0(%rdi)
movq 0x78(%rdi), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x5f87
pushq $-0x1
popq %rsi
jmp 0x5f9f
pushq $0x2
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x31e0
movq %r14, %rdi
callq 0x3270
movq %rax, %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x108(%rax)
movq 0x78(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x45dc
movq %r14, %rdi
movq %rax, %rsi
callq 0x31b0
leaq 0x10(%rbx), %rsi
pushq $0x28
popq %rdx
movq %r14, %rdi
callq 0x31a0
movb $0x1, %bpl
cmpb $0x0, 0xa0(%rbx)
jne 0x6078
cmpb $0x0, 0xa1(%rbx)
jne 0x6078
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xc0(%rax)
testq %rax, %rax
setne %bpl
movq %rbx, %rdi
callq 0x62c8
testb %al, %al
je 0x6078
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
leaq 0x8(%rsp), %r9
andq $0x0, (%r9)
movq 0x80(%rbx), %rsi
movq 0x60(%rbx), %rdx
movq 0x70(%rbx), %rcx
movq (%rsi), %r10
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %r8
callq *0x10(%r10)
cmpq $0x0, (%r14)
je 0x6070
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0xa0(%rax)
addq $0x60, %rbx
movq (%rsp), %rsi
andq $0x0, (%rsp)
movq %rbx, %rdi
callq 0x5744
movq %rsp, %rdi
callq 0x5518
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5518
movq %rbx, %rdi
callq 0x3280
|
/serge1[P]ELFIO/elfio/elfio_section.hpp
|
ELFIO::section_impl<ELFIO::Elf32_Shdr>::load_data() const
|
bool load_data() const
{
Elf_Xword sh_offset = (*translator)[(*convertor)(header.sh_offset)];
Elf_Xword size = get_size();
// Check for integer overflow in offset calculation
if (sh_offset > get_stream_size()) {
return false;
}
// Check for integer overflow in size calculation
if (size > get_stream_size() ||
size > (get_stream_size() - sh_offset)) {
return false;
}
// Check if we need to load data
if (nullptr == data && SHT_NULL != get_type() && SHT_NOBITS != get_type()) {
// Check if size can be safely converted to size_t
if (size > std::numeric_limits<size_t>::max() - 1) {
return false;
}
data.reset(new (std::nothrow) char[size_t(size) + 1]);
if ((0 != size) && (nullptr != data)) {
pstream->seekg(sh_offset);
pstream->read(data.get(), size);
if (static_cast<Elf_Xword>(pstream->gcount()) != size) {
data.reset(nullptr);
data_size = 0;
return false;
}
data_size = size;
data.get()[size] = 0; // Safe now as we allocated size + 1
}
else {
data_size = 0;
if (size != 0) {
return false; // Failed to allocate required memory
}
}
is_loaded = true;
return true;
}
// Data already loaded or doesn't need loading
is_loaded = (nullptr != data) || (SHT_NULL == get_type()) || (SHT_NOBITS == get_type());
return is_loaded;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
movq 0x70(%rbx), %rax
movl 0x20(%rbx), %ecx
movl %ecx, %esi
bswapl %esi
cmpb $0x0, (%rax)
cmovel %ecx, %esi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x45dc
movq %rax, %r12
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x100(%rax)
cmpq %rax, %r12
ja 0x6222
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x100(%rax)
cmpq %rax, %r14
ja 0x61c9
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x100(%rax)
subq %r12, %rax
cmpq %rax, %r14
jbe 0x61ce
xorl %r15d, %r15d
jmp 0x6222
movb $0x1, %r15b
cmpq $0x0, 0x60(%rbx)
jne 0x621b
leaq 0x60(%rbx), %r13
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testl %eax, %eax
je 0x61f7
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x8, %eax
jne 0x622f
cmpq $0x0, (%r13)
jne 0x621b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testl %eax, %eax
je 0x621b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x8, %eax
sete %r15b
movb %r15b, 0xa1(%rbx)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq $-0x1, %r14
je 0x61c9
leaq 0x1(%r14), %rdi
movq 0x9d80(%rip), %rsi # 0xffc0
callq 0x3250
movq %r13, %rdi
movq %rax, %rsi
callq 0x5744
testq %r14, %r14
je 0x6293
cmpq $0x0, (%r13)
je 0x62a7
movq 0x8(%rbx), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x31b0
movq 0x8(%rbx), %rdi
movq 0x60(%rbx), %rsi
movq %r14, %rdx
callq 0x31a0
movq 0x8(%rbx), %rax
cmpq %r14, 0x8(%rax)
jne 0x62b1
movq %r14, 0x68(%rbx)
movq 0x60(%rbx), %rax
movb $0x0, (%rax,%r14)
jmp 0x6298
andq $0x0, 0x68(%rbx)
movb $0x1, 0xa1(%rbx)
movb $0x1, %r15b
jmp 0x6222
andq $0x0, 0x68(%rbx)
jmp 0x61c9
xorl %r15d, %r15d
movq %r13, %rdi
xorl %esi, %esi
callq 0x5744
andq $0x0, 0x68(%rbx)
jmp 0x6222
|
/serge1[P]ELFIO/elfio/elfio_section.hpp
|
ELFIO::elfio::save(std::ostream&)
|
bool save( std::ostream& stream )
{
if ( !stream || header == nullptr ) {
return false;
}
// Define layout specific header fields
// The position of the segment table is fixed after the header.
// The position of the section table is variable and needs to be fixed
// before saving.
header->set_segments_num( segments.size() );
header->set_segments_offset(
segments.size() > 0 ? header->get_header_size() : 0 );
header->set_sections_num( sections.size() );
header->set_sections_offset( 0 );
// Layout the first section right after the segment table
current_file_pos =
header->get_header_size() +
header->get_segment_entry_size() *
static_cast<Elf_Xword>( header->get_segments_num() );
calc_segment_alignment();
bool is_still_good = layout_segments_and_their_sections();
is_still_good = is_still_good && layout_sections_without_segments();
is_still_good = is_still_good && layout_section_table();
is_still_good = is_still_good && save_header( stream );
is_still_good = is_still_good && save_sections( stream );
is_still_good = is_still_good && save_segments( stream );
return is_still_good;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsi,%rax)
je 0x6430
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x6422
movq %rsi, %rbx
movq 0x8(%r14), %rax
movl 0x40(%rax), %ecx
subl 0x38(%rax), %ecx
shrl $0x3, %ecx
movq %rsp, %rsi
movw %cx, (%rsi)
movq (%rdi), %rax
callq *0xe8(%rax)
movq 0x18(%r14), %r15
movq 0x8(%r14), %rax
movl 0x40(%rax), %ecx
subl 0x38(%rax), %ecx
testl $0x7fff8, %ecx # imm = 0x7FFF8
je 0x647f
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movzwl %ax, %eax
jmp 0x6481
xorl %eax, %eax
movq %rsp, %r12
movq %rax, (%r12)
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0xf8(%rax)
movq (%r14), %rax
movl 0x28(%rax), %ecx
subl 0x20(%rax), %ecx
movq 0x18(%r14), %rdi
shrl $0x3, %ecx
movw %cx, (%r12)
movq (%rdi), %rax
movq %rsp, %r15
movq %r15, %rsi
callq *0xc8(%rax)
movq 0x18(%r14), %rdi
andq $0x0, (%r15)
movq (%rdi), %rax
movq %rsp, %rsi
callq *0xd8(%rax)
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movzwl %ax, %r15d
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movzwl %ax, %r12d
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0xe0(%rax)
movzwl %ax, %eax
imulq %r12, %rax
addq %r15, %rax
movq %rax, 0x80(%r14)
movq %r14, %rdi
callq 0x657a
movq %r14, %rdi
callq 0x6622
testb %al, %al
je 0x6422
movq %r14, %rdi
callq 0x694c
testb %al, %al
je 0x6422
movq %r14, %rdi
callq 0x6a1a
testb %al, %al
je 0x6422
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
testb %al, %al
je 0x6422
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a4c
testb %al, %al
je 0x6422
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6ae0
jmp 0x6424
nop
|
/serge1[P]ELFIO/elfio/elfio.hpp
|
ELFIO::elfio::layout_segments_and_their_sections()
|
bool layout_segments_and_their_sections()
{
std::vector<segment*> worklist;
std::vector<bool> section_generated( sections.size(), false );
// Get segments in a order in where segments which contain a
// sub sequence of other segments are located at the end
worklist = get_ordered_segments();
for ( auto* seg : worklist ) {
Elf_Xword segment_memory = 0;
Elf_Xword segment_filesize = 0;
Elf_Xword seg_start_pos = current_file_pos;
// Special case: PHDR segment
// This segment contains the program headers but no sections
if ( seg->get_type() == PT_PHDR && seg->get_sections_num() == 0 ) {
seg_start_pos = header->get_segments_offset();
segment_memory = segment_filesize =
header->get_segment_entry_size() *
static_cast<Elf_Xword>( header->get_segments_num() );
}
// Special case:
else if ( seg->is_offset_initialized() && seg->get_offset() == 0 ) {
seg_start_pos = 0;
if ( seg->get_sections_num() > 0 ) {
segment_memory = segment_filesize = current_file_pos;
}
}
// New segments with not generated sections
// have to be aligned
else if ( seg->get_sections_num() > 0 &&
!section_generated[seg->get_section_index_at( 0 )] ) {
Elf_Xword align = seg->get_align() > 0 ? seg->get_align() : 1;
Elf64_Off cur_page_alignment = current_file_pos % align;
Elf64_Off req_page_alignment =
seg->get_virtual_address() % align;
Elf64_Off adjustment = req_page_alignment - cur_page_alignment;
current_file_pos += ( seg->get_align() + adjustment ) % align;
seg_start_pos = current_file_pos;
}
else if ( seg->get_sections_num() > 0 ) {
seg_start_pos =
sections[seg->get_section_index_at( 0 )]->get_offset();
}
// Write segment's data
if ( !write_segment_data( seg, section_generated, segment_memory,
segment_filesize, seg_start_pos ) ) {
return false;
}
seg->set_file_size( segment_filesize );
// If we already have a memory size from loading an elf file (value > 0),
// it must not shrink!
// Memory size may be bigger than file size and it is the loader's job to do something
// with the surplus bytes in memory, like initializing them with a defined value.
if ( seg->get_memory_size() < segment_memory ) {
seg->set_memory_size( segment_memory );
}
seg->set_offset( seg_start_pos );
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
movq (%rdi), %rax
movl 0x28(%rax), %ecx
subl 0x20(%rax), %ecx
shrl $0x3, %ecx
movzwl %cx, %esi
leaq 0x20(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x60(%rsp), %rdi
leaq 0x10(%rsp), %rcx
callq 0x6b74
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x6bd8
leaq 0x40(%rsp), %r14
leaq 0x20(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x7ace
movq %r12, %rdi
callq 0x7b20
movq (%r14), %r13
movq 0x8(%r14), %rbx
movq %r15, 0x18(%rsp)
movq %rbx, 0x38(%rsp)
cmpq %rbx, %r13
je 0x68f0
movq (%r13), %rbp
andq $0x0, 0x20(%rsp)
andq $0x0, 0x10(%rsp)
movq 0x80(%r15), %rax
movq %rax, 0x8(%rsp)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x18(%rax)
cmpl $0x6, %eax
jne 0x66ef
movq (%rbp), %rax
movq %rbp, %rdi
callq *0xb0(%rax)
testw %ax, %ax
je 0x6793
movq (%rbp), %rax
movq %rbp, %rdi
callq *0xc0(%rax)
testb %al, %al
je 0x6716
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x88(%rax)
testq %rax, %rax
je 0x685b
movq (%rbp), %rax
movq %rbp, %rdi
callq *0xb0(%rax)
testw %ax, %ax
je 0x674d
movq (%rbp), %rax
movq %rbp, %rdi
xorl %esi, %esi
callq *0xb8(%rax)
movzwl %ax, %esi
leaq 0x60(%rsp), %rdi
callq 0x6dc0
testq %rdx, (%rax)
je 0x67cf
movq (%rbp), %rax
movq %rbp, %rdi
callq *0xb0(%rax)
testw %ax, %ax
je 0x6884
movq (%rbp), %rax
movq %rbp, %rdi
xorl %esi, %esi
callq *0xb8(%rax)
movq (%r15), %rcx
movq 0x20(%rcx), %rcx
movzwl %ax, %eax
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0xb8(%rax)
movq %rax, 0x8(%rsp)
jmp 0x6884
movq 0x18(%r15), %rdi
movq (%rdi), %rax
callq *0xf0(%rax)
movq %rax, 0x8(%rsp)
movq 0x18(%r15), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movl %eax, %r14d
movq 0x18(%r15), %rdi
movq (%rdi), %rax
callq *0xe0(%rax)
movzwl %r14w, %ecx
movzwl %ax, %eax
imulq %rcx, %rax
jmp 0x687a
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x38(%rax)
pushq $0x1
popq %r15
testq %rax, %rax
je 0x67ef
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x38(%rax)
movq %rax, %r15
movq %r12, %rbx
movq 0x18(%rsp), %rax
movq 0x80(%rax), %r14
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x48(%rax)
movq %rax, %r12
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x38(%rax)
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %r15
movq %rdx, %rsi
movq %r14, %rax
xorl %edx, %edx
divq %r15
addq %rcx, %rsi
subq %rdx, %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %r15
movq 0x18(%rsp), %r15
addq 0x80(%r15), %rdx
movq %rdx, 0x80(%r15)
movq %rdx, 0x8(%rsp)
movq %rbx, %r12
movq 0x38(%rsp), %rbx
jmp 0x6884
andq $0x0, 0x8(%rsp)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0xb0(%rax)
testw %ax, %ax
je 0x6884
movq 0x80(%r15), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x20(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
leaq 0x60(%rsp), %rdx
movq %r12, %rcx
leaq 0x10(%rsp), %r8
leaq 0x8(%rsp), %r9
callq 0x6dde
testb %al, %al
je 0x68f0
movq (%rbp), %rax
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
callq *0x70(%rax)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x78(%rax)
cmpq 0x20(%rsp), %rax
jae 0x68d5
movq (%rbp), %rax
movq %rbp, %rdi
movq %r12, %rsi
callq *0x80(%rax)
movq (%rbp), %rax
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
callq *0xc8(%rax)
addq $0x8, %r13
jmp 0x66a5
cmpq %rbx, %r13
sete %bl
leaq 0x60(%rsp), %rdi
callq 0x70ce
leaq 0x40(%rsp), %rdi
callq 0x7b20
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x692d
movq %rax, %rbx
jmp 0x693a
jmp 0x692d
jmp 0x692d
jmp 0x692d
jmp 0x692d
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x70ce
leaq 0x40(%rsp), %rdi
callq 0x7b20
movq %rbx, %rdi
callq 0x3280
|
/serge1[P]ELFIO/elfio/elfio.hpp
|
bool ELFIO::relocation_section_accessor_template<ELFIO::section>::generic_get_entry_rela<ELFIO::Elf32_Rela>(unsigned long, unsigned long&, unsigned int&, unsigned int&, long&) const
|
bool generic_get_entry_rela( Elf_Xword index,
Elf64_Addr& offset,
Elf_Word& symbol,
unsigned& type,
Elf_Sxword& addend ) const
{
const endianness_convertor& convertor = elf_file.get_convertor();
if ( relocation_section->get_entry_size() < sizeof( T ) ) {
return false;
}
const T* pEntry = reinterpret_cast<const T*>(
relocation_section->get_data() +
index * relocation_section->get_entry_size() );
offset = convertor( pEntry->r_offset );
Elf_Xword tmp = convertor( pEntry->r_info );
symbol = get_sym_and_type<T>::get_r_sym( tmp );
type = get_sym_and_type<T>::get_r_type( tmp );
addend = convertor( pEntry->r_addend );
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, %r12
cmpq $0xc, %rax
jb 0x8cc5
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movq %rbp, (%rsp)
movq %rax, %rbp
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
imulq %rbx, %rax
movl (%rbp,%rax), %ecx
movl %ecx, %edx
bswapl %edx
movb 0x50(%r15), %sil
testb %sil, %sil
cmovel %ecx, %edx
movq %rdx, (%r13)
movl 0x4(%rbp,%rax), %ecx
movl %ecx, %edx
bswapl %edx
cmovel %ecx, %edx
movzbl %dl, %ecx
shrl $0x8, %edx
testb %sil, %sil
movq 0x8(%rsp), %rsi
movl %edx, (%rsi)
movq 0x10(%rsp), %rdx
movl %ecx, (%rdx)
movl 0x8(%rbp,%rax), %eax
movl %eax, %ecx
bswapl %ecx
cmovel %eax, %ecx
movslq %ecx, %rax
movq (%rsp), %rcx
movq %rax, (%rcx)
cmpq $0xc, %r12
setae %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/serge1[P]ELFIO/elfio/elfio_relocation.hpp
|
bool ELFIO::relocation_section_accessor_template<ELFIO::section>::generic_get_entry_rel<ELFIO::Elf64_Rel>(unsigned long, unsigned long&, unsigned int&, unsigned int&, long&) const
|
bool generic_get_entry_rel( Elf_Xword index,
Elf64_Addr& offset,
Elf_Word& symbol,
unsigned& type,
Elf_Sxword& addend ) const
{
const endianness_convertor& convertor = elf_file.get_convertor();
if ( relocation_section->get_entry_size() < sizeof( T ) ) {
return false;
}
const T* pEntry = reinterpret_cast<const T*>(
relocation_section->get_data() +
index * relocation_section->get_entry_size() );
offset = convertor( pEntry->r_offset );
Elf_Xword tmp = convertor( pEntry->r_info );
symbol = get_sym_and_type<T>::get_r_sym( tmp );
type = get_sym_and_type<T>::get_r_type( tmp );
addend = 0;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, %r12
cmpq $0x10, %rax
jb 0x8d7b
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movq %r14, (%rsp)
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
imulq %rbp, %rax
movq (%r14,%rax), %rcx
movq %rcx, %rdx
bswapq %rdx
cmpb $0x0, 0x50(%r15)
cmoveq %rcx, %rdx
movq %rdx, (%r13)
movq 0x8(%r14,%rax), %rax
movq %rax, %rcx
bswapq %rcx
cmoveq %rax, %rcx
movq %rcx, %rax
shrq $0x20, %rax
movq 0x8(%rsp), %rdx
movl %eax, (%rdx)
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq (%rsp), %rax
andq $0x0, (%rax)
cmpq $0x10, %r12
setae %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/serge1[P]ELFIO/elfio/elfio_relocation.hpp
|
bool ELFIO::relocation_section_accessor_template<ELFIO::section>::generic_get_entry_rela<ELFIO::Elf64_Rela>(unsigned long, unsigned long&, unsigned int&, unsigned int&, long&) const
|
bool generic_get_entry_rela( Elf_Xword index,
Elf64_Addr& offset,
Elf_Word& symbol,
unsigned& type,
Elf_Sxword& addend ) const
{
const endianness_convertor& convertor = elf_file.get_convertor();
if ( relocation_section->get_entry_size() < sizeof( T ) ) {
return false;
}
const T* pEntry = reinterpret_cast<const T*>(
relocation_section->get_data() +
index * relocation_section->get_entry_size() );
offset = convertor( pEntry->r_offset );
Elf_Xword tmp = convertor( pEntry->r_info );
symbol = get_sym_and_type<T>::get_r_sym( tmp );
type = get_sym_and_type<T>::get_r_type( tmp );
addend = convertor( pEntry->r_addend );
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, %r12
cmpq $0x18, %rax
jb 0x8e44
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movq %r14, (%rsp)
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
imulq %rbp, %rax
movq (%r14,%rax), %rcx
movq %rcx, %rdx
bswapq %rdx
movb 0x50(%r15), %sil
testb %sil, %sil
cmoveq %rcx, %rdx
movq %rdx, (%r13)
movq 0x8(%r14,%rax), %rcx
movq %rcx, %rdx
bswapq %rdx
cmoveq %rcx, %rdx
movq %rdx, %rcx
shrq $0x20, %rcx
movq 0x8(%rsp), %rdi
movl %ecx, (%rdi)
movq 0x10(%rsp), %rcx
movl %edx, (%rcx)
movq 0x10(%r14,%rax), %rax
movq %rax, %rcx
bswapq %rcx
testb %sil, %sil
cmoveq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
cmpq $0x18, %r12
setae %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/serge1[P]ELFIO/elfio/elfio_relocation.hpp
|
void ELFIO::relocation_section_accessor_template<ELFIO::section>::generic_set_entry_rela<ELFIO::Elf32_Rela>(unsigned long, unsigned long, unsigned int, unsigned int, long)
|
void generic_set_entry_rela( Elf_Xword index,
Elf64_Addr offset,
Elf_Word symbol,
unsigned type,
Elf_Sxword addend )
{
const endianness_convertor& convertor = elf_file.get_convertor();
T* pEntry = const_cast<T*>( reinterpret_cast<const T*>(
relocation_section->get_data() +
index * relocation_section->get_entry_size() ) );
if ( elf_file.get_class() == ELFCLASS32 ) {
pEntry->r_info = ELF32_R_INFO( (Elf_Xword)symbol, type );
}
else {
pEntry->r_info = ELF64_R_INFO( (Elf_Xword)symbol, type );
}
pEntry->r_offset = decltype( pEntry->r_offset )( offset );
pEntry->r_addend = decltype( pEntry->r_addend )( addend );
pEntry->r_offset = convertor( pEntry->r_offset );
pEntry->r_info = convertor( pEntry->r_info );
pEntry->r_addend = convertor( pEntry->r_addend );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, 0x4(%rsp)
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
movq %rdi, %r13
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movq %rax, %r14
movq 0x8(%r13), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, %r12
movq (%r13), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x8f60
movq (%rdi), %rax
callq *0x20(%rax)
cmpb $0x1, %al
jne 0x8f60
movl 0x4(%rsp), %eax
shll $0x8, %eax
movzbl %bpl, %ebp
orl %eax, %ebp
imulq 0x8(%rsp), %r12
movl %r15d, %eax
bswapl %eax
movq 0x10(%rsp), %rcx
cmpb $0x0, 0x50(%rcx)
cmovel %r15d, %eax
movl %eax, (%r14,%r12)
movl %ebp, %eax
bswapl %eax
cmovel %ebp, %eax
movl %eax, 0x4(%r14,%r12)
movl %ebx, %eax
bswapl %eax
cmovel %ebx, %eax
movl %eax, 0x8(%r14,%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/serge1[P]ELFIO/elfio/elfio_relocation.hpp
|
void ELFIO::relocation_section_accessor_template<ELFIO::section>::generic_set_entry_rel<ELFIO::Elf64_Rel>(unsigned long, unsigned long, unsigned int, unsigned int, long)
|
void generic_set_entry_rel( Elf_Xword index,
Elf64_Addr offset,
Elf_Word symbol,
unsigned type,
Elf_Sxword )
{
const endianness_convertor& convertor = elf_file.get_convertor();
T* pEntry = const_cast<T*>( reinterpret_cast<const T*>(
relocation_section->get_data() +
index * relocation_section->get_entry_size() ) );
if ( elf_file.get_class() == ELFCLASS32 ) {
pEntry->r_info = ELF32_R_INFO( (Elf_Xword)symbol, type );
}
else {
pEntry->r_info = ELF64_R_INFO( (Elf_Xword)symbol, type );
}
pEntry->r_offset = decltype( pEntry->r_offset )( offset );
pEntry->r_offset = convertor( pEntry->r_offset );
pEntry->r_info = convertor( pEntry->r_info );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
movq %rax, %r14
movq 0x8(%r12), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, %r13
movq (%r12), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x900d
movq (%rdi), %rax
callq *0x20(%rax)
cmpb $0x1, %al
jne 0x900d
movl %r15d, %r15d
shlq $0x8, %r15
movzbl %bpl, %ebp
jmp 0x9011
shlq $0x20, %r15
imulq 0x8(%rsp), %r13
movl %ebp, %eax
orq %r15, %rax
movq %rbx, %rcx
bswapq %rcx
movq 0x10(%rsp), %rdx
cmpb $0x0, 0x50(%rdx)
cmoveq %rbx, %rcx
movq %rax, %rdx
bswapq %rdx
movq %rcx, (%r14,%r13)
cmoveq %rax, %rdx
movq %rdx, 0x8(%r14,%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/serge1[P]ELFIO/elfio/elfio_relocation.hpp
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>::hex_writer>::operator()<char*>(char*&&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x8bf84
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x85a60
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %r15
movq 0x20(%r14), %r12
movq %r15, %r13
testq %r12, %r12
je 0x8bfa6
leaq (%r15,%r12), %r13
movl 0x18(%r14), %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x85330
movq %r13, (%rbx)
movq 0x28(%r14), %rcx
movslq 0x30(%r14), %rdx
movq 0x8(%rcx), %rax
addq %rdx, %r13
cmpb $0x78, 0x11(%rax)
leaq 0x7a8b6(%rip), %rsi # 0x106879
leaq 0x7a89e(%rip), %rax # 0x106868
cmoveq %rsi, %rax
movl 0x10(%rcx), %ecx
addq %rdx, %r12
leaq (%r15,%r12), %rdx
decq %rdx
movl %ecx, %esi
movl %ecx, %edi
andl $0xf, %edi
movb (%rax,%rdi), %dil
movb %dil, (%rdx)
shrl $0x4, %esi
decq %rdx
cmpl $0xf, %ecx
movl %esi, %ecx
ja 0x8bfdd
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>::bin_writer<3>>::operator()<char*>(char*&&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x8c64c
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x85a60
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %r15
movq 0x20(%r14), %r12
movq %r15, %r13
testq %r12, %r12
je 0x8c66e
leaq (%r15,%r12), %r13
movl 0x18(%r14), %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x85330
movq %r13, (%rbx)
movl 0x28(%r14), %eax
movslq 0x2c(%r14), %rcx
addq %rcx, %r13
addq %rcx, %r12
leaq (%r15,%r12), %rcx
decq %rcx
movl %eax, %edx
movl %eax, %esi
andb $0x7, %sil
orb $0x30, %sil
movb %sil, (%rcx)
shrl $0x3, %edx
decq %rcx
cmpl $0x7, %eax
movl %edx, %eax
ja 0x8c688
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::hex_writer>>(fmt::v5::align_spec const&, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::hex_writer>&&)
|
void write_padded(const align_spec &spec, F &&f) {
unsigned width = spec.width(); // User-perceived width (in code points).
size_t size = f.size(); // The number of code units.
size_t num_code_points = width != 0 ? f.width() : size;
if (width <= num_code_points)
return f(reserve(size));
auto &&it = reserve(width + (size - num_code_points));
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - num_code_points;
if (spec.align() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl (%rsi), %eax
movq (%rdx), %r15
movq %rax, %r14
subq %r15, %r14
jbe 0x8d594
movq %rsi, %r13
movq %r12, 0x10(%rsp)
movq (%rdi), %rbp
movq 0x10(%rbp), %r12
movq %rax, 0x8(%rsp)
leaq (%r12,%rax), %rbx
cmpq %rbx, 0x18(%rbp)
jae 0x8d540
movq (%rbp), %rax
movq %rbp, %rdi
movq %rbx, %rsi
callq *(%rax)
movq %rbx, 0x10(%rbp)
addq 0x8(%rbp), %r12
movq %r12, (%rsp)
movb 0x4(%r13), %bpl
movl 0x8(%r13), %eax
cmpl $0x3, %eax
je 0x8d5c7
cmpl $0x2, %eax
jne 0x8d60b
cmpq %r15, 0x8(%rsp)
je 0x8d57f
leaq (%r12,%r14), %rbx
movzbl %bpl, %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x85330
movq %rbx, %r12
movq %rsp, %rsi
movq %r12, (%rsi)
movq 0x10(%rsp), %rdi
callq 0x8d6fc
jmp 0x8d63c
movq (%rdi), %r14
movq 0x10(%r14), %rbx
addq %rbx, %r15
cmpq %r15, 0x18(%r14)
jae 0x8d5af
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *(%rax)
movq %r15, 0x10(%r14)
addq 0x8(%r14), %rbx
movq %rsp, %rsi
movq %rbx, (%rsi)
movq %r12, %rdi
callq 0x8d64c
jmp 0x8d63c
movq %r14, %r13
shrq %r13
cmpq $0x2, %r14
jb 0x8d5e9
leaq (%r12,%r13), %rbx
movzbl %bpl, %esi
movq %r12, %rdi
movq %r13, %rdx
callq 0x85330
movq %rbx, %r12
movq %rsp, %rbx
movq %r12, (%rbx)
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x8d6fc
movq (%rbx), %rdi
cmpq %r15, 0x8(%rsp)
je 0x8d638
subq %r13, %r14
jmp 0x8d625
movq %rsp, %rbx
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x8d6fc
movq (%rbx), %rdi
cmpq %r15, 0x8(%rsp)
je 0x8d638
leaq (%rdi,%r14), %rbx
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x85330
movq %rbx, %rdi
movq %rdi, (%rsp)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::hex_writer>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x8d72c
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x85a60
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %r15
movq 0x20(%r14), %r12
movq %r15, %r13
testq %r12, %r12
je 0x8d74e
leaq (%r15,%r12), %r13
movl 0x18(%r14), %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x85330
movq %r13, (%rbx)
movq 0x28(%r14), %rcx
movslq 0x30(%r14), %rdx
movq 0x8(%rcx), %rax
addq %rdx, %r13
cmpb $0x78, 0x11(%rax)
leaq 0x7910e(%rip), %rsi # 0x106879
leaq 0x790f6(%rip), %rax # 0x106868
cmoveq %rsi, %rax
movl 0x10(%rcx), %ecx
addq %rdx, %r12
leaq (%r15,%r12), %rdx
decq %rdx
movl %ecx, %esi
movl %ecx, %edi
andl $0xf, %edi
movb (%rax,%rdi), %dil
movb %dil, (%rdx)
shrl $0x4, %esi
decq %rdx
cmpl $0xf, %ecx
movl %esi, %ecx
ja 0x8d785
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<3>>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x8ddd8
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x85a60
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %r15
movq 0x20(%r14), %r12
movq %r15, %r13
testq %r12, %r12
je 0x8ddfa
leaq (%r15,%r12), %r13
movl 0x18(%r14), %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x85330
movq %r13, (%rbx)
movl 0x28(%r14), %eax
movslq 0x2c(%r14), %rcx
addq %rcx, %r13
addq %rcx, %r12
leaq (%r15,%r12), %rcx
decq %rcx
movl %eax, %edx
movl %eax, %esi
andb $0x7, %sil
orb $0x30, %sil
movb %sil, (%rcx)
shrl $0x3, %edx
decq %rcx
cmpl $0x7, %eax
movl %edx, %eax
ja 0x8de14
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x8e101
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x85a60
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x8e11d
leaq (%rdi,%rdx), %r15
movl 0x18(%r14), %esi
callq 0x85330
movq %r15, %rdi
movq %rdi, (%rbx)
addq $0x28, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8e13a
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::on_hex()
|
void on_hex() {
if (spec.has(HASH_FLAG)) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = static_cast<char>(spec.type);
}
int num_digits = count_digits<4>();
writer.write_int(num_digits, get_prefix(), spec,
hex_writer{*this, num_digits});
}
|
movq 0x8(%rdi), %r8
testb $0x8, 0x10(%r8)
je 0x8e548
movl 0x1c(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1c(%rdi)
movb $0x30, 0x18(%rdi,%rax)
movb 0x11(%r8), %al
movl 0x1c(%rdi), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x1c(%rdi)
movb %al, 0x18(%rdi,%rcx)
movq 0x10(%rdi), %rax
xorl %esi, %esi
movq %rax, %rcx
incl %esi
shrq $0x4, %rcx
cmpq $0xf, %rax
movq %rcx, %rax
ja 0x8e551
subq $0x28, %rsp
movq (%rdi), %rax
leaq 0x18(%rdi), %rdx
movl 0x1c(%rdi), %ecx
movq %rdi, 0x18(%rsp)
movl %esi, 0x20(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rax, %rdi
callq 0x8eb3c
addq $0x28, %rsp
retq
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::dec_writer>>(fmt::v5::align_spec const&, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::dec_writer>&&)
|
void write_padded(const align_spec &spec, F &&f) {
unsigned width = spec.width(); // User-perceived width (in code points).
size_t size = f.size(); // The number of code units.
size_t num_code_points = width != 0 ? f.width() : size;
if (width <= num_code_points)
return f(reserve(size));
auto &&it = reserve(width + (size - num_code_points));
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - num_code_points;
if (spec.align() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl (%rsi), %eax
movq (%rdx), %r15
movq %rax, %r14
subq %r15, %r14
jbe 0x8e8c4
movq %rsi, %r13
movq %r12, 0x10(%rsp)
movq (%rdi), %rbp
movq 0x10(%rbp), %r12
movq %rax, 0x8(%rsp)
leaq (%r12,%rax), %rbx
cmpq %rbx, 0x18(%rbp)
jae 0x8e870
movq (%rbp), %rax
movq %rbp, %rdi
movq %rbx, %rsi
callq *(%rax)
movq %rbx, 0x10(%rbp)
addq 0x8(%rbp), %r12
movq %r12, (%rsp)
movb 0x4(%r13), %bpl
movl 0x8(%r13), %eax
cmpl $0x3, %eax
je 0x8e8f7
cmpl $0x2, %eax
jne 0x8e93b
cmpq %r15, 0x8(%rsp)
je 0x8e8af
leaq (%r12,%r14), %rbx
movzbl %bpl, %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x85330
movq %rbx, %r12
movq %rsp, %rsi
movq %r12, (%rsi)
movq 0x10(%rsp), %rdi
callq 0x8e9e4
jmp 0x8e96c
movq (%rdi), %r14
movq 0x10(%r14), %rbx
addq %rbx, %r15
cmpq %r15, 0x18(%r14)
jae 0x8e8df
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *(%rax)
movq %r15, 0x10(%r14)
addq 0x8(%r14), %rbx
movq %rsp, %rsi
movq %rbx, (%rsi)
movq %r12, %rdi
callq 0x8e97c
jmp 0x8e96c
movq %r14, %r13
shrq %r13
cmpq $0x2, %r14
jb 0x8e919
leaq (%r12,%r13), %rbx
movzbl %bpl, %esi
movq %r12, %rdi
movq %r13, %rdx
callq 0x85330
movq %rbx, %r12
movq %rsp, %rbx
movq %r12, (%rbx)
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x8e9e4
movq (%rbx), %rdi
cmpq %r15, 0x8(%rsp)
je 0x8e968
subq %r13, %r14
jmp 0x8e955
movq %rsp, %rbx
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x8e9e4
movq (%rbx), %rdi
cmpq %r15, 0x8(%rsp)
je 0x8e968
leaq (%rdi,%r14), %rbx
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x85330
movq %rbx, %rdi
movq %rdi, (%rsp)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::bin_writer<3>>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x8f516
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x85a60
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %r15
movq 0x20(%r14), %r12
movq %r15, %r13
testq %r12, %r12
je 0x8f538
leaq (%r15,%r12), %r13
movl 0x18(%r14), %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x85330
movq %r13, (%rbx)
movq 0x28(%r14), %rax
movslq 0x30(%r14), %rcx
addq %rcx, %r13
addq %rcx, %r12
leaq (%r15,%r12), %rcx
decq %rcx
movq %rax, %rdx
movl %eax, %esi
andb $0x7, %sil
orb $0x30, %sil
movb %sil, (%rcx)
shrq $0x3, %rdx
decq %rcx
cmpq $0x7, %rax
movq %rdx, %rax
ja 0x8f553
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::num_writer::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
basic_string_view<char_type> s(&sep, SEP_SIZE);
it = internal::format_decimal<char_type>(
it, abs_value, size, internal::add_thousands_sep<char_type>(s));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movslq 0x8(%rdi), %r14
testq %r14, %r14
js 0x8fa20
movq %rsi, %rbx
movq (%rsi), %r15
movq (%rdi), %rsi
leaq (%rsp,%r14), %rcx
addq $0x10, %rcx
cmpq $0x64, %rsi
jb 0x8f9a2
movq %r15, (%rsp)
movq %rbx, 0x8(%rsp)
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
movl $0x1, %r9d
movl $0xfffffffe, %r10d # imm = 0xFFFFFFFE
movl $0x2, %r11d
movl $0xaaaaaaab, %r12d # imm = 0xAAAAAAAB
movabsq $0x28f5c28f5c28f5c3, %r13 # imm = 0x28F5C28F5C28F5C3
leaq 0x85f3c(%rip), %rbp # 0x115820
movl %r9d, %eax
imulq %r12, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %r15d
movq %rsi, %rax
shrq $0x2, %rax
mulq %r13
shrq $0x2, %rdx
imull $0x64, %edx, %ebx
movl %esi, %eax
subl %ebx, %eax
addl %eax, %eax
movb 0x1(%rbp,%rax), %bl
movb %bl, -0x1(%rcx)
movq $-0x1, %rbx
addl %r8d, %r15d
jne 0x8f92a
movb 0xc(%rdi), %bl
movb %bl, -0x2(%rcx)
movq $-0x2, %rbx
movl %r11d, %r15d
imulq %r12, %r15
shrq $0x21, %r15
leal (%r15,%r15,2), %r15d
movb (%rbp,%rax), %al
movb %al, -0x1(%rcx,%rbx)
addl %r10d, %r15d
je 0x8f94e
addq %rbx, %rcx
decq %rcx
jmp 0x8f95b
addq %rbx, %rcx
movb 0xc(%rdi), %al
movb %al, -0x2(%rcx)
addq $-0x2, %rcx
addl $-0x2, %r8d
addl $0x2, %r9d
addl $-0x2, %r10d
addl $0x2, %r11d
cmpq $0x270f, %rsi # imm = 0x270F
movq %rdx, %rsi
ja 0x8f8e4
movl %r9d, %eax
movl $0xaaaaaaab, %esi # imm = 0xAAAAAAAB
imulq %rax, %rsi
shrq $0x21, %rsi
leal (%rsi,%rsi,2), %eax
addl %eax, %r8d
sete %al
movq %rdx, %rsi
movq 0x8(%rsp), %rbx
movq (%rsp), %r15
jmp 0x8f9a4
xorl %eax, %eax
cmpq $0x9, %rsi
ja 0x8f9b0
orb $0x30, %sil
jmp 0x8f9f2
addq %rsi, %rsi
movabsq $0x1fffffffe, %rdx # imm = 0x1FFFFFFFE
andq %rsi, %rdx
movl %esi, %r8d
leaq 0x85e56(%rip), %rsi # 0x115820
movb 0x1(%rsi,%r8), %r8b
movb %r8b, -0x1(%rcx)
movq $-0x1, %r8
testb %al, %al
je 0x8f9eb
movb 0xc(%rdi), %al
movb %al, -0x2(%rcx)
movq $-0x2, %r8
addq %r8, %rcx
movb (%rsi,%rdx), %sil
movb %sil, -0x1(%rcx)
testl %r14d, %r14d
je 0x8fa0b
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x854f0
addq %r14, %r15
movq %r15, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x76cf7(%rip), %rdi # 0x10671e
leaq 0x76d1b(%rip), %rsi # 0x106749
leaq 0x76fda(%rip), %rcx # 0x106a0f
movl $0x3dd, %edx # imm = 0x3DD
callq 0x853d0
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::on_bin()
|
void on_bin() {
if (spec.has(HASH_FLAG)) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = static_cast<char>(spec.type);
}
int num_digits = count_digits<1>();
writer.write_int(num_digits, get_prefix(), spec,
bin_writer<1>{abs_value, num_digits});
}
|
movq %rdi, %rdx
movq 0x8(%rdi), %r8
testb $0x8, 0x10(%r8)
je 0x8fd43
movl 0x1c(%rdx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1c(%rdx)
movb $0x30, 0x18(%rdx,%rax)
movb 0x11(%r8), %al
movl 0x1c(%rdx), %ecx
leal 0x1(%rcx), %esi
movl %esi, 0x1c(%rdx)
movb %al, 0x18(%rdx,%rcx)
movq 0x10(%rdx), %rax
xorl %esi, %esi
movq %rax, %rcx
movq %rax, %rdi
incl %esi
shrq %rdi
cmpq $0x1, %rcx
movq %rdi, %rcx
ja 0x8fd4f
subq $0x28, %rsp
movq (%rdx), %rdi
movl 0x1c(%rdx), %ecx
addq $0x18, %rdx
movq %rax, 0x18(%rsp)
movl %esi, 0x20(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x9065a
addq $0x28, %rsp
retq
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::dec_writer>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x9019b
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x85a60
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x901b7
leaq (%rdi,%rdx), %r15
movl 0x18(%r14), %esi
callq 0x85330
movq %r15, %rdi
movq %rdi, (%rbx)
addq $0x28, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x901d4
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::hex_writer>::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x905d6
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x85a60
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %r15
movq 0x20(%r14), %r12
movq %r15, %r13
testq %r12, %r12
je 0x905f8
leaq (%r15,%r12), %r13
movl 0x18(%r14), %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x85330
movq %r13, (%rbx)
movq 0x28(%r14), %rcx
movq 0x8(%rcx), %rax
movslq 0x30(%r14), %rdx
addq %rdx, %r13
cmpb $0x78, 0x11(%rax)
leaq 0x76264(%rip), %rsi # 0x106879
leaq 0x7624c(%rip), %rax # 0x106868
cmoveq %rsi, %rax
movq 0x10(%rcx), %rcx
addq %rdx, %r12
leaq (%r15,%r12), %rdx
decq %rdx
movq %rcx, %rsi
movl %ecx, %edi
andl $0xf, %edi
movb (%rax,%rdi), %dil
movb %dil, (%rdx)
shrq $0x4, %rsi
decq %rdx
cmpq $0xf, %rcx
movq %rsi, %rcx
ja 0x90631
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::num_writer::operator()<char*&>(char*&) const
|
void operator()(It &&it) const {
basic_string_view<char_type> s(&sep, SEP_SIZE);
it = internal::format_decimal<char_type>(
it, abs_value, size, internal::add_thousands_sep<char_type>(s));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movslq 0x8(%rdi), %r14
testq %r14, %r14
js 0x911a8
movq %rsi, %rbx
movq (%rsi), %r15
movq (%rdi), %rsi
leaq (%rsp,%r14), %rcx
addq $0x10, %rcx
cmpq $0x64, %rsi
jb 0x9112a
movq %r15, (%rsp)
movq %rbx, 0x8(%rsp)
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
movl $0x1, %r9d
movl $0xfffffffe, %r10d # imm = 0xFFFFFFFE
movl $0x2, %r11d
movl $0xaaaaaaab, %r12d # imm = 0xAAAAAAAB
movabsq $0x28f5c28f5c28f5c3, %r13 # imm = 0x28F5C28F5C28F5C3
leaq 0x847b4(%rip), %rbp # 0x115820
movl %r9d, %eax
imulq %r12, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %r15d
movq %rsi, %rax
shrq $0x2, %rax
mulq %r13
shrq $0x2, %rdx
imull $0x64, %edx, %ebx
movl %esi, %eax
subl %ebx, %eax
addl %eax, %eax
movb 0x1(%rbp,%rax), %bl
movb %bl, -0x1(%rcx)
movq $-0x1, %rbx
addl %r8d, %r15d
jne 0x910b2
movb 0xc(%rdi), %bl
movb %bl, -0x2(%rcx)
movq $-0x2, %rbx
movl %r11d, %r15d
imulq %r12, %r15
shrq $0x21, %r15
leal (%r15,%r15,2), %r15d
movb (%rbp,%rax), %al
movb %al, -0x1(%rcx,%rbx)
addl %r10d, %r15d
je 0x910d6
addq %rbx, %rcx
decq %rcx
jmp 0x910e3
addq %rbx, %rcx
movb 0xc(%rdi), %al
movb %al, -0x2(%rcx)
addq $-0x2, %rcx
addl $-0x2, %r8d
addl $0x2, %r9d
addl $-0x2, %r10d
addl $0x2, %r11d
cmpq $0x270f, %rsi # imm = 0x270F
movq %rdx, %rsi
ja 0x9106c
movl %r9d, %eax
movl $0xaaaaaaab, %esi # imm = 0xAAAAAAAB
imulq %rax, %rsi
shrq $0x21, %rsi
leal (%rsi,%rsi,2), %eax
addl %eax, %r8d
sete %al
movq %rdx, %rsi
movq 0x8(%rsp), %rbx
movq (%rsp), %r15
jmp 0x9112c
xorl %eax, %eax
cmpq $0x9, %rsi
ja 0x91138
orb $0x30, %sil
jmp 0x9117a
addq %rsi, %rsi
movabsq $0x1fffffffe, %rdx # imm = 0x1FFFFFFFE
andq %rsi, %rdx
movl %esi, %r8d
leaq 0x846ce(%rip), %rsi # 0x115820
movb 0x1(%rsi,%r8), %r8b
movb %r8b, -0x1(%rcx)
movq $-0x1, %r8
testb %al, %al
je 0x91173
movb 0xc(%rdi), %al
movb %al, -0x2(%rcx)
movq $-0x2, %r8
addq %r8, %rcx
movb (%rsi,%rdx), %sil
movb %sil, -0x1(%rcx)
testl %r14d, %r14d
je 0x91193
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x854f0
addq %r14, %r15
movq %r15, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7556f(%rip), %rdi # 0x10671e
leaq 0x75593(%rip), %rsi # 0x106749
leaq 0x75852(%rip), %rcx # 0x106a0f
movl $0x3dd, %edx # imm = 0x3DD
callq 0x853d0
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<char, fmt::v5::basic_format_specs<char>>::dec_writer>(int, fmt::v5::basic_string_view<char>, fmt::v5::basic_format_specs<char> const&, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<char, fmt::v5::basic_format_specs<char>>::dec_writer)
|
inline uint32_t clzll(uint64_t x) {
unsigned long r = 0;
# ifdef _WIN64
_BitScanReverse64(&r, x);
# else
// Scan the high 32 bits.
if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
return 63 - (r + 32);
// Scan the low 32 bits.
_BitScanReverse(&r, static_cast<uint32_t>(x));
# endif
assert(x != 0);
// Static analysis complains about using uninitialized data
// "r", but the only way that can happen is if "x" is 0,
// which the callers guarantee to not happen.
# pragma warning(suppress: 6102)
return 63 - r;
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
testl %esi, %esi
js 0x91aae
movl %esi, %r11d
addq %rcx, %r11
movb 0x4(%r8), %r10b
movl 0x8(%r8), %eax
cmpl $0x4, %eax
jne 0x91a3d
movl (%r8), %ebx
cmpq %rbx, %r11
movq %rbx, %r14
cmovaq %r11, %r14
xorl %esi, %esi
subq %r11, %rbx
cmovaeq %rbx, %rsi
movq %r14, %r11
jmp 0x91a61
movl 0xc(%r8), %ebx
cmpl %esi, %ebx
jle 0x91a5f
testl %ebx, %ebx
js 0x91aae
movl %ebx, %r10d
subl %esi, %r10d
js 0x91aae
addq %rcx, %rbx
movl %r10d, %esi
movb $0x30, %r10b
movq %rbx, %r11
jmp 0x91a61
xorl %esi, %esi
movl 0x8(%r8), %ebx
movl %ebx, 0x10(%rsp)
movq (%r8), %r8
movq %r8, 0x8(%rsp)
testl %eax, %eax
jne 0x91a7d
movl $0x2, 0x10(%rsp)
leaq 0x18(%rsp), %rax
movq %r11, (%rax)
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb %r10b, 0x18(%rax)
movq %rsi, 0x20(%rax)
movq %r9, 0x28(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x91ace
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x747f3(%rip), %rdi # 0x1062a8
leaq 0x7480d(%rip), %rsi # 0x1062c9
leaq 0x74938(%rip), %rcx # 0x1063fb
movl $0xd1, %edx
callq 0x853d0
nop
|
/tinfoilboy[P]sonne/extern/fmt/include/fmt/format.h
|
Sonne::Counter::_CompareStringToBuffer(std::vector<char, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long const&)
|
bool Counter::_CompareStringToBuffer(std::vector<char>& buffer, std::string& compare, const size_t& start)
{
// check if the first character matches, and if not we can already say that the string doesn't match
if (buffer[start] != compare[0])
{
return false;
}
for (size_t i = 1; i < compare.size(); i++)
{
char& compareChar = compare.at(i);
if (_GetBufferLookahead(buffer, start + i) != compareChar)
{
return false; // the current character is not the same of that in the buffer, so no match
}
}
return true;
}
|
movq (%rcx), %rcx
movq (%rsi), %rdi
movb (%rdi,%rcx), %al
movq (%rdx), %r8
cmpb (%r8), %al
jne 0x9b1a7
movq 0x8(%rdx), %rdx
cmpq $0x2, %rdx
setb %al
jb 0x9b1a9
movq 0x8(%rsi), %rsi
subq %rdi, %rsi
addq %rcx, %rdi
movl $0x1, %r9d
leaq (%rcx,%r9), %r10
cmpq %rsi, %r10
jae 0x9b191
movb (%rdi,%r9), %r10b
jmp 0x9b194
xorl %r10d, %r10d
cmpb (%r8,%r9), %r10b
jne 0x9b1a9
incq %r9
cmpq %rdx, %r9
setae %al
jne 0x9b182
jmp 0x9b1a9
xorl %eax, %eax
andb $0x1, %al
retq
|
/tinfoilboy[P]sonne/source/counter.cpp
|
nlohmann::detail::parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::detail::input_stream_adapter> nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>::parser<nlohmann::detail::input_stream_adapter>(nlohmann::detail::input_stream_adapter, std::function<bool (int, nlohmann::detail::parse_event_t, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>&)>, bool)
|
static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
InputAdapterType adapter,
detail::parser_callback_t<basic_json>cb = nullptr,
bool allow_exceptions = true
)
{
return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter), std::move(cb), allow_exceptions);
}
|
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rdx), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0x9e42f
movups (%rdx), %xmm1
addq $0x10, %rdx
movaps %xmm1, (%rsp)
movq %rax, 0x10(%rsp)
movups %xmm0, (%rdx)
movzbl %cl, %ecx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x9ea36
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x9e454
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x9e481
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x9e479
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x85b40
movq %rax, %rdi
callq 0x877cd
nop
|
/tinfoilboy[P]sonne/extern/json/single_include/nlohmann/json.hpp
|
nlohmann::detail::type_error::create(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
static type_error create(int id_, const std::string& what_arg)
{
std::string w = exception::name("type_error", id_) + what_arg;
return type_error(id_, w.c_str());
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x66710(%rip), %rsi # 0x10a080
leaq 0x66713(%rip), %rdx # 0x10a08a
leaq 0x28(%rsp), %rdi
callq 0x87868
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %ebp, %edx
callq 0x9dfb0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x48(%rsp), %rdi
callq 0x85180
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xa39ca
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0xa39d1
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa39fc
callq 0x855f0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xa3a0b
callq 0x855f0
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9e35c
leaq 0x9efcf(%rip), %rax # 0x1429f0
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xa3a33
callq 0x855f0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0xa3a75
jmp 0xa3a7f
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa3a6b
callq 0x855f0
jmp 0xa3a6b
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xa3a7f
callq 0x855f0
jmp 0xa3a7f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x85b40
nop
|
/tinfoilboy[P]sonne/extern/json/single_include/nlohmann/json.hpp
|
nlohmann::detail::json_sax_dom_parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::start_object(unsigned long)
|
bool start_object(std::size_t len)
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len)));
}
return true;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movb $0x1, (%rsi)
callq 0xa5cca
movq %rax, (%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0xa5ac1
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0xa5acd
leaq 0x8(%rbx), %rdi
movq %rsp, %rdx
callq 0xa5e4c
cmpq $-0x1, %r14
je 0xa5af9
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movzbl (%rax), %eax
movl $0x1, %ecx
cmpq $0x2, %rax
ja 0xa5af4
leaq 0x664e8(%rip), %rcx # 0x10bfd8
movq (%rcx,%rax,8), %rcx
cmpq %r14, %rcx
jb 0xa5b04
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x852c0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xa31ff
leaq 0x641e3(%rip), %rsi # 0x109d08
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0xa2ddb
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x198, %esi # imm = 0x198
callq 0xa2ca2
xorl %ebp, %ebp
leaq 0x9ce22(%rip), %rsi # 0x142970
leaq -0x4969(%rip), %rdx # 0xa11ec
movq %rbx, %rdi
callq 0x85ae0
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa5b7b
callq 0x855f0
jmp 0xa5b7b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa5b96
callq 0x855f0
jmp 0xa5b96
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xa5ba3
movq %rbx, %rdi
callq 0x85480
movq %r14, %rdi
callq 0x85b40
nop
|
/tinfoilboy[P]sonne/extern/json/single_include/nlohmann/json.hpp
|
void nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>>::dump_integer<unsigned long, 0>(unsigned long)
|
void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
{{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
{{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
{{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
{{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
{{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
{{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
{{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
{{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
}
};
// special case for "0"
if (x == 0)
{
o->write_character('0');
return;
}
// use a pointer to fill the buffer
auto buffer_ptr = number_buffer.begin();
const bool is_negative = std::is_same<NumberType, number_integer_t>::value and not(x >= 0); // see issue #755
number_unsigned_t abs_value;
unsigned int n_chars;
if (is_negative)
{
*buffer_ptr = '-';
abs_value = remove_sign(static_cast<number_integer_t>(x));
// account one more byte for the minus sign
n_chars = 1 + count_digits(abs_value);
}
else
{
abs_value = static_cast<number_unsigned_t>(x);
n_chars = count_digits(abs_value);
}
// spare 1 byte for '\0'
assert(n_chars < number_buffer.size() - 1);
// jump to the end to generate the string from backward
// so we later avoid reversing the result
buffer_ptr += n_chars;
// Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
// See: https://www.youtube.com/watch?v=o4-CwDo2zpg
while (abs_value >= 100)
{
const auto digits_index = static_cast<unsigned>((abs_value % 100));
abs_value /= 100;
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
if (abs_value >= 10)
{
const auto digits_index = static_cast<unsigned>(abs_value);
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
else
{
*(--buffer_ptr) = static_cast<char>('0' + abs_value);
}
o->write_characters(number_buffer.data(), n_chars);
}
|
pushq %rbx
testq %rsi, %rsi
je 0xa95d7
movl $0x1, %r8d
cmpq $0xa, %rsi
jb 0xa95f1
movl $0x4, %r8d
movabsq $0x346dc5d63886594b, %r9 # imm = 0x346DC5D63886594B
movq %rsi, %rcx
cmpq $0x63, %rcx
jbe 0xa95e8
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0xa95ee
cmpq $0x2710, %rcx # imm = 0x2710
jb 0xa95f1
movq %rcx, %rax
mulq %r9
shrq $0xb, %rdx
addl $0x4, %r8d
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0xa959f
addl $-0x3, %r8d
jmp 0xa95f1
movq (%rdi), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movl $0x30, %esi
popq %rbx
jmpq *%rax
addl $-0x2, %r8d
jmp 0xa95f1
decl %r8d
cmpl $0x3f, %r8d
jae 0xa9690
leaq 0x10(%rdi), %rcx
movl %r8d, %r8d
leaq (%rcx,%r8), %r9
leaq 0x62f2a(%rip), %r10 # 0x10c537
cmpq $0x64, %rsi
jb 0xa964e
movabsq $0x28f5c28f5c28f5c3, %r11 # imm = 0x28F5C28F5C28F5C3
movq %rsi, %rax
shrq $0x2, %rax
mulq %r11
shrq $0x2, %rdx
imull $0x64, %edx, %eax
movl %esi, %ebx
subl %eax, %ebx
movzwl (%r10,%rbx,2), %eax
movw %ax, -0x2(%r9)
addq $-0x2, %r9
cmpq $0x270f, %rsi # imm = 0x270F
movq %rdx, %rsi
ja 0xa961d
jmp 0xa9651
movq %rsi, %rdx
cmpq $0xa, %rdx
jb 0xa966d
movb (%r10,%rdx,2), %al
movb 0x1(%r10,%rdx,2), %dl
movb %dl, -0x1(%r9)
movq $-0x2, %rsi
jmp 0xa9679
orb $0x30, %dl
movq $-0x1, %rsi
movl %edx, %eax
movb %al, (%r9,%rsi)
movq (%rdi), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %rcx, %rsi
movq %r8, %rdx
popq %rbx
jmpq *%rax
leaq 0x61e90(%rip), %rdi # 0x10b527
leaq 0x5ef68(%rip), %rsi # 0x108606
leaq 0x61f35(%rip), %rcx # 0x10b5da
movl $0x3cf9, %edx # imm = 0x3CF9
callq 0x853d0
nop
|
/tinfoilboy[P]sonne/extern/json/single_include/nlohmann/json.hpp
|
nlohmann::detail::dtoa_impl::get_cached_power_for_binary_exponent(int)
|
inline cached_power get_cached_power_for_binary_exponent(int e)
{
// Now
//
// alpha <= e_c + e + q <= gamma (1)
// ==> f_c * 2^alpha <= c * 2^e * 2^q
//
// and since the c's are normalized, 2^(q-1) <= f_c,
//
// ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
// ==> 2^(alpha - e - 1) <= c
//
// If c were an exact power of ten, i.e. c = 10^k, one may determine k as
//
// k = ceil( log_10( 2^(alpha - e - 1) ) )
// = ceil( (alpha - e - 1) * log_10(2) )
//
// From the paper:
// "In theory the result of the procedure could be wrong since c is rounded,
// and the computation itself is approximated [...]. In practice, however,
// this simple function is sufficient."
//
// For IEEE double precision floating-point numbers converted into
// normalized diyfp's w = f * 2^e, with q = 64,
//
// e >= -1022 (min IEEE exponent)
// -52 (p - 1)
// -52 (p - 1, possibly normalize denormal IEEE numbers)
// -11 (normalize the diyfp)
// = -1137
//
// and
//
// e <= +1023 (max IEEE exponent)
// -52 (p - 1)
// -11 (normalize the diyfp)
// = 960
//
// This binary exponent range [-1137,960] results in a decimal exponent
// range [-307,324]. One does not need to store a cached power for each
// k in this range. For each such k it suffices to find a cached power
// such that the exponent of the product lies in [alpha,gamma].
// This implies that the difference of the decimal exponents of adjacent
// table entries must be less than or equal to
//
// floor( (gamma - alpha) * log_10(2) ) = 8.
//
// (A smaller distance gamma-alpha would require a larger table.)
// NB:
// Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
constexpr int kCachedPowersMinDecExp = -300;
constexpr int kCachedPowersDecStep = 8;
static constexpr std::array<cached_power, 79> kCachedPowers =
{
{
{ 0xAB70FE17C79AC6CA, -1060, -300 },
{ 0xFF77B1FCBEBCDC4F, -1034, -292 },
{ 0xBE5691EF416BD60C, -1007, -284 },
{ 0x8DD01FAD907FFC3C, -980, -276 },
{ 0xD3515C2831559A83, -954, -268 },
{ 0x9D71AC8FADA6C9B5, -927, -260 },
{ 0xEA9C227723EE8BCB, -901, -252 },
{ 0xAECC49914078536D, -874, -244 },
{ 0x823C12795DB6CE57, -847, -236 },
{ 0xC21094364DFB5637, -821, -228 },
{ 0x9096EA6F3848984F, -794, -220 },
{ 0xD77485CB25823AC7, -768, -212 },
{ 0xA086CFCD97BF97F4, -741, -204 },
{ 0xEF340A98172AACE5, -715, -196 },
{ 0xB23867FB2A35B28E, -688, -188 },
{ 0x84C8D4DFD2C63F3B, -661, -180 },
{ 0xC5DD44271AD3CDBA, -635, -172 },
{ 0x936B9FCEBB25C996, -608, -164 },
{ 0xDBAC6C247D62A584, -582, -156 },
{ 0xA3AB66580D5FDAF6, -555, -148 },
{ 0xF3E2F893DEC3F126, -529, -140 },
{ 0xB5B5ADA8AAFF80B8, -502, -132 },
{ 0x87625F056C7C4A8B, -475, -124 },
{ 0xC9BCFF6034C13053, -449, -116 },
{ 0x964E858C91BA2655, -422, -108 },
{ 0xDFF9772470297EBD, -396, -100 },
{ 0xA6DFBD9FB8E5B88F, -369, -92 },
{ 0xF8A95FCF88747D94, -343, -84 },
{ 0xB94470938FA89BCF, -316, -76 },
{ 0x8A08F0F8BF0F156B, -289, -68 },
{ 0xCDB02555653131B6, -263, -60 },
{ 0x993FE2C6D07B7FAC, -236, -52 },
{ 0xE45C10C42A2B3B06, -210, -44 },
{ 0xAA242499697392D3, -183, -36 },
{ 0xFD87B5F28300CA0E, -157, -28 },
{ 0xBCE5086492111AEB, -130, -20 },
{ 0x8CBCCC096F5088CC, -103, -12 },
{ 0xD1B71758E219652C, -77, -4 },
{ 0x9C40000000000000, -50, 4 },
{ 0xE8D4A51000000000, -24, 12 },
{ 0xAD78EBC5AC620000, 3, 20 },
{ 0x813F3978F8940984, 30, 28 },
{ 0xC097CE7BC90715B3, 56, 36 },
{ 0x8F7E32CE7BEA5C70, 83, 44 },
{ 0xD5D238A4ABE98068, 109, 52 },
{ 0x9F4F2726179A2245, 136, 60 },
{ 0xED63A231D4C4FB27, 162, 68 },
{ 0xB0DE65388CC8ADA8, 189, 76 },
{ 0x83C7088E1AAB65DB, 216, 84 },
{ 0xC45D1DF942711D9A, 242, 92 },
{ 0x924D692CA61BE758, 269, 100 },
{ 0xDA01EE641A708DEA, 295, 108 },
{ 0xA26DA3999AEF774A, 322, 116 },
{ 0xF209787BB47D6B85, 348, 124 },
{ 0xB454E4A179DD1877, 375, 132 },
{ 0x865B86925B9BC5C2, 402, 140 },
{ 0xC83553C5C8965D3D, 428, 148 },
{ 0x952AB45CFA97A0B3, 455, 156 },
{ 0xDE469FBD99A05FE3, 481, 164 },
{ 0xA59BC234DB398C25, 508, 172 },
{ 0xF6C69A72A3989F5C, 534, 180 },
{ 0xB7DCBF5354E9BECE, 561, 188 },
{ 0x88FCF317F22241E2, 588, 196 },
{ 0xCC20CE9BD35C78A5, 614, 204 },
{ 0x98165AF37B2153DF, 641, 212 },
{ 0xE2A0B5DC971F303A, 667, 220 },
{ 0xA8D9D1535CE3B396, 694, 228 },
{ 0xFB9B7CD9A4A7443C, 720, 236 },
{ 0xBB764C4CA7A44410, 747, 244 },
{ 0x8BAB8EEFB6409C1A, 774, 252 },
{ 0xD01FEF10A657842C, 800, 260 },
{ 0x9B10A4E5E9913129, 827, 268 },
{ 0xE7109BFBA19C0C9D, 853, 276 },
{ 0xAC2820D9623BF429, 880, 284 },
{ 0x80444B5E7AA7CF85, 907, 292 },
{ 0xBF21E44003ACDD2D, 933, 300 },
{ 0x8E679C2F5E44FF8F, 960, 308 },
{ 0xD433179D9C8CB841, 986, 316 },
{ 0x9E19DB92B4E31BA9, 1013, 324 },
}
};
// This computation gives exactly the same results for k as
// k = ceil((kAlpha - e - 1) * 0.30102999566398114)
// for |e| <= 1500, but doesn't require floating-point operations.
// NB: log_10(2) ~= 78913 / 2^18
assert(e >= -1500);
assert(e <= 1500);
const int f = kAlpha - e - 1;
const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
assert(index >= 0);
assert(static_cast<std::size_t>(index) < kCachedPowers.size());
const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
assert(kAlpha <= cached.e + e + 64);
assert(kGamma >= cached.e + e + 64);
return cached;
}
|
pushq %rax
cmpl $0xfffffa23, %edi # imm = 0xFFFFFA23
jle 0xa9fbe
cmpl $0x5dd, %edi # imm = 0x5DD
jge 0xa9fdd
movl $0xffffffc3, %ecx # imm = 0xFFFFFFC3
subl %edi, %ecx
imull $0x13441, %ecx, %eax # imm = 0x13441
leal 0x3ffff(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
sarl $0x12, %edx
xorl %eax, %eax
testl %ecx, %ecx
setg %al
addl %edx, %eax
cmpl $0xfffffec5, %eax # imm = 0xFFFFFEC5
jle 0xa9ffc
leal 0x133(%rax), %ecx
addl $0x13a, %eax # imm = 0x13A
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x3, %eax
cmpl $0x4f, %eax
jae 0xaa01b
movl %eax, %eax
shlq $0x4, %rax
leaq 0x62661(%rip), %rcx # 0x10c600
movq 0x8(%rax,%rcx), %rdx
addl %edx, %edi
cmpl $-0x7d, %edi
jle 0xaa03a
cmpl $-0x5f, %edi
jge 0xaa059
movq (%rax,%rcx), %rax
popq %rcx
retq
leaq 0x61a2b(%rip), %rdi # 0x10b9f0
leaq 0x5e63a(%rip), %rsi # 0x108606
leaq 0x61a28(%rip), %rcx # 0x10b9fb
movl $0x37ac, %edx # imm = 0x37AC
callq 0x853d0
leaq 0x61a6b(%rip), %rdi # 0x10ba4f
leaq 0x5e61b(%rip), %rsi # 0x108606
leaq 0x61a09(%rip), %rcx # 0x10b9fb
movl $0x37ad, %edx # imm = 0x37AD
callq 0x853d0
leaq 0x61a56(%rip), %rdi # 0x10ba59
leaq 0x5e5fc(%rip), %rsi # 0x108606
leaq 0x619ea(%rip), %rcx # 0x10b9fb
movl $0x37b2, %edx # imm = 0x37B2
callq 0x853d0
leaq 0x61a42(%rip), %rdi # 0x10ba64
leaq 0x5e5dd(%rip), %rsi # 0x108606
leaq 0x619cb(%rip), %rcx # 0x10b9fb
movl $0x37b3, %edx # imm = 0x37B3
callq 0x853d0
leaq 0x61a5a(%rip), %rdi # 0x10ba9b
leaq 0x5e5be(%rip), %rsi # 0x108606
leaq 0x619ac(%rip), %rcx # 0x10b9fb
movl $0x37b6, %edx # imm = 0x37B6
callq 0x853d0
leaq 0x61a57(%rip), %rdi # 0x10bab7
leaq 0x5e59f(%rip), %rsi # 0x108606
leaq 0x6198d(%rip), %rcx # 0x10b9fb
movl $0x37b7, %edx # imm = 0x37B7
callq 0x853d0
|
/tinfoilboy[P]sonne/extern/json/single_include/nlohmann/json.hpp
|
nlohmann::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&, nlohmann::detail::dtoa_impl::diyfp, nlohmann::detail::dtoa_impl::diyfp, nlohmann::detail::dtoa_impl::diyfp)
|
inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
diyfp M_minus, diyfp w, diyfp M_plus)
{
static_assert(kAlpha >= -60, "internal error");
static_assert(kGamma <= -32, "internal error");
// Generates the digits (and the exponent) of a decimal floating-point
// number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
// w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
//
// <--------------------------- delta ---->
// <---- dist --------->
// --------------[------------------+-------------------]--------------
// M- w M+
//
// Grisu2 generates the digits of M+ from left to right and stops as soon as
// V is in [M-,M+].
assert(M_plus.e >= kAlpha);
assert(M_plus.e <= kGamma);
std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
// Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
//
// M+ = f * 2^e
// = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
// = ((p1 ) * 2^-e + (p2 )) * 2^e
// = p1 + p2 * 2^e
const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
// 1)
//
// Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
assert(p1 > 0);
std::uint32_t pow10;
const int k = find_largest_pow10(p1, pow10);
// 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
//
// p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
// = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
//
// M+ = p1 + p2 * 2^e
// = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
// = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
// = d[k-1] * 10^(k-1) + ( rest) * 2^e
//
// Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
//
// p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
//
// but stop as soon as
//
// rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
int n = k;
while (n > 0)
{
// Invariants:
// M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
// pow10 = 10^(n-1) <= p1 < 10^n
//
const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
//
// M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
// = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
//
assert(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
//
p1 = r;
n--;
//
// M+ = buffer * 10^n + (p1 + p2 * 2^e)
// pow10 = 10^n
//
// Now check if enough digits have been generated.
// Compute
//
// p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
//
// Note:
// Since rest and delta share the same exponent e, it suffices to
// compare the significands.
const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
if (rest <= delta)
{
// V = buffer * 10^n, with M- <= V <= M+.
decimal_exponent += n;
// We may now just stop. But instead look if the buffer could be
// decremented to bring V closer to w.
//
// pow10 = 10^n is now 1 ulp in the decimal representation V.
// The rounding procedure works with diyfp's with an implicit
// exponent of e.
//
// 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
//
const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
grisu2_round(buffer, length, dist, delta, rest, ten_n);
return;
}
pow10 /= 10;
//
// pow10 = 10^(n-1) <= p1 < 10^n
// Invariants restored.
}
// 2)
//
// The digits of the integral part have been generated:
//
// M+ = d[k-1]...d[1]d[0] + p2 * 2^e
// = buffer + p2 * 2^e
//
// Now generate the digits of the fractional part p2 * 2^e.
//
// Note:
// No decimal point is generated: the exponent is adjusted instead.
//
// p2 actually represents the fraction
//
// p2 * 2^e
// = p2 / 2^-e
// = d[-1] / 10^1 + d[-2] / 10^2 + ...
//
// Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
//
// p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
// + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
//
// using
//
// 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
// = ( d) * 2^-e + ( r)
//
// or
// 10^m * p2 * 2^e = d + r * 2^e
//
// i.e.
//
// M+ = buffer + p2 * 2^e
// = buffer + 10^-m * (d + r * 2^e)
// = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
//
// and stop as soon as 10^-m * r * 2^e <= delta * 2^e
assert(p2 > delta);
int m = 0;
for (;;)
{
// Invariant:
// M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
// = buffer * 10^-m + 10^-m * (p2 ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
//
assert(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
p2 *= 10;
const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
//
// M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
// = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
assert(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
p2 = r;
m++;
//
// M+ = buffer * 10^-m + 10^-m * p2 * 2^e
// Invariant restored.
// Check if enough digits have been generated.
//
// 10^-m * p2 * 2^e <= delta * 2^e
// p2 * 2^e <= 10^m * delta * 2^e
// p2 <= 10^m * delta
delta *= 10;
dist *= 10;
if (p2 <= delta)
{
break;
}
}
// V = buffer * 10^-m, with M- <= V <= M+.
decimal_exponent -= m;
// 1 ulp in the decimal representation is now 10^-m.
// Since delta and dist are now scaled by 10^m, we need to do the
// same with ulp in order to keep the units in sync.
//
// 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
//
const std::uint64_t ten_m = one.f;
grisu2_round(buffer, length, dist, delta, p2, ten_m);
// By construction this algorithm generates the shortest possible decimal
// number (Loitsch, Theorem 6.2) which rounds back to w.
// For an input number of precision p, at least
//
// N = 1 + ceil(p * log_10(2))
//
// decimal digits are sufficient to identify all binary floating-point
// numbers (Matula, "In-and-Out conversions").
// This implies that the algorithm does not produce more than N decimal
// digits.
//
// N = 17 for p = 53 (IEEE double precision)
// N = 9 for p = 24 (IEEE single precision)
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x40(%rsp)
movl 0x98(%rsp), %eax
cmpl $-0x3d, %eax
jle 0xaa3d5
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
cmpl $-0x1f, %eax
jge 0xaa3f4
leaq 0x90(%rsp), %rbx
leaq 0x80(%rsp), %r15
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xaa452
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0xaa452
xorl %r11d, %r11d
subl 0x8(%rbx), %r11d
movl $0x1, %esi
movl %r11d, %ecx
shlq %cl, %rsi
movq (%rbx), %r13
movq %r13, %rdx
shrq %cl, %rdx
testl %edx, %edx
je 0xaa413
movq %rax, %r15
movq %rsi, 0x28(%rsp)
leaq -0x1(%rsi), %rax
cmpl $0x3b9ac9ff, %edx # imm = 0x3B9AC9FF
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %r10
movq %rax, 0x8(%rsp)
jbe 0xaa196
movl $0xa, %r14d
movl $0x3b9aca00, %r8d # imm = 0x3B9ACA00
jmp 0xaa244
cmpl $0x5f5e0ff, %edx # imm = 0x5F5E0FF
jbe 0xaa1af
movl $0x9, %r14d
movl $0x5f5e100, %r8d # imm = 0x5F5E100
jmp 0xaa244
cmpl $0x98967f, %edx # imm = 0x98967F
jbe 0xaa1c5
movl $0x8, %r14d
movl $0x989680, %r8d # imm = 0x989680
jmp 0xaa244
cmpl $0xf423f, %edx # imm = 0xF423F
jbe 0xaa1db
movl $0x7, %r14d
movl $0xf4240, %r8d # imm = 0xF4240
jmp 0xaa244
cmpl $0x1869f, %edx # imm = 0x1869F
jbe 0xaa1f1
movl $0x6, %r14d
movl $0x186a0, %r8d # imm = 0x186A0
jmp 0xaa244
cmpl $0x270f, %edx # imm = 0x270F
jbe 0xaa207
movl $0x5, %r14d
movl $0x2710, %r8d # imm = 0x2710
jmp 0xaa244
cmpl $0x3e7, %edx # imm = 0x3E7
jbe 0xaa21d
movl $0x4, %r14d
movl $0x3e8, %r8d # imm = 0x3E8
jmp 0xaa244
cmpl $0x63, %edx
jbe 0xaa230
movl $0x3, %r14d
movl $0x64, %r8d
jmp 0xaa244
xorl %r14d, %r14d
cmpl $0xa, %edx
setae %r14b
leal (%r14,%r14,8), %r8d
incl %r8d
incl %r14d
andq 0x8(%rsp), %r13
testl %r14d, %r14d
jle 0xaa2ec
movl %edx, %eax
xorl %edx, %edx
divl %r8d
cmpl $0xa, %eax
jae 0xaa3b6
orb $0x30, %al
movslq (%r10), %rsi
leal 0x1(%rsi), %ecx
movl %ecx, (%r10)
movl %edx, %ebp
movl %r11d, %ecx
shlq %cl, %rbp
movb %al, (%rdi,%rsi)
addq %r13, %rbp
movl %r8d, %r9d
cmpq %r12, %rbp
jbe 0xaa295
movl $0xcccccccd, %eax # imm = 0xCCCCCCCD
imulq %rax, %r9
shrq $0x23, %r9
movl %r9d, %r8d
jmp 0xaa2de
movq 0x10(%rsp), %rcx
movl (%rcx), %eax
addl %r14d, %eax
decl %eax
movl %eax, (%rcx)
movl %r11d, %ecx
shlq %cl, %r9
movq %rdx, 0x30(%rsp)
movl (%r10), %esi
movq %r15, %rdx
movq %r12, %rcx
movl %r8d, 0x4(%rsp)
movq %rbp, %r8
movq %r11, %rbx
callq 0xaa4a3
movl 0x4(%rsp), %r8d
movq 0x30(%rsp), %rdx
movq %rbx, %r11
movq 0x18(%rsp), %r10
movq 0x20(%rsp), %rdi
decl %r14d
cmpq %r12, %rbp
ja 0xaa249
jmp 0xaa369
cmpq %r12, %r13
jbe 0xaa432
xorl %eax, %eax
movabsq $0x199999999999999a, %rdx # imm = 0x199999999999999A
movq 0x8(%rsp), %r9
cmpq %rdx, %r13
jae 0xaa378
addq %r13, %r13
leaq (%r13,%r13,4), %r13
movq %r13, %rsi
movl %r11d, %ecx
shrq %cl, %rsi
cmpq $0xa, %rsi
jae 0xaa397
andq %r9, %r13
orb $0x30, %sil
movslq (%r10), %rcx
leal 0x1(%rcx), %r8d
movl %r8d, (%r10)
movb %sil, (%rdi,%rcx)
addq %r12, %r12
leaq (%r12,%r12,4), %r12
addq %r15, %r15
leaq (%r15,%r15,4), %r15
decl %eax
cmpq %r12, %r13
ja 0xaa306
movq 0x10(%rsp), %rcx
addl %eax, (%rcx)
movl (%r10), %esi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
movq 0x28(%rsp), %r9
callq 0xaa4a3
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x617f1(%rip), %rdi # 0x10bb70
leaq 0x5e280(%rip), %rsi # 0x108606
leaq 0x61759(%rip), %rcx # 0x10bae6
movl $0x38cf, %edx # imm = 0x38CF
callq 0x853d0
leaq 0x617c0(%rip), %rdi # 0x10bb5e
leaq 0x5e261(%rip), %rsi # 0x108606
leaq 0x6173a(%rip), %rcx # 0x10bae6
movl $0x38d8, %edx # imm = 0x38D8
callq 0x853d0
leaq 0x617a1(%rip), %rdi # 0x10bb5e
leaq 0x5e242(%rip), %rsi # 0x108606
leaq 0x6171b(%rip), %rcx # 0x10bae6
movl $0x386d, %edx # imm = 0x386D
callq 0x853d0
leaq 0x616f7(%rip), %rdi # 0x10bad3
leaq 0x5e223(%rip), %rsi # 0x108606
leaq 0x616fc(%rip), %rcx # 0x10bae6
movl $0x3833, %edx # imm = 0x3833
callq 0x853d0
leaq 0x61749(%rip), %rdi # 0x10bb44
leaq 0x5e204(%rip), %rsi # 0x108606
leaq 0x616dd(%rip), %rcx # 0x10bae6
movl $0x3834, %edx # imm = 0x3834
callq 0x853d0
leaq 0x6173d(%rip), %rdi # 0x10bb57
leaq 0x5e1e5(%rip), %rsi # 0x108606
leaq 0x616be(%rip), %rcx # 0x10bae6
movl $0x3849, %edx # imm = 0x3849
callq 0x853d0
leaq 0x6172c(%rip), %rdi # 0x10bb65
leaq 0x5e1c6(%rip), %rsi # 0x108606
leaq 0x6169f(%rip), %rcx # 0x10bae6
movl $0x38c4, %edx # imm = 0x38C4
callq 0x853d0
nop
|
/tinfoilboy[P]sonne/extern/json/single_include/nlohmann/json.hpp
|
Catch::handleExceptionMatchExpr(Catch::AssertionHandler&, Catch::Matchers::Impl::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, Catch::StringRef const&)
|
void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString ) {
std::string exceptionMessage = Catch::translateActiveException();
MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
handler.handleExpr( expr );
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0xd1e3a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
movq (%rax), %rcx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
leaq 0x28(%r15), %rdi
movq 0x28(%r15), %rax
movq %r12, %rsi
callq *(%rax)
leaq 0x28(%rsp), %rdx
movb $0x1, 0x8(%rdx)
movb %al, 0x9(%rdx)
leaq 0x9a452(%rip), %rax # 0x146120
movq %rax, (%rdx)
movq %r12, 0x10(%rdx)
movq %r15, 0x18(%rdx)
movups (%r14), %xmm0
movups %xmm0, 0x20(%rdx)
movq 0x40(%rbx), %rdi
leaq 0x38(%rbx), %rcx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xabd05
callq 0x855f0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xabd13
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xabd29
callq 0x855f0
movq %rbx, %rdi
callq 0x85b40
|
/tinfoilboy[P]sonne/extern/Catch2/single_include/catch2/catch.hpp
|
Catch::Matchers::Equals(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CaseSensitive::Choice)
|
StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl %edx, -0x8(%rdi)
movq %rsp, %r14
movq %r14, %rsi
movq %rax, %rdx
callq 0xb5f18
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb61f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xabd72
callq 0x855f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xabd93
callq 0x855f0
movq %rbx, %rdi
callq 0x85b40
nop
|
/tinfoilboy[P]sonne/extern/Catch2/single_include/catch2/catch.hpp
|
Catch::AssertionResult::getExpression[abi:cxx11]() const
|
std::string AssertionResult::getExpression() const {
// Possibly overallocating by 3 characters should be basically free
std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
if (isFalseTest(m_info.resultDisposition)) {
expr += "!(";
}
expr += m_info.capturedExpression;
if (isFalseTest(m_info.resultDisposition)) {
expr += ')';
}
return expr;
}
|
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 0x28(%rsi), %rsi
addq $0x3, %rsi
callq 0x859e0
testb $0x4, 0x30(%r14)
je 0xabfe1
leaq 0x6228c(%rip), %rsi # 0x10e265
movq %rbx, %rdi
callq 0x85c00
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x850b0
testb $0x4, 0x30(%r14)
je 0xac005
movq %rbx, %rdi
movl $0x29, %esi
callq 0x85540
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xac01e
callq 0x855f0
movq %r14, %rdi
callq 0x85b40
|
/tinfoilboy[P]sonne/extern/Catch2/single_include/catch2/catch.hpp
|
Catch::formatReconstructedExpression(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::StringRef, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
if( lhs.size() + rhs.size() < 40 &&
lhs.find('\n') == std::string::npos &&
rhs.find('\n') == std::string::npos )
os << lhs << " " << op << " " << rhs;
else
os << lhs << "\n" << op << "\n" << rhs;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq 0x8(%r8), %rax
addq 0x8(%rsi), %rax
cmpq $0x27, %rax
ja 0xb27f8
movq %r13, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x85820
cmpq $-0x1, %rax
jne 0xb27f8
movq %rbx, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x85820
cmpq $-0x1, %rax
je 0xb2860
leaq 0x5cdc6(%rip), %rbp # 0x10f5c5
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r12, %rdi
callq 0x85720
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x85720
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x85830
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x85720
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x85720
leaq 0x5c929(%rip), %rbp # 0x10f190
jmp 0xb27ff
|
/tinfoilboy[P]sonne/extern/Catch2/single_include/catch2/catch.hpp
|
Catch::ReporterConfig::ReporterConfig(std::shared_ptr<Catch::IConfig const> const&, std::ostream&)
|
ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
: m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
|
movq %rdx, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xb3321
movq 0x93c64(%rip), %rcx # 0x146f78
cmpb $0x0, (%rcx)
je 0xb331d
incl 0x8(%rax)
retq
lock
incl 0x8(%rax)
retq
|
/tinfoilboy[P]sonne/extern/Catch2/single_include/catch2/catch.hpp
|
Catch::RunContext::sectionEnded(Catch::SectionEndInfo const&)
|
void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
Counts assertions = m_totals.assertions - endInfo.prevAssertions;
bool missingAssertions = testForMissingAssertions(assertions);
if (!m_activeSections.empty()) {
m_activeSections.back()->close();
m_activeSections.pop_back();
}
m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
m_messages.clear();
m_messageScopes.clear();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq 0xf8(%rdi), %rax
subq 0x50(%r14), %rax
movq %rax, (%rsi)
movq 0x100(%rdi), %rax
subq 0x58(%r14), %rax
movq %rax, 0x8(%rsi)
movq 0x108(%rdi), %rax
subq 0x60(%r14), %rax
movq %rax, 0x10(%rsi)
callq 0xb8dd2
movl %eax, %ebp
movq 0x1b8(%rbx), %rax
cmpq %rax, 0x1b0(%rbx)
je 0xb8eb5
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
addq $-0x8, 0x1b8(%rbx)
movq 0x128(%rbx), %r15
movsd 0x68(%r14), %xmm0
movzbl %bpl, %ecx
leaq 0x20(%rsp), %r12
movq %rsp, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xb369e
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x58(%rax)
leaq 0x20(%rsp), %rdi
callq 0xb3754
leaq 0x130(%rbx), %rdi
callq 0xd4950
movq 0x148(%rbx), %r15
movq 0x150(%rbx), %r12
cmpq %r15, %r12
je 0xb8f29
movq %r15, %r14
movq %r14, %rdi
callq 0xb6c9a
addq $0x50, %r14
cmpq %r12, %r14
jne 0xb8f11
movq %r15, 0x150(%rbx)
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb3754
movq %rbx, %rdi
callq 0x85b40
|
/tinfoilboy[P]sonne/extern/Catch2/single_include/catch2/catch.hpp
|
Catch::ListeningReporter::getSupportedVerbosities()
|
std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
return std::set<Verbosity>{ };
}
|
movq %rdi, %rax
leaq 0x8(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, (%rdi)
movq %rcx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
retq
|
/tinfoilboy[P]sonne/extern/Catch2/single_include/catch2/catch.hpp
|
miniros::Duration::~Duration()
|
class MINIROS_DECL Duration : public DurationBase<Duration>
{
public:
Duration()
: DurationBase<Duration>()
{ }
Duration(int32_t _sec, int32_t _nsec)
: DurationBase<Duration>(_sec, _nsec)
{}
explicit Duration(double t) { fromSec(t); }
explicit Duration(const Rate&);
/**
* \brief sleep for the amount of time specified by this Duration. If a signal interrupts the sleep, resleeps for the time remaining.
* @return True if the desired sleep duration was met, false otherwise.
*/
bool sleep() const;
}
|
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x52580
popq %rax
retq
|
/dkargin[P]miniroscpp/include/miniros/duration.h
|
minibag::Bag::decompressLz4Chunk(minibag::ChunkHeader const&) const
|
void Bag::decompressLz4Chunk(ChunkHeader const& chunk_header) const {
assert(chunk_header.compression == COMPRESSION_LZ4);
CompressionType compression = compression::LZ4;
MINIROS_CONSOLE_BRIDGE_logDebug("lz4 compressed_size: %d uncompressed_size: %d",
chunk_header.compressed_size, chunk_header.uncompressed_size);
encryptor_->decryptChunk(chunk_header, chunk_buffer_, file_);
decompress_buffer_.setSize(chunk_header.uncompressed_size);
file_.decompress(compression, decompress_buffer_.getData(), decompress_buffer_.getSize(), chunk_buffer_.getData(), chunk_buffer_.getSize());
// todo check read was successful
}
|
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movl $0x2, 0x34(%rsp)
movq 0x38(%rsp), %rax
movl 0x20(%rax), %r8d
movq 0x38(%rsp), %rax
movl 0x24(%rax), %r9d
leaq 0x9663b(%rip), %rdi # 0xfc2c3
movl $0x3a4, %esi # imm = 0x3A4
xorl %edx, %edx
leaq 0x96c80(%rip), %rcx # 0xfc916
movb $0x0, %al
callq 0x4d7c0
movq (%rsp), %rdi
addq $0x270, %rdi # imm = 0x270
callq 0x52c30
movq (%rsp), %rcx
movq %rax, %rdi
movq 0x38(%rsp), %rsi
movq %rcx, %rdx
addq $0x230, %rdx # imm = 0x230
addq $0x8, %rcx
movq (%rdi), %rax
callq *0x20(%rax)
movq (%rsp), %rdi
addq $0x240, %rdi # imm = 0x240
movq 0x38(%rsp), %rax
movl 0x24(%rax), %esi
callq 0x53920
movq (%rsp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x240, %rdi # imm = 0x240
callq 0x54190
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x240, %rdi # imm = 0x240
callq 0x51750
movq (%rsp), %rdi
movl %eax, 0x24(%rsp)
addq $0x230, %rdi # imm = 0x230
callq 0x54190
movq (%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x230, %rdi # imm = 0x230
callq 0x51750
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %r8
movl %eax, %r9d
callq 0x520e0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
|
/dkargin[P]miniroscpp/src/rosbag_storage/bag.cpp
|
minibag::Bag::readHeaderFromBuffer(minibag::Buffer&, unsigned int, miniros::Header&, unsigned int&, unsigned int&) const
|
void Bag::readHeaderFromBuffer(Buffer& buffer, uint32_t offset, miniros::Header& header, uint32_t& data_size, uint32_t& bytes_read) const {
assert(buffer.getSize() > 8);
uint8_t* start = (uint8_t*) buffer.getData() + offset;
uint8_t* ptr = start;
// Read the header length
uint32_t header_len;
memcpy(&header_len, ptr, 4);
ptr += 4;
// Parse the header
string error_msg;
bool parsed = header.parse(ptr, header_len, error_msg);
if (!parsed)
throw BagFormatException("Error parsing header");
ptr += header_len;
// Read the data size
memcpy(&data_size, ptr, 4);
ptr += 4;
bytes_read = ptr - start;
}
|
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movl %edx, 0xb4(%rsp)
movq %rcx, 0xa8(%rsp)
movq %r8, 0xa0(%rsp)
movq %r9, 0x98(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x54190
movl 0xb4(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x84(%rsp)
movq 0x88(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x88(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x51fb0
movq 0x18(%rsp), %rcx
movq 0xa8(%rsp), %rdi
movq 0x88(%rsp), %rsi
movl 0x84(%rsp), %edx
callq 0x4f670
movb %al, 0x25(%rsp)
jmp 0x669f0
movb 0x25(%rsp), %al
andb $0x1, %al
movb %al, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x66acd
movb $0x1, 0x26(%rsp)
movl $0x10, %edi
callq 0x4e850
movq %rax, 0x8(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x53700
movq 0x10(%rsp), %rdx
leaq 0x96031(%rip), %rsi # 0xfca65
leaq 0x28(%rsp), %rdi
callq 0x53290
jmp 0x66a40
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4e7c0
jmp 0x66a51
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0xae4f6(%rip), %rsi # 0x114f58
movq 0xae49f(%rip), %rdx # 0x114f08
callq 0x53310
jmp 0x66b56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x66b42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x66aae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x544b8
leaq 0x27(%rsp), %rdi
callq 0x50c30
testb $0x1, 0x26(%rsp)
jne 0x66ac1
jmp 0x66acb
movq 0x8(%rsp), %rdi
callq 0x4f6b0
jmp 0x66b42
movl 0x84(%rsp), %ecx
movq 0x88(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movq 0x88(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq 0x88(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq 0x90(%rsp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq 0x98(%rsp), %rax
movl %ecx, (%rax)
leaq 0x60(%rsp), %rdi
callq 0x544b8
addq $0xc8, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x544b8
movq 0x50(%rsp), %rdi
callq 0x536e0
nopw %cs:(%rax,%rax)
|
/dkargin[P]miniroscpp/src/rosbag_storage/bag.cpp
|
minibag::UncompressedStream::~UncompressedStream()
|
class ROSBAG_STORAGE_DECL UncompressedStream : public Stream
{
public:
UncompressedStream(ChunkedFile* file);
CompressionType getCompressionType() const;
void write(void* ptr, size_t size);
void read(void* ptr, size_t size);
void decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len);
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x52820
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x508f0
addq $0x18, %rsp
retq
nopl (%rax)
|
/dkargin[P]miniroscpp/include/minibag/stream.h
|
minibag::View::iterator::increment()
|
void View::iterator::increment() {
assert(view_ != NULL);
// Our message instance is no longer valid
if (message_instance_ != NULL)
{
delete message_instance_;
message_instance_ = NULL;
}
view_->update();
// Note, updating may have blown away our message-ranges and
// replaced them in general the ViewIterHelpers are no longer
// valid, but the iterator it stores should still be good.
if (view_revision_ != view_->view_revision_)
populateSeek(iters_.back().iter);
if (view_->reduce_overlap_)
{
std::multiset<IndexEntry>::const_iterator last_iter = iters_.back().iter;
while (!iters_.empty() && iters_.back().iter == last_iter)
{
iters_.back().iter++;
if (iters_.back().iter == iters_.back().range->end)
iters_.pop_back();
std::sort(iters_.begin(), iters_.end(), ViewIterHelperCompare());
}
} else {
iters_.back().iter++;
if (iters_.back().iter == iters_.back().range->end)
iters_.pop_back();
std::sort(iters_.begin(), iters_.end(), ViewIterHelperCompare());
}
}
|
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rax)
je 0x7a6e3
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x7a6d6
movq 0x20(%rsp), %rdi
movl $0x28, %esi
callq 0x508f0
movq 0x28(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x54480
movq 0x28(%rsp), %rcx
movl 0x20(%rcx), %eax
movq (%rcx), %rcx
cmpl 0x30(%rcx), %eax
je 0x7a725
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x4fe80
movq 0x28(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rsi
callq 0x52350
movq 0x28(%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x3c(%rax)
je 0x7a837
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x4fe80
movq (%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x52a50
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x7a787
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x4fe80
movq %rax, %rdi
leaq 0x70(%rsp), %rsi
callq 0x50560
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x7a794
jmp 0x7a832
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x4fe80
movq %rax, %rdi
xorl %esi, %esi
callq 0x53f70
movq 0x28(%rsp), %rdi
movq %rax, 0x68(%rsp)
addq $0x8, %rdi
callq 0x4fe80
movq 0x28(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0x4fe80
movq 0x10(%rsp), %rdi
movq 0x8(%rax), %rsi
addq $0x8, %rsi
callq 0x50560
testb $0x1, %al
jne 0x7a7ea
jmp 0x7a7f8
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x51970
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x51820
movq 0x28(%rsp), %rdi
movq %rax, 0x60(%rsp)
addq $0x8, %rdi
callq 0x4f6e0
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x50e70
jmp 0x7a74d
jmp 0x7a8d0
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x4fe80
movq %rax, %rdi
xorl %esi, %esi
callq 0x53f70
movq 0x28(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x8, %rdi
callq 0x4fe80
movq 0x28(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x4fe80
movq 0x8(%rsp), %rdi
movq 0x8(%rax), %rsi
addq $0x8, %rsi
callq 0x50560
testb $0x1, %al
jne 0x7a88d
jmp 0x7a89b
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x51970
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x51820
movq 0x28(%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x8, %rdi
callq 0x4f6e0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x50e70
addq $0x88, %rsp
retq
nopl (%rax,%rax)
|
/dkargin[P]miniroscpp/src/rosbag_storage/view.cpp
|
minibag::View::addQuery(minibag::Bag const&, miniros::Time const&, miniros::Time const&)
|
void View::addQuery(Bag const& bag, miniros::Time const& start_time, miniros::Time const& end_time) {
if ((bag.getMode() & bagmode::Read) != bagmode::Read)
throw BagException("Bag not opened for reading");
std::function<bool(ConnectionInfo const*)> query = TrueQuery();
queries_.push_back(new BagQuery(&bag, Query(query, start_time, end_time), bag.bag_revision_));
updateQueries(queries_.back());
}
|
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rcx, 0xd8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x4ddd0
andl $0x2, %eax
cmpl $0x2, %eax
je 0x7ad99
movb $0x1, 0xa3(%rsp)
movl $0x10, %edi
callq 0x4e850
movq %rax, 0x20(%rsp)
leaq 0xb7(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x53700
movq 0x28(%rsp), %rdx
leaq 0x8236e(%rip), %rsi # 0xfd060
leaq 0xb8(%rsp), %rdi
callq 0x53290
jmp 0x7ad01
movq 0x20(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x4d4b0
jmp 0x7ad15
movq 0x20(%rsp), %rdi
movb $0x0, 0xa3(%rsp)
movq 0x9a187(%rip), %rsi # 0x114eb0
movq 0x9a1a8(%rip), %rdx # 0x114ed8
callq 0x53310
jmp 0x7aefe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x7ad71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x544b8
leaq 0xb7(%rsp), %rdi
callq 0x50c30
testb $0x1, 0xa3(%rsp)
jne 0x7ad8a
jmp 0x7ad94
movq 0x20(%rsp), %rdi
callq 0x4f6b0
jmp 0x7aef1
leaq 0x80(%rsp), %rdi
leaq 0x7f(%rsp), %rsi
callq 0x50530
movq 0x30(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
movl $0x40, %edi
callq 0x507b0
movq %rax, 0x18(%rsp)
jmp 0x7adca
movb $0x1, 0x3f(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xe0(%rsp), %rdx
movq 0xd8(%rsp), %rcx
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x4d9b0
jmp 0x7ae00
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq 0xe8(%rsp), %rax
movl 0x8c(%rax), %ecx
leaq 0x40(%rsp), %rdx
callq 0x53190
jmp 0x7ae24
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movb $0x0, 0x3f(%rsp)
movq %rax, 0x70(%rsp)
leaq 0x70(%rsp), %rsi
callq 0x50490
jmp 0x7ae44
leaq 0x40(%rsp), %rdi
callq 0x4dba0
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0x53e90
movq 0x30(%rsp), %rdi
movq (%rax), %rsi
callq 0x52da0
jmp 0x7ae6b
leaq 0x80(%rsp), %rdi
callq 0x51670
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x7aee4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x7aeca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4dba0
testb $0x1, 0x3f(%rsp)
jne 0x7aed3
jmp 0x7aee2
movq 0x18(%rsp), %rdi
movl $0x40, %esi
callq 0x508f0
jmp 0x7aee4
leaq 0x80(%rsp), %rdi
callq 0x51670
movq 0xa8(%rsp), %rdi
callq 0x536e0
nop
|
/dkargin[P]miniroscpp/src/rosbag_storage/view.cpp
|
minibag::View::addQuery(minibag::Bag const&, std::function<bool (minibag::ConnectionInfo const*)>, miniros::Time const&, miniros::Time const&)
|
void View::addQuery(Bag const& bag, std::function<bool(ConnectionInfo const*)> query, miniros::Time const& start_time, miniros::Time const& end_time) {
if ((bag.getMode() & bagmode::Read) != bagmode::Read)
throw BagException("Bag not opened for reading");
queries_.push_back(new BagQuery(&bag, Query(query, start_time, end_time), bag.bag_revision_));
updateQueries(queries_.back());
}
|
subq $0xd8, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x4ddd0
andl $0x2, %eax
cmpl $0x2, %eax
je 0x7b147
movb $0x1, 0x7b(%rsp)
movl $0x10, %edi
callq 0x4e850
movq %rax, 0x18(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x53700
movq 0x20(%rsp), %rdx
leaq 0x81fb4(%rip), %rsi # 0xfd060
leaq 0x90(%rsp), %rdi
callq 0x53290
jmp 0x7b0bb
movq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x4d4b0
jmp 0x7b0cf
movq 0x18(%rsp), %rdi
movb $0x0, 0x7b(%rsp)
movq 0x99dd0(%rip), %rsi # 0x114eb0
movq 0x99df1(%rip), %rdx # 0x114ed8
callq 0x53310
jmp 0x7b25b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x7b122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x544b8
leaq 0x8f(%rsp), %rdi
callq 0x50c30
testb $0x1, 0x7b(%rsp)
jne 0x7b138
jmp 0x7b142
movq 0x18(%rsp), %rdi
callq 0x4f6b0
jmp 0x7b24e
movq 0x30(%rsp), %rax
addq $0x18, %rax
movq %rax, (%rsp)
movl $0x40, %edi
callq 0x507b0
movq 0x28(%rsp), %rsi
movq %rax, 0x8(%rsp)
movb $0x1, 0x3f(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xb8(%rsp), %rdx
movq 0xb0(%rsp), %rcx
leaq 0x40(%rsp), %rdi
callq 0x4d9b0
jmp 0x7b196
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0xc8(%rsp), %rax
movl 0x8c(%rax), %ecx
leaq 0x40(%rsp), %rdx
callq 0x53190
jmp 0x7b1ba
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movb $0x0, 0x3f(%rsp)
movq %rax, 0x70(%rsp)
leaq 0x70(%rsp), %rsi
callq 0x50490
jmp 0x7b1d9
leaq 0x40(%rsp), %rdi
callq 0x4dba0
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0x53e90
movq 0x30(%rsp), %rdi
movq (%rax), %rsi
callq 0x52da0
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x7b234
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4dba0
testb $0x1, 0x3f(%rsp)
jne 0x7b23d
jmp 0x7b24c
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x508f0
jmp 0x7b24e
movq 0x80(%rsp), %rdi
callq 0x536e0
nopl (%rax,%rax)
|
/dkargin[P]miniroscpp/src/rosbag_storage/view.cpp
|
minibag::View::~View()
|
View::~View() {
for (MessageRange* range : ranges_)
delete range;
for (BagQuery* query : queries_)
delete query;
}
|
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x52040
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x526e0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x50a50
testb $0x1, %al
jne 0x7b2ab
jmp 0x7b2ea
leaq 0x50(%rsp), %rdi
callq 0x4e360
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x7b2dc
movq 0x10(%rsp), %rdi
movl $0x20, %esi
callq 0x508f0
jmp 0x7b2de
leaq 0x50(%rsp), %rdi
callq 0x4f390
jmp 0x7b296
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x51f40
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x53090
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4d930
testb $0x1, %al
jne 0x7b32b
jmp 0x7b374
leaq 0x30(%rsp), %rdi
callq 0x51250
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x7b366
movq 0x8(%rsp), %rdi
callq 0x4da70
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x508f0
jmp 0x7b368
leaq 0x30(%rsp), %rdi
callq 0x4e150
jmp 0x7b316
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x53a00
movq 0x18(%rsp), %rdi
callq 0x4fc10
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
|
/dkargin[P]miniroscpp/src/rosbag_storage/view.cpp
|
minibag::View::getBeginTime()
|
miniros::Time View::getBeginTime()
{
update();
miniros::Time begin = miniros::TIME_MAX;
for (minibag::MessageRange* range : ranges_)
{
if (range->begin->time < begin)
begin = range->begin->time;
}
return begin;
}
|
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x54480
movq (%rsp), %rax
movq 0x99b56(%rip), %rcx # 0x114f18
movq (%rcx), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x52040
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x526e0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x50a50
testb $0x1, %al
jne 0x7b402
jmp 0x7b451
leaq 0x18(%rsp), %rdi
callq 0x4e360
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x50120
movq %rax, %rdi
leaq 0x30(%rsp), %rsi
callq 0x543a0
testb $0x1, %al
jne 0x7b431
jmp 0x7b443
movq 0x8(%rsp), %rdi
callq 0x50120
movq (%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x7b445
leaq 0x18(%rsp), %rdi
callq 0x4f390
jmp 0x7b3ed
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
|
/dkargin[P]miniroscpp/src/rosbag_storage/view.cpp
|
minibag::BZ2Stream::write(void*, unsigned long)
|
void BZ2Stream::write(void* ptr, size_t size) {
if (!bzfile_) {
throw BagException("cannot write to unopened bzfile");
}
BZ2_bzWrite(&bzerror_, bzfile_, ptr, (int)size);
switch (bzerror_) {
case BZ_IO_ERROR: throw BagException("BZ_IO_ERROR: error writing the compressed file");
}
setCompressedIn(getCompressedIn() + size);
}
|
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x20(%rax)
jne 0x81faf
movb $0x1, 0x5b(%rsp)
movl $0x10, %edi
callq 0x4e850
movq %rax, 0x18(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x53700
movq 0x20(%rsp), %rdx
leaq 0x7b220(%rip), %rsi # 0xfd146
leaq 0x70(%rsp), %rdi
callq 0x53290
jmp 0x81f32
movq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x4d4b0
jmp 0x81f43
movq 0x18(%rsp), %rdi
movb $0x0, 0x5b(%rsp)
movq 0x92f5c(%rip), %rsi # 0x114eb0
movq 0x92f7d(%rip), %rdx # 0x114ed8
callq 0x53310
jmp 0x820c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x81f8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x544b8
leaq 0x6f(%rsp), %rdi
callq 0x50c30
testb $0x1, 0x5b(%rsp)
jne 0x81fa0
jmp 0x81faa
movq 0x18(%rsp), %rdi
callq 0x4f6b0
jmp 0x820bf
movq 0x28(%rsp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq 0x20(%rax), %rsi
movq 0x98(%rsp), %rdx
movl 0x90(%rsp), %ecx
callq 0x53e80
movq 0x28(%rsp), %rax
movl 0x28(%rax), %eax
subl $-0x6, %eax
jne 0x82098
jmp 0x81fe6
movb $0x1, 0x36(%rsp)
movl $0x10, %edi
callq 0x4e850
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x53700
movq 0x10(%rsp), %rdx
leaq 0x7b151(%rip), %rsi # 0xfd166
leaq 0x38(%rsp), %rdi
callq 0x53290
jmp 0x82021
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4d4b0
jmp 0x82032
movq 0x8(%rsp), %rdi
movb $0x0, 0x36(%rsp)
movq 0x92e6d(%rip), %rsi # 0x114eb0
movq 0x92e8e(%rip), %rdx # 0x114ed8
callq 0x53310
jmp 0x820c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x82079
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x544b8
leaq 0x37(%rsp), %rdi
callq 0x50c30
testb $0x1, 0x36(%rsp)
jne 0x8208c
jmp 0x82096
movq 0x8(%rsp), %rdi
callq 0x4f6b0
jmp 0x820bf
movq 0x28(%rsp), %rdi
callq 0x4f4f0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
addq 0x90(%rsp), %rsi
callq 0x4f460
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x536e0
nopl (%rax)
|
/dkargin[P]miniroscpp/src/rosbag_storage/bz2_stream.cpp
|
minibag::BZ2Stream::stopWrite()
|
void BZ2Stream::stopWrite() {
if (!bzfile_) {
throw BagException("cannot close unopened bzfile");
}
unsigned int nbytes_in;
unsigned int nbytes_out;
BZ2_bzWriteClose(&bzerror_, bzfile_, 0, &nbytes_in, &nbytes_out);
switch (bzerror_) {
case BZ_IO_ERROR: throw BagIOException("BZ_IO_ERROR");
}
advanceOffset(nbytes_out);
setCompressedIn(0);
}
|
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rax)
jne 0x821af
movb $0x1, 0x5b(%rsp)
movl $0x10, %edi
callq 0x4e850
movq %rax, 0x10(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x53700
movq 0x18(%rsp), %rdx
leaq 0x7b06f(%rip), %rsi # 0xfd195
leaq 0x70(%rsp), %rdi
callq 0x53290
jmp 0x82132
movq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x4d4b0
jmp 0x82143
movq 0x10(%rsp), %rdi
movb $0x0, 0x5b(%rsp)
movq 0x92d5c(%rip), %rsi # 0x114eb0
movq 0x92d7d(%rip), %rdx # 0x114ed8
callq 0x53310
jmp 0x822c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x8218d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x544b8
leaq 0x6f(%rsp), %rdi
callq 0x50c30
testb $0x1, 0x5b(%rsp)
jne 0x821a0
jmp 0x821aa
movq 0x10(%rsp), %rdi
callq 0x4f6b0
jmp 0x822b7
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq 0x20(%rax), %rsi
xorl %edx, %edx
leaq 0x54(%rsp), %rcx
leaq 0x50(%rsp), %r8
callq 0x527b0
movq 0x20(%rsp), %rax
movl 0x28(%rax), %eax
subl $-0x6, %eax
jne 0x82291
jmp 0x821e3
movb $0x1, 0x2e(%rsp)
movl $0x10, %edi
callq 0x4e850
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x53700
movq 0x8(%rsp), %rdx
leaq 0x7afa1(%rip), %rsi # 0xfd1b2
leaq 0x30(%rsp), %rdi
callq 0x53290
jmp 0x8221d
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x519b0
jmp 0x8222d
movq (%rsp), %rdi
movb $0x0, 0x2e(%rsp)
movq 0x92c6b(%rip), %rsi # 0x114ea8
movq 0x92c54(%rip), %rdx # 0x114e98
callq 0x53310
jmp 0x822c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x82273
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x544b8
leaq 0x2f(%rsp), %rdi
callq 0x50c30
testb $0x1, 0x2e(%rsp)
jne 0x82286
jmp 0x8228f
movq (%rsp), %rdi
callq 0x4f6b0
jmp 0x822b7
movq 0x20(%rsp), %rdi
movl 0x50(%rsp), %eax
movl %eax, %esi
callq 0x4fa80
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4f460
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x536e0
nopw %cs:(%rax,%rax)
|
/dkargin[P]miniroscpp/src/rosbag_storage/bz2_stream.cpp
|
minibag::BZ2Stream::startRead()
|
void BZ2Stream::startRead() {
bzfile_ = BZ2_bzReadOpen(&bzerror_, getFilePointer(), verbosity_, 0, getUnused(), getUnusedLength());
switch (bzerror_) {
case BZ_OK: break;
default: {
BZ2_bzReadClose(&bzerror_, bzfile_);
throw BagException("Error opening file for reading compressed stream");
}
}
clearUnused();
}
|
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
callq 0x53230
movq 0x30(%rsp), %rdi
movq %rax, 0x18(%rsp)
movl 0x10(%rdi), %eax
movl %eax, 0x24(%rsp)
callq 0x4ff40
movq 0x30(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0x53d50
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %r8
movl %eax, %r9d
xorl %ecx, %ecx
callq 0x529b0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movl 0x28(%rax), %eax
testl %eax, %eax
jne 0x82350
jmp 0x8234b
jmp 0x82413
movq 0x30(%rsp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq 0x20(%rax), %rsi
callq 0x53f90
movb $0x1, 0x3b(%rsp)
movl $0x10, %edi
callq 0x4e850
movq %rax, (%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x53700
movq 0x8(%rsp), %rdx
leaq 0x7ae2b(%rip), %rsi # 0xfd1be
leaq 0x50(%rsp), %rdi
callq 0x53290
jmp 0x8239f
movq (%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x4d4b0
jmp 0x823af
movq (%rsp), %rdi
movb $0x0, 0x3b(%rsp)
movq 0x92af1(%rip), %rsi # 0x114eb0
movq 0x92b12(%rip), %rdx # 0x114ed8
callq 0x53310
jmp 0x8242c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x823f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x544b8
leaq 0x4f(%rsp), %rdi
callq 0x50c30
testb $0x1, 0x3b(%rsp)
jne 0x82408
jmp 0x82411
movq (%rsp), %rdi
callq 0x4f6b0
jmp 0x82422
movq 0x30(%rsp), %rdi
callq 0x4d820
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x536e0
nopl (%rax)
|
/dkargin[P]miniroscpp/src/rosbag_storage/bz2_stream.cpp
|
minibag::BZ2Stream::~BZ2Stream()
|
class ROSBAG_STORAGE_DECL BZ2Stream : public Stream
{
public:
BZ2Stream(ChunkedFile* file);
CompressionType getCompressionType() const;
void startWrite();
void write(void* ptr, size_t size);
void stopWrite();
void startRead();
void read(void* ptr, size_t size);
void stopRead();
void decompress(uint8_t* dest, unsigned int dest_len, uint8_t* source, unsigned int source_len);
private:
int verbosity_; //!< level of debugging output (0-4; 0 default). 0 is silent, 4 is max verbose debugging output
int block_size_100k_; //!< compression block size (1-9; 9 default). 9 is best compression, most memory
int work_factor_; //!< compression behavior for worst case, highly repetitive data (0-250; 30 default)
BZFILE* bzfile_; //!< bzlib compressed file stream
int bzerror_; //!< last error from bzlib
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x53020
movq 0x8(%rsp), %rdi
movl $0x30, %esi
callq 0x508f0
addq $0x18, %rsp
retq
nopl (%rax)
|
/dkargin[P]miniroscpp/include/minibag/bz2_stream.h
|
streamStateAlloc
|
int streamStateAlloc(roslz4_stream *str) {
stream_state *state = (stream_state*) malloc(sizeof(stream_state));
if (state == NULL) {
return ROSLZ4_MEMORY_ERROR; // Allocation of state failed
}
str->state = state;
str->block_size_id = -1;
state->block_independence_flag = 1;
state->block_checksum_flag = 0;
state->stream_checksum_flag = 1;
state->finished = 0;
state->xxh32_state = XXH32_init(0);
if (state->xxh32_state == NULL) {
if (state->buffer != NULL) {
free(state->buffer);
}
free(state);
str->state = NULL;
return ROSLZ4_MEMORY_ERROR; // Allocation failed
}
state->stream_checksum = 0;
state->stream_checksum_read = 0;
state->wrote_header = 0;
state->buffer_offset = 0;
state->buffer_size = 0;
state->buffer = NULL;
state->block_size = 0;
state->block_size_read = 0;
state->block_uncompressed = 0;
str->total_in = 0;
str->total_out = 0;
return ROSLZ4_OK;
}
|
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x58, %edi
callq 0x51bb0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x85abb
movl $0xfffffffb, 0x14(%rsp) # imm = 0xFFFFFFFB
jmp 0x85bdb
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x24(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0x1, (%rax)
movq (%rsp), %rax
movl $0x0, 0x4(%rax)
movq (%rsp), %rax
movl $0x1, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, 0x20(%rax)
xorl %edi, %edi
callq 0x50ff0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x85b57
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x85b34
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x512e0
movq (%rsp), %rdi
callq 0x512e0
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movl $0xfffffffb, 0x14(%rsp) # imm = 0xFFFFFFFB
jmp 0x85bdb
movq (%rsp), %rax
movl $0x0, 0x4c(%rax)
movq (%rsp), %rax
movl $0x0, 0x50(%rax)
movq (%rsp), %rax
movl $0x0, 0x30(%rax)
movq (%rsp), %rax
movl $0x0, 0x1c(%rax)
movq (%rsp), %rax
movl $0x0, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movl $0x0, 0x40(%rax)
movq (%rsp), %rax
movl $0x0, 0x44(%rax)
movq (%rsp), %rax
movl $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x1c(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
|
/dkargin[P]miniroscpp/src/roslz4/lz4s.c
|
streamStateFree
|
void streamStateFree(roslz4_stream *str) {
stream_state *state = str->state;
if (state != NULL) {
if (state->buffer != NULL) {
free(state->buffer);
}
if (state->xxh32_state != NULL) {
XXH32_digest(state->xxh32_state);
}
free(state);
str->state = NULL;
}
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x85d2a
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x85cf9
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x512e0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x85d13
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x4f690
movq 0x8(%rsp), %rdi
callq 0x512e0
movq 0x10(%rsp), %rax
movq $0x0, 0x28(%rax)
addq $0x18, %rsp
retq
nop
|
/dkargin[P]miniroscpp/src/roslz4/lz4s.c
|
decompressBlock
|
int decompressBlock(roslz4_stream *str) {
stream_state *state = str->state;
if (state->block_size_read != 4 || state->block_size != state->buffer_offset) {
// Internal error: Can't decompress block, it's not in buffer
return ROSLZ4_ERROR;
}
if (state->block_uncompressed) {
if (str->output_left >= state->block_size) {
memcpy(str->output_next, state->buffer, state->block_size);
int ret = XXH32_update(state->xxh32_state, str->output_next,
state->block_size);
if (ret == XXH_ERROR) { return ROSLZ4_ERROR; }
advanceOutput(str, state->block_size);
state->block_size_read = 0;
state->buffer_offset = 0;
return ROSLZ4_OK;
} else {
return ROSLZ4_OUTPUT_SMALL;
}
} else {
int decomp_size;
decomp_size = LZ4_decompress_safe(state->buffer, str->output_next,
state->block_size, str->output_left);
if (decomp_size < 0) {
if (str->output_left >= state->buffer_size) {
return ROSLZ4_DATA_ERROR; // Must be a problem with the data stream
} else {
// Data error or output is small; increase output to disambiguate
return ROSLZ4_OUTPUT_SMALL;
}
} else {
int ret = XXH32_update(state->xxh32_state, str->output_next, decomp_size);
if (ret == XXH_ERROR) { return ROSLZ4_ERROR; }
advanceOutput(str, decomp_size);
state->block_size_read = 0;
state->buffer_offset = 0;
return ROSLZ4_OK;
}
}
}
|
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x4, 0x44(%rax)
jne 0x86364
movq 0x10(%rsp), %rax
movl 0x40(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x1c(%rcx), %eax
je 0x86371
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x864e8
movq 0x10(%rsp), %rax
cmpl $0x0, 0x48(%rax)
je 0x86432
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x40(%rcx), %eax
jb 0x86425
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, %edx
callq 0x4fcf0
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rax
movl 0x40(%rax), %edx
callq 0x4da80
movl %eax, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jne 0x863ee
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x864e8
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x40(%rax), %esi
callq 0x516f0
movq 0x10(%rsp), %rax
movl $0x0, 0x44(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x1c(%rax)
movl $0x0, 0x24(%rsp)
jmp 0x864e8
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0x864e8
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rax
movl 0x40(%rax), %edx
movq 0x18(%rsp), %rax
movl 0x18(%rax), %ecx
callq 0x4e5f0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jge 0x8648a
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x86480
movl $0xfffffffd, 0x24(%rsp) # imm = 0xFFFFFFFD
jmp 0x864e8
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0x864e8
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x8(%rsp), %edx
callq 0x4da80
movl %eax, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jne 0x864ba
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x864e8
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x516f0
movq 0x10(%rsp), %rax
movl $0x0, 0x44(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x1c(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
/dkargin[P]miniroscpp/src/roslz4/lz4s.c
|
readChecksum
|
int readChecksum(roslz4_stream *str) {
stream_state *state = str->state;
fillUInt32(str, &state->stream_checksum, &state->stream_checksum_read);
if (state->stream_checksum_read == 4) {
state->finished = 1;
state->stream_checksum = readUInt32((unsigned char*)&state->stream_checksum);
uint32_t checksum = XXH32_digest(state->xxh32_state);
state->xxh32_state = NULL;
if (checksum == state->stream_checksum) {
return ROSLZ4_STREAM_END;
} else {
return ROSLZ4_DATA_ERROR;
}
}
return ROSLZ4_OK;
}
|
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x4c, %rsi
movq 0x10(%rsp), %rdx
addq $0x50, %rdx
callq 0x4fa30
movq 0x10(%rsp), %rax
cmpl $0x4, 0x50(%rax)
jne 0x865a3
movq 0x10(%rsp), %rax
movl $0x1, 0x20(%rax)
movq 0x10(%rsp), %rdi
addq $0x4c, %rdi
callq 0x53a70
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4c(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x4f690
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, 0x28(%rax)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x4c(%rcx), %eax
jne 0x86599
movl $0x2, 0x24(%rsp)
jmp 0x865ab
movl $0xfffffffd, 0x24(%rsp) # imm = 0xFFFFFFFD
jmp 0x865ab
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
/dkargin[P]miniroscpp/src/roslz4/lz4s.c
|
XXH32_update
|
XXH_errorcode XXH32_update (void* state_in, const void* input, int len)
{
XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
else
return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
}
|
subq $0x3e8, %rsp # imm = 0x3E8
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl %edx, 0x84(%rsp)
movsbl 0x75fc3(%rip), %eax # 0xfd8d8
movl %eax, 0x80(%rsp)
cmpl $0x1, 0x80(%rsp)
jne 0x885c4
movq 0x90(%rsp), %rdx
movq 0x88(%rsp), %rcx
movl 0x84(%rsp), %eax
movq %rdx, 0x140(%rsp)
movq %rcx, 0x138(%rsp)
movl %eax, 0x134(%rsp)
movl $0x1, 0x130(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rax
movslq 0x134(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x118(%rsp)
movslq 0x134(%rsp), %rcx
movq 0x128(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x128(%rsp), %rax
movl 0x1c(%rax), %eax
addl 0x134(%rsp), %eax
cmpl $0x10, %eax
jge 0x87a54
movq 0x128(%rsp), %rdx
addq $0x20, %rdx
movq 0x128(%rsp), %rax
movslq 0x1c(%rax), %rax
addq %rax, %rdx
movq 0x138(%rsp), %rcx
movslq 0x134(%rsp), %rax
movq %rdx, 0x160(%rsp)
movq %rcx, 0x158(%rsp)
movq %rax, 0x150(%rsp)
movq 0x160(%rsp), %rdi
movq 0x158(%rsp), %rsi
movq 0x150(%rsp), %rdx
callq 0x4fcf0
movl 0x134(%rsp), %ecx
movq 0x128(%rsp), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movl $0x0, 0x14c(%rsp)
jmp 0x885b1
movq 0x128(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x87fc5
movq 0x128(%rsp), %rdx
addq $0x20, %rdx
movq 0x128(%rsp), %rax
movslq 0x1c(%rax), %rax
addq %rax, %rdx
movq 0x138(%rsp), %rcx
movq 0x128(%rsp), %rsi
movl $0x10, %eax
subl 0x1c(%rsi), %eax
cltq
movq %rdx, 0x178(%rsp)
movq %rcx, 0x170(%rsp)
movq %rax, 0x168(%rsp)
movq 0x178(%rsp), %rdi
movq 0x170(%rsp), %rsi
movq 0x168(%rsp), %rdx
callq 0x4fcf0
movq 0x128(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rcx
movl 0x130(%rsp), %eax
movq %rcx, 0x248(%rsp)
movl %eax, 0x244(%rsp)
movq 0x248(%rsp), %rcx
movl 0x244(%rsp), %eax
movq %rcx, 0x258(%rsp)
movl %eax, 0x254(%rsp)
movl $0x1, 0x250(%rsp)
cmpl $0x1, 0x250(%rsp)
jne 0x87b6f
cmpl $0x1, 0x254(%rsp)
jne 0x87b4f
movq 0x258(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x7c(%rsp)
jmp 0x87b62
movq 0x258(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x260(%rsp)
jmp 0x87ba7
cmpl $0x1, 0x254(%rsp)
jne 0x87b89
movq 0x258(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x78(%rsp)
jmp 0x87b9c
movq 0x258(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x78(%rsp)
movl 0x78(%rsp), %eax
movl %eax, 0x260(%rsp)
imull $0x85ebca77, 0x260(%rsp), %ecx # imm = 0x85EBCA77
movq 0x128(%rsp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq 0x128(%rsp), %rax
movl 0xc(%rax), %ecx
shll $0xd, %ecx
movq 0x128(%rsp), %rax
movl 0xc(%rax), %eax
shrl $0x13, %eax
orl %eax, %ecx
movq 0x128(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x128(%rsp), %rax
imull $0x9e3779b1, 0xc(%rax), %ecx # imm = 0x9E3779B1
movl %ecx, 0xc(%rax)
movq 0x110(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rcx
movl 0x130(%rsp), %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
movq 0x228(%rsp), %rcx
movl 0x224(%rsp), %eax
movq %rcx, 0x238(%rsp)
movl %eax, 0x234(%rsp)
movl $0x1, 0x230(%rsp)
cmpl $0x1, 0x230(%rsp)
jne 0x87c9a
cmpl $0x1, 0x234(%rsp)
jne 0x87c7a
movq 0x238(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x74(%rsp)
jmp 0x87c8d
movq 0x238(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
movl %eax, 0x240(%rsp)
jmp 0x87cd2
cmpl $0x1, 0x234(%rsp)
jne 0x87cb4
movq 0x238(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x70(%rsp)
jmp 0x87cc7
movq 0x238(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x70(%rsp)
movl 0x70(%rsp), %eax
movl %eax, 0x240(%rsp)
imull $0x85ebca77, 0x240(%rsp), %ecx # imm = 0x85EBCA77
movq 0x128(%rsp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq 0x128(%rsp), %rax
movl 0x10(%rax), %ecx
shll $0xd, %ecx
movq 0x128(%rsp), %rax
movl 0x10(%rax), %eax
shrl $0x13, %eax
orl %eax, %ecx
movq 0x128(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x128(%rsp), %rax
imull $0x9e3779b1, 0x10(%rax), %ecx # imm = 0x9E3779B1
movl %ecx, 0x10(%rax)
movq 0x110(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rcx
movl 0x130(%rsp), %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
movq 0x208(%rsp), %rcx
movl 0x204(%rsp), %eax
movq %rcx, 0x218(%rsp)
movl %eax, 0x214(%rsp)
movl $0x1, 0x210(%rsp)
cmpl $0x1, 0x210(%rsp)
jne 0x87dc5
cmpl $0x1, 0x214(%rsp)
jne 0x87da5
movq 0x218(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x6c(%rsp)
jmp 0x87db8
movq 0x218(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x220(%rsp)
jmp 0x87dfd
cmpl $0x1, 0x214(%rsp)
jne 0x87ddf
movq 0x218(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x68(%rsp)
jmp 0x87df2
movq 0x218(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x68(%rsp)
movl 0x68(%rsp), %eax
movl %eax, 0x220(%rsp)
imull $0x85ebca77, 0x220(%rsp), %ecx # imm = 0x85EBCA77
movq 0x128(%rsp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq 0x128(%rsp), %rax
movl 0x14(%rax), %ecx
shll $0xd, %ecx
movq 0x128(%rsp), %rax
movl 0x14(%rax), %eax
shrl $0x13, %eax
orl %eax, %ecx
movq 0x128(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x128(%rsp), %rax
imull $0x9e3779b1, 0x14(%rax), %ecx # imm = 0x9E3779B1
movl %ecx, 0x14(%rax)
movq 0x110(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rcx
movl 0x130(%rsp), %eax
movq %rcx, 0x1e8(%rsp)
movl %eax, 0x1e4(%rsp)
movq 0x1e8(%rsp), %rcx
movl 0x1e4(%rsp), %eax
movq %rcx, 0x1f8(%rsp)
movl %eax, 0x1f4(%rsp)
movl $0x1, 0x1f0(%rsp)
cmpl $0x1, 0x1f0(%rsp)
jne 0x87ef0
cmpl $0x1, 0x1f4(%rsp)
jne 0x87ed0
movq 0x1f8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x64(%rsp)
jmp 0x87ee3
movq 0x1f8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x200(%rsp)
jmp 0x87f28
cmpl $0x1, 0x1f4(%rsp)
jne 0x87f0a
movq 0x1f8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x60(%rsp)
jmp 0x87f1d
movq 0x1f8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x200(%rsp)
imull $0x85ebca77, 0x200(%rsp), %ecx # imm = 0x85EBCA77
movq 0x128(%rsp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movq 0x128(%rsp), %rax
movl 0x18(%rax), %ecx
shll $0xd, %ecx
movq 0x128(%rsp), %rax
movl 0x18(%rax), %eax
shrl $0x13, %eax
orl %eax, %ecx
movq 0x128(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x128(%rsp), %rax
imull $0x9e3779b1, 0x18(%rax), %ecx # imm = 0x9E3779B1
movl %ecx, 0x18(%rax)
movq 0x110(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x110(%rsp)
movq 0x128(%rsp), %rax
movl $0x10, %ecx
subl 0x1c(%rax), %ecx
movq 0x120(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x120(%rsp)
movq 0x128(%rsp), %rax
movl $0x0, 0x1c(%rax)
movq 0x120(%rsp), %rax
movq 0x118(%rsp), %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
ja 0x88518
movq 0x118(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x108(%rsp)
movq 0x128(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x104(%rsp)
movq 0x128(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x100(%rsp)
movq 0x128(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0xfc(%rsp)
movq 0x128(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0xf8(%rsp)
movq 0x120(%rsp), %rcx
movl 0x130(%rsp), %eax
movq %rcx, 0x2c8(%rsp)
movl %eax, 0x2c4(%rsp)
movq 0x2c8(%rsp), %rcx
movl 0x2c4(%rsp), %eax
movq %rcx, 0x2d8(%rsp)
movl %eax, 0x2d4(%rsp)
movl $0x1, 0x2d0(%rsp)
cmpl $0x1, 0x2d0(%rsp)
jne 0x880c9
cmpl $0x1, 0x2d4(%rsp)
jne 0x880a9
movq 0x2d8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x5c(%rsp)
jmp 0x880bc
movq 0x2d8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x2e0(%rsp)
jmp 0x88101
cmpl $0x1, 0x2d4(%rsp)
jne 0x880e3
movq 0x2d8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x58(%rsp)
jmp 0x880f6
movq 0x2d8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x58(%rsp)
movl 0x58(%rsp), %eax
movl %eax, 0x2e0(%rsp)
imull $0x85ebca77, 0x2e0(%rsp), %eax # imm = 0x85EBCA77
addl 0x104(%rsp), %eax
movl %eax, 0x104(%rsp)
movl 0x104(%rsp), %eax
shll $0xd, %eax
movl 0x104(%rsp), %ecx
shrl $0x13, %ecx
orl %ecx, %eax
movl %eax, 0x104(%rsp)
imull $0x9e3779b1, 0x104(%rsp), %eax # imm = 0x9E3779B1
movl %eax, 0x104(%rsp)
movq 0x120(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rcx
movl 0x130(%rsp), %eax
movq %rcx, 0x2a8(%rsp)
movl %eax, 0x2a4(%rsp)
movq 0x2a8(%rsp), %rcx
movl 0x2a4(%rsp), %eax
movq %rcx, 0x2b8(%rsp)
movl %eax, 0x2b4(%rsp)
movl $0x1, 0x2b0(%rsp)
cmpl $0x1, 0x2b0(%rsp)
jne 0x881e8
cmpl $0x1, 0x2b4(%rsp)
jne 0x881c8
movq 0x2b8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x54(%rsp)
jmp 0x881db
movq 0x2b8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x2c0(%rsp)
jmp 0x88220
cmpl $0x1, 0x2b4(%rsp)
jne 0x88202
movq 0x2b8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x50(%rsp)
jmp 0x88215
movq 0x2b8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x50(%rsp)
movl 0x50(%rsp), %eax
movl %eax, 0x2c0(%rsp)
imull $0x85ebca77, 0x2c0(%rsp), %eax # imm = 0x85EBCA77
addl 0x100(%rsp), %eax
movl %eax, 0x100(%rsp)
movl 0x100(%rsp), %eax
shll $0xd, %eax
movl 0x100(%rsp), %ecx
shrl $0x13, %ecx
orl %ecx, %eax
movl %eax, 0x100(%rsp)
imull $0x9e3779b1, 0x100(%rsp), %eax # imm = 0x9E3779B1
movl %eax, 0x100(%rsp)
movq 0x120(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rcx
movl 0x130(%rsp), %eax
movq %rcx, 0x288(%rsp)
movl %eax, 0x284(%rsp)
movq 0x288(%rsp), %rcx
movl 0x284(%rsp), %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
movl $0x1, 0x290(%rsp)
cmpl $0x1, 0x290(%rsp)
jne 0x88307
cmpl $0x1, 0x294(%rsp)
jne 0x882e7
movq 0x298(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4c(%rsp)
jmp 0x882fa
movq 0x298(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x2a0(%rsp)
jmp 0x8833f
cmpl $0x1, 0x294(%rsp)
jne 0x88321
movq 0x298(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x48(%rsp)
jmp 0x88334
movq 0x298(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x48(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x2a0(%rsp)
imull $0x85ebca77, 0x2a0(%rsp), %eax # imm = 0x85EBCA77
addl 0xfc(%rsp), %eax
movl %eax, 0xfc(%rsp)
movl 0xfc(%rsp), %eax
shll $0xd, %eax
movl 0xfc(%rsp), %ecx
shrl $0x13, %ecx
orl %ecx, %eax
movl %eax, 0xfc(%rsp)
imull $0x9e3779b1, 0xfc(%rsp), %eax # imm = 0x9E3779B1
movl %eax, 0xfc(%rsp)
movq 0x120(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rcx
movl 0x130(%rsp), %eax
movq %rcx, 0x268(%rsp)
movl %eax, 0x264(%rsp)
movq 0x268(%rsp), %rcx
movl 0x264(%rsp), %eax
movq %rcx, 0x278(%rsp)
movl %eax, 0x274(%rsp)
movl $0x1, 0x270(%rsp)
cmpl $0x1, 0x270(%rsp)
jne 0x88426
cmpl $0x1, 0x274(%rsp)
jne 0x88406
movq 0x278(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x44(%rsp)
jmp 0x88419
movq 0x278(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x280(%rsp)
jmp 0x8845e
cmpl $0x1, 0x274(%rsp)
jne 0x88440
movq 0x278(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x40(%rsp)
jmp 0x88453
movq 0x278(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x280(%rsp)
imull $0x85ebca77, 0x280(%rsp), %eax # imm = 0x85EBCA77
addl 0xf8(%rsp), %eax
movl %eax, 0xf8(%rsp)
movl 0xf8(%rsp), %eax
shll $0xd, %eax
movl 0xf8(%rsp), %ecx
shrl $0x13, %ecx
orl %ecx, %eax
movl %eax, 0xf8(%rsp)
imull $0x9e3779b1, 0xf8(%rsp), %eax # imm = 0x9E3779B1
movl %eax, 0xf8(%rsp)
movq 0x120(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rax
cmpq 0x108(%rsp), %rax
jbe 0x8803e
movl 0x104(%rsp), %ecx
movq 0x128(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x100(%rsp), %ecx
movq 0x128(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0xfc(%rsp), %ecx
movq 0x128(%rsp), %rax
movl %ecx, 0x14(%rax)
movl 0xf8(%rsp), %ecx
movq 0x128(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x120(%rsp), %rax
cmpq 0x118(%rsp), %rax
jae 0x885a6
movq 0x128(%rsp), %rdx
addq $0x20, %rdx
movq 0x120(%rsp), %rcx
movq 0x118(%rsp), %rax
movq 0x120(%rsp), %rsi
subq %rsi, %rax
movq %rdx, 0x190(%rsp)
movq %rcx, 0x188(%rsp)
movq %rax, 0x180(%rsp)
movq 0x190(%rsp), %rdi
movq 0x188(%rsp), %rsi
movq 0x180(%rsp), %rdx
callq 0x4fcf0
movq 0x118(%rsp), %rax
movq 0x120(%rsp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq 0x128(%rsp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, 0x14c(%rsp)
movl 0x14c(%rsp), %eax
movl %eax, 0x9c(%rsp)
jmp 0x89256
movq 0x90(%rsp), %rdx
movq 0x88(%rsp), %rcx
movl 0x84(%rsp), %eax
movq %rdx, 0xe8(%rsp)
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
movl $0x0, 0xd8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
movslq 0xdc(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0xc0(%rsp)
movslq 0xdc(%rsp), %rcx
movq 0xd0(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0xd0(%rsp), %rax
movl 0x1c(%rax), %eax
addl 0xdc(%rsp), %eax
cmpl $0x10, %eax
jge 0x886ee
movq 0xd0(%rsp), %rdx
addq $0x20, %rdx
movq 0xd0(%rsp), %rax
movslq 0x1c(%rax), %rax
addq %rax, %rdx
movq 0xe0(%rsp), %rcx
movslq 0xdc(%rsp), %rax
movq %rdx, 0x1a8(%rsp)
movq %rcx, 0x1a0(%rsp)
movq %rax, 0x198(%rsp)
movq 0x1a8(%rsp), %rdi
movq 0x1a0(%rsp), %rsi
movq 0x198(%rsp), %rdx
callq 0x4fcf0
movl 0xdc(%rsp), %ecx
movq 0xd0(%rsp), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movl $0x0, 0xf4(%rsp)
jmp 0x89248
movq 0xd0(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x88c5f
movq 0xd0(%rsp), %rdx
addq $0x20, %rdx
movq 0xd0(%rsp), %rax
movslq 0x1c(%rax), %rax
addq %rax, %rdx
movq 0xe0(%rsp), %rcx
movq 0xd0(%rsp), %rsi
movl $0x10, %eax
subl 0x1c(%rsi), %eax
cltq
movq %rdx, 0x1c0(%rsp)
movq %rcx, 0x1b8(%rsp)
movq %rax, 0x1b0(%rsp)
movq 0x1c0(%rsp), %rdi
movq 0x1b8(%rsp), %rsi
movq 0x1b0(%rsp), %rdx
callq 0x4fcf0
movq 0xd0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rcx
movl 0xd8(%rsp), %eax
movq %rcx, 0x348(%rsp)
movl %eax, 0x344(%rsp)
movq 0x348(%rsp), %rcx
movl 0x344(%rsp), %eax
movq %rcx, 0x358(%rsp)
movl %eax, 0x354(%rsp)
movl $0x1, 0x350(%rsp)
cmpl $0x1, 0x350(%rsp)
jne 0x88809
cmpl $0x1, 0x354(%rsp)
jne 0x887e9
movq 0x358(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x3c(%rsp)
jmp 0x887fc
movq 0x358(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x360(%rsp)
jmp 0x88841
cmpl $0x1, 0x354(%rsp)
jne 0x88823
movq 0x358(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x38(%rsp)
jmp 0x88836
movq 0x358(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x360(%rsp)
imull $0x85ebca77, 0x360(%rsp), %ecx # imm = 0x85EBCA77
movq 0xd0(%rsp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq 0xd0(%rsp), %rax
movl 0xc(%rax), %ecx
shll $0xd, %ecx
movq 0xd0(%rsp), %rax
movl 0xc(%rax), %eax
shrl $0x13, %eax
orl %eax, %ecx
movq 0xd0(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0xd0(%rsp), %rax
imull $0x9e3779b1, 0xc(%rax), %ecx # imm = 0x9E3779B1
movl %ecx, 0xc(%rax)
movq 0xb8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rcx
movl 0xd8(%rsp), %eax
movq %rcx, 0x328(%rsp)
movl %eax, 0x324(%rsp)
movq 0x328(%rsp), %rcx
movl 0x324(%rsp), %eax
movq %rcx, 0x338(%rsp)
movl %eax, 0x334(%rsp)
movl $0x1, 0x330(%rsp)
cmpl $0x1, 0x330(%rsp)
jne 0x88934
cmpl $0x1, 0x334(%rsp)
jne 0x88914
movq 0x338(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x88927
movq 0x338(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x340(%rsp)
jmp 0x8896c
cmpl $0x1, 0x334(%rsp)
jne 0x8894e
movq 0x338(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x30(%rsp)
jmp 0x88961
movq 0x338(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x340(%rsp)
imull $0x85ebca77, 0x340(%rsp), %ecx # imm = 0x85EBCA77
movq 0xd0(%rsp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq 0xd0(%rsp), %rax
movl 0x10(%rax), %ecx
shll $0xd, %ecx
movq 0xd0(%rsp), %rax
movl 0x10(%rax), %eax
shrl $0x13, %eax
orl %eax, %ecx
movq 0xd0(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0xd0(%rsp), %rax
imull $0x9e3779b1, 0x10(%rax), %ecx # imm = 0x9E3779B1
movl %ecx, 0x10(%rax)
movq 0xb8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rcx
movl 0xd8(%rsp), %eax
movq %rcx, 0x308(%rsp)
movl %eax, 0x304(%rsp)
movq 0x308(%rsp), %rcx
movl 0x304(%rsp), %eax
movq %rcx, 0x318(%rsp)
movl %eax, 0x314(%rsp)
movl $0x1, 0x310(%rsp)
cmpl $0x1, 0x310(%rsp)
jne 0x88a5f
cmpl $0x1, 0x314(%rsp)
jne 0x88a3f
movq 0x318(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
jmp 0x88a52
movq 0x318(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x320(%rsp)
jmp 0x88a97
cmpl $0x1, 0x314(%rsp)
jne 0x88a79
movq 0x318(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x28(%rsp)
jmp 0x88a8c
movq 0x318(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x320(%rsp)
imull $0x85ebca77, 0x320(%rsp), %ecx # imm = 0x85EBCA77
movq 0xd0(%rsp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq 0xd0(%rsp), %rax
movl 0x14(%rax), %ecx
shll $0xd, %ecx
movq 0xd0(%rsp), %rax
movl 0x14(%rax), %eax
shrl $0x13, %eax
orl %eax, %ecx
movq 0xd0(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0xd0(%rsp), %rax
imull $0x9e3779b1, 0x14(%rax), %ecx # imm = 0x9E3779B1
movl %ecx, 0x14(%rax)
movq 0xb8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rcx
movl 0xd8(%rsp), %eax
movq %rcx, 0x2e8(%rsp)
movl %eax, 0x2e4(%rsp)
movq 0x2e8(%rsp), %rcx
movl 0x2e4(%rsp), %eax
movq %rcx, 0x2f8(%rsp)
movl %eax, 0x2f4(%rsp)
movl $0x1, 0x2f0(%rsp)
cmpl $0x1, 0x2f0(%rsp)
jne 0x88b8a
cmpl $0x1, 0x2f4(%rsp)
jne 0x88b6a
movq 0x2f8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x88b7d
movq 0x2f8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x300(%rsp)
jmp 0x88bc2
cmpl $0x1, 0x2f4(%rsp)
jne 0x88ba4
movq 0x2f8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x20(%rsp)
jmp 0x88bb7
movq 0x2f8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x300(%rsp)
imull $0x85ebca77, 0x300(%rsp), %ecx # imm = 0x85EBCA77
movq 0xd0(%rsp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movq 0xd0(%rsp), %rax
movl 0x18(%rax), %ecx
shll $0xd, %ecx
movq 0xd0(%rsp), %rax
movl 0x18(%rax), %eax
shrl $0x13, %eax
orl %eax, %ecx
movq 0xd0(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0xd0(%rsp), %rax
imull $0x9e3779b1, 0x18(%rax), %ecx # imm = 0x9E3779B1
movl %ecx, 0x18(%rax)
movq 0xb8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xb8(%rsp)
movq 0xd0(%rsp), %rax
movl $0x10, %ecx
subl 0x1c(%rax), %ecx
movq 0xc8(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movl $0x0, 0x1c(%rax)
movq 0xc8(%rsp), %rax
movq 0xc0(%rsp), %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
ja 0x891af
movq 0xc0(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0xb0(%rsp)
movq 0xd0(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xac(%rsp)
movq 0xd0(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0xa8(%rsp)
movq 0xd0(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0xa4(%rsp)
movq 0xd0(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0xa0(%rsp)
movq 0xc8(%rsp), %rcx
movl 0xd8(%rsp), %eax
movq %rcx, 0x3c8(%rsp)
movl %eax, 0x3c4(%rsp)
movq 0x3c8(%rsp), %rcx
movl 0x3c4(%rsp), %eax
movq %rcx, 0x3d8(%rsp)
movl %eax, 0x3d4(%rsp)
movl $0x1, 0x3d0(%rsp)
cmpl $0x1, 0x3d0(%rsp)
jne 0x88d63
cmpl $0x1, 0x3d4(%rsp)
jne 0x88d43
movq 0x3d8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x88d56
movq 0x3d8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x3e4(%rsp)
jmp 0x88d9b
cmpl $0x1, 0x3d4(%rsp)
jne 0x88d7d
movq 0x3d8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x18(%rsp)
jmp 0x88d90
movq 0x3d8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x3e4(%rsp)
imull $0x85ebca77, 0x3e4(%rsp), %eax # imm = 0x85EBCA77
addl 0xac(%rsp), %eax
movl %eax, 0xac(%rsp)
movl 0xac(%rsp), %eax
shll $0xd, %eax
movl 0xac(%rsp), %ecx
shrl $0x13, %ecx
orl %ecx, %eax
movl %eax, 0xac(%rsp)
imull $0x9e3779b1, 0xac(%rsp), %eax # imm = 0x9E3779B1
movl %eax, 0xac(%rsp)
movq 0xc8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rcx
movl 0xd8(%rsp), %eax
movq %rcx, 0x3a8(%rsp)
movl %eax, 0x3a4(%rsp)
movq 0x3a8(%rsp), %rcx
movl 0x3a4(%rsp), %eax
movq %rcx, 0x3b8(%rsp)
movl %eax, 0x3b4(%rsp)
movl $0x1, 0x3b0(%rsp)
cmpl $0x1, 0x3b0(%rsp)
jne 0x88e82
cmpl $0x1, 0x3b4(%rsp)
jne 0x88e62
movq 0x3b8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x88e75
movq 0x3b8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x3c0(%rsp)
jmp 0x88eba
cmpl $0x1, 0x3b4(%rsp)
jne 0x88e9c
movq 0x3b8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x10(%rsp)
jmp 0x88eaf
movq 0x3b8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x3c0(%rsp)
imull $0x85ebca77, 0x3c0(%rsp), %eax # imm = 0x85EBCA77
addl 0xa8(%rsp), %eax
movl %eax, 0xa8(%rsp)
movl 0xa8(%rsp), %eax
shll $0xd, %eax
movl 0xa8(%rsp), %ecx
shrl $0x13, %ecx
orl %ecx, %eax
movl %eax, 0xa8(%rsp)
imull $0x9e3779b1, 0xa8(%rsp), %eax # imm = 0x9E3779B1
movl %eax, 0xa8(%rsp)
movq 0xc8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rcx
movl 0xd8(%rsp), %eax
movq %rcx, 0x388(%rsp)
movl %eax, 0x384(%rsp)
movq 0x388(%rsp), %rcx
movl 0x384(%rsp), %eax
movq %rcx, 0x398(%rsp)
movl %eax, 0x394(%rsp)
movl $0x1, 0x390(%rsp)
cmpl $0x1, 0x390(%rsp)
jne 0x88fa1
cmpl $0x1, 0x394(%rsp)
jne 0x88f81
movq 0x398(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x88f94
movq 0x398(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x3a0(%rsp)
jmp 0x88fd9
cmpl $0x1, 0x394(%rsp)
jne 0x88fbb
movq 0x398(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x88fce
movq 0x398(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x3a0(%rsp)
imull $0x85ebca77, 0x3a0(%rsp), %eax # imm = 0x85EBCA77
addl 0xa4(%rsp), %eax
movl %eax, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
shll $0xd, %eax
movl 0xa4(%rsp), %ecx
shrl $0x13, %ecx
orl %ecx, %eax
movl %eax, 0xa4(%rsp)
imull $0x9e3779b1, 0xa4(%rsp), %eax # imm = 0x9E3779B1
movl %eax, 0xa4(%rsp)
movq 0xc8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rcx
movl 0xd8(%rsp), %eax
movq %rcx, 0x368(%rsp)
movl %eax, 0x364(%rsp)
movq 0x368(%rsp), %rcx
movl 0x364(%rsp), %eax
movq %rcx, 0x378(%rsp)
movl %eax, 0x374(%rsp)
movl $0x1, 0x370(%rsp)
cmpl $0x1, 0x370(%rsp)
jne 0x890c0
cmpl $0x1, 0x374(%rsp)
jne 0x890a0
movq 0x378(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x890b3
movq 0x378(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x380(%rsp)
jmp 0x890f5
cmpl $0x1, 0x374(%rsp)
jne 0x890d9
movq 0x378(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rsp)
jmp 0x890eb
movq 0x378(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x380(%rsp)
imull $0x85ebca77, 0x380(%rsp), %eax # imm = 0x85EBCA77
addl 0xa0(%rsp), %eax
movl %eax, 0xa0(%rsp)
movl 0xa0(%rsp), %eax
shll $0xd, %eax
movl 0xa0(%rsp), %ecx
shrl $0x13, %ecx
orl %ecx, %eax
movl %eax, 0xa0(%rsp)
imull $0x9e3779b1, 0xa0(%rsp), %eax # imm = 0x9E3779B1
movl %eax, 0xa0(%rsp)
movq 0xc8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
cmpq 0xb0(%rsp), %rax
jbe 0x88cd8
movl 0xac(%rsp), %ecx
movq 0xd0(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0xa8(%rsp), %ecx
movq 0xd0(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0xa4(%rsp), %ecx
movq 0xd0(%rsp), %rax
movl %ecx, 0x14(%rax)
movl 0xa0(%rsp), %ecx
movq 0xd0(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0xc8(%rsp), %rax
cmpq 0xc0(%rsp), %rax
jae 0x8923d
movq 0xd0(%rsp), %rdx
addq $0x20, %rdx
movq 0xc8(%rsp), %rcx
movq 0xc0(%rsp), %rax
movq 0xc8(%rsp), %rsi
subq %rsi, %rax
movq %rdx, 0x1d8(%rsp)
movq %rcx, 0x1d0(%rsp)
movq %rax, 0x1c8(%rsp)
movq 0x1d8(%rsp), %rdi
movq 0x1d0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
callq 0x4fcf0
movq 0xc0(%rsp), %rax
movq 0xc8(%rsp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq 0xd0(%rsp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, 0xf4(%rsp)
movl 0xf4(%rsp), %eax
movl %eax, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
addq $0x3e8, %rsp # imm = 0x3E8
retq
nopw %cs:(%rax,%rax)
|
/dkargin[P]miniroscpp/src/roslz4/xxhash.c
|
XXH32_intermediateDigest
|
U32 XXH32_intermediateDigest (void* state_in)
{
XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
return XXH32_intermediateDigest_endian(state_in, XXH_littleEndian);
else
return XXH32_intermediateDigest_endian(state_in, XXH_bigEndian);
}
|
subq $0xc8, %rsp
movq %rdi, 0x18(%rsp)
movsbl 0x74655(%rip), %eax # 0xfd8d8
movl %eax, 0x14(%rsp)
cmpl $0x1, 0x14(%rsp)
jne 0x89521
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
movl $0x1, 0x74(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
addq $0x20, %rax
movq 0x68(%rsp), %rcx
movslq 0x1c(%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rax
cmpq $0x10, (%rax)
jb 0x8934c
movq 0x68(%rsp), %rax
movl 0xc(%rax), %eax
shll %eax
movq 0x68(%rsp), %rcx
movl 0xc(%rcx), %ecx
shrl $0x1f, %ecx
orl %ecx, %eax
movq 0x68(%rsp), %rcx
movl 0x10(%rcx), %ecx
shll $0x7, %ecx
movq 0x68(%rsp), %rdx
movl 0x10(%rdx), %edx
shrl $0x19, %edx
orl %edx, %ecx
addl %ecx, %eax
movq 0x68(%rsp), %rcx
movl 0x14(%rcx), %ecx
shll $0xc, %ecx
movq 0x68(%rsp), %rdx
movl 0x14(%rdx), %edx
shrl $0x14, %edx
orl %edx, %ecx
addl %ecx, %eax
movq 0x68(%rsp), %rcx
movl 0x18(%rcx), %ecx
shll $0x12, %ecx
movq 0x68(%rsp), %rdx
movl 0x18(%rdx), %edx
shrl $0xe, %edx
orl %edx, %ecx
addl %ecx, %eax
movl %eax, 0x54(%rsp)
jmp 0x8935d
movq 0x68(%rsp), %rax
movl 0x8(%rax), %eax
addl $0x165667b1, %eax # imm = 0x165667B1
movl %eax, 0x54(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rax
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
ja 0x89481
movq 0x60(%rsp), %rcx
movl 0x74(%rsp), %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
movq 0x88(%rsp), %rcx
movl 0x84(%rsp), %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
movl $0x1, 0x90(%rsp)
cmpl $0x1, 0x90(%rsp)
jne 0x89409
cmpl $0x1, 0x94(%rsp)
jne 0x893e9
movq 0x98(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x10(%rsp)
jmp 0x893fc
movq 0x98(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0xa0(%rsp)
jmp 0x89441
cmpl $0x1, 0x94(%rsp)
jne 0x89423
movq 0x98(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x89436
movq 0x98(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0xa0(%rsp)
imull $0xc2b2ae3d, 0xa0(%rsp), %eax # imm = 0xC2B2AE3D
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
shll $0x11, %eax
movl 0x54(%rsp), %ecx
shrl $0xf, %ecx
orl %ecx, %eax
imull $0x27d4eb2f, %eax, %eax # imm = 0x27D4EB2F
movl %eax, 0x54(%rsp)
movq 0x60(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x60(%rsp)
jmp 0x8936d
jmp 0x89483
movq 0x60(%rsp), %rax
cmpq 0x58(%rsp), %rax
jae 0x894cf
movq 0x60(%rsp), %rax
movzbl (%rax), %eax
imull $0x165667b1, %eax, %eax # imm = 0x165667B1
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
shll $0xb, %eax
movl 0x54(%rsp), %ecx
shrl $0x15, %ecx
orl %ecx, %eax
imull $0x9e3779b1, %eax, %eax # imm = 0x9E3779B1
movl %eax, 0x54(%rsp)
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x89483
movl 0x54(%rsp), %eax
shrl $0xf, %eax
xorl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
imull $0x85ebca77, 0x54(%rsp), %eax # imm = 0x85EBCA77
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
shrl $0xd, %eax
xorl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
imull $0xc2b2ae3d, 0x54(%rsp), %eax # imm = 0xC2B2AE3D
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
shrl $0x10, %eax
xorl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x20(%rsp)
jmp 0x897ab
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
addq $0x20, %rax
movq 0x38(%rsp), %rcx
movslq 0x1c(%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
cmpq $0x10, (%rax)
jb 0x895db
movq 0x38(%rsp), %rax
movl 0xc(%rax), %eax
shll %eax
movq 0x38(%rsp), %rcx
movl 0xc(%rcx), %ecx
shrl $0x1f, %ecx
orl %ecx, %eax
movq 0x38(%rsp), %rcx
movl 0x10(%rcx), %ecx
shll $0x7, %ecx
movq 0x38(%rsp), %rdx
movl 0x10(%rdx), %edx
shrl $0x19, %edx
orl %edx, %ecx
addl %ecx, %eax
movq 0x38(%rsp), %rcx
movl 0x14(%rcx), %ecx
shll $0xc, %ecx
movq 0x38(%rsp), %rdx
movl 0x14(%rdx), %edx
shrl $0x14, %edx
orl %edx, %ecx
addl %ecx, %eax
movq 0x38(%rsp), %rcx
movl 0x18(%rcx), %ecx
shll $0x12, %ecx
movq 0x38(%rsp), %rdx
movl 0x18(%rdx), %edx
shrl $0xe, %edx
orl %edx, %ecx
addl %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0x895ec
movq 0x38(%rsp), %rax
movl 0x8(%rax), %eax
addl $0x165667b1, %eax # imm = 0x165667B1
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
ja 0x89710
movq 0x30(%rsp), %rcx
movl 0x44(%rsp), %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
movq 0xa8(%rsp), %rcx
movl 0xa4(%rsp), %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
movl $0x1, 0xb0(%rsp)
cmpl $0x1, 0xb0(%rsp)
jne 0x89698
cmpl $0x1, 0xb4(%rsp)
jne 0x89678
movq 0xb8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x8968b
movq 0xb8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0xc4(%rsp)
jmp 0x896d0
cmpl $0x1, 0xb4(%rsp)
jne 0x896b2
movq 0xb8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x896c5
movq 0xb8(%rsp), %rax
movl (%rax), %edi
callq 0x89800
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0xc4(%rsp)
imull $0xc2b2ae3d, 0xc4(%rsp), %eax # imm = 0xC2B2AE3D
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
shll $0x11, %eax
movl 0x24(%rsp), %ecx
shrl $0xf, %ecx
orl %ecx, %eax
imull $0x27d4eb2f, %eax, %eax # imm = 0x27D4EB2F
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x30(%rsp)
jmp 0x895fc
jmp 0x89712
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x8975e
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
imull $0x165667b1, %eax, %eax # imm = 0x165667B1
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
shll $0xb, %eax
movl 0x24(%rsp), %ecx
shrl $0x15, %ecx
orl %ecx, %eax
imull $0x9e3779b1, %eax, %eax # imm = 0x9E3779B1
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x89712
movl 0x24(%rsp), %eax
shrl $0xf, %eax
xorl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
imull $0x85ebca77, 0x24(%rsp), %eax # imm = 0x85EBCA77
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
shrl $0xd, %eax
xorl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
imull $0xc2b2ae3d, 0x24(%rsp), %eax # imm = 0xC2B2AE3D
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
shrl $0x10, %eax
xorl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
addq $0xc8, %rsp
retq
nopw (%rax,%rax)
|
/dkargin[P]miniroscpp/src/roslz4/xxhash.c
|
prepare_new_block
|
static
void prepare_new_block ( EState* s )
{
Int32 i;
s->nblock = 0;
s->numZ = 0;
s->state_out_pos = 0;
BZ_INITIALISE_CRC ( s->blockCRC );
for (i = 0; i < 256; i++) s->inUse[i] = False;
s->blockNo++;
}
|
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x6c(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x74(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x78(%rax)
movq -0x8(%rsp), %rax
movl $0xffffffff, 0x288(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rsp)
cmpl $0x100, -0xc(%rsp) # imm = 0x100
jge 0x89f29
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movb $0x0, 0x80(%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x89f00
movq -0x8(%rsp), %rax
movl 0x294(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x294(%rax)
retq
nop
|
/dkargin[P]miniroscpp/external/bzip2/bzlib.c
|
handle_compress
|
static
Bool handle_compress ( bz_stream* strm )
{
Bool progress_in = False;
Bool progress_out = False;
EState* s = strm->state;
while (True) {
if (s->state == BZ_S_OUTPUT) {
progress_out |= copy_output_until_stop ( s );
if (s->state_out_pos < s->numZ) break;
if (s->mode == BZ_M_FINISHING &&
s->avail_in_expect == 0 &&
isempty_RL(s)) break;
prepare_new_block ( s );
s->state = BZ_S_INPUT;
if (s->mode == BZ_M_FLUSHING &&
s->avail_in_expect == 0 &&
isempty_RL(s)) break;
}
if (s->state == BZ_S_INPUT) {
progress_in |= copy_input_until_stop ( s );
if (s->mode != BZ_M_RUNNING && s->avail_in_expect == 0) {
flush_RL ( s );
BZ2_compressBlock ( s, (Bool)(s->mode == BZ_M_FINISHING) );
s->state = BZ_S_OUTPUT;
}
else
if (s->nblock >= s->nblockMAX) {
BZ2_compressBlock ( s, False );
s->state = BZ_S_OUTPUT;
}
else
if (s->strm->avail_in == 0) {
break;
}
}
}
return progress_in || progress_out;
}
|
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movb $0x0, 0x1e(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x8a281
movq 0x10(%rsp), %rdi
callq 0x8dee0
movzbl %al, %ecx
movzbl 0x1e(%rsp), %eax
orl %ecx, %eax
movb %al, 0x1e(%rsp)
movq 0x10(%rsp), %rax
movl 0x78(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x74(%rcx), %eax
jge 0x8a20f
jmp 0x8a33b
movq 0x10(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x8a23c
movq 0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x8a23c
movq 0x10(%rsp), %rdi
callq 0x8a370
movzbl %al, %eax
cmpl $0x0, %eax
je 0x8a23c
jmp 0x8a33b
movq 0x10(%rsp), %rdi
callq 0x89ec0
movq 0x10(%rsp), %rax
movl $0x2, 0xc(%rax)
movq 0x10(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x8a27f
movq 0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x8a27f
movq 0x10(%rsp), %rdi
callq 0x8a370
movzbl %al, %eax
cmpl $0x0, %eax
je 0x8a27f
jmp 0x8a33b
jmp 0x8a281
movq 0x10(%rsp), %rax
cmpl $0x2, 0xc(%rax)
jne 0x8a336
movq 0x10(%rsp), %rdi
callq 0x8dfb0
movzbl %al, %ecx
movzbl 0x1f(%rsp), %eax
orl %ecx, %eax
movb %al, 0x1f(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x2, 0x8(%rax)
je 0x8a2f4
movq 0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x8a2f4
movq 0x10(%rsp), %rdi
callq 0x8e360
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
cmpl $0x4, 0x8(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movzbl %al, %esi
callq 0x4d670
movq 0x10(%rsp), %rax
movl $0x1, 0xc(%rax)
jmp 0x8a334
movq 0x10(%rsp), %rax
movl 0x6c(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x70(%rcx), %eax
jl 0x8a320
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x4d670
movq 0x10(%rsp), %rax
movl $0x1, 0xc(%rax)
jmp 0x8a332
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0x8a330
jmp 0x8a33b
jmp 0x8a332
jmp 0x8a334
jmp 0x8a336
jmp 0x8a1d1
movzbl 0x1f(%rsp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jne 0x8a35a
movzbl 0x1e(%rsp), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
/dkargin[P]miniroscpp/external/bzip2/bzlib.c
|
BZ2_bzDecompress
|
int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
{
Bool corrupt;
DState* s;
if (strm == NULL) return BZ_PARAM_ERROR;
s = strm->state;
if (s == NULL) return BZ_PARAM_ERROR;
if (s->strm != strm) return BZ_PARAM_ERROR;
while (True) {
if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR;
if (s->state == BZ_X_OUTPUT) {
if (s->smallDecompress)
corrupt = unRLE_obuf_to_output_SMALL ( s ); else
corrupt = unRLE_obuf_to_output_FAST ( s );
if (corrupt) return BZ_DATA_ERROR;
if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
BZ_FINALISE_CRC ( s->calculatedBlockCRC );
if (s->verbosity >= 3)
VPrintf2 ( " {0x%08x, 0x%08x}", s->storedBlockCRC,
s->calculatedBlockCRC );
if (s->verbosity >= 2) VPrintf0 ( "]" );
if (s->calculatedBlockCRC != s->storedBlockCRC)
return BZ_DATA_ERROR;
s->calculatedCombinedCRC
= (s->calculatedCombinedCRC << 1) |
(s->calculatedCombinedCRC >> 31);
s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
s->state = BZ_X_BLKHDR_1;
} else {
return BZ_OK;
}
}
if (s->state >= BZ_X_MAGIC_1) {
Int32 r = BZ2_decompress ( s );
if (r == BZ_STREAM_END) {
if (s->verbosity >= 3)
VPrintf2 ( "\n combined CRCs: stored = 0x%08x, computed = 0x%08x",
s->storedCombinedCRC, s->calculatedCombinedCRC );
if (s->calculatedCombinedCRC != s->storedCombinedCRC)
return BZ_DATA_ERROR;
return r;
}
if (s->state != BZ_X_OUTPUT) return r;
}
}
AssertH ( 0, 6001 );
return 0; /*NOTREACHED*/
}
|
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x8a6fe
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0x8a973
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x8a721
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0x8a973
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq 0x18(%rsp), %rax
je 0x8a73d
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0x8a973
jmp 0x8a73f
movq 0x8(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x8a757
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x8a973
movq 0x8(%rsp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x8a8ce
movq 0x8(%rsp), %rax
cmpb $0x0, 0x2c(%rax)
je 0x8a781
movq 0x8(%rsp), %rdi
callq 0x8a980
movb %al, 0x17(%rsp)
jmp 0x8a78f
movq 0x8(%rsp), %rdi
callq 0x8b7a0
movb %al, 0x17(%rsp)
cmpb $0x0, 0x17(%rsp)
je 0x8a7a3
movl $0xfffffffc, 0x24(%rsp) # imm = 0xFFFFFFFC
jmp 0x8a973
movq 0x8(%rsp), %rax
movl 0x444(%rax), %eax
movq 0x8(%rsp), %rcx
movl 0xfa50(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8a8bf
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x8a8bf
movq 0x8(%rsp), %rax
movl 0xc70(%rax), %ecx
xorl $-0x1, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc70(%rax)
movq 0x8(%rsp), %rax
cmpl $0x3, 0x34(%rax)
jl 0x8a825
movq 0x8a76a(%rip), %rax # 0x114f68
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movl 0xc68(%rax), %edx
movq 0x8(%rsp), %rax
movl 0xc70(%rax), %ecx
leaq 0x736c1(%rip), %rsi # 0xfdedf
movb $0x0, %al
callq 0x52290
movq 0x8(%rsp), %rax
cmpl $0x2, 0x34(%rax)
jl 0x8a848
movq 0x8a731(%rip), %rax # 0x114f68
movq (%rax), %rdi
leaq 0x736b0(%rip), %rsi # 0xfdef1
movb $0x0, %al
callq 0x52290
movq 0x8(%rsp), %rax
movl 0xc70(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc68(%rcx), %eax
je 0x8a86d
movl $0xfffffffc, 0x24(%rsp) # imm = 0xFFFFFFFC
jmp 0x8a973
movq 0x8(%rsp), %rax
movl 0xc74(%rax), %ecx
shll %ecx
movq 0x8(%rsp), %rax
movl 0xc74(%rax), %eax
shrl $0x1f, %eax
orl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc74(%rax)
movq 0x8(%rsp), %rax
movl 0xc70(%rax), %ecx
movq 0x8(%rsp), %rax
xorl 0xc74(%rax), %ecx
movl %ecx, 0xc74(%rax)
movq 0x8(%rsp), %rax
movl $0xe, 0x8(%rax)
jmp 0x8a8cc
movl $0x0, 0x24(%rsp)
jmp 0x8a973
jmp 0x8a8ce
movq 0x8(%rsp), %rax
cmpl $0xa, 0x8(%rax)
jl 0x8a96e
movq 0x8(%rsp), %rdi
callq 0x52f90
movl %eax, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jne 0x8a957
movq 0x8(%rsp), %rax
cmpl $0x3, 0x34(%rax)
jl 0x8a92b
movq 0x8a664(%rip), %rax # 0x114f68
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movl 0xc6c(%rax), %edx
movq 0x8(%rsp), %rax
movl 0xc74(%rax), %ecx
leaq 0x735cf(%rip), %rsi # 0xfdef3
movb $0x0, %al
callq 0x52290
movq 0x8(%rsp), %rax
movl 0xc74(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc6c(%rcx), %eax
je 0x8a94d
movl $0xfffffffc, 0x24(%rsp) # imm = 0xFFFFFFFC
jmp 0x8a973
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x8a973
movq 0x8(%rsp), %rax
cmpl $0x2, 0x8(%rax)
je 0x8a96c
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x8a973
jmp 0x8a96e
jmp 0x8a73f
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
|
/dkargin[P]miniroscpp/external/bzip2/bzlib.c
|
BZ2_hbMakeCodeLengths
|
void BZ2_hbMakeCodeLengths ( UChar *len,
Int32 *freq,
Int32 alphaSize,
Int32 maxLen )
{
/*--
Nodes and heap entries run from 1. Entry 0
for both the heap and nodes is a sentinel.
--*/
Int32 nNodes, nHeap, n1, n2, i, j, k;
Bool tooLong;
Int32 heap [ BZ_MAX_ALPHA_SIZE + 2 ];
Int32 weight [ BZ_MAX_ALPHA_SIZE * 2 ];
Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ];
for (i = 0; i < alphaSize; i++)
weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
while (True) {
nNodes = alphaSize;
nHeap = 0;
heap[0] = 0;
weight[0] = 0;
parent[0] = -2;
for (i = 1; i <= alphaSize; i++) {
parent[i] = -1;
nHeap++;
heap[nHeap] = i;
UPHEAP(nHeap);
}
AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 );
while (nHeap > 1) {
n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
nNodes++;
parent[n1] = parent[n2] = nNodes;
weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]);
parent[nNodes] = -1;
nHeap++;
heap[nHeap] = nNodes;
UPHEAP(nHeap);
}
AssertH( nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002 );
tooLong = False;
for (i = 1; i <= alphaSize; i++) {
j = 0;
k = i;
while (parent[k] >= 0) { k = parent[k]; j++; }
len[i-1] = j;
if (j > maxLen) tooLong = True;
}
if (! tooLong) break;
/* 17 Oct 04: keep-going condition for the following loop used
to be 'i < alphaSize', which missed the last element,
theoretically leading to the possibility of the compressor
looping. However, this count-scaling step is only needed if
one of the generated Huffman code words is longer than
maxLen, which up to and including version 1.0.2 was 20 bits,
which is extremely unlikely. In version 1.0.3 maxLen was
changed to 17 bits, which has minimal effect on compression
ratio, but does mean this scaling step is used from time to
time, enough to verify that it works.
This means that bzip2-1.0.3 and later will only produce
Huffman codes with a maximum length of 17 bits. However, in
order to preserve backwards compatibility with bitstreams
produced by versions pre-1.0.3, the decompressor must still
handle lengths of up to 20. */
for (i = 1; i <= alphaSize; i++) {
j = weight[i] >> 8;
j = 1 + (j / 2);
weight[i] = j << 8;
}
}
}
|
subq $0x14a8, %rsp # imm = 0x14A8
movq %rdi, 0x14a0(%rsp)
movq %rsi, 0x1498(%rsp)
movl %edx, 0x1494(%rsp)
movl %ecx, 0x1490(%rsp)
movl $0x0, 0x147c(%rsp)
movl 0x147c(%rsp), %eax
cmpl 0x1494(%rsp), %eax
jge 0x9d415
movq 0x1498(%rsp), %rax
movslq 0x147c(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x9d3d1
movl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x9d3e8
movq 0x1498(%rsp), %rax
movslq 0x147c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %ecx
shll $0x8, %ecx
movl 0x147c(%rsp), %eax
addl $0x1, %eax
cltq
movl %ecx, 0x850(%rsp,%rax,4)
movl 0x147c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x147c(%rsp)
jmp 0x9d3a0
jmp 0x9d417
movl 0x1494(%rsp), %eax
movl %eax, 0x148c(%rsp)
movl $0x0, 0x1488(%rsp)
movl $0x0, 0x1060(%rsp)
movl $0x0, 0x850(%rsp)
movl $0xfffffffe, 0x40(%rsp) # imm = 0xFFFFFFFE
movl $0x1, 0x147c(%rsp)
movl 0x147c(%rsp), %eax
cmpl 0x1494(%rsp), %eax
jg 0x9d532
movslq 0x147c(%rsp), %rax
movl $0xffffffff, 0x40(%rsp,%rax,4) # imm = 0xFFFFFFFF
movl 0x1488(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1488(%rsp)
movl 0x147c(%rsp), %ecx
movslq 0x1488(%rsp), %rax
movl %ecx, 0x1060(%rsp,%rax,4)
movl 0x1488(%rsp), %eax
movl %eax, 0x3c(%rsp)
movslq 0x3c(%rsp), %rax
movl 0x1060(%rsp,%rax,4), %eax
movl %eax, 0x38(%rsp)
movslq 0x38(%rsp), %rax
movl 0x850(%rsp,%rax,4), %eax
movl 0x3c(%rsp), %ecx
sarl %ecx
movslq %ecx, %rcx
movslq 0x1060(%rsp,%rcx,4), %rcx
cmpl 0x850(%rsp,%rcx,4), %eax
jge 0x9d50c
movl 0x3c(%rsp), %eax
sarl %eax
cltq
movl 0x1060(%rsp,%rax,4), %ecx
movslq 0x3c(%rsp), %rax
movl %ecx, 0x1060(%rsp,%rax,4)
movl 0x3c(%rsp), %eax
sarl %eax
movl %eax, 0x3c(%rsp)
jmp 0x9d4bf
movl 0x38(%rsp), %ecx
movslq 0x3c(%rsp), %rax
movl %ecx, 0x1060(%rsp,%rax,4)
movl 0x147c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x147c(%rsp)
jmp 0x9d459
cmpl $0x104, 0x1488(%rsp) # imm = 0x104
jl 0x9d549
movl $0x7d1, %edi # imm = 0x7D1
callq 0x4fbd0
jmp 0x9d54b
cmpl $0x1, 0x1488(%rsp)
jle 0x9d8f7
movl 0x1064(%rsp), %eax
movl %eax, 0x1484(%rsp)
movslq 0x1488(%rsp), %rax
movl 0x1060(%rsp,%rax,4), %eax
movl %eax, 0x1064(%rsp)
movl 0x1488(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x1488(%rsp)
movl $0x1, 0x34(%rsp)
movslq 0x34(%rsp), %rax
movl 0x1060(%rsp,%rax,4), %eax
movl %eax, 0x2c(%rsp)
movl 0x34(%rsp), %eax
shll %eax
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x1488(%rsp), %eax
jle 0x9d5c2
jmp 0x9d651
movl 0x30(%rsp), %eax
cmpl 0x1488(%rsp), %eax
jge 0x9d608
movl 0x30(%rsp), %eax
addl $0x1, %eax
cltq
movslq 0x1060(%rsp,%rax,4), %rax
movl 0x850(%rsp,%rax,4), %eax
movslq 0x30(%rsp), %rcx
movslq 0x1060(%rsp,%rcx,4), %rcx
cmpl 0x850(%rsp,%rcx,4), %eax
jge 0x9d608
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
movslq 0x2c(%rsp), %rax
movl 0x850(%rsp,%rax,4), %eax
movslq 0x30(%rsp), %rcx
movslq 0x1060(%rsp,%rcx,4), %rcx
cmpl 0x850(%rsp,%rcx,4), %eax
jge 0x9d62c
jmp 0x9d651
movslq 0x30(%rsp), %rax
movl 0x1060(%rsp,%rax,4), %ecx
movslq 0x34(%rsp), %rax
movl %ecx, 0x1060(%rsp,%rax,4)
movl 0x30(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x9d5a6
movl 0x2c(%rsp), %ecx
movslq 0x34(%rsp), %rax
movl %ecx, 0x1060(%rsp,%rax,4)
movl 0x1064(%rsp), %eax
movl %eax, 0x1480(%rsp)
movslq 0x1488(%rsp), %rax
movl 0x1060(%rsp,%rax,4), %eax
movl %eax, 0x1064(%rsp)
movl 0x1488(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x1488(%rsp)
movl $0x1, 0x28(%rsp)
movslq 0x28(%rsp), %rax
movl 0x1060(%rsp,%rax,4), %eax
movl %eax, 0x20(%rsp)
movl 0x28(%rsp), %eax
shll %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x1488(%rsp), %eax
jle 0x9d6ca
jmp 0x9d759
movl 0x24(%rsp), %eax
cmpl 0x1488(%rsp), %eax
jge 0x9d710
movl 0x24(%rsp), %eax
addl $0x1, %eax
cltq
movslq 0x1060(%rsp,%rax,4), %rax
movl 0x850(%rsp,%rax,4), %eax
movslq 0x24(%rsp), %rcx
movslq 0x1060(%rsp,%rcx,4), %rcx
cmpl 0x850(%rsp,%rcx,4), %eax
jge 0x9d710
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movslq 0x20(%rsp), %rax
movl 0x850(%rsp,%rax,4), %eax
movslq 0x24(%rsp), %rcx
movslq 0x1060(%rsp,%rcx,4), %rcx
cmpl 0x850(%rsp,%rcx,4), %eax
jge 0x9d734
jmp 0x9d759
movslq 0x24(%rsp), %rax
movl 0x1060(%rsp,%rax,4), %ecx
movslq 0x28(%rsp), %rax
movl %ecx, 0x1060(%rsp,%rax,4)
movl 0x24(%rsp), %eax
movl %eax, 0x28(%rsp)
jmp 0x9d6ae
movl 0x20(%rsp), %ecx
movslq 0x28(%rsp), %rax
movl %ecx, 0x1060(%rsp,%rax,4)
movl 0x148c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x148c(%rsp)
movl 0x148c(%rsp), %ecx
movslq 0x1480(%rsp), %rax
movl %ecx, 0x40(%rsp,%rax,4)
movslq 0x1484(%rsp), %rax
movl %ecx, 0x40(%rsp,%rax,4)
movslq 0x1484(%rsp), %rax
movl 0x850(%rsp,%rax,4), %eax
andl $0xffffff00, %eax # imm = 0xFFFFFF00
movslq 0x1480(%rsp), %rcx
movl 0x850(%rsp,%rcx,4), %ecx
andl $0xffffff00, %ecx # imm = 0xFFFFFF00
addl %ecx, %eax
movl %eax, 0x10(%rsp)
movslq 0x1484(%rsp), %rax
movl 0x850(%rsp,%rax,4), %eax
andl $0xff, %eax
movslq 0x1480(%rsp), %rcx
movl 0x850(%rsp,%rcx,4), %ecx
andl $0xff, %ecx
cmpl %ecx, %eax
jle 0x9d80f
movslq 0x1484(%rsp), %rax
movl 0x850(%rsp,%rax,4), %eax
andl $0xff, %eax
movl %eax, 0xc(%rsp)
jmp 0x9d827
movslq 0x1480(%rsp), %rax
movl 0x850(%rsp,%rax,4), %eax
andl $0xff, %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %eax
addl $0x1, %eax
orl %eax, %ecx
movslq 0x148c(%rsp), %rax
movl %ecx, 0x850(%rsp,%rax,4)
movslq 0x148c(%rsp), %rax
movl $0xffffffff, 0x40(%rsp,%rax,4) # imm = 0xFFFFFFFF
movl 0x1488(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1488(%rsp)
movl 0x148c(%rsp), %ecx
movslq 0x1488(%rsp), %rax
movl %ecx, 0x1060(%rsp,%rax,4)
movl 0x1488(%rsp), %eax
movl %eax, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movl 0x1060(%rsp,%rax,4), %eax
movl %eax, 0x18(%rsp)
movslq 0x18(%rsp), %rax
movl 0x850(%rsp,%rax,4), %eax
movl 0x1c(%rsp), %ecx
sarl %ecx
movslq %ecx, %rcx
movslq 0x1060(%rsp,%rcx,4), %rcx
cmpl 0x850(%rsp,%rcx,4), %eax
jge 0x9d8e2
movl 0x1c(%rsp), %eax
sarl %eax
cltq
movl 0x1060(%rsp,%rax,4), %ecx
movslq 0x1c(%rsp), %rax
movl %ecx, 0x1060(%rsp,%rax,4)
movl 0x1c(%rsp), %eax
sarl %eax
movl %eax, 0x1c(%rsp)
jmp 0x9d895
movl 0x18(%rsp), %ecx
movslq 0x1c(%rsp), %rax
movl %ecx, 0x1060(%rsp,%rax,4)
jmp 0x9d54b
cmpl $0x204, 0x148c(%rsp) # imm = 0x204
jl 0x9d90e
movl $0x7d2, %edi # imm = 0x7D2
callq 0x4fbd0
movb $0x0, 0x1473(%rsp)
movl $0x1, 0x147c(%rsp)
movl 0x147c(%rsp), %eax
cmpl 0x1494(%rsp), %eax
jg 0x9d9d4
movl $0x0, 0x1478(%rsp)
movl 0x147c(%rsp), %eax
movl %eax, 0x1474(%rsp)
movslq 0x1474(%rsp), %rax
cmpl $0x0, 0x40(%rsp,%rax,4)
jl 0x9d983
movslq 0x1474(%rsp), %rax
movl 0x40(%rsp,%rax,4), %eax
movl %eax, 0x1474(%rsp)
movl 0x1478(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1478(%rsp)
jmp 0x9d94e
movl 0x1478(%rsp), %eax
movb %al, %dl
movq 0x14a0(%rsp), %rax
movl 0x147c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x1478(%rsp), %eax
cmpl 0x1490(%rsp), %eax
jle 0x9d9bc
movb $0x1, 0x1473(%rsp)
jmp 0x9d9be
movl 0x147c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x147c(%rsp)
jmp 0x9d921
cmpb $0x0, 0x1473(%rsp)
jne 0x9d9e0
jmp 0x9da5e
movl $0x1, 0x147c(%rsp)
movl 0x147c(%rsp), %eax
cmpl 0x1494(%rsp), %eax
jg 0x9da59
movslq 0x147c(%rsp), %rax
movl 0x850(%rsp,%rax,4), %eax
sarl $0x8, %eax
movl %eax, 0x1478(%rsp)
movl 0x1478(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, 0x1478(%rsp)
movl 0x1478(%rsp), %ecx
shll $0x8, %ecx
movslq 0x147c(%rsp), %rax
movl %ecx, 0x850(%rsp,%rax,4)
movl 0x147c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x147c(%rsp)
jmp 0x9d9eb
jmp 0x9d417
addq $0x14a8, %rsp # imm = 0x14A8
retq
nopw %cs:(%rax,%rax)
|
/dkargin[P]miniroscpp/external/bzip2/huffman.c
|
curlx_sltoui
|
unsigned int curlx_sltoui(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < CURL_SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT);
#endif
return (unsigned int)(slnum & (long) CURL_MASK_UINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
}
|
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x29ea
jmp 0x29ec
jmp 0x29ee
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x8(%rbp), %rax
popq %rbp
retq
nop
|
/xyzz[P]vita-curl/lib/warnless.c
|
curlx_uitosi
|
int curlx_uitosi(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_SINT);
return (int) (uinum & (unsigned int) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
}
|
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
jmp 0x2ac9
movl -0x4(%rbp), %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/xyzz[P]vita-curl/lib/warnless.c
|
LIF::update(double)
|
Event* LIF::update(double n_dt) {
dt = n_dt;
if(t_rest > 0.0) {
rest();
}
else if(u > param->u_thresh) {
fire();
return new SpikeEvent();
}
else {
integrate();
}
return new NoEvent();
}
|
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, 0x40(%rdi)
movsd 0x20(%rdi), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x7f60
movq 0x48(%rdi), %rax
movsd (%rax), %xmm2
movsd %xmm2, 0x28(%rdi)
subsd %xmm0, %xmm1
jmp 0x7fe9
movsd 0x28(%rdi), %xmm1
movq 0x48(%rdi), %rax
ucomisd 0x8(%rax), %xmm1
jbe 0x7fc5
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rdi)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x20(%rdi)
movl $0x28, %edi
callq 0x6230
movq %rax, %rbx
leaq 0x8ad9(%rip), %rax # 0x10a70
movq %rax, (%rbx)
movl $0x1, 0x18(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x20(%rbx)
movl $0x0, 0x8(%rbx)
callq 0xa6bc
movq %rax, %rdi
callq 0xa6ee
jmp 0x8019
movsd 0x18(%rax), %xmm2
mulsd 0x38(%rdi), %xmm2
subsd %xmm1, %xmm2
divsd 0x20(%rax), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x28(%rdi)
xorpd %xmm1, %xmm1
movsd %xmm1, 0x20(%rdi)
movl $0x18, %edi
callq 0x6230
movq %rax, %rbx
leaq 0x8abe(%rip), %rax # 0x10ac0
movq %rax, (%rbx)
movl $0x2, 0x8(%rbx)
callq 0xa6bc
movq %rax, %rdi
callq 0xa6ee
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x28, %esi
jmp 0x803b
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x6240
movq %r14, %rdi
callq 0x6330
nop
|
/haukri[P]MasterProject/Network/Neuron/LIF.cpp
|
CurrentGenerator::CurrentGenerator(CurrentGenerator_param*)
|
CurrentGenerator::CurrentGenerator(CurrentGenerator_param* param) : param(param) {
clock = Clock::getInstance();
initialize();
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
generator = std::default_random_engine(seed);
distribution = std::normal_distribution<double>(param->noiseMean, param->noiseStd);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x86fe(%rip), %rax # 0x10b50
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
movq $0x1, 0x30(%rdi)
xorps %xmm0, %xmm0
movhps 0x3bad(%rip), %xmm0 # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, 0x38(%rdi)
xorl %r15d, %r15d
movq %r15, 0x48(%rdi)
movb %r15b, 0x50(%rdi)
callq 0xa6bc
movq %rax, 0x58(%rbx)
callq 0xa718
movq %rax, 0x18(%rbx)
callq 0x6040
movl %eax, %ecx
leaq (%rcx,%rcx,2), %rcx
shrq $0x20, %rcx
movl %eax, %edx
subl %ecx, %edx
shrl %edx
addl %ecx, %edx
shrl $0x1e, %edx
movl %edx, %ecx
shll $0x1f, %ecx
orl %edx, %ecx
leal (%rax,%rcx), %edx
cmpl $0x1, %edx
adcl %eax, %ecx
movq %rcx, 0x30(%rbx)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x38(%rbx)
movq %r15, 0x48(%rbx)
movb %r15b, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
/haukri[P]MasterProject/Network/Neuron/CurrentGenerator.cpp
|
SignalGenerator::update(double)
|
Event* SignalGenerator::update(double n_dt) {
double signalValue = 0;
if(param->f1 > 0)
signalValue += sin(2*3.1415926535897*param->f1*clock->getCurrentTime());
if(param->f2 > 0)
signalValue += sin(2*3.1415926535897*param->f2*clock->getCurrentTime());
if(param->f3 > 0)
signalValue += sin(2*3.1415926535897*param->f3*clock->getCurrentTime());
if(param->f4 > 0)
signalValue += sin(2*3.1415926535897*param->f4*clock->getCurrentTime());
if(param->f5 > 0)
signalValue += sin(2*3.1415926535897*param->f5*clock->getCurrentTime());
if(param->f6 > 0)
signalValue += sin(2*3.1415926535897*param->f6*clock->getCurrentTime());
if(param->f7 > 0)
signalValue += sin(2*3.1415926535897*param->f7*clock->getCurrentTime());
signalValue *= param->scale;
signalValue += param->offset;
if(param->noiseStd > 0) {
signalValue += distribution(generator);
}
logger->logValue(999, 0, EventType::Value, signalValue);
return new ValueEvent(signalValue);
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movsd (%rax), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
xorpd %xmm1, %xmm1
jbe 0x8a20
mulsd 0x389a(%rip), %xmm2 # 0xc290
movsd %xmm2, 0x8(%rsp)
movq 0x58(%rbx), %rdi
callq 0xa6ee
mulsd 0x8(%rsp), %xmm0
callq 0x6050
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
movq 0x28(%rbx), %rax
movsd 0x8(%rax), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x8a61
mulsd 0x385d(%rip), %xmm2 # 0xc290
movsd %xmm2, 0x10(%rsp)
movq 0x58(%rbx), %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xa6ee
mulsd 0x10(%rsp), %xmm0
callq 0x6050
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x28(%rbx), %rax
movsd 0x10(%rax), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x8aaa
mulsd 0x3818(%rip), %xmm2 # 0xc290
movsd %xmm2, 0x10(%rsp)
movq 0x58(%rbx), %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xa6ee
mulsd 0x10(%rsp), %xmm0
callq 0x6050
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
movq 0x28(%rbx), %rax
movsd 0x18(%rax), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x8aeb
mulsd 0x37d3(%rip), %xmm2 # 0xc290
movsd %xmm2, 0x10(%rsp)
movq 0x58(%rbx), %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xa6ee
mulsd 0x10(%rsp), %xmm0
callq 0x6050
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x28(%rbx), %rax
movsd 0x20(%rax), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x8b34
mulsd 0x378e(%rip), %xmm2 # 0xc290
movsd %xmm2, 0x10(%rsp)
movq 0x58(%rbx), %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xa6ee
mulsd 0x10(%rsp), %xmm0
callq 0x6050
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
movq 0x28(%rbx), %rax
movsd 0x28(%rax), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x8b75
mulsd 0x3749(%rip), %xmm2 # 0xc290
movsd %xmm2, 0x10(%rsp)
movq 0x58(%rbx), %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xa6ee
mulsd 0x10(%rsp), %xmm0
callq 0x6050
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x28(%rbx), %rax
movsd 0x30(%rax), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x8bbe
mulsd 0x3704(%rip), %xmm0 # 0xc290
movsd %xmm0, 0x10(%rsp)
movq 0x58(%rbx), %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xa6ee
mulsd 0x10(%rsp), %xmm0
callq 0x6050
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x28(%rbx), %rax
mulsd 0x38(%rax), %xmm1
addsd 0x40(%rax), %xmm1
movsd 0x50(%rax), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x8bf3
leaq 0x38(%rbx), %rdi
leaq 0x30(%rbx), %rsi
movq %rdi, %rdx
movsd %xmm1, 0x8(%rsp)
callq 0x8674
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x18(%rbx), %rdi
movl $0x3e7, %esi # imm = 0x3E7
xorl %edx, %edx
movl $0x3, %ecx
movsd %xmm1, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0xa870
movl $0x20, %edi
callq 0x6230
movq %rax, %rbx
leaq 0x800a(%rip), %rax # 0x10c30
movq %rax, (%rbx)
movq $0x0, 0x18(%rbx)
movl $0x3, 0x8(%rbx)
callq 0xa6bc
movq %rax, %rdi
callq 0xa6ee
movsd %xmm0, 0x10(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x6240
movq %r14, %rdi
callq 0x6330
|
/haukri[P]MasterProject/Network/Neuron/SignalGenerator.cpp
|
testing::internal::SuiteApiResolver<adt_set_test>::GetSetUpCaseOrSuite(char const*, int)
|
static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearDownSuiteFuncType test_suite_fp =
GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);
GTEST_CHECK_(!test_case_fp || !test_suite_fp)
<< "Test can not provide both SetUpTestSuite and SetUpTestCase, please "
"make sure there is only one present at "
<< filename << ":" << line_num;
return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
#else
(void)(filename);
(void)(line_num);
return &T::SetUpTestSuite;
#endif
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xb718
testb %al, %al
jne 0xa7ad
leaq 0x2dc60(%rip), %rdx # 0x3835d
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x211, %ecx # imm = 0x211
callq 0x2a45a
movq 0x428d0(%rip), %rdi # 0x4cfe8
leaq 0x2dce1(%rip), %rsi # 0x38400
movl $0x32, %edx
callq 0x8620
movq 0x428b8(%rip), %r15 # 0x4cfe8
leaq 0x2dcfc(%rip), %rsi # 0x38433
movl $0x6a, %edx
movq %r15, %rdi
callq 0x8620
testq %r14, %r14
je 0xa765
movq %r14, %rdi
callq 0x8230
movq 0x42890(%rip), %rdi # 0x4cfe8
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
jmp 0xa77d
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x89c0
movq 0x42864(%rip), %rdi # 0x4cfe8
leaq 0x30214(%rip), %rsi # 0x3a99f
movl $0x1, %edx
callq 0x8620
movq 0x4284c(%rip), %rdi # 0x4cfe8
movl %ebx, %esi
callq 0x89f0
leaq 0xc(%rsp), %rdi
callq 0x2a5a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x2a5a0
movq %rbx, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-internal.h
|
testing::AssertionResult testing::internal::CmpHelperEQFailure<int, int>(char const*, char const*, int const&, int const&)
|
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs),
false);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0xaaf2
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xaaf2
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x10a2e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaa9a
callq 0x84a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaaad
callq 0x84a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaad7
callq 0x84a0
jmp 0xaad7
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaaea
callq 0x84a0
movq %rbx, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
|
testing::AssertionResult& testing::AssertionResult::operator<<<char [12]>(char const (&) [12])
|
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb0d6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xaeae
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xaece
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
|
testing::AssertionResult& testing::AssertionResult::operator<<<char [3]>(char const (&) [3])
|
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb0d6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xafbc
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xafdc
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
|
testing::AssertionResult& testing::AssertionResult::operator<<<char [5]>(char const (&) [5])
|
AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb0d6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb0ae
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb0ce
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
|
void testing::internal::PointerPrinter::PrintValue<int>(int*, std::ostream*)
|
static void PrintValue(T* p, ::std::ostream* os) {
if (p == nullptr) {
*os << "NULL";
} else {
// T is not a function type. We just call << to print p,
// relying on ADL to pick up user-defined << for their pointer
// types, if any.
*os << p;
}
}
|
movq %rsi, %rcx
testq %rdi, %rdi
je 0xb22e
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0x83e0
leaq 0x2d303(%rip), %rsi # 0x38538
movl $0x4, %edx
movq %rcx, %rdi
jmp 0x8620
nop
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-printers.h
|
testing::internal::BoolFromGTestEnv(char const*, bool)
|
bool BoolFromGTestEnv(const char* flag, bool default_value) {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const string_value = posix::GetEnv(env_var.c_str());
return string_value == nullptr ? default_value
: strcmp(string_value, "0") != 0;
#endif // defined(GTEST_GET_BOOL_FROM_ENV_)
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2a943
movq (%r14), %r14
movq %r14, %rdi
callq 0x86e0
testq %rax, %rax
je 0xb284
leaq 0x30a5c(%rip), %rsi # 0x3bcd3
movq %rax, %rdi
callq 0x8810
testl %eax, %eax
setne %bl
leaq -0x20(%rbp), %rax
cmpq %rax, %r14
je 0xb29c
movq -0x20(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x8520
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
|
testing::internal::StringFromGTestEnv(char const*, char const*)
|
const char* StringFromGTestEnv(const char* flag, const char* default_value) {
#if defined(GTEST_GET_STRING_FROM_ENV_)
return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const value = posix::GetEnv(env_var.c_str());
return value == nullptr ? default_value : value;
#endif // defined(GTEST_GET_STRING_FROM_ENV_)
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x2a943
movq (%r14), %r15
movq %r15, %rdi
callq 0x86e0
movq %rax, %r14
leaq -0x28(%rbp), %rax
cmpq %rax, %r15
je 0xb2ec
movq -0x28(%rbp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x8520
testq %r14, %r14
cmovneq %r14, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
|
testing::internal::OutputFlagAlsoCheckEnvVar[abi:cxx11]()
|
std::string OutputFlagAlsoCheckEnvVar(){
std::string default_value_for_output_flag = "";
const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
if (nullptr != xml_output_file_env) {
default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
}
return default_value_for_output_flag;
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x2f190(%rip), %rdx # 0x3a4b1
movq %rdx, %rsi
callq 0x3470e
leaq 0x2ff38(%rip), %rdi # 0x3b268
callq 0x86e0
testq %rax, %rax
je 0xb3e7
movq %rax, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x2ff27(%rip), %rsi # 0x3b278
leaq 0x2ff24(%rip), %rdx # 0x3b27c
leaq -0x40(%rbp), %rdi
callq 0x3470e
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x8b10
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xb391
movq %rdx, -0x60(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x50(%rbp)
jmp 0xb398
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x60(%rbp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x86f0
movq (%r14), %rdi
cmpq %r15, %rdi
je 0xb3d2
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xb3e7
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xb414
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xb414
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xb427
movq (%r15), %rsi
incq %rsi
callq 0x8520
movq %r14, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
|
testing::internal::Int32FromGTestEnv(char const*, int)
|
int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
#if defined(GTEST_GET_INT32_FROM_ENV_)
return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
#else
const std::string env_var = FlagToEnvVar(flag);
const char* const string_value = posix::GetEnv(env_var.c_str());
if (string_value == nullptr) {
// The environment variable is not set.
return default_value;
}
int32_t result = default_value;
if (!ParseInt32(Message() << "Environment variable " << env_var,
string_value, &result)) {
printf("The default value %s is used.\n",
(Message() << default_value).GetString().c_str());
fflush(stdout);
return default_value;
}
return result;
#endif // defined(GTEST_GET_INT32_FROM_ENV_)
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x2a943
movq (%r14), %rdi
callq 0x86e0
testq %rax, %rax
je 0xb532
movq %rax, %r15
movl %ebx, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xf840
movq -0x50(%rbp), %r14
leaq 0x10(%r14), %r12
leaq 0x2fdb5(%rip), %rsi # 0x3b233
movl $0x15, %edx
movq %r12, %rdi
callq 0x8620
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq %r12, %rdi
callq 0x8620
leaq -0x50(%rbp), %rdi
leaq -0x24(%rbp), %rdx
movq %r15, %rsi
callq 0x21fed
movl %eax, %r15d
testq %r14, %r14
je 0xb4bc
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
testb %r15b, %r15b
je 0xb4c6
movl -0x24(%rbp), %ebx
jmp 0xb532
leaq -0x30(%rbp), %rdi
callq 0xf840
movq -0x30(%rbp), %r14
leaq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x89f0
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0xfac9
leaq -0x40(%rbp), %r15
movq -0x10(%r15), %rsi
leaq 0x2fd50(%rip), %rdi # 0x3b249
xorl %eax, %eax
callq 0x8080
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0xb515
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8520
testq %r14, %r14
je 0xb523
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x41a3e(%rip), %rax # 0x4cf68
movq (%rax), %rdi
callq 0x8670
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb54b
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x8520
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb577
movq %rax, %rbx
testq %r14, %r14
je 0xb56d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, -0x30(%rbp)
jmp 0xb595
movq %rax, %rbx
jmp 0xb595
movq %rax, %rbx
testq %r14, %r14
je 0xb58d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, -0x50(%rbp)
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb5ae
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
|
testing::internal::Random::Generate(unsigned int)
|
uint32_t Random::Generate(uint32_t range) {
// These constants are the same as are used in glibc's rand(3).
// Use wider types than necessary to prevent unsigned overflow diagnostics.
state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange;
GTEST_CHECK_(range > 0)
<< "Cannot generate a number in the range [0, 0).";
GTEST_CHECK_(range <= kMaxRange)
<< "Generation of a number in [0, " << range << ") was requested, "
<< "but this can only generate numbers in [0, " << kMaxRange << ").";
// Converting via modulus introduces a bit of downward bias, but
// it's simple, and a linear congruential generator isn't too good
// to begin with.
return state_ % range;
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax # imm = 0x3039
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
jne 0xb62e
leaq 0x2e2ca(%rip), %rdx # 0x398ac
leaq -0x20(%rbp), %rdi
movl $0x3, %esi
movl $0x161, %ecx # imm = 0x161
callq 0x2a45a
movq 0x419ec(%rip), %rdi # 0x4cfe8
leaq 0x2e331(%rip), %rsi # 0x39934
movl $0x1c, %edx
callq 0x8620
movq 0x419d4(%rip), %rdi # 0x4cfe8
leaq 0x2e336(%rip), %rsi # 0x39951
movl $0x2d, %edx
callq 0x8620
leaq -0x20(%rbp), %rdi
callq 0x2a5a0
cmpl $0x80000001, %ebx # imm = 0x80000001
jb 0xb6e7
leaq 0x2e26b(%rip), %rdx # 0x398ac
leaq -0x1c(%rbp), %rdi
movl $0x3, %esi
movl $0x163, %ecx # imm = 0x163
callq 0x2a45a
movq 0x4198d(%rip), %rdi # 0x4cfe8
leaq 0x2e31d(%rip), %rsi # 0x3997f
movl $0x25, %edx
callq 0x8620
movq 0x41975(%rip), %rdi # 0x4cfe8
leaq 0x2e32b(%rip), %rsi # 0x399a5
movl $0x1e, %edx
callq 0x8620
movl %ebx, %esi
movq 0x4195b(%rip), %rdi # 0x4cfe8
callq 0x8340
movq %rax, %r15
leaq 0x2e328(%rip), %rsi # 0x399c4
movl $0x11, %edx
movq %rax, %rdi
callq 0x8620
leaq 0x2e326(%rip), %rsi # 0x399d6
movl $0x2a, %edx
movq %r15, %rdi
callq 0x8620
movl $0x80000000, %esi # imm = 0x80000000
movq %r15, %rdi
callq 0x8340
leaq 0x2e2ab(%rip), %rsi # 0x3997c
movl $0x2, %edx
movq %rax, %rdi
callq 0x8620
leaq -0x1c(%rbp), %rdi
callq 0x2a5a0
movl (%r14), %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
jmp 0xb70b
movq %rax, %rbx
leaq -0x1c(%rbp), %rdi
callq 0x2a5a0
movq %rbx, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
|
testing::internal::AssertHelper::~AssertHelper()
|
AssertHelper::~AssertHelper() {
delete data_;
}
|
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xb7d1
movq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0xb7be
movq (%rax), %rsi
incq %rsi
callq 0x8520
movl $0x38, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8520
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
|
testing::internal::AssertHelper::operator=(testing::Message const&) const
|
void AssertHelper::operator=(const Message& message) const {
UnitTest::GetInstance()->
AddTestPartResult(data_->type, data_->file, data_->line,
AppendUserMessage(data_->message, message),
UnitTest::GetInstance()->impl()
->CurrentOsStackTraceExceptTop(1)
// Skips the stack frame for this function itself.
); // NOLINT
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r12
movq %rdi, %rbx
callq 0xb8c6
movq (%rbx), %rsi
movl (%rsi), %ebx
movq 0x8(%rsi), %r14
movl 0x10(%rsi), %r15d
addq $0x18, %rsi
leaq -0x60(%rbp), %rdi
movq %r12, %rdx
callq 0xbcee
callq 0xb8c6
movq 0x423e5(%rip), %rsi # 0x4dc00
leaq -0x40(%rbp), %rdi
movl $0x1, %edx
callq 0xbe4e
leaq 0x42390(%rip), %rdi # 0x4dbc0
leaq -0x60(%rbp), %r8
leaq -0x40(%rbp), %r9
movl %ebx, %esi
movq %r14, %rdx
movl %r15d, %ecx
callq 0xb940
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb85e
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb877
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb8a5
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xb8a5
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb8be
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
|
testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&)
|
std::string AppendUserMessage(const std::string& gtest_msg,
const Message& user_msg) {
// Appends the user message if it's non-empty.
const std::string user_msg_string = user_msg.GetString();
if (user_msg_string.empty()) {
return gtest_msg;
}
if (gtest_msg.empty()) {
return user_msg_string;
}
return gtest_msg + "\n" + user_msg_string;
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0xfac9
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0xbd7f
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xbd9a
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
addq %rsi, %rax
leaq -0x38(%rbp), %rdi
movq %rax, %rdx
callq 0xa940
leaq 0x2e76d(%rip), %rsi # 0x3a4b0
leaq -0x38(%rbp), %rdi
callq 0x8b10
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x8180
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xbdb2
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xbdb8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xa940
jmp 0xbde4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x58(%rbp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xa940
jmp 0xbde4
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xbde4
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbdfd
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbe0d
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xbe2c
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xbe2c
jmp 0xbe29
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbe45
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
nop
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
|
testing::internal::TypeParameterizedTestSuiteRegistry::RegisterTestSuite(char const*, testing::internal::CodeLocation)
|
void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
const char* test_suite_name, CodeLocation code_location) {
suites_.emplace(std::string(test_suite_name),
TypeParameterizedTestSuiteInfo(code_location));
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x68(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2d590
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xa940
movl 0x20(%r14), %eax
movl %eax, -0x28(%rbp)
leaq -0x88(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0xa940
movl -0x28(%rbp), %eax
leaq -0x98(%rbp), %rdx
movl %eax, 0x20(%rdx)
movb $0x0, 0x28(%rdx)
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x34e26
movq -0x98(%rbp), %rdi
cmpq %r14, %rdi
je 0xc87f
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x8520
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xc894
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc8ad
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x98(%rbp), %rdi
cmpq %r14, %rdi
je 0xc8de
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xc8de
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xc8f8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xc8f8
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc911
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x8520
movq %rbx, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
|
testing::internal::TypeParameterizedTestSuiteRegistry::RegisterInstantiation(char const*)
|
void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
const char* test_suite_name) {
auto it = suites_.find(std::string(test_suite_name));
if (it != suites_.end()) {
it->second.instantiated = true;
} else {
GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"
<< test_suite_name << "'";
}
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2d590
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x3507c
movq %rax, %r15
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc98a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
addq $0x8, %r14
cmpq %r14, %r15
je 0xc99d
movb $0x1, 0x68(%r15)
jmp 0xca2c
leaq 0x2cf08(%rip), %rdx # 0x398ac
leaq -0x40(%rbp), %rdi
movl $0x2, %esi
movl $0x218, %ecx # imm = 0x218
callq 0x2a45a
movq 0x4062a(%rip), %r14 # 0x4cfe8
leaq 0x2d096(%rip), %rsi # 0x39a5b
movl $0x26, %edx
movq %r14, %rdi
callq 0x8620
testq %rbx, %rbx
je 0xc9f3
movq %rbx, %rdi
callq 0x8230
movq 0x40602(%rip), %rdi # 0x4cfe8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x8620
jmp 0xca0b
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x89c0
movq 0x405d6(%rip), %rdi # 0x4cfe8
leaq 0x2d067(%rip), %rsi # 0x39a80
movl $0x1, %edx
callq 0x8620
leaq -0x40(%rbp), %rdi
callq 0x2a5a0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xca66
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8520
jmp 0xca66
movq %rax, %rbx
jmp 0xca66
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2a5a0
movq %rbx, %rdi
callq 0x8a30
|
/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.