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 &_of->links[_li].tags;
}
|
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
movq 0x30(%rdi), %rcx
cltq
imulq $0x178, %rax, %rax # imm = 0x178
addq %rcx, %rax
addq $0x158, %rax # imm = 0x158
retq
decl %ecx
movl %ecx, %eax
jmp 0xc139
|
/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, %rbx
movq %rbx, %rdi
callq 0x3190
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
/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 ret;
int li;
if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
if(OP_UNLIKELY(!_of->seekable))return OP_ENOSEEK;
if(OP_UNLIKELY(_pcm_offset<0))return OP_EINVAL;
target_gp=op_get_granulepos(_of,_pcm_offset,&li);
if(OP_UNLIKELY(target_gp==-1))return OP_EINVAL;
link=_of->links+li;
pcm_start=link->pcm_start;
OP_ALWAYS_TRUE(!op_granpos_diff(&_pcm_offset,target_gp,pcm_start));
#if !defined(OP_SMALL_FOOTPRINT)
/*For small (90 ms or less) forward seeks within the same link, just decode
forward.
This also optimizes the case of seeking to the current position.*/
if(li==_of->cur_link&&_of->ready_state>=OP_INITSET){
ogg_int64_t gp;
gp=_of->prev_packet_gp;
if(OP_LIKELY(gp!=-1)){
ogg_int64_t discard_count;
int nbuffered;
nbuffered=OP_MAX(_of->od_buffer_size-_of->od_buffer_pos,0);
OP_ALWAYS_TRUE(!op_granpos_add(&gp,gp,-nbuffered));
/*We do _not_ add cur_discard_count to gp.
Otherwise the total amount to discard could grow without bound, and it
would be better just to do a full seek.*/
if(OP_LIKELY(!op_granpos_diff(&discard_count,target_gp,gp))){
/*We use a threshold of 90 ms instead of 80, since 80 ms is the
_minimum_ we would have discarded after a full seek.
Assuming 20 ms frames (the default), we'd discard 90 ms on average.*/
if(discard_count>=0&&OP_UNLIKELY(discard_count<90*48)){
_of->cur_discard_count=(opus_int32)discard_count;
return 0;
}
}
}
}
#endif
ret=op_pcm_seek_page(_of,target_gp,li);
if(OP_UNLIKELY(ret<0))return ret;
/*Now skip samples until we actually get to our target.*/
/*Figure out where we should skip to.*/
if(_pcm_offset<=link->head.pre_skip)skip=0;
else skip=OP_MAX(_pcm_offset-80*48,0);
OP_ASSERT(_pcm_offset-skip>=0);
OP_ASSERT(_pcm_offset-skip<OP_INT32_MAX-120*48);
/*Skip packets until we find one with samples past our skip target.*/
for(;;){
op_count=_of->op_count;
prev_packet_gp=_of->prev_packet_gp;
for(op_pos=_of->op_pos;op_pos<op_count;op_pos++){
ogg_int64_t cur_packet_gp;
cur_packet_gp=_of->op[op_pos].granulepos;
if(OP_LIKELY(!op_granpos_diff(&diff,cur_packet_gp,pcm_start))
&&diff>skip){
break;
}
prev_packet_gp=cur_packet_gp;
}
_of->prev_packet_gp=prev_packet_gp;
_of->op_pos=op_pos;
if(op_pos<op_count)break;
/*We skipped all the packets on this page.
Fetch another.*/
ret=op_fetch_and_process_page(_of,NULL,-1,0,1);
if(OP_UNLIKELY(ret<0))return OP_EBADLINK;
}
/*We skipped too far, or couldn't get within 2 billion samples of the target.
Either the timestamps were illegal or there was a hole in the data.*/
if(op_granpos_diff(&diff,prev_packet_gp,pcm_start)||diff>skip
||_pcm_offset-diff>=OP_INT32_MAX){
return OP_EBADLINK;
}
/*TODO: If there are further holes/illegal timestamps, we still won't decode
to the correct sample.
However, at least op_pcm_tell() will report the correct value immediately
after returning.*/
_of->cur_discard_count=(opus_int32)(_pcm_offset-diff);
return 0;
}
|
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
addl %r15d, %ecx
movslq %ecx, %rdx
imulq $0x178, %rdx, %rdx # imm = 0x178
cmpq %rsi, 0x18(%rbp,%rdx)
jg 0xc228
movl %ecx, %r15d
jmp 0xc22a
movl %ecx, %eax
movl %eax, %ecx
subl %r15d, %ecx
cmpl $0x1, %ecx
jg 0xc208
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movslq %r15d, %rax
imulq $0x178, %rax, %rbx # imm = 0x178
movq %rsi, %rax
subq 0x18(%rbp,%rbx), %rax
movq 0x20(%rbp,%rbx), %rdx
movq 0x28(%rbp,%rbx), %r9
movslq 0x3c(%rbp,%rbx), %rcx
movq %rdx, %rdi
xorq %r9, %rdi
movq %rsi, 0x60(%rsp)
js 0xc416
subq %r9, %rdx
subq %rcx, %rdx
movq $-0x1, %r14
cmpq %rdx, %rax
movl $0xffffff7d, %edx # imm = 0xFFFFFF7D
jge 0xc2ac
addq %rcx, %rax
movq %rax, %rcx
notq %rcx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
addq %r14, %rcx
cmpq %rcx, %r9
jg 0xd158
movq %r9, %r14
addq %rax, %r14
movq %r9, 0x40(%rsp)
cmpq $-0x1, %r14
je 0xd00a
movq %r14, %rax
movq 0x40(%rsp), %rsi
xorq %rsi, %rax
js 0xc433
movq %r14, %rax
subq %rsi, %rax
movq %rax, 0x60(%rsp)
movq 0x20(%rsp), %rax
movl 0x7c(%rax), %r13d
cmpl $0x4, %r12d
jl 0xc324
cmpl %r13d, %r15d
jne 0xc324
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rdx
movq %rdx, 0xc8(%rsp)
cmpq $-0x1, %rdx
je 0xc324
leaq 0xc8(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq %r14, %rcx
callq 0x63e1
xorl %edx, %edx
testb $0x1, %al
je 0xd00a
addq %rbx, %rbp
pxor %xmm0, %xmm0
movq 0x20(%rsp), %rax
movdqu %xmm0, 0x98(%rax)
movq %r14, %rdx
cmpq $0xf00, %r14 # imm = 0xF00
jb 0xc36b
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
leaq 0xf00(%rax), %rcx
movq $-0xf00, %rax # imm = 0xF100
movq %r14, %rdx
cmpq %rcx, %r14
jl 0xd12e
addq %rax, %rdx
movq 0x28(%rbp), %rbx
cmpq $0xf00, %r14 # imm = 0xF00
jb 0xc407
testq %rdx, %rdx
js 0xd14a
testq %rbx, %rbx
js 0xc407
cmpq %rdx, %rbx
jg 0xc407
movq %rdx, 0x28(%rsp)
movq 0x8(%rbp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rbp), %rax
movq %rax, 0x18(%rsp)
movl 0x30(%rbp), %eax
movl %eax, 0x7c(%rsp)
movl 0x3c(%rbp), %edx
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x459b
movq (%r14), %rax
movq 0x28(%rsp), %rcx
testq %rcx, %rcx
movq %rbp, 0xb0(%rsp)
js 0xc470
cmpq %rcx, %rax
jbe 0xc47e
movl $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq %rax, %rbp
movq %rax, %r8
jmp 0xc5aa
movl $0xffffff7d, %edx # imm = 0xFFFFFF7D
jmp 0xd00a
movq %rbx, %rdx
jmp 0xc38f
movl $0xffffff76, %edx # imm = 0xFFFFFF76
jmp 0xd00a
testq %rdx, %rdx
js 0xc270
orq %r8, %rdx
subq %r9, %rdx
jl 0xd285
xorq %r8, %rdx
jmp 0xc273
testq %r14, %r14
jns 0xd166
movq %rsi, %rax
notq %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
addq %rcx, %rax
movq $-0x2, %rcx
subq %r14, %rcx
movq %r14, %rdx
subq %rsi, %rdx
cmpq %rax, %rcx
movq 0x60(%rsp), %rax
cmovgeq %rdx, %rax
jmp 0xc2d2
testq %rax, %rax
jns 0xc47e
cmpq %rcx, %rax
jg 0xc3e5
movq 0x10(%rbp), %rbp
movl $0x0, 0x4(%rsp)
cmpl $0x4, %r12d
jl 0xc5a5
cmpl %r13d, %r15d
jne 0xc5a5
movq 0x20(%rsp), %rcx
movl 0x3214(%rcx), %eax
movb $0x1, %r14b
movl $0x0, 0x4(%rsp)
testl %eax, %eax
jle 0xd210
movq 0x48(%rcx), %r8
movq %r8, %r13
subq 0x10(%rsp), %r13
jl 0xd210
cmpq %rbp, %r8
jg 0xd210
decl %eax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq 0x20(%rsp), %rcx
movq 0x260(%rcx,%rax), %r12
cmpq $-0x1, %r12
je 0xd210
testq %rbx, %rbx
movq 0x18(%rsp), %rcx
js 0xd1f1
testq %r12, %r12
js 0xc513
cmpq %rbx, %r12
jle 0xd204
testq %rcx, %rcx
js 0xd22d
testq %r12, %r12
js 0xd204
cmpq %r12, %rcx
jle 0xd204
movq %r12, %rax
movq 0x28(%rsp), %rcx
xorq %rcx, %rax
js 0xd23b
movq %r12, %rax
subq %rcx, %rax
movq %rax, %rcx
testq %rcx, %rcx
movq %rcx, 0x48(%rsp)
jns 0xd03a
movq %rbp, %rax
subq 0x10(%rsp), %rax
sarq %rax
cmpq %rax, %r13
jge 0xc573
cmpq $-0x57e3ff, %rcx # imm = 0xFFA81C01
jl 0xd210
movq 0x20(%rsp), %rcx
movq 0xc0(%rcx), %rax
movl $0x1, 0x4(%rsp)
cmpq 0xb8(%rcx), %rax
jge 0xd02d
movq 0x90(%rcx), %rax
movq %rax, 0x10(%rsp)
jmp 0xd032
movq 0x10(%rsp), %r8
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
xorl %eax, %eax
movq 0x20(%rsp), %r12
movl %eax, 0x3214(%r12)
movl %eax, 0x3254(%r12)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x88(%r12)
cmpl %eax, 0x28(%r12)
jne 0xc5fb
movl $0x158, %edi # imm = 0x158
addq 0x30(%r12), %rdi
movq %rcx, %r14
movq %r8, %r13
callq 0x9fe6
movq %r13, %r8
movq %r14, %rcx
movl $0x2, 0x78(%r12)
cmpl $0x0, 0x4(%rsp)
jne 0xc628
leaq 0xa8(%r12), %rdi
movq %r8, %r13
movl 0x7c(%rsp), %esi
movq %rcx, %r14
callq 0x32e0
movq %r13, %r8
movq %r14, %rcx
movl %r15d, 0x7c(%r12)
movl $0x3, 0x78(%r12)
movq $-0x1, 0x68(%rsp)
movq %rbp, %rdx
subq %r8, %rdx
movq %r12, %r15
jle 0xcd61
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, %rdi
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
orq %rax, %rdi
movq %rdi, 0xa0(%rsp)
movq $-0x2, %rax
subq %rcx, %rax
movq %rax, 0x98(%rsp)
leaq 0xa8(%r15), %rax
movq %rax, 0x70(%rsp)
movl $0x0, 0x58(%rsp)
movq %rbx, 0x90(%rsp)
movq %rdx, 0xb8(%rsp)
movq %rdx, 0x80(%rsp)
movq %rdx, 0xc0(%rsp)
movq %r8, 0x88(%rsp)
movq %rbp, %r12
movq %rbp, %rdx
subq %r8, %rdx
cmpq $0x10000, %rdx # imm = 0x10000
jge 0xc6e0
movq %r8, %rsi
movq 0x80(%rsp), %r14
jmp 0xc783
movq %rdx, %r14
shrq %r14
cmpl $0x0, 0x58(%rsp)
je 0xc6f3
leaq (%r14,%r8), %rsi
jmp 0xc747
movq %rbx, %rax
movq 0x28(%rsp), %rcx
movq %r12, %r13
movq %r8, %r12
xorq %rcx, %rax
js 0xcc8c
movq %rcx, %rdi
subq %rbx, %rdi
movq %rbx, %rax
movq 0x18(%rsp), %rsi
xorq %rsi, %rax
js 0xccbc
subq %rbx, %rsi
movq %rdi, 0x48(%rsp)
movq %rsi, 0xa8(%rsp)
callq 0xddd3
movq %r12, %r8
leaq (%r12,%rax), %rsi
addq $-0x10000, %rsi # imm = 0xFFFF0000
movq %r13, %r12
movq 0xb8(%rsp), %rdx
sarq %rdx
movq 0x80(%rsp), %rcx
sarq %rcx
leaq -0x10000(%rsi), %rax
cmpq %r8, %rax
cmovlq %r8, %rsi
movl $0x0, 0x58(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %rsi, 0x50(%rsp)
cmpq 0x48(%r15), %rsi
movq %r14, 0x80(%rsp)
je 0xc7d0
movq %r12, %r13
movq %r8, %r12
cmpl $0x0, 0x4(%rsp)
je 0xc7ad
movq 0x70(%rsp), %rdi
callq 0x3300
movq %r15, %rdi
movq 0x50(%rsp), %rsi
callq 0xc182
movl $0x0, 0x4(%rsp)
testl %eax, %eax
js 0xcc5a
movq %r12, %r8
movq %r13, %r12
movq 0xc0(%rsp), %rax
addq %rax, %rax
movq %rax, 0xe8(%rsp)
movl $0x10000, %r13d # imm = 0x10000
movq %r12, 0x30(%rsp)
movl %r13d, 0x5c(%rsp)
movq %rbx, %r14
movq %rbp, %rbx
movq %r8, %rbp
movq %r15, %rdi
leaq 0xc8(%rsp), %r13
movq %r13, %rsi
movq 0x30(%rsp), %rdx
callq 0xdc8c
testq %rax, %rax
movq %rax, 0x68(%rsp)
js 0xcb89
cmpq %r12, %rax
cmovlq %rax, %r12
movq %r12, 0x38(%rsp)
movq %r13, %rdi
callq 0x3290
movl $0x4, %r12d
cmpl %eax, 0x7c(%rsp)
jne 0xc85e
movq %r13, %rdi
callq 0x3620
movl %eax, %r15d
testl %eax, %eax
jle 0xc889
movq %r13, %rdi
callq 0x3550
movq %rax, %r13
jmp 0xc890
movq %r14, %r13
movq %rbp, %r8
movq %rbx, %rbp
movb $0x1, %cl
cmpl $0x4, %r12d
jne 0xcb72
movq %r13, %rbx
cmpq %rbp, %r8
movq 0x38(%rsp), %r12
jl 0xc7f3
jmp 0xcc25
movq $-0x1, %r13
cmpq $-0x1, %r13
movq %rbp, %r8
je 0xc99d
testq %r13, %r13
js 0xc9e1
cmpq %r13, 0x28(%rsp)
movq 0x20(%rsp), %r15
movq %rbx, %rbp
jbe 0xca02
movq 0x48(%r15), %r8
testq %r14, %r14
movq 0x18(%rsp), %rax
js 0xca83
testq %r13, %r13
js 0xc8d9
cmpq %r13, %r14
jg 0xcaab
testq %rax, %rax
js 0xca99
movl $0x5, %r12d
testq %r13, %r13
js 0xca7b
cmpq %rax, %r13
jg 0xca7b
cmpl $0x0, 0x4(%rsp)
je 0xc911
movq 0x70(%rsp), %rdi
movq %r8, %rbx
callq 0x3300
movq %rbx, %r8
movq 0xc8(%rsp), %rax
movzbl 0x1a(%rax), %ecx
cmpb $-0x1, 0x1a(%rax,%rcx)
movq %r8, 0x10(%rsp)
jne 0xc949
movq %r15, %rdi
movq %r8, %rbx
leaq 0xc8(%rsp), %rsi
callq 0xdea9
movq %rbx, %r8
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r13, %rax
movq 0x28(%rsp), %rdx
xorq %rdx, %rax
js 0xcab3
subq %r13, %rdx
xorl %eax, %eax
movq %rdx, 0x48(%rsp)
cmpq $0xbb81, %rdx # imm = 0xBB81
setge %al
movq 0x50(%rsp), %rcx
cmovlq %r8, %rcx
movq %rcx, 0x50(%rsp)
leal (%rax,%rax,4), %r12d
movl $0x1, 0x4(%rsp)
movq %r8, 0x88(%rsp)
movq %r13, 0x90(%rsp)
jmp 0xc867
cmpl $0x0, 0x4(%rsp)
je 0xc9cc
testl %r15d, %r15d
jg 0xcae7
movq 0x70(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x34d0
movq %r14, %r13
movq 0x20(%rsp), %r15
jmp 0xc861
movl $0x0, 0x4(%rsp)
movq %r14, %r13
movq 0x20(%rsp), %r15
jmp 0xc864
movq 0x28(%rsp), %rcx
testq %rcx, %rcx
sets %al
cmpq %r13, %rcx
setg %cl
testb %cl, %al
movq 0x20(%rsp), %r15
movq %rbx, %rbp
jne 0xc8b9
leaq 0x1(%r8), %rax
xorl %r12d, %r12d
movq 0x50(%rsp), %rbp
cmpq %rax, %rbp
jle 0xca78
movq %rbp, %rax
subq %r8, %rax
xorl %edx, %edx
cmpq 0xe8(%rsp), %rax
setg %dl
movq 0x18(%rsp), %rax
testq %rax, %rax
movl %edx, 0x58(%rsp)
js 0xcafe
movl $0x5, %r12d
testq %r13, %r13
js 0xca6c
cmpq %r13, %rax
jle 0xca6c
testq %r14, %r14
js 0xcb15
testq %r13, %r13
js 0xcb29
cmpq %r13, %r14
cmovleq %r13, %rax
movq %rax, 0x18(%rsp)
movl $0x5, %r12d
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xca7b
movq %r8, %rbp
movq %r14, %r13
jmp 0xc867
movl $0x5, %r12d
testq %r13, %r13
jns 0xca7b
cmpq %r13, %r14
jle 0xc8d9
jmp 0xca7b
testq %r13, %r13
jns 0xc8fa
cmpq %rax, %r13
jle 0xc8fa
movl $0x5, %r12d
jmp 0xca7b
testq %rdx, %rdx
js 0xcb43
movq 0xa0(%rsp), %rax
subq %r13, %rax
movq 0x48(%rsp), %rdx
jl 0xc95d
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %rdx
jmp 0xc95d
movq 0x70(%rsp), %rdi
callq 0x3300
movl $0x0, 0x4(%rsp)
jmp 0xc9bf
testq %r13, %r13
jns 0xca48
cmpq %r13, %rax
jg 0xca48
jmp 0xca66
movl $0x5, %r12d
testq %r13, %r13
jns 0xca6c
jmp 0xca5a
movl $0x5, %r12d
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %r13, 0x18(%rsp)
jmp 0xca7b
movq %r13, %rax
notq %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
addq %rcx, %rax
movq %rdx, %rcx
subq %r13, %rcx
cmpq %rax, 0x98(%rsp)
movq 0x48(%rsp), %rdx
cmovgeq %rcx, %rdx
jmp 0xc95d
cmpl $0x5, %r12d
je 0xcc25
movq %r13, %rbx
movq 0x38(%rsp), %r12
jmp 0xcc0e
cmpq $-0x1, %rax
jne 0xcc43
movq %rbp, %r8
leaq 0x1(%rbp), %rax
cmpq %rax, 0x50(%rsp)
jle 0xcc08
cmpl $0x0, 0x4(%rsp)
movl 0x5c(%rsp), %r13d
je 0xcbba
movq 0x70(%rsp), %rdi
callq 0x3300
movq %rbp, %r8
movslq %r13d, %rax
movq 0x50(%rsp), %rsi
subq %rax, %rsi
cmpq %r8, %rsi
cmovleq %r8, %rsi
movq %r15, %rdi
movq %rsi, 0x50(%rsp)
callq 0xc182
testl %eax, %eax
js 0xcc72
addl %r13d, %r13d
movl $0x100000, %eax # imm = 0x100000
cmpl %eax, %r13d
cmovgel %eax, %r13d
movl $0x0, 0x4(%rsp)
movq %r12, 0x30(%rsp)
movq %rbp, %r8
movq %rbx, %rbp
movq %r14, %rbx
jmp 0xcc13
movq %r8, %rbp
movq %r14, %rbx
movl 0x5c(%rsp), %r13d
cmpq %rbp, %r8
jl 0xc7ee
movb $0x1, %cl
movq 0x30(%rsp), %r12
jmp 0xcc2d
movq 0x30(%rsp), %r12
movq %r13, %rbx
testb %cl, %cl
je 0xce6c
cmpq %rbp, %r8
jl 0xc6c1
jmp 0xcd71
xorl %ecx, %ecx
movq 0x30(%rsp), %r12
movq %rax, 0x8(%rsp)
movq %rbp, %r8
movq %rbx, %rbp
movq %r14, %rbx
jmp 0xcc2d
movq $-0x1, 0x68(%rsp)
xorl %ecx, %ecx
movq %rax, 0x8(%rsp)
movq %r12, %r8
movq %r13, %r12
jmp 0xcc2d
movl $0x0, 0x4(%rsp)
movq $-0x1, 0x68(%rsp)
movq 0x30(%rsp), %r12
xorl %ecx, %ecx
jmp 0xcc4a
testq %rcx, %rcx
js 0xccf6
movq 0xa0(%rsp), %rax
subq %rbx, %rax
movq 0x48(%rsp), %rdi
jl 0xc710
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %rdi
jmp 0xc710
movq %rdi, %r8
testq %rsi, %rsi
js 0xcd27
movq %rsi, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq %rcx, %rax
subq %rbx, %rax
movq %r8, %rdi
movq 0xa8(%rsp), %rsi
jl 0xc724
xorq %rcx, %rax
movq %r8, %rdi
movq %rax, %rsi
jmp 0xc724
movq %rbx, %rax
notq %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
addq %rcx, %rax
movq 0x28(%rsp), %rcx
subq %rbx, %rcx
cmpq %rax, 0x98(%rsp)
movq 0x48(%rsp), %rdi
cmovgeq %rcx, %rdi
jmp 0xc710
movq %rbx, %rax
notq %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
addq %rcx, %rax
movq $-0x2, %rcx
subq %rsi, %rcx
movq %rsi, %rdi
subq %rbx, %rdi
cmpq %rax, %rcx
movq 0xa8(%rsp), %rsi
cmovgeq %rdi, %rsi
movq %r8, %rdi
jmp 0xc724
movq %r8, 0x88(%rsp)
movq %rbx, 0x90(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0xd01e
movq 0x10(%rsp), %r12
movq 0x68(%rsp), %rdx
cmpq %rdx, %r12
movq 0xb0(%rsp), %rbx
je 0xcdad
movq %r15, %rdi
movq %r12, %rsi
callq 0xc182
movq $-0x1, %rdx
testl %eax, %eax
js 0xce67
cmpq 0x88(%rsp), %r12
jge 0xcdfa
testq %rdx, %rdx
jns 0xcde3
movq 0x10(%rbx), %rdx
leaq 0xc8(%rsp), %rsi
movq %r15, %rdi
callq 0xdc8c
cmpq $-0x2, %rax
jle 0xce67
cmpq %r12, %rax
jne 0xd0ed
leaq 0xc8(%rsp), %rsi
movq %r15, %rdi
callq 0xdea9
movq $-0x1, %rdx
movq 0x90(%rsp), %rax
movq %rax, 0x88(%r15)
movq %r12, 0x90(%r15)
xorl %eax, %eax
testq %rdx, %rdx
leaq 0xc8(%rsp), %rsi
cmovsq %rax, %rsi
movq %r15, %rdi
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x4a7a
testl %eax, %eax
js 0xd0ed
leaq 0x88(%r15), %rax
movq (%rax), %rax
testq %rax, %rax
js 0xd1aa
movq 0x28(%rsp), %rdx
testq %rdx, %rdx
js 0xd1c7
xorl %ecx, %ecx
cmpq %rdx, %rax
movl $0xffffff77, %eax # imm = 0xFFFFFF77
cmovlel %ecx, %eax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdx
testl %edx, %edx
movq 0xb0(%rsp), %rax
js 0xd00a
movl 0x3c(%rax), %eax
movq 0x60(%rsp), %rdx
cmpq $0xf01, %rdx # imm = 0xF01
movl $0xf00, %ecx # imm = 0xF00
cmovgeq %rdx, %rcx
addq $-0xf00, %rcx # imm = 0xF100
xorl %ebx, %ebx
cmpq %rax, %rdx
cmovgq %rcx, %rbx
movq 0x40(%rsp), %r15
notq %r15
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
addq %rax, %r15
movq 0x20(%rsp), %r13
leaq 0x260(%r13), %r12
movl 0x3214(%r13), %esi
movq 0x88(%r13), %rax
movl 0x3210(%r13), %ecx
cmpl %esi, %ecx
setl %dl
jge 0xcf94
movslq %esi, %rdi
movslq %ecx, %r8
leaq (%r8,%r8,2), %r9
shlq $0x4, %r9
addq %r12, %r9
incq %r8
movq 0x40(%rsp), %r13
movq (%r9), %r10
movq %r10, %r11
xorq %r13, %r11
js 0xcf3c
movq %r10, %r14
subq %r13, %r14
movb $0x1, %r11b
cmpq %rbx, %r14
setg %bpl
testb %bpl, %r11b
cmoveq %r10, %rax
jne 0xcf94
cmpq %rdi, %r8
setl %dl
incl %ecx
addq $0x30, %r9
incq %r8
cmpl %ecx, %esi
jne 0xcf03
jmp 0xcf92
testq %r10, %r10
js 0xcf68
movq %r10, %r13
movabsq $-0x8000000000000000, %r11 # imm = 0x8000000000000000
orq %r11, %r13
subq 0x40(%rsp), %r13
jl 0xcf8d
xorq %r11, %r13
movb $0x1, %r11b
movq %r13, %r14
movq 0x40(%rsp), %r13
jmp 0xcf17
movq $-0x2, %r11
subq %r10, %r11
movq %r10, %r13
movq 0x40(%rsp), %rbp
subq %rbp, %r13
cmpq %r15, %r11
setge %r11b
cmovgeq %r13, %r14
movq %rbp, %r13
jmp 0xcf17
xorl %r11d, %r11d
jmp 0xcf61
movl %esi, %ecx
movq 0x20(%rsp), %r13
movq %rax, 0x88(%r13)
movl %ecx, 0x3210(%r13)
testb $0x1, %dl
jne 0xcfc3
movq %r13, %rdi
callq 0x647e
testb $0x1, %al
je 0xceca
movl $0xffffff77, %edx # imm = 0xFFFFFF77
jmp 0xd00a
movq %rax, %rcx
movq 0x40(%rsp), %rdx
xorq %rdx, %rcx
js 0xd187
subq %rdx, %rax
xorl %ecx, %ecx
movq %rax, %r14
movl $0xffffff77, %edx # imm = 0xFFFFFF77
testb %cl, %cl
jne 0xd00a
cmpq %rbx, %r14
jg 0xd00a
movq 0x60(%rsp), %rax
subq %r14, %rax
cmpq $0x7ffffffe, %rax # imm = 0x7FFFFFFE
jg 0xd00a
movq %rax, %rcx
movq 0x20(%rsp), %rax
movl %ecx, 0x80(%rax)
xorl %edx, %edx
movl %edx, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %r12
movq 0x68(%rsp), %rdx
jmp 0xcdfa
movq %r8, 0x10(%rsp)
movq %r12, %rbx
jmp 0xd215
movq %r8, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq 0x260(%rax), %r14
movq 0x240(%rax), %rdi
movl 0x248(%rax), %esi
callq 0x5ea4
negl %eax
leaq 0xc8(%rsp), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x459b
testl %eax, %eax
jns 0xd081
movq $0x0, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
testq %rax, %rax
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rsi
js 0xd26c
testq %rcx, %rcx
js 0xd27d
cmpq %rcx, %rax
setg %r14b
testb %r14b, %r14b
je 0xd0f7
movq %rbp, %rax
movq 0x10(%rsp), %rdx
subq %rdx, %rax
sarq %rax
cmpq %rax, %r13
setle %al
cmpq $0x57e400, 0x48(%rsp) # imm = 0x57E400
setl %cl
orb %al, %cl
cmovneq %rsi, %rbp
movq 0x18(%rsp), %rcx
cmovneq %r12, %rcx
movq %rax, 0x8(%rsp)
movq %rdx, %r8
jmp 0xd21f
movl $0xffffff77, %eax # imm = 0xFFFFFF77
jmp 0xce67
xorl %ecx, %ecx
movq 0x20(%rsp), %rdi
movl %ecx, 0x3210(%rdi)
movl %ecx, 0x3254(%rdi)
movq %rax, 0x88(%rdi)
movl $0x3, 0x78(%rdi)
callq 0x5ee3
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
jmp 0xd0e5
leal -0xeff(%r14), %eax
cltq
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
jmp 0xc368
testq %rbx, %rbx
js 0xc38a
jmp 0xc38f
movq %r9, %rcx
xorq %r14, %rcx
addq %rcx, %rax
jmp 0xc2a9
movq %r14, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq %rcx, %rax
subq %rsi, %rax
jl 0xc2d7
xorq %rcx, %rax
jmp 0xc2d2
testq %rax, %rax
js 0xd1d5
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq %rcx, %rax
subq %rdx, %rax
jl 0xd28a
xorq %rcx, %rax
jmp 0xcfd7
movl $0xffffff77, %ecx # imm = 0xFFFFFF77
movq %rcx, 0x8(%rsp)
movq 0x28(%rsp), %rdx
testq %rdx, %rdx
jns 0xce6c
jmp 0xce5a
movq $0x0, 0x8(%rsp)
jmp 0xce6c
movq $-0x2, %rcx
subq %rax, %rcx
subq %rdx, %rax
cmpq %r15, %rcx
setl %cl
cmovgeq %rax, %r14
jmp 0xcfdc
testq %r12, %r12
jns 0xd210
cmpq %rbx, %r12
movq 0x18(%rsp), %rcx
jg 0xc513
movq 0x10(%rsp), %r8
movq %rax, 0x8(%rsp)
jmp 0xd21f
movq 0x10(%rsp), %r8
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
testb %r14b, %r14b
jne 0xc5b4
jmp 0xce6c
testq %r12, %r12
js 0xc525
jmp 0xc52e
movq %r8, %rsi
movq %r12, %rcx
testq %r12, %r12
js 0xd25f
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
orq %rax, %rcx
subq 0x28(%rsp), %rcx
jl 0xd291
xorq %rax, %rcx
jmp 0xd264
subq 0x28(%rsp), %rcx
movq %rsi, %r8
jmp 0xc548
movb $0x1, %r14b
testq %rcx, %rcx
jns 0xd0ac
jmp 0xd0a5
xorl %r14d, %r14d
jmp 0xd0ac
jmp 0xc273
movb $0x1, %cl
jmp 0xcfdc
jmp 0xd264
|
/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 range [-65536,65534].
These bounds allow the offset to set the final value to anywhere in the
range [-32768,32767], which is what we'll clamp it to before applying.*/
_of->gain_offset_q8=OP_CLAMP(-98302,_gain_offset_q8,98303);
op_update_gain(_of);
return 0;
}
|
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 # imm = 0xFFFE8002
cmovgel %eax, %ecx
movl %ecx, 0x325c(%rdi)
callq 0xd2e6
xorl %eax, %eax
addq $0x8, %rsp
retq
|
/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->links[li].head;
/*We don't have to worry about overflow here because the header gain and
track gain must lie in the range [-32768,32767], and the user-supplied
offset has been pre-clamped to [-98302,98303].*/
switch(_of->gain_type){
case OP_ALBUM_GAIN:{
int album_gain_q8;
album_gain_q8=0;
opus_tags_get_album_gain(&_of->links[li].tags,&album_gain_q8);
gain_q8+=album_gain_q8;
gain_q8+=head->output_gain;
}break;
case OP_TRACK_GAIN:{
int track_gain_q8;
track_gain_q8=0;
opus_tags_get_track_gain(&_of->links[li].tags,&track_gain_q8);
gain_q8+=track_gain_q8;
gain_q8+=head->output_gain;
}break;
case OP_HEADER_GAIN:gain_q8+=head->output_gain;break;
case OP_ABSOLUTE_GAIN:break;
default:OP_ASSERT(0);
}
gain_q8=OP_CLAMP(-32768,gain_q8,32767);
OP_ASSERT(_of->od!=NULL);
#if defined(OPUS_SET_GAIN)
opus_multistream_decoder_ctl(_of->od,OPUS_SET_GAIN(gain_q8));
#else
/*A fallback that works with both float and fixed-point is a bunch of work,
so just force people to use a sufficiently new version.
This is deployed well enough at this point that this shouldn't be a burden.*/
# error "libopus 1.0.1 or later required"
#endif
}
|
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 0x3258(%rbx), %edx
testl %edx, %edx
je 0xd37c
cmpl $0xbc0, %edx # imm = 0xBC0
je 0xd35c
cmpl $0xbbf, %edx # imm = 0xBBF
jne 0xd380
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
leaq (%rax,%rcx), %rdi
addq $0x158, %rdi # imm = 0x158
movq %r14, %rsi
callq 0xa0e3
jmp 0xd379
movq %rsp, %r14
movl $0x0, (%r14)
leaq (%rax,%rcx), %rdi
addq $0x158, %rdi # imm = 0x158
movq %r14, %rsi
callq 0xa1ca
addl (%r14), %ebp
addl 0x10(%r15), %ebp
movl $0x7fff, %eax # imm = 0x7FFF
cmpl %eax, %ebp
cmovll %ebp, %eax
cmpl $0xffff8001, %eax # imm = 0xFFFF8001
movl $0xffff8000, %edx # imm = 0xFFFF8000
cmovgel %eax, %edx
movq 0x3218(%rbx), %rdi
movl $0xfc2, %esi # imm = 0xFC2
xorl %eax, %eax
callq 0x32f0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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_channel_count!=_nchannels){
for(ci=0;ci<_nchannels;ci++)_of->clip_state[ci]=0;
}
opus_pcm_soft_clip(_src,_nsamples,_nchannels,_of->clip_state);
# endif
if(_of->dither_disabled){
for(i=0;i<_nchannels*_nsamples;i++){
dst[i]=op_float2int(OP_CLAMP(-32768,32768.0F*_src[i],32767));
}
}
else{
opus_uint32 seed;
int mute;
seed=_of->dither_seed;
mute=_of->dither_mute;
if(_of->state_channel_count!=_nchannels)mute=65;
/*In order to avoid replacing digital silence with quiet dither noise, we
mute if the output has been silent for a while.*/
if(mute>64)memset(_of->dither_a,0,sizeof(*_of->dither_a)*4*_nchannels);
for(i=0;i<_nsamples;i++){
int silent;
silent=1;
for(ci=0;ci<_nchannels;ci++){
float r;
float s;
float err;
int si;
int j;
s=_src[_nchannels*i+ci];
silent&=s==0;
s*=OP_GAIN;
err=0;
for(j=0;j<4;j++){
err+=OP_FCOEF_B[j]*_of->dither_b[ci*4+j]
-OP_FCOEF_A[j]*_of->dither_a[ci*4+j];
}
for(j=3;j-->0;)_of->dither_a[ci*4+j+1]=_of->dither_a[ci*4+j];
for(j=3;j-->0;)_of->dither_b[ci*4+j+1]=_of->dither_b[ci*4+j];
_of->dither_a[ci*4]=err;
s-=err;
if(mute>16)r=0;
else{
seed=op_rand(seed);
r=seed*OP_PRNG_GAIN;
seed=op_rand(seed);
r-=seed*OP_PRNG_GAIN;
}
/*Clamp in float out of paranoia that the input will be > 96 dBFS and
wrap if the integer is clamped.*/
si=op_float2int(OP_CLAMP(-32768,s+r,32767));
dst[_nchannels*i+ci]=(opus_int16)si;
/*Including clipping in the noise shaping is generally disastrous: the
futile effort to restore the clipped energy results in more clipping.
However, small amounts---at the level which could normally be created
by dither and rounding---are harmless and can even reduce clipping
somewhat due to the clipping sometimes reducing the dither + rounding
error.*/
_of->dither_b[ci*4]=mute>16?0:OP_CLAMP(-1.5F,si-s,1.5F);
}
mute++;
if(!silent)mute=0;
}
_of->dither_mute=OP_MIN(mute,65);
_of->dither_seed=seed;
}
_of->state_channel_count=_nchannels;
return _nsamples;
}
|
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 0xd444
movq 0x8(%rsp), %rax
leaq 0x3260(%rax), %rdi
movl %ebp, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x31d0
movq 0x8(%rsp), %rdi
leaq 0x3260(%rdi), %rcx
movq 0x18(%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x3640
movq 0x8(%rsp), %rdx
cmpl $0x0, 0x3388(%rdx)
je 0xd503
movl %r15d, %eax
imull %ebp, %eax
testl %eax, %eax
jle 0xd7c8
movl %eax, %ebx
xorl %r14d, %r14d
movss 0x3211(%rip), %xmm4 # 0x10698
movq 0x18(%rsp), %rax
movss (%rax,%r14,4), %xmm1
mulss 0x31f6(%rip), %xmm1 # 0x10690
movss 0x31f2(%rip), %xmm3 # 0x10694
ucomiss %xmm1, %xmm3
movaps %xmm1, %xmm2
cmpltss %xmm4, %xmm2
movaps %xmm2, %xmm0
andps %xmm4, %xmm0
andnps %xmm3, %xmm2
orps %xmm0, %xmm2
movaps %xmm1, %xmm0
cmpltss %xmm3, %xmm0
andps %xmm0, %xmm2
andnps %xmm3, %xmm0
orps %xmm2, %xmm0
movaps %xmm1, %xmm2
ja 0xd4d2
movaps %xmm0, %xmm2
ucomiss %xmm1, %xmm4
ja 0xd4da
movaps %xmm2, %xmm0
callq 0x3240
movq 0x40(%rsp), %rcx
movw %ax, (%rcx,%r14,2)
incq %r14
cmpq %r14, %rbx
movq 0x8(%rsp), %rdx
movss 0x319c(%rip), %xmm4 # 0x10698
jne 0xd487
jmp 0xd7c8
movl $0x41, %esi
cmpl %ebp, 0x338c(%rdx)
jne 0xd516
movl 0x3384(%rdx), %esi
movl 0x3380(%rdx), %eax
movq %rax, 0x10(%rsp)
movslq %ebp, %rax
movq %rax, 0x38(%rsp)
cmpl $0x41, %esi
jl 0xd553
movq 0x8(%rsp), %rax
leaq 0x3280(%rax), %rdi
movq 0x38(%rsp), %rdx
shlq $0x4, %rdx
movl %esi, %ebx
xorl %esi, %esi
callq 0x31d0
movl %ebx, %esi
movq 0x8(%rsp), %rdx
testl %r15d, %r15d
movl %r15d, 0x24(%rsp)
jle 0xd7a7
leaq 0x3300(%rdx), %rax
movq %rax, 0x58(%rsp)
movl %r15d, %eax
movq %rax, 0x60(%rsp)
movl %ebp, %eax
movq %rax, 0x70(%rsp)
leaq 0x328c(%rdx), %rax
movq %rax, 0x50(%rsp)
leaq 0x330c(%rdx), %rax
movq %rax, 0x48(%rsp)
leaq 0x30d5(%rip), %r15 # 0x10670
leaq 0x30de(%rip), %rbx # 0x10680
xorl %ecx, %ecx
movl %ebp, 0x28(%rsp)
testl %ebp, %ebp
jle 0xd78b
movq %rcx, 0x68(%rsp)
imulq 0x38(%rsp), %rcx
movq %rcx, 0x78(%rsp)
movl $0x1, %ecx
movq 0x48(%rsp), %r12
movq 0x50(%rsp), %r13
movq 0x58(%rsp), %rbp
xorl %r14d, %r14d
movl %esi, 0x2c(%rsp)
movq 0x78(%rsp), %rax
leaq (%r14,%rax), %rdi
movq 0x18(%rsp), %rax
movq %rdi, 0x80(%rsp)
movss (%rax,%rdi,4), %xmm4
xorps %xmm0, %xmm0
ucomiss %xmm4, %xmm0
movl $0x0, %eax
cmovnel %eax, %ecx
cmovpl %eax, %ecx
movl %ecx, 0x34(%rsp)
xorl %eax, %eax
movss (%rax,%r15), %xmm1
movss -0x80(%rbp,%rax), %xmm2
mulss (%rax,%rbx), %xmm2
mulss (%rbp,%rax), %xmm1
subss %xmm2, %xmm1
addss %xmm1, %xmm0
addq $0x4, %rax
cmpq $0x10, %rax
jne 0xd60d
xorl %eax, %eax
movss -0x4(%r13,%rax,4), %xmm1
movss %xmm1, (%r13,%rax,4)
leaq -0x1(%rax), %rcx
addq $0x3, %rax
cmpq $0x1, %rax
movq %rcx, %rax
ja 0xd638
xorl %eax, %eax
movss -0x4(%r12,%rax,4), %xmm1
movss %xmm1, (%r12,%rax,4)
leaq -0x1(%rax), %rcx
addq $0x3, %rax
cmpq $0x1, %rax
movq %rcx, %rax
ja 0xd659
movq %r14, %rax
shlq $0x4, %rax
mulss 0x3016(%rip), %xmm4 # 0x1069c
movss %xmm0, 0x3280(%rdx,%rax)
cmpl $0x10, %esi
jle 0xd699
xorps %xmm1, %xmm1
jmp 0xd6de
movq 0x10(%rsp), %rcx
imull $0x5bda335, %ecx, %eax # imm = 0x5BDA335
addl $0x3619636b, %eax # imm = 0x3619636B
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
imull $0x764e88f9, %ecx, %ecx # imm = 0x764E88F9
addl $0x10a71992, %ecx # imm = 0x10A71992
movq %rcx, 0x10(%rsp)
xorps %xmm2, %xmm2
cvtsi2ss %rcx, %xmm2
movss 0x2fce(%rip), %xmm3 # 0x106a0
mulss %xmm3, %xmm1
mulss %xmm3, %xmm2
subss %xmm2, %xmm1
subss %xmm0, %xmm4
movss %xmm4, 0x30(%rsp)
addss %xmm4, %xmm1
minss 0x2fa0(%rip), %xmm1 # 0x10694
movss 0x2f9c(%rip), %xmm0 # 0x10698
maxss %xmm1, %xmm0
callq 0x3240
movq 0x40(%rsp), %rcx
movq 0x80(%rsp), %rdx
movw %ax, (%rcx,%rdx,2)
movl 0x2c(%rsp), %esi
cmpl $0x10, %esi
xorps %xmm1, %xmm1
jg 0xd747
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
subss 0x30(%rsp), %xmm0
minss 0x2f6d(%rip), %xmm0 # 0x106a4
movss 0x2f69(%rip), %xmm1 # 0x106a8
ucomiss %xmm0, %xmm1
ja 0xd747
movaps %xmm0, %xmm1
leaq (,%r14,4), %rax
movq 0x8(%rsp), %rdx
movss %xmm1, 0x3300(%rdx,%rax,4)
incq %r14
addq $0x10, %rbp
addq $0x10, %r13
addq $0x10, %r12
cmpq 0x70(%rsp), %r14
movl 0x34(%rsp), %ecx
jne 0xd5db
testl %ecx, %ecx
sete %al
movl 0x28(%rsp), %ebp
movq 0x68(%rsp), %rcx
jmp 0xd78d
xorl %eax, %eax
incl %esi
testb %al, %al
movl $0x0, %eax
cmovnel %eax, %esi
incq %rcx
cmpq 0x60(%rsp), %rcx
jne 0xd5a8
cmpl $0x41, %esi
movl $0x41, %eax
cmovll %esi, %eax
movl %eax, 0x3384(%rdx)
movq 0x10(%rsp), %rax
movl %eax, 0x3380(%rdx)
movl 0x24(%rsp), %r15d
movl %ebp, 0x338c(%rdx)
movl %r15d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %eax
cltd
idivl %ebp
movl %eax, %r15d
jmp 0xd40f
|
/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]=dst[2*i+1]=dst[i];
}
else{
if(_nchannels>2){
_nsamples=OP_MIN(_nsamples,_dst_sz>>1);
_nsamples=op_stereo_filter(_of,_src,_nsamples*2,
_src,_nsamples,_nchannels);
}
_nsamples=op_float2short_filter(_of,dst,_dst_sz,_src,_nsamples,2);
}
return _nsamples;
}
|
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,%rcx,2), %edx
movw %dx, -0x6(%rbx,%rcx,4)
movw %dx, -0x8(%rbx,%rcx,4)
decq %rcx
cmpq $0x1, %rcx
jg 0xd838
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x3, %r9d
jl 0xd880
movl %ebp, %eax
sarl %eax
cmpl %r8d, %eax
cmovgel %r8d, %eax
leal (%rax,%rax), %edx
movq %r14, %rsi
movq %r14, %rcx
movl %eax, %r8d
callq 0xd8a0
movl %eax, %r8d
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r14, %rcx
movl $0x2, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd3df
|
/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){
for(i=0;i<_nsamples;i++)dst[2*i+0]=dst[2*i+1]=_src[i];
}
else{
for(i=0;i<_nsamples;i++){
float l;
float r;
int ci;
l=r=0;
for(ci=0;ci<_nchannels;ci++){
l+=OP_STEREO_DOWNMIX[_nchannels-3][ci][0]*_src[_nchannels*i+ci];
r+=OP_STEREO_DOWNMIX[_nchannels-3][ci][1]*_src[_nchannels*i+ci];
}
dst[2*i+0]=l;
dst[2*i+1]=r;
}
}
}
return _nsamples;
}
|
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
leal (%rbx,%rbx), %eax
movslq %eax, %rdx
shlq $0x2, %rdx
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x3260
jmp 0xd97d
testl %ebx, %ebx
jle 0xd97d
leal -0x3(%r9), %eax
movslq %eax, %r8
movl %r9d, %eax
movl %ebx, %edx
leaq (,%rax,4), %rdi
shlq $0x6, %r8
leaq 0x2da2(%rip), %r10 # 0x106c0
addq %r10, %r8
addq $0x4, %r8
xorl %r10d, %r10d
testl %r9d, %r9d
jle 0xd95f
xorps %xmm0, %xmm0
xorl %r11d, %r11d
xorps %xmm1, %xmm1
movss (%rcx,%r11,4), %xmm2
movss -0x4(%r8,%r11,8), %xmm3
mulss %xmm2, %xmm3
mulss (%r8,%r11,8), %xmm2
addss %xmm3, %xmm1
addss %xmm2, %xmm0
incq %r11
cmpq %r11, %rax
jne 0xd936
jmp 0xd965
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
movss %xmm1, (%rsi,%r10,8)
movss %xmm0, 0x4(%rsi,%r10,8)
incq %r10
addq %rdi, %rcx
cmpq %rdx, %r10
jne 0xd928
movl %ebx, %eax
popq %rbx
retq
|
/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 cur_page_eos;
int op_count;
int pi;
if(_og==NULL)_og=&og;
serialno=_of->os.serialno;
op_count=0;
/*We shouldn't have to initialize total_duration, but gcc is too dumb to
figure out that op_count>0 implies we've been through the whole loop at
least once.*/
total_duration=0;
do{
page_offset=op_get_next_page(_of,_og,_of->end);
/*We should get a page unless the file is truncated or mangled.
Otherwise there are no audio data packets in the whole logical stream.*/
if(OP_UNLIKELY(page_offset<0)){
/*Fail if there was a read error.*/
if(page_offset<OP_FALSE)return (int)page_offset;
/*Fail if the pre-skip is non-zero, since it's asking us to skip more
samples than exist.*/
if(_link->head.pre_skip>0)return OP_EBADTIMESTAMP;
_link->pcm_file_offset=0;
/*Set pcm_end and end_offset so we can skip the call to
op_find_final_pcm_offset().*/
_link->pcm_start=_link->pcm_end=0;
_link->end_offset=_link->data_offset;
return 0;
}
/*Similarly, if we hit the next link in the chain, we've gone too far.*/
if(OP_UNLIKELY(ogg_page_bos(_og))){
if(_link->head.pre_skip>0)return OP_EBADTIMESTAMP;
/*Set pcm_end and end_offset so we can skip the call to
op_find_final_pcm_offset().*/
_link->pcm_file_offset=0;
_link->pcm_start=_link->pcm_end=0;
_link->end_offset=_link->data_offset;
/*Tell the caller we've got a buffered page for them.*/
return 1;
}
/*Ignore pages from other streams (not strictly necessary, because of the
checks in ogg_stream_pagein(), but saves some work).*/
if(serialno!=(ogg_uint32_t)ogg_page_serialno(_og))continue;
ogg_stream_pagein(&_of->os,_og);
/*Bitrate tracking: add the header's bytes here.
The body bytes are counted when we consume the packets.*/
_of->bytes_tracked+=_og->header_len;
/*Count the durations of all packets in the page.*/
do total_duration=op_collect_audio_packets(_of,durations);
/*Ignore holes.*/
while(OP_UNLIKELY(total_duration<0));
op_count=_of->op_count;
}
while(op_count<=0);
/*We found the first page with a completed audio data packet: actually look
at the granule position.
RFC 3533 says, "A special value of -1 (in two's complement) indicates that
no packets finish on this page," which does not say that a granule
position that is NOT -1 indicates that some packets DO finish on that page
(even though this was the intention, libogg itself violated this intention
for years before we fixed it).
The Ogg Opus specification only imposes its start-time requirements
on the granule position of the first page with completed packets,
so we ignore any set granule positions until then.*/
cur_page_gp=_of->op[op_count-1].granulepos;
/*But getting a packet without a valid granule position on the page is not
okay.*/
if(cur_page_gp==-1)return OP_EBADTIMESTAMP;
cur_page_eos=_of->op[op_count-1].e_o_s;
if(OP_LIKELY(!cur_page_eos)){
/*The EOS flag wasn't set.
Work backwards from the provided granule position to get the starting PCM
offset.*/
if(OP_UNLIKELY(op_granpos_add(&pcm_start,cur_page_gp,-total_duration)<0)){
/*The starting granule position MUST not be smaller than the amount of
audio on the first page with completed packets.*/
return OP_EBADTIMESTAMP;
}
}
else{
/*The first page with completed packets was also the last.*/
if(OP_LIKELY(op_granpos_add(&pcm_start,cur_page_gp,-total_duration)<0)){
/*If there's less audio on the page than indicated by the granule
position, then we're doing end-trimming, and the starting PCM offset
is zero by spec mandate.*/
pcm_start=0;
/*However, the end-trimming MUST not ask us to trim more samples than
exist after applying the pre-skip.*/
if(OP_UNLIKELY(op_granpos_cmp(cur_page_gp,_link->head.pre_skip)<0)){
return OP_EBADTIMESTAMP;
}
}
}
/*Timestamp the individual packets.*/
prev_packet_gp=pcm_start;
for(pi=0;pi<op_count;pi++){
if(cur_page_eos){
ogg_int64_t diff;
OP_ALWAYS_TRUE(!op_granpos_diff(&diff,cur_page_gp,prev_packet_gp));
diff=durations[pi]-diff;
/*If we have samples to trim...*/
if(diff>0){
/*If we trimmed the entire packet, stop (the spec says encoders
shouldn't do this, but we support it anyway).*/
if(OP_UNLIKELY(diff>durations[pi]))break;
_of->op[pi].granulepos=prev_packet_gp=cur_page_gp;
/*Move the EOS flag to this packet, if necessary, so we'll trim the
samples.*/
_of->op[pi].e_o_s=1;
continue;
}
}
/*Update the granule position as normal.*/
OP_ALWAYS_TRUE(!op_granpos_add(&_of->op[pi].granulepos,
prev_packet_gp,durations[pi]));
prev_packet_gp=_of->op[pi].granulepos;
}
/*Update the packet count after end-trimming.*/
_of->op_count=pi;
_of->cur_discard_count=_link->head.pre_skip;
_link->pcm_file_offset=0;
_of->prev_packet_gp=_link->pcm_start=pcm_start;
_of->prev_page_offset=page_offset;
return 0;
}
|
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), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0xdc8c
movq %rax, %r15
testq %rax, %rax
js 0xdbdc
movq %r12, %rdi
callq 0x3610
testl %eax, %eax
jne 0xdbea
movq %r12, %rdi
callq 0x3290
cmpl %r13d, %eax
jne 0xda28
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x34d0
movq 0x8(%r12), %rax
addq %rax, 0x98(%r14)
movq %r14, %rdi
leaq 0x60(%rsp), %rsi
callq 0x5de6
testl %eax, %eax
js 0xda0e
movl %eax, %ebp
movl 0x3214(%r14), %ebx
testl %ebx, %ebx
jle 0xd9bd
leal -0x1(%rbx), %eax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq 0x260(%r14,%rax), %r12
movl $0xffffff75, %r13d # imm = 0xFFFFFF75
cmpq $-0x1, %r12
jne 0xda60
movl %r13d, %eax
addq $0x468, %rsp # imm = 0x468
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %r14, %rax
addq $0x240, %rax # imm = 0x240
movl 0x18(%rax), %eax
movq %rax, 0x10(%rsp)
negl %ebp
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x459b
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
jne 0xdc5c
testl %eax, %eax
js 0xda4b
movq %r12, %rax
btsq $0x3f, %rax
movq %rax, 0x28(%rsp)
movq $-0x2, %rax
subq %r12, %rax
movq %rax, 0x20(%rsp)
cmpl $0x2, %ebx
movl $0x1, %r8d
cmovgel %ebx, %r8d
movq 0x18(%rsp), %rsi
leaq 0x260(%r14), %r13
xorl %ebp, %ebp
movq %rsi, 0x30(%rsp)
movq %r8, 0x38(%rsp)
testq %rdi, %rdi
je 0xdb2b
movq %rsi, %rcx
xorq %r12, %rcx
js 0xdb4a
movq %r12, %rax
subq %rsi, %rax
movslq 0x60(%rsp,%rbp,4), %rbx
subq %rax, %rbx
jle 0xdb0d
testq %rax, %rax
js 0xdb6e
movq %r12, (%r13)
movq $0x1, -0x8(%r13)
movl $0x8, %eax
movq %r12, %rsi
jmp 0xdb0f
xorl %eax, %eax
cmpl $0x8, %eax
jne 0xdb25
incq %rbp
addq $0x30, %r13
movq %rbx, %rax
cmpq %rbp, %r8
jne 0xdad5
jmp 0xdb9f
testl %eax, %eax
je 0xdb2e
jmp 0xdb9c
movq %rax, %rbx
movl 0x60(%rsp,%rbp,4), %edx
movq %r13, %rdi
callq 0x459b
movq 0x38(%rsp), %r8
movq 0x10(%rsp), %rdi
movq (%r13), %rsi
jmp 0xdb14
testq %r12, %r12
js 0xdb75
movq 0x28(%rsp), %rcx
subq %rsi, %rcx
jl 0xdae8
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
xorq %rax, %rcx
movq %rcx, %rax
jmp 0xdae8
movl $0x6, %eax
jmp 0xdb0f
movq %rsi, %rcx
notq %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
addq %rdx, %rcx
movq %r12, %rdx
subq %rsi, %rdx
cmpq %rcx, 0x20(%rsp)
cmovgeq %rdx, %rax
jmp 0xdae8
movl %ebp, %r8d
movl %r8d, 0x3214(%r14)
movq 0x8(%rsp), %rcx
movl 0x3c(%rcx), %eax
movl %eax, 0x80(%r14)
movq $0x0, 0x18(%rcx)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rcx)
movq %rax, 0x88(%r14)
movq %r15, 0x90(%r14)
xorl %r13d, %r13d
jmp 0xda4b
cmpq $-0x1, %r15
je 0xdc26
movl %r15d, %r13d
jmp 0xda4b
movl $0xffffff75, %r13d # imm = 0xFFFFFF75
movq 0x8(%rsp), %rax
cmpl $0x0, 0x3c(%rax)
jne 0xda4b
xorps %xmm0, %xmm0
movq 0x8(%rsp), %rcx
movups %xmm0, 0x18(%rcx)
movq $0x0, 0x28(%rcx)
movq 0x8(%rcx), %rax
movq %rax, 0x10(%rcx)
movl $0x1, %r13d
jmp 0xda4b
movl $0xffffff75, %r13d # imm = 0xFFFFFF75
movq 0x8(%rsp), %rax
cmpl $0x0, 0x3c(%rax)
jne 0xda4b
xorps %xmm0, %xmm0
movq 0x8(%rsp), %rcx
movups %xmm0, 0x18(%rcx)
movq $0x0, 0x28(%rcx)
movq 0x8(%rcx), %rax
movq %rax, 0x10(%rcx)
jmp 0xdbd4
testl %eax, %eax
jns 0xda94
movq $0x0, 0x18(%rsp)
testq %r12, %r12
js 0xda94
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %eax
cmpq %rax, %r12
jge 0xda94
jmp 0xda4b
|
/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;
int ret;
/*Send more paramedics.*/
if(!_boundary)return OP_FALSE;
if(_boundary<0)read_nbytes=OP_READ_SIZE;
else{
opus_int64 position;
position=op_position(_of);
if(position>=_boundary)return OP_FALSE;
read_nbytes=(int)OP_MIN(_boundary-position,OP_READ_SIZE);
}
ret=op_get_data(_of,read_nbytes);
if(OP_UNLIKELY(ret<0))return OP_EREAD;
if(OP_UNLIKELY(ret==0)){
/*Only fail cleanly on EOF if we didn't have a known boundary.
Otherwise, we should have been able to reach that boundary, and this
is a fatal error.*/
return OP_UNLIKELY(_boundary<0)?OP_FALSE:OP_EBADLINK;
}
}
else{
/*Got a page.
Return the page start offset and advance the internal offset past the
page end.*/
opus_int64 page_offset;
page_offset=_of->offset;
_of->offset+=more;
OP_ASSERT(page_offset>=0);
return page_offset;
}
}
return OP_FALSE;
}
|
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, %rdi
movq %r14, %rsi
callq 0x3220
testl %eax, %eax
js 0xdd8c
je 0xdcfd
movq 0x48(%r15), %r13
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
addq %r13, %rax
movq %rax, 0x48(%r15)
xorl %eax, %eax
testb %al, %al
jne 0xdcbe
jmp 0xddc1
testq %rbx, %rbx
je 0xdd3a
js 0xdd43
movslq 0x64(%r15), %rax
addq 0x48(%r15), %rax
movslq 0x68(%r15), %rcx
subq %rcx, %rax
movq %rbx, %rcx
subq %rax, %rcx
movl $0x800, %edx # imm = 0x800
cmpq %rdx, %rcx
cmovgeq %rdx, %rcx
cmpq %rax, %rbx
cmovgl %ecx, %ebp
movq $-0x1, %rax
cmovleq %rax, %r13
jle 0xdcf2
jmp 0xdd48
movq $-0x1, %r13
jmp 0xdcf2
movl $0x800, %ebp # imm = 0x800
movslq %ebp, %rsi
movq %r12, %rdi
callq 0x3540
testq %rax, %rax
je 0xdd99
movq 0x20(%r15), %rdi
movq %rax, %rsi
movl %ebp, %r14d
movl %ebp, %edx
callq *(%r15)
movl %eax, %ebp
testl %eax, %eax
jle 0xdd77
movl %ebp, %esi
movq %r12, %rdi
callq 0x3420
testl %ebp, %ebp
js 0xdda3
movb $0x1, %al
movl %r14d, %ebp
je 0xddb1
movq 0x8(%rsp), %r14
jmp 0xdcf4
cltq
subq %rax, 0x48(%r15)
movb $0x1, %al
jmp 0xdcf4
movl %ebp, %r14d
movl $0xffffff7f, %ebp # imm = 0xFFFFFF7F
jmp 0xdd77
movq $-0x80, %r13
xorl %eax, %eax
movl %r14d, %ebp
jmp 0xdd82
xorl %eax, %eax
movq 0x10(%rsp), %r13
jmp 0xdd82
movq $-0x1, %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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;
}
else _x<<=1;
}
ret=0;
for(i=0;i<63;i++){
if(frac&1)ret=(ret&_to&1)+(ret>>1)+(_to>>1);
else ret>>=1;
frac>>=1;
}
return ret;
}
|
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, %esi
sarq %rdx
movl $0x3f, %edi
xorl %eax, %eax
testb $0x1, %cl
jne 0xde28
sarq %rax
jmp 0xde37
movl %esi, %r8d
andl %eax, %r8d
sarq %rax
addq %rdx, %rax
addq %r8, %rax
sarq %rcx
decl %edi
jne 0xde1e
retq
movq %rdx, %rax
retq
xorl %eax, %eax
retq
|
/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;
/*Start off by guessing we're just a multiplexed page in the current link.*/
li_hi=_cur_link+1<nlinks&&_page_offset<links[_cur_link+1].offset?
_cur_link+1:nlinks;
do{
if(_page_offset>=links[_cur_link].offset)li_lo=_cur_link;
else li_hi=_cur_link;
_cur_link=li_lo+(li_hi-li_lo>>1);
}
while(li_hi-li_lo>1);
/*We've identified the link that should contain this page.
Make sure it's a page we care about.*/
if(links[_cur_link].serialno!=_serialno)return OP_FALSE;
return _cur_link;
}
|
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, %edi
jmp 0xde7e
movl %esi, %eax
movl %eax, %r9d
subl %edi, %r9d
movl %r9d, %esi
sarl %esi
addl %edi, %esi
cmpl $0x1, %r9d
jg 0xde68
movslq %esi, %rax
imulq $0x178, %rax, %rdx # imm = 0x178
cmpl %ecx, 0x30(%r8,%rdx)
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmovnel %ecx, %eax
retq
|
/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[li].head.channel_count);
}
}
else nchannels_max=OP_NCHANNELS_MAX;
_of->od_buffer=(op_sample *)_ogg_malloc(
sizeof(*_of->od_buffer)*nchannels_max*120*48);
if(_of->od_buffer==NULL)return OP_EFAULT;
return 0;
}
|
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 = 0x178
cmpq %rsi, %rcx
jne 0xdf03
movl %edx, %eax
imulq $0x5a00, %rax, %rdi # imm = 0x5A00
jmp 0xdf31
movl $0x2d000, %edi # imm = 0x2D000
jmp 0xdf31
movl $0x5a00, %edi # imm = 0x5A00
callq 0x3460
movq %rax, 0x3248(%rbx)
xorl %ecx, %ecx
testq %rax, %rax
movl $0xffffff7f, %eax # imm = 0xFFFFFF7F
cmovnel %ecx, %eax
popq %rbx
retq
|
/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==NULL)errno=ENOENT;
else fp=_wfopen(wpath,wmode);
_ogg_free(wmode);
_ogg_free(wpath);
}
#endif
if(fp!=NULL)*_cb=*op_get_file_callbacks(fp);
return fp;
}
|
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)errno=EINVAL;
else if(wpath==NULL)errno=ENOENT;
else fp=_wfreopen(wpath,wmode,(FILE *)_stream);
_ogg_free(wmode);
_ogg_free(wpath);
}
#endif
if(fp!=NULL)*_cb=*op_get_file_callbacks(fp);
return fp;
}
|
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;
stream->pos=0;
}
return stream;
}
|
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, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
|
/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.*/
return ret>0||feof(stream)?(int)ret:OP_EREAD;
}
|
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
jmp 0xe05d
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 extra runtime libraries.
i686-pc-mingw32 does not have fseeko() and requires
__MSVCRT_VERSION__>=0x800 for _fseeki64(), which screws up linking with
other libraries (that don't use MSVCRT80 from MSVC 2005 by default).
i686-w64-mingw32 does have fseeko() and respects _FILE_OFFSET_BITS, but I
don't know how to detect that at compile time.
We could just use fseeko64() (which is available in both), but it's
implemented using fgetpos()/fsetpos() just like this code, except without
the overflow checking, so we prefer our version.*/
opus_int64 pos;
/*We don't use fpos_t directly because it might be a struct if __STDC__ is
non-zero or _INTEGRAL_MAX_BITS < 64.
I'm not certain when the latter is true, but someone could in theory set
the former.
Either way, it should be binary compatible with a normal 64-bit int (this
assumption is not portable, but I believe it is true for MSVCRT).*/
OP_ASSERT(sizeof(pos)==sizeof(fpos_t));
/*Translate the seek to an absolute one.*/
if(_whence==SEEK_CUR){
int ret;
ret=fgetpos((FILE *)_stream,(fpos_t *)&pos);
if(ret)return ret;
}
else if(_whence==SEEK_END)pos=_filelengthi64(_fileno((FILE *)_stream));
else if(_whence==SEEK_SET)pos=0;
else return -1;
/*Check for errors or overflow.*/
if(pos<0||_offset<-pos||_offset>OP_INT64_MAX-pos)return -1;
pos+=_offset;
return fsetpos((FILE *)_stream,(fpos_t *)&pos);
#else
/*This function actually conforms to the SUSv2 and POSIX.1-2001, so we prefer
it except on Windows.*/
return fseeko((FILE *)_stream,(off_t)_offset,_whence);
#endif
}
|
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((FILE *)_stream,(fpos_t *)&pos)?-1:pos;
#else
/*This function actually conforms to the SUSv2 and POSIX.1-2001, so we prefer
it except on Windows.*/
return ftello((FILE *)_stream);
#endif
}
|
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;
/*Check for a short read.*/
_buf_size=(int)OP_MIN(size-pos,_buf_size);
memcpy(_ptr,stream->data+pos,_buf_size);
pos+=_buf_size;
stream->pos=pos;
return _buf_size;
}
|
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
movq %r15, %rdx
callq 0x3260
addq %r12, %r15
movq %r15, 0x10(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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;
pos=(ptrdiff_t)_offset;
}break;
case SEEK_CUR:{
/*Check for overflow:*/
if(_offset<-pos||_offset>OP_MEM_DIFF_MAX-pos)return -1;
pos=(ptrdiff_t)(pos+_offset);
}break;
case SEEK_END:{
ptrdiff_t size;
size=stream->size;
OP_ASSERT(size>=0);
/*Check for overflow:*/
if(_offset<-size||_offset>OP_MEM_DIFF_MAX-size)return -1;
pos=(ptrdiff_t)(size+_offset);
}break;
default:return -1;
}
stream->pos=pos;
return 0;
}
|
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, %r8
setl %r8b
orb %dl, %r8b
jne 0xe0e0
addq %rcx, %rsi
jmp 0xe146
movq 0x8(%rdi), %rdx
movq %rdx, %r8
negq %r8
cmpq %rsi, %r8
setle %r8b
movabsq $0x7fffffffffffffff, %r9 # imm = 0x7FFFFFFFFFFFFFFF
subq %rdx, %r9
cmpq %rsi, %r9
setge %r9b
andb %r8b, %r9b
addq %rsi, %rdx
testb %r9b, %r9b
cmovneq %rdx, %rcx
movq %rcx, %rsi
cmpb $0x1, %r9b
jne 0xe0e0
movq %rsi, 0x10(%rdi)
xorl %eax, %eax
retq
|
/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 %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
addq $0x50, %rsp
popq %rbx
retq
|
/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 *pinfo;
skip_certificate_check=0;
proxy_host=NULL;
proxy_port=8080;
proxy_user=NULL;
proxy_pass=NULL;
pinfo=NULL;
*_pinfo=NULL;
for(;;){
ptrdiff_t request;
request=va_arg(_ap,char *)-(char *)NULL;
/*If we hit NULL, we're done processing options.*/
if(!request)break;
switch(request){
case OP_SSL_SKIP_CERTIFICATE_CHECK_REQUEST:{
skip_certificate_check=!!va_arg(_ap,opus_int32);
}break;
case OP_HTTP_PROXY_HOST_REQUEST:{
proxy_host=va_arg(_ap,const char *);
}break;
case OP_HTTP_PROXY_PORT_REQUEST:{
proxy_port=va_arg(_ap,opus_int32);
if(proxy_port<0||proxy_port>(opus_int32)65535)return NULL;
}break;
case OP_HTTP_PROXY_USER_REQUEST:{
proxy_user=va_arg(_ap,const char *);
}break;
case OP_HTTP_PROXY_PASS_REQUEST:{
proxy_pass=va_arg(_ap,const char *);
}break;
case OP_GET_SERVER_INFO_REQUEST:{
pinfo=va_arg(_ap,OpusServerInfo *);
}break;
/*Some unknown option.*/
default:return NULL;
}
}
/*If the caller has requested server information, proxy it to a local copy to
simplify error handling.*/
if(pinfo!=NULL){
void *ret;
opus_server_info_init(_info);
ret=op_url_stream_create_impl(_cb,_url,skip_certificate_check,
proxy_host,proxy_port,proxy_user,proxy_pass,_info);
if(ret!=NULL)*_pinfo=pinfo;
else opus_server_info_clear(_info);
return ret;
}
return op_url_stream_create_impl(_cb,_url,skip_certificate_check,
proxy_host,proxy_port,proxy_user,proxy_pass,NULL);
}
|
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 $0x28, %r11d
ja 0xe249
movl %r11d, %r13d
addq 0x10(%r8), %r13
addl $0x8, %r11d
movl %r11d, (%r8)
jmp 0xe255
movq 0x8(%r8), %r13
leaq 0x8(%r13), %rbp
movq %rbp, 0x8(%r8)
movq (%r13), %r13
testq %r13, %r13
je 0xe29a
addq $-0x1940, %r13 # imm = 0xE6C0
rolq $0x3a, %r13
cmpq $0x5, %r13
ja 0xe316
movslq (%r15,%r13,4), %r13
addq %r15, %r13
jmpq *%r13
cmpl $0x28, %r11d
ja 0xe35a
movl %r11d, %r13d
addq 0x10(%r8), %r13
addl $0x8, %r11d
movl %r11d, (%r8)
jmp 0xe366
movl $0x2, %ebp
jmp 0xe396
cmpl $0x28, %r11d
ja 0xe31d
movl %r11d, %r10d
addq 0x10(%r8), %r10
addl $0x8, %r11d
movl %r11d, (%r8)
jmp 0xe329
cmpl $0x28, %r11d
ja 0xe32e
movl %r11d, %eax
addq 0x10(%r8), %rax
addl $0x8, %r11d
movl %r11d, (%r8)
jmp 0xe33a
cmpl $0x28, %r11d
ja 0xe349
movl %r11d, %r9d
addq 0x10(%r8), %r9
addl $0x8, %r11d
movl %r11d, (%r8)
jmp 0xe355
cmpl $0x28, %r11d
ja 0xe372
movl %r11d, %ecx
addq 0x10(%r8), %rcx
addl $0x8, %r11d
movl %r11d, (%r8)
jmp 0xe37e
cmpl $0x28, %r11d
ja 0xe383
movl %r11d, %r12d
addq 0x10(%r8), %r12
addl $0x8, %r11d
movl %r11d, (%r8)
jmp 0xe390
movl $0x1, %ebp
jmp 0xe396
movq 0x8(%r8), %r10
leaq 0x8(%r10), %r13
movq %r13, 0x8(%r8)
movq (%r10), %r10
jmp 0xe394
movq 0x8(%r8), %rax
leaq 0x8(%rax), %r13
movq %r13, 0x8(%r8)
movl (%rax), %eax
xorl %ebp, %ebp
cmpl $0x10000, %eax # imm = 0x10000
setae %bpl
jmp 0xe396
movq 0x8(%r8), %r9
leaq 0x8(%r9), %r13
movq %r13, 0x8(%r8)
movq (%r9), %r9
jmp 0xe394
movq 0x8(%r8), %r13
leaq 0x8(%r13), %rdx
movq %rdx, 0x8(%r8)
xorl %edx, %edx
cmpl $0x0, (%r13)
setne %dl
jmp 0xe394
movq 0x8(%r8), %rcx
leaq 0x8(%rcx), %r13
movq %r13, 0x8(%r8)
movq (%rcx), %rcx
jmp 0xe394
movq 0x8(%r8), %r12
leaq 0x8(%r12), %r13
movq %r13, 0x8(%r8)
movq (%r12), %r12
xorl %ebp, %ebp
testl %ebp, %ebp
je 0xe233
cmpl $0x2, %ebp
je 0xe3b8
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r12, %r12
jne 0xe3cf
movl %eax, %r8d
pushq $0x0
pushq %r10
callq 0x649e
addq $0x18, %rsp
jmp 0xe3ad
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $-0x1, 0x30(%rbx)
movl $0x0, 0x38(%rbx)
movl %eax, %r8d
pushq %rbx
pushq %r10
callq 0x649e
addq $0x10, %rsp
movq %rax, %r15
testq %rax, %rax
je 0xe408
movq %r12, (%r14)
jmp 0xe3a6
movq %rbx, %rdi
callq 0xe17a
jmp 0xe3a6
|
/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 %xmm5, 0xf0(%rsp)
movaps %xmm6, 0x100(%rsp)
movaps %xmm7, 0x110(%rsp)
leaq 0x50(%rsp), %r8
movq %r10, 0x10(%r8)
leaq 0x130(%rsp), %rax
movq %rax, 0x8(%r8)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%r8)
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq 0xe1ff
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xe4d2
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 %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
addq $0x120, %rsp # imm = 0x120
popq %rbx
retq
|
/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==NULL);
if(_error!=NULL)*_error=OP_EFAULT;
return NULL;
}
of=op_open_callbacks(source,&cb,NULL,0,_error);
if(OP_UNLIKELY(of==NULL)){
if(pinfo!=NULL)opus_server_info_clear(&info);
(*cb.close)(source);
}
else if(pinfo!=NULL)*pinfo=*&info;
return of;
}
|
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 (%rsp), %rax
testq %rbx, %rbx
je 0xe567
testq %rax, %rax
je 0xe54d
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups 0x38(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
testq %rbx, %rbx
je 0xe563
movl $0xffffff7f, (%rbx) # imm = 0xFFFFFF7F
xorl %ebx, %ebx
jmp 0xe54d
testq %rax, %rax
je 0xe576
leaq 0x8(%rsp), %rdi
callq 0xe17a
movq %r14, %rdi
callq *0x60(%rsp)
jmp 0xe54d
|
/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(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %r10, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rdx)
callq 0xe4db
addq $0xd8, %rsp
retq
|
/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==NULL);
if(_error!=NULL)*_error=OP_EFAULT;
return NULL;
}
of=op_test_callbacks(source,&cb,NULL,0,_error);
if(OP_UNLIKELY(of==NULL)){
if(pinfo!=NULL)opus_server_info_clear(&info);
(*cb.close)(source);
}
else if(pinfo!=NULL)*pinfo=*&info;
return of;
}
|
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 (%rsp), %rax
testq %rbx, %rbx
je 0xe68f
testq %rax, %rax
je 0xe675
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups 0x38(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
testq %rbx, %rbx
je 0xe68b
movl $0xffffff7f, (%rbx) # imm = 0xFFFFFF7F
xorl %ebx, %ebx
jmp 0xe675
testq %rax, %rax
je 0xe69e
leaq 0x8(%rsp), %rdi
callq 0xe17a
movq %r14, %rdi
callq *0x60(%rsp)
jmp 0xe675
|
/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(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %r10, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rdx)
callq 0xe603
addq $0xd8, %rsp
retq
|
/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 $0xd0, %r9d
addb %dil, %sil
shlb $0x4, %sil
cmpb $0x61, %r8b
cmovgel %ecx, %r9d
leaq 0x2(%rdx), %rdi
addb %r8b, %r9b
orb %sil, %r9b
movb %r9b, (%rax,%rdx)
incl %edi
jmp 0xe735
retq
|
/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(&_stream->response);
op_sb_clear(&_stream->proxy_connect);
op_sb_clear(&_stream->request);
if(_stream->connect_host!=_stream->url.host)_ogg_free(_stream->connect_host);
op_parsed_url_clear(&_stream->url);
}
|
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
testq %rdi, %rdi
je 0xe7ea
callq 0x3070
movq 0x250(%rbx), %rdi
callq 0x33f0
movq 0x240(%rbx), %rdi
callq 0x33f0
movq 0x230(%rbx), %rdi
callq 0x33f0
movq 0x270(%rbx), %rdi
cmpq 0x1b8(%rbx), %rdi
je 0xe823
callq 0x33f0
addq $0x1a0, %rbx # imm = 0x1A0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf1b4
|
/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_time_get(&resolve_time);
if(_addrs!=&_stream->addr_info||op_time_diff_ms(&resolve_time,
&_stream->resolve_time)>=OP_RESOLVE_CACHE_TIMEOUT_MS){
new_addrs=op_resolve(_stream->connect_host,_stream->connect_port);
if(OP_LIKELY(new_addrs!=NULL)){
_addrs=new_addrs;
*&_stream->resolve_time=*&resolve_time;
}
else if(OP_LIKELY(_addrs==NULL))return OP_FALSE;
}
ret=op_http_connect_impl(_stream,_conn,_addrs,_start_time);
if(new_addrs!=NULL)freeaddrinfo(new_addrs);
return ret;
}
|
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), %rcx
cmpq $0x20c49a, %rcx # imm = 0x20C49A
jg 0xe8e0
cmpq $-0x20c49a, %rcx # imm = 0xFFDF3B66
jl 0xed5d
movabsq $0x3e800000000, %rax # imm = 0x3E800000000
imulq %rax, %rcx
movq 0x68(%rsp), %rax
subq 0x228(%rbp), %rax
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
imulq %rdx
shrq $0x20, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x12, %rdx
addl %eax, %edx
addl %edx, %ecx
cmpl $0x927c0, %ecx # imm = 0x927C0
jl 0xed5d
movq 0x270(%rbp), %r15
movl 0x278(%rbp), %edx
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rbp
movaps %xmm0, (%rbp)
movaps %xmm0, 0x10(%rbp)
movaps %xmm0, 0x20(%rbp)
movl $0x1, 0x8(%rbp)
movl $0x400, (%rbp) # imm = 0x400
leaq 0x19fa(%rip), %rsi # 0x10310
xorl %r12d, %r12d
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30a0
leaq 0x20(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x3440
testl %eax, %eax
jne 0xe944
movq 0x20(%rsp), %r12
testq %r12, %r12
movq 0x10(%rsp), %rbp
je 0xed74
movups 0x60(%rsp), %xmm0
movups %xmm0, 0x220(%rbp)
movq %r12, 0x30(%rsp)
movq %r12, %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
xorl %ebx, %ebx
movl $0x0, %r12d
testq %r13, %r13
je 0xe9c4
xorl %eax, %eax
movl 0x4(%r13), %ecx
movl %ecx, %edx
orl $0x8, %edx
cmpl $0xa, %edx
jne 0xe9af
xorl %r12d, %r12d
movq 0x70(%rsp), %rdx
cmpl %eax, %r12d
jge 0xe9a5
movl $0x1, %r12d
cmpl %ecx, 0x4(%rdx)
jne 0xe993
jmp 0xe9b2
movslq %eax, %rcx
incl %eax
movq %r13, 0x70(%rsp,%rcx,8)
movl %eax, %r12d
movq 0x28(%r13), %r13
testq %r13, %r13
je 0xe9c4
movl %r12d, %eax
cmpl $0x2, %r12d
jl 0xe97d
movq 0x38(%rsp), %r15
movq 0x28(%r15), %rax
movq %rax, 0x198(%rbp)
movq 0x190(%rbp), %rax
movq %rax, 0x28(%r15)
movq %r15, 0x190(%rbp)
movq %r14, %rdi
callq 0xf181
movups (%r14), %xmm0
movups %xmm0, 0x30(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r15)
testl %r12d, %r12d
jle 0xeac0
xorl %ebx, %ebx
movslq %ebx, %r14
movq 0x70(%rsp,%r14,8), %rax
movl 0x4(%rax), %ebp
movl 0xc(%rax), %edx
movl %ebp, %edi
movl $0x1, %esi
callq 0x30d0
movl %eax, 0x20(%rsp,%r14,8)
movw $0x4, 0x24(%rsp,%r14,8)
cmpl $-0x1, %eax
je 0xea8d
movl %eax, %r15d
movl %eax, %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x3560
testl %eax, %eax
js 0xea83
orl $0x800, %eax # imm = 0x800
movl %r15d, %edi
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x3560
testl %eax, %eax
js 0xea83
movl 0x20(%rsp,%r14,8), %edi
leaq (%rsp,%r14,8), %rsi
addq $0x70, %rsi
movl %ebp, %edx
callq 0xf256
testl %eax, %eax
jg 0xed6b
je 0xeab5
movl 0x20(%rsp,%r14,8), %edi
callq 0x36a0
leaq (%rsp,%r14,8), %rdi
addq $0x70, %rdi
leaq (%rsp,%r14,8), %rsi
addq $0x78, %rsi
movl %ebx, %eax
notl %eax
addl %r12d, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x3570
decl %r12d
decl %ebx
incl %ebx
cmpl %r12d, %ebx
jl 0xea0a
cmpl %r12d, %ebx
setge %r15b
setl %al
testl %r12d, %r12d
setle %cl
orb %al, %cl
jne 0xec04
movl %r12d, %esi
leaq 0x20(%rsp), %rdi
movl $0x7530, %edx # imm = 0x7530
callq 0x34f0
testl %eax, %eax
jle 0xec04
xorl %r14d, %r14d
leaq 0x20(%rsp), %r13
movslq %r14d, %rbp
cmpw $0x0, 0x26(%rsp,%rbp,8)
je 0xebbe
movl $0x4, 0x18(%rsp)
movl 0x20(%rsp,%rbp,8), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq 0x44(%rsp), %rcx
leaq 0x18(%rsp), %r8
callq 0x3230
testl %eax, %eax
jns 0xeb3d
callq 0x3050
movl (%rax), %eax
movl %eax, 0x44(%rsp)
movb $0x1, %bl
movl 0x44(%rsp), %eax
testl %eax, %eax
je 0xebc0
cmpl $0x6a, %eax
je 0xebc0
leaq (%rsp,%rbp,8), %r15
addq $0x70, %r15
movq (%r15), %rax
movl 0x4(%rax), %edx
movq 0x28(%rax), %rax
movq %rax, (%r15)
movl 0x20(%rsp,%rbp,8), %edi
movq %r15, %rsi
callq 0xf256
testl %eax, %eax
jg 0xebc0
je 0xebbe
leaq (%rsp,%rbp,8), %rbx
addq $0x20, %rbx
movl (%rbx), %edi
callq 0x36a0
leaq (%rsp,%rbp,8), %rsi
addq $0x28, %rsi
movl %ebp, %eax
notl %eax
addl %r12d, %eax
movslq %eax, %r14
shlq $0x3, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3570
leaq 0x8(%r15), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x3570
decl %r12d
decl %ebp
xorl %ebx, %ebx
movl %ebp, %r14d
jmp 0xebc0
xorl %ebx, %ebx
testb %bl, %bl
je 0xebc9
movl %r14d, %ebx
jmp 0xebd8
incl %r14d
movl %r14d, %ebx
cmpl %r12d, %r14d
jl 0xeafa
cmpl %r12d, %ebx
setge %r15b
testl %r12d, %r12d
jle 0xec04
cmpl %r12d, %ebx
jl 0xec04
movl %r12d, %esi
movq %r13, %rdi
movl $0x7530, %edx # imm = 0x7530
callq 0x34f0
xorl %r14d, %r14d
testl %eax, %eax
jg 0xeafa
testl %r12d, %r12d
jle 0xec29
movl %ebx, %r14d
movl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r14
je 0xec21
movl 0x20(%rsp,%r13,8), %edi
callq 0x36a0
incq %r13
cmpq %r13, %r12
jne 0xec12
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testb %r15b, %r15b
je 0xec3d
movq 0x30(%rsp), %r15
jmp 0xed3c
movslq %ebx, %rbx
movq 0x70(%rsp,%rbx,8), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
movq 0x10(%rsp), %r14
movq 0x30(%rsp), %r15
je 0xec94
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
leaq 0x200(%r14), %rdi
movq %rdi, 0x1e8(%r14)
movq $0x0, 0x1f8(%r14)
movq 0x18(%rax), %rsi
movl 0x10(%rax), %edx
callq 0x3260
movq 0x1a0(%r14), %rax
cmpb $0x73, 0x4(%rax)
jne 0xecff
movq 0x180(%r14), %rdi
callq 0x3310
testq %rax, %rax
je 0xece3
movq %rax, %r14
movl 0x20(%rsp,%rbx,8), %r12d
movl %r12d, %edi
xorl %esi, %esi
callq 0x3400
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %rax, %rax
jne 0xed91
testl %ebp, %ebp
movq 0x30(%rsp), %r15
jns 0xed3c
movq %r14, %rdi
callq 0x31e0
movl 0x20(%rsp,%rbx,8), %edi
callq 0x36a0
movq 0x38(%rsp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jmp 0xed3c
movq 0x38(%rsp), %rax
movq $0x0, 0x20(%rax)
movl 0x20(%rsp,%rbx,8), %edi
movl %edi, 0x50(%rax)
movl $0x64, 0x54(%rax)
leaq 0x18(%rsp), %rcx
movl $0x1, (%rcx)
movl $0x6, %esi
movl $0x1, %edx
movl $0x4, %r8d
callq 0x3600
xorl %ebp, %ebp
testq %r15, %r15
je 0xed49
movq %r15, %rdi
callq 0x3450
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x30(%rsp)
jmp 0xe966
leal 0x1(%rbx), %r12d
jmp 0xeac0
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %r13, %r13
je 0xed49
movq $0x0, 0x30(%rsp)
movq 0x10(%rsp), %rbp
jmp 0xe966
movq %rax, %r13
movq %r14, %rdi
movq 0x10(%rsp), %r14
movq 0x1b8(%r14), %rcx
movq %rdi, 0x8(%rsp)
movl $0x37, %esi
xorl %edx, %edx
callq 0x3150
cmpl $0x0, 0x288(%r14)
jne 0xee87
movq 0x8(%rsp), %rdi
callq 0x3030
movq %rax, 0x58(%rsp)
movq 0x1b8(%r14), %rbp
movq %rbp, %rdi
callq 0xf2ce
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0xee1b
movq 0x50(%rsp), %rax
movl 0x4(%rax), %eax
cmpl $0x2, %eax
je 0xee3b
xorl %r14d, %r14d
movl $0x0, %ecx
movq %rcx, 0x48(%rsp)
cmpl $0xa, %eax
jne 0xee56
movl $0x10, %eax
movq %rax, 0x48(%rsp)
movl $0x8, %r14d
jmp 0xee4b
movq 0x58(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x3680
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x30b0
jmp 0xee82
movl $0x4, %r14d
movl $0x4, %eax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
addq 0x18(%rax), %r14
xorl %ebp, %ebp
movq 0x58(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x3680
movq %r15, %rdi
movq %r14, %rsi
movq 0x48(%rsp), %rdx
callq 0x30b0
movq 0x50(%rsp), %rdi
callq 0x3450
movq 0x10(%rsp), %r14
movq 0x188(%r14), %rsi
testq %rsi, %rsi
je 0xee9d
movq 0x8(%rsp), %rdi
callq 0x3280
cmpl $0x0, 0x248(%r14)
jg 0xf027
leaq 0x18(%rsp), %rcx
movl $0x1, (%rcx)
movl %r12d, %edi
movl $0x6, %esi
movl $0x1, %edx
movl $0x4, %r8d
callq 0x3600
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x3320
movq %r14, %rdi
callq 0x3130
leaq 0x18(%rsp), %r13
movl %r12d, (%r13)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3480
testl %eax, %eax
js 0xef0f
xorl %ecx, %ecx
movl %eax, %r14d
jmp 0xef57
movq %r15, %rdi
movl %eax, %esi
callq 0x3040
cmpl $0x2, %eax
je 0xef29
cmpl $0x3, %eax
jne 0xef4f
movw $0x4, %ax
jmp 0xef2d
movw $0x1, %ax
movw %ax, 0x1c(%rsp)
movl $0x1, %esi
movq %r13, %rdi
movl $0x7530, %edx # imm = 0x7530
callq 0x34f0
testl %eax, %eax
setg %cl
cmovlel %ebp, %r14d
jmp 0xef57
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
xorl %ecx, %ecx
testb %cl, %cl
jne 0xeefc
testl %r14d, %r14d
jle 0xf04d
movq 0x10(%rsp), %rax
cmpq $0x0, 0x188(%rax)
movq 0x8(%rsp), %r14
jne 0xf00c
leaq 0x18(%rsp), %r13
movl %r12d, (%r13)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x34a0
testl %eax, %eax
js 0xefa2
xorl %ecx, %ecx
movl %eax, %r14d
jmp 0xefea
movq %r15, %rdi
movl %eax, %esi
callq 0x3040
cmpl $0x2, %eax
je 0xefbc
cmpl $0x3, %eax
jne 0xefe2
movw $0x4, %ax
jmp 0xefc0
movw $0x1, %ax
movw %ax, 0x1c(%rsp)
movl $0x1, %esi
movq %r13, %rdi
movl $0x7530, %edx # imm = 0x7530
callq 0x34f0
testl %eax, %eax
setg %cl
cmovlel %ebp, %r14d
jmp 0xefea
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
xorl %ecx, %ecx
testb %cl, %cl
jne 0xef8f
testl %r14d, %r14d
jle 0xf04d
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3660
movq 0x10(%rsp), %rcx
movq %rax, 0x188(%rcx)
movq 0x38(%rsp), %rax
movq %r14, 0x20(%rax)
movl %r12d, 0x50(%rax)
movl $0x64, 0x54(%rax)
xorl %ebp, %ebp
jmp 0xecd2
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl %r12d, %edx
movq 0x8(%rsp), %rcx
movq %r13, %r8
callq 0x8626
testl %eax, %eax
jns 0xeee9
movl %eax, %ebp
jmp 0xf052
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movq 0x8(%rsp), %r14
jmp 0xecd2
|
/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){
/*Wrote some data.*/
_buf+=ret;
_buf_size-=ret;
continue;
}
/*Connection closed.*/
else if(ret==0)return OP_FALSE;
err=SSL_get_error(ssl_conn,ret);
/*Yes, renegotiations can cause SSL_write() to block for reading.*/
if(err==SSL_ERROR_WANT_READ)fd.events=POLLIN;
else if(err==SSL_ERROR_WANT_WRITE)fd.events=POLLOUT;
else return OP_FALSE;
}
else{
ssize_t ret;
op_reset_errno();
ret=send(fd.fd,_buf,_buf_size,0);
if(ret>0){
_buf+=ret;
OP_ASSERT(ret<=_buf_size);
_buf_size-=(int)ret;
continue;
}
err=op_errno();
if(err!=EAGAIN&&err!=EWOULDBLOCK)return OP_FALSE;
fd.events=POLLOUT;
}
if(poll(&fd,1,OP_POLL_TIMEOUT_MS)<=0)return OP_FALSE;
}
return 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
jle 0xf104
movl %eax, %ecx
addq %rcx, %r14
subl %eax, %ebx
movl $0x2, %ebp
xorl %ecx, %ecx
testb %cl, %cl
je 0xf0c3
movl $0x1, %esi
movq %r12, %rdi
movl $0x7530, %edx # imm = 0x7530
callq 0x34f0
xorl %ebp, %ebp
testl %eax, %eax
setle %bpl
testb $0x1, %bpl
jne 0xf16d
testl %ebx, %ebx
jg 0xf081
jmp 0xf169
callq 0x3050
movq %rax, %r13
movl $0x0, (%rax)
movl (%rsp), %edi
movl %ebx, %edx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x31b0
testq %rax, %rax
jle 0xf131
addq %rax, %r14
subl %eax, %ebx
movl $0x2, %ebp
jmp 0xf14a
movl $0x1, %ebp
je 0xf0a3
movq %r15, %rdi
movl %eax, %esi
callq 0x3040
xorl %ecx, %ecx
cmpl $0x3, %eax
je 0xf159
cmpl $0x2, %eax
jne 0xf0a5
movw $0x1, 0x4(%rsp)
xorl %ebp, %ebp
movb $0x1, %cl
jmp 0xf0a5
xorl %ebp, %ebp
cmpl $0xb, (%r13)
jne 0xf145
movw $0x4, 0x4(%rsp)
movb $0x1, %al
jmp 0xf14c
movl $0x1, %ebp
xorl %eax, %eax
testb %al, %al
jne 0xf0a9
jmp 0xf0c3
movw $0x4, 0x4(%rsp)
movb $0x1, %cl
xorl %ebp, %ebp
jmp 0xf0a5
xorl %eax, %eax
jmp 0xf172
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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(!clock_gettime(CLOCK_REALTIME,now));
# else
ftime(now);
# endif
}
|
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 we shut down gracefully if we can.
However, we will not wait if this would block (it's not worth the savings
from session resumption to do so).
Clients (that's us) MAY resume a TLS session that ended with an incomplete
close, according to RFC 2818, so there's no reason to make sure the server
shut things down gracefully.*/
if(_gracefully&&_conn->ssl_conn!=NULL)SSL_shutdown(_conn->ssl_conn);
op_http_conn_clear(_conn);
_conn->next_pos=-1;
_conn->ssl_conn=NULL;
_conn->fd=OP_INVALID_SOCKET;
OP_ASSERT(*_pnext==_conn);
*_pnext=_conn->next;
_conn->next=_stream->free_head;
_stream->free_head=_conn;
}
|
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)
movq $0x0, 0x20(%rbx)
movl $0xffffffff, 0x50(%rbx) # imm = 0xFFFFFFFF
movq 0x28(%rbx), %rax
movq %rax, (%r15)
movq 0x198(%r14), %rax
movq %rax, 0x28(%rbx)
movq %rbx, 0x198(%r14)
popq %rbx
popq %r14
popq %r15
retq
|
/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;
/*No more: failure.*/
if(addr==NULL)return OP_FALSE;
if(connect(_fd,addr->ai_addr,addr->ai_addrlen)>=0)return 1;
err=op_errno();
/*Winsock will set WSAEWOULDBLOCK.*/
if(OP_LIKELY(err==EINPROGRESS||err==EWOULDBLOCK))return 0;
}
}
|
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), %rsi
movl 0x10(%r15), %edx
movl %r14d, %edi
callq 0x3270
testl %eax, %eax
jns 0xf2c7
callq 0x3050
movl (%rax), %ecx
xorl %eax, %eax
cmpl $0xb, %ecx
je 0xf2bc
cmpl $0x73, %ecx
jne 0xf276
jmp 0xf2bc
movq %r15, (%rbx)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0xf2bc
|
/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, %rsp
popq %rbx
retq
|
/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:
case BIO_CTRL_SET_CLOSE:
case BIO_CTRL_FLUSH:
case BIO_CTRL_DUP:{
ret=1;
}break;
}
return ret;
}
|
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 treat any premature closes as
errors and the data received as potentially truncated," so we make very
sure to report read errors upwards.*/
do{
int err;
if(ssl_conn!=NULL){
int ret;
ret=SSL_read(ssl_conn,_buf+nread,_buf_size-nread);
OP_ASSERT(ret<=_buf_size-nread);
if(ret>0){
/*Read some data.
Keep going to see if there's more.*/
nread+=ret;
nread_unblocked+=ret;
continue;
}
/*If we already read some data, return it right now.*/
if(nread>0)break;
err=SSL_get_error(ssl_conn,ret);
if(ret==0){
/*Connection close.
Check for a clean shutdown to prevent truncation attacks.
This check always succeeds for SSLv2, as it has no "close notify"
message and thus can't verify an orderly shutdown.*/
return err==SSL_ERROR_ZERO_RETURN?0:OP_EREAD;
}
if(err==SSL_ERROR_WANT_READ)fd.events=POLLIN;
/*Yes, renegotiations can cause SSL_read() to block for writing.*/
else if(err==SSL_ERROR_WANT_WRITE)fd.events=POLLOUT;
/*Some other error.*/
else return OP_EREAD;
}
else{
ssize_t ret;
op_reset_errno();
ret=recv(fd.fd,_buf+nread,_buf_size-nread,0);
OP_ASSERT(ret<=_buf_size-nread);
if(ret>0){
/*Read some data.
Keep going to see if there's more.*/
OP_ASSERT(ret<=_buf_size-nread);
nread+=(int)ret;
nread_unblocked+=(int)ret;
continue;
}
/*If we already read some data or the connection was closed, return
right now.*/
if(ret==0||nread>0)break;
err=op_errno();
if(err!=EAGAIN&&err!=EWOULDBLOCK)return OP_EREAD;
fd.events=POLLIN;
}
_conn->read_bytes+=nread_unblocked;
op_http_conn_read_rate_update(_conn);
nread_unblocked=0;
if(!_blocking)break;
/*Need to wait to get any data at all.*/
if(poll(&fd,1,OP_POLL_TIMEOUT_MS)<=0)return OP_EREAD;
}
while(nread<_buf_size);
_conn->read_bytes+=nread_unblocked;
return nread;
}
|
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 0xf43d
movq 0x18(%rsp), %rax
leaq (%rax,%r15), %rsi
movl %r14d, %edx
subl %r15d, %edx
movq %r13, %rdi
callq 0x3060
movl %eax, %r15d
testl %eax, %eax
jle 0xf479
addl %r15d, %ebp
addl %r15d, %ebx
movl $0x3, %ecx
jmp 0xf51f
movl %r12d, %r13d
callq 0x3050
movq %rax, %r12
movl $0x0, (%rax)
movl 0x8(%rsp), %edi
addq 0x18(%rsp), %r15
movl %r14d, %eax
subl %ebp, %eax
movslq %eax, %rdx
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x30f0
testq %rax, %rax
jle 0xf487
addl %eax, %ebp
addl %eax, %ebx
movl $0x3, %ecx
jmp 0xf498
testl %ebp, %ebp
jle 0xf4ab
movl $0x2, %ecx
jmp 0xf51f
sete %al
testl %ebp, %ebp
setg %cl
orb %al, %cl
je 0xf4d2
movl $0x2, %ecx
xorl %eax, %eax
movl %r13d, %r12d
testb %al, %al
movq 0x20(%rsp), %r13
jne 0xf525
jmp 0xf55c
movq %r13, %rdi
movl %r15d, %esi
callq 0x3040
testl %r15d, %r15d
je 0xf4f5
xorl %ecx, %ecx
cmpl $0x3, %eax
je 0xf509
cmpl $0x2, %eax
jne 0xf514
movw $0x1, 0xc(%rsp)
xorl %ecx, %ecx
jmp 0xf510
xorl %ecx, %ecx
cmpl $0xb, (%r12)
jne 0xf4e6
movw $0x1, 0xc(%rsp)
movb $0x1, %al
jmp 0xf49a
movl $0xffffff80, %r12d # imm = 0xFFFFFF80
movl $0x1, %ecx
xorl %eax, %eax
jmp 0xf49d
xorl %r12d, %r12d
cmpl $0x6, %eax
sete %r12b
shll $0x7, %r12d
addl $-0x80, %r12d
jmp 0xf51a
movw $0x4, 0xc(%rsp)
movb $0x1, %al
jmp 0xf521
movl $0xffffff80, %r12d # imm = 0xFFFFFF80
movl $0x1, %ecx
xorl %eax, %eax
testb %al, %al
je 0xf55c
movslq %ebx, %rax
movq 0x10(%rsp), %rdi
addq %rax, 0x40(%rdi)
callq 0xf597
movl $0x1, %esi
leaq 0x8(%rsp), %rdi
movl $0x7530, %edx # imm = 0x7530
callq 0x34f0
xorl %ecx, %ecx
testl %eax, %eax
setle %cl
movl $0xffffff80, %eax # imm = 0xFFFFFF80
cmovlel %eax, %r12d
xorl %ebx, %ebx
testl %ecx, %ecx
je 0xf565
cmpl $0x3, %ecx
jne 0xf570
cmpl %r14d, %ebp
jl 0xf407
jmp 0xf575
cmpl $0x2, %ecx
jne 0xf583
movslq %ebx, %rax
movq 0x10(%rsp), %rcx
addq %rax, 0x40(%rcx)
jmp 0xf586
movl %r12d, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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,&_conn->read_time);
read_rate=_conn->read_rate;
read_delta_ms=OP_MAX(read_delta_ms,1);
read_rate+=read_delta_bytes*1000/read_delta_ms-read_rate+4>>3;
*&_conn->read_time=*&read_time;
_conn->read_bytes=0;
_conn->read_rate=read_rate;
}
|
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, %esi
je 0xf610
movl %eax, %edx
movzbl (%rdi,%rdx), %esi
movl $0x1, %edx
cmpl $0x9, %esi
je 0xf610
cmpl $0x20, %esi
jne 0xf614
addl %edx, %eax
jmp 0xf5c0
retq
|
/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;
/*No current connection => EOF.*/
if(ci<0)return 0;
pos=stream->conns[ci].pos;
size=stream->content_length;
/*Check for EOF.*/
if(size>=0){
if(pos>=size)return 0;
/*Check for a short read.*/
if(_buf_size>size-pos)_buf_size=(int)(size-pos);
}
nread=op_http_conn_read_body(stream,stream->conns+ci,_ptr,_buf_size);
if(OP_UNLIKELY(nread<=0)){
/*We hit an error or EOF.
Either way, we're done with this connection.*/
op_http_conn_close(stream,stream->conns+ci,&stream->lru_head,1);
stream->cur_conni=-1;
stream->pos=pos;
}
return nread;
}
|
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 0xf67b
movq %r15, %rcx
subq %rdx, %rcx
jle 0xf787
movq %rdx, 0x18(%rsp)
movl %r12d, %edx
cmpq %rdx, %rcx
cmovgel %r12d, %ecx
movl %ecx, %r12d
jmp 0xf680
movq %rdx, 0x18(%rsp)
leaq (%rbx,%rax), %r13
movq (%rbx,%rax), %r14
movq 0x8(%rbx,%rax), %r8
movq 0x10(%rbx,%rax), %rcx
movl 0x284(%rbx), %eax
testq %r8, %r8
js 0xf6a8
cmpq %r8, %r14
jge 0xf6b8
movl %eax, 0xc(%rsp)
jmp 0xf6e8
movq %r8, 0x20(%rsp)
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0xf702
xorl %ebp, %ebp
cmpq %r8, %r15
jle 0xf77f
testq %rcx, %rcx
movl %eax, 0xc(%rsp)
js 0xf7ac
testq %rcx, %rcx
jns 0xf806
movq (%r13), %r14
movq 0x8(%r13), %r8
movq 0x260(%rbx), %r15
movq %rcx, 0x10(%rsp)
movslq %r12d, %rax
movq %r8, 0x20(%rsp)
movq %r8, %r12
subq %r14, %r12
cmpq %rax, %r12
cmovgeq %rax, %r12
movq %r13, %rdi
movl %r12d, %edx
callq 0xf3d5
movl %eax, %ebp
testl %eax, %eax
js 0xf77f
movl %ebp, %eax
addq %rax, %r14
movq %r14, (%r13)
movq 0x20(%rsp), %rdx
testq %rdx, %rdx
movq 0x10(%rsp), %rcx
js 0xf77f
cmpq %r15, %rdx
setl %al
testq %rcx, %rcx
sets %cl
andb %al, %cl
cmpl $0x0, 0xc(%rsp)
setne %al
andb %cl, %al
cmpb $0x1, %al
jne 0xf77f
cmpl $0x0, 0x54(%r13)
jle 0xf77f
movslq 0x290(%rbx), %rax
imulq 0x48(%r13), %rax
sarq $0xc, %rax
movl 0x58(%r13), %ecx
movl %ecx, %esi
shrl $0x2, %esi
cmpq %rsi, %rax
cmovlq %rax, %rsi
testl %ecx, %ecx
cmovsq %rax, %rsi
movq %rdx, %rax
subq %r14, %rax
cmpq %rsi, %rax
jl 0xf798
testl %ebp, %ebp
jle 0xf868
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8991
testl %eax, %eax
jns 0xf77f
jmp 0xf89a
movq %rsi, %rbp
testl %eax, %eax
je 0xf7be
cmpl $0x0, 0x54(%r13)
jg 0xf846
movq %rcx, %r15
leaq 0x190(%rbx), %rdx
movq %rbx, %rdi
movq %r13, %r14
movq %r13, %rsi
movl $0x1, %ecx
movq %r8, %r13
callq 0xf1e5
movl 0x58(%r14), %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x8896
movq %r15, %rcx
movq %r14, %r13
testl %eax, %eax
movq %rbp, %rsi
jns 0xf6d0
jmp 0xf89a
movq %rcx, %r14
movq %rsi, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %r15
movq %r13, %rsi
callq 0x8ab7
movl $0xffffff80, %ebp # imm = 0xFFFFFF80
testl %eax, %eax
js 0xf83e
movq %r15, %r13
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %eax
movq %r14, %rcx
je 0xf6d9
testl %eax, %eax
jne 0xf8a4
movq %r15, %r13
jmp 0xf77f
movl 0x58(%r13), %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x8991
testl %eax, %eax
js 0xf89a
movq 0x10(%r13), %rcx
movq %rbp, %rsi
jmp 0xf6d0
leaq 0x190(%rbx), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movl $0x1, %ecx
callq 0xf1e5
movl $0xffffffff, 0x27c(%rbx) # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rax
movq %rax, 0x268(%rbx)
jmp 0xf787
movl $0xffffff80, %ebp # imm = 0xFFFFFF80
jmp 0xf77f
movq 0x18(%r15), %r13
leaq 0x190(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %ecx
callq 0xf1e5
movq %r13, %rcx
movl %ecx, %eax
subl %r14d, %eax
testq %r13, %r13
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmovnsl %eax, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8896
movq %r14, %rcx
movq %r15, %r13
testl %eax, %eax
movq 0x10(%rsp), %rsi
jns 0xf6d9
jmp 0xf77f
|
/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 pipeline;
int ci;
int ret;
stream=(OpusHTTPStream *)_stream;
if(!stream->seekable)return -1;
content_length=stream->content_length;
/*If we're seekable, we should have gotten a Content-Length.*/
OP_ASSERT(content_length>=0);
ci=stream->cur_conni;
pos=ci<0?content_length:stream->conns[ci].pos;
switch(_whence){
case SEEK_SET:{
/*Check for overflow:*/
if(_offset<0)return -1;
pos=_offset;
}break;
case SEEK_CUR:{
/*Check for overflow:*/
if(_offset<-pos||_offset>OP_INT64_MAX-pos)return -1;
pos+=_offset;
}break;
case SEEK_END:{
/*Check for overflow:*/
if(_offset<-content_length||_offset>OP_INT64_MAX-content_length){
return -1;
}
pos=content_length+_offset;
}break;
default:return -1;
}
/*Mark when we deactivated the active connection.*/
if(ci>=0){
op_http_conn_read_rate_update(stream->conns+ci);
*&seek_time=*&stream->conns[ci].read_time;
}
else op_time_get(&seek_time);
/*If we seeked past the end of the stream, just disable the active
connection.*/
if(pos>=content_length){
stream->cur_conni=-1;
stream->pos=pos;
return 0;
}
/*First try to find a connection we can use without waiting.*/
pnext=&stream->lru_head;
conn=stream->lru_head;
while(conn!=NULL){
opus_int64 conn_pos;
opus_int64 end_pos;
int available;
/*If this connection has been dormant too long or has made too many
requests, close it.
This is to prevent us from hitting server limits/firewall timeouts.*/
if(op_time_diff_ms(&seek_time,&conn->read_time)>
OP_CONNECTION_IDLE_TIMEOUT_MS
||conn->nrequests_left<OP_PIPELINE_MIN_REQUESTS){
op_http_conn_close(stream,conn,pnext,1);
conn=*pnext;
continue;
}
available=op_http_conn_estimate_available(conn);
conn_pos=conn->pos;
end_pos=conn->end_pos;
if(conn->next_pos>=0){
OP_ASSERT(end_pos>=0);
OP_ASSERT(conn->next_pos==end_pos);
end_pos=conn->next_end;
}
OP_ASSERT(end_pos<0||conn_pos<=end_pos);
/*Can we quickly read ahead without issuing a new request or waiting for
any more data?
If we have an oustanding request, we'll over-estimate the amount of data
it has available (because we'll count the response headers, too), but
that probably doesn't matter.*/
if(conn_pos<=pos&&pos-conn_pos<=available&&(end_pos<0||pos<end_pos)){
/*Found a suitable connection to re-use.*/
ret=op_http_conn_read_ahead(stream,conn,1,pos);
if(OP_UNLIKELY(ret<0)){
/*The connection might have become stale, so close it and keep going.*/
op_http_conn_close(stream,conn,pnext,1);
conn=*pnext;
continue;
}
/*Sucessfully resurrected this connection.*/
*pnext=conn->next;
conn->next=stream->lru_head;
stream->lru_head=conn;
stream->cur_conni=(int)(conn-stream->conns);
OP_ASSERT(stream->cur_conni>=0&&stream->cur_conni<OP_NCONNS_MAX);
return 0;
}
pnext=&conn->next;
conn=conn->next;
}
/*Chances are that didn't work, so now try to find one we can use by reading
ahead a reasonable amount and/or by issuing a new request.*/
close_pnext=NULL;
close_conn=NULL;
pnext=&stream->lru_head;
conn=stream->lru_head;
pipeline=stream->pipeline;
while(conn!=NULL){
opus_int64 conn_pos;
opus_int64 end_pos;
opus_int64 read_ahead_thresh;
int available;
int just_read_ahead;
/*Dividing by 2048 instead of 1000 scales this by nearly 1/2, biasing away
from connection re-use (and roughly compensating for the lag required to
reopen the TCP window of a connection that's been idle).
There's no overflow checking here, because it's vanishingly unlikely, and
all it would do is cause us to make poor decisions.*/
read_ahead_thresh=OP_MAX(OP_READAHEAD_THRESH_MIN,
stream->connect_rate*conn->read_rate>>11);
available=op_http_conn_estimate_available(conn);
conn_pos=conn->pos;
end_pos=conn->end_pos;
if(conn->next_pos>=0){
OP_ASSERT(end_pos>=0);
OP_ASSERT(conn->next_pos==end_pos);
end_pos=conn->next_end;
}
OP_ASSERT(end_pos<0||conn_pos<=end_pos);
/*Can we quickly read ahead without issuing a new request?*/
just_read_ahead=conn_pos<=pos&&pos-conn_pos-available<=read_ahead_thresh
&&(end_pos<0||pos<end_pos);
if(just_read_ahead||pipeline&&end_pos>=0
&&end_pos-conn_pos-available<=read_ahead_thresh){
/*Found a suitable connection to re-use.*/
ret=op_http_conn_read_ahead(stream,conn,just_read_ahead,pos);
if(OP_UNLIKELY(ret<0)){
/*The connection might have become stale, so close it and keep going.*/
op_http_conn_close(stream,conn,pnext,1);
conn=*pnext;
continue;
}
/*Sucessfully resurrected this connection.*/
*pnext=conn->next;
conn->next=stream->lru_head;
stream->lru_head=conn;
stream->cur_conni=(int)(conn-stream->conns);
OP_ASSERT(stream->cur_conni>=0&&stream->cur_conni<OP_NCONNS_MAX);
return 0;
}
close_pnext=pnext;
close_conn=conn;
pnext=&conn->next;
conn=conn->next;
}
/*No suitable connections.
Open a new one.*/
if(stream->free_head==NULL){
/*All connections in use.
Expire one of them (we should have already picked which one when scanning
the list).*/
OP_ASSERT(close_conn!=NULL);
OP_ASSERT(close_pnext!=NULL);
op_http_conn_close(stream,close_conn,close_pnext,1);
}
OP_ASSERT(stream->free_head!=NULL);
conn=stream->free_head;
/*If we can pipeline, only request a chunk of data.
If we're seeking now, there's a good chance we will want to seek again
soon, and this avoids committing this connection to reading the rest of
the stream.
Particularly with SSL or proxies, issuing a new request on the same
connection can be substantially faster than opening a new one.
This also limits the amount of data the server will blast at us on this
connection if we later seek elsewhere and start reading from a different
connection.*/
ret=op_http_conn_open_pos(stream,conn,pos,
pipeline?OP_PIPELINE_CHUNK_SIZE:-1);
if(OP_UNLIKELY(ret<0)){
op_http_conn_close(stream,conn,&stream->lru_head,1);
return -1;
}
return 0;
}
|
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 $0x5, %rcx
movq (%rbx,%rcx), %rcx
cmpl $0x2, %edx
je 0xf98a
cmpl $0x1, %edx
je 0xf95c
testl %edx, %edx
jne 0xfb47
testq %r14, %r14
jns 0xf9b4
jmp 0xfb47
movq %rcx, %rdx
negq %rdx
cmpq %r14, %rdx
setg %dl
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
subq %rcx, %rsi
cmpq %r14, %rsi
setl %sil
orb %dl, %sil
jne 0xfb47
addq %rcx, %r14
jmp 0xf9b4
movq %r15, %rcx
negq %rcx
cmpq %r14, %rcx
setg %cl
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
subq %r15, %rdx
cmpq %r14, %rdx
setl %dl
orb %cl, %dl
jne 0xfb47
addq %r15, %r14
testl %eax, %eax
js 0xf9d6
leaq (%rax,%rax,2), %r12
shlq $0x5, %r12
leaq (%rbx,%r12), %rdi
callq 0xf597
movups 0x30(%rbx,%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
jmp 0xf9e0
leaq 0x20(%rsp), %rdi
callq 0xf181
cmpq %r15, %r14
jge 0xfb34
leaq 0x190(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x190(%rbx), %r15
testq %r15, %r15
je 0xfb58
movabsq $0x3e800000000, %r13 # imm = 0x3E800000000
movabsq $0x431bde82d7b634db, %rbp # imm = 0x431BDE82D7B634DB
movq 0x10(%rsp), %r12
movq 0x20(%rsp), %rcx
subq 0x30(%r15), %rcx
cmpq $0x20c49a, %rcx # imm = 0x20C49A
jg 0xfa6b
cmpq $-0x20c49a, %rcx # imm = 0xFFDF3B66
jl 0xfa64
movq 0x28(%rsp), %rax
subq 0x38(%r15), %rax
imulq %r13, %rcx
imulq %rbp
shrq $0x20, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x12, %rdx
addl %eax, %edx
addl %edx, %ecx
cmpl $0x1388, %ecx # imm = 0x1388
jg 0xfa6b
cmpl $0x6, 0x54(%r15)
jg 0xfa89
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x1, %ecx
callq 0xf1e5
movq (%r12), %r15
movl $0x3, %eax
jmp 0xface
movq %r15, %rdi
callq 0xfd40
xorl %ecx, %ecx
cmpq $0x0, 0x10(%r15)
setns %dl
movq %r14, %rsi
subq (%r15), %rsi
jl 0xfabe
cltq
cmpq %rax, %rsi
jg 0xfabe
movb %dl, %cl
shll $0x4, %ecx
movq 0x8(%r15,%rcx), %rax
testq %rax, %rax
js 0xfae2
cmpq %rax, %r14
jl 0xfae2
movq 0x28(%r15), %rcx
addq $0x28, %r15
xorl %eax, %eax
movq %r15, %r12
movq %rcx, %r15
cmpl $0x3, %eax
je 0xfad7
testl %eax, %eax
jne 0xfb45
testq %r15, %r15
jne 0xfa1e
jmp 0xfb58
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
movq %r14, %rcx
callq 0x8dfd
testl %eax, %eax
js 0xfa6b
movq 0x28(%r15), %rax
movq %rax, (%r12)
movq 0x190(%rbx), %rax
movq %rax, 0x28(%r15)
movq %r15, 0x190(%rbx)
movq %r15, %rax
subq %rbx, %rax
shrq $0x5, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0x27c(%rbx)
movl $0x1, %eax
jmp 0xface
movl $0xffffffff, 0x27c(%rbx) # imm = 0xFFFFFFFF
movq %r14, 0x268(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x190(%rbx), %rbp
movl 0x284(%rbx), %eax
movl %eax, 0xc(%rsp)
testq %rbp, %rbp
je 0xfca2
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %r13
xorl %r15d, %r15d
movslq 0x290(%rbx), %r12
imulq 0x48(%rbp), %r12
sarq $0xb, %r12
cmpq $0x8001, %r12 # imm = 0x8001
movl $0x8000, %eax # imm = 0x8000
cmovlq %rax, %r12
movq %rbp, %rdi
callq 0xfd40
movq (%rbp), %rcx
xorl %edx, %edx
cmpq $0x0, 0x10(%rbp)
setns %dl
shll $0x4, %edx
movq 0x8(%rbp,%rdx), %rdx
cmpq %r14, %rcx
jg 0xfbd7
movslq %eax, %rsi
addq %rcx, %rsi
movq %r14, %rdi
subq %rsi, %rdi
cmpq %r12, %rdi
jle 0xfbdb
xorl %esi, %esi
jmp 0xfbec
testq %rdx, %rdx
sets %dil
cmpq %rdx, %r14
setl %sil
orb %dil, %sil
testb %sil, %sil
jne 0xfc34
cmpl $0x0, 0xc(%rsp)
je 0xfc0a
testq %rdx, %rdx
js 0xfc0a
cltq
addq %rax, %rcx
subq %rcx, %rdx
cmpq %r12, %rdx
jle 0xfc34
movq %r13, %r15
leaq 0x28(%rbp), %r13
movq %rbp, 0x18(%rsp)
movq 0x28(%rbp), %rbp
xorl %eax, %eax
cmpl $0x5, %eax
je 0xfc29
testl %eax, %eax
jne 0xfb45
testq %rbp, %rbp
jne 0xfb83
jmp 0xfcae
movzbl %sil, %edx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rcx
callq 0x8dfd
testl %eax, %eax
js 0xfc81
movq 0x28(%rbp), %rax
movq %rax, (%r13)
movq 0x190(%rbx), %rax
movq %rax, 0x28(%rbp)
movq %rbp, 0x190(%rbx)
movq %rbp, %rax
subq %rbx, %rax
shrq $0x5, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0x27c(%rbx)
movl $0x1, %eax
jmp 0xfc1c
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0xf1e5
movq (%r13), %rbp
movl $0x5, %eax
jmp 0xfc1c
xorl %r15d, %r15d
movq $0x0, 0x18(%rsp)
cmpq $0x0, 0x198(%rbx)
jne 0xfccd
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0xf1e5
movq 0x198(%rbx), %r15
xorl %ebp, %ebp
cmpl $0x1, 0xc(%rsp)
movl $0x0, %ecx
sbbl %ecx, %ecx
orl $0x8000, %ecx # imm = 0x8000
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8896
testl %eax, %eax
jns 0xfb47
movq %rbx, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movl $0x1, %ecx
callq 0xf1e5
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jmp 0xfb47
|
/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.
This means we might return somewhat less than can truly be read without
blocking (if there's a partial record).
This is okay, because we're using this value to estimate network transfer
time, and we _have_ already received those bytes.
We also might return slightly more (due to protocol overhead), but that's
small enough that it probably doesn't matter.*/
if(_conn->ssl_conn!=NULL)available+=SSL_pending(_conn->ssl_conn);
return available;
}
|
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 $0x10, %rsp
popq %rbx
retq
|
/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, __int128>>, std::__or_<std::is_same<std::remove_cv<int>::type, unsigned char>, std::is_same<std::remove_cv<int>::type, unsigned short>, std::is_same<std::remove_cv<int>::type, unsigned int>, std::is_same<std::remove_cv<int>::type, unsigned long>, std::is_same<std::remove_cv<int>::type, unsigned long long>, std::is_same<std::remove_cv<int>::type, unsigned __int128>>, std::is_same<char, std::remove_cv<int>::type>>::value, std::to_chars_result>::type std::__to_chars_i<int>(char*, char*, int, int)
|
__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__]]
return { __last, errc::value_too_large };
if (__value == 0)
{
*__first = '0';
return { __first + 1, errc{} };
}
else if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value)
if (__value < 0)
{
*__first++ = '-';
__unsigned_val = _Up(~__value) + _Up(1);
}
switch (__base)
{
case 16:
return __detail::__to_chars_16(__first, __last, __unsigned_val);
case 10:
return __detail::__to_chars_10(__first, __last, __unsigned_val);
case 8:
return __detail::__to_chars_8(__first, __last, __unsigned_val);
case 2:
return __detail::__to_chars_2(__first, __last, __unsigned_val);
default:
return __detail::__to_chars(__first, __last, __unsigned_val, __base);
}
}
|
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
addq %rdx, %rax
jmpq *%rax
cmpl $0xa, %r8d
jae 0x11631
pushq $0x1
popq %r9
jmp 0x11677
movb $0x30, (%rbx)
incq %rbx
jmp 0x11696
pushq $0x4
popq %r9
movl $0x2710, %r10d # imm = 0x2710
movl %r8d, %ecx
cmpl $0x63, %ecx
jbe 0x1166e
cmpl $0x3e7, %ecx # imm = 0x3E7
jbe 0x11674
cmpl $0x2710, %ecx # imm = 0x2710
jb 0x11677
movl %ecx, %eax
xorl %edx, %edx
divl %r10d
addl $0x4, %r9d
cmpl $0x1869f, %ecx # imm = 0x1869F
movl %eax, %ecx
ja 0x1163e
addl $-0x3, %r9d
jmp 0x11677
addl $-0x2, %r9d
jmp 0x11677
decl %r9d
movq %rsi, %rax
subq %rbx, %rax
movl %r9d, %r14d
cmpq %r14, %rax
jl 0x1169b
movq %rbx, %rdi
movl %r14d, %esi
movl %r8d, %edx
callq 0x227da
addq %r14, %rbx
xorl %edi, %edi
movq %rbx, %rsi
movq %rsi, %rax
movl %edi, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movl %r8d, %edx
callq 0x1181c
jmp 0x116da
movq %rbx, %rdi
movl %r8d, %edx
callq 0x11780
jmp 0x116da
movq %rbx, %rdi
movl %r8d, %edx
callq 0x116e1
jmp 0x116da
movq %rbx, %rdi
movl %r8d, %edx
callq 0x11877
movq %rax, %rsi
movl %edx, %edi
jmp 0x1169b
|
/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 long>, std::is_same<std::remove_cv<unsigned int>::type, __int128>>, std::__or_<std::is_same<std::remove_cv<unsigned int>::type, unsigned char>, std::is_same<std::remove_cv<unsigned int>::type, unsigned short>, std::is_same<std::remove_cv<unsigned int>::type, unsigned int>, std::is_same<std::remove_cv<unsigned int>::type, unsigned long>, std::is_same<std::remove_cv<unsigned int>::type, unsigned long long>, std::is_same<std::remove_cv<unsigned int>::type, unsigned __int128>>, std::is_same<char, std::remove_cv<unsigned int>::type>>::value, std::to_chars_result>::type std::__detail::__to_chars_16<unsigned int>(char*, char*, unsigned int)
|
__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_2(__val) + 3) / 4;
if (__builtin_expect((__last - __first) < __len, 0))
{
__res.ptr = __last;
__res.ec = errc::value_too_large;
return __res;
}
static constexpr char __digits[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f'
};
unsigned __pos = __len - 1;
while (__val >= 0x100)
{
auto __num = __val & 0xF;
__val >>= 4;
__first[__pos] = __digits[__num];
__num = __val & 0xF;
__val >>= 4;
__first[__pos - 1] = __digits[__num];
__pos -= 2;
}
if (__val >= 0x10)
{
const auto __num = __val & 0xF;
__val >>= 4;
__first[1] = __digits[__num];
__first[0] = __digits[__val];
}
else
__first[0] = __digits[__val];
__res.ptr = __first + __len;
__res.ec = {};
return __res;
}
|
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
leal -0x1(%rcx), %r8d
movl %edx, %esi
movl %edx, %r9d
andl $0xf, %r9d
movl %edx, %r10d
shrl $0x4, %r10d
movb (%r9,%rax), %r9b
movl %r8d, %r11d
movb %r9b, (%rdi,%r11)
andl $0xf, %r10d
shrl $0x8, %esi
movb (%r10,%rax), %r9b
leal -0x1(%r8), %r10d
movb %r9b, (%rdi,%r10)
addl $-0x2, %r8d
cmpl $0xffff, %edx # imm = 0xFFFF
movl %esi, %edx
ja 0x1171b
jmp 0x11759
movl %edx, %esi
cmpl $0x10, %esi
jb 0x1176c
movl %esi, %edx
andl $0xf, %edx
shrl $0x4, %esi
movb (%rdx,%rax), %dl
movb %dl, 0x1(%rdi)
movl %esi, %edx
movb (%rdx,%rax), %al
movb %al, (%rdi)
addq %rdi, %rcx
xorl %edx, %edx
movq %rcx, %rax
retq
pushq $0x4b
popq %rdx
retq
|
/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 long>, std::is_same<std::remove_cv<unsigned int>::type, __int128>>, std::__or_<std::is_same<std::remove_cv<unsigned int>::type, unsigned char>, std::is_same<std::remove_cv<unsigned int>::type, unsigned short>, std::is_same<std::remove_cv<unsigned int>::type, unsigned int>, std::is_same<std::remove_cv<unsigned int>::type, unsigned long>, std::is_same<std::remove_cv<unsigned int>::type, unsigned long long>, std::is_same<std::remove_cv<unsigned int>::type, unsigned __int128>>, std::is_same<char, std::remove_cv<unsigned int>::type>>::value, std::to_chars_result>::type std::__detail::__to_chars_8<unsigned int>(char*, char*, unsigned int)
|
__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_CONSTEXPR (__gnu_cxx::__int_traits<_Tp>::__digits <= 16)
{
__len = __val > 077777u ? 6u
: __val > 07777u ? 5u
: __val > 0777u ? 4u
: __val > 077u ? 3u
: __val > 07u ? 2u
: 1u;
}
|
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
movl %ecx, %r8d
andb $0x7, %r8b
orb $0x30, %r8b
movl %esi, %r9d
movb %r8b, (%rdi,%r9)
shrl $0x6, %edx
movl %ecx, %r8d
shrb $0x3, %r8b
andb $0x7, %r8b
orb $0x30, %r8b
leal -0x1(%rsi), %r9d
movb %r8b, (%rdi,%r9)
addl $-0x2, %esi
cmpl $0xfff, %ecx # imm = 0xFFF
movl %edx, %ecx
ja 0x117b4
jmp 0x117f1
movl %ecx, %edx
cmpl $0x8, %edx
jb 0x11806
movl %edx, %ecx
shrl $0x3, %ecx
andb $0x7, %dl
orb $0x30, %dl
movb %dl, 0x1(%rdi)
movl %ecx, %edx
orb $0x30, %dl
movb %dl, (%rdi)
addq %rdi, %rax
xorl %edx, %edx
movq %rax, %rsi
movq %rsi, %rax
retq
pushq $0x4b
popq %rdx
jmp 0x11813
|
/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 long>, std::is_same<std::remove_cv<unsigned int>::type, __int128>>, std::__or_<std::is_same<std::remove_cv<unsigned int>::type, unsigned char>, std::is_same<std::remove_cv<unsigned int>::type, unsigned short>, std::is_same<std::remove_cv<unsigned int>::type, unsigned int>, std::is_same<std::remove_cv<unsigned int>::type, unsigned long>, std::is_same<std::remove_cv<unsigned int>::type, unsigned long long>, std::is_same<std::remove_cv<unsigned int>::type, unsigned __int128>>, std::is_same<char, std::remove_cv<unsigned int>::type>>::value, std::to_chars_result>::type std::__detail::__to_chars_2<unsigned int>(char*, char*, unsigned int)
|
__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(__val);
if (__builtin_expect((__last - __first) < __len, 0))
{
__res.ptr = __last;
__res.ec = errc::value_too_large;
return __res;
}
unsigned __pos = __len - 1;
while (__pos)
{
__first[__pos--] = '0' + (__val & 1);
__val >>= 1;
}
// First digit is always '1' because __to_chars_len_2 skips
// leading zero bits and std::to_chars handles zero values
// directly.
__first[0] = '1';
__res.ptr = __first + __len;
__res.ec = {};
return __res;
}
|
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, %r8b
movb %r8b, 0x1(%rdi,%rax)
shrl %edx
decq %rsi
testl %eax, %eax
movq %rsi, %rax
jne 0x1184b
movb $0x31, (%rdi)
addq %rdi, %rcx
xorl %edx, %edx
movq %rcx, %rax
retq
pushq $0x4b
popq %rdx
retq
|
/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, __base);
if (__builtin_expect((__last - __first) < __len, 0))
{
__res.ptr = __last;
__res.ec = errc::value_too_large;
return __res;
}
unsigned __pos = __len - 1;
static constexpr char __digits[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z'
};
while (__val >= (unsigned)__base)
{
auto const __quo = __val / __base;
auto const __rem = __val % __base;
__first[__pos--] = __digits[__rem];
__val = __quo;
}
*__first = __digits[__val];
__res.ptr = __first + __len;
__res.ec = {};
return __res;
}
|
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 # 0x27c10
movl %r14d, %eax
xorl %edx, %edx
divl %ebp
movb (%rdx,%rdi), %dl
movl %esi, %r8d
movb %dl, (%rbx,%r8)
decl %esi
movl %eax, %r14d
cmpl %ebp, %eax
jae 0x118ae
movl %r14d, %eax
leaq 0x1633e(%rip), %rdx # 0x27c10
movb (%rax,%rdx), %al
movb %al, (%rbx)
addq %rbx, %rcx
xorl %edx, %edx
movq %rcx, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4b
popq %rdx
jmp 0x118df
|
/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)
leaq 0x1323d(%rip), %rsi # 0x2514e
leaq 0x13241(%rip), %rdx # 0x25159
movq %rsp, %rdi
callq 0x19680
leaq 0x131b4(%rip), %rax # 0x250db
movq %rsp, %rdi
movq %rax, 0x20(%rdi)
movq $0x21, 0x28(%rdi)
leaq 0x30(%rsp), %rsi
xorl %edx, %edx
callq 0x177fe
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x11f58
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x112e0
leaq 0x1e611(%rip), %rsi # 0x30570
leaq 0x30(%rsp), %rdi
callq 0x11250
leaq 0xb0(%rsp), %rdi
callq 0x110e0
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x11fa1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x11fa1
jmp 0x11f9e
movq %rax, %rbx
leaq 0x1e5c8(%rip), %rsi # 0x30570
leaq 0x30(%rsp), %rdi
callq 0x11250
leaq 0xb0(%rsp), %rdi
callq 0x110e0
movq %rbx, %rdi
callq 0x11540
nop
|
/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)
leaq 0x13171(%rip), %rsi # 0x2517e
leaq 0x13172(%rip), %rdx # 0x25186
movq %rsp, %rdi
callq 0x19680
leaq 0x130b8(%rip), %rax # 0x250db
movq %rsp, %rdi
movq %rax, 0x20(%rdi)
movabsq $0x200000026, %rax # imm = 0x200000026
movq %rax, 0x28(%rdi)
leaq 0x30(%rsp), %rsi
xorl %edx, %edx
callq 0x177fe
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1205a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x112e0
leaq 0x1e50f(%rip), %rsi # 0x30570
leaq 0x30(%rsp), %rdi
callq 0x11250
leaq 0xb0(%rsp), %rdi
callq 0x110e0
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x120a3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x120a3
jmp 0x120a0
movq %rax, %rbx
leaq 0x1e4c6(%rip), %rsi # 0x30570
leaq 0x30(%rsp), %rdi
callq 0x11250
leaq 0xb0(%rsp), %rdi
callq 0x110e0
movq %rbx, %rdi
callq 0x11540
|
/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::SetLogger(&logger);
#endif
{
if( IUTEST_RUN_ALL_TESTS() != 0 ) return 1;
#if !defined(IUTEST_USE_GTEST)
IUTEST_EXPECT_STREQ(tap_test_str, logger.c_str());
logger.clear();
#endif
if( ::iutest::UnitTest::GetInstance()->Failed() ) return 1;
}
{
::iutest::IUTEST_FLAG(filter) = "*Hoge*";
::iutest::IUTEST_FLAG(also_run_disabled_tests) = false;
if( IUTEST_RUN_ALL_TESTS() != 0 ) return 1;
#if !defined(IUTEST_USE_GTEST) && IUTEST_HAS_ASSERTION_RETURN
IUTEST_EXPECT_STRIN("*Hoge*", logger.c_str()) << ::iutest::AssertionReturn<int>(1);
logger.clear();
#endif
}
{
::iutest::IUTEST_FLAG(filter) = NULL;
::iutest::IUTEST_FLAG(also_run_disabled_tests) = true;
if( IUTEST_RUN_ALL_TESTS() == 0 ) return 1;
#if !defined(IUTEST_USE_GTEST) && IUTEST_HAS_ASSERTION_RETURN
IUTEST_EXPECT_STRIN("not ok", logger.c_str()) << ::iutest::AssertionReturn<int>(1);
IUTEST_EXPECT_STRIN("show failed., test.", logger.c_str()) << ::iutest::AssertionReturn<int>(1);
logger.clear();
#endif
}
printf("*** Successful ***\n");
return 0;
}
|
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 0x184b0
callq 0x16e38
movq 0x110(%rax), %rsi
leaq 0xe8(%rax), %rdi
callq 0x1af56
testq %rax, %rax
je 0x1213d
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
callq 0x134c8
leaq 0x1e8ff(%rip), %r15 # 0x30a48
leaq 0x78(%rsp), %r13
movq %r15, -0x18(%r13)
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x60(%rsp), %rax
movq %rax, 0x1f369(%rip) # 0x314d8
callq 0x1352a
movq %rax, %rdi
callq 0x1359a
movl $0x1, %ebx
testl %eax, %eax
jne 0x1276f
movq 0x68(%rsp), %r8
leaq 0x12ff2(%rip), %rsi # 0x25187
leaq 0x12ff8(%rip), %rdx # 0x25194
leaq 0x155ed(%rip), %rcx # 0x27790
leaq 0x1f306(%rip), %r9 # 0x314b0
leaq 0x30(%rsp), %rdi
callq 0x135b3
cmpb $0x0, 0x50(%rsp)
jne 0x12267
leaq 0x90(%rsp), %r14
movl $0x188, %edx # imm = 0x188
movq %r14, %rdi
xorl %esi, %esi
callq 0x111b0
movq %r14, %rdi
callq 0x17610
movq 0x30(%rsp), %rsi
leaq 0x220(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x12f10
leaq 0x12edf(%rip), %rax # 0x250db
leaq 0x220(%rsp), %rdi
movq %rax, 0x20(%rdi)
movabsq $0x100000040, %rax # imm = 0x100000040
movq %rax, 0x28(%rdi)
leaq 0x90(%rsp), %rsi
xorl %edx, %edx
callq 0x177fe
leaq 0x230(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12246
movq 0x230(%rsp), %rsi
incq %rsi
callq 0x112e0
leaq 0x1e323(%rip), %rsi # 0x30570
leaq 0x90(%rsp), %rdi
callq 0x11250
leaq 0x110(%rsp), %rdi
callq 0x110e0
leaq 0x40(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x12282
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x112e0
movq $0x0, 0x70(%rsp)
movq 0x68(%rsp), %rax
movb $0x0, (%rax)
callq 0x184b0
movq %rax, %rdi
callq 0x137b2
testb %al, %al
jne 0x1276f
callq 0x16e38
movq 0x38(%rax), %rsi
leaq 0x90(%rsp), %rdi
leaq 0x220(%rsp), %rdx
callq 0x12f10
leaq 0x12ed6(%rip), %rsi # 0x251a3
leaq 0x90(%rsp), %rdi
callq 0x1380e
leaq 0xa0(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x122fb
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x112e0
callq 0x16c4e
orb $0x2, (%rax)
callq 0x16c4e
andb $-0x3, (%rax)
callq 0x1352a
movq %rax, %rdi
callq 0x1359a
testl %eax, %eax
jne 0x1276f
movq 0x68(%rsp), %rax
leaq 0x90(%rsp), %r8
movq %rax, (%r8)
leaq 0x12e73(%rip), %rsi # 0x251aa
leaq 0x12e56(%rip), %rdx # 0x25194
leaq 0x12e5e(%rip), %rcx # 0x251a3
leaq 0x8(%rsp), %rdi
callq 0x2375d
cmpb $0x0, 0x28(%rsp)
jne 0x12448
leaq 0x220(%rsp), %r14
movl $0x188, %edx # imm = 0x188
movq %r14, %rdi
xorl %esi, %esi
callq 0x111b0
movq %r14, %rdi
callq 0x17610
leaq 0x90(%rsp), %rdi
leaq 0x220(%rsp), %r14
movq %r14, %rsi
callq 0x24a4e
movl $0x1, 0x218(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x12f10
leaq 0x12d24(%rip), %rax # 0x250db
leaq 0x30(%rsp), %rdi
movq %rax, 0x20(%rdi)
movabsq $0x10000004c, %rax # imm = 0x10000004C
movq %rax, 0x28(%rdi)
leaq 0x90(%rsp), %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x177fe
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x123fc
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x112e0
leaq 0x1e16d(%rip), %r12 # 0x30570
movq %r15, %rdi
movq %r12, %rsi
callq 0x11250
movl $0x80, %ebp
addq %rbp, %r15
movq %r15, %rdi
callq 0x110e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x11250
addq %rbp, %r14
movq %r14, %rdi
callq 0x110e0
leaq 0x1e60d(%rip), %r15 # 0x30a48
leaq 0x40(%rsp), %r14
leaq 0xa0(%rsp), %rbp
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x12464
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x112e0
movq $0x0, 0x70(%rsp)
movq 0x68(%rsp), %rax
movb $0x0, (%rax)
callq 0x16e38
movq 0x38(%rax), %rsi
leaq 0x90(%rsp), %rdi
leaq 0x220(%rsp), %rdx
callq 0x12f10
leaq 0x90(%rsp), %rdi
xorl %esi, %esi
callq 0x1380e
movq 0x90(%rsp), %rdi
cmpq %rbp, %rdi
je 0x124bf
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x112e0
callq 0x16c4e
orb $0x2, (%rax)
callq 0x16c4e
callq 0x1352a
movq %rax, %rdi
callq 0x1359a
testl %eax, %eax
je 0x1276f
movq 0x68(%rsp), %rax
leaq 0x90(%rsp), %r8
movq %rax, (%r8)
leaq 0x12cbb(%rip), %rsi # 0x251b3
leaq 0x12c95(%rip), %rdx # 0x25194
leaq 0x12cb6(%rip), %rcx # 0x251bc
leaq 0x8(%rsp), %rdi
callq 0x2375d
cmpb $0x0, 0x28(%rsp)
jne 0x12605
leaq 0x220(%rsp), %rbx
movl $0x188, %edx # imm = 0x188
movq %rbx, %rdi
xorl %esi, %esi
callq 0x111b0
movq %rbx, %rdi
callq 0x17610
leaq 0x90(%rsp), %rdi
leaq 0x220(%rsp), %rbx
movq %rbx, %rsi
callq 0x24a4e
movl $0x1, 0x218(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x12f10
leaq 0x12b63(%rip), %rax # 0x250db
leaq 0x30(%rsp), %rdi
movq %rax, 0x20(%rdi)
movabsq $0x100000057, %rax # imm = 0x100000057
movq %rax, 0x28(%rdi)
leaq 0x90(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x177fe
movq %r15, %r12
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x125c0
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x112e0
leaq 0x1dfa9(%rip), %r15 # 0x30570
movq %r14, %rdi
movq %r15, %rsi
callq 0x11250
movl $0x80, %ebp
addq %rbp, %r14
movq %r14, %rdi
callq 0x110e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11250
addq %rbp, %rbx
movq %rbx, %rdi
callq 0x110e0
movq %r12, %r15
leaq 0x40(%rsp), %r14
leaq 0x18(%rsp), %r12
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1261c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x112e0
movq 0x68(%rsp), %rax
leaq 0x90(%rsp), %r8
movq %rax, (%r8)
leaq 0x12b90(%rip), %rsi # 0x251c3
leaq 0x12b5a(%rip), %rdx # 0x25194
leaq 0x12b98(%rip), %rcx # 0x251d9
leaq 0x8(%rsp), %rdi
callq 0x24b9b
cmpb $0x0, 0x28(%rsp)
jne 0x12739
leaq 0x220(%rsp), %rbx
movl $0x188, %edx # imm = 0x188
movq %rbx, %rdi
xorl %esi, %esi
callq 0x111b0
movq %rbx, %rdi
callq 0x17610
leaq 0x90(%rsp), %rdi
leaq 0x220(%rsp), %rbx
movq %rbx, %rsi
callq 0x24a4e
movq %r14, %rbp
movl $0x1, 0x218(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x12f10
leaq 0x12a25(%rip), %rax # 0x250db
leaq 0x30(%rsp), %rdi
movq %rax, 0x20(%rdi)
movabsq $0x100000058, %rax # imm = 0x100000058
movq %rax, 0x28(%rdi)
leaq 0x90(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x177fe
movq %r15, %r12
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x126f9
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x112e0
leaq 0x1de70(%rip), %r15 # 0x30570
movq %r14, %rdi
movq %r15, %rsi
callq 0x11250
movl $0x80, %ebp
addq %rbp, %r14
movq %r14, %rdi
callq 0x110e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11250
addq %rbp, %rbx
movq %rbx, %rdi
callq 0x110e0
movq %r12, %r15
leaq 0x18(%rsp), %r12
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x12750
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x112e0
movq $0x0, 0x70(%rsp)
movq 0x68(%rsp), %rax
movb $0x0, (%rax)
leaq 0x1500d(%rip), %rdi # 0x27775
callq 0x11470
xorl %ebx, %ebx
movq %r15, 0x60(%rsp)
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x1278b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x112e0
movl %ebx, %eax
addq $0x3a8, %rsp # imm = 0x3A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
jne 0x127c6
jmp 0x127d8
jmp 0x127d5
jmp 0x127fb
jmp 0x12821
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x127d8
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x127d8
movq %rax, %rbx
leaq 0x1dd91(%rip), %rsi # 0x30570
leaq 0x90(%rsp), %rdi
callq 0x11250
leaq 0x110(%rsp), %rdi
callq 0x110e0
jmp 0x127fe
movq %rax, %rbx
leaq 0x1dd6b(%rip), %rsi # 0x30570
leaq 0x220(%rsp), %rdi
callq 0x11250
leaq 0x2a0(%rsp), %rdi
callq 0x110e0
jmp 0x12824
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
jmp 0x128a9
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x12854
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x12854
movq %rax, %rbx
leaq 0x1dd15(%rip), %rsi # 0x30570
leaq 0x90(%rsp), %rdi
callq 0x11250
leaq 0x110(%rsp), %rdi
callq 0x110e0
jmp 0x1287a
movq %rax, %rbx
leaq 0x1dcef(%rip), %rsi # 0x30570
leaq 0x220(%rsp), %rdi
callq 0x11250
leaq 0x2a0(%rsp), %rdi
callq 0x110e0
jmp 0x128a0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12976
movq 0x18(%rsp), %rsi
jmp 0x12965
jmp 0x12973
jmp 0x12973
movq %rax, %rbx
movq 0x90(%rsp), %rdi
cmpq %rbp, %rdi
jne 0x128f9
jmp 0x12976
jmp 0x12973
jmp 0x12973
movq %rax, %rbx
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12976
movq 0xa0(%rsp), %rsi
jmp 0x12965
movq %rax, %rbx
leaq 0x230(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1292c
movq 0x230(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x1292c
movq %rax, %rbx
leaq 0x1dc3d(%rip), %rsi # 0x30570
leaq 0x90(%rsp), %rdi
callq 0x11250
leaq 0x110(%rsp), %rdi
callq 0x110e0
jmp 0x12952
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12976
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x12976
jmp 0x12973
jmp 0x12973
movq %rax, %rbx
leaq 0x1e0cb(%rip), %rax # 0x30a48
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x12999
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x112e0
movq %rbx, %rdi
callq 0x11540
nop
|
/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, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rsp)
callq 0x16c4e
testb $0x1, 0x1(%rax)
jne 0x12aa7
callq 0x16c4e
testb $0x2, 0x1(%rax)
jne 0x12ad4
movb 0x1ea3a(%rip), %al # 0x314d0
testb %al, %al
je 0x12b1e
testb $0x1, 0x1ea23(%rip) # 0x314c8
je 0x12ad4
addl $0x30, %ebp
leaq 0x127cb(%rip), %rdi # 0x2527c
movl %ebp, %esi
xorl %eax, %eax
callq 0x16d8c
movq 0x1ea17(%rip), %rdi # 0x314d8
testq %rdi, %rdi
je 0x12aee
movq (%rdi), %rax
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x18(%rax)
jmp 0x12af9
movq 0x1e9fd(%rip), %rdi # 0x314d8
testq %rdi, %rdi
je 0x12b11
movq (%rdi), %rax
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x18(%rax)
jmp 0x12b07
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x112f0
leaq 0x12785(%rip), %rdi # 0x25285
xorl %eax, %eax
callq 0x16d8c
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x112f0
jmp 0x12b07
leaq 0x1e9ab(%rip), %rdi # 0x314d0
callq 0x11570
testl %eax, %eax
je 0x12a9e
callq 0x16c6c
movb %al, 0x1e98b(%rip) # 0x314c8
leaq 0x1e98c(%rip), %rdi # 0x314d0
callq 0x11200
jmp 0x12a9e
movq %rax, %rbx
leaq 0x1e978(%rip), %rdi # 0x314d0
callq 0x111f0
movq %rbx, %rdi
callq 0x11540
nop
|
/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), %edx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
movl $0xa, %ecx
callq 0x115da
movb $0x0, (%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x11130
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19680
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
nop
|
/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, %rcx
jne 0x12ddd
testl %eax, %eax
setg %al
retq
|
/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, random_access_iterator_tag());
}
|
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.GetTestInfo(i);
if( !test_info->should_run() )
{
// スキップ
stream->Printf("ok %d # SKIP - %s\n", top+i, test_info->name());
}
else
{
if( test_info->HasFailure() )
{
stream->Printf("not ok %d - %s ", top+i, test_info->name() );
for( int j=0, part_count=test_info->result()->total_part_count(); j < part_count; ++j )
{
const TestPartResult& part = test_info->result()->GetTestPartResult(j);
::std::string summary = part.make_message();
// 改行を置き換え
detail::StringReplace(summary, '\n', ", ");
stream->Printf("%s. ", summary.c_str() );
}
stream->Printf("\n");
}
else
{
stream->Printf("ok %d - %s\n", top+i, test_info->name() );
}
}
}
stream->Printf("# %s ended.\n", test_suite.name());
}
|
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, %rax
movq %rax, 0x8(%rsp)
testl %eax, %eax
jle 0x131bb
movq 0x8(%rsp), %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %r13
leaq 0x6(%rsp), %r12
xorl %ebp, %ebp
movq %r14, 0x48(%rsp)
movq 0x28(%r14), %rax
movq (%rax,%rbp,8), %r15
cmpb $0x0, 0x98(%r15)
je 0x1317c
leaq 0x40(%r15), %rdi
movq %rdi, 0x50(%rsp)
callq 0x172c6
movq (%r15), %rcx
movq (%rbx), %rdx
movq 0x18(%rdx), %r8
movq %rbp, 0x18(%rsp)
movq 0x20(%rsp), %rdx
addl %ebp, %edx
movq %rbx, %rdi
testb %al, %al
je 0x1319c
leaq 0x122a8(%rip), %rsi # 0x252d4
xorl %eax, %eax
callq *%r8
movq 0x48(%r15), %rcx
subq 0x40(%r15), %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %rcx, 0x10(%rsp)
testl %ecx, %ecx
jle 0x13163
movq 0x10(%rsp), %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
movq %rbx, %r14
movq 0x50(%rsp), %rax
movq (%rax), %r15
leaq (,%rbp,2), %rbx
addq %rbp, %rbx
shlq $0x4, %rbx
movq 0x20(%r15,%rbx), %rsi
movl 0x28(%r15,%rbx), %edx
movq %r13, %rdi
callq 0x17333
movq %r13, %rdi
leaq 0x1467b(%rip), %rsi # 0x2771a
callq 0x11590
addq %rbx, %r15
movq (%r15), %rsi
movq %r13, %rdi
callq 0x11590
movw $0xa, 0x6(%rsp)
movq %r12, %rdi
callq 0x11130
movq %r13, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x11530
cmpq $-0x1, %rax
movq %r14, %rbx
leaq 0x14689(%rip), %r14 # 0x27768
je 0x13122
movq %rax, %r15
movl $0x1, %edx
movl $0x2, %r8d
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x11360
incq %r15
movq %r12, %rdi
callq 0x11130
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x11530
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x130e4
movq 0x28(%rsp), %rdx
movq (%rbx), %rcx
movq %rbx, %rdi
leaq 0x121b0(%rip), %rsi # 0x252e4
xorl %eax, %eax
callq *0x18(%rcx)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x13155
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x112e0
incq %rbp
cmpq 0x10(%rsp), %rbp
jne 0x13069
movq (%rbx), %rcx
movq %rbx, %rdi
leaq 0x13f14(%rip), %rsi # 0x27084
xorl %eax, %eax
callq *0x18(%rcx)
movq 0x48(%rsp), %r14
jmp 0x131a8
movq (%r15), %rcx
movq (%rbx), %r8
movq 0x20(%rsp), %rax
leal (%rax,%rbp), %edx
movq %rbx, %rdi
leaq 0x1212d(%rip), %rsi # 0x252c1
xorl %eax, %eax
callq *0x18(%r8)
jmp 0x131ad
leaq 0x12146(%rip), %rsi # 0x252e9
xorl %eax, %eax
callq *%r8
movq 0x18(%rsp), %rbp
incq %rbp
cmpq 0x8(%rsp), %rbp
jne 0x12fe0
movq 0x8(%r14), %rdx
movq (%rbx), %rcx
leaq 0x1212c(%rip), %rsi # 0x252f5
movq %rbx, %rdi
xorl %eax, %eax
callq *0x18(%rcx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x131e4
jmp 0x131e4
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x13203
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x112e0
movq %rbx, %rdi
callq 0x11540
nop
|
/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(%rip), %rax # 0x30bf0
movq %rax, (%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r13, %rsi
callq 0x12f10
leaq 0x10(%rbx), %r14
leaq 0xc8(%rbx), %r15
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x22866
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1329e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x112e0
leaq 0x1da7b(%rip), %rax # 0x30d20
movq %rax, (%r15)
callq 0x184b0
movq 0x8(%rbx), %rdi
incl (%rax)
movq %r14, %rsi
callq 0x22e2a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x132fa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x132fa
movq %rax, %rbx
jmp 0x132fa
movq %rax, %rbx
movq %r14, %rdi
callq 0x1746a
movq %rbx, %rdi
callq 0x11540
|
/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(%rip), %rax # 0x30bf0
movq %rax, (%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r13, %rsi
callq 0x12f10
leaq 0x10(%rbx), %r14
leaq 0xc8(%rbx), %r15
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x22866
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x133fc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x112e0
leaq 0x1d96d(%rip), %rax # 0x30d70
movq %rax, (%r15)
callq 0x184b0
movq 0x8(%rbx), %rdi
incl (%rax)
movq %r14, %rsi
callq 0x22e2a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13458
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x13458
movq %rax, %rbx
jmp 0x13458
movq %rax, %rbx
movq %r14, %rdi
callq 0x1746a
movq %rbx, %rdi
callq 0x11540
|
/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), %rsi # 0x318c8
leaq 0x1dd79(%rip), %rdx # 0x312e8
callq 0x112a0
leaq 0x1e355(%rip), %rdi # 0x318d0
callq 0x11200
jmp 0x13535
movq %rax, %rbx
leaq 0x1e344(%rip), %rdi # 0x318d0
callq 0x111f0
movq %rbx, %rdi
callq 0x11540
nop
|
/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::Compare(val1, val2) )
{
return AssertionSuccess();
}
return EqFailure(expr1, expr2
, detail::ShowStringQuoted(FormatForComparisonFailureMessage(val1, val2))
, detail::ShowStringQuoted(FormatForComparisonFailureMessage(val2, val1)));
}
|
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, %rdi
callq 0x11130
movq %rax, %rbp
movq %r12, %rdi
callq 0x11130
cmpq %rax, %rbp
jne 0x13652
testq %rbp, %rbp
je 0x13626
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x11300
testl %eax, %eax
sete %al
testb %al, %al
je 0x13652
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movb $0x1, 0x20(%rbx)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x78(%rsp), %r12
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x2225c
leaq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0x2353a
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2225c
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2353a
leaq 0x58(%rsp), %rcx
leaq 0x38(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x232d4
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x136c5
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x112e0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x136e0
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x112e0
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x136fb
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x112e0
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1363d
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x1363d
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13748
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x13748
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13768
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x13768
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13788
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x112e0
jmp 0x13788
movq %rax, %rbx
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x137a9
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x112e0
movq %rbx, %rdi
callq 0x11540
nop
|
/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 0x13803
movq (%r14), %rdi
callq 0x1cb50
addq $0x8, %r14
testb %al, %al
jne 0x137eb
xorb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
|
/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, %rdi
callq 0x19632
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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.