address string | name string | code string | asm string | file string | bin string |
|---|---|---|---|---|---|
0xc0fe | op_head | const OpusHead *op_head(const OggOpusFile *_of,int _li){
if(OP_UNLIKELY(_li>=_of->nlinks))_li=_of->nlinks-1;
if(!_of->seekable)_li=0;
return &_of->links[_li<0?_of->cur_link:_li].head;
} | movl 0x2c(%rdi), %eax
cmpl %esi, %eax
jle 0xc12a
movl 0x28(%rdi), %eax
testl %eax, %eax
cmovel %eax, %esi
movq 0x30(%rdi), %rax
testl %esi, %esi
jns 0xc118
movl 0x7c(%rdi), %esi
movslq %esi, %rcx
imulq $0x178, %rcx, %rcx # imm = 0x178
addq %rcx, %rax
addq $0x34, %rax
retq
decl %eax
movl %eax, %esi
jmp 0xc105
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xc130 | op_tags | const OpusTags *op_tags(const OggOpusFile *_of,int _li){
if(OP_UNLIKELY(_li>=_of->nlinks))_li=_of->nlinks-1;
if(!_of->seekable){
if(_of->ready_state<OP_STREAMSET&&_of->ready_state!=OP_PARTOPEN){
return NULL;
}
_li=0;
}
else if(_li<0)_li=_of->ready_state>=OP_STREAMSET?_of->cur_link:0;
return ... | movl %esi, %eax
movl 0x2c(%rdi), %ecx
cmpl %esi, %ecx
jle 0xc17c
cmpl $0x0, 0x28(%rdi)
je 0xc150
testl %eax, %eax
jns 0xc165
xorl %eax, %eax
cmpl $0x3, 0x78(%rdi)
jl 0xc165
movl 0x7c(%rdi), %eax
jmp 0xc165
movl 0x78(%rdi), %eax
cmpl $0x3, %eax
setge %cl
cmpl $0x1, %eax
sete %dl
xorl %eax, %eax
orb %cl, %dl
je 0xc17b
mo... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xc182 | op_seek_helper | static int op_seek_helper(OggOpusFile *_of,opus_int64 _offset){
if(_offset==_of->offset)return 0;
if(_of->callbacks.seek==NULL
||(*_of->callbacks.seek)(_of->stream,_offset,SEEK_SET)){
return OP_EREAD;
}
_of->offset=_offset;
ogg_sync_reset(&_of->oy);
return 0;
} | pushq %rbp
pushq %r14
pushq %rbx
xorl %ebp, %ebp
cmpq %rsi, 0x48(%rdi)
je 0xc1c0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl $0xffffff80, %ebp # imm = 0xFFFFFF80
testq %rax, %rax
je 0xc1c0
movq %rsi, %r14
movq 0x20(%rbx), %rdi
xorl %edx, %edx
callq *%rax
testl %eax, %eax
jne 0xc1c0
movq %r14, 0x48(%rbx)
addq $0x58,... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xc1c7 | op_pcm_seek | int op_pcm_seek(OggOpusFile *_of,ogg_int64_t _pcm_offset){
const OggOpusLink *link;
ogg_int64_t pcm_start;
ogg_int64_t target_gp;
ogg_int64_t prev_packet_gp;
ogg_int64_t skip;
ogg_int64_t diff;
int op_count;
int op_pos;
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl 0x78(%rdi), %r12d
cmpl $0x2, %r12d
jl 0xc3fd
cmpl $0x0, 0x28(%rdi)
je 0xc40c
testq %rsi, %rsi
js 0xc3fd
movl 0x2c(%rdi), %eax
movq %rdi, 0x20(%rsp)
movq 0x30(%rdi), %rbp
xorl %r15d, %r15d
movl %eax, %ecx
subl %r15d, %ecx
sarl %ecx
a... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xd293 | op_set_decode_callback | void op_set_decode_callback(OggOpusFile *_of,
op_decode_cb_func _decode_cb,void *_ctx){
_of->decode_cb=_decode_cb;
_of->decode_cb_ctx=_ctx;
} | movq %rsi, 0x3220(%rdi)
movq %rdx, 0x3228(%rdi)
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xd2a2 | op_set_gain_offset | int op_set_gain_offset(OggOpusFile *_of,
int _gain_type,opus_int32 _gain_offset_q8){
if(_gain_type!=OP_HEADER_GAIN&&_gain_type!=OP_ALBUM_GAIN
&&_gain_type!=OP_TRACK_GAIN&&_gain_type!=OP_ABSOLUTE_GAIN){
return OP_EINVAL;
}
_of->gain_type=_gain_type;
/*The sum of header gain and track gain lies in the ran... | leal -0xbbf(%rsi), %eax
cmpl $0x3, %eax
jb 0xd2b6
movl $0xffffff7d, %eax # imm = 0xFFFFFF7D
testl %esi, %esi
jne 0xd2e5
pushq %rax
movl %esi, 0x3258(%rdi)
movl $0x17fff, %eax # imm = 0x17FFF
cmpl %eax, %edx
cmovll %edx, %eax
cmpl $0xfffe8003, %eax # imm = 0xFFFE8003
movl $0xfffe8002, %ecx # i... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xd2e6 | op_update_gain | static void op_update_gain(OggOpusFile *_of){
OpusHead *head;
opus_int32 gain_q8;
int li;
/*If decode isn't ready, then we'll apply the gain when we initialize the
decoder.*/
if(_of->ready_state<OP_INITSET)return;
gain_q8=_of->gain_offset_q8;
li=_of->seekable?_of->cur_link:0;
head=&_of->... | cmpl $0x4, 0x78(%rdi)
jl 0xd3b4
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
je 0xd306
movslq 0x7c(%rbx), %rcx
jmp 0xd308
xorl %ecx, %ecx
movl 0x325c(%rbx), %ebp
movq 0x30(%rbx), %rax
imulq $0x178, %rcx, %rcx # imm = 0x178
leaq (%rax,%rcx), %r15
addq $0x34, %r15
movl... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xd3b5 | op_set_dither_enabled | void op_set_dither_enabled(OggOpusFile *_of,int _enabled){
#if !defined(OP_FIXED_POINT)
_of->dither_disabled=!_enabled;
if(!_enabled)_of->dither_mute=65;
#endif
} | xorl %eax, %eax
testl %esi, %esi
sete %al
movl %eax, 0x3388(%rdi)
je 0xd3c5
retq
movl $0x41, 0x3384(%rdi)
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xd3d0 | op_read | int op_read(OggOpusFile *_of,opus_int16 *_pcm,int _buf_size,int *_li){
return op_filter_read_native(_of,_pcm,_buf_size,op_float2short_filter,_li);
} | movq %rcx, %r8
leaq 0x5(%rip), %rcx # 0xd3df
jmp 0x55e4
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xd3df | op_float2short_filter | static int op_float2short_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
float *_src,int _nsamples,int _nchannels){
opus_int16 *dst;
int ci;
int i;
dst=(opus_int16 *)_dst;
if(OP_UNLIKELY(_nsamples*_nchannels>_dst_sz))_nsamples=_dst_sz/_nchannels;
# if defined(OP_SOFT_CLIP)
if(_of->state_ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %ebp
movl %r8d, %r15d
movq %rcx, 0x18(%rsp)
movq %rsi, 0x40(%rsp)
movl %r9d, %eax
imull %r8d, %eax
cmpl %edx, %eax
jg 0xd7e3
cmpl %ebp, 0x338c(%rdi)
sete %al
testl %ebp, %ebp
setle %cl
orb %al, %cl
movq %rdi, 0x8(%rsp)
jne 0xd... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xd7f0 | op_read_float | int op_read_float(OggOpusFile *_of,float *_pcm,int _buf_size,int *_li){
_of->state_channel_count=0;
return op_read_native(_of,_pcm,_buf_size,_li);
} | movl $0x0, 0x338c(%rdi)
jmp 0x5674
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xd7ff | op_float2short_stereo_filter | static int op_float2short_stereo_filter(OggOpusFile *_of,
void *_dst,int _dst_sz,op_sample *_src,int _nsamples,int _nchannels){
opus_int16 *dst;
dst=(opus_int16 *)_dst;
if(_nchannels==1){
int i;
_nsamples=op_float2short_filter(_of,dst,_dst_sz>>1,_src,_nsamples,1);
for(i=_nsamples;i-->0;)dst[2*i+0]=ds... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x1, %r9d
jne 0xd85b
sarl %ebp
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r14, %rcx
movl $0x1, %r9d
callq 0xd3df
testl %eax, %eax
jle 0xd850
movl %eax, %ecx
incq %rcx
movzwl -0x4(%rbx,... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xd8a0 | op_stereo_filter | static int op_stereo_filter(OggOpusFile *_of,void *_dst,int _dst_sz,
op_sample *_src,int _nsamples,int _nchannels){
(void)_of;
_nsamples=OP_MIN(_nsamples,_dst_sz>>1);
if(_nchannels==2)memcpy(_dst,_src,_nsamples*2*sizeof(*_src));
else{
float *dst;
int i;
dst=(float *)_dst;
if(_nchannels==1){
... | pushq %rbx
movl %edx, %ebx
sarl %ebx
cmpl %r8d, %ebx
cmovgel %r8d, %ebx
cmpl $0x2, %r9d
je 0xd8e1
cmpl $0x1, %r9d
jne 0xd8fb
testl %ebx, %ebx
jle 0xd97d
movl %ebx, %eax
xorl %edx, %edx
movss (%rcx,%rdx,4), %xmm0
movss %xmm0, 0x4(%rsi,%rdx,8)
movss %xmm0, (%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xd8c4
jmp 0xd97d
lea... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xd981 | op_find_initial_pcm_offset | static int op_find_initial_pcm_offset(OggOpusFile *_of,
OggOpusLink *_link,ogg_page *_og){
ogg_page og;
opus_int64 page_offset;
ogg_int64_t pcm_start;
ogg_int64_t prev_packet_gp;
ogg_int64_t cur_page_gp;
ogg_uint32_t serialno;
opus_int32 total_duration;
int durations[255];
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x468, %rsp # imm = 0x468
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
testq %rdx, %rdx
leaq 0x40(%rsp), %r12
cmovneq %rdx, %r12
leaq 0xa8(%rdi), %rax
movq %rax, 0x10(%rsp)
movl 0x220(%rdi), %r13d
xorl %ebp, %ebp
xorl %ebx, %ebx
movq 0x50(%r14),... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xdc8c | op_get_next_page | static opus_int64 op_get_next_page(OggOpusFile *_of,ogg_page *_og,
opus_int64 _boundary){
while(_boundary<=0||_of->offset<_boundary){
int more;
more=ogg_sync_pageseek(&_of->oy,_og);
/*Skipped (-more) bytes.*/
if(OP_UNLIKELY(more<0))_of->offset-=more;
else if(more==0){
int read_nbytes;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x58(%rdi), %r12
movq %rdx, %rax
sarq $0x3f, %rax
orq $-0x89, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
testq %rbx, %rbx
jle 0xdccd
cmpq %rbx, 0x48(%r15)
jge 0xddba
movq %r12, %r... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xddd3 | op_rescale64 | static opus_int64 op_rescale64(opus_int64 _x,opus_int64 _from,opus_int64 _to){
opus_int64 frac;
opus_int64 ret;
int i;
if(_x>=_from)return _to;
if(_x<=0)return 0;
frac=0;
for(i=0;i<63;i++){
frac<<=1;
OP_ASSERT(_x<=_from);
if(_x>=_from>>1){
_x-=_from-_x;
frac|=1;
}
el... | cmpq %rsi, %rdi
jge 0xde3f
testq %rdi, %rdi
jle 0xde43
movq %rsi, %rax
sarq %rax
movl $0x3f, %r8d
xorl %ecx, %ecx
leaq (%rdi,%rdi), %r9
movq %r9, %r10
subq %rsi, %r10
xorl %r11d, %r11d
cmpq %rax, %rdi
cmovlq %r9, %r10
setge %r11b
leaq (%r11,%rcx,2), %rcx
movq %r10, %rdi
decl %r8d
jne 0xddeb
movl %edx, %esi
andl $0x1, %... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xde46 | op_get_link_from_serialno | static int op_get_link_from_serialno(const OggOpusFile *_of,int _cur_link,
opus_int64 _page_offset,ogg_uint32_t _serialno){
const OggOpusLink *links;
int nlinks;
int li_lo;
int li_hi;
OP_ASSERT(_of->seekable);
links=_of->links;
nlinks=_of->nlinks;
li_lo=0;
... | movq 0x30(%rdi), %r8
movl 0x2c(%rdi), %edi
leal 0x1(%rsi), %eax
cmpl %edi, %eax
jge 0xde64
movslq %eax, %r9
imulq $0x178, %r9, %r9 # imm = 0x178
cmpq %rdx, (%r8,%r9)
jg 0xde66
movl %edi, %eax
xorl %edi, %edi
movslq %esi, %r9
imulq $0x178, %r9, %r9 # imm = 0x178
cmpq %rdx, (%r8,%r9)
jg 0xde7c
movl %esi, %e... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xdea9 | op_buffer_continued_data | static void op_buffer_continued_data(OggOpusFile *_of,ogg_page *_og){
ogg_packet op;
ogg_stream_pagein(&_of->os,_og);
/*Drain any packets that did end on this page (and ignore holes).
We only care about the continued packet data.*/
while(ogg_stream_packetout(&_of->os,&op));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
addq $0xa8, %rbx
movq %rbx, %rdi
callq 0x34d0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3510
testl %eax, %eax
jne 0xdec7
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xdede | op_init_buffer | static int op_init_buffer(OggOpusFile *_of){
int nchannels_max;
if(_of->seekable){
const OggOpusLink *links;
int nlinks;
int li;
links=_of->links;
nlinks=_of->nlinks;
nchannels_max=1;
for(li=0;li<nlinks;li++){
nchannels_max=OP_MAX(nchannels_max,links[l... | pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
je 0xdf25
movslq 0x2c(%rbx), %rcx
testq %rcx, %rcx
jle 0xdf2c
movq 0x30(%rbx), %rax
imulq $0x178, %rcx, %rcx # imm = 0x178
movl $0x1, %edx
xorl %esi, %esi
movl %edx, %edi
movl 0x38(%rax,%rsi), %edx
cmpl %edx, %edi
cmovgl %edi, %edx
addq $0x178, %rsi # imm... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xdf4c | op_fopen | void *op_fopen(OpusFileCallbacks *_cb,const char *_path,const char *_mode){
FILE *fp;
#if !defined(_WIN32)
fp=fopen(_path,_mode);
#else
fp=NULL;
{
wchar_t *wpath;
wchar_t *wmode;
wpath=op_utf8_to_utf16(_path);
wmode=op_utf8_to_utf16(_mode);
if(wmode==NULL)errno=EINVAL;
else if(wpath==NUL... | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x33c0
testq %rax, %rax
je 0xdf75
movups 0x6d99(%rip), %xmm0 # 0x14d00
movups %xmm0, 0x10(%rbx)
movups 0x6d7e(%rip), %xmm0 # 0x14cf0
movups %xmm0, (%rbx)
popq %rbx
retq
| /xiph[P]opusfile/src/stream.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xdf77 | op_fdopen | void *op_fdopen(OpusFileCallbacks *_cb,int _fd,const char *_mode){
FILE *fp;
fp=fdopen(_fd,_mode);
if(fp!=NULL)*_cb=*op_get_file_callbacks(fp);
return fp;
} | pushq %rbx
movq %rdi, %rbx
movl %esi, %edi
movq %rdx, %rsi
callq 0x3350
testq %rax, %rax
je 0xdf9f
movups 0x6d6f(%rip), %xmm0 # 0x14d00
movups %xmm0, 0x10(%rbx)
movups 0x6d54(%rip), %xmm0 # 0x14cf0
movups %xmm0, (%rbx)
popq %rbx
retq
| /xiph[P]opusfile/src/stream.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xdfa1 | op_freopen | void *op_freopen(OpusFileCallbacks *_cb,const char *_path,const char *_mode,
void *_stream){
FILE *fp;
#if !defined(_WIN32)
fp=freopen(_path,_mode,(FILE *)_stream);
#else
fp=NULL;
{
wchar_t *wpath;
wchar_t *wmode;
wpath=op_utf8_to_utf16(_path);
wmode=op_utf8_to_utf16(_mode);
if(wmode==NULL)... | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x32d0
testq %rax, %rax
je 0xdfcd
movups 0x6d41(%rip), %xmm0 # 0x14d00
movups %xmm0, 0x10(%rbx)
movups 0x6d26(%rip), %xmm0 # 0x14cf0
movups %xmm0, (%rbx)
popq %rbx
retq
| /xiph[P]opusfile/src/stream.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xdfcf | op_mem_stream_create | void *op_mem_stream_create(OpusFileCallbacks *_cb,
const unsigned char *_data,size_t _size){
OpusMemStream *stream;
if(_size>OP_MEM_SIZE_MAX)return NULL;
stream=(OpusMemStream *)_ogg_malloc(sizeof(*stream));
if(stream!=NULL){
*_cb=*&OP_MEM_CALLBACKS;
stream->data=_data;
stream->size=_size;
stre... | testq %rdx, %rdx
js 0xe01d
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x3460
testq %rax, %rax
je 0xe017
movups 0x6ce8(%rip), %xmm0 # 0x14ce0
movups %xmm0, 0x10(%r15)
movups 0x6ccc(%rip), %xmm0 # 0x14cd0
movups %xmm0, (%r15)
movq %r14, (%rax)
movq %rbx... | /xiph[P]opusfile/src/stream.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe020 | op_fread | static int op_fread(void *_stream,unsigned char *_ptr,int _buf_size){
FILE *stream;
size_t ret;
/*Check for empty read.*/
if(_buf_size<=0)return 0;
stream=(FILE *)_stream;
ret=fread(_ptr,1,_buf_size,stream);
OP_ASSERT(ret<=(size_t)_buf_size);
/*If ret==0 and !feof(stream), there was a read error.*/
... | pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xe05b
movq %rsi, %rax
movq %rdi, %r14
movl %edx, %edx
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rcx
callq 0x34e0
movq %rax, %rbx
testq %rax, %rax
jne 0xe05d
movq %r14, %rdi
callq 0x3530
testl %eax, %eax
jne 0xe05d
movl $0xffffff80, %ebx # imm = 0xFFFFFF80
j... | /xiph[P]opusfile/src/stream.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe067 | op_fseek | static int op_fseek(void *_stream,opus_int64 _offset,int _whence){
#if defined(_WIN32)
/*_fseeki64() is not exposed until MSVCRT80.
This is the default starting with MSVC 2005 (_MSC_VER>=1400), but we want
to allow linking against older MSVCRT versions for compatibility back to
XP without installing ext... | jmp 0x3590
| /xiph[P]opusfile/src/stream.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe06c | op_ftell | static opus_int64 op_ftell(void *_stream){
#if defined(_WIN32)
/*_ftelli64() is not exposed until MSVCRT80, and ftello()/ftello64() have
the same problems as fseeko()/fseeko64() in MingW.
See above for a more detailed explanation.*/
opus_int64 pos;
OP_ASSERT(sizeof(pos)==sizeof(fpos_t));
return fgetpos... | jmp 0x3500
| /xiph[P]opusfile/src/stream.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe071 | op_mem_read | static int op_mem_read(void *_stream,unsigned char *_ptr,int _buf_size){
OpusMemStream *stream;
ptrdiff_t size;
ptrdiff_t pos;
stream=(OpusMemStream *)_stream;
/*Check for empty read.*/
if(_buf_size<=0)return 0;
size=stream->size;
pos=stream->pos;
/*Check for EOF.*/
if(pos>=size)return 0;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testl %edx, %edx
jle 0xe0b6
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %r12
subq %r12, %rax
jle 0xe0b6
movl %edx, %ebx
cmpq %rbx, %rax
cmovlq %rax, %rbx
movq (%r14), %rax
addq %r12, %rax
movslq %ebx, %r15
movq %rsi, %rdi
movq %rax, %rsi
m... | /xiph[P]opusfile/src/stream.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe0c4 | op_mem_seek | static int op_mem_seek(void *_stream,opus_int64 _offset,int _whence){
OpusMemStream *stream;
ptrdiff_t pos;
stream=(OpusMemStream *)_stream;
pos=stream->pos;
OP_ASSERT(pos>=0);
switch(_whence){
case SEEK_SET:{
/*Check for overflow:*/
if(_offset<0||_offset>OP_MEM_DIFF_MAX)return -1;
... | movq 0x10(%rdi), %rcx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x2, %edx
je 0xe10b
cmpl $0x1, %edx
je 0xe0e1
testl %edx, %edx
jne 0xe0e0
testq %rsi, %rsi
jns 0xe146
retq
movq %rcx, %rdx
negq %rdx
cmpq %rsi, %rdx
setg %dl
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
subq %rcx, %r8
cmpq %rsi, ... | /xiph[P]opusfile/src/stream.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe14d | op_mem_tell | static opus_int64 op_mem_tell(void *_stream){
OpusMemStream *stream;
stream=(OpusMemStream *)_stream;
return (ogg_int64_t)stream->pos;
} | movq 0x10(%rdi), %rax
retq
| /xiph[P]opusfile/src/stream.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe152 | op_mem_close | static int op_mem_close(void *_stream){
_ogg_free(_stream);
return 0;
} | pushq %rax
callq 0x33f0
xorl %eax, %eax
popq %rcx
retq
| /xiph[P]opusfile/src/stream.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe15c | opus_server_info_init | void opus_server_info_init(OpusServerInfo *_info){
_info->name=NULL;
_info->description=NULL;
_info->genre=NULL;
_info->url=NULL;
_info->server=NULL;
_info->content_type=NULL;
_info->bitrate_kbps=-1;
_info->is_public=-1;
_info->is_ssl=0;
} | xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $-0x1, 0x30(%rdi)
movl $0x0, 0x38(%rdi)
retq
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe17a | opus_server_info_clear | void opus_server_info_clear(OpusServerInfo *_info){
_ogg_free(_info->content_type);
_ogg_free(_info->server);
_ogg_free(_info->url);
_ogg_free(_info->genre);
_ogg_free(_info->description);
_ogg_free(_info->name);
} | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x33f0
movq 0x20(%rbx), %rdi
callq 0x33f0
movq 0x18(%rbx), %rdi
callq 0x33f0
movq 0x10(%rbx), %rdi
callq 0x33f0
movq 0x8(%rbx), %rdi
callq 0x33f0
movq (%rbx), %rdi
popq %rbx
jmp 0x33f0
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe1b4 | op_url_stream_vcreate | void *op_url_stream_vcreate(OpusFileCallbacks *_cb,
const char *_url,va_list _ap){
OpusServerInfo info;
OpusServerInfo *pinfo;
void *ret;
ret=op_url_stream_vcreate_impl(_cb,_url,&info,&pinfo,_ap);
if(pinfo!=NULL)*pinfo=*&info;
return ret;
} | pushq %rbx
subq $0x50, %rsp
movq %rdx, %r8
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq 0xe1ff
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xe1f9
movups 0x10(%rsp), %xmm0
movups 0x20(%rsp), %xmm1
movups 0x30(%rsp), %xmm2
movups 0x40(%rsp), %xmm3
movups %xmm3, 0x30(%rcx)
movups %xmm2, 0x20(%rcx)
movups %xm... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe1ff | op_url_stream_vcreate_impl | static void *op_url_stream_vcreate_impl(OpusFileCallbacks *_cb,
const char *_url,OpusServerInfo *_info,OpusServerInfo **_pinfo,va_list _ap){
int skip_certificate_check;
const char *proxy_host;
opus_int32 proxy_port;
const char *proxy_user;
const char *proxy_pass;
OpusServerInfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq $0x0, (%rcx)
movl (%r8), %r11d
xorl %ecx, %ecx
movl $0x1f90, %eax # imm = 0x1F90
leaq 0x2618(%rip), %r15 # 0x10840
xorl %r9d, %r9d
xorl %r10d, %r10d
xorl %r12d, %r12d
xorl %edx, %edx
cmpl $0x... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe412 | op_url_stream_create | void *op_url_stream_create(OpusFileCallbacks *_cb,
const char *_url,...){
va_list ap;
void *ret;
va_start(ap,_url);
ret=op_url_stream_vcreate(_cb,_url,ap);
va_end(ap);
return ret;
} | pushq %rbx
subq $0x120, %rsp # imm = 0x120
leaq 0x70(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xe473
movaps %xmm0, 0xa0(%rsp)
movaps %xmm1, 0xb0(%rsp)
movaps %xmm2, 0xc0(%rsp)
movaps %xmm3, 0xd0(%rsp)
movaps %xmm4, 0xe0(%rsp)
movaps %... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe4db | op_vopen_url | OggOpusFile *op_vopen_url(const char *_url,int *_error,va_list _ap){
OpusFileCallbacks cb;
OggOpusFile *of;
OpusServerInfo info;
OpusServerInfo *pinfo;
void *source;
source=op_url_stream_vcreate_impl(&cb,_url,&info,&pinfo,_ap);
if(OP_UNLIKELY(source==NULL)){
OP_ASSERT(pinfo=... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r8
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rsp, %rcx
callq 0xe1ff
testq %rax, %rax
je 0xe558
movq %rax, %r14
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x46ec
movq %rax, %rbx
movq ... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe57f | op_open_url | OggOpusFile *op_open_url(const char *_url,int *_error,...){
OggOpusFile *ret;
va_list ap;
va_start(ap,_error);
ret=op_vopen_url(_url,_error,ap);
va_end(ap);
return ret;
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xe5d6
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe603 | op_vtest_url | OggOpusFile *op_vtest_url(const char *_url,int *_error,va_list _ap){
OpusFileCallbacks cb;
OggOpusFile *of;
OpusServerInfo info;
OpusServerInfo *pinfo;
void *source;
source=op_url_stream_vcreate_impl(&cb,_url,&info,&pinfo,_ap);
if(OP_UNLIKELY(source==NULL)){
OP_ASSERT(pinfo=... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r8
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rsp, %rcx
callq 0xe1ff
testq %rax, %rax
je 0xe680
movq %rax, %r14
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0xae24
movq %rax, %rbx
movq ... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe6a7 | op_test_url | OggOpusFile *op_test_url(const char *_url,int *_error,...){
OggOpusFile *ret;
va_list ap;
va_start(ap,_error);
ret=op_vtest_url(_url,_error,ap);
va_end(ap);
return ret;
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xe6fe
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe72b | op_unescape_url_component | static char *op_unescape_url_component(char *_s){
int i;
int j;
for(i=j=0;_s[i];i++,j++){
if(_s[i]=='%'){
_s[i]=(char)(op_hex_value(_s[i+1])<<4|op_hex_value(_s[i+2]));
i+=2;
}
}
return _s;
} | movq %rdi, %rax
xorl %edi, %edi
movl $0xa9, %ecx
movslq %edi, %rdx
movzbl (%rax,%rdx), %esi
cmpl $0x25, %esi
je 0xe747
testl %esi, %esi
jne 0xe790
jmp 0xe794
movb 0x1(%rax,%rdx), %sil
movl $0x9, %edi
cmpb $0x41, %sil
jge 0xe75c
movl $0x40, %edi
movb 0x2(%rax,%rdx), %r8b
movl $0xc9, %r9d
cmpb $0x41, %r8b
jge 0xe773
movl... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe795 | op_http_stream_clear | static void op_http_stream_clear(OpusHTTPStream *_stream){
while(_stream->lru_head!=NULL){
op_http_conn_close(_stream,_stream->lru_head,&_stream->lru_head,0);
}
if(_stream->ssl_session!=NULL)SSL_SESSION_free(_stream->ssl_session);
if(_stream->ssl_ctx!=NULL)SSL_CTX_free(_stream->ssl_ctx);
op_sb_clear(&_str... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x190(%rdi), %rsi
testq %rsi, %rsi
je 0xe7c8
leaq 0x190(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xf1e5
movq 0x190(%rbx), %rsi
testq %rsi, %rsi
jne 0xe7af
movq 0x188(%rbx), %rdi
testq %rdi, %rdi
je 0xe7d9
callq 0x3650
movq 0x180(%rbx), %rdi
... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xe839 | op_http_connect | static int op_http_connect(OpusHTTPStream *_stream,OpusHTTPConn *_conn,
struct addrinfo *_addrs,op_time *_start_time){
op_time resolve_time;
struct addrinfo *new_addrs;
int ret;
/*Re-resolve the host if we need to (RFC 6555 says we MUST do so
occasionally).*/
new_addrs=NULL;
op_t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, 0x38(%rsp)
movq %rdi, %rbp
leaq 0x60(%rsp), %rdi
callq 0xf181
leaq 0x1d0(%rbp), %rsi
cmpq %r13, %rsi
movq %rbp, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
jne 0xe8e0
movq 0x60(%rsp), %rcx
subq 0x220(%rbp),... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf05c | op_http_conn_write_fully | static int op_http_conn_write_fully(OpusHTTPConn *_conn,
const char *_buf,int _buf_size){
struct pollfd fd;
SSL *ssl_conn;
fd.fd=_conn->fd;
ssl_conn=_conn->ssl_conn;
while(_buf_size>0){
int err;
if(ssl_conn!=NULL){
int ret;
ret=SSL_write(ssl_conn,_buf,_buf_size);
if(ret>0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x50(%rdi), %eax
movl %eax, (%rsp)
testl %edx, %edx
jle 0xf169
movl %edx, %ebx
movq %rsi, %r14
movq 0x20(%rdi), %r15
movq %rsp, %r12
testq %r15, %r15
je 0xf0d6
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x3670
testl %eax, %eax
... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf181 | op_time_get | static void op_time_get(op_time *now){
# ifdef OP_HAVE_CLOCK_GETTIME
/*Prefer a monotonic clock that continues to increment during suspend.*/
# ifdef CLOCK_BOOTTIME
if(clock_gettime(CLOCK_BOOTTIME,now)!=0)
# endif
# ifdef CLOCK_MONOTONIC
if(clock_gettime(CLOCK_MONOTONIC,now)!=0)
# endif
OP_ALWAYS_TRUE(!cloc... | pushq %rbx
movq %rdi, %rbx
movl $0x7, %edi
movq %rbx, %rsi
callq 0x32b0
testl %eax, %eax
je 0xf1b2
movl $0x1, %edi
movq %rbx, %rsi
callq 0x32b0
testl %eax, %eax
je 0xf1b2
xorl %edi, %edi
movq %rbx, %rsi
popq %rbx
jmp 0x32b0
popq %rbx
retq
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf1b4 | op_parsed_url_clear | static void op_parsed_url_clear(OpusParsedURL *_url){
_ogg_free(_url->scheme);
_ogg_free(_url->user);
_ogg_free(_url->pass);
_ogg_free(_url->host);
_ogg_free(_url->path);
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x33f0
movq 0x8(%rbx), %rdi
callq 0x33f0
movq 0x10(%rbx), %rdi
callq 0x33f0
movq 0x18(%rbx), %rdi
callq 0x33f0
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x33f0
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf1e5 | op_http_conn_close | static void op_http_conn_close(OpusHTTPStream *_stream,OpusHTTPConn *_conn,
OpusHTTPConn **_pnext,int _gracefully){
/*If we don't shut down gracefully, the server MUST NOT re-use our session
according to RFC 2246, because it can't tell the difference between an
abrupt close and a truncation attack.
So ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testl %ecx, %ecx
je 0xf205
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xf205
callq 0x33b0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xf213
callq 0x31e0
movl 0x50(%rbx), %edi
cmpl $-0x1, %edi
je 0xf220
callq 0x36a0
movq $-0x1, 0x10(%rbx)
mov... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf256 | op_sock_connect_next | static int op_sock_connect_next(op_sock _fd,
struct addrinfo **_addr,int _ai_family){
struct addrinfo *addr;
int err;
for(addr=*_addr;;addr=addr->ai_next){
/*Move to the next address of the requested type.*/
for(;addr!=NULL&&addr->ai_family!=_ai_family;addr=addr->ai_next);
*_addr=addr;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r15
testq %r15, %r15
sete %al
je 0xf2b4
movl %edx, %ebp
movl %edi, %r14d
cmpl %ebp, 0x4(%r15)
je 0xf284
movq 0x28(%r15), %r15
testq %r15, %r15
sete %al
jne 0xf270
jmp 0xf2b4
movq %r15, (%rbx)
testb $0x1, %al
jne 0xf2b7
movq 0x18(%r15),... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf2ce | op_inet_pton | static struct addrinfo *op_inet_pton(const char *_host){
struct addrinfo *addrs;
struct addrinfo hints;
memset(&hints,0,sizeof(hints));
hints.ai_socktype=SOCK_STREAM;
hints.ai_flags=AI_NUMERICHOST;
if(!getaddrinfo(_host,NULL,&hints,&addrs))return addrs;
return NULL;
} | pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movl $0x1, 0x8(%rdx)
movl $0x4, (%rdx)
xorl %ebx, %ebx
leaq 0x8(%rsp), %rcx
xorl %esi, %esi
callq 0x3440
testl %eax, %eax
jne 0xf30a
movq 0x8(%rsp), %rbx
movq %rbx, %rax
addq $0x40... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf313 | op_bio_retry_write | static int op_bio_retry_write(BIO *_b,const char *_buf,int _num){
(void)_buf;
(void)_num;
BIO_clear_retry_flags(_b);
BIO_set_retry_write(_b);
return -1;
} | pushq %rbx
movq %rdi, %rbx
movl $0xf, %esi
callq 0x3520
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3090
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
retq
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf335 | op_bio_retry_read | static int op_bio_retry_read(BIO *_b,char *_buf,int _num){
(void)_buf;
(void)_num;
BIO_clear_retry_flags(_b);
BIO_set_retry_read(_b);
return -1;
} | pushq %rbx
movq %rdi, %rbx
movl $0xf, %esi
callq 0x3520
movq %rbx, %rdi
movl $0x9, %esi
callq 0x3090
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
retq
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf357 | op_bio_retry_puts | static int op_bio_retry_puts(BIO *_b,const char *_str){
return op_bio_retry_write(_b,_str,0);
} | pushq %rbx
movq %rdi, %rbx
movl $0xf, %esi
callq 0x3520
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3090
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
retq
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf379 | op_bio_retry_ctrl | static long op_bio_retry_ctrl(BIO *_b,int _cmd,long _num,void *_ptr){
long ret;
(void)_b;
(void)_num;
(void)_ptr;
ret=0;
switch(_cmd){
case BIO_CTRL_RESET:
case BIO_C_RESET_READ_REQUEST:{
BIO_clear_retry_flags(_b);
}
/*Fall through.*/
case BIO_CTRL_EOF:
case BIO_CTRL_SET:
c... | cmpl $0xc, %esi
ja 0xf38d
movl $0x1a14, %eax # imm = 0x1A14
btl %esi, %eax
jb 0xf3a4
cmpl $0x1, %esi
je 0xf395
cmpl $0x93, %esi
jne 0xf3aa
pushq %rax
movl $0xf, %esi
callq 0x3520
addq $0x8, %rsp
movl $0x1, %eax
retq
xorl %eax, %eax
retq
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf3ad | op_bio_retry_new | static int op_bio_retry_new(BIO *_b){
BIO_set_init(_b,1);
# if (OPENSSL_VERSION_NUMBER<0x10100000L&&LIBRESSL_VERSION_NUMBER<0x2070000fL)
_b->num=0;
# endif
BIO_set_data(_b,NULL);
return 1;
} | pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x3200
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3360
movl $0x1, %eax
popq %rbx
retq
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf3cc | op_bio_retry_free | static int op_bio_retry_free(BIO *_b){
return _b!=NULL;
} | xorl %eax, %eax
testq %rdi, %rdi
setne %al
retq
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf3d5 | op_http_conn_read | static int op_http_conn_read(OpusHTTPConn *_conn,
char *_buf,int _buf_size,int _blocking){
struct pollfd fd;
SSL *ssl_conn;
int nread;
int nread_unblocked;
fd.fd=_conn->fd;
ssl_conn=_conn->ssl_conn;
nread=nread_unblocked=0;
/*RFC 2818 says "client implementations MUST t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rsi, 0x18(%rsp)
movl 0x50(%rdi), %eax
leaq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movq %rdi, 0x10(%rsp)
movq 0x20(%rdi), %r13
xorl %ebx, %ebx
xorl %ebp, %ebp
movq %r13, 0x20(%rsp)
movslq %ebp, %r15
testq %r13, %r13
je 0... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf597 | op_http_conn_read_rate_update | static void op_http_conn_read_rate_update(OpusHTTPConn *_conn){
op_time read_time;
opus_int32 read_delta_ms;
opus_int64 read_delta_bytes;
opus_int64 read_rate;
read_delta_bytes=_conn->read_bytes;
if(read_delta_bytes<=0)return;
op_time_get(&read_time);
read_delta_ms=op_time_diff_ms(&read_time,... | movq 0x40(%rdi), %rdx
testq %rdx, %rdx
jg 0xf5a1
retq
subq $0x18, %rsp
movq %rdi, %rsi
leaq 0x40(%rdi), %rcx
leaq 0x8(%rsp), %rdi
callq 0x8f6a
addq $0x18, %rsp
retq
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf5bb | op_http_lwsspn | static int op_http_lwsspn(const char *_s){
int i;
for(i=0;;){
if(_s[0]=='\r'&&_s[1]=='\n'&&(_s[2]=='\t'||_s[2]==' '))i+=3;
/*This case is for broken servers.*/
else if(_s[0]=='\n'&&(_s[1]=='\t'||_s[1]==' '))i+=2;
else if(_s[i]=='\t'||_s[i]==' ')i++;
else return i;
}
} | movzbl (%rdi), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
je 0xf5e8
cmpl $0xd, %ecx
jne 0xf5fb
cmpb $0xa, 0x1(%rdi)
jne 0xf5e3
movzbl 0x2(%rdi), %esi
movl $0x3, %edx
cmpl $0x9, %esi
je 0xf610
cmpl $0x20, %esi
je 0xf610
cmpl $0xa, %ecx
jne 0xf5fb
movzbl 0x1(%rdi), %esi
movl $0x2, %edx
cmpl $0x9, %esi
je 0xf610
cmpl $0x20, %es... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf615 | op_http_stream_read | static int op_http_stream_read(void *_stream,
unsigned char *_ptr,int _buf_size){
OpusHTTPStream *stream;
int nread;
opus_int64 size;
opus_int64 pos;
int ci;
stream=(OpusHTTPStream *)_stream;
/*Check for an empty read.*/
if(_buf_size<=0)return 0;
ci=stream->cur_conni... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %ebp, %ebp
testl %edx, %edx
jle 0xf787
movq %rdi, %rbx
movslq 0x27c(%rdi), %rax
testq %rax, %rax
js 0xf787
movl %edx, %r12d
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
movq (%rbx,%rax), %rdx
movq 0x260(%rbx), %r15
testq %r15, %r15
js 0... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xf8f8 | op_http_stream_seek | static int op_http_stream_seek(void *_stream,opus_int64 _offset,int _whence){
op_time seek_time;
OpusHTTPStream *stream;
OpusHTTPConn *conn;
OpusHTTPConn **pnext;
OpusHTTPConn *close_conn;
OpusHTTPConn **close_pnext;
opus_int64 content_length;
opus_int64 pos;
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $0x0, 0x280(%rdi)
je 0xfb47
movq %rsi, %r14
movq %rdi, %rbx
movq 0x260(%rdi), %r15
movslq 0x27c(%rdi), %rax
movq %r15, %rcx
testq %rax, %rax
js 0xf940
leaq (%rax,%rax,2), %rcx
shlq $0x... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xfd1d | op_http_stream_tell | static opus_int64 op_http_stream_tell(void *_stream){
OpusHTTPStream *stream;
int ci;
stream=(OpusHTTPStream *)_stream;
ci=stream->cur_conni;
return ci<0?stream->pos:stream->conns[ci].pos;
} | movslq 0x27c(%rdi), %rax
movq %rax, %rcx
shlq $0x5, %rcx
testq %rax, %rax
leaq (%rcx,%rcx,2), %rax
movl $0x268, %ecx # imm = 0x268
cmovnsq %rax, %rcx
movq (%rdi,%rcx), %rax
retq
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xfd40 | op_http_conn_estimate_available | static int op_http_conn_estimate_available(OpusHTTPConn *_conn){
int available;
int ret;
ret=ioctl(_conn->fd,FIONREAD,&available);
if(ret<0)available=0;
/*This requires the SSL read_ahead flag to be unset to work.
We ignore partial records as well as the protocol overhead for any pending
bytes.
T... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x50(%rdi), %edi
leaq 0xc(%rsp), %rdx
movl $0x541b, %esi # imm = 0x541B
xorl %eax, %eax
callq 0x3490
testl %eax, %eax
jns 0xfd68
movl $0x0, 0xc(%rsp)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xfd7a
callq 0x36b0
addl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x115d0 | iutest::detail::IFileSystem::~IFileSystem() | virtual ~IFileSystem()
{
SetInstance(NULL);
} | ud2
| /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_file.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x115d2 | iutest::IFile::~IFile() | virtual ~IFile() {} | ud2
| /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_file.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x115d4 | non-virtual thunk to iutest::IFile::~IFile() | virtual ~IFile() {} | ud2
| /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_file.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x115d6 | iutest::detail::IOutStream::~IOutStream() | virtual ~IOutStream() {} | ud2
| /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_stream.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x115d8 | iutest::detail::IInStream::~IInStream() | virtual ~IInStream() {} | ud2
| /srz-zumix[P]iutest/include/internal/../internal/../impl/../internal/iutest_stream.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x115da | std::enable_if<__or_<std::__or_<std::is_same<std::remove_cv<int>::type, signed char>, std::is_same<std::remove_cv<int>::type, short>, std::is_same<std::remove_cv<int>::type, int>, std::is_same<std::remove_cv<int>::type, long>, std::is_same<std::remove_cv<int>::type, long long>, std::is_same<std::remove_cv<int>::type, _... | __detail::__integer_to_chars_result_type<_Tp>
__to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10)
{
__glibcxx_assert(2 <= __base && __base <= 36);
using _Up = __detail::__unsigned_least_t<_Tp>;
_Up __unsigned_val = __value;
if (__first == __last) [[__unlikely__]]
r... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x4b
popq %rdi
cmpq %rsi, %rbx
je 0x1169b
movl %edx, %r8d
testl %edx, %edx
je 0x11629
jns 0x115ff
movb $0x2d, (%rbx)
incq %rbx
negl %r8d
leal -0x2(%rcx), %eax
rorl %eax
cmpl $0x7, %eax
ja 0x116cf
leaq 0x13a44(%rip), %rdx # 0x25058
movslq (%rdx,%rax,4), %rax
ad... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/charconv | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x116e1 | std::enable_if<__or_<std::__or_<std::is_same<std::remove_cv<unsigned int>::type, signed char>, std::is_same<std::remove_cv<unsigned int>::type, short>, std::is_same<std::remove_cv<unsigned int>::type, int>, std::is_same<std::remove_cv<unsigned int>::type, long>, std::is_same<std::remove_cv<unsigned int>::type, long lon... | __integer_to_chars_result_type<_Tp>
__to_chars_16(char* __first, char* __last, _Tp __val) noexcept
{
static_assert(is_integral<_Tp>::value, "implementation bug");
static_assert(is_unsigned<_Tp>::value, "implementation bug");
to_chars_result __res;
const unsigned __len = (__to_chars_len... | movq %rsi, %rax
testl %edx, %edx
je 0x116f0
bsrl %edx, %esi
xorl $0x1f, %esi
jmp 0x116f3
pushq $0x20
popq %rsi
pushq $0x23
popq %rcx
subl %esi, %ecx
shrl $0x2, %ecx
movq %rax, %rsi
subq %rdi, %rsi
cmpq %rcx, %rsi
jl 0x1177c
leaq 0x16423(%rip), %rax # 0x27b30
cmpl $0x100, %edx # imm = 0x100
jb 0x11757
lea... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/charconv | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x11780 | std::enable_if<__or_<std::__or_<std::is_same<std::remove_cv<unsigned int>::type, signed char>, std::is_same<std::remove_cv<unsigned int>::type, short>, std::is_same<std::remove_cv<unsigned int>::type, int>, std::is_same<std::remove_cv<unsigned int>::type, long>, std::is_same<std::remove_cv<unsigned int>::type, long lon... | __integer_to_chars_result_type<_Tp>
__to_chars_8(char* __first, char* __last, _Tp __val) noexcept
{
static_assert(is_integral<_Tp>::value, "implementation bug");
static_assert(is_unsigned<_Tp>::value, "implementation bug");
to_chars_result __res;
unsigned __len;
if _GLIBCXX17_CON... | movl %edx, %ecx
testl %edx, %edx
je 0x1178e
bsrl %ecx, %edx
xorl $0x1f, %edx
jmp 0x11791
pushq $0x20
popq %rdx
pushq $0x22
popq %rax
subl %edx, %eax
pushq $0x3
popq %r8
xorl %edx, %edx
divl %r8d
movq %rsi, %rdx
subq %rdi, %rdx
cmpq %rax, %rdx
jl 0x11817
cmpl $0x40, %ecx
jb 0x117ef
leal -0x1(%rax), %esi
movl %ecx, %edx
... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/charconv | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x1181c | std::enable_if<__or_<std::__or_<std::is_same<std::remove_cv<unsigned int>::type, signed char>, std::is_same<std::remove_cv<unsigned int>::type, short>, std::is_same<std::remove_cv<unsigned int>::type, int>, std::is_same<std::remove_cv<unsigned int>::type, long>, std::is_same<std::remove_cv<unsigned int>::type, long lon... | __integer_to_chars_result_type<_Tp>
__to_chars_2(char* __first, char* __last, _Tp __val) noexcept
{
static_assert(is_integral<_Tp>::value, "implementation bug");
static_assert(is_unsigned<_Tp>::value, "implementation bug");
to_chars_result __res;
const unsigned __len = __to_chars_len_2... | movq %rsi, %rax
pushq $0x20
popq %rcx
movl %ecx, %esi
testl %edx, %edx
je 0x1182e
bsrl %edx, %esi
xorl $0x1f, %esi
subl %esi, %ecx
movq %rax, %r8
subq %rdi, %r8
cmpq %rcx, %r8
jl 0x11873
cmpl $0x1f, %esi
je 0x11867
pushq $0x1f
popq %rax
subl %esi, %eax
decq %rax
movq %rax, %rsi
movl %edx, %r8d
andb $0x1, %r8b
orb $0x30... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/charconv | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x11877 | std::to_chars_result std::__detail::__to_chars<unsigned int>(char*, char*, unsigned int, int) | to_chars_result
__to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
{
static_assert(is_integral<_Tp>::value, "implementation bug");
static_assert(is_unsigned<_Tp>::value, "implementation bug");
to_chars_result __res;
const unsigned __len = __to_chars_len(__val, __ba... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %edi
movl %ecx, %esi
callq 0x2278e
movq %r15, %rdx
subq %rbx, %rdx
movl %eax, %ecx
cmpq %rcx, %rdx
jl 0x118ed
cmpl %ebp, %r14d
jb 0x118c8
leal -0x1(%rcx), %esi
leaq 0x16362(%rip), %rdi ... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/charconv | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x118f2 | iutest::detail::iuITestSuiteMediator::~iuITestSuiteMediator() | TestSuite* ptr() const IUTEST_CXX_NOEXCEPT_SPEC { return m_test_suite; } | ud2
| /srz-zumix[P]iutest/include/internal/../internal/iutest_mediator.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x11b23 | iutest::DefaultXmlGeneratorListener::DefaultXmlGeneratorListener(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) (.cold.1) | pointer
_M_data() const
{ return _M_dataplus._M_p; } | movq (%rdi), %rdi
cmpq %rsi, %rdi
je 0x11b36
movq (%rsi), %rsi
incq %rsi
jmp 0x112e0
retq
| /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x11ecc | iu_Foo_x_iutest_x_Ok_Test::Body() | IUTEST(Foo, Ok)
{
IUTEST_SUCCEED() << "not show.";
} | pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
leaq 0x30(%rsp), %rbx
movl $0x188, %edx # imm = 0x188
movq %rbx, %rdi
xorl %esi, %esi
callq 0x111b0
movq %rbx, %rdi
callq 0x17610
leaq 0x1324b(%rip), %rsi # 0x25144
movq %rbx, %rdi
callq 0x22f90
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
... | /srz-zumix[P]iutest/test/tap_printer_listener_tests.cpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x11fc8 | iu_Bar_x_iutest_x_DISABLED_Ng_Test::Body() | IUTEST(Bar, DISABLED_Ng)
{
IUTEST_FAIL() << "show failed.\n test.";
} | pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
leaq 0x30(%rsp), %rbx
movl $0x188, %edx # imm = 0x188
movq %rbx, %rdi
xorl %esi, %esi
callq 0x111b0
movq %rbx, %rdi
callq 0x17610
leaq 0x13175(%rip), %rsi # 0x2516a
movq %rbx, %rdi
callq 0x23178
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
... | /srz-zumix[P]iutest/test/tap_printer_listener_tests.cpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x120c9 | main | int main(int argc, char* argv[])
#endif
{
IUTEST_INIT(&argc, argv);
#if defined(DISABLE_FALSE_POSITIVE_XML)
// 失敗テストを含むので xml 出力しない
::iuutil::ReleaseDefaultXmlGenerator();
#endif
#if !defined(IUTEST_USE_GTEST)
::iutest::TAPPrintListener::SetUp();
TestLogger logger;
::iutest::detail::iuConsole:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3a8, %rsp # imm = 0x3A8
movq %rsi, %rbx
leaq 0x8c(%rsp), %r14
movl %edi, (%r14)
callq 0x1352a
movq %rax, %rdi
callq 0x1820e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18272
callq 0x182dc
callq 0x1352a
movq %rax, %rdi
callq 0x183ba
callq 0... | /srz-zumix[P]iutest/test/tap_printer_listener_tests.cpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x129fc | iutest::detail::iuConsole::color_output(iutest::detail::iuConsole::Color, char const*, ...) | inline void iuConsole::color_output(Color color, const char *fmt, ...)
{
va_list va;
va_start(va, fmt);
if( IsShouldUseColor(true) )
{
color_output_impl(color, fmt, va);
}
else
{
voutput(fmt, va);
}
va_end(va);
} | pushq %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x12a5a
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0... | /srz-zumix[P]iutest/include/internal/iutest_console.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x12d51 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::detail::iu_to_string<int>(int const&) | ::std::string iu_to_string(const T& value)
{
const size_t kN = 128;
char buf[kN] = { 0 };
const ::std::to_chars_result r = ::std::to_chars(buf, buf + kN, value);
*r.ptr = '\0';
return buf;
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rax
movaps %xmm0, -0x10(%rax)
movaps %xmm0, -0x20(%rax)
movaps %xmm0, -0x30(%rax)
movaps %xmm0, -0x40(%rax)
movaps %xmm0, -0x50(%rax)
movaps %xmm0, -0x60(%rax)
movaps %xmm0, -0x70(%rax)
movaps %xmm0, -0x80(%rax)
movl (%rsi), %ed... | /srz-zumix[P]iutest/include/internal/iutest_string.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x12dce | iutest::JunitXmlGeneratorListener::IsReportable(iutest::UnitTest const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | movq 0x20(%rsi), %rcx
movq 0x28(%rsi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x12e13
movq (%rcx), %rsi
movq 0x28(%rsi), %rdi
movq 0x30(%rsi), %r8
xorl %esi, %esi
cmpq %r8, %rdi
je 0x12e03
movq (%rdi), %r9
movzbl 0x9c(%r9), %r9d
addl %r9d, %esi
addq $0x8, %rdi
jmp 0x12dea
addl %esi, %eax
addq $0x8, %rcx
cmpq %rdx, %rc... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x12f10 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string<std::allocator<char>>(char const*, std::allocator<char> const&) | basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{
const _CharT* __end = __s ? __s + traits_type::length(__s)
// We just need a non-null pointer here to get an exception:
: reinterpret_cast<const _CharT*>(__alignof__(_CharT));
_M_construct(__s, __end,... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
testq %rsi, %rsi
je 0x12f36
movq %rbx, %rdi
callq 0x11130
movq %rax, %rdx
addq %rbx, %rdx
jmp 0x12f3b
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19680
nop
| /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x12f4e | iutest::TAPPrintListener::OnTestProgramStart(iutest::UnitTest const&) | inline void TAPPrintListener::OnTestProgramStart(const UnitTest& test)
{
IUTEST_UNUSED_VAR(test);
// フィルタリング
if( TestFlag::IsEnableFlag(TestFlag::FILTERING_TESTS) )
{
detail::iuConsole::color_output(detail::iuConsole::yellow
, "# Note: iutest filter = %s\n", TestEnv::test_filter());
... | pushq %rax
callq 0x16c4e
testb $0x4, (%rax)
jne 0x12f5b
popq %rax
retq
callq 0x16e38
movq 0x38(%rax), %rdx
leaq 0x1212b(%rip), %rsi # 0x25096
movl $0x3, %edi
xorl %eax, %eax
popq %rcx
jmp 0x129fc
| /srz-zumix[P]iutest/test/../include/listener/iutest_tap_printer.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x12f78 | iutest::TAPPrintListener::OnReportTestSuite(iutest::detail::IOutStream*, iutest::TestSuite const&, int) | inline void TAPPrintListener::OnReportTestSuite(detail::IOutStream* const stream, const TestSuite& test_suite, int top)
{
stream->Printf("# %s started.\n", test_suite.name());
for( int i=0, test_count=test_suite.total_test_count(); i < test_count; ++i )
{
const TestInfo* test_info = test_suite.GetT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, %r14
movq %rsi, %rbx
movq 0x8(%rdx), %rdx
movq (%rsi), %rcx
leaq 0x12313(%rip), %rsi # 0x252b2
movq %rbx, %rdi
xorl %eax, %eax
callq *0x18(%rcx)
movq 0x30(%r14), %rax
subq 0x28(%r14), %rax
shrq $0x3, ... | /srz-zumix[P]iutest/test/../include/listener/iutest_tap_printer.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x1320c | iutest::detail::TestInstance<iu_Foo_x_iutest_x_Ok_Test>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x184b0
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x22952
movq %rax, 0x8(%rbx)
leaq 0x1d9a0(%r... | /srz-zumix[P]iutest/include/iutest_core.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x1336a | iutest::detail::TestInstance<iu_Bar_x_iutest_x_DISABLED_Ng_Test>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x184b0
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x22952
movq %rax, 0x8(%rbx)
leaq 0x1d842(%r... | /srz-zumix[P]iutest/include/iutest_core.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x1352a | iutest::UnitTestSource::GetInstance() | static UnitTestSource& GetInstance() { static UnitTestSource inst; return inst; } | pushq %rbx
movb 0x1e39f(%rip), %al # 0x318d0
testb %al, %al
je 0x1353e
leaq 0x1e38c(%rip), %rax # 0x318c8
popq %rbx
retq
leaq 0x1e38b(%rip), %rdi # 0x318d0
callq 0x11570
testl %eax, %eax
je 0x13535
leaq 0x1e373(%rip), %rdi # 0x318c8
callq 0x1b410
leaq 0x7f0f(%rip), %rdi # 0x1b470
leaq 0x1e360(%rip... | /srz-zumix[P]iutest/include/iutest.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x1359a | iutest::UnitTestSource::Run() | int Run()
{
SetUpDefaultListener();
return UnitTest::instance().Run();
} | pushq %rax
callq 0x183ba
callq 0x1b5c2
callq 0x184b0
movq %rax, %rdi
popq %rax
jmp 0x1b4ea
| /srz-zumix[P]iutest/include/iutest.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x135b3 | iutest::AssertionResult iutest::internal::CmpHelperSTREQ<char const*, char const*>(char const*, char const*, char const*, char const*, iutest_type_traits::enable_if<!detail::is_integral<char const*>::value || !detail::is_pointer<char const*>::value, void>::type*&) | inline AssertionResult IUTEST_ATTRIBUTE_UNUSED_ CmpHelperSTREQ(
const char* expr1, const char* expr2
, T1 val1, T2 val2, typename detail::enable_if<
!detail::is_integral<T1>::value || !detail::is_pointer<T2>::value, void>::type*& = detail::enabler::value)
{
if IUTEST_COND_LIKELY( StrEqHelper::Compar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
testq %rcx, %rcx
setne %al
testq %r8, %r8
setne %cl
testb %cl, %al
jne 0x135f2
cmpq %r12, %r13
jmp 0x1361f
movq %r13... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x137b2 | iutest::UnitTest::Failed() const | bool Failed() const { return !Passed(); } | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x172c6
testb %al, %al
je 0x137cb
xorl %ebx, %ebx
jmp 0x13803
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %r15
cmpq %r15, %r14
sete %bl
je 0x13803
movq (%r14), %rdi
callq 0x1cb50
testb %al, %al
je 0x13803
addq $0x8, %r14
cmpq %r15, %r14
sete %bl
je 0x13... | /srz-zumix[P]iutest/include/iutest_core.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x1380e | iutest::TestEnv::OptionString<&iutest::TestEnv::test_filter(), &iutest::TestEnv::set_test_filter(char const*)>::operator=(char const*) | const _Myt& operator = (const char* c_str_)
{
m_option = detail::NullableString(c_str_);
S(c_str_);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x1385f(%rip), %r15 # 0x27085
cmovneq %rsi, %r15
movq 0x8(%rdi), %r12
movq %r15, %rdi
callq 0x11130
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x11480
movq %rbx, %rd... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_env.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x139ac | iutest::TestEventListener::OnTestCaseStart(iutest::TestSuite const&) | virtual void OnTestCaseStart(const TestSuite& /*test_suite*/) {} | retq
nop
| /srz-zumix[P]iutest/include/internal/../internal/../iutest_listener.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x13aa2 | iutest::TestEventListener::OnTestCaseEnd(iutest::TestSuite const&) | virtual void OnTestCaseEnd(const TestSuite& /*test_suite*/) {} | retq
nop
| /srz-zumix[P]iutest/include/internal/../internal/../iutest_listener.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x13b7c | iutest::DefaultResultPrintListener::~DefaultResultPrintListener() | virtual ~DefaultResultPrintListener()
{
TestEnv::event_listeners().set_default_result_printer(NULL);
} | pushq %rbx
leaq 0x1c404(%rip), %rax # 0x2ff88
movq %rax, (%rdi)
callq 0x16e38
movq %rax, %rbx
movq %rax, %rdi
addq $0xe8, %rdi
movq 0x108(%rax), %rsi
callq 0x1af56
testq %rax, %rax
je 0x13bb3
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq $0x0, 0x108(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x171b0
| /srz-zumix[P]iutest/include/listener/iutest_default_printer.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x13bc8 | iutest::DefaultResultPrintListener::~DefaultResultPrintListener() | virtual ~DefaultResultPrintListener()
{
TestEnv::event_listeners().set_default_result_printer(NULL);
} | pushq %rbx
movq %rdi, %rbx
callq 0x13b7c
movl $0x8, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x112e0
nop
| /srz-zumix[P]iutest/include/listener/iutest_default_printer.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x13dd6 | iutest::DefaultResultPrintListener::OnTestRecordProperty(iutest::TestProperty const&) | pointer
_M_data() const
{ return _M_dataplus._M_p; } | movq (%rsi), %rax
movq 0x20(%rsi), %rdx
leaq 0x13360(%rip), %rdi # 0x27144
movq %rax, %rsi
xorl %eax, %eax
jmp 0x16d8c
| /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x146f4 | iutest::DefaultXmlGeneratorListener::~DefaultXmlGeneratorListener() | virtual ~DefaultXmlGeneratorListener()
{
FileClose();
TestEnv::event_listeners().set_default_xml_generator(NULL);
} | pushq %rbx
movq %rdi, %rbx
callq 0x14c38
movl $0x50, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x112e0
nop
| /srz-zumix[P]iutest/include/listener/iutest_default_xml_generator.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x1470c | iutest::EmptyTestEventListener::OnTestProgramStart(iutest::UnitTest const&) | virtual void OnTestProgramStart(const UnitTest& /*test*/) IUTEST_CXX_OVERRIDE {} | retq
nop
| /srz-zumix[P]iutest/include/internal/../internal/../iutest_listener.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x1470e | iutest::EmptyTestEventListener::OnEnvironmentsSetUpStart(iutest::UnitTest const&) | virtual void OnEnvironmentsSetUpStart(const UnitTest& /*test*/) IUTEST_CXX_OVERRIDE {} | retq
nop
| /srz-zumix[P]iutest/include/internal/../internal/../iutest_listener.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x14710 | iutest::EmptyTestEventListener::OnEnvironmentsSetUpEnd(iutest::UnitTest const&) | virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*test*/) IUTEST_CXX_OVERRIDE {} | retq
nop
| /srz-zumix[P]iutest/include/internal/../internal/../iutest_listener.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x14712 | iutest::EmptyTestEventListener::OnTestSuiteStart(iutest::TestSuite const&) | virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) IUTEST_CXX_OVERRIDE {} | retq
nop
| /srz-zumix[P]iutest/include/internal/../internal/../iutest_listener.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
0x14714 | iutest::EmptyTestEventListener::OnTestStart(iutest::TestInfo const&) | virtual void OnTestStart(const TestInfo& /*test_info*/) IUTEST_CXX_OVERRIDE {} | retq
nop
| /srz-zumix[P]iutest/include/internal/../internal/../iutest_listener.hpp | srz-zumix[P]iutest[P]build_O1[P]projects[P]cmake[P]tap_printer_listener_tests |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.