name string | code string | asm string | file string |
|---|---|---|---|
std::shared_ptr<spdlog::logger> spdlog::synchronous_factory::create<spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_nullmutex>, spdlog::color_mode&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, spdlog::color_mode&) | static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
{
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
details::registry::instance().initia... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rcx
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x20(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x18(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
callq 0x56140
movq %r14, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/details/synchronous_factory.h |
std::shared_ptr<spdlog::logger> spdlog::synchronous_factory::create<spdlog::sinks::ansicolor_stderr_sink<spdlog::details::console_nullmutex>, spdlog::color_mode&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, spdlog::color_mode&) | static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
{
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
details::registry::instance().initia... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rcx
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x20(%rsp), %rdi
movq %r14, -0x8(%rdi)
leaq 0x18(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
callq 0x5656c
movq %r14, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/details/synchronous_factory.h |
spdlog::async_logger::flush_() | SPDLOG_INLINE void spdlog::async_logger::flush_()
{
if (auto pool_ptr = thread_pool_.lock())
{
pool_ptr->post_flush(shared_from_this(), overflow_policy_);
}
else
{
throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movq 0xe8(%rdi), %rbx
testq %rbx, %rbx
je 0x574fb
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x574f9
leal 0x1(%rax), %ecx
lock
cmpxchgl %ecx, 0x8(%rbx)
jne 0x574e9
jmp 0x574fb
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x5750a
movl 0x8(%rbx), %eax
testl %eax, %ea... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/async_logger-inl.h |
fmt::v9::vsystem_error(int, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_args<fmt::v9::basic_format_context<fmt::v9::appender, char>>) | FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
format_args args) {
auto ec = std::error_code(error_code, std::generic_category());
return std::system_error(ec, vformat(format_str, args));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movl %esi, 0x4(%rsp)
movq %rdi, %r14
callq 0x172f0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbp, %r8
callq 0x5926b
movq %r14,... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h |
Tag::getCloseTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool Tag::getCloseTag( std::string &s )
{
bool success = true;
std::stringstream stream;
stream << "</" << getName() << ">";
if ( s != stream.str() )
{
//std::cerr << "Syntax error: \"</" << getName() << ">\" expected." << std::endl;
success = false;
}
return success;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x28(%rsp), %rdi
callq 0x5130
leaq 0x38(%rsp), %r14
leaq 0x1f7e(%rip), %rsi # 0x80ca
movl $0x2, %edx
movq %r14, %rdi
callq 0x52c0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x52b0
movq 0x8(%rsp), %rsi
m... | /miho[P]FlexPars/src/Tag.cpp |
File::~File() | File::~File()
{
for ( unsigned int i = 0; i < _tags.size();i++ )
{
if ( _tags[i] != NULL )
{
delete _tags[i];
_tags[i] = NULL;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x473b(%rip), %rax # 0xafa8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
cmpq %rdi, 0x18(%rbx)
je 0x68c9
movl $0x1, %ebp
xorl %r15d, %r15d
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x68b0
movq %r14, %rdi
callq 0x5300
movl $0... | /miho[P]FlexPars/src/File.cpp |
DoubleElement::DoubleElement() | DoubleElement::DoubleElement( )
{
setName( "DoubleElement" );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x53f0
movq 0x3bf8(%rip), %rax # 0xafb8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe60(%rip), %rsi # 0x8237
leaq 0xe66(%rip), %rdx # 0x8244
movq %rsp, %rdi
callq 0x50c0
movq %rsp, %rsi
mo... | /miho[P]FlexPars/src/DoubleElement.cpp |
IntegerField::IntegerField(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int) | IntegerField::IntegerField( std::string name, int size ) : Tag( name )
{
// we have to add at least one element
if ( size == 0 )
{
addElement( new IntegerElement() );
}
else
{
for ( int i = 0; i < size; i++ )
{
addElement( new IntegerElement() );
}
}
// We want to treat each element
// as seperate l... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x50e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5410
movq 0x8(%rsp), ... | /miho[P]FlexPars/src/IntegerField.cpp |
fgetc | int fgetc( struct _PDCLIB_file_t * stream )
{
int rc = EOF;
_PDCLIB_LOCK( stream->mtx );
if ( _PDCLIB_prepread( stream ) != EOF )
{
if ( _PDCLIB_CHECKBUFFER( stream ) != EOF )
{
rc = _PDCLIB_GETC( stream );
}
}
_PDCLIB_UNLOCK( stream->mtx );
return rc;... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x48(%rdi), %rbx
movq %rbx, %rdi
callq 0x8f6c
movq %r14, %rdi
callq 0x7b38
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x3894
movq 0x18(%r14), %rax
cmpq 0x20(%r14), %rax
jne 0x3867
cmpq $0x0, 0x38(%r14)
jne 0x3867
movq %r14, %rdi
callq 0x8dd8... | /DevSolar[P]pdclib/functions/stdio/fgetc.c |
freopen | struct _PDCLIB_file_t * freopen( const char * _PDCLIB_restrict filename, const char * _PDCLIB_restrict mode, struct _PDCLIB_file_t * _PDCLIB_restrict stream )
{
unsigned int filemode = _PDCLIB_filemode( mode );
if ( stream == NULL )
{
errno = EBADF;
return NULL;
}
_PDCLIB_LOCK( _PD... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x79ac
testq %rbx, %rbx
je 0x394d
movl %eax, %ebp
leaq 0xb7e5(%rip), %rdi # 0xf0b0
callq 0x8f6c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7af0
leaq 0x48(%rbx), %r14
movq %r14, %rdi
testl %eax, %eax
je 0x395d
... | /DevSolar[P]pdclib/functions/stdio/freopen.c |
free | void dlfree(void* mem) {
/*
Consolidate freed chunks with preceeding or succeeding bordering
free chunks, if they exist, and then place in a bin. Intermixed
with special cases for top, dv, mmapped chunks, and usage errors.
*/
if (mem != 0) {
mchunkptr p = mem2chunk(mem);
#if FOOTERS
msta... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5971
movq %rdi, %r14
leaq -0x10(%rdi), %rbx
testb $0x2, 0x9dd0(%rip) # 0xf068
je 0x52d5
movl $0x1, %ebp
movl $0x1, %eax
xchgl %eax, 0x9dc2(%rip) # 0xf06c
testl %eax, %eax
jne 0x52bd
jmp 0x52d5
testb $0x3f, %bpl
jne 0x52bb
callq 0x30b... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
release_unused_segments | static size_t release_unused_segments(mstate m) {
size_t released = 0;
int nsegs = 0;
msegmentptr pred = &m->seg;
msegmentptr sp = pred->next;
while (sp != 0) {
char* base = sp->base;
size_t size = sp->size;
msegmentptr next = sp->next;
++nsegs;
if (is_mmapped_segment(sp) && !is_extern_seg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x945a(%rip), %rdx # 0xf080
testq %rdx, %rdx
je 0x5f75
leaq 0x943a(%rip), %r9 # 0xf070
leaq 0x90bb(%rip), %r8 # 0xecf8
movq $0x0, 0x8(%rsp)
xorl %r12d, %r12d
movq %rdx, %r15
movq 0x10(%rdx), %rdx
movl 0x18(%r15), %e... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
calloc | void* dlcalloc(size_t n_elements, size_t elem_size) {
void* mem;
size_t req = 0;
if (n_elements != 0) {
req = n_elements * elem_size;
if (((n_elements | elem_size) & ~(size_t)0xffff) &&
(req / n_elements != elem_size))
req = MAX_SIZE_T; /* force downstream failure on overflow */
}
mem = ... | pushq %rbx
testq %rdi, %rdi
je 0x5fde
movq %rdi, %rax
mulq %rsi
movq %rax, %rbx
seto %al
orq %rdi, %rsi
cmpq $0x10000, %rsi # imm = 0x10000
jb 0x5fe0
testb %al, %al
movq $-0x1, %rax
cmovneq %rax, %rbx
jmp 0x5fe0
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x3d94
testq %rax, %rax
je 0x6001
testb $0x3, -0x8(%rax)
je 0... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
ialloc | static void** ialloc(mstate m,
size_t n_elements,
size_t* sizes,
int opts,
void* chunks[]) {
size_t element_size; /* chunksize of each element, if all same */
size_t contents_size; /* total size of elements */
size_t ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x8462(%rip) # 0xecc8
jne 0x686d
callq 0x51c0
testq %rbx, %rbx
je 0x687f
testq %r15, %r15
je 0x6a83
xorl %edi, %edi
jmp 0x68ab
testq %r15, %r15
je 0x690e
lea... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
dlmalloc_set_footprint_limit | size_t dlmalloc_set_footprint_limit(size_t bytes) {
size_t result; /* invert sense of 0 */
if (bytes == 0)
result = granularity_align(1); /* Use minimal size */
if (bytes == MAX_SIZE_T)
result = 0; /* disable */
else
result = granularity_align(bytes);
return gm->footprint_limit... | cmpq $-0x1, %rdi
je 0x6c85
movq 0x8062(%rip), %rax # 0xecd8
leaq (%rdi,%rax), %rcx
decq %rcx
negq %rax
andq %rcx, %rax
jmp 0x6c87
xorl %eax, %eax
movq %rax, 0x83d2(%rip) # 0xf060
retq
| /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
dlmallinfo | struct mallinfo dlmallinfo(void) {
return internal_mallinfo(gm);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
cmpq $0x0, 0x8010(%rip) # 0xecc8
jne 0x6cbf
callq 0x51c0
testb $0x2, 0x83a2(%rip) # 0xf068
je 0x6d0... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
dlmallopt | int dlmallopt(int param_number, int value) {
return change_mparam(param_number, value);
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
cmpq $0x0, 0x7ec3(%rip) # 0xecc8
jne 0x6e0c
callq 0x51c0
movslq %ebp, %rcx
cmpl $-0x3, %ebx
je 0x6eac
cmpl $-0x1, %ebx
je 0x6ea3
xorl %eax, %eax
cmpl $-0x2, %ebx
jne 0x6ebb
cmpq %rcx, 0x7e9d(%rip) # 0xecd0
ja 0x6ebb
movq %rcx, %rdx
shrq %rdx
mov... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
PDCLIB_print | const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status )
{
const char * orig_spec = spec;
if ( *( ++spec ) == '%' )
{
/* %% -> print single '%' */
PUT( *spec );
return ++spec;
}
/* Initializing status structure */
status->flags = 0;
status->... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rdi), %rax
movq %rax, 0x18(%rsp)
movb 0x1(%rdi), %al
cmpb $0x25, %al
jne 0x7c13
movq 0x10(%rbx), %rcx
cmpq 0x8(%rbx), %rcx
jae 0x7d43
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x7d3c
movl $0x25, %edi
callq 0x90c0
jmp ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print.c |
PDCLIB_print_double | void _PDCLIB_print_double( double value, struct _PDCLIB_status_t * status )
{
unsigned char bytes[ sizeof( double ) ];
int exp;
memcpy( bytes, &value, sizeof( double ) );
exp = _PDCLIB_DBL_EXP( bytes ) - _PDCLIB_DBL_BIAS;
if ( exp == _PDCLIB_DBL_MAX_EXP )
{
/* ... | pushq %rax
movq %rdi, %r9
leaq 0x6(%rsp), %rcx
movsd %xmm0, -0x6(%rcx)
movzbl 0x1(%rcx), %edi
movl %edi, %eax
andl $0x7f, %eax
shll $0x4, %eax
movzbl (%rcx), %r8d
shrl $0x4, %r8d
leal (%r8,%rax), %edx
addl $0xfffffc01, %edx # imm = 0xFFFFFC01
xorl %esi, %esi
ucomisd %xmm0, %xmm0
setp %sil
addl $0x7fffffff, %esi ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_fp.c |
PDCLIB_print_fp | static void _PDCLIB_print_fp( int sign,
int exp,
int dec,
unsigned char const * mant,
size_t mant_dig,
struct _PDCLIB_status_t * status )
{
/* Turning sign bit into s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %rcx, %r9
movl %esi, %eax
movl $0x4, %ecx
testl %edi, %edi
je 0x837b
movl $0x2d, %ebp
jmp 0x839b
movl 0x4(%rbx), %ebp
testb $0x2, %bpl
jne 0x8396
xorl %r15d, %r15d
andl $0x8, %ebp
sete %r15b
subq %r15, %rcx
shll $0x2,... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_fp.c |
PDCLIB_fillbuffer | int _PDCLIB_fillbuffer( struct _PDCLIB_file_t * stream )
{
/* No need to handle buffers > INT_MAX, as PDCLib doesn't allow them */
ssize_t rc = read( stream->handle, stream->buffer, stream->bufsize );
if ( rc > 0 )
{
/* Reading successful. */
if ( !( stream->status & _PDCLIB_FBIN ) )
... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
callq 0x30c0
testq %rax, %rax
jle 0x8e06
addq %rax, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
xorl %eax, %eax
jmp 0x8e25
js 0x8e0e
orb $0x4, 0x45(%rbx)
jmp 0x8e20
callq 0x3030
movl (%rax), %ebp
cal... | /DevSolar[P]pdclib/platform/example/functions/_PDCLIB/_PDCLIB_fillbuffer.c |
sprintf | int sprintf( char * _PDCLIB_restrict s, const char * _PDCLIB_restrict format, ... )
{
int rc;
va_list ap;
va_start( ap, format );
rc = vsnprintf( s, SIZE_MAX, format, ap ); /* TODO: replace with non-checking call */
va_end( ap );
return rc;
} | subq $0xd8, %rsp
movq %rsi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x91de
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
mova... | /DevSolar[P]pdclib/functions/stdio/sprintf.c |
PDCLIB_closeall | void _PDCLIB_closeall( void )
{
struct _PDCLIB_file_t * stream = _PDCLIB_filelist;
struct _PDCLIB_file_t * next;
while ( stream != NULL )
{
next = stream->next;
fclose( stream );
stream = next;
}
} | pushq %rbx
leaq 0x4c04(%rip), %rax # 0xe0e8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x94fd
movq 0x78(%rdi), %rbx
callq 0x3740
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x94ec
popq %rbx
retq
nop
| /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_closeall.c |
ncnn::Layer_final::load_param(ncnn::ParamDict const&) | virtual int load_param(const ParamDict& pd)
{
set_layer_properties();
#if NCNN_VULKAN
if (layer_vulkan)
{
if (vkdev)
{
int ret = layer_vulkan->load_param(pd);
get_layer_properties();
if (layer_vulkan->support_vulkan)
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2cca2
movq 0xd0(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq 0xd0(%r14), %rcx
movb 0x8(%rcx), %dl
movb %dl, 0x8(%r14)
movb 0x9(%rcx), %dl
movb %dl, 0x9(%r14)
movl 0xb(%rcx), %ecx
movl %ecx, 0xb(%r14)
movb $0x0, 0xa(%r14)
mo... | /Tencent[P]ncnn/src/layer.cpp |
ncnn::Mat::create(int, int, int, int, unsigned long, ncnn::Allocator*) | void Mat::create(int _w, int _h, int _d, int _c, size_t _elemsize, Allocator* _allocator)
{
if (dims == 4 && w == _w && h == _h && d == _d && c == _c && elemsize == _elemsize && elempack == 1 && allocator == _allocator)
return;
release();
elemsize = _elemsize;
elempack = 1;
allocator = _al... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movl %r8d, %ebp
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, %rbx
movq 0x40(%rsp), %r8
movdqu 0x28(%rdi), %xmm0
movd %ecx, %xmm1
movd %edx, %xmm2
punpckldq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1... | /Tencent[P]ncnn/src/mat.cpp |
test | int test(char *url)
{
CURLM *multi = NULL;
int running;
int i;
int num_handles = 0;
enum HandleState state = ReadyForNewHandle;
size_t urllen = strlen(url) + 4 + 1;
char *full_url = malloc(urllen);
start_test_timing();
if(!full_url) {
fprintf(stderr, "Not enough memory for full url\n");
retu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, 0x28(%rsp)
callq 0x2080
movq %rax, %r15
addq $0x5, %r15
movq %r15, %rdi
callq 0x2170
movq %rax, %rbx
callq 0x323c
leaq 0x40b3(%rip), %r13 # 0x63c8
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
testq %rb... | /kfalconspb[P]curl/tests/libtest/libntlmconnect.c |
hexdump | char *hexdump(const unsigned char *buffer, size_t len)
{
static char dump[200 * 3 + 1];
char *p = dump;
size_t i;
if(len > 200)
return NULL;
for(i = 0; i<len; i++, p += 3)
msnprintf(p, 4, "%02x ", buffer[i]);
return dump;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0xc8, %rsi
jbe 0x3143
xorl %ebx, %ebx
jmp 0x318d
movq %rsi, %r14
testq %rsi, %rsi
je 0x3186
movq %rdi, %r15
leaq 0x300b(%rip), %rbx # 0x6160
leaq 0x1354(%rip), %r12 # 0x44b0
xorl %ebp, %ebp
movq %rbx, %r13
movzbl (%r15,%rbp), %... | /kfalconspb[P]curl/tests/libtest/first.c |
tutil_tvnow | struct timeval tutil_tvnow(void)
{
/*
** clock_gettime() is granted to be increased monotonically when the
** monotonic clock is queried. Time starting point is unspecified, it
** could be the system start-up time, the Epoch, or something else,
** in any case the time starting point does not change once that ... | subq $0x28, %rsp
leaq 0x18(%rsp), %rsi
movl $0x1, %edi
callq 0x20e0
testl %eax, %eax
je 0x3261
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x21b0
jmp 0x328d
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7,... | /kfalconspb[P]curl/tests/libtest/testutil.c |
tutil_tvdiff | long tutil_tvdiff(struct timeval newer, struct timeval older)
{
return (long)(newer.tv_sec-older.tv_sec)*1000+
(long)(newer.tv_usec-older.tv_usec)/1000;
} | movq %rsi, %rax
subq %rdx, %rdi
subq %rcx, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
imulq $0x3e8, %rdi, %rcx # imm = 0x3E8
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rdx, %rax
addq %rcx, %rax
retq
| /kfalconspb[P]curl/tests/libtest/testutil.c |
curlx_ultous | unsigned short curlx_ultous(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(ulnum & (unsigned long) CURL_MASK_USHORT);
#ifdef __IN... | movq %rdi, %rax
retq
| /kfalconspb[P]curl/lib/warnless.c |
curlx_uztosi | int curlx_uztosi(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SINT);
return (int)(uznum & (size_t) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /kfalconspb[P]curl/lib/warnless.c |
curlx_uztoul | unsigned long curlx_uztoul(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
#if (SIZEOF_LONG < SIZEOF_SIZE_T)
DEBUGASSERT(uznum <= (size_t) CURL_MASK_ULONG);
#endif
return (unsigned long)(uznum & (size_t) CURL_MASK_ULONG)... | movq %rdi, %rax
retq
| /kfalconspb[P]curl/lib/warnless.c |
curlx_sltosi | int curlx_sltosi(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_SINT);
#endif
return (int)(slnum &... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /kfalconspb[P]curl/lib/warnless.c |
curlx_uztosz | ssize_t curlx_uztosz(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(po... | movq %rdi, %rax
btrq $0x3f, %rax
retq
| /kfalconspb[P]curl/lib/warnless.c |
curlx_sztosi | int curlx_sztosi(ssize_t sznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sznum >= 0);
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
#endif
return (int)(sznum & (ssize_t... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /kfalconspb[P]curl/lib/warnless.c |
curlx_uitous | unsigned short curlx_uitous(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_USHORT);
return (unsigned short) (uinum & (unsigned int) CURL_MASK_USHORT);
#ifdef __INTE... | movl %edi, %eax
retq
| /kfalconspb[P]curl/lib/warnless.c |
curlx_sitouz | size_t curlx_sitouz(int sinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sinum >= 0);
return (size_t) sinum;
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movslq %edi, %rax
retq
| /kfalconspb[P]curl/lib/warnless.c |
png_do_read_transformations | void /* PRIVATE */
png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
{
png_debug(1, "in png_do_read_transformations");
if (png_ptr->row_buf == NULL)
{
/* Prior to 1.5.4 this output row/pass where the NULL pointer is, but this
* error is incredibly rare and incredibly easy ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %r12
movq 0x228(%rdi), %rsi
testq %rsi, %rsi
je 0x15dd2
movl $0x4040, %eax # imm = 0x4040
andl 0x130(%r12), %eax
cmpl $0x4000, %eax # imm = 0x4000
je 0x15ddb
movl 0x134(%r12), %eax
btl $0xc,... | /hunter-packages[P]libpng/pngrtran.c |
png_get_uint_32 | png_uint_32 (PNGAPI
png_get_uint_32)(png_const_bytep buf)
{
png_uint_32 uval =
((png_uint_32)(*(buf )) << 24) +
((png_uint_32)(*(buf + 1)) << 16) +
((png_uint_32)(*(buf + 2)) << 8) +
((png_uint_32)(*(buf + 3)) ) ;
return uval;
} | movl (%rdi), %eax
bswapl %eax
retq
| /hunter-packages[P]libpng/pngrutil.c |
png_check_chunk_name | void /* PRIVATE */
png_check_chunk_name(png_const_structrp png_ptr, png_uint_32 chunk_name)
{
int i;
png_uint_32 cn=chunk_name;
png_debug(1, "in png_check_chunk_name");
for (i=1; i<=4; ++i)
{
int c = cn & 0xff;
if (c < 65 || c > 122 || (c > 90 && c < 97))
png_chunk_error(png_ptr, ... | pushq $0x4
popq %rax
subl $0x1, %eax
jb 0x164ae
movzbl %sil, %ecx
leal -0x7b(%rcx), %edx
cmpl $-0x3a, %edx
jb 0x164af
addl $-0x5b, %ecx
cmpl $0x5, %ecx
jbe 0x164af
shrl $0x8, %esi
jmp 0x16490
retq
pushq %rax
leaq 0x16c8d(%rip), %rsi # 0x2d144
callq 0xc497
| /hunter-packages[P]libpng/pngrutil.c |
png_crc_error | int /* PRIVATE */
png_crc_error(png_structrp png_ptr)
{
png_byte crc_bytes[4];
png_uint_32 crc;
int need_crc = 1;
if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0)
{
if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
(PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x130(%rdi), %eax
movl %eax, %ecx
notl %ecx
xorl %ebp, %ebp
testw $0x300, %cx # imm = 0x300
sete %bpl
shrl $0xb, %eax
andl $0x1, %eax
btl $0x1d, 0x218(%rdi)
cmovael %eax, %ebp
movl $0x81, 0x474(%rdi)
leaq 0x4(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x119b... | /hunter-packages[P]libpng/pngrutil.c |
png_handle_IHDR | void /* PRIVATE */
png_handle_IHDR(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
{
png_byte buf[13];
png_uint_32 width, height;
int bit_depth, color_type, compression_type, filter_type;
int interlace_type;
png_debug(1, "in png_handle_IHDR");
if ((png_ptr->mode & PNG_HAVE_IHDR) != 0)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x12c(%rdi), %eax
testb $0x1, %al
jne 0x1680d
cmpl $0xd, %edx
jne 0x16816
movq %rsi, %r14
orl $0x1, %eax
movl %eax, 0x12c(%rbx)
leaq 0x3(%rsp), %r15
pushq $0xd
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x16574
movq %rbx, ... | /hunter-packages[P]libpng/pngrutil.c |
png_handle_IEND | void /* PRIVATE */
png_handle_IEND(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
{
png_debug(1, "in png_handle_IEND");
if ((png_ptr->mode & PNG_HAVE_IHDR) == 0 ||
(png_ptr->mode & PNG_HAVE_IDAT) == 0)
png_chunk_error(png_ptr, "out of place");
png_ptr->mode |= (PNG_AFTER_IDAT | P... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x12c(%rdi), %eax
movl %eax, %ecx
notl %ecx
testb $0x5, %cl
jne 0x16a74
movl %edx, %ebp
orl $0x18, %eax
movl %eax, 0x12c(%rbx)
movq %rbx, %rdi
movl %edx, %esi
callq 0x165a3
testl %ebp, %ebp
je 0x16a6d
leaq 0x16391(%rip), %rsi # 0x2cdf0
movq %rbx, %rdi
addq $0x8,... | /hunter-packages[P]libpng/pngrutil.c |
save_png | void save_png(gdImagePtr im, const char *filename)
{
FILE *fp;
fp = fopen(filename, "wb");
if (!fp) {
fprintf(stderr, "Can't save png image %s\n", filename);
return;
}
#ifdef HAVE_LIBPNG
gdImagePng(im, fp);
#else
printf("No PNG support. Cannot save image.\n");
#endif
fclose(fp);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xe2a(%rip), %rsi # 0x2004
movq %rbx, %rdi
callq 0x1060
testq %rax, %rax
je 0x1205
movq %rax, %r14
leaq 0xe90(%rip), %rdi # 0x2081
callq 0x1090
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1050
movq 0x2dd4(%rip), %rax # 0x3fe0
movq (%ra... | /imazen[P]gd-libgd/examples/crop.c |
doctest::String doctest::toString<long double>(doctest::IsNaN<long double>) | String toString(IsNaN<F> in) { return String(in.flipped ? "! " : "") + "IsNaN( " + doctest::toString(in.value) + " )"; } | subq $0xd8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xd0(%rsp)
movb 0x10(%rax), %cl
leaq 0xb4df0(%rip), %rax # 0xdef73
leaq 0xb45d5(%rip), %rsi # 0xde75f
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0xfd50
leaq 0xb... | /approvals[P]ApprovalTests/third_party/doctest/include/doctest/doctest.2.4.11.h |
doctest::TestCaseData::TestCaseData() | struct DOCTEST_INTERFACE TestCaseData
{
String m_file; // the file in which the test was registered (using String - see #350)
unsigned m_line; // the line where the test was registered
const char* m_name; // name of the test case
const char* m_test_suite; // the test suite in w... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xfcf0
popq %rax
retq
| /approvals[P]ApprovalTests/third_party/doctest/include/doctest/doctest.2.4.11.h |
ApprovalTests::TApprovals<ApprovalTests::ToStringCompileTimeOptions<ApprovalTests::FmtToString>>::verify(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ApprovalTests::Options const&) | static void verify(const std::string& contents,
const Options& options = Options())
{
StringWriter writer(options.scrub(contents),
options.fileOptions().getFileExtension());
FileApprover::verify(*options.getNamer(), writer, optio... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xe8(%rsp), %rsi
movq 0xf0(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x5f570
movq 0xe8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x5f460
jmp 0x3c678
leaq 0x38(%rsp), %rdi
callq 0x5efb0
movq %rax, 0x10(%rsp)
jmp 0x3c689
movq 0x10(%rsp), %rsi
leaq 0x60(%rsp), ... | /approvals[P]ApprovalTests/ApprovalTests/../ApprovalTests/Approvals.h |
fmt::v6::format_arg_store<fmt::v6::basic_format_context<std::back_insert_iterator<fmt::v6::internal::buffer<char>>, char>, std::remove_reference<std::vector<int, std::allocator<int>> const&>::type> fmt::v6::internal::make_args_checked<std::vector<int, std::allocator<int>> const&, char [3], char>(char const (&) [3], std... | inline format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>
make_args_checked(const S& format_str,
const remove_reference_t<Args>&... args) {
static_assert(
all_true<(!std::is_base_of<view, remove_reference_t<Args>>::value ||
!std::is_reference<Args>::value)...>:... | subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x5c8b0
movq (%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x5c8c0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/core.h |
fmt::v6::basic_memory_buffer<char, 500ul, std::allocator<char>>::grow(unsigned long) | void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size) {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
if (size > 1000) throw std::runtime_error("fuzz mode - won't grow that much");
#endif
std::size_t old_capacity = this->capacity();
std::size_t new_capacity = old_capacity + old_capacity / 2;
if... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3d120
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x40(%rsp), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x38(%rsp), %rax
jbe 0x3d01d
movq 0x48(%rsp), %rax
movq %rax... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format.h |
fmt::v6::basic_format_args<fmt::v6::basic_format_context<std::back_insert_iterator<fmt::v6::internal::buffer<char>>, char>>::do_get(int) const | format_arg do_get(int index) const {
format_arg arg;
if (!is_packed()) {
auto num_args = max_size();
if (index < num_args) arg = args_[index];
return arg;
}
if (index > internal::max_packed_args) return arg;
arg.type_ = type(index);
if (arg.type_ == internal::type::none_type) r... | subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x3da10
movq 0x18(%rsp), %rdi
callq 0x3e4c0
testb $0x1, %al
jne 0x3e3ef
movq 0x18(%rsp), %rdi
callq 0x3e4f0
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %ea... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/core.h |
decltype(fp(0)) fmt::v6::visit_format_arg<fmt::v6::arg_formatter<fmt::v6::buffer_range<char>>, fmt::v6::basic_format_context<std::back_insert_iterator<fmt::v6::internal::buffer<char>>, char>>(fmt::v6::arg_formatter<fmt::v6::buffer_range<char>>&&, fmt::v6::basic_format_arg<fmt::v6::basic_format_context<std::back_insert_... | FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
const basic_format_arg<Context>& arg)
-> decltype(vis(0)) {
using char_type = typename Context::char_type;
switch (arg.type_) {
case internal::type::none_type:
break;
case internal::type::named_arg_type:
FMT_ASSER... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movl 0x10(%rax), %eax
movq %rax, 0x20(%rsp)
subq $0x10, %rax
ja 0x3e94d
movq 0x20(%rsp), %rax
leaq 0xa2197(%rip), %rcx # 0xe0814
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x3e94d
jmp 0x3e94d
movq 0x88(%rsp), %rdi
movq... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/core.h |
fmt::v6::internal::basic_writer<fmt::v6::buffer_range<char>>::int_writer<int, fmt::v6::basic_format_specs<char>>::int_writer(fmt::v6::internal::basic_writer<fmt::v6::buffer_range<char>>&, int, fmt::v6::basic_format_specs<char> const&) | int_writer(basic_writer<Range>& w, Int value, const Specs& s)
: writer(w),
specs(s),
abs_value(static_cast<unsigned_type>(value)),
prefix_size(0) {
if (is_negative(value)) {
prefix[0] = '-';
++prefix_size;
abs_value = 0 - abs_value;
} else if (sp... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x24(%rsp), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 0x18(%rax)
movl 0x24(%rsp), %edi
... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format.h |
fmt::v6::internal::basic_writer<fmt::v6::buffer_range<char>>::int_writer<int, fmt::v6::basic_format_specs<char>>::on_num() | void on_num() {
std::string groups = grouping<char_type>(writer.locale_);
if (groups.empty()) return on_dec();
auto sep = thousands_sep<char_type>(writer.locale_);
if (!sep) return on_dec();
int num_digits = count_digits(abs_value);
int size = num_digits;
std::string::const_ite... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
callq 0x41e20
leaq 0xd0(%rsp), %rdi
callq 0xec80
testb $0x1, %al
jne 0x3f953
jmp 0x3f995
movq 0x40(%rsp), %rdi
callq 0x3f590
jmp 0x3... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format.h |
void fmt::v6::internal::basic_writer<fmt::v6::buffer_range<char>>::write_int<fmt::v6::internal::basic_writer<fmt::v6::buffer_range<char>>::int_writer<int, fmt::v6::basic_format_specs<char>>::hex_writer>(int, fmt::v6::basic_string_view<char>, fmt::v6::basic_format_specs<char>, fmt::v6::internal::basic_writer<fmt::v6::bu... | void write_int(int num_digits, string_view prefix, format_specs specs, F f) {
std::size_t size = prefix.size() + to_unsigned(num_digits);
char_type fill = specs.fill[0];
std::size_t padding = 0;
if (specs.align == align::numeric) {
auto unsiged_width = to_unsigned(specs.width);
if (unsiged_w... | subq $0xa8, %rsp
leaq 0xb0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdx, 0x98(%rsp)
movq %rcx, 0xa0(%rsp)
movq %r8, 0x88(%rsp)
movq %r9, 0x90(%rsp)
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x3dae0
movq %rax, 0x18(%rsp)
movl 0x7c(%rsp), %edi
callq ... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format.h |
void fmt::v6::internal::basic_writer<fmt::v6::buffer_range<char>>::write_padded<fmt::v6::internal::basic_writer<fmt::v6::buffer_range<char>>::padded_int_writer<fmt::v6::internal::basic_writer<fmt::v6::buffer_range<char>>::int_writer<int, fmt::v6::basic_format_specs<char>>::hex_writer>>(fmt::v6::basic_format_specs<char>... | void write_padded(const format_specs& specs, F&& f) {
// User-perceived width (in code points).
unsigned width = to_unsigned(specs.width);
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... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movl (%rax), %edi
callq 0x3ff00
movl %eax, 0x5c(%rsp)
movq 0x60(%rsp), %rdi
callq 0x40f70
movq %rax, 0x50(%rsp)
cmpl $0x0, 0x5c(%rsp)
je 0x40dc4
movq 0x60(%rsp), %rdi
call... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format.h |
fmt::v6::internal::basic_writer<fmt::v6::buffer_range<char>>::int_writer<unsigned int, fmt::v6::basic_format_specs<char>>::on_hex() | void on_hex() {
if (specs.alt) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = specs.type;
}
int num_digits = count_digits<4>(abs_value);
writer.write_int(num_digits, get_prefix(), specs,
hex_writer{*this, num_digits});
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rax), %rax
movb 0x9(%rax), %al
shrb $0x7, %al
testb $0x1, %al
je 0x42eb0
movq 0x20(%rsp), %rax
movl 0x18(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x18(%rax)
movl %ecx, %ecx
movb $0x30, 0x14(%rax,%rcx)
movq 0x8(%ra... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format.h |
fmt::v6::internal::basic_writer<fmt::v6::buffer_range<char>>::int_writer<unsigned int, fmt::v6::basic_format_specs<char>>::on_bin() | void on_bin() {
if (specs.alt) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = static_cast<char>(specs.type);
}
int num_digits = count_digits<1>(abs_value);
writer.write_int(num_digits, get_prefix(), specs,
bin_writer<1>{abs_value, num_digits});
... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rax), %rax
movb 0x9(%rax), %al
shrb $0x7, %al
testb $0x1, %al
je 0x42fa0
movq 0x18(%rsp), %rax
movl 0x18(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x18(%rax)
movl %ecx, %ecx
movb $0x30, 0x14(%rax,%rcx)
movq 0x8(%ra... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format.h |
fmt::v6::internal::basic_writer<fmt::v6::buffer_range<char>>::int_writer<unsigned int, fmt::v6::basic_format_specs<char>>::on_num() | void on_num() {
std::string groups = grouping<char_type>(writer.locale_);
if (groups.empty()) return on_dec();
auto sep = thousands_sep<char_type>(writer.locale_);
if (!sep) return on_dec();
int num_digits = count_digits(abs_value);
int size = num_digits;
std::string::const_ite... | subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
callq 0x41e20
leaq 0xd0(%rsp), %rdi
callq 0xec80
testb $0x1, %al
jne 0x43183
jmp 0x431c5
movq 0x40(%rsp), %rdi
callq 0x42dc0
jmp 0x4... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format.h |
fmt::v6::internal::arg_formatter_base<fmt::v6::buffer_range<char>, fmt::v6::internal::error_handler>::write(char const*) | void write(const char_type* value) {
if (!value) {
FMT_THROW(format_error("string pointer is null"));
} else {
auto length = std::char_traits<char_type>::length(value);
basic_string_view<char_type> sv(value, length);
specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
}
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x58805
movl $0x10, %edi
callq 0xe3c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x883a8(%rip), %rsi # 0xe0b73
callq 0x42a50
jmp 0x587d2
movq (%rsp), %rdi
leaq 0xd2363(%rip),... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format.h |
char const* fmt::v6::internal::next_code_point<char>(char const*, char const*) | FMT_CONSTEXPR const Char* next_code_point(const Char* begin, const Char* end) {
if (const_check(sizeof(Char) != 1) || (*begin & 0x80) == 0) return begin + 1;
do {
++begin;
} while (begin != end && (*begin & 0xc0) == 0x80);
return begin;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
xorl %edi, %edi
callq 0x54cb0
testb $0x1, %al
jne 0x5a66b
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x5a67b
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x5a6c8
jmp 0x5a67d
movq 0x18(%rsp), %rax
addq $0x... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format.h |
fmt::v6::basic_format_context<std::back_insert_iterator<fmt::v6::internal::buffer<char>>, char>::iterator fmt::v6::formatter<std::vector<int, std::allocator<int>>, char, void>::format<fmt::v6::basic_format_context<std::back_insert_iterator<fmt::v6::internal::buffer<char>>, char>>(std::vector<int, std::allocator<int>> c... | typename FormatContext::iterator format(const RangeT& values,
FormatContext& ctx) {
auto out = internal::copy(formatting.prefix, ctx.out());
std::size_t i = 0;
for (auto it = values.begin(), end = values.end(); it != end; ++it) {
if (i > 0) {
if (forma... | subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movb (%rax), %al
movb %al, 0x1f(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x3d920
movq %rax, %rcx
movb 0x1f(%rsp), %al
movq %rcx, 0x98(%rsp)
movq 0x98(%rsp), %rsi
movsbl %al, %edi
callq 0x5cd10
movq %r... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/ranges.h |
ApprovalTests::TestName::getRootDirectory[abi:cxx11]() | std::string TestName::getRootDirectory()
{
if (!rootDirectoryStorage().empty())
{
return rootDirectoryStorage();
}
else
{
throw std::runtime_error(HelpMessages::getUnconfiguredRootDirectory());
}
} | subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
callq 0x60640
movq %rax, %rdi
callq 0xec80
testb $0x1, %al
jne 0x60893
callq 0x60640
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xe310
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movb $0x1, 0x23(%rsp)
movl $0x10, %edi
ca... | /approvals[P]ApprovalTests/ApprovalTests/namers/ApprovalTestNamer.cpp |
ApprovalTests::Mac::MacDiffReporter::report(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool MacDiffReporter::report(std::string received, std::string approved) const
{
if (!SystemUtils::isMacOs())
{
return false;
}
return FirstWorkingReporter::report(received, approved);
} | subq $0x98, %rsp
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0xa7730
testb $0x1, %al
jne 0x6ae19
movb $0x0, 0x97(%rsp)
jmp 0x6aeaa
movq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0xe310
movq 0x18(%rsp),... | /approvals[P]ApprovalTests/ApprovalTests/reporters/MacReporters.cpp |
ApprovalTests::ReporterFactory::createMap[abi:cxx11]() | ReporterFactory::Reporters ReporterFactory::createMap()
{
Reporters map;
APPROVAL_TESTS_REGISTER_REPORTER(AutoApproveIfMissingReporter);
APPROVAL_TESTS_REGISTER_REPORTER(AutoApproveReporter);
APPROVAL_TESTS_REGISTER_REPORTER(CIBuildOnlyReporter);
APPROVAL_TESTS_REGISTER_REPO... | subq $0x7a8, %rsp # imm = 0x7A8
movq %rdi, 0x220(%rsp)
movq %rdi, %rax
movq %rax, 0x228(%rsp)
movq %rdi, 0x7a0(%rsp)
movb $0x0, 0x79f(%rsp)
callq 0x76bb0
leaq 0x777(%rsp), %rdi
movq %rdi, 0x230(%rsp)
callq 0xed90
movq 0x230(%rsp), %rdx
leaq 0x77b30(%rip), %rsi # 0xe2e53
leaq 0x778(%rsp), %rdi
callq 0xea8... | /approvals[P]ApprovalTests/ApprovalTests/reporters/ReporterFactory.cpp |
fmt::v6::internal::fwrite_fully(void const*, unsigned long, unsigned long, _IO_FILE*) | FMT_FUNC void fwrite_fully(const void* ptr, size_t size, size_t count,
FILE* stream) {
size_t written = std::fwrite(ptr, size, count, stream);
if (written < count) FMT_THROW(system_error(errno, "cannot write to file"));
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0xeec0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0xb536b
movl $0x18, %edi
callq 0xe3c0
movq %... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format-inl.h |
fmt::v6::format_system_error(fmt::v6::internal::buffer<char>&, int, fmt::v6::basic_string_view<char>) | FMT_FUNC void format_system_error(internal::buffer<char>& out, int error_code,
string_view message) FMT_NOEXCEPT {
FMT_TRY {
memory_buffer buf;
buf.resize(inline_buffer_size);
for (;;) {
char* system_message = &buf[0];
int result =
internal::safe_str... | subq $0x2f8, %rsp # imm = 0x2F8
movq %rdx, 0x2e8(%rsp)
movq %rcx, 0x2f0(%rsp)
movq %rdi, 0x2e0(%rsp)
movl %esi, 0x2dc(%rsp)
leaq 0xbf(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xed90
movq 0x20(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x3cd50
jmp 0xb561c
leaq 0xbf(%rsp), %rdi
callq 0xe800
leaq 0xc0(%rsp), %rdi
m... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format-inl.h |
fmt::v6::internal::utf8_decode(char const*, unsigned int*, int*) | FMT_FUNC const char* utf8_decode(const char* buf, uint32_t* c, int* e) {
static const char lengths[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 2, 2, 2, 2, 3, 3, 4, 0};
static const int masks[] = {0x00, 0x7f, 0x1f, 0x0... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
sarl $0x3, %eax
movslq %eax, %rcx
leaq 0x2fe12(%rip), %rax # 0xe5750
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rsp)
movq -0x8(%rsp), %rax
movslq -0x24(%rsp), %... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format-inl.h |
fmt::v6::internal::utf8_to_utf16::utf8_to_utf16(fmt::v6::basic_string_view<char>)::$_0::operator()(char const*) const | FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
auto transcode = [this](const char* p) {
auto cp = uint32_t();
auto error = 0;
p = utf8_decode(p, &cp, &error);
if (error != 0) FMT_THROW(std::runtime_error("invalid utf8"));
if (cp <= 0xFFFF) {
buffer_.push_back(static_cast<wc... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x34(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xb5910
movq %rax, 0x38(%rsp)
cmpl $0x0, 0x30(%rsp)
je 0xb5e30
movl $0x10, %edi
c... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format-inl.h |
void fmt::v6::print<char [28], char const*&, int&, char const*&, char>(_IO_FILE*, char const (&) [28], char const*&, int&, char const*&) | inline void print(std::FILE* f, const S& format_str, Args&&... args) {
return internal::is_unicode<Char>()
? vprint(f, to_string_view(format_str),
internal::make_args_checked<Args...>(format_str, args...))
: internal::vprint_mojibake(
f, to_string_vie... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3ccb0
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq ... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/core.h |
char* fmt::v6::internal::sprintf_format<double>(double, fmt::v6::internal::buffer<char>&, fmt::v6::internal::sprintf_specs) | char* sprintf_format(Double value, internal::buffer<char>& buf,
sprintf_specs specs) {
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
FMT_ASSERT(buf.capacity() != 0, "empty buffer");
// Build format string.
enum { max_format_size = 10 }; // longest format: %#... | subq $0x98, %rsp
movq %rsi, 0x90(%rsp)
movsd %xmm0, 0x88(%rsp)
movq %rdi, 0x80(%rsp)
leaq 0x76(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rsp)
movb $0x25, (%rax)
movb 0x95(%rsp), %al
andb $0x1, %al
testb $0x1, %al
jne 0xb6585
cmpb $0x0, 0x94(%rsp)
jne 0xb659... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/src/format.cc |
char* fmt::v6::internal::sprintf_format<long double>(long double, fmt::v6::internal::buffer<char>&, fmt::v6::internal::sprintf_specs) | char* sprintf_format(Double value, internal::buffer<char>& buf,
sprintf_specs specs) {
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
FMT_ASSERT(buf.capacity() != 0, "empty buffer");
// Build format string.
enum { max_format_size = 10 }; // longest format: %#... | subq $0xb8, %rsp
fldt 0xc0(%rsp)
movq %rsi, 0xb0(%rsp)
fstpt 0xa0(%rsp)
movq %rdi, 0x98(%rsp)
leaq 0x8e(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x80(%rsp)
movb $0x25, (%rax)
movb 0xb5(%rsp), %al
andb $0x1, %al
testb $0x1, %al
jne 0xb6a86
cmpb $0x0, 0xb4(%rsp)
j... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/src/format.cc |
void fmt::v6::internal::basic_writer<fmt::v6::buffer_range<wchar_t>>::int_writer<__int128, fmt::v6::basic_format_specs<wchar_t>>::num_writer::operator()<wchar_t*&>(wchar_t*&) const | void operator()(It&& it) const {
basic_string_view<char_type> s(&sep, sep_size);
// Index of a decimal digit with the least significant digit having
// index 0.
int digit_index = 0;
std::string::const_iterator group = groups.cbegin();
it = format_decimal<char_type>(
... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rsi
movq %rsi, 0x28(%rsp)
addq $0x20, %rsi
leaq 0x78(%rsp), %rdi
movl $0x1, %edx
callq 0xc0440
movq 0x28(%rsp), %rax
movl $0x0, 0x74(%rsp)
movq 0x18(%rax), %rdi
callq 0xe2f0
movq 0x28(%rsp), %rsi
movq %rax, 0x68(%rsp)
movq 0x88(%rsp), %rax
m... | /approvals[P]ApprovalTests/build_O0/CMake/fmt/fmt-src/include/fmt/format.h |
testPosixIO(char const*, char const*, std::vector<char, std::allocator<char>>&) | void testPosixIO(const char* inFile, const char* outFile, std::vector<char>& inBuffer)
{
int in = ::open(inFile, O_RDONLY | O_BINARY);
if (in < 0)
{
std::cout << "Can't open input file: " << inFile << std::endl;
return;
}
int out = ::open(outFile, O_CREAT | O_WRONLY | O_BINARY, 0666... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0xd270
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xdb9d
movq 0xb45f(%rip), %rdi # 0x18fd0
leaq 0x64cb(%rip), %rsi # 0x14043
callq 0... | /tcbrindle[P]modern-io/benchmark/adam_benchmark.cpp |
testModernIO(char const*, char const*, std::vector<char, std::allocator<char>>&) | void testModernIO(const char* inFile, const char* outFile, std::vector<char>& inBuffer)
{
auto in = io::file{inFile, io::open_mode::read_only};
auto out = io::file{outFile,
io::open_mode::write_only | io::open_mode::create};
const auto inFileSize = io::seek(in, 0, io::seek_mode::end... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
leaq -0x8(%rbp), %rsi
movl $0x2, %edx
callq 0xe6a0
movq -0xd8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movl $0x1, %edx
movl $0x180, %ecx # imm = 0x180
callq ... | /tcbrindle[P]modern-io/benchmark/adam_benchmark.cpp |
main | int main(int argc, char* argv[])
{
std::vector<std::string> args(argv, argv + argc);
if (args.size() != 4)
{
std::cout << "Usage: " << args[0] << " copy_method (c, posix, c++) in_file number_of_times" << std::endl;
return 1;
}
typedef std::map<std::string, std::function<void (const ... | pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x240(%rbp)
movslq -0x8(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x238(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x230(%rbp)
callq 0xe970
mov... | /tcbrindle[P]modern-io/benchmark/adam_benchmark.cpp |
server_sent | static void server_sent(Plug *plug, size_t bufsize)
{
#ifdef FIXME
server *srv = container_of(plug, server, plug);
/*
* If the send backlog on the SSH socket itself clears, we should
* unthrottle the whole world if it was throttled. Also trigger an
* extra call to the consumer of the BPP's outpu... | retq
| /codexns[P]putty/ssh/server.c |
sesschan_run_subsystem | bool sesschan_run_subsystem(Channel *chan, ptrlen subsys)
{
sesschan *sess = container_of(chan, sesschan, chan);
if (ptrlen_eq_string(subsys, "sftp") && sess->sftpserver_vt) {
sess->sftpsrv = sftpsrv_new(sess->sftpserver_vt);
sess->chan.vt = &sftp_channelvt;
logevent(sess->parent_logctx... | pushq %rbx
movq %rdi, %rbx
leaq 0x50ebb(%rip), %rax # 0x65d9d
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x60c64
testb %al, %al
je 0x14f27
movq -0x5b8(%rbx), %rdi
testq %rdi, %rdi
je 0x14f27
callq *(%rdi)
movq %rax, -0x18(%rbx)
leaq 0x7c423(%rip), %rax # 0x91330
movq %rax, (%rbx)
movq -0x5d0(%rbx), %... | /codexns[P]putty/ssh/sesschan.c |
uss_mkdir | static void uss_mkdir(SftpServer *srv, SftpReplyBuilder *reply,
ptrlen path, struct fxp_attrs attrs)
{
UnixSftpServer *uss = container_of(srv, UnixSftpServer, srv);
char *pathstr = mkstr(path);
int status = mkdir(pathstr, GET_PERMISSIONS(attrs, 0777));
free(pathstr);
if (stat... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rdi
movq %rsi, %rbx
movq %rcx, %rsi
callq 0x60ec1
movq %rax, %r14
testb $0x4, 0x20(%rsp)
movl $0x1ff, %esi # imm = 0x1FF
je 0x16d31
movl 0x40(%rsp), %esi
movq %r14, %rdi
callq 0xea30
movl %eax, %ebp
movq %r14, %rdi
callq 0xe370
testl %ebp, %ebp
js 0x16d53
movq (%r... | /codexns[P]putty/unix/sftpserver.c |
get_ttymodes_from_conf | struct ssh_ttymodes get_ttymodes_from_conf(Seat *seat, Conf *conf)
{
struct ssh_ttymodes modes;
size_t i;
static const struct mode_name_type {
const char *mode;
int opcode;
enum { TYPE_CHAR, TYPE_BOOL } type;
} modes_names_types[] = {
#define TTYMODE_CHAR(name, val, inde... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
movl $0x50c, %edx # imm = 0x50C
xorl %esi, %esi
callq 0xe090
movl $0xc, %r12d
leaq 0x76bf8(%rip), %r15 # 0x91650
movq -0xc(%r12,%r15), %rbp
movq 0x10(%rsp), %rdi
... | /codexns[P]putty/ssh/common.c |
ssh1_channel_close_local | static void ssh1_channel_close_local(struct ssh1_channel *c,
const char *reason)
{
struct ssh1_connection_state *s = c->connlayer;
PacketProtocolLayer *ppl = &s->ppl; /* for ppl_logevent */
char *msg = chan_log_close_msg(c->chan);
if (msg != NULL) {
ppl_loge... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testq %rax, %rax
je 0x1c955
movq %rax, %r14
movq 0x130(%r12), %r12
testq %r15, %r15
leaq 0x5b764(%rip), %rax # 0x78083
leaq 0x50e81(%rip), %rdx # 0x6... | /codexns[P]putty/ssh/connection1.c |
ssh1_lportfwd_open | static SshChannel *ssh1_lportfwd_open(
ConnectionLayer *cl, const char *hostname, int port,
const char *description, const SocketPeerInfo *pi, Channel *chan)
{
struct ssh1_connection_state *s =
container_of(cl, struct ssh1_connection_state, cl);
PacketProtocolLayer *ppl = &s->ppl; /* for ppl_log... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %rcx, (%rsp)
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
leaq -0xe0(%rdi), %rbp
movl $0x1, %edi
movl $0x38, %esi
xorl %edx, %edx
callq 0x60434
movq %rax, %r14
movq %rbp, (%rax)
movq %rax, %rdi
callq 0x1c0d8
movb $0x1, ... | /codexns[P]putty/ssh/connection1.c |
ssh1sesschan_send_exit_status | static void ssh1sesschan_send_exit_status(SshChannel *sc, int status)
{
struct ssh1_connection_state *s =
container_of(sc, struct ssh1_connection_state, mainchan_sc);
PktOut *pktout;
pktout = ssh_bpp_new_pktout(s->ppl.bpp, SSH1_SMSG_EXIT_STATUS);
put_uint32(pktout, status);
pq_push(s->ppl.o... | pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0xd8(%rdi), %rax
movq (%rax), %rax
movl $0x14, %edi
callq *0x18(%rax)
movq %rax, %r15
leaq 0x60(%rax), %rdi
movslq %ebx, %rsi
callq 0x5fe5c
movq 0xe8(%r14), %rdi
addq $0x40, %r15
movq %r15, %rsi
callq 0x1a554
movb $0x1, 0x89(%r14)
popq %rbx
popq %r14... | /codexns[P]putty/ssh/connection1-server.c |
ssh2_connection_parse_channel_open | ChanopenResult ssh2_connection_parse_channel_open(
struct ssh2_connection_state *s, ptrlen type,
PktIn *pktin, SshChannel *sc)
{
if (ptrlen_eq_string(type, "session")) {
return chan_open_session(s, sc);
} else if (ptrlen_eq_string(type, "direct-tcpip")) {
ptrlen dstaddr = get_string(pkti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x44b65(%rip), %rdx # 0x70651
movq %rbp, %rdi
movq %rcx, %rsi
callq 0x60c64
testb %al, %al
je 0x2bb43
movq 0x128(%r14), %r12
leaq 0x40... | /codexns[P]putty/ssh/connection2-server.c |
ssh2_connection_parse_global_request | bool ssh2_connection_parse_global_request(
struct ssh2_connection_state *s, ptrlen type, PktIn *pktin)
{
if (ptrlen_eq_string(type, "tcpip-forward")) {
char *host = mkstr(get_string(pktin));
unsigned port = get_uint32(pktin);
/* In SSH-2, the host/port we listen on are the same host/port... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x40499(%rip), %rdx # 0x6c168
movq %rsi, %rdi
movq %r15, %rsi
callq 0x60c64
testb %al, %al
je 0x2bd1d
addq $0x30, %r14
movq %r14, %rdi
callq 0x601ab
movq %rax, %rdi
movq %rdx, %rsi
callq 0x60e... | /codexns[P]putty/ssh/connection2-server.c |
ssh2_portfwd_chanopen | PktOut *ssh2_portfwd_chanopen(
struct ssh2_connection_state *s, struct ssh2_channel *c,
const char *hostname, int port,
const char *description, const SocketPeerInfo *pi)
{
PacketProtocolLayer *ppl = &s->ppl; /* for ppl_logevent */
PktOut *pktout;
/*
* In server mode, this function is call... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
testq %r9, %r9
je 0x2bdbf
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0x2bdbf
movq 0x128(%rdi), %r12
leaq 0x403c5(%rip), %rdi # 0x6c176
movq %r14, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x5f5a0
jm... | /codexns[P]putty/ssh/connection2-server.c |
ssh2channel_send_exit_signal | void ssh2channel_send_exit_signal(
SshChannel *sc, ptrlen signame, bool core_dumped, ptrlen msg)
{
struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc);
struct ssh2_connection_state *s = c->connlayer;
PktOut *pktout = ssh2_chanreq_init(c, "exit-signal", NULL, NULL);
put_stringpl(pktou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq -0xb0(%rdi), %rax
movq %rax, 0x10(%rsp)
addq $-0xb0, %rdi
leaq 0x3c96a(%rip), %rsi # 0x68a8c
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1cf8e
movq %... | /codexns[P]putty/ssh/connection2-server.c |
ssh2channel_send_exit_signal_numeric | void ssh2channel_send_exit_signal_numeric(
SshChannel *sc, int signum, bool core_dumped, ptrlen msg)
{
struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc);
struct ssh2_connection_state *s = c->connlayer;
PktOut *pktout = ssh2_chanreq_init(c, "exit-signal", NULL, NULL);
put_uint32(pkt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq -0xb0(%rdi), %rax
movq %rax, (%rsp)
addq $-0xb0, %rdi
leaq 0x3c8ce(%rip), %rsi # 0x68a8c
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1cf8e
movq %rax, %r12
leaq 0x60(%rax), %r... | /codexns[P]putty/ssh/connection2-server.c |
finalise_and_sign_exhash | static strbuf *finalise_and_sign_exhash(struct ssh2_transport_state *s)
{
strbuf *sb;
ssh2transport_finalise_exhash(s);
sb = strbuf_new();
ssh_key_sign(
s->hkey, make_ptrlen(s->exchange_hash, s->kex_alg->hash->hlen),
s->hkflags, BinarySink_UPCAST(sb));
return sb;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x24c5a
callq 0x6145c
movq %rax, %r14
movq 0x2e8(%rbx), %rdi
leaq 0x310(%rbx), %rsi
movq 0xc8(%rbx), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rdx
movl 0x2f0(%rbx), %ecx
leaq 0x18(%r14), %r8
movq (%rdi), %rax
callq *0x28(%rax)
movq %r14, %rax
addq $0x8, %rsp
pop... | /codexns[P]putty/ssh/kex2-server.c |
ssh1_login_server_new | PacketProtocolLayer *ssh1_login_server_new(
PacketProtocolLayer *successor_layer, RSAKey *hostkey,
AuthPolicy *authpolicy, const SshServerConfig *ssc)
{
struct ssh1_login_server_state *s = snew(struct ssh1_login_server_state);
memset(s, 0, sizeof(*s));
s->ppl.vt = &ssh1_login_server_vtable;
s->... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x1, %edi
movl $0x138, %esi # imm = 0x138
xorl %edx, %edx
callq 0x60434
movq %rax, %r13
movl $0x138, %edx # imm = 0x138
movq %rax, %rdi
xorl %esi, %esi
callq 0xe090
leaq 0xd... | /codexns[P]putty/ssh/login1-server.c |
ssh1_login_server_free | static void ssh1_login_server_free(PacketProtocolLayer *ppl)
{
struct ssh1_login_server_state *s =
container_of(ppl, struct ssh1_login_server_state, ppl);
if (s->successor_layer)
ssh_ppl_free(s->successor_layer);
if (s->servkey_generated_here && s->servkey) {
freersakey(s->servkey)... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq -0xc8(%rdi), %rdi
testq %rdi, %rdi
je 0x2cf59
callq 0x1b2bf
cmpb $0x1, -0x38(%rbx)
jne 0x2cf76
movq -0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x2cf76
callq 0x56e14
movq -0x48(%rbx), %rdi
callq 0x604a1
leaq -0xd0(%rbx), %r14
leaq -0x94(%rbx), %rdi
movl $0x20, %esi
callq ... | /codexns[P]putty/ssh/login1-server.c |
ssh1_login_server_process_queue | static void ssh1_login_server_process_queue(PacketProtocolLayer *ppl)
{
struct ssh1_login_server_state *s =
container_of(ppl, struct ssh1_login_server_state, ppl);
PktIn *pktin;
PktOut *pktout;
int i;
/* Filter centrally handled messages off the front of the queue on
* every entry to t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1bb88
testb %al, %al
je 0x2cfcc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl -0xd0(%rbx), %eax
cmpl $0x10f, %eax # imm = 0x10F
jg 0x2d08f
testl %eax, %eax
je 0x2d0bf
c... | /codexns[P]putty/ssh/login1-server.c |
ssh_transient_hostkey_cache_free | void ssh_transient_hostkey_cache_free(ssh_transient_hostkey_cache *thc)
{
struct ssh_transient_hostkey_cache_entry *ent;
while ((ent = delpos234(thc->cache, 0)) != NULL) {
strbuf_free(ent->pub_blob);
sfree(ent);
}
freetree234(thc->cache);
sfree(thc);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %esi, %esi
callq 0x6263d
testq %rax, %rax
je 0x2da56
movq %rax, %r14
movq 0x8(%r14), %rdi
callq 0x614dc
movq %r14, %rdi
callq 0x604a1
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x6263d
movq %rax, %r14
testq %rax, %rax
jne 0x2da33
movq (%rbx), %rdi
cal... | /codexns[P]putty/ssh/transient-hostkey-cache.c |
provableprime_add_progress_phase | static ProgressPhase provableprime_add_progress_phase(
const PrimeGenerationPolicy *policy,
ProgressReceiver *prog, unsigned bits)
{
/*
* Estimating the cost of making a _provable_ prime is difficult
* because of all the recursions to smaller sizes.
*
* Once you have enough factors of p-... | pushq %rbx
movq %rsi, %rbx
movl %edx, %eax
cvtsi2sd %rax, %xmm0
movsd 0x3f182(%rip), %xmm1 # 0x6ceb0
callq 0xe980
mulsd 0x3f17d(%rip), %xmm0 # 0x6ceb8
movq (%rbx), %rax
movq (%rax), %rax
movq %rbx, %rdi
popq %rbx
jmpq *%rax
| /codexns[P]putty/keygen/prime.c |
provableprime_generate_inner | static mp_int *provableprime_generate_inner(
ProvablePrimeContext *ppc, PrimeCandidateSource *pcs,
ProgressReceiver *prog, double progress_origin, double progress_scale)
{
unsigned bits = pcs_get_bits(pcs);
assert(bits > 1);
if (bits <= 32) {
debug_f("ppgi(%u) -> small", bits);
retu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x50(%rsp)
movsd %xmm0, 0x58(%rsp)
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2ece7
cmpl $0x1, %eax
jbe 0x2e433
cmpl $0x20, %eax
ja 0x2de73
movq (%r15), %r14
movq %rbx, %rdi
callq 0x2ece7
cmpl $0... | /codexns[P]putty/keygen/prime.c |
arcfour_block | static void arcfour_block(void *handle, void *vblk, int len)
{
unsigned char *blk = (unsigned char *)vblk;
ArcfourContext *ctx = (ArcfourContext *)handle;
unsigned k;
unsigned char tmp, i, j, *s;
s = ctx->s;
i = ctx->i; j = ctx->j;
for (k = 0; (int)k < len; k++) {
i = (i + 1) & 0xf... | movb (%rdi), %al
movb 0x1(%rdi), %cl
testl %edx, %edx
jle 0x43cb3
pushq %rbx
movl %edx, %edx
negq %rdx
movl $0x1, %r8d
incb %al
movzbl %al, %r9d
movb 0x2(%rdi,%r9), %r10b
addb %r10b, %cl
movzbl %cl, %r11d
movb 0x2(%rdi,%r11), %bl
movb %bl, 0x2(%rdi,%r9)
movb %r10b, 0x2(%rdi,%r11)
addb 0x2(%rdi,%r9), %r10b
movzbl %r10b,... | /codexns[P]putty/crypto/arcfour.c |
hprime_final | static void hprime_final(ssh_hash *h, unsigned length, void *vout)
{
uint8_t *out = (uint8_t *)vout;
while (length > 64) {
uint8_t hashbuf[64];
ssh_hash_final(h, hashbuf);
memcpy(out, hashbuf, 32);
out += 32;
length -= 32;
h = blake2b_new_general(length > 64 ? ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x41, %esi
jb 0x43dc1
movl %esi, %ebp
movq %rsp, %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
m... | /codexns[P]putty/crypto/argon2.c |
argon2 | void argon2(Argon2Flavour flavour, uint32_t mem, uint32_t passes,
uint32_t parallel, uint32_t taglen,
ptrlen P, ptrlen S, ptrlen K, ptrlen X, strbuf *out)
{
argon2_internal(parallel, taglen, mem, passes, flavour,
P, S, K, X, strbuf_append(out, taglen));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x11b8, %rsp # imm = 0x11B8
movl %r8d, %ebp
movl %ecx, %r12d
movl %edx, %ebx
movl %esi, 0x58(%rsp)
movl %edi, %r15d
movl %r8d, %esi
movq %r9, %rdi
callq 0x61380
movq %rax, 0xc8(%rsp)
movq 0x11f0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x11... | /codexns[P]putty/crypto/argon2.c |
blake2b_new_inner | static ssh_hash *blake2b_new_inner(unsigned hashlen)
{
assert(hashlen <= ssh_blake2b.hlen);
blake2b *s = snew(blake2b);
s->hash.vt = &ssh_blake2b;
s->hashlen = hashlen;
BinarySink_INIT(s, blake2b_write);
BinarySink_DELEGATE_INIT(&s->hash, s);
return &s->hash;
} | pushq %rbx
cmpl $0x41, %edi
jae 0x45193
movl %edi, %ebx
movl $0x1, %edi
movl $0x108, %esi # imm = 0x108
xorl %edx, %edx
callq 0x60434
leaq 0xf8(%rax), %rcx
leaq 0x4e38a(%rip), %rdx # 0x934e0
movq %rdx, 0xf8(%rax)
movl %ebx, 0x40(%rax)
leaq 0xe0(%rax), %rdx
leaq 0x199(%rip), %rsi # 0x45307
movq %rsi... | /codexns[P]putty/crypto/blake2.c |
blake2b_digest | static void blake2b_digest(ssh_hash *hash, uint8_t *digest)
{
blake2b *s = container_of(hash, blake2b, hash);
memset(s->block + s->used, 0, sizeof(s->block) - s->used);
f_outer(s->h, s->block, s->lenhi, s->lenlo, 1);
uint8_t hash_pre[128];
for (unsigned i = 0; i < 8; i++)
PUT_64BIT_LSB_FIR... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xf8(%rdi), %r15
leaq -0xb4(%rdi), %r12
movq -0x30(%rdi), %rax
addq %rax, %rdi
addq $-0xb4, %rdi
movl $0x80, %edx
subq %rax, %rdx
xorl %r13d, %r13d
xorl %esi, %esi
callq 0xe090
movq -0x28(%r14), %rdx
movq -0x20... | /codexns[P]putty/crypto/blake2.c |
blake2b_write | static void blake2b_write(BinarySink *bs, const void *vp, size_t len)
{
blake2b *s = BinarySink_DOWNCAST(bs, blake2b);
const uint8_t *p = vp;
while (len > 0) {
if (s->used == sizeof(s->block)) {
f_outer(s->h, s->block, s->lenhi, s->lenlo, 0);
s->used = 0;
}
... | testq %rdx, %rdx
je 0x453a6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0xe0(%rdi), %r12
leaq -0x9c(%rdi), %r13
movq -0x18(%rdi), %rdi
cmpq $0x80, %rdi
jne 0x4535f
movq -0x10(%r15), %rdx
movq -0x8(%r15), %rcx
movq %r12, %rdi
movq %r1... | /codexns[P]putty/crypto/blake2.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.