name string | code string | asm string | file string |
|---|---|---|---|
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 );
... | 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 0x2... | /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... | /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::n... | 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 %b... | /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] = E... | 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, 0x... | /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] = E... | 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)
mo... | /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;
... | 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(%rb... | /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 == ELFCLAS... | 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,... | /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 %... | /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::c... | 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
mov... | /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 ... | 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... | /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( strea... | 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
... | /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 );
... | 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
mo... | /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... | 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 ... | /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( offs... | 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),... | /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() ... | 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::c... | 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
mov... | /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 ... | 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... | /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( strea... | 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
... | /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 f... | 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... | /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 fixe... | 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 0x... | /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... | 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), %rd... | /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 = e... | 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),... | /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_fi... | 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)... | /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 = e... | 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)... | /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... | 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), %rd... | /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()... | 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... | /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 %r... | /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 %r... | /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<uns... | 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 &... | 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(%rb... | /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 %r... | /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 %r... | /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 0x8e... | /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... | /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<lon... | 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 &... | 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(%rb... | /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 %r... | /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 ... | /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... | /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 0x90... | /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 %r... | /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 ... | /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_strin... | 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 !... | 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 ... | /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... | 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 %... | /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_ada... | 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),... | 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
m... | /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 %... | /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(unsigne... | 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,
"ex... | 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 $-0... | /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 lo... | 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'}... | 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 %r... | /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) <= ... | 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 %... | /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 floatin... | 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
l... | /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.han... | 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, %... | /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, %... | /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.c... | 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),... | /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... | 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... | /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_activeSec... | 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... | /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 amo... | 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_heade... | 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 0x96c8... | /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;
... | 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)... | /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, u... | 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
// repl... | 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... | /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 BagQu... | 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), ... | /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(que... | 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 0x4e... | /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
l... | /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, 0x... | /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");
}
s... | 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... | /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_... | 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... | /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 c... | 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 0x1... | /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();
v... | 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 =... | 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), ... | /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), %ra... | /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 >= s... | 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
... | /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 ... | 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)
m... | /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
re... | 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)
mo... | /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_intermediateDig... | 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(%rs... | /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), %... | /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->mod... | 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)
mov... | /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;
... | 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 (%r... | /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, n... | 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... | /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... | 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 warni... | 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 (%ra... | /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>(pa... | 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,... | /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)
signalValu... | 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
a... | /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);
SetUpTearD... | 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 0x2dce... | /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,... | 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 ... | /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... | /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... | /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... | /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 ? defaul... | 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
... | /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 ? ... | 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, %r... | /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_fl... | 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(%... | /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) {... | 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(%rb... | /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 ... | 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 ... | /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... | /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()
->CurrentOsStackTraceExceptT... | 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 ... | /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()) {
retu... | 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)... | /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... | /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 '"
... | 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... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.