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