index int64 0 66.5k | func_name stringlengths 2 5.36k | func_dep stringlengths 16 2.19k | func stringlengths 8 55.3k | test stringlengths 0 7.07k | opt stringclasses 4 values | language stringclasses 2 values | asm stringlengths 0 45.4k | ida_asm stringlengths 0 44.7k | ida_pseudo stringlengths 0 44.3k | ghidra_asm stringlengths 0 49.1k | ghidra_pseudo stringlengths 0 64.7k |
|---|---|---|---|---|---|---|---|---|---|---|---|
22,500 | js_atomics_notify | bluesky950520[P]quickjs/quickjs.c | static JSValue js_atomics_notify(JSContext *ctx,
JSValue this_obj,
int argc, JSValue *argv)
{
struct list_head *el, *el1, waiter_list;
int32_t count, n;
void *ptr;
JSAtomicsWaiter *waiter;
JSArrayBuffer *abuf;
ptr = js_atomics_get_ptr(ctx, &abuf, NULL, NULL, argv[0], argv[1], 1);
if (!ptr)
return JS_EXCEPTION;
if (JS_IsUndefined(argv[2])) {
count = INT32_MAX;
} else {
if (JS_ToInt32Clamp(ctx, &count, argv[2], 0, INT32_MAX, 0))
return JS_EXCEPTION;
}
if (abuf->detached)
return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
n = 0;
if (abuf->shared && count > 0) {
js_mutex_lock(&js_atomics_mutex);
init_list_head(&waiter_list);
list_for_each_safe(el, el1, &js_atomics_waiter_list) {
waiter = list_entry(el, JSAtomicsWaiter, link);
if (waiter->ptr == ptr) {
list_del(&waiter->link);
waiter->linked = FALSE;
list_add_tail(&waiter->link, &waiter_list);
n++;
if (n >= count)
break;
}
}
list_for_each(el, &waiter_list) {
waiter = list_entry(el, JSAtomicsWaiter, link);
js_cond_signal(&waiter->cond);
}
js_mutex_unlock(&js_atomics_mutex);
}
return js_int32(n);
} | O1 | c | js_atomics_notify:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rdi, %r12
movq (%r8), %r8
movq 0x8(%r13), %r9
movups 0x10(%r13), %xmm0
movups %xmm0, (%rsp)
movl $0x1, 0x10(%rsp)
xorl %ebx, %ebx
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x7f9e1
movl $0x6, %r15d
testq %rax, %rax
je 0x7f9cc
movq %rax, %r14
movq 0x28(%r13), %rcx
cmpl $0x3, %ecx
jne 0x7f8c4
movl $0x7fffffff, 0x1c(%rsp) # imm = 0x7FFFFFFF
jmp 0x7f8ef
movq 0x20(%r13), %rdx
movl $0x0, (%rsp)
leaq 0x1c(%rsp), %rsi
xorl %ebx, %ebx
movq %r12, %rdi
xorl %r8d, %r8d
movl $0x7fffffff, %r9d # imm = 0x7FFFFFFF
callq 0x27756
testl %eax, %eax
jne 0x7f9cc
movq 0x20(%rsp), %rax
cmpb $0x0, 0x8(%rax)
je 0x7f912
leaq 0x22af8(%rip), %rsi # 0xa23f9
xorl %ebx, %ebx
movq %r12, %rdi
xorl %eax, %eax
callq 0x22567
jmp 0x7f9cc
cmpb $0x0, 0x9(%rax)
setne %al
movl 0x1c(%rsp), %ebp
testl %ebp, %ebp
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x7f9b9
leaq 0x4dcf4(%rip), %rdi # 0xcd628
callq 0x1c767
leaq 0x28(%rsp), %r15
movq %r15, (%r15)
movq %r15, 0x8(%r15)
movq 0x4dc0c(%rip), %rcx # 0xcd558
leaq 0x4dbfd(%rip), %rax # 0xcd550
xorl %ebx, %ebx
cmpq %rax, %rcx
je 0x7f9a0
xorps %xmm0, %xmm0
movq 0x8(%rcx), %rdx
cmpq %r14, 0x48(%rcx)
jne 0x7f996
movq (%rcx), %rsi
movq %rdx, 0x8(%rsi)
movq %rsi, (%rdx)
movups %xmm0, (%rcx)
movl $0x0, 0x10(%rcx)
movq 0x28(%rsp), %rsi
movq %rcx, 0x8(%rsi)
movq %rsi, (%rcx)
movq %r15, 0x8(%rcx)
movq %rcx, 0x28(%rsp)
incl %ebx
cmpl %ebp, %ebx
jge 0x7f99e
movq %rdx, %rcx
cmpq %rax, %rdx
jne 0x7f95d
movl %ebx, %ebx
movq 0x30(%rsp), %r14
cmpq %r15, %r14
je 0x7f9bd
leaq 0x18(%r14), %rdi
callq 0x1c7ed
movq 0x8(%r14), %r14
jmp 0x7f9a5
xorl %ebx, %ebx
jmp 0x7f9c9
leaq 0x4dc64(%rip), %rdi # 0xcd628
callq 0x1c778
xorl %r15d, %r15d
movq %rbx, %rax
movq %r15, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_atomics_notify:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r13, r8
mov r12, rdi
mov r8, [r8]
mov r9, [r13+8]
movups xmm0, xmmword ptr [r13+10h]
movups [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 1
xor ebx, ebx
lea rsi, [rsp+68h+var_48]
xor edx, edx
xor ecx, ecx
call js_atomics_get_ptr
mov r15d, 6
test rax, rax
jz loc_7F9CC
mov r14, rax
mov rcx, [r13+28h]
cmp ecx, 3
jnz short loc_7F8C4
mov [rsp+68h+var_4C], 7FFFFFFFh
jmp short loc_7F8EF
loc_7F8C4:
mov rdx, [r13+20h]
mov dword ptr [rsp+68h+var_68], 0
lea rsi, [rsp+68h+var_4C]
xor ebx, ebx
mov rdi, r12
xor r8d, r8d
mov r9d, 7FFFFFFFh
call JS_ToInt32Clamp
test eax, eax
jnz loc_7F9CC
loc_7F8EF:
mov rax, [rsp+68h+var_48]
cmp byte ptr [rax+8], 0
jz short loc_7F912
lea rsi, aArraybufferIsD; "ArrayBuffer is detached"
xor ebx, ebx
mov rdi, r12
xor eax, eax
call JS_ThrowTypeError
jmp loc_7F9CC
loc_7F912:
cmp byte ptr [rax+9], 0
setnz al
mov ebp, [rsp+68h+var_4C]
test ebp, ebp
setnle cl
and cl, al
cmp cl, 1
jnz loc_7F9B9
lea rdi, js_atomics_mutex
call js_mutex_lock
lea r15, [rsp+68h+var_40]
mov [r15], r15
mov [r15+8], r15
mov rcx, cs:off_CD558
lea rax, js_atomics_waiter_list
xor ebx, ebx
cmp rcx, rax
jz short loc_7F9A0
xorps xmm0, xmm0
loc_7F95D:
mov rdx, [rcx+8]
cmp [rcx+48h], r14
jnz short loc_7F996
mov rsi, [rcx]
mov [rsi+8], rdx
mov [rdx], rsi
movups xmmword ptr [rcx], xmm0
mov dword ptr [rcx+10h], 0
mov rsi, [rsp+68h+var_40]
mov [rsi+8], rcx
mov [rcx], rsi
mov [rcx+8], r15
mov [rsp+68h+var_40], rcx
inc ebx
cmp ebx, ebp
jge short loc_7F99E
loc_7F996:
mov rcx, rdx
cmp rdx, rax
jnz short loc_7F95D
loc_7F99E:
mov ebx, ebx
loc_7F9A0:
mov r14, [rsp+68h+var_38]
loc_7F9A5:
cmp r14, r15
jz short loc_7F9BD
lea rdi, [r14+18h]
call js_cond_signal
mov r14, [r14+8]
jmp short loc_7F9A5
loc_7F9B9:
xor ebx, ebx
jmp short loc_7F9C9
loc_7F9BD:
lea rdi, js_atomics_mutex
call js_mutex_unlock
loc_7F9C9:
xor r15d, r15d
loc_7F9CC:
mov rax, rbx
mov rdx, r15
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_atomics_notify(
long long a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13)
{
__m128 v14; // xmm0
long long v15; // rbx
long long ptr; // rax
long long v17; // rdx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
void *v22; // r14
long long v23; // rcx
int v24; // ebp
_UNKNOWN **v25; // rcx
_UNKNOWN **v26; // rdx
long long v27; // rsi
void *v28; // rsi
_QWORD *i; // r14
char v31; // [rsp+0h] [rbp-68h]
int v32; // [rsp+1Ch] [rbp-4Ch] BYREF
long long v33; // [rsp+20h] [rbp-48h] BYREF
_UNKNOWN **v34; // [rsp+28h] [rbp-40h] BYREF
_QWORD *v35; // [rsp+30h] [rbp-38h]
v14 = *(__m128 *)(a13 + 16);
v15 = 0LL;
ptr = js_atomics_get_ptr(
a1,
(unsigned int)&v33,
0,
0,
*(_QWORD *)a13,
*(_QWORD *)(a13 + 8),
*(_OWORD *)(a13 + 16),
*(_QWORD *)(a13 + 24),
1);
if ( ptr )
{
v22 = (void *)ptr;
v23 = *(_QWORD *)(a13 + 40);
if ( (_DWORD)v23 == 3 )
{
v32 = 0x7FFFFFFF;
}
else
{
v15 = 0LL;
if ( (unsigned int)JS_ToInt32Clamp(a1, &v32, *(_DWORD **)(a13 + 32), v23, 0, 0x7FFFFFFF, 0) )
return v15;
}
if ( *(_BYTE *)(v33 + 8) )
{
v15 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"ArrayBuffer is detached",
v17,
v23,
v18,
v19,
v14,
a3,
a4,
a5,
v20,
v21,
a8,
a9,
v31);
}
else
{
v24 = v32;
if ( *(_BYTE *)(v33 + 9) != 0 && v32 > 0 )
{
js_mutex_lock((long long)&js_atomics_mutex);
v34 = (_UNKNOWN **)&v34;
v35 = &v34;
v25 = off_CD558;
v15 = 0LL;
if ( off_CD558 != &js_atomics_waiter_list )
{
do
{
v26 = (_UNKNOWN **)v25[1];
if ( v25[9] == v22 )
{
v27 = (long long)*v25;
*(_QWORD *)(v27 + 8) = v26;
*v26 = (_UNKNOWN *)v27;
*(_OWORD *)v25 = 0LL;
*((_DWORD *)v25 + 4) = 0;
v28 = v34;
v34[1] = v25;
*v25 = v28;
v25[1] = &v34;
v34 = v25;
LODWORD(v15) = v15 + 1;
if ( (int)v15 >= v24 )
break;
}
v25 = v26;
}
while ( v26 != &js_atomics_waiter_list );
v15 = (unsigned int)v15;
}
for ( i = v35; i != &v34; i = (_QWORD *)i[1] )
js_cond_signal((long long)(i + 3));
js_mutex_unlock((long long)&js_atomics_mutex);
}
else
{
return 0LL;
}
}
}
return v15;
}
| |||
22,501 | js_atomics_notify | bluesky950520[P]quickjs/quickjs.c | static JSValue js_atomics_notify(JSContext *ctx,
JSValue this_obj,
int argc, JSValue *argv)
{
struct list_head *el, *el1, waiter_list;
int32_t count, n;
void *ptr;
JSAtomicsWaiter *waiter;
JSArrayBuffer *abuf;
ptr = js_atomics_get_ptr(ctx, &abuf, NULL, NULL, argv[0], argv[1], 1);
if (!ptr)
return JS_EXCEPTION;
if (JS_IsUndefined(argv[2])) {
count = INT32_MAX;
} else {
if (JS_ToInt32Clamp(ctx, &count, argv[2], 0, INT32_MAX, 0))
return JS_EXCEPTION;
}
if (abuf->detached)
return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
n = 0;
if (abuf->shared && count > 0) {
js_mutex_lock(&js_atomics_mutex);
init_list_head(&waiter_list);
list_for_each_safe(el, el1, &js_atomics_waiter_list) {
waiter = list_entry(el, JSAtomicsWaiter, link);
if (waiter->ptr == ptr) {
list_del(&waiter->link);
waiter->linked = FALSE;
list_add_tail(&waiter->link, &waiter_list);
n++;
if (n >= count)
break;
}
}
list_for_each(el, &waiter_list) {
waiter = list_entry(el, JSAtomicsWaiter, link);
js_cond_signal(&waiter->cond);
}
js_mutex_unlock(&js_atomics_mutex);
}
return js_int32(n);
} | O2 | c | js_atomics_notify:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rdi, %r12
movq (%r8), %r8
movq 0x8(%r13), %r9
movups 0x10(%r13), %xmm0
movups %xmm0, (%rsp)
movl $0x1, 0x10(%rsp)
xorl %ebx, %ebx
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6b468
pushq $0x6
popq %r15
testq %rax, %rax
je 0x6b453
movq %rax, %r14
movq 0x28(%r13), %rcx
cmpl $0x3, %ecx
jne 0x6b35e
movl $0x7fffffff, 0x1c(%rsp) # imm = 0x7FFFFFFF
jmp 0x6b386
movq 0x20(%r13), %rdx
andl $0x0, (%rsp)
leaq 0x1c(%rsp), %rsi
xorl %ebx, %ebx
movq %r12, %rdi
xorl %r8d, %r8d
movl $0x7fffffff, %r9d # imm = 0x7FFFFFFF
callq 0x213d5
testl %eax, %eax
jne 0x6b453
movq 0x20(%rsp), %rax
cmpb $0x0, 0x8(%rax)
je 0x6b3a0
movq %r12, %rdi
callq 0x32121
xorl %ebx, %ebx
jmp 0x6b453
cmpb $0x0, 0x9(%rax)
setne %al
movl 0x1c(%rsp), %ebp
testl %ebp, %ebp
setg %cl
andb %al, %cl
xorl %ebx, %ebx
cmpb $0x1, %cl
jne 0x6b450
leaq 0x50274(%rip), %rdi # 0xbb638
callq 0x16d99
leaq 0x28(%rsp), %r15
movq %r15, (%r15)
leaq 0x30(%rsp), %r12
movq %r15, (%r12)
movq 0x50187(%rip), %rcx # 0xbb568
leaq 0x50178(%rip), %rax # 0xbb560
xorps %xmm0, %xmm0
cmpq %rax, %rcx
je 0x6b439
movq %rcx, %rdx
movq 0x8(%rcx), %rcx
cmpq %r14, 0x48(%rdx)
jne 0x6b3eb
movq (%rdx), %rsi
movq %rcx, 0x8(%rsi)
movq %rsi, (%rcx)
andl $0x0, 0x10(%rdx)
movups %xmm0, (%rdx)
movq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rsi, (%rdx)
movq %r15, 0x8(%rdx)
movq %rdx, 0x28(%rsp)
incl %ebx
cmpl %ebp, %ebx
jl 0x6b3eb
jmp 0x6b439
leaq 0x18(%r12), %rdi
callq 0x16e1d
addq $0x8, %r12
movq (%r12), %r12
cmpq %r15, %r12
jne 0x6b42b
leaq 0x501ef(%rip), %rdi # 0xbb638
callq 0x16daa
movl %ebx, %ebx
xorl %r15d, %r15d
movq %rbx, %rax
movq %r15, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_atomics_notify:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r13, r8
mov r12, rdi
mov r8, [r8]
mov r9, [r13+8]
movups xmm0, xmmword ptr [r13+10h]
movups [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 1
xor ebx, ebx
lea rsi, [rsp+68h+var_48]
xor edx, edx
xor ecx, ecx
call js_atomics_get_ptr
push 6
pop r15
test rax, rax
jz loc_6B453
mov r14, rax
mov rcx, [r13+28h]
cmp ecx, 3
jnz short loc_6B35E
mov [rsp+68h+var_4C], 7FFFFFFFh
jmp short loc_6B386
loc_6B35E:
mov rdx, [r13+20h]
and dword ptr [rsp+68h+var_68], 0
lea rsi, [rsp+68h+var_4C]
xor ebx, ebx
mov rdi, r12
xor r8d, r8d
mov r9d, 7FFFFFFFh
call JS_ToInt32Clamp
test eax, eax
jnz loc_6B453
loc_6B386:
mov rax, [rsp+68h+var_48]
cmp byte ptr [rax+8], 0
jz short loc_6B3A0
mov rdi, r12
call JS_ThrowTypeErrorDetachedArrayBuffer
xor ebx, ebx
jmp loc_6B453
loc_6B3A0:
cmp byte ptr [rax+9], 0
setnz al
mov ebp, [rsp+68h+var_4C]
test ebp, ebp
setnle cl
and cl, al
xor ebx, ebx
cmp cl, 1
jnz loc_6B450
lea rdi, js_atomics_mutex
call js_mutex_lock
lea r15, [rsp+68h+var_40]
mov [r15], r15
lea r12, [rsp+68h+var_38]
mov [r12], r15
mov rcx, cs:off_BB568
lea rax, js_atomics_waiter_list
xorps xmm0, xmm0
loc_6B3EB:
cmp rcx, rax
jz short loc_6B439
mov rdx, rcx
mov rcx, [rcx+8]
cmp [rdx+48h], r14
jnz short loc_6B3EB
mov rsi, [rdx]
mov [rsi+8], rcx
mov [rcx], rsi
and dword ptr [rdx+10h], 0
movups xmmword ptr [rdx], xmm0
mov rsi, [rsp+68h+var_40]
mov [rsi+8], rdx
mov [rdx], rsi
mov [rdx+8], r15
mov [rsp+68h+var_40], rdx
inc ebx
cmp ebx, ebp
jl short loc_6B3EB
jmp short loc_6B439
loc_6B42B:
lea rdi, [r12+18h]
call js_cond_signal
add r12, 8
loc_6B439:
mov r12, [r12]
cmp r12, r15
jnz short loc_6B42B
lea rdi, js_atomics_mutex
call js_mutex_unlock
mov ebx, ebx
loc_6B450:
xor r15d, r15d
loc_6B453:
mov rax, rbx
mov rdx, r15
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_atomics_notify(
long long a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13)
{
__m128 v14; // xmm0
long long v15; // rbx
int *v16; // rsi
long long ptr; // rax
long long v18; // rdx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
long long v23; // r14
long long v24; // rcx
int v25; // ebp
_QWORD **v26; // r12
_UNKNOWN **v27; // rcx
_UNKNOWN **v28; // rdx
long long v29; // rsi
void *v30; // rsi
_QWORD *v31; // r12
char v33; // [rsp+0h] [rbp-68h]
int v34; // [rsp+1Ch] [rbp-4Ch] BYREF
long long v35; // [rsp+20h] [rbp-48h] BYREF
_UNKNOWN **v36; // [rsp+28h] [rbp-40h] BYREF
_QWORD *v37; // [rsp+30h] [rbp-38h] BYREF
v14 = *(__m128 *)(a13 + 16);
v15 = 0LL;
v16 = (int *)&v35;
ptr = js_atomics_get_ptr(
a1,
(unsigned int)&v35,
0,
0,
*(_QWORD *)a13,
*(_QWORD *)(a13 + 8),
*(_OWORD *)(a13 + 16),
*(_QWORD *)(a13 + 24),
1);
if ( ptr )
{
v23 = ptr;
v24 = *(_QWORD *)(a13 + 40);
if ( (_DWORD)v24 == 3 )
{
v34 = 0x7FFFFFFF;
}
else
{
v16 = &v34;
v15 = 0LL;
if ( (unsigned int)JS_ToInt32Clamp(a1, &v34, *(_DWORD **)(a13 + 32), v24, 0, 0x7FFFFFFF, 0) )
return v15;
}
if ( *(_BYTE *)(v35 + 8) )
{
JS_ThrowTypeErrorDetachedArrayBuffer(a1, v14, a3, a4, a5, v21, v22, a8, a9, (long long)v16, v18, v24, v19, v20, v33);
return 0LL;
}
else
{
v25 = v34;
v15 = 0LL;
if ( *(_BYTE *)(v35 + 9) != 0 && v34 > 0 )
{
js_mutex_lock((long long)&js_atomics_mutex);
v36 = (_UNKNOWN **)&v36;
v26 = &v37;
v37 = &v36;
v27 = off_BB568;
while ( v27 != &js_atomics_waiter_list )
{
v28 = v27;
v27 = (_UNKNOWN **)v27[1];
if ( v28[9] == (_UNKNOWN *)v23 )
{
v29 = (long long)*v28;
*(_QWORD *)(v29 + 8) = v27;
*v27 = (_UNKNOWN *)v29;
*((_DWORD *)v28 + 4) = 0;
*(_OWORD *)v28 = 0LL;
v30 = v36;
v36[1] = v28;
*v28 = v30;
v28[1] = &v36;
v36 = v28;
LODWORD(v15) = v15 + 1;
if ( (int)v15 >= v25 )
break;
}
}
while ( 1 )
{
v31 = *v26;
if ( v31 == &v36 )
break;
js_cond_signal((long long)(v31 + 3));
v26 = (_QWORD **)(v31 + 1);
}
js_mutex_unlock((long long)&js_atomics_mutex);
return (unsigned int)v15;
}
}
}
return v15;
}
| js_atomics_notify:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R13,R8
MOV R12,RDI
MOV R8,qword ptr [R8]
MOV R9,qword ptr [R13 + 0x8]
MOVUPS XMM0,xmmword ptr [R13 + 0x10]
MOVUPS xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x10],0x1
XOR EBX,EBX
LEA RSI,[RSP + 0x20]
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0016b468
PUSH 0x6
POP R15
TEST RAX,RAX
JZ 0x0016b453
MOV R14,RAX
MOV RCX,qword ptr [R13 + 0x28]
CMP ECX,0x3
JNZ 0x0016b35e
MOV dword ptr [RSP + 0x1c],0x7fffffff
JMP 0x0016b386
LAB_0016b35e:
MOV RDX,qword ptr [R13 + 0x20]
AND dword ptr [RSP],0x0
LEA RSI,[RSP + 0x1c]
XOR EBX,EBX
MOV RDI,R12
XOR R8D,R8D
MOV R9D,0x7fffffff
CALL 0x001213d5
TEST EAX,EAX
JNZ 0x0016b453
LAB_0016b386:
MOV RAX,qword ptr [RSP + 0x20]
CMP byte ptr [RAX + 0x8],0x0
JZ 0x0016b3a0
MOV RDI,R12
CALL 0x00132121
XOR EBX,EBX
JMP 0x0016b453
LAB_0016b3a0:
CMP byte ptr [RAX + 0x9],0x0
SETNZ AL
MOV EBP,dword ptr [RSP + 0x1c]
TEST EBP,EBP
SETG CL
AND CL,AL
XOR EBX,EBX
CMP CL,0x1
JNZ 0x0016b450
LEA RDI,[0x1bb638]
CALL 0x00116d99
LEA R15,[RSP + 0x28]
MOV qword ptr [R15],R15
LEA R12,[RSP + 0x30]
MOV qword ptr [R12],R15
MOV RCX,qword ptr [0x001bb568]
LEA RAX,[0x1bb560]
XORPS XMM0,XMM0
LAB_0016b3eb:
CMP RCX,RAX
JZ 0x0016b439
MOV RDX,RCX
MOV RCX,qword ptr [RCX + 0x8]
CMP qword ptr [RDX + 0x48],R14
JNZ 0x0016b3eb
MOV RSI,qword ptr [RDX]
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [RCX],RSI
AND dword ptr [RDX + 0x10],0x0
MOVUPS xmmword ptr [RDX],XMM0
MOV RSI,qword ptr [RSP + 0x28]
MOV qword ptr [RSI + 0x8],RDX
MOV qword ptr [RDX],RSI
MOV qword ptr [RDX + 0x8],R15
MOV qword ptr [RSP + 0x28],RDX
INC EBX
CMP EBX,EBP
JL 0x0016b3eb
JMP 0x0016b439
LAB_0016b42b:
LEA RDI,[R12 + 0x18]
CALL 0x00116e1d
ADD R12,0x8
LAB_0016b439:
MOV R12,qword ptr [R12]
CMP R12,R15
JNZ 0x0016b42b
LEA RDI,[0x1bb638]
CALL 0x00116daa
MOV EBX,EBX
LAB_0016b450:
XOR R15D,R15D
LAB_0016b453:
MOV RAX,RBX
MOV RDX,R15
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int js_atomics_notify(int8 param_1)
{
long ******pppppplVar1;
long *****ppppplVar2;
int iVar3;
long *****ppppplVar4;
long ******pppppplVar5;
int iVar6;
int8 *in_R8;
long ******pppppplVar7;
int local_4c;
long local_48;
long *****local_40;
long *****local_38;
iVar6 = 0;
ppppplVar4 = (long *****)
js_atomics_get_ptr(param_1,&local_48,0,0,*in_R8,in_R8[1],*(int4 *)(in_R8 + 2),
*(int4 *)(in_R8 + 3),1);
if (ppppplVar4 != (long *****)0x0) {
if ((int)in_R8[5] == 3) {
local_4c = 0x7fffffff;
}
else {
iVar6 = JS_ToInt32Clamp(param_1,&local_4c,in_R8[4],in_R8[5],0,0x7fffffff,0);
if (iVar6 != 0) {
return 0;
}
}
iVar3 = local_4c;
if (*(char *)(local_48 + 8) == '\0') {
iVar6 = 0;
if (0 < local_4c && *(char *)(local_48 + 9) != '\0') {
js_mutex_lock(js_atomics_mutex);
pppppplVar7 = &local_38;
local_38 = (long *****)&local_40;
pppppplVar1 = (long ******)PTR_LOOP_001bb568;
local_40 = (long *****)&local_40;
do {
do {
pppppplVar5 = pppppplVar1;
if (pppppplVar5 == (long ******)&js_atomics_waiter_list) goto LAB_0016b439;
pppppplVar1 = (long ******)pppppplVar5[1];
} while (pppppplVar5[9] != ppppplVar4);
ppppplVar2 = *pppppplVar5;
ppppplVar2[1] = (long ****)pppppplVar1;
*pppppplVar1 = ppppplVar2;
*(int4 *)(pppppplVar5 + 2) = 0;
*pppppplVar5 = (long *****)0x0;
pppppplVar5[1] = (long *****)0x0;
local_40[1] = (long ****)pppppplVar5;
*pppppplVar5 = local_40;
pppppplVar5[1] = (long *****)&local_40;
iVar6 = iVar6 + 1;
local_40 = (long *****)pppppplVar5;
} while (iVar6 < iVar3);
LAB_0016b439:
for (; pppppplVar7 = (long ******)*pppppplVar7, pppppplVar7 != &local_40;
pppppplVar7 = pppppplVar7 + 1) {
js_cond_signal(pppppplVar7 + 3);
}
js_mutex_unlock(js_atomics_mutex);
}
}
else {
JS_ThrowTypeErrorDetachedArrayBuffer(param_1);
iVar6 = 0;
}
}
return iVar6;
}
| |
22,502 | cr_compress | bluesky950520[P]quickjs/libunicode.c | static void cr_compress(CharRange *cr)
{
int i, j, k, len;
uint32_t *pt;
pt = cr->points;
len = cr->len;
i = 0;
j = 0;
k = 0;
while ((i + 1) < len) {
if (pt[i] == pt[i + 1]) {
/* empty interval */
i += 2;
} else {
j = i;
while ((j + 3) < len && pt[j + 1] == pt[j + 2])
j += 2;
/* just copy */
pt[k] = pt[i];
pt[k + 1] = pt[j + 1];
k += 2;
i = j + 2;
}
}
cr->len = k;
} | O2 | c | cr_compress:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
movq %rcx, %rdx
addq $-0x3, %rdx
xorl %esi, %esi
movabsq $0x200000000, %r8 # imm = 0x200000000
xorl %r9d, %r9d
leal 0x1(%r9), %r11d
cmpl %ecx, %r11d
jge 0x83203
movslq %r9d, %rbx
movl (%rax,%rbx,4), %r10d
movslq %r11d, %r11
cmpl (%rax,%r11,4), %r10d
je 0x831fd
movq %rbx, %r14
shlq $0x20, %r14
movq %rbx, %r9
movq %r14, %r11
cmpq %rdx, %rbx
jge 0x831e5
movl 0x4(%rax,%r9,4), %ebp
leaq 0x2(%r9), %rbx
leaq (%r11,%r8), %r14
cmpl 0x8(%rax,%r9,4), %ebp
je 0x831c6
movslq %esi, %rbx
movl %r10d, (%rax,%rbx,4)
sarq $0x1e, %r11
movl 0x4(%rax,%r11), %r10d
movl %r10d, 0x4(%rax,%rbx,4)
addl $0x2, %esi
addl $0x2, %r9d
jmp 0x831a6
movl %esi, (%rdi)
popq %rbx
popq %r14
popq %rbp
retq
| cr_compress:
push rbp
push r14
push rbx
mov rax, [rdi+8]
movsxd rcx, dword ptr [rdi]
mov rdx, rcx
add rdx, 0FFFFFFFFFFFFFFFDh
xor esi, esi
mov r8, 200000000h
xor r9d, r9d
loc_831A6:
lea r11d, [r9+1]
cmp r11d, ecx
jge short loc_83203
movsxd rbx, r9d
mov r10d, [rax+rbx*4]
movsxd r11, r11d
cmp r10d, [rax+r11*4]
jz short loc_831FD
mov r14, rbx
shl r14, 20h
loc_831C6:
mov r9, rbx
mov r11, r14
cmp rbx, rdx
jge short loc_831E5
mov ebp, [rax+r9*4+4]
lea rbx, [r9+2]
lea r14, [r11+r8]
cmp ebp, [rax+r9*4+8]
jz short loc_831C6
loc_831E5:
movsxd rbx, esi
mov [rax+rbx*4], r10d
sar r11, 1Eh
mov r10d, [rax+r11+4]
mov [rax+rbx*4+4], r10d
add esi, 2
loc_831FD:
add r9d, 2
jmp short loc_831A6
loc_83203:
mov [rdi], esi
pop rbx
pop r14
pop rbp
retn
| long long cr_compress(int *a1)
{
long long result; // rax
int v2; // ecx
long long v3; // rdx
int v4; // esi
long long v5; // r9
long long v6; // rbx
int v7; // r10d
long long v8; // r14
long long v9; // r11
int v10; // ebp
result = *((_QWORD *)a1 + 1);
v2 = *a1;
v3 = *a1 - 3LL;
v4 = 0;
LODWORD(v5) = 0;
while ( (int)v5 + 1 < v2 )
{
v6 = (int)v5;
v7 = *(_DWORD *)(result + 4LL * (int)v5);
if ( v7 != *(_DWORD *)(result + 4LL * ((int)v5 + 1)) )
{
v8 = (long long)(int)v5 << 32;
do
{
v5 = v6;
v9 = v8;
if ( v6 >= v3 )
break;
v10 = *(_DWORD *)(result + 4 * v6 + 4);
v6 += 2LL;
v8 += 0x200000000LL;
}
while ( v10 == *(_DWORD *)(result + 4 * v5 + 8) );
*(_DWORD *)(result + 4LL * v4) = v7;
*(_DWORD *)(result + 4LL * v4 + 4) = *(_DWORD *)(result + (v9 >> 30) + 4);
v4 += 2;
}
LODWORD(v5) = v5 + 2;
}
*a1 = v4;
return result;
}
| cr_compress:
PUSH RBP
PUSH R14
PUSH RBX
MOV RAX,qword ptr [RDI + 0x8]
MOVSXD RCX,dword ptr [RDI]
MOV RDX,RCX
ADD RDX,-0x3
XOR ESI,ESI
MOV R8,0x200000000
XOR R9D,R9D
LAB_001831a6:
LEA R11D,[R9 + 0x1]
CMP R11D,ECX
JGE 0x00183203
MOVSXD RBX,R9D
MOV R10D,dword ptr [RAX + RBX*0x4]
MOVSXD R11,R11D
CMP R10D,dword ptr [RAX + R11*0x4]
JZ 0x001831fd
MOV R14,RBX
SHL R14,0x20
LAB_001831c6:
MOV R9,RBX
MOV R11,R14
CMP RBX,RDX
JGE 0x001831e5
MOV EBP,dword ptr [RAX + R9*0x4 + 0x4]
LEA RBX,[R9 + 0x2]
LEA R14,[R11 + R8*0x1]
CMP EBP,dword ptr [RAX + R9*0x4 + 0x8]
JZ 0x001831c6
LAB_001831e5:
MOVSXD RBX,ESI
MOV dword ptr [RAX + RBX*0x4],R10D
SAR R11,0x1e
MOV R10D,dword ptr [RAX + R11*0x1 + 0x4]
MOV dword ptr [RAX + RBX*0x4 + 0x4],R10D
ADD ESI,0x2
LAB_001831fd:
ADD R9D,0x2
JMP 0x001831a6
LAB_00183203:
MOV dword ptr [RDI],ESI
POP RBX
POP R14
POP RBP
RET
|
void cr_compress(int *param_1)
{
int iVar1;
int iVar2;
long lVar3;
long lVar4;
ulong uVar5;
int iVar6;
ulong uVar7;
int iVar8;
long lVar9;
lVar3 = *(long *)(param_1 + 2);
iVar1 = *param_1;
iVar6 = 0;
uVar7 = 0;
do {
iVar8 = (int)uVar7 + 1;
if (iVar1 <= iVar8) {
*param_1 = iVar6;
return;
}
uVar5 = (ulong)(int)uVar7;
iVar2 = *(int *)(lVar3 + uVar5 * 4);
if (iVar2 != *(int *)(lVar3 + (long)iVar8 * 4)) {
lVar4 = uVar5 << 0x20;
do {
lVar9 = lVar4;
uVar7 = uVar5;
if ((long)iVar1 + -3 <= (long)uVar7) break;
uVar5 = uVar7 + 2;
lVar4 = lVar9 + 0x200000000;
} while (*(int *)(lVar3 + 4 + uVar7 * 4) == *(int *)(lVar3 + 8 + uVar7 * 4));
*(int *)(lVar3 + (long)iVar6 * 4) = iVar2;
*(int4 *)(lVar3 + 4 + (long)iVar6 * 4) = *(int4 *)(lVar3 + 4 + (lVar9 >> 0x1e));
iVar6 = iVar6 + 2;
}
uVar7 = (ulong)((int)uVar7 + 2);
} while( true );
}
| |
22,503 | ma_lock_key_del | eloqsql/storage/maria/ma_key_recover.c | my_bool _ma_lock_key_del(MARIA_HA *info, my_bool insert_at_end)
{
MARIA_SHARE *share= info->s;
/*
info->key_del_used is 0 initially.
If the caller needs a block (_ma_new()), we look at the free list:
- looks empty? then caller will create a new block at end of file and
remember (through info->key_del_used==2) that it will not change
state.key_del and does not need to wake up waiters as nobody will wait for
it.
- non-empty? then we wait for other users of the state.key_del list to
have finished, then we lock this list (through share->key_del_used==1)
because we need to prevent some other thread to also read state.key_del
and use the same page as ours. We remember through info->key_del_used==1
that we will have to set state.key_del at unlock time and wake up
waiters.
If the caller wants to free a block (_ma_dispose()), "empty" and
"non-empty" are treated as "non-empty" is treated above.
When we are ready to unlock, we copy share->key_del_current into
state.key_del. Unlocking happens when writing the UNDO log record, that
can make a long lock time.
Why we wrote "*looks* empty": because we are looking at state.key_del
which may be slightly old (share->key_del_current may be more recent and
exact): when we want a new page, we tolerate to treat "there was no free
page 1 millisecond ago" as "there is no free page". It's ok to non-pop
(_ma_new(), page will be found later anyway) but it's not ok to non-push
(_ma_dispose(), page would be lost).
When we leave this function, info->key_del_used is always 1 or 2.
*/
if (info->key_del_used != 1)
{
mysql_mutex_lock(&share->key_del_lock);
if (share->state.key_del == HA_OFFSET_ERROR && insert_at_end)
{
mysql_mutex_unlock(&share->key_del_lock);
info->key_del_used= 2; /* insert-with-append */
return 1;
}
while (share->key_del_used)
mysql_cond_wait(&share->key_del_cond, &share->key_del_lock);
info->key_del_used= 1;
share->key_del_used= 1;
share->key_del_current= share->state.key_del;
mysql_mutex_unlock(&share->key_del_lock);
}
return share->key_del_current == HA_OFFSET_ERROR;
} | O0 | c | ma_lock_key_del:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x67e(%rax), %eax
cmpl $0x1, %eax
je 0x71eec
movq -0x20(%rbp), %rdi
addq $0x938, %rdi # imm = 0x938
leaq 0xdfa26(%rip), %rsi # 0x151859
movl $0x57a, %edx # imm = 0x57A
callq 0x6f8d0
movq -0x20(%rbp), %rax
cmpq $-0x1, 0x120(%rax)
jne 0x71e78
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0x71e78
movq -0x20(%rbp), %rdi
addq $0x938, %rdi # imm = 0x938
callq 0x6f940
movq -0x10(%rbp), %rax
movb $0x2, 0x67e(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x71f03
jmp 0x71e7a
movq -0x20(%rbp), %rax
cmpb $0x0, 0x7e9(%rax)
je 0x71eb0
movq -0x20(%rbp), %rdi
addq $0x980, %rdi # imm = 0x980
movq -0x20(%rbp), %rsi
addq $0x938, %rsi # imm = 0x938
leaq 0xdf9b5(%rip), %rdx # 0x151859
movl $0x582, %ecx # imm = 0x582
callq 0x71f10
jmp 0x71e7a
movq -0x10(%rbp), %rax
movb $0x1, 0x67e(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x7e9(%rax)
movq -0x20(%rbp), %rax
movq 0x120(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x700(%rax)
movq -0x20(%rbp), %rdi
addq $0x938, %rdi # imm = 0x938
callq 0x6f940
movq -0x20(%rbp), %rax
cmpq $-0x1, 0x700(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| _ma_lock_key_del:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, sil
mov [rbp+var_10], rdi
mov [rbp+var_11], al
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+67Eh]
cmp eax, 1
jz loc_71EEC
mov rdi, [rbp+var_20]
add rdi, 938h
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 57Ah
call inline_mysql_mutex_lock_13
mov rax, [rbp+var_20]
cmp qword ptr [rax+120h], 0FFFFFFFFFFFFFFFFh
jnz short loc_71E78
movsx eax, [rbp+var_11]
cmp eax, 0
jz short loc_71E78
mov rdi, [rbp+var_20]
add rdi, 938h
call inline_mysql_mutex_unlock_13
mov rax, [rbp+var_10]
mov byte ptr [rax+67Eh], 2
mov [rbp+var_1], 1
jmp loc_71F03
loc_71E78:
jmp short $+2
loc_71E7A:
mov rax, [rbp+var_20]
cmp byte ptr [rax+7E9h], 0
jz short loc_71EB0
mov rdi, [rbp+var_20]
add rdi, 980h
mov rsi, [rbp+var_20]
add rsi, 938h
lea rdx, aWorkspaceLlm4b_16; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 582h
call inline_mysql_cond_wait_2
jmp short loc_71E7A
loc_71EB0:
mov rax, [rbp+var_10]
mov byte ptr [rax+67Eh], 1
mov rax, [rbp+var_20]
mov byte ptr [rax+7E9h], 1
mov rax, [rbp+var_20]
mov rcx, [rax+120h]
mov rax, [rbp+var_20]
mov [rax+700h], rcx
mov rdi, [rbp+var_20]
add rdi, 938h
call inline_mysql_mutex_unlock_13
loc_71EEC:
mov rax, [rbp+var_20]
cmp qword ptr [rax+700h], 0FFFFFFFFFFFFFFFFh
setz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
loc_71F03:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char ma_lock_key_del(long long *a1, char a2)
{
long long v3; // [rsp+0h] [rbp-20h]
v3 = *a1;
if ( *((_BYTE *)a1 + 1662) == 1 )
return *(_QWORD *)(v3 + 1792) == -1LL;
inline_mysql_mutex_lock_13(
v3 + 2360,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_key_recover.c",
0x57Au);
if ( *(_QWORD *)(v3 + 288) != -1LL || !a2 )
{
while ( *(_BYTE *)(v3 + 2025) )
inline_mysql_cond_wait_2(
v3 + 2432,
v3 + 2360,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_key_recover.c",
1410LL);
*((_BYTE *)a1 + 1662) = 1;
*(_BYTE *)(v3 + 2025) = 1;
*(_QWORD *)(v3 + 1792) = *(_QWORD *)(v3 + 288);
inline_mysql_mutex_unlock_13(v3 + 2360);
return *(_QWORD *)(v3 + 1792) == -1LL;
}
inline_mysql_mutex_unlock_13(v3 + 2360);
*((_BYTE *)a1 + 1662) = 2;
return 1;
}
| _ma_lock_key_del:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,SIL
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x67e]
CMP EAX,0x1
JZ 0x00171eec
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x938
LEA RSI,[0x251859]
MOV EDX,0x57a
CALL 0x0016f8d0
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x120],-0x1
JNZ 0x00171e78
MOVSX EAX,byte ptr [RBP + -0x11]
CMP EAX,0x0
JZ 0x00171e78
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x938
CALL 0x0016f940
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x67e],0x2
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00171f03
LAB_00171e78:
JMP 0x00171e7a
LAB_00171e7a:
MOV RAX,qword ptr [RBP + -0x20]
CMP byte ptr [RAX + 0x7e9],0x0
JZ 0x00171eb0
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x980
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x938
LEA RDX,[0x251859]
MOV ECX,0x582
CALL 0x00171f10
JMP 0x00171e7a
LAB_00171eb0:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x67e],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x7e9],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x120]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x700],RCX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x938
CALL 0x0016f940
LAB_00171eec:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x700],-0x1
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
LAB_00171f03:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
bool _ma_lock_key_del(long *param_1,char param_2)
{
long lVar1;
lVar1 = *param_1;
if (*(char *)((long)param_1 + 0x67e) != '\x01') {
inline_mysql_mutex_lock
(lVar1 + 0x938,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_key_recover.c",0x57a);
if ((*(long *)(lVar1 + 0x120) == -1) && (param_2 != '\0')) {
inline_mysql_mutex_unlock(lVar1 + 0x938);
*(int1 *)((long)param_1 + 0x67e) = 2;
return true;
}
while (*(char *)(lVar1 + 0x7e9) != '\0') {
inline_mysql_cond_wait
(lVar1 + 0x980,lVar1 + 0x938,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_key_recover.c",0x582);
}
*(int1 *)((long)param_1 + 0x67e) = 1;
*(int1 *)(lVar1 + 0x7e9) = 1;
*(int8 *)(lVar1 + 0x700) = *(int8 *)(lVar1 + 0x120);
inline_mysql_mutex_unlock(lVar1 + 0x938);
}
return *(long *)(lVar1 + 0x700) == -1;
}
| |
22,504 | inherit_charset_data | eloqsql/mysys/charset.c | static void
inherit_charset_data(struct charset_info_st *cs, CHARSET_INFO *refcs)
{
if (!cs->to_upper)
cs->to_upper= refcs->to_upper;
if (!cs->to_lower)
cs->to_lower= refcs->to_lower;
if (!cs->m_ctype)
cs->m_ctype= refcs->m_ctype;
if (!cs->tab_to_uni)
cs->tab_to_uni= refcs->tab_to_uni;
} | O0 | c | inherit_charset_data:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x2c327
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x2c342
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2c35d
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x2c378
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
popq %rbp
retq
nopw (%rax,%rax)
| inherit_charset_data:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
cmp qword ptr [rax+50h], 0
jnz short loc_2C327
mov rax, [rbp+var_10]
mov rcx, [rax+50h]
mov rax, [rbp+var_8]
mov [rax+50h], rcx
loc_2C327:
mov rax, [rbp+var_8]
cmp qword ptr [rax+48h], 0
jnz short loc_2C342
mov rax, [rbp+var_10]
mov rcx, [rax+48h]
mov rax, [rbp+var_8]
mov [rax+48h], rcx
loc_2C342:
mov rax, [rbp+var_8]
cmp qword ptr [rax+40h], 0
jnz short loc_2C35D
mov rax, [rbp+var_10]
mov rcx, [rax+40h]
mov rax, [rbp+var_8]
mov [rax+40h], rcx
loc_2C35D:
mov rax, [rbp+var_8]
cmp qword ptr [rax+68h], 0
jnz short loc_2C378
mov rax, [rbp+var_10]
mov rcx, [rax+68h]
mov rax, [rbp+var_8]
mov [rax+68h], rcx
loc_2C378:
pop rbp
retn
| _QWORD * inherit_charset_data(_QWORD *a1, _QWORD *a2)
{
_QWORD *result; // rax
if ( !a1[10] )
a1[10] = a2[10];
if ( !a1[9] )
a1[9] = a2[9];
if ( !a1[8] )
a1[8] = a2[8];
result = a1;
if ( !a1[13] )
{
result = a1;
a1[13] = a2[13];
}
return result;
}
| inherit_charset_data:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x50],0x0
JNZ 0x0012c327
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x50],RCX
LAB_0012c327:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x48],0x0
JNZ 0x0012c342
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x48],RCX
LAB_0012c342:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x0012c35d
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x40],RCX
LAB_0012c35d:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x68],0x0
JNZ 0x0012c378
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],RCX
LAB_0012c378:
POP RBP
RET
|
void inherit_charset_data(long param_1,long param_2)
{
if (*(long *)(param_1 + 0x50) == 0) {
*(int8 *)(param_1 + 0x50) = *(int8 *)(param_2 + 0x50);
}
if (*(long *)(param_1 + 0x48) == 0) {
*(int8 *)(param_1 + 0x48) = *(int8 *)(param_2 + 0x48);
}
if (*(long *)(param_1 + 0x40) == 0) {
*(int8 *)(param_1 + 0x40) = *(int8 *)(param_2 + 0x40);
}
if (*(long *)(param_1 + 0x68) == 0) {
*(int8 *)(param_1 + 0x68) = *(int8 *)(param_2 + 0x68);
}
return;
}
| |
22,505 | minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/minja.hpp | Value get_named(const std::string & name) {
for (const auto & [key, value] : kwargs) {
if (key == name) return value;
}
return Value();
} | O2 | cpp | minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
movq 0x18(%rsi), %r14
movq 0x20(%rsi), %r12
cmpq %r12, %r14
je 0x83bd4
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e220
testb %al, %al
jne 0x83bde
addq $0x70, %r14
jmp 0x83bba
movq %rbx, %rdi
callq 0x69816
jmp 0x83bed
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6beb0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN5minja14ArgumentsValue9get_namedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rdi
mov r14, [rsi+18h]
mov r12, [rsi+20h]
loc_83BBA:
cmp r14, r12
jz short loc_83BD4
mov rdi, r14
mov rsi, r15
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
test al, al
jnz short loc_83BDE
add r14, 70h ; 'p'
jmp short loc_83BBA
loc_83BD4:
mov rdi, rbx; this
call _ZN5minja5ValueC2Ev; minja::Value::Value(void)
jmp short loc_83BED
loc_83BDE:
add r14, 20h ; ' '
mov rdi, rbx; this
mov rsi, r14; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
loc_83BED:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| minja::Value * minja::ArgumentsValue::get_named(minja::Value *this, long long a2, _QWORD *a3)
{
_QWORD *v4; // r14
_QWORD *v5; // r12
v4 = *(_QWORD **)(a2 + 24);
v5 = *(_QWORD **)(a2 + 32);
while ( 1 )
{
if ( v4 == v5 )
{
minja::Value::Value(this);
return this;
}
if ( std::operator==<char>(v4, a3) )
break;
v4 += 14;
}
minja::Value::Value(this, (const minja::Value *)(v4 + 4));
return this;
}
| get_named:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RDI
MOV R14,qword ptr [RSI + 0x18]
MOV R12,qword ptr [RSI + 0x20]
LAB_00183bba:
CMP R14,R12
JZ 0x00183bd4
MOV RDI,R14
MOV RSI,R15
CALL 0x0013e220
TEST AL,AL
JNZ 0x00183bde
ADD R14,0x70
JMP 0x00183bba
LAB_00183bd4:
MOV RDI,RBX
CALL 0x00169816
JMP 0x00183bed
LAB_00183bde:
ADD R14,0x20
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016beb0
LAB_00183bed:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::ArgumentsValue::get_named(std::__cxx11::string const&) */
string * minja::ArgumentsValue::get_named(string *param_1)
{
string *psVar1;
char cVar2;
string *in_RDX;
long in_RSI;
string *psVar3;
psVar3 = *(string **)(in_RSI + 0x18);
psVar1 = *(string **)(in_RSI + 0x20);
while( true ) {
if (psVar3 == psVar1) {
Value::Value((Value *)param_1);
return param_1;
}
cVar2 = std::operator==(psVar3,in_RDX);
if (cVar2 != '\0') break;
psVar3 = psVar3 + 0x70;
}
Value::Value((Value *)param_1,(Value *)(psVar3 + 0x20));
return param_1;
}
| |
22,506 | l_delete(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned int, LF_PINS*) | eloqsql/mysys/lf_hash.cc | static int l_delete(LF_SLIST **head, CHARSET_INFO *cs, uint32 hashnr,
const uchar *key, uint keylen, LF_PINS *pins)
{
CURSOR cursor;
int res;
for (;;)
{
if (!l_find(head, cs, hashnr, key, keylen, &cursor, pins, 0))
{
res= 1; /* not found */
break;
}
else
{
/* mark the node deleted */
if (my_atomic_casptr((void **) (char*) &(cursor.curr->link),
(void **) (char*) &cursor.next,
(void *)(((intptr)cursor.next) | 1)))
{
/* and remove it from the list */
if (my_atomic_casptr((void **)cursor.prev,
(void **)(char*)&cursor.curr, cursor.next))
lf_alloc_free(pins, cursor.curr);
else
{
/*
somebody already "helped" us and removed the node ?
Let's check if we need to help that someone too!
(to ensure the number of "set DELETED flag" actions
is equal to the number of "remove from the list" actions)
*/
l_find(head, cs, hashnr, key, keylen, &cursor, pins, 0);
}
res= 0;
break;
}
}
}
lf_unpin(pins, 0);
lf_unpin(pins, 1);
lf_unpin(pins, 2);
return res;
} | O0 | cpp | l_delete(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned int, LF_PINS*):
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
movl %eax, %r8d
movq -0x30(%rbp), %rax
leaq -0x48(%rbp), %r9
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0xfe1e0
cmpl $0x0, %eax
jne 0xfdd55
movl $0x1, -0x4c(%rbp)
jmp 0xfde68
leaq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
orq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rdx
lock
cmpxchgq %rdx, (%rcx)
movq %rax, %rcx
sete %al
movb %al, -0x91(%rbp)
movq %rcx, -0x90(%rbp)
testb $0x1, %al
jne 0xfdda5
movq -0xa0(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, (%rax)
movb -0x91(%rbp), %al
andb $0x1, %al
movb %al, -0x59(%rbp)
testb $0x1, -0x59(%rbp)
je 0xfde61
leaq -0x40(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq -0x68(%rbp), %rdx
lock
cmpxchgq %rdx, (%rcx)
movq %rax, %rcx
sete %al
movb %al, -0xa9(%rbp)
movq %rcx, -0xa8(%rbp)
testb $0x1, %al
jne 0xfde06
movq -0xb8(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, (%rax)
movb -0xa9(%rbp), %al
andb $0x1, %al
movb %al, -0x69(%rbp)
testb $0x1, -0x69(%rbp)
je 0xfde26
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xfc770
jmp 0xfde58
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
movl %eax, %r8d
movq -0x30(%rbp), %rax
leaq -0x48(%rbp), %r9
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0xfe1e0
movl $0x0, -0x4c(%rbp)
jmp 0xfde68
jmp 0xfde63
jmp 0xfdd12
jmp 0xfde6a
jmp 0xfde6c
jmp 0xfde6e
movq -0x30(%rbp), %rcx
movq $0x0, -0x78(%rbp)
movq -0x78(%rbp), %rax
xchgq %rax, (%rcx)
jmp 0xfde83
jmp 0xfde85
jmp 0xfde87
movq -0x30(%rbp), %rcx
movq $0x0, -0x80(%rbp)
movq -0x80(%rbp), %rax
xchgq %rax, 0x8(%rcx)
jmp 0xfde9d
jmp 0xfde9f
jmp 0xfdea1
movq -0x30(%rbp), %rcx
movq $0x0, -0x88(%rbp)
movq -0x88(%rbp), %rax
xchgq %rax, 0x10(%rcx)
movl -0x4c(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZL8l_deletePP8LF_SLISTPK15charset_info_stjPKhjP7LF_PINS:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
loc_FDD12:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov rcx, [rbp+var_20]
mov eax, [rbp+var_24]
mov r8d, eax
mov rax, [rbp+var_30]
lea r9, [rbp+var_48]
xor r10d, r10d
mov [rsp+0D0h+var_D0], rax
mov [rsp+0D0h+var_C8], 0
call _ZL6l_findPP8LF_SLISTPK15charset_info_stjPKhmP6CURSORP7LF_PINSPFcPvSB_E; l_find(LF_SLIST **,charset_info_st const*,uint,uchar const*,ulong,CURSOR *,LF_PINS *,char (*)(void *,void *))
cmp eax, 0
jnz short loc_FDD55
mov [rbp+var_4C], 1
jmp loc_FDE68
loc_FDD55:
lea rax, [rbp+var_38]
mov [rbp+var_A0], rax
mov rcx, [rbp+var_40]
mov rax, [rbp+var_38]
or rax, 1
mov [rbp+var_58], rax
mov rax, [rbp+var_38]
mov rdx, [rbp+var_58]
lock cmpxchg [rcx], rdx
mov rcx, rax
setz al
mov [rbp+var_91], al
mov [rbp+var_90], rcx
test al, 1
jnz short loc_FDDA5
mov rax, [rbp+var_A0]
mov rcx, [rbp+var_90]
mov [rax], rcx
loc_FDDA5:
mov al, [rbp+var_91]
and al, 1
mov [rbp+var_59], al
test [rbp+var_59], 1
jz loc_FDE61
lea rax, [rbp+var_40]
mov [rbp+var_B8], rax
mov rcx, [rbp+var_48]
mov rax, [rbp+var_38]
mov [rbp+var_68], rax
mov rax, [rbp+var_40]
mov rdx, [rbp+var_68]
lock cmpxchg [rcx], rdx
mov rcx, rax
setz al
mov [rbp+var_A9], al
mov [rbp+var_A8], rcx
test al, 1
jnz short loc_FDE06
mov rax, [rbp+var_B8]
mov rcx, [rbp+var_A8]
mov [rax], rcx
loc_FDE06:
mov al, [rbp+var_A9]
and al, 1
mov [rbp+var_69], al
test [rbp+var_69], 1
jz short loc_FDE26
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_40]
call lf_pinbox_free
jmp short loc_FDE58
loc_FDE26:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov rcx, [rbp+var_20]
mov eax, [rbp+var_24]
mov r8d, eax
mov rax, [rbp+var_30]
lea r9, [rbp+var_48]
xor r10d, r10d
mov [rsp+0D0h+var_D0], rax
mov [rsp+0D0h+var_C8], 0
call _ZL6l_findPP8LF_SLISTPK15charset_info_stjPKhmP6CURSORP7LF_PINSPFcPvSB_E; l_find(LF_SLIST **,charset_info_st const*,uint,uchar const*,ulong,CURSOR *,LF_PINS *,char (*)(void *,void *))
loc_FDE58:
mov [rbp+var_4C], 0
jmp short loc_FDE68
loc_FDE61:
jmp short $+2
loc_FDE63:
jmp loc_FDD12
loc_FDE68:
jmp short $+2
loc_FDE6A:
jmp short $+2
loc_FDE6C:
jmp short $+2
loc_FDE6E:
mov rcx, [rbp+var_30]
mov [rbp+var_78], 0
mov rax, [rbp+var_78]
xchg rax, [rcx]
jmp short $+2
loc_FDE83:
jmp short $+2
loc_FDE85:
jmp short $+2
loc_FDE87:
mov rcx, [rbp+var_30]
mov [rbp+var_80], 0
mov rax, [rbp+var_80]
xchg rax, [rcx+8]
jmp short $+2
loc_FDE9D:
jmp short $+2
loc_FDE9F:
jmp short $+2
loc_FDEA1:
mov rcx, [rbp+var_30]
mov [rbp+var_88], 0
mov rax, [rbp+var_88]
xchg rax, [rcx+10h]
mov eax, [rbp+var_4C]
add rsp, 0D0h
pop rbp
retn
| long long l_delete(long long a1, long long a2, int a3, long long a4, int a5, volatile long long *a6)
{
signed long long v6; // rax
signed long long v7; // rtt
char *v8; // rtt
const char *v9; // rcx
bool v11; // [rsp+27h] [rbp-A9h]
bool v12; // [rsp+3Fh] [rbp-91h]
unsigned int v13; // [rsp+84h] [rbp-4Ch]
volatile signed long long *v14; // [rsp+88h] [rbp-48h] BYREF
char *v15; // [rsp+90h] [rbp-40h]
signed long long v16; // [rsp+98h] [rbp-38h]
volatile long long *v17; // [rsp+A0h] [rbp-30h]
int v18; // [rsp+ACh] [rbp-24h]
long long v19; // [rsp+B0h] [rbp-20h]
int v20; // [rsp+BCh] [rbp-14h]
long long v21; // [rsp+C0h] [rbp-10h]
long long v22; // [rsp+C8h] [rbp-8h]
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = a5;
v17 = a6;
do
{
if ( !(unsigned int)l_find(v22, v21, v20, v19, v18, (unsigned int)&v14, (long long)v17, 0LL) )
{
v13 = 1;
goto LABEL_14;
}
v7 = v16;
v6 = _InterlockedCompareExchange64((volatile signed long long *)v15, v16 | 1, v16);
v12 = v7 == v6;
if ( v7 != v6 )
v16 = v6;
}
while ( !v12 );
v8 = v15;
v9 = (const char *)_InterlockedCompareExchange64(v14, v16, (signed long long)v15);
v11 = v8 == v9;
if ( v8 != v9 )
v15 = (char *)v9;
if ( v11 )
lf_pinbox_free((long long)v17, v15);
else
l_find(v22, v21, v20, v19, v18, (unsigned int)&v14, (long long)v17, 0LL);
v13 = 0;
LABEL_14:
_InterlockedExchange64(v17, 0LL);
_InterlockedExchange64(v17 + 1, 0LL);
_InterlockedExchange64(v17 + 2, 0LL);
return v13;
}
| l_delete:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
LAB_001fdd12:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV R8D,EAX
MOV RAX,qword ptr [RBP + -0x30]
LEA R9,[RBP + -0x48]
XOR R10D,R10D
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
CALL 0x001fe1e0
CMP EAX,0x0
JNZ 0x001fdd55
MOV dword ptr [RBP + -0x4c],0x1
JMP 0x001fde68
LAB_001fdd55:
LEA RAX,[RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x38]
OR RAX,0x1
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x58]
CMPXCHG.LOCK qword ptr [RCX],RDX
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0x91],AL
MOV qword ptr [RBP + -0x90],RCX
TEST AL,0x1
JNZ 0x001fdda5
MOV RAX,qword ptr [RBP + -0xa0]
MOV RCX,qword ptr [RBP + -0x90]
MOV qword ptr [RAX],RCX
LAB_001fdda5:
MOV AL,byte ptr [RBP + -0x91]
AND AL,0x1
MOV byte ptr [RBP + -0x59],AL
TEST byte ptr [RBP + -0x59],0x1
JZ 0x001fde61
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0xb8],RAX
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x68]
CMPXCHG.LOCK qword ptr [RCX],RDX
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0xa9],AL
MOV qword ptr [RBP + -0xa8],RCX
TEST AL,0x1
JNZ 0x001fde06
MOV RAX,qword ptr [RBP + -0xb8]
MOV RCX,qword ptr [RBP + -0xa8]
MOV qword ptr [RAX],RCX
LAB_001fde06:
MOV AL,byte ptr [RBP + -0xa9]
AND AL,0x1
MOV byte ptr [RBP + -0x69],AL
TEST byte ptr [RBP + -0x69],0x1
JZ 0x001fde26
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x40]
CALL 0x001fc770
JMP 0x001fde58
LAB_001fde26:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV R8D,EAX
MOV RAX,qword ptr [RBP + -0x30]
LEA R9,[RBP + -0x48]
XOR R10D,R10D
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
CALL 0x001fe1e0
LAB_001fde58:
MOV dword ptr [RBP + -0x4c],0x0
JMP 0x001fde68
LAB_001fde61:
JMP 0x001fde63
LAB_001fde63:
JMP 0x001fdd12
LAB_001fde68:
JMP 0x001fde6a
LAB_001fde6a:
JMP 0x001fde6c
LAB_001fde6c:
JMP 0x001fde6e
LAB_001fde6e:
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x78],0x0
MOV RAX,qword ptr [RBP + -0x78]
XCHG qword ptr [RCX],RAX
JMP 0x001fde83
LAB_001fde83:
JMP 0x001fde85
LAB_001fde85:
JMP 0x001fde87
LAB_001fde87:
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x80],0x0
MOV RAX,qword ptr [RBP + -0x80]
XCHG qword ptr [RCX + 0x8],RAX
JMP 0x001fde9d
LAB_001fde9d:
JMP 0x001fde9f
LAB_001fde9f:
JMP 0x001fdea1
LAB_001fdea1:
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x88],0x0
MOV RAX,qword ptr [RBP + -0x88]
XCHG qword ptr [RCX + 0x10],RAX
MOV EAX,dword ptr [RBP + -0x4c]
ADD RSP,0xd0
POP RBP
RET
|
/* l_delete(LF_SLIST**, charset_info_st const*, unsigned int, unsigned char const*, unsigned int,
LF_PINS*) */
int4
l_delete(LF_SLIST **param_1,charset_info_st *param_2,uint param_3,uchar *param_4,uint param_5,
LF_PINS *param_6)
{
ulong *puVar1;
int iVar2;
ulong uVar3;
bool bVar4;
int4 local_54;
ulong *local_50;
ulong *local_48;
ulong local_40;
LF_PINS *local_38;
uint local_2c;
uchar *local_28;
uint local_1c;
charset_info_st *local_18;
LF_SLIST **local_10;
uVar3 = local_40;
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
do {
local_40 = uVar3;
iVar2 = l_find(local_10,local_18,local_1c,local_28,(ulong)local_2c,(CURSOR *)&local_50,local_38,
(_func_char_void_ptr_void_ptr *)0x0);
if (iVar2 == 0) {
local_54 = 1;
goto LAB_001fde68;
}
LOCK();
uVar3 = *local_48;
bVar4 = local_40 == uVar3;
if (bVar4) {
*local_48 = local_40 | 1;
uVar3 = local_40;
}
UNLOCK();
} while (!bVar4);
LOCK();
puVar1 = (ulong *)*local_50;
if (local_48 == puVar1) {
*local_50 = local_40;
}
UNLOCK();
if (local_48 == puVar1) {
lf_pinbox_free(local_38,local_48);
}
else {
l_find(local_10,local_18,local_1c,local_28,(ulong)local_2c,(CURSOR *)&local_50,local_38,
(_func_char_void_ptr_void_ptr *)0x0);
}
local_54 = 0;
LAB_001fde68:
LOCK();
*(int8 *)local_38 = 0;
UNLOCK();
LOCK();
*(int8 *)(local_38 + 8) = 0;
UNLOCK();
LOCK();
*(int8 *)(local_38 + 0x10) = 0;
UNLOCK();
return local_54;
}
| |
22,507 | evmc::load64le(unsigned char const*) | corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/evmc/include/evmc/evmc.hpp | inline constexpr uint64_t load64le(const uint8_t* data) noexcept
{
return uint64_t{data[0]} | (uint64_t{data[1]} << 8) | (uint64_t{data[2]} << 16) |
(uint64_t{data[3]} << 24) | (uint64_t{data[4]} << 32) | (uint64_t{data[5]} << 40) |
(uint64_t{data[6]} << 48) | (uint64_t{data[7]} << 56);
} | O0 | cpp | evmc::load64le(unsigned char const*):
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shlq $0x18, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
shlq $0x28, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
shlq $0x30, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
shlq $0x38, %rcx
orq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
| _ZN4evmc8load64leEPKh:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx+1]
shl rcx, 8
or rax, rcx
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx+2]
shl rcx, 10h
or rax, rcx
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx+3]
shl rcx, 18h
or rax, rcx
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx+4]
shl rcx, 20h
or rax, rcx
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx+5]
shl rcx, 28h
or rax, rcx
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx+6]
shl rcx, 30h
or rax, rcx
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx+7]
shl rcx, 38h
or rax, rcx
pop rbp
retn
| unsigned long long evmc::load64le(evmc *this, const unsigned __int8 *a2)
{
return ((unsigned long long)*((unsigned __int8 *)this + 7) << 56) | ((unsigned long long)*((unsigned __int8 *)this + 6) << 48) | ((unsigned long long)*((unsigned __int8 *)this + 5) << 40) | ((unsigned long long)*((unsigned __int8 *)this + 4) << 32) | ((unsigned long long)*((unsigned __int8 *)this + 3) << 24) | ((unsigned long long)*((unsigned __int8 *)this + 2) << 16) | *(unsigned __int16 *)this;
}
| load64le:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL RCX,0x8
OR RAX,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL RCX,0x10
OR RAX,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX + 0x3]
SHL RCX,0x18
OR RAX,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX + 0x4]
SHL RCX,0x20
OR RAX,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX + 0x5]
SHL RCX,0x28
OR RAX,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX + 0x6]
SHL RCX,0x30
OR RAX,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX + 0x7]
SHL RCX,0x38
OR RAX,RCX
POP RBP
RET
|
/* evmc::load64le(unsigned char const*) */
int8 evmc::load64le(uchar *param_1)
{
return *(int8 *)param_1;
}
| |
22,508 | my_fcvt | eloqsql/strings/dtoa.c | size_t my_fcvt(double x, int precision, char *to, my_bool *error)
{
int decpt, sign, len, i;
char *res, *src, *end, *dst= to;
char buf[DTOA_BUFF_SIZE];
DBUG_ASSERT(precision >= 0 && precision < DECIMAL_NOT_SPECIFIED && to != NULL);
res= dtoa(x, 5, precision, &decpt, &sign, &end, buf, sizeof(buf));
if (decpt == DTOA_OVERFLOW)
{
dtoa_free(res, buf, sizeof(buf));
*to++= '0';
*to= '\0';
if (error != NULL)
*error= TRUE;
return 1;
}
src= res;
len= (int)(end - src);
if (sign)
*dst++= '-';
if (decpt <= 0)
{
*dst++= '0';
*dst++= '.';
for (i= decpt; i < 0; i++)
*dst++= '0';
}
for (i= 1; i <= len; i++)
{
*dst++= *src++;
if (i == decpt && i < len)
*dst++= '.';
}
while (i++ <= decpt)
*dst++= '0';
if (precision > 0)
{
if (len <= decpt)
*dst++= '.';
for (i= precision - MY_MAX(0, (len - decpt)); i > 0; i--)
*dst++= '0';
}
*dst= '\0';
if (error != NULL)
*error= FALSE;
dtoa_free(res, buf, sizeof(buf));
return dst - to;
} | O3 | c | my_fcvt:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe98, %rsp # imm = 0xE98
movq %rdx, -0xea8(%rbp)
movq %rsi, %r14
movl %edi, %esi
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0xe94(%rbp), %r13
leaq -0xe9c(%rbp), %rcx
leaq -0xec0(%rbp), %r8
leaq -0xe90(%rbp), %rbx
movl $0x5, %edi
movl %esi, -0xe98(%rbp)
movq %r13, %rdx
movq %rbx, %r9
callq 0x5e36a
movq %rax, %r15
movl (%r13), %r12d
cmpl $0x270f, %r12d # imm = 0x270F
jne 0x5e1d7
cmpq %rbx, %r15
setae %al
leaq -0x30(%rbp), %rcx
cmpq %r15, %rcx
seta %cl
testb %cl, %al
jne 0x5e1b3
movq %r15, %rdi
callq 0x24450
movw $0x30, (%r14)
movl $0x1, %r13d
movq -0xea8(%rbp), %rax
testq %rax, %rax
je 0x5e341
movb $0x1, (%rax)
jmp 0x5e341
movq -0xec0(%rbp), %rbx
movq %r14, %rax
movl %ebx, %r14d
cmpl $0x0, -0xe9c(%rbp)
movq %rax, %r13
je 0x5e1f7
leaq 0x1(%rax), %r13
movb $0x2d, (%rax)
movq %rax, -0xeb8(%rbp)
subl %r15d, %r14d
testl %r12d, %r12d
movl -0xe98(%rbp), %r8d
jg 0x5e251
movw $0x2e30, (%r13) # imm = 0x2E30
leaq 0x2(%r13), %rdi
testl %r12d, %r12d
js 0x5e222
movq %rdi, %r13
jmp 0x5e251
movl %r12d, %eax
notl %eax
movq %rax, -0xeb0(%rbp)
leaq 0x1(%rax), %rdx
movl $0x30, %esi
callq 0x241e0
movl -0xe98(%rbp), %r8d
movq -0xeb0(%rbp), %rax
addq %rax, %r13
addq $0x3, %r13
testl %r14d, %r14d
jle 0x5e298
subl %r15d, %ebx
incl %ebx
movl %r14d, %eax
xorl %ecx, %ecx
movq %r13, %rdx
leal 0x1(%rcx), %esi
movb (%r15,%rcx), %dil
incq %r13
movb %dil, (%rdx)
cmpl -0xe94(%rbp), %esi
jne 0x5e288
cmpl %r14d, %esi
jge 0x5e288
movb $0x2e, 0x1(%rdx)
addq $0x2, %rdx
movq %rdx, %r13
incq %rcx
cmpl %ecx, %eax
jne 0x5e260
movl -0xe94(%rbp), %r12d
jmp 0x5e29d
movl $0x1, %ebx
cmpl %r12d, %ebx
jg 0x5e2ba
decl %ebx
movb $0x30, (%r13)
incq %r13
movl -0xe94(%rbp), %r12d
incl %ebx
cmpl %r12d, %ebx
jl 0x5e2a4
testl %r8d, %r8d
jle 0x5e300
cmpl %r14d, %r12d
jl 0x5e2d3
movb $0x2e, (%r13)
incq %r13
movl -0xe94(%rbp), %r12d
subl %r12d, %r14d
cmpl %r8d, %r14d
jge 0x5e300
xorl %ebx, %ebx
testl %r14d, %r14d
cmovgl %r14d, %ebx
notl %ebx
addl %r8d, %ebx
leaq 0x1(%rbx), %rdx
movq %r13, %rdi
movl $0x30, %esi
callq 0x241e0
addq %rbx, %r13
incq %r13
movb $0x0, (%r13)
movq -0xea8(%rbp), %rax
testq %rax, %rax
movq -0xeb8(%rbp), %rbx
je 0x5e31b
movb $0x0, (%rax)
leaq -0xe90(%rbp), %rax
cmpq %rax, %r15
setae %al
leaq -0x30(%rbp), %rcx
cmpq %r15, %rcx
seta %cl
testb %cl, %al
jne 0x5e33e
movq %r15, %rdi
callq 0x24450
subq %rbx, %r13
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x5e365
movq %r13, %rax
addq $0xe98, %rsp # imm = 0xE98
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x243e0
| my_fcvt:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E98h
mov [rbp+var_EA8], rdx
mov r14, rsi
mov esi, edi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r13, [rbp+var_E94]
lea rcx, [rbp+var_E9C]
lea r8, [rbp+var_EC0]
lea rbx, [rbp+var_E90]
mov edi, 5
mov [rbp+var_E98], esi
mov rdx, r13
mov r9, rbx
call dtoa
mov r15, rax
mov r12d, [r13+0]
cmp r12d, 270Fh
jnz short loc_5E1D7
cmp r15, rbx
setnb al
lea rcx, [rbp+var_30]
cmp rcx, r15
setnbe cl
test al, cl
jnz short loc_5E1B3
mov rdi, r15
call _free
loc_5E1B3:
mov word ptr [r14], 30h ; '0'
mov r13d, 1
mov rax, [rbp+var_EA8]
test rax, rax
jz loc_5E341
mov byte ptr [rax], 1
jmp loc_5E341
loc_5E1D7:
mov rbx, [rbp+var_EC0]
mov rax, r14
mov r14d, ebx
cmp [rbp+var_E9C], 0
mov r13, rax
jz short loc_5E1F7
lea r13, [rax+1]
mov byte ptr [rax], 2Dh ; '-'
loc_5E1F7:
mov [rbp+var_EB8], rax
sub r14d, r15d
test r12d, r12d
mov r8d, [rbp+var_E98]
jg short loc_5E251
mov word ptr [r13+0], 2E30h
lea rdi, [r13+2]
test r12d, r12d
js short loc_5E222
mov r13, rdi
jmp short loc_5E251
loc_5E222:
mov eax, r12d
not eax
mov [rbp+var_EB0], rax
lea rdx, [rax+1]
mov esi, 30h ; '0'
call _memset
mov r8d, [rbp+var_E98]
mov rax, [rbp+var_EB0]
add r13, rax
add r13, 3
loc_5E251:
test r14d, r14d
jle short loc_5E298
sub ebx, r15d
inc ebx
mov eax, r14d
xor ecx, ecx
loc_5E260:
mov rdx, r13
lea esi, [rcx+1]
mov dil, [r15+rcx]
inc r13
mov [rdx], dil
cmp esi, [rbp+var_E94]
jnz short loc_5E288
cmp esi, r14d
jge short loc_5E288
mov byte ptr [rdx+1], 2Eh ; '.'
add rdx, 2
mov r13, rdx
loc_5E288:
inc rcx
cmp eax, ecx
jnz short loc_5E260
mov r12d, [rbp+var_E94]
jmp short loc_5E29D
loc_5E298:
mov ebx, 1
loc_5E29D:
cmp ebx, r12d
jg short loc_5E2BA
dec ebx
loc_5E2A4:
mov byte ptr [r13+0], 30h ; '0'
inc r13
mov r12d, [rbp+var_E94]
inc ebx
cmp ebx, r12d
jl short loc_5E2A4
loc_5E2BA:
test r8d, r8d
jle short loc_5E300
cmp r12d, r14d
jl short loc_5E2D3
mov byte ptr [r13+0], 2Eh ; '.'
inc r13
mov r12d, [rbp+var_E94]
loc_5E2D3:
sub r14d, r12d
cmp r14d, r8d
jge short loc_5E300
xor ebx, ebx
test r14d, r14d
cmovg ebx, r14d
not ebx
add ebx, r8d
lea rdx, [rbx+1]
mov rdi, r13
mov esi, 30h ; '0'
call _memset
add r13, rbx
inc r13
loc_5E300:
mov byte ptr [r13+0], 0
mov rax, [rbp+var_EA8]
test rax, rax
mov rbx, [rbp+var_EB8]
jz short loc_5E31B
mov byte ptr [rax], 0
loc_5E31B:
lea rax, [rbp+var_E90]
cmp r15, rax
setnb al
lea rcx, [rbp+var_30]
cmp rcx, r15
setnbe cl
test al, cl
jnz short loc_5E33E
mov rdi, r15
call _free
loc_5E33E:
sub r13, rbx
loc_5E341:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_5E365
mov rax, r13
add rsp, 0E98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5E365:
call ___stack_chk_fail
| _BYTE * my_fcvt(unsigned int a1, _WORD *a2, _BYTE *a3)
{
long long v4; // rsi
unsigned long long v5; // r15
int v6; // r12d
long long v7; // r13
int v8; // ebx
_BYTE *v9; // rax
int v10; // r14d
_BYTE *v11; // r13
int v12; // r14d
int v13; // r8d
int v14; // ebx
long long v15; // rcx
_BYTE *v16; // rdx
int v17; // ebx
int v18; // r14d
int v19; // ebx
long long v20; // rbx
_BYTE *v21; // rbx
long long v23; // [rsp+0h] [rbp-EC0h] BYREF
_BYTE *v24; // [rsp+8h] [rbp-EB8h]
long long v25; // [rsp+10h] [rbp-EB0h]
_BYTE *v26; // [rsp+18h] [rbp-EA8h]
int v27; // [rsp+24h] [rbp-E9Ch] BYREF
int v28; // [rsp+28h] [rbp-E98h]
int v29; // [rsp+2Ch] [rbp-E94h] BYREF
_BYTE v30[3680]; // [rsp+30h] [rbp-E90h] BYREF
_QWORD v31[6]; // [rsp+E90h] [rbp-30h] BYREF
v26 = a3;
v4 = a1;
v31[0] = __readfsqword(0x28u);
v28 = a1;
v5 = dtoa(5LL, a1, &v29, &v27, &v23, v30);
v6 = v29;
if ( v29 == 9999 )
{
if ( (unsigned long long)v31 <= v5 || v5 < (unsigned long long)v30 )
free(v5, a1);
*a2 = 48;
v7 = 1LL;
if ( v26 )
*v26 = 1;
}
else
{
v8 = v23;
v9 = a2;
v10 = v23;
v11 = v9;
if ( v27 )
{
v11 = v9 + 1;
*v9 = 45;
}
v24 = v9;
v12 = v10 - v5;
v13 = v28;
if ( v6 <= 0 )
{
*(_WORD *)v11 = 11824;
if ( v6 < 0 )
{
v25 = (unsigned int)~v6;
v4 = 48LL;
memset(v11 + 2, 48LL, v25 + 1);
v13 = v28;
v11 += v25 + 3;
}
else
{
v11 += 2;
}
}
if ( v12 <= 0 )
{
v14 = 1;
}
else
{
v14 = v8 - v5 + 1;
v15 = 0LL;
do
{
v16 = v11;
v4 = (unsigned int)(v15 + 1);
++v11;
*v16 = *(_BYTE *)(v5 + v15);
if ( (_DWORD)v4 == v29 && (int)v4 < v12 )
{
v16[1] = 46;
v11 = v16 + 2;
}
++v15;
}
while ( v12 != (_DWORD)v15 );
v6 = v29;
}
if ( v14 <= v6 )
{
v17 = v14 - 1;
do
{
*v11++ = 48;
v6 = v29;
++v17;
}
while ( v17 < v29 );
}
if ( v13 > 0 )
{
if ( v6 >= v12 )
{
*v11++ = 46;
v6 = v29;
}
v18 = v12 - v6;
if ( v18 < v13 )
{
v19 = 0;
if ( v18 > 0 )
v19 = v18;
v20 = (unsigned int)(v13 + ~v19);
v4 = 48LL;
memset(v11, 48LL, v20 + 1);
v11 += v20 + 1;
}
}
*v11 = 0;
v21 = v24;
if ( v26 )
*v26 = 0;
if ( (unsigned long long)v31 <= v5 || v5 < (unsigned long long)v30 )
free(v5, v4);
return (_BYTE *)(v11 - v21);
}
return (_BYTE *)v7;
}
| my_fcvt:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe98
MOV qword ptr [RBP + -0xea8],RDX
MOV R14,RSI
MOV ESI,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R13,[RBP + -0xe94]
LEA RCX,[RBP + -0xe9c]
LEA R8,[RBP + -0xec0]
LEA RBX,[RBP + -0xe90]
MOV EDI,0x5
MOV dword ptr [RBP + -0xe98],ESI
MOV RDX,R13
MOV R9,RBX
CALL 0x0015e36a
MOV R15,RAX
MOV R12D,dword ptr [R13]
CMP R12D,0x270f
JNZ 0x0015e1d7
CMP R15,RBX
SETNC AL
LEA RCX,[RBP + -0x30]
CMP RCX,R15
SETA CL
TEST AL,CL
JNZ 0x0015e1b3
MOV RDI,R15
CALL 0x00124450
LAB_0015e1b3:
MOV word ptr [R14],0x30
MOV R13D,0x1
MOV RAX,qword ptr [RBP + -0xea8]
TEST RAX,RAX
JZ 0x0015e341
MOV byte ptr [RAX],0x1
JMP 0x0015e341
LAB_0015e1d7:
MOV RBX,qword ptr [RBP + -0xec0]
MOV RAX,R14
MOV R14D,EBX
CMP dword ptr [RBP + -0xe9c],0x0
MOV R13,RAX
JZ 0x0015e1f7
LEA R13,[RAX + 0x1]
MOV byte ptr [RAX],0x2d
LAB_0015e1f7:
MOV qword ptr [RBP + -0xeb8],RAX
SUB R14D,R15D
TEST R12D,R12D
MOV R8D,dword ptr [RBP + -0xe98]
JG 0x0015e251
MOV word ptr [R13],0x2e30
LEA RDI,[R13 + 0x2]
TEST R12D,R12D
JS 0x0015e222
MOV R13,RDI
JMP 0x0015e251
LAB_0015e222:
MOV EAX,R12D
NOT EAX
MOV qword ptr [RBP + -0xeb0],RAX
LEA RDX,[RAX + 0x1]
MOV ESI,0x30
CALL 0x001241e0
MOV R8D,dword ptr [RBP + -0xe98]
MOV RAX,qword ptr [RBP + -0xeb0]
ADD R13,RAX
ADD R13,0x3
LAB_0015e251:
TEST R14D,R14D
JLE 0x0015e298
SUB EBX,R15D
INC EBX
MOV EAX,R14D
XOR ECX,ECX
LAB_0015e260:
MOV RDX,R13
LEA ESI,[RCX + 0x1]
MOV DIL,byte ptr [R15 + RCX*0x1]
INC R13
MOV byte ptr [RDX],DIL
CMP ESI,dword ptr [RBP + -0xe94]
JNZ 0x0015e288
CMP ESI,R14D
JGE 0x0015e288
MOV byte ptr [RDX + 0x1],0x2e
ADD RDX,0x2
MOV R13,RDX
LAB_0015e288:
INC RCX
CMP EAX,ECX
JNZ 0x0015e260
MOV R12D,dword ptr [RBP + -0xe94]
JMP 0x0015e29d
LAB_0015e298:
MOV EBX,0x1
LAB_0015e29d:
CMP EBX,R12D
JG 0x0015e2ba
DEC EBX
LAB_0015e2a4:
MOV byte ptr [R13],0x30
INC R13
MOV R12D,dword ptr [RBP + -0xe94]
INC EBX
CMP EBX,R12D
JL 0x0015e2a4
LAB_0015e2ba:
TEST R8D,R8D
JLE 0x0015e300
CMP R12D,R14D
JL 0x0015e2d3
MOV byte ptr [R13],0x2e
INC R13
MOV R12D,dword ptr [RBP + -0xe94]
LAB_0015e2d3:
SUB R14D,R12D
CMP R14D,R8D
JGE 0x0015e300
XOR EBX,EBX
TEST R14D,R14D
CMOVG EBX,R14D
NOT EBX
ADD EBX,R8D
LEA RDX,[RBX + 0x1]
MOV RDI,R13
MOV ESI,0x30
CALL 0x001241e0
ADD R13,RBX
INC R13
LAB_0015e300:
MOV byte ptr [R13],0x0
MOV RAX,qword ptr [RBP + -0xea8]
TEST RAX,RAX
MOV RBX,qword ptr [RBP + -0xeb8]
JZ 0x0015e31b
MOV byte ptr [RAX],0x0
LAB_0015e31b:
LEA RAX,[RBP + -0xe90]
CMP R15,RAX
SETNC AL
LEA RCX,[RBP + -0x30]
CMP RCX,R15
SETA CL
TEST AL,CL
JNZ 0x0015e33e
MOV RDI,R15
CALL 0x00124450
LAB_0015e33e:
SUB R13,RBX
LAB_0015e341:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0015e365
MOV RAX,R13
ADD RSP,0xe98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015e365:
CALL 0x001243e0
|
long my_fcvt(int param_1,int2 *param_2,int1 *param_3)
{
long *__ptr;
int iVar1;
uint uVar2;
uint uVar3;
long lVar4;
int2 *puVar5;
int2 *__s;
int iVar6;
long in_FS_OFFSET;
int local_ec8 [2];
int2 *local_ec0;
ulong local_eb8;
int1 *local_eb0;
int local_ea4;
int local_ea0;
uint local_e9c;
long local_e98 [460];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_eb0 = param_3;
local_ea0 = param_1;
__ptr = (long *)dtoa(5,param_1,&local_e9c,&local_ea4,local_ec8,local_e98);
uVar3 = local_e9c;
if (local_e9c == 9999) {
if (__ptr < local_e98 || &local_38 <= __ptr) {
free(__ptr);
}
*param_2 = 0x30;
lVar4 = 1;
if (local_eb0 != (int1 *)0x0) {
*local_eb0 = 1;
}
}
else {
puVar5 = param_2;
if (local_ea4 != 0) {
puVar5 = (int2 *)((long)param_2 + 1);
*(int1 *)param_2 = 0x2d;
}
iVar6 = local_ec8[0] - (int)__ptr;
__s = puVar5;
local_ec0 = param_2;
if ((int)local_e9c < 1) {
*puVar5 = 0x2e30;
__s = puVar5 + 1;
if ((int)local_e9c < 0) {
local_eb8 = (ulong)~local_e9c;
memset(__s,0x30,local_eb8 + 1);
__s = (int2 *)((long)puVar5 + local_eb8 + 3);
}
}
if (iVar6 < 1) {
iVar1 = 1;
}
else {
iVar1 = (local_ec8[0] - (int)__ptr) + 1;
lVar4 = 0;
puVar5 = __s;
do {
uVar3 = (int)lVar4 + 1;
__s = (int2 *)((long)puVar5 + 1);
*(int1 *)puVar5 = *(int1 *)((long)__ptr + lVar4);
if ((uVar3 == local_e9c) && ((int)uVar3 < iVar6)) {
*(int1 *)((long)puVar5 + 1) = 0x2e;
__s = puVar5 + 1;
}
lVar4 = lVar4 + 1;
puVar5 = __s;
uVar3 = local_e9c;
} while (iVar6 != (int)lVar4);
}
if (iVar1 <= (int)uVar3) {
iVar1 = iVar1 + -1;
do {
*(int1 *)__s = 0x30;
__s = (int2 *)((long)__s + 1);
iVar1 = iVar1 + 1;
uVar3 = local_e9c;
} while (iVar1 < (int)local_e9c);
}
if (0 < local_ea0) {
if (iVar6 <= (int)uVar3) {
*(int1 *)__s = 0x2e;
__s = (int2 *)((long)__s + 1);
uVar3 = local_e9c;
}
uVar3 = iVar6 - uVar3;
if ((int)uVar3 < local_ea0) {
uVar2 = 0;
if (0 < (int)uVar3) {
uVar2 = uVar3;
}
uVar3 = ~uVar2 + local_ea0;
memset(__s,0x30,(ulong)uVar3 + 1);
__s = (int2 *)((long)__s + (ulong)uVar3 + 1);
}
}
puVar5 = local_ec0;
*(int1 *)__s = 0;
if (local_eb0 != (int1 *)0x0) {
*local_eb0 = 0;
}
if (__ptr < local_e98 || &local_38 <= __ptr) {
free(__ptr);
}
lVar4 = (long)__s - (long)puVar5;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar4;
}
| |
22,509 | bc_idx_to_atom | bluesky950520[P]quickjs/quickjs.c | static int bc_idx_to_atom(BCReaderState *s, JSAtom *patom, uint32_t idx)
{
JSAtom atom;
if (__JS_AtomIsTaggedInt(idx)) {
atom = idx;
} else if (idx < s->first_atom) {
atom = JS_DupAtom(s->ctx, idx);
} else {
idx -= s->first_atom;
if (idx >= s->idx_to_atom_count) {
JS_ThrowSyntaxError(s->ctx, "invalid atom index (pos=%u)",
(unsigned int)(s->ptr - s->buf_start));
*patom = JS_ATOM_NULL;
return s->error_state = -1;
}
atom = JS_DupAtom(s->ctx, s->idx_to_atom[idx]);
}
*patom = atom;
return 0;
} | O0 | c | bc_idx_to_atom:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl 0x1c(%rsp), %edi
callq 0x360c0
cmpl $0x0, %eax
je 0x7d35d
movl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0x7d420
movl 0x1c(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x7d385
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movl 0x1c(%rsp), %esi
callq 0x27fa0
movl %eax, 0x18(%rsp)
jmp 0x7d41e
movq 0x28(%rsp), %rax
movl 0x20(%rax), %ecx
movl 0x1c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x24(%rcx), %eax
jb 0x7d3fd
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl %eax, %edx
leaq 0x91671(%rip), %rsi # 0x10ea3c
movb $0x0, %al
callq 0x2d210
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x7d433
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x1c(%rsp), %ecx
movl (%rax,%rcx,4), %esi
callq 0x27fa0
movl %eax, 0x18(%rsp)
jmp 0x7d420
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
| bc_idx_to_atom:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_1C], edx
mov edi, [rsp+38h+var_1C]
call __JS_AtomIsTaggedInt
cmp eax, 0
jz short loc_7D35D
mov eax, [rsp+38h+var_1C]
mov [rsp+38h+var_20], eax
jmp loc_7D420
loc_7D35D:
mov eax, [rsp+38h+var_1C]
mov rcx, [rsp+38h+var_10]
cmp eax, [rcx+20h]
jnb short loc_7D385
mov rax, [rsp+38h+var_10]
mov rdi, [rax]
mov esi, [rsp+38h+var_1C]
call JS_DupAtom
mov [rsp+38h+var_20], eax
jmp loc_7D41E
loc_7D385:
mov rax, [rsp+38h+var_10]
mov ecx, [rax+20h]
mov eax, [rsp+38h+var_1C]
sub eax, ecx
mov [rsp+38h+var_1C], eax
mov eax, [rsp+38h+var_1C]
mov rcx, [rsp+38h+var_10]
cmp eax, [rcx+24h]
jb short loc_7D3FD
mov rax, [rsp+38h+var_10]
mov rdi, [rax]
mov rax, [rsp+38h+var_10]
mov rax, [rax+10h]
mov rcx, [rsp+38h+var_10]
mov rcx, [rcx+8]
sub rax, rcx
mov edx, eax
lea rsi, aInvalidAtomInd; "invalid atom index (pos=%u)"
mov al, 0
call JS_ThrowSyntaxError
mov [rsp+38h+var_30], rax
mov [rsp+38h+var_28], rdx
mov rax, [rsp+38h+var_18]
mov dword ptr [rax], 0
mov rax, [rsp+38h+var_10]
mov dword ptr [rax+30h], 0FFFFFFFFh
mov [rsp+38h+var_4], 0FFFFFFFFh
jmp short loc_7D433
loc_7D3FD:
mov rax, [rsp+38h+var_10]
mov rdi, [rax]
mov rax, [rsp+38h+var_10]
mov rax, [rax+28h]
mov ecx, [rsp+38h+var_1C]
mov esi, [rax+rcx*4]
call JS_DupAtom
mov [rsp+38h+var_20], eax
loc_7D41E:
jmp short $+2
loc_7D420:
mov ecx, [rsp+38h+var_20]
mov rax, [rsp+38h+var_18]
mov [rax], ecx
mov [rsp+38h+var_4], 0
loc_7D433:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long bc_idx_to_atom(
long long a1,
_DWORD *a2,
unsigned int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v11; // r8
long long v12; // r9
__m128 v13; // xmm4
__m128 v14; // xmm5
char v16; // [rsp+0h] [rbp-38h]
int v17; // [rsp+18h] [rbp-20h]
unsigned int v19; // [rsp+1Ch] [rbp-1Ch]
if ( _JS_AtomIsTaggedInt(a3) )
{
v17 = a3;
LABEL_8:
*a2 = v17;
return 0;
}
if ( a3 < *(_DWORD *)(a1 + 32) )
{
v17 = JS_DupAtom(*(_QWORD *)a1, a3);
goto LABEL_8;
}
v19 = a3 - *(_DWORD *)(a1 + 32);
if ( v19 < *(_DWORD *)(a1 + 36) )
{
v17 = JS_DupAtom(*(_QWORD *)a1, *(_DWORD *)(*(_QWORD *)(a1 + 40) + 4LL * v19));
goto LABEL_8;
}
JS_ThrowSyntaxError(
*(_QWORD *)a1,
(long long)"invalid atom index (pos=%u)",
(unsigned int)*(_QWORD *)(a1 + 16) - (unsigned int)*(_QWORD *)(a1 + 8),
*(_QWORD *)(a1 + 8),
v11,
v12,
a4,
a5,
a6,
a7,
v13,
v14,
a10,
a11,
v16);
*a2 = 0;
*(_DWORD *)(a1 + 48) = -1;
return (unsigned int)-1;
}
| bc_idx_to_atom:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV dword ptr [RSP + 0x1c],EDX
MOV EDI,dword ptr [RSP + 0x1c]
CALL 0x001360c0
CMP EAX,0x0
JZ 0x0017d35d
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x18],EAX
JMP 0x0017d420
LAB_0017d35d:
MOV EAX,dword ptr [RSP + 0x1c]
MOV RCX,qword ptr [RSP + 0x28]
CMP EAX,dword ptr [RCX + 0x20]
JNC 0x0017d385
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX]
MOV ESI,dword ptr [RSP + 0x1c]
CALL 0x00127fa0
MOV dword ptr [RSP + 0x18],EAX
JMP 0x0017d41e
LAB_0017d385:
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RAX + 0x20]
MOV EAX,dword ptr [RSP + 0x1c]
SUB EAX,ECX
MOV dword ptr [RSP + 0x1c],EAX
MOV EAX,dword ptr [RSP + 0x1c]
MOV RCX,qword ptr [RSP + 0x28]
CMP EAX,dword ptr [RCX + 0x24]
JC 0x0017d3fd
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RCX + 0x8]
SUB RAX,RCX
MOV EDX,EAX
LEA RSI,[0x20ea3c]
MOV AL,0x0
CALL 0x0012d210
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX + 0x30],0xffffffff
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x0017d433
LAB_0017d3fd:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x28]
MOV ECX,dword ptr [RSP + 0x1c]
MOV ESI,dword ptr [RAX + RCX*0x4]
CALL 0x00127fa0
MOV dword ptr [RSP + 0x18],EAX
LAB_0017d41e:
JMP 0x0017d420
LAB_0017d420:
MOV ECX,dword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x34],0x0
LAB_0017d433:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int4 bc_idx_to_atom(int8 *param_1,uint *param_2,uint param_3)
{
int iVar1;
uint local_20;
iVar1 = __JS_AtomIsTaggedInt(param_3);
local_20 = param_3;
if (iVar1 == 0) {
if (param_3 < *(uint *)(param_1 + 4)) {
local_20 = JS_DupAtom(*param_1,param_3);
}
else {
if (*(uint *)((long)param_1 + 0x24) <= param_3 - *(int *)(param_1 + 4)) {
JS_ThrowSyntaxError(*param_1,"invalid atom index (pos=%u)",(int)param_1[2] - (int)param_1[1]
);
*param_2 = 0;
*(int4 *)(param_1 + 6) = 0xffffffff;
return 0xffffffff;
}
local_20 = JS_DupAtom(*param_1,*(int4 *)
(param_1[5] + (ulong)(param_3 - *(int *)(param_1 + 4)) * 4));
}
}
*param_2 = local_20;
return 0;
}
| |
22,510 | bc_idx_to_atom | bluesky950520[P]quickjs/quickjs.c | static int bc_idx_to_atom(BCReaderState *s, JSAtom *patom, uint32_t idx)
{
JSAtom atom;
if (__JS_AtomIsTaggedInt(idx)) {
atom = idx;
} else if (idx < s->first_atom) {
atom = JS_DupAtom(s->ctx, idx);
} else {
idx -= s->first_atom;
if (idx >= s->idx_to_atom_count) {
JS_ThrowSyntaxError(s->ctx, "invalid atom index (pos=%u)",
(unsigned int)(s->ptr - s->buf_start));
*patom = JS_ATOM_NULL;
return s->error_state = -1;
}
atom = JS_DupAtom(s->ctx, s->idx_to_atom[idx]);
}
*patom = atom;
return 0;
} | O2 | c | bc_idx_to_atom:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %edx, %edx
js 0x3d400
movq %rdi, %r14
movl %edx, %eax
subl 0x20(%rdi), %eax
jae 0x3d40c
cmpl $0xdf, %edx
jbe 0x3d400
movq (%r14), %rax
movq 0x18(%rax), %rax
movq 0x68(%rax), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %rax
incl (%rax)
movl %edx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl 0x24(%r14), %eax
jae 0x3d425
movq 0x28(%r14), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %edx
cmpl $0xe0, %edx
jge 0x3d3ed
jmp 0x3d400
movq (%r14), %rdi
movl 0x10(%r14), %edx
subl 0x8(%r14), %edx
leaq 0x494f1(%rip), %rsi # 0x86928
xorl %eax, %eax
callq 0x1c5bb
andl $0x0, (%rbx)
orl $-0x1, 0x30(%r14)
pushq $-0x1
popq %rax
jmp 0x3d404
| bc_idx_to_atom:
push r14
push rbx
push rax
mov rbx, rsi
test edx, edx
js short loc_3D400
mov r14, rdi
mov eax, edx
sub eax, [rdi+20h]
jnb short loc_3D40C
cmp edx, 0DFh
jbe short loc_3D400
loc_3D3ED:
mov rax, [r14]
mov rax, [rax+18h]
mov rax, [rax+68h]
mov ecx, edx
mov rax, [rax+rcx*8]
inc dword ptr [rax]
loc_3D400:
mov [rbx], edx
xor eax, eax
loc_3D404:
add rsp, 8
pop rbx
pop r14
retn
loc_3D40C:
cmp eax, [r14+24h]
jnb short loc_3D425
mov rcx, [r14+28h]
mov eax, eax
mov edx, [rcx+rax*4]
cmp edx, 0E0h
jge short loc_3D3ED
jmp short loc_3D400
loc_3D425:
mov rdi, [r14]
mov edx, [r14+10h]
sub edx, [r14+8]
lea rsi, aInvalidAtomInd; "invalid atom index (pos=%u)"
xor eax, eax
call JS_ThrowSyntaxError
and dword ptr [rbx], 0
or dword ptr [r14+30h], 0FFFFFFFFh
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_3D404
| long long bc_idx_to_atom(
long long a1,
int *a2,
int a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v14; // al
unsigned int v15; // eax
_DWORD *v16; // rax
char v18; // [rsp-8h] [rbp-18h]
v18 = v14;
if ( a3 < 0 )
goto LABEL_5;
v15 = a3 - *(_DWORD *)(a1 + 32);
if ( (unsigned int)a3 >= *(_DWORD *)(a1 + 32) )
{
if ( v15 >= *(_DWORD *)(a1 + 36) )
{
JS_ThrowSyntaxError(
*(_QWORD *)a1,
(long long)"invalid atom index (pos=%u)",
(unsigned int)(*(_DWORD *)(a1 + 16) - *(_DWORD *)(a1 + 8)),
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v18);
*a2 = 0;
*(_DWORD *)(a1 + 48) = -1;
return -1LL;
}
a3 = *(_DWORD *)(*(_QWORD *)(a1 + 40) + 4LL * v15);
if ( a3 >= 224 )
goto LABEL_4;
}
else if ( (unsigned int)a3 > 0xDF )
{
LABEL_4:
v16 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 24LL) + 104LL) + 8LL * (unsigned int)a3);
++*v16;
}
LABEL_5:
*a2 = a3;
return 0LL;
}
| bc_idx_to_atom:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
TEST EDX,EDX
JS 0x0013d400
MOV R14,RDI
MOV EAX,EDX
SUB EAX,dword ptr [RDI + 0x20]
JNC 0x0013d40c
CMP EDX,0xdf
JBE 0x0013d400
LAB_0013d3ed:
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,EDX
MOV RAX,qword ptr [RAX + RCX*0x8]
INC dword ptr [RAX]
LAB_0013d400:
MOV dword ptr [RBX],EDX
XOR EAX,EAX
LAB_0013d404:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0013d40c:
CMP EAX,dword ptr [R14 + 0x24]
JNC 0x0013d425
MOV RCX,qword ptr [R14 + 0x28]
MOV EAX,EAX
MOV EDX,dword ptr [RCX + RAX*0x4]
CMP EDX,0xe0
JGE 0x0013d3ed
JMP 0x0013d400
LAB_0013d425:
MOV RDI,qword ptr [R14]
MOV EDX,dword ptr [R14 + 0x10]
SUB EDX,dword ptr [R14 + 0x8]
LEA RSI,[0x186928]
XOR EAX,EAX
CALL 0x0011c5bb
AND dword ptr [RBX],0x0
OR dword ptr [R14 + 0x30],0xffffffff
PUSH -0x1
POP RAX
JMP 0x0013d404
|
int8 bc_idx_to_atom(long *param_1,uint *param_2,uint param_3)
{
int *piVar1;
uint uVar2;
if (-1 < (int)param_3) {
uVar2 = param_3 - *(uint *)(param_1 + 4);
if (param_3 < *(uint *)(param_1 + 4)) {
if (param_3 < 0xe0) goto LAB_0013d400;
}
else {
if (*(uint *)((long)param_1 + 0x24) <= uVar2) {
JS_ThrowSyntaxError(*param_1,"invalid atom index (pos=%u)",(int)param_1[2] - (int)param_1[1]
);
*param_2 = 0;
*(int4 *)(param_1 + 6) = 0xffffffff;
return 0xffffffffffffffff;
}
param_3 = *(uint *)(param_1[5] + (ulong)uVar2 * 4);
if ((int)param_3 < 0xe0) goto LAB_0013d400;
}
piVar1 = *(int **)(*(long *)(*(long *)(*param_1 + 0x18) + 0x68) + (ulong)param_3 * 8);
*piVar1 = *piVar1 + 1;
}
LAB_0013d400:
*param_2 = param_3;
return 0;
}
| |
22,511 | testing::internal::PrintTestPartResult(testing::TestPartResult const&) | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc | static void PrintTestPartResult(const TestPartResult& test_part_result) {
const std::string& result = PrintTestPartResultToString(test_part_result);
printf("%s\n", result.c_str());
fflush(stdout);
// If the test program runs in Visual Studio or a debugger, the
// following statements add the test part result message to the Output
// window such that the user can double-click on it to jump to the
// corresponding source code location; otherwise they do nothing.
#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE)
// We don't call OutputDebugString*() on Windows Mobile, as printing
// to stdout is done by OutputDebugString() there already - we don't
// want the same message printed twice.
::OutputDebugStringA(result.c_str());
::OutputDebugStringA("\n");
#endif
} | O0 | cpp | testing::internal::PrintTestPartResult(testing::TestPartResult const&):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xcea10
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1f1e0
movq %rax, %rsi
leaq 0x4bdba(%rip), %rdi # 0x11d753
xorl %eax, %eax
callq 0x16060
jmp 0xd19a2
movq 0xb3557(%rip), %rax # 0x184f00
movq (%rax), %rdi
callq 0x16850
jmp 0xd19b3
leaq 0x18(%rsp), %rdi
callq 0x1dfd0
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1dfd0
movq 0x10(%rsp), %rdi
callq 0x16cf0
nopw %cs:(%rax,%rax)
| _ZN7testing8internalL19PrintTestPartResultERKNS_14TestPartResultE:
sub rsp, 48h
mov [rsp+48h+var_8], rdi; int
mov rsi, [rsp+48h+var_8]; __int64
lea rdi, [rsp+48h+var_30]; int
mov qword ptr [rsp+48h+var_48], rdi; int
call _ZN7testing8internalL27PrintTestPartResultToStringB5cxx11ERKNS_14TestPartResultE; testing::internal::PrintTestPartResultToString(testing::TestPartResult const&)
mov rax, qword ptr [rsp+48h+var_48]
mov [rsp+48h+var_10], rax
mov rdi, [rsp+48h+var_10]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, rax
lea rdi, aNoteSFilterS+12h; "%s\n"
xor eax, eax
call _printf
jmp short $+2
loc_D19A2:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
jmp short $+2
loc_D19B3:
lea rdi, [rsp+48h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add rsp, 48h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_8], rcx
mov [rsp+arg_4], eax
lea rdi, [rsp+arg_10]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+arg_8]
call __Unwind_Resume
| void testing::internal::PrintTestPartResult(testing::internal *this, const testing::TestPartResult *a2)
{
const char *v2; // rax
int v3[8]; // [rsp+18h] [rbp-30h] BYREF
int *v4; // [rsp+38h] [rbp-10h]
long long v5; // [rsp+40h] [rbp-8h]
v5 = (long long)this;
testing::internal::PrintTestPartResultToString[abi:cxx11]((long long)v3, this);
v4 = v3;
v2 = (const char *)std::string::c_str((long long)v3);
printf("%s\n", v2);
fflush(stdout);
std::string::~string(v3);
}
| PrintTestPartResult:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV RSI,qword ptr [RSP + 0x40]
LEA RDI,[RSP + 0x18]
MOV qword ptr [RSP],RDI
CALL 0x001cea10
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x0011f1e0
MOV RSI,RAX
LAB_001d1992:
LEA RDI,[0x21d753]
XOR EAX,EAX
CALL 0x00116060
JMP 0x001d19a2
LAB_001d19a2:
MOV RAX,qword ptr [0x00284f00]
MOV RDI,qword ptr [RAX]
CALL 0x00116850
LAB_001d19b1:
JMP 0x001d19b3
LAB_001d19b3:
LEA RDI,[RSP + 0x18]
CALL 0x0011dfd0
ADD RSP,0x48
RET
|
/* testing::internal::PrintTestPartResult(testing::TestPartResult const&) */
void testing::internal::PrintTestPartResult(TestPartResult *param_1)
{
int8 uVar1;
internal local_30 [32];
internal *local_10;
TestPartResult *local_8;
local_8 = param_1;
PrintTestPartResultToString_abi_cxx11_(local_30,param_1);
local_10 = local_30;
uVar1 = std::__cxx11::string::c_str((string *)local_30);
/* try { // try from 001d1992 to 001d19b0 has its CatchHandler @ 001d19c2 */
printf("%s\n",uVar1);
fflush(*(FILE **)PTR_stdout_00284f00);
std::__cxx11::string::~string((string *)local_30);
return;
}
| |
22,512 | my_cset_init_8bit | eloqsql/strings/ctype-simple.c | static my_bool
my_cset_init_8bit(struct charset_info_st *cs, MY_CHARSET_LOADER *loader)
{
cs->state|= my_8bit_charset_flags_from_data(cs);
cs->caseup_multiply= 1;
cs->casedn_multiply= 1;
cs->pad_char= ' ';
if (!cs->to_lower || !cs->to_upper || !cs->m_ctype || !cs->tab_to_uni)
return TRUE;
return create_fromuni(cs, loader);
} | O3 | c | my_cset_init_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1808, %rsp # imm = 0x1808
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movq 0x68(%rdi), %r15
xorl %eax, %eax
testq %r15, %r15
je 0xb9519
xorl %ecx, %ecx
cmpw $0x80, (%r15,%rcx,2)
jae 0xb94fa
incq %rcx
cmpq $0x100, %rcx # imm = 0x100
jne 0xb94e0
movl $0x1000, %eax # imm = 0x1000
xorl %ecx, %ecx
movzwl (%r15,%rcx,2), %edx
cmpq %rdx, %rcx
jne 0xb9514
incq %rcx
cmpq $0x80, %rcx
jne 0xb94fc
jmp 0xb9519
orl $0x2000, %eax # imm = 0x2000
orl %eax, 0xc(%rbx)
movw $0x101, 0x94(%rbx) # imm = 0x101
movb $0x20, 0xb0(%rbx)
movb $0x1, %al
cmpq $0x0, 0x48(%rbx)
je 0xb9709
cmpq $0x0, 0x50(%rbx)
je 0xb9709
testq %r15, %r15
je 0xb9709
cmpq $0x0, 0x40(%rbx)
je 0xb9709
leaq -0x1830(%rbp), %rdi
xorl %r12d, %r12d
movl $0x1800, %edx # imm = 0x1800
xorl %esi, %esi
callq 0x29270
movzwl (%r15,%r12,2), %eax
testq %rax, %rax
sete %cl
testq %r12, %r12
setne %dl
testb %cl, %dl
jne 0xb95c6
movl %eax, %ecx
shrl $0x8, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq -0x1830(,%rcx,8), %rcx
addq %rbp, %rcx
movl (%rcx), %edx
testl %edx, %edx
je 0xb95ba
movl 0x8(%rcx), %esi
movl %eax, %edi
cmpw %si, %ax
jb 0xb95a9
movl %esi, %edi
movw %di, 0x8(%rcx)
movzwl 0xa(%rcx), %esi
cmpw %si, %ax
ja 0xb95be
movl %esi, %eax
jmp 0xb95be
movw %ax, 0x8(%rcx)
movw %ax, 0xa(%rcx)
incl %edx
movl %edx, (%rcx)
incq %r12
cmpq $0x100, %r12 # imm = 0x100
jne 0xb956e
leaq 0x1b0(%rip), %rcx # 0xb9789
leaq -0x1830(%rbp), %rdi
movl $0x100, %esi # imm = 0x100
movl $0x18, %edx
callq 0x29550
xorl %r13d, %r13d
leaq (,%r13,2), %rax
addq %r13, %rax
cmpl $0x0, -0x1830(%rbp,%rax,8)
je 0xb96a0
leaq -0x1830(,%rax,8), %r14
addq %rbp, %r14
movzwl 0xa(%r14), %r12d
movzwl 0x8(%r14), %eax
subq %rax, %r12
incq %r12
movq %r12, %rdi
movq -0x30(%rbp), %rax
callq *0x80(%rax)
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0xb96f4
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x29270
movl $0x1, %eax
movq 0x68(%rbx), %rcx
movzwl (%rcx,%rax,2), %ecx
movzwl 0x8(%r14), %edx
cmpw %dx, %cx
jb 0xb967f
leal -0x1(%rcx), %esi
cmpw 0xa(%r14), %si
jae 0xb967f
subq %rdx, %rcx
cmpb $0x0, (%r15,%rcx)
jg 0xb967f
movb %al, (%r15,%rcx)
incq %rax
cmpq $0x100, %rax # imm = 0x100
jne 0xb9655
incq %r13
cmpq $0x100, %r13 # imm = 0x100
jne 0xb95f2
movl $0x100, %r13d # imm = 0x100
movl %r13d, %r14d
movq %r14, %rdi
shlq $0x4, %rdi
addq $0x10, %rdi
movq -0x30(%rbp), %rax
callq *0x80(%rax)
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0xb96f4
testl %r13d, %r13d
je 0xb96f8
movq %r14, %rax
shlq $0x4, %rax
leaq -0x1828(%rbp), %rcx
xorl %edx, %edx
movq 0x70(%rbx), %rsi
movups (%rcx), %xmm0
movups %xmm0, (%rsi,%rdx)
addq $0x10, %rdx
addq $0x18, %rcx
cmpq %rdx, %rax
jne 0xb96d6
movq 0x70(%rbx), %rax
jmp 0xb96fb
movb $0x1, %al
jmp 0xb9709
xorl %r14d, %r14d
shlq $0x4, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%r14)
xorl %eax, %eax
addq $0x1808, %rsp # imm = 0x1808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_cset_init_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1808h
mov [rbp+var_30], rsi
mov rbx, rdi
mov r15, [rdi+68h]
xor eax, eax
test r15, r15
jz short loc_B9519
xor ecx, ecx
loc_B94E0:
cmp word ptr [r15+rcx*2], 80h
jnb short loc_B94FA
inc rcx
cmp rcx, 100h
jnz short loc_B94E0
mov eax, 1000h
loc_B94FA:
xor ecx, ecx
loc_B94FC:
movzx edx, word ptr [r15+rcx*2]
cmp rcx, rdx
jnz short loc_B9514
inc rcx
cmp rcx, 80h
jnz short loc_B94FC
jmp short loc_B9519
loc_B9514:
or eax, 2000h
loc_B9519:
or [rbx+0Ch], eax
mov word ptr [rbx+94h], 101h
mov byte ptr [rbx+0B0h], 20h ; ' '
mov al, 1
cmp qword ptr [rbx+48h], 0
jz loc_B9709
cmp qword ptr [rbx+50h], 0
jz loc_B9709
test r15, r15
jz loc_B9709
cmp qword ptr [rbx+40h], 0
jz loc_B9709
lea rdi, [rbp+var_1830]
xor r12d, r12d
mov edx, 1800h
xor esi, esi
call _memset
loc_B956E:
movzx eax, word ptr [r15+r12*2]
test rax, rax
setz cl
test r12, r12
setnz dl
test dl, cl
jnz short loc_B95C6
mov ecx, eax
shr ecx, 8
lea rcx, [rcx+rcx*2]
lea rcx, ds:0FFFFFFFFFFFFE7D0h[rcx*8]
add rcx, rbp
mov edx, [rcx]
test edx, edx
jz short loc_B95BA
mov esi, [rcx+8]
mov edi, eax
cmp ax, si
jb short loc_B95A9
mov edi, esi
loc_B95A9:
mov [rcx+8], di
movzx esi, word ptr [rcx+0Ah]
cmp ax, si
ja short loc_B95BE
mov eax, esi
jmp short loc_B95BE
loc_B95BA:
mov [rcx+8], ax
loc_B95BE:
mov [rcx+0Ah], ax
inc edx
mov [rcx], edx
loc_B95C6:
inc r12
cmp r12, 100h
jnz short loc_B956E
lea rcx, pcmp
lea rdi, [rbp+var_1830]
mov esi, 100h
mov edx, 18h
call _qsort
xor r13d, r13d
loc_B95F2:
lea rax, ds:0[r13*2]
add rax, r13
cmp [rbp+rax*8+var_1830], 0
jz loc_B96A0
lea r14, ds:0FFFFFFFFFFFFE7D0h[rax*8]
add r14, rbp
movzx r12d, word ptr [r14+0Ah]
movzx eax, word ptr [r14+8]
sub r12, rax
inc r12
mov rdi, r12
mov rax, [rbp+var_30]
call qword ptr [rax+80h]
mov [r14+10h], rax
test rax, rax
jz loc_B96F4
mov r15, rax
mov rdi, rax
xor esi, esi
mov rdx, r12
call _memset
mov eax, 1
loc_B9655:
mov rcx, [rbx+68h]
movzx ecx, word ptr [rcx+rax*2]
movzx edx, word ptr [r14+8]
cmp cx, dx
jb short loc_B967F
lea esi, [rcx-1]
cmp si, [r14+0Ah]
jnb short loc_B967F
sub rcx, rdx
cmp byte ptr [r15+rcx], 0
jg short loc_B967F
mov [r15+rcx], al
loc_B967F:
inc rax
cmp rax, 100h
jnz short loc_B9655
inc r13
cmp r13, 100h
jnz loc_B95F2
mov r13d, 100h
loc_B96A0:
mov r14d, r13d
mov rdi, r14
shl rdi, 4
add rdi, 10h
mov rax, [rbp+var_30]
call qword ptr [rax+80h]
mov [rbx+70h], rax
test rax, rax
jz short loc_B96F4
test r13d, r13d
jz short loc_B96F8
mov rax, r14
shl rax, 4
lea rcx, [rbp+var_1828]
xor edx, edx
loc_B96D6:
mov rsi, [rbx+70h]
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rsi+rdx], xmm0
add rdx, 10h
add rcx, 18h
cmp rax, rdx
jnz short loc_B96D6
mov rax, [rbx+70h]
jmp short loc_B96FB
loc_B96F4:
mov al, 1
jmp short loc_B9709
loc_B96F8:
xor r14d, r14d
loc_B96FB:
shl r14, 4
xorps xmm0, xmm0
movups xmmword ptr [rax+r14], xmm0
xor eax, eax
loc_B9709:
add rsp, 1808h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char my_cset_init_8bit(long long a1, long long a2)
{
long long v3; // r15
int v4; // eax
long long v5; // rcx
long long v6; // rcx
char result; // al
long long v8; // r12
long long v9; // rax
long long *v10; // rcx
int v11; // edx
__int16 v12; // di
long long v13; // r13
long long *v14; // r14
unsigned long long v15; // r12
long long v16; // rax
long long v17; // r15
long long i; // rax
long long v19; // rcx
long long v20; // rdx
long long v21; // rcx
long long v22; // r14
long long v23; // rax
char *v24; // rcx
long long v25; // rdx
_DWORD v26[2]; // [rsp+0h] [rbp-1830h] BYREF
char v27; // [rsp+8h] [rbp-1828h] BYREF
long long v28; // [rsp+1800h] [rbp-30h]
long long savedregs; // [rsp+1830h] [rbp+0h] BYREF
_UNKNOWN *retaddr; // [rsp+1838h] [rbp+8h]
v28 = a2;
v3 = *(_QWORD *)(a1 + 104);
v4 = 0;
if ( v3 )
{
v5 = 0LL;
while ( *(_WORD *)(v3 + 2 * v5) < 0x80u )
{
if ( ++v5 == 256 )
{
v4 = 4096;
break;
}
}
v6 = 0LL;
while ( v6 == *(unsigned __int16 *)(v3 + 2 * v6) )
{
if ( ++v6 == 128 )
goto LABEL_11;
}
v4 |= 0x2000u;
}
LABEL_11:
*(_DWORD *)(a1 + 12) |= v4;
*(_WORD *)(a1 + 148) = 257;
*(_BYTE *)(a1 + 176) = 32;
result = 1;
if ( *(_QWORD *)(a1 + 72) && *(_QWORD *)(a1 + 80) && v3 && *(_QWORD *)(a1 + 64) )
{
v8 = 0LL;
memset(v26, 0LL, 6144LL);
do
{
v9 = *(unsigned __int16 *)(v3 + 2 * v8);
if ( v9 != 0 || v8 == 0 )
{
v10 = &savedregs + 3 * ((unsigned int)v9 >> 8) - 774;
v11 = *(_DWORD *)v10;
if ( *(_DWORD *)v10 )
{
v12 = *(_WORD *)(v3 + 2 * v8);
if ( (unsigned __int16)v9 >= (unsigned __int16)*((_DWORD *)v10 + 2) )
v12 = *((_DWORD *)v10 + 2);
*((_WORD *)v10 + 4) = v12;
if ( (unsigned __int16)v9 <= *((_WORD *)v10 + 5) )
LOWORD(v9) = *((_WORD *)v10 + 5);
}
else
{
*((_WORD *)v10 + 4) = v9;
}
*((_WORD *)v10 + 5) = v9;
*(_DWORD *)v10 = v11 + 1;
}
++v8;
}
while ( v8 != 256 );
qsort(v26, 256LL, 24LL, pcmp);
v13 = 0LL;
while ( v26[6 * v13] )
{
v14 = &savedregs + 3 * v13 - 774;
v15 = *((unsigned __int16 *)&retaddr + 12 * v13 - 3095)
- (unsigned long long)*((unsigned __int16 *)&retaddr + 12 * v13 - 3096)
+ 1;
v16 = (*(long long ( **)(unsigned long long))(v28 + 128))(v15);
v14[2] = v16;
if ( !v16 )
return 1;
v17 = v16;
memset(v16, 0LL, v15);
for ( i = 1LL; i != 256; ++i )
{
v19 = *(unsigned __int16 *)(*(_QWORD *)(a1 + 104) + 2 * i);
v20 = *((unsigned __int16 *)v14 + 4);
if ( (unsigned __int16)v19 >= (unsigned __int16)v20 && (unsigned __int16)(v19 - 1) < *((_WORD *)v14 + 5) )
{
v21 = v19 - v20;
if ( *(char *)(v17 + v21) <= 0 )
*(_BYTE *)(v17 + v21) = i;
}
}
if ( ++v13 == 256 )
{
LODWORD(v13) = 256;
break;
}
}
v22 = (unsigned int)v13;
v23 = (*(long long ( **)(long long))(v28 + 128))(16LL * (unsigned int)v13 + 16);
*(_QWORD *)(a1 + 112) = v23;
if ( !v23 )
return 1;
if ( (_DWORD)v13 )
{
v24 = &v27;
v25 = 0LL;
do
{
*(_OWORD *)(*(_QWORD *)(a1 + 112) + v25) = *(_OWORD *)v24;
v25 += 16LL;
v24 += 24;
}
while ( 16LL * (unsigned int)v13 != v25 );
v23 = *(_QWORD *)(a1 + 112);
}
else
{
v22 = 0LL;
}
*(_OWORD *)(v23 + 16 * v22) = 0LL;
return 0;
}
return result;
}
| my_cset_init_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1808
MOV qword ptr [RBP + -0x30],RSI
MOV RBX,RDI
MOV R15,qword ptr [RDI + 0x68]
XOR EAX,EAX
TEST R15,R15
JZ 0x001b9519
XOR ECX,ECX
LAB_001b94e0:
CMP word ptr [R15 + RCX*0x2],0x80
JNC 0x001b94fa
INC RCX
CMP RCX,0x100
JNZ 0x001b94e0
MOV EAX,0x1000
LAB_001b94fa:
XOR ECX,ECX
LAB_001b94fc:
MOVZX EDX,word ptr [R15 + RCX*0x2]
CMP RCX,RDX
JNZ 0x001b9514
INC RCX
CMP RCX,0x80
JNZ 0x001b94fc
JMP 0x001b9519
LAB_001b9514:
OR EAX,0x2000
LAB_001b9519:
OR dword ptr [RBX + 0xc],EAX
MOV word ptr [RBX + 0x94],0x101
MOV byte ptr [RBX + 0xb0],0x20
MOV AL,0x1
CMP qword ptr [RBX + 0x48],0x0
JZ 0x001b9709
CMP qword ptr [RBX + 0x50],0x0
JZ 0x001b9709
TEST R15,R15
JZ 0x001b9709
CMP qword ptr [RBX + 0x40],0x0
JZ 0x001b9709
LEA RDI,[RBP + -0x1830]
XOR R12D,R12D
MOV EDX,0x1800
XOR ESI,ESI
CALL 0x00129270
LAB_001b956e:
MOVZX EAX,word ptr [R15 + R12*0x2]
TEST RAX,RAX
SETZ CL
TEST R12,R12
SETNZ DL
TEST DL,CL
JNZ 0x001b95c6
MOV ECX,EAX
SHR ECX,0x8
LEA RCX,[RCX + RCX*0x2]
LEA RCX,[-0x1830 + RCX*0x8]
ADD RCX,RBP
MOV EDX,dword ptr [RCX]
TEST EDX,EDX
JZ 0x001b95ba
MOV ESI,dword ptr [RCX + 0x8]
MOV EDI,EAX
CMP AX,SI
JC 0x001b95a9
MOV EDI,ESI
LAB_001b95a9:
MOV word ptr [RCX + 0x8],DI
MOVZX ESI,word ptr [RCX + 0xa]
CMP AX,SI
JA 0x001b95be
MOV EAX,ESI
JMP 0x001b95be
LAB_001b95ba:
MOV word ptr [RCX + 0x8],AX
LAB_001b95be:
MOV word ptr [RCX + 0xa],AX
INC EDX
MOV dword ptr [RCX],EDX
LAB_001b95c6:
INC R12
CMP R12,0x100
JNZ 0x001b956e
LEA RCX,[0x1b9789]
LEA RDI,[RBP + -0x1830]
MOV ESI,0x100
MOV EDX,0x18
CALL 0x00129550
XOR R13D,R13D
LAB_001b95f2:
LEA RAX,[R13*0x2]
ADD RAX,R13
CMP dword ptr [RBP + RAX*0x8 + -0x1830],0x0
JZ 0x001b96a0
LEA R14,[-0x1830 + RAX*0x8]
ADD R14,RBP
MOVZX R12D,word ptr [R14 + 0xa]
MOVZX EAX,word ptr [R14 + 0x8]
SUB R12,RAX
INC R12
MOV RDI,R12
MOV RAX,qword ptr [RBP + -0x30]
CALL qword ptr [RAX + 0x80]
MOV qword ptr [R14 + 0x10],RAX
TEST RAX,RAX
JZ 0x001b96f4
MOV R15,RAX
MOV RDI,RAX
XOR ESI,ESI
MOV RDX,R12
CALL 0x00129270
MOV EAX,0x1
LAB_001b9655:
MOV RCX,qword ptr [RBX + 0x68]
MOVZX ECX,word ptr [RCX + RAX*0x2]
MOVZX EDX,word ptr [R14 + 0x8]
CMP CX,DX
JC 0x001b967f
LEA ESI,[RCX + -0x1]
CMP SI,word ptr [R14 + 0xa]
JNC 0x001b967f
SUB RCX,RDX
CMP byte ptr [R15 + RCX*0x1],0x0
JG 0x001b967f
MOV byte ptr [R15 + RCX*0x1],AL
LAB_001b967f:
INC RAX
CMP RAX,0x100
JNZ 0x001b9655
INC R13
CMP R13,0x100
JNZ 0x001b95f2
MOV R13D,0x100
LAB_001b96a0:
MOV R14D,R13D
MOV RDI,R14
SHL RDI,0x4
ADD RDI,0x10
MOV RAX,qword ptr [RBP + -0x30]
CALL qword ptr [RAX + 0x80]
MOV qword ptr [RBX + 0x70],RAX
TEST RAX,RAX
JZ 0x001b96f4
TEST R13D,R13D
JZ 0x001b96f8
MOV RAX,R14
SHL RAX,0x4
LEA RCX,[RBP + -0x1828]
XOR EDX,EDX
LAB_001b96d6:
MOV RSI,qword ptr [RBX + 0x70]
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSI + RDX*0x1],XMM0
ADD RDX,0x10
ADD RCX,0x18
CMP RAX,RDX
JNZ 0x001b96d6
MOV RAX,qword ptr [RBX + 0x70]
JMP 0x001b96fb
LAB_001b96f4:
MOV AL,0x1
JMP 0x001b9709
LAB_001b96f8:
XOR R14D,R14D
LAB_001b96fb:
SHL R14,0x4
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + R14*0x1],XMM0
XOR EAX,EAX
LAB_001b9709:
ADD RSP,0x1808
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 my_cset_init_8bit(long param_1,long param_2)
{
int8 *puVar1;
int iVar2;
ushort uVar3;
uint uVar4;
int8 uVar5;
void *__s;
long lVar6;
long lVar7;
ulong uVar8;
ushort *puVar9;
ushort uVar10;
size_t __n;
ulong uVar11;
int local_1838 [2];
ushort local_1830 [4];
int8 auStack_1828 [766];
long local_38;
lVar6 = *(long *)(param_1 + 0x68);
uVar4 = 0;
if (lVar6 != 0) {
lVar7 = 0;
do {
if (0x7f < *(ushort *)(lVar6 + lVar7 * 2)) goto LAB_001b94fa;
lVar7 = lVar7 + 1;
} while (lVar7 != 0x100);
uVar4 = 0x1000;
LAB_001b94fa:
uVar8 = 0;
do {
if (uVar8 != *(ushort *)(lVar6 + uVar8 * 2)) {
uVar4 = uVar4 | 0x2000;
break;
}
uVar8 = uVar8 + 1;
} while (uVar8 != 0x80);
}
*(uint *)(param_1 + 0xc) = *(uint *)(param_1 + 0xc) | uVar4;
*(int2 *)(param_1 + 0x94) = 0x101;
*(int1 *)(param_1 + 0xb0) = 0x20;
uVar5 = 1;
if ((((*(long *)(param_1 + 0x48) != 0) && (*(long *)(param_1 + 0x50) != 0)) && (lVar6 != 0)) &&
(*(long *)(param_1 + 0x40) != 0)) {
lVar7 = 0;
local_38 = param_2;
memset(local_1838,0,0x1800);
do {
uVar3 = *(ushort *)(lVar6 + lVar7 * 2);
if (lVar7 == 0 || uVar3 != 0) {
uVar8 = (ulong)(uVar3 >> 8);
iVar2 = local_1838[uVar8 * 6];
if (iVar2 == 0) {
local_1830[uVar8 * 0xc] = uVar3;
}
else {
uVar10 = uVar3;
if ((ushort)*(int4 *)(local_1830 + uVar8 * 0xc) <= uVar3) {
uVar10 = (ushort)*(int4 *)(local_1830 + uVar8 * 0xc);
}
local_1830[uVar8 * 0xc] = uVar10;
if (uVar3 <= local_1830[uVar8 * 0xc + 1]) {
uVar3 = local_1830[uVar8 * 0xc + 1];
}
}
local_1830[uVar8 * 0xc + 1] = uVar3;
local_1838[uVar8 * 6] = iVar2 + 1;
}
lVar7 = lVar7 + 1;
} while (lVar7 != 0x100);
qsort(local_1838,0x100,0x18,pcmp);
uVar8 = 0;
do {
if (local_1838[uVar8 * 6] == 0) goto LAB_001b96a0;
__n = ((ulong)local_1830[uVar8 * 0xc + 1] - (ulong)local_1830[uVar8 * 0xc]) + 1;
__s = (void *)(**(code **)(local_38 + 0x80))(__n);
auStack_1828[uVar8 * 3] = __s;
if (__s == (void *)0x0) goto LAB_001b96f4;
memset(__s,0,__n);
lVar6 = 1;
do {
uVar3 = *(ushort *)(*(long *)(param_1 + 0x68) + lVar6 * 2);
if (((local_1830[uVar8 * 0xc] <= uVar3) &&
((ushort)(uVar3 - 1) < local_1830[uVar8 * 0xc + 1])) &&
(lVar7 = (ulong)uVar3 - (ulong)local_1830[uVar8 * 0xc],
*(char *)((long)__s + lVar7) < '\x01')) {
*(char *)((long)__s + lVar7) = (char)lVar6;
}
lVar6 = lVar6 + 1;
} while (lVar6 != 0x100);
uVar8 = uVar8 + 1;
} while (uVar8 != 0x100);
uVar8 = 0x100;
LAB_001b96a0:
uVar11 = uVar8 & 0xffffffff;
lVar6 = (**(code **)(local_38 + 0x80))(uVar11 * 0x10 + 0x10);
*(long *)(param_1 + 0x70) = lVar6;
if (lVar6 == 0) {
LAB_001b96f4:
uVar5 = 1;
}
else {
if ((int)uVar8 == 0) {
uVar11 = 0;
}
else {
puVar9 = local_1830;
lVar6 = 0;
do {
uVar5 = *(int8 *)(puVar9 + 4);
puVar1 = (int8 *)(*(long *)(param_1 + 0x70) + lVar6);
*puVar1 = *(int8 *)puVar9;
puVar1[1] = uVar5;
lVar6 = lVar6 + 0x10;
puVar9 = puVar9 + 0xc;
} while (uVar11 << 4 != lVar6);
lVar6 = *(long *)(param_1 + 0x70);
}
puVar1 = (int8 *)(lVar6 + uVar11 * 0x10);
*puVar1 = 0;
puVar1[1] = 0;
uVar5 = 0;
}
}
return uVar5;
}
| |
22,513 | ma_mark_file_crashed | eloqsql/storage/maria/ma_locking.c | void _ma_mark_file_crashed(MARIA_SHARE *share)
{
uchar buff[2];
DBUG_ENTER("_ma_mark_file_crashed");
share->state.changed|= STATE_CRASHED;
if (share->no_status_updates)
DBUG_VOID_RETURN; /* Safety */
mi_int2store(buff, share->state.changed);
/*
We can ignore the errors, as if the mark failed, there isn't anything
else we can do; The user should already have got an error that the
table was crashed.
*/
(void) my_pwrite(share->kfile.file, buff, sizeof(buff),
sizeof(share->state.header) +
MARIA_FILE_CHANGED_OFFSET,
MYF(MY_NABP));
DBUG_VOID_RETURN;
} | O0 | c | ma_mark_file_crashed:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x170(%rax)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x7e1(%rax)
je 0x35c70
jmp 0x35c6e
jmp 0x35cb1
movq -0x8(%rbp), %rax
movl 0x170(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movb %al, -0x9(%rbp)
movl -0x10(%rbp), %eax
shrl $0x8, %eax
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl 0x760(%rax), %edi
leaq -0xa(%rbp), %rsi
movl $0x2, %edx
movl $0x1a, %ecx
movl $0x4, %r8d
callq 0xf4280
jmp 0x35cb1
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ma_mark_file_crashed:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov ecx, [rax+170h]
or ecx, 2
mov [rax+170h], ecx
mov rax, [rbp+var_8]
cmp byte ptr [rax+7E1h], 0
jz short loc_35C70
jmp short $+2
loc_35C6E:
jmp short loc_35CB1
loc_35C70:
mov rax, [rbp+var_8]
mov eax, [rax+170h]
mov [rbp+var_10], eax
mov eax, [rbp+var_10]
mov [rbp+var_9], al
mov eax, [rbp+var_10]
shr eax, 8
mov [rbp+var_A], al
mov rax, [rbp+var_8]
mov edi, [rax+760h]
lea rsi, [rbp+var_A]
mov edx, 2
mov ecx, 1Ah
mov r8d, 4
call my_pwrite
jmp short $+2
loc_35CB1:
add rsp, 10h
pop rbp
retn
| long long ma_mark_file_crashed(long long a1)
{
long long result; // rax
__int16 v2; // kr00_2
_BYTE v3[2]; // [rsp+6h] [rbp-Ah] BYREF
long long v4; // [rsp+8h] [rbp-8h]
v4 = a1;
*(_DWORD *)(a1 + 368) |= 2u;
result = v4;
if ( !*(_BYTE *)(v4 + 2017) )
{
v2 = *(_DWORD *)(v4 + 368);
v3[0] = HIBYTE(v2);
v3[1] = v2;
return my_pwrite(*(unsigned int *)(v4 + 1888), v3, 2LL, 26LL);
}
return result;
}
| _ma_mark_file_crashed:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x2
MOV dword ptr [RAX + 0x170],ECX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x7e1],0x0
JZ 0x00135c70
JMP 0x00135c6e
LAB_00135c6e:
JMP 0x00135cb1
LAB_00135c70:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x170]
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x10]
MOV byte ptr [RBP + -0x9],AL
MOV EAX,dword ptr [RBP + -0x10]
SHR EAX,0x8
MOV byte ptr [RBP + -0xa],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV EDI,dword ptr [RAX + 0x760]
LEA RSI,[RBP + -0xa]
MOV EDX,0x2
MOV ECX,0x1a
MOV R8D,0x4
CALL 0x001f4280
JMP 0x00135cb1
LAB_00135cb1:
ADD RSP,0x10
POP RBP
RET
|
void _ma_mark_file_crashed(long param_1)
{
int4 uVar1;
int8 in_R9;
int1 local_12;
int1 local_11;
long local_10;
*(uint *)(param_1 + 0x170) = *(uint *)(param_1 + 0x170) | 2;
if (*(char *)(param_1 + 0x7e1) == '\0') {
uVar1 = *(int4 *)(param_1 + 0x170);
local_11 = (int1)uVar1;
local_12 = (int1)((uint)uVar1 >> 8);
local_10 = param_1;
my_pwrite(*(int4 *)(param_1 + 0x760),&local_12,2,0x1a,4,in_R9,uVar1);
}
return;
}
| |
22,514 | minja::Parser::parseString[abi:cxx11]() | monkey531[P]llama/common/minja.hpp | std::unique_ptr<std::string> parseString() {
auto doParse = [&](char quote) -> std::unique_ptr<std::string> {
if (it == end || *it != quote) return nullptr;
std::string result;
bool escape = false;
for (++it; it != end; ++it) {
if (escape) {
escape = false;
switch (*it) {
case 'n': result += '\n'; break;
case 'r': result += '\r'; break;
case 't': result += '\t'; break;
case 'b': result += '\b'; break;
case 'f': result += '\f'; break;
case '\\': result += '\\'; break;
default:
if (*it == quote) {
result += quote;
} else {
result += *it;
}
break;
}
} else if (*it == '\\') {
escape = true;
} else if (*it == quote) {
++it;
return std::make_unique<std::string>(std::move(result));
} else {
result += *it;
}
}
return nullptr;
};
consumeSpaces();
if (it == end) return nullptr;
if (*it == '"') return doParse('"');
if (*it == '\'') return doParse('\'');
return nullptr;
} | O0 | cpp | minja::Parser::parseString[abi:cxx11]():
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x1, %esi
callq 0x10ee00
movq 0x18(%rsp), %rsi
movq %rsi, %rdi
addq $0x20, %rdi
addq $0x18, %rsi
callq 0xe1760
testb $0x1, %al
jne 0x11bf3f
jmp 0x11bf4f
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11c8c0
jmp 0x11bfb5
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0xa5620
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x11bf7b
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x22, %edx
callq 0x11c900
jmp 0x11bfb5
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0xa5620
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x11bfa7
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x27, %edx
callq 0x11c900
jmp 0x11bfb5
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11c8c0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nop
| _ZN5minja6Parser11parseStringB5cxx11Ev:
sub rsp, 38h
mov [rsp+38h+var_30], rdi
mov rax, rdi
mov [rsp+38h+var_28], rax
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rdi, [rsp+38h+var_10]
mov [rsp+38h+var_20], rdi
mov [rsp+38h+var_18], rdi
mov esi, 1
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rsi, [rsp+38h+var_20]
mov rdi, rsi
add rdi, 20h ; ' '
add rsi, 18h
call _ZN9__gnu_cxxeqIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESE_; __gnu_cxx::operator==<char const*,std::string>(__gnu_cxx::__normal_iterator<char const*,std::string> const&,__gnu_cxx::__normal_iterator<char const*,std::string> const&)
test al, 1
jnz short loc_11BF3F
jmp short loc_11BF4F
loc_11BF3F:
mov rdi, [rsp+38h+var_30]
xor eax, eax
mov esi, eax
call _ZNSt10unique_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt14default_deleteIS5_EEC2IS7_vEEDn; std::unique_ptr<std::string>::unique_ptr<std::default_delete<std::string>,void>(decltype(nullptr))
jmp short loc_11BFB5
loc_11BF4F:
mov rdi, [rsp+38h+var_20]
add rdi, 20h ; ' '
call _ZNK9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char const*,std::string>::operator*(void)
movsx eax, byte ptr [rax]
cmp eax, 22h ; '"'
jnz short loc_11BF7B
mov rdi, [rsp+38h+var_30]
lea rsi, [rsp+38h+var_18]
mov edx, 22h ; '"'
call _ZZN5minja6Parser11parseStringB5cxx11EvENKUlcE_clB5cxx11Ec; minja::Parser::parseString(void)::{lambda(char)#1}::operator()(char)
jmp short loc_11BFB5
loc_11BF7B:
mov rdi, [rsp+38h+var_20]
add rdi, 20h ; ' '
call _ZNK9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char const*,std::string>::operator*(void)
movsx eax, byte ptr [rax]
cmp eax, 27h ; '''
jnz short loc_11BFA7
mov rdi, [rsp+38h+var_30]
lea rsi, [rsp+38h+var_18]
mov edx, 27h ; '''
call _ZZN5minja6Parser11parseStringB5cxx11EvENKUlcE_clB5cxx11Ec; minja::Parser::parseString(void)::{lambda(char)#1}::operator()(char)
jmp short loc_11BFB5
loc_11BFA7:
mov rdi, [rsp+38h+var_30]
xor eax, eax
mov esi, eax
call _ZNSt10unique_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt14default_deleteIS5_EEC2IS7_vEEDn; std::unique_ptr<std::string>::unique_ptr<std::default_delete<std::string>,void>(decltype(nullptr))
loc_11BFB5:
mov rax, [rsp+38h+var_28]
add rsp, 38h
retn
| ||||
22,515 | minja::Parser::parseString[abi:cxx11]() | monkey531[P]llama/common/minja.hpp | std::unique_ptr<std::string> parseString() {
auto doParse = [&](char quote) -> std::unique_ptr<std::string> {
if (it == end || *it != quote) return nullptr;
std::string result;
bool escape = false;
for (++it; it != end; ++it) {
if (escape) {
escape = false;
switch (*it) {
case 'n': result += '\n'; break;
case 'r': result += '\r'; break;
case 't': result += '\t'; break;
case 'b': result += '\b'; break;
case 'f': result += '\f'; break;
case '\\': result += '\\'; break;
default:
if (*it == quote) {
result += quote;
} else {
result += *it;
}
break;
}
} else if (*it == '\\') {
escape = true;
} else if (*it == quote) {
++it;
return std::make_unique<std::string>(std::move(result));
} else {
result += *it;
}
}
return nullptr;
};
consumeSpaces();
if (it == end) return nullptr;
if (*it == '"') return doParse('"');
if (*it == '\'') return doParse('\'');
return nullptr;
} | O2 | cpp | minja::Parser::parseString[abi:cxx11]():
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rsp)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x614be
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
je 0x66b1b
movzbl (%rax), %eax
cmpl $0x27, %eax
je 0x66b21
cmpl $0x22, %eax
jne 0x66b1b
movq %rsp, %rsi
pushq $0x22
jmp 0x66b26
andq $0x0, (%rbx)
jmp 0x66b2f
movq %rsp, %rsi
pushq $0x27
popq %rdx
movq %rbx, %rdi
callq 0x66e96
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN5minja6Parser11parseStringB5cxx11Ev:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov [rsp+18h+var_18], rsi
push 1
pop rsi
mov rdi, r14
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rax, [r14+20h]
cmp rax, [r14+18h]
jz short loc_66B1B
movzx eax, byte ptr [rax]
cmp eax, 27h ; '''
jz short loc_66B21
cmp eax, 22h ; '"'
jnz short loc_66B1B
mov rsi, rsp
push 22h ; '"'
jmp short loc_66B26
loc_66B1B:
and qword ptr [rbx], 0
jmp short loc_66B2F
loc_66B21:
mov rsi, rsp
push 27h ; '''
loc_66B26:
pop rdx
mov rdi, rbx
call _ZZN5minja6Parser11parseStringB5cxx11EvENKUlcE_clB5cxx11Ec; minja::Parser::parseString(void)::{lambda(char)#1}::operator()(char)
loc_66B2F:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| _QWORD * minja::Parser::parseString[abi:cxx11](_QWORD *a1, long long a2)
{
int v2; // ecx
int v3; // r8d
int v4; // r9d
unsigned __int8 *v5; // rax
int v6; // eax
char v8[24]; // [rsp+0h] [rbp-18h] BYREF
*(_QWORD *)v8 = a2;
minja::Parser::consumeSpaces(a2, 1);
v5 = *(unsigned __int8 **)(a2 + 32);
if ( v5 == *(unsigned __int8 **)(a2 + 24) )
goto LABEL_5;
v6 = *v5;
if ( v6 == 39 )
{
minja::Parser::parseString[abi:cxx11](void)::{lambda(char)#1}::operator()[abi:cxx11](
(_DWORD)a1,
(unsigned int)v8,
39,
v2,
v3,
v4,
v8[0]);
return a1;
}
if ( v6 != 34 )
LABEL_5:
*a1 = 0LL;
else
minja::Parser::parseString[abi:cxx11](void)::{lambda(char)#1}::operator()[abi:cxx11](
(_DWORD)a1,
(unsigned int)v8,
34,
v2,
v3,
v4,
v8[0]);
return a1;
}
| parseString[abi:cxx11]:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV qword ptr [RSP],RSI
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x001614be
MOV RAX,qword ptr [R14 + 0x20]
CMP RAX,qword ptr [R14 + 0x18]
JZ 0x00166b1b
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x27
JZ 0x00166b21
CMP EAX,0x22
JNZ 0x00166b1b
MOV RSI,RSP
PUSH 0x22
JMP 0x00166b26
LAB_00166b1b:
AND qword ptr [RBX],0x0
JMP 0x00166b2f
LAB_00166b21:
MOV RSI,RSP
PUSH 0x27
LAB_00166b26:
POP RDX
MOV RDI,RBX
CALL 0x00166e96
LAB_00166b2f:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::Parser::parseString[abi:cxx11]() */
void minja::Parser::parseString_abi_cxx11_(void)
{
char cVar1;
long in_RSI;
int8 *in_RDI;
consumeSpaces();
if ((*(char **)(in_RSI + 0x20) == *(char **)(in_RSI + 0x18)) ||
((cVar1 = **(char **)(in_RSI + 0x20), cVar1 != '\'' && (cVar1 != '\"')))) {
*in_RDI = 0;
}
else {
parseString[abi:cxx11]()::{lambda(char)#1}::operator()[abi_cxx11_((char)in_RDI);
}
return;
}
| |
22,516 | ma_pvio_tls_compare_fp | eloqsql/libmariadb/libmariadb/ma_tls.c | static my_bool ma_pvio_tls_compare_fp(const char *cert_fp,
unsigned int cert_fp_len,
const char *fp, unsigned int fp_len)
{
char *p= (char *)fp,
*c;
/* check length */
if (cert_fp_len != 20)
return 1;
/* We support two formats:
2 digits hex numbers, separated by colons (length=59)
20 * 2 digits hex numbers without separators (length = 40)
*/
if (fp_len != (strchr(fp, ':') ? 59 : 40))
return 1;
for(c= (char *)cert_fp; c < cert_fp + cert_fp_len; c++)
{
signed char d1, d2;
if (*p == ':')
p++;
if (p - fp > (int)fp_len -1)
return 1;
if ((d1 = ma_hex2int(*p)) == - 1 ||
(d2 = ma_hex2int(*(p+1))) == -1 ||
(char)(d1 * 16 + d2) != *c)
return 1;
p+= 2;
}
return 0;
} | O0 | c | ma_pvio_tls_compare_fp:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x14, -0x14(%rbp)
je 0x2c61d
movb $0x1, -0x1(%rbp)
jmp 0x2c71c
movl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movl $0x3a, %esi
callq 0x13170
movq %rax, %rsi
movl -0x40(%rbp), %eax
movl $0x28, %ecx
movl $0x3b, %edx
cmpq $0x0, %rsi
cmovnel %edx, %ecx
cmpl %ecx, %eax
je 0x2c655
movb $0x1, -0x1(%rbp)
jmp 0x2c71c
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x2c718
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x2c68c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jle 0x2c6ab
movb $0x1, -0x1(%rbp)
jmp 0x2c71c
movq -0x30(%rbp), %rax
movsbl (%rax), %edi
callq 0x2c750
movb %al, -0x39(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x2c6f5
movq -0x30(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0x2c750
movb %al, -0x3a(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x2c6f5
movsbl -0x39(%rbp), %eax
shll $0x4, %eax
movsbl -0x3a(%rbp), %ecx
addl %ecx, %eax
movsbl %al, %eax
movq -0x38(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x2c6fb
movb $0x1, -0x1(%rbp)
jmp 0x2c71c
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2c65d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_pvio_tls_compare_fp:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
cmp [rbp+var_14], 14h
jz short loc_2C61D
mov [rbp+var_1], 1
jmp loc_2C71C
loc_2C61D:
mov eax, [rbp+var_24]
mov [rbp+var_40], eax
mov rdi, [rbp+var_20]
mov esi, 3Ah ; ':'
call _strchr
mov rsi, rax
mov eax, [rbp+var_40]
mov ecx, 28h ; '('
mov edx, 3Bh ; ';'
cmp rsi, 0
cmovnz ecx, edx
cmp eax, ecx
jz short loc_2C655
mov [rbp+var_1], 1
jmp loc_2C71C
loc_2C655:
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
loc_2C65D:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_10]
mov edx, [rbp+var_14]
add rcx, rdx
cmp rax, rcx
jnb loc_2C718
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 3Ah ; ':'
jnz short loc_2C68C
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
loc_2C68C:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_20]
sub rax, rcx
mov ecx, [rbp+var_24]
sub ecx, 1
movsxd rcx, ecx
cmp rax, rcx
jle short loc_2C6AB
mov [rbp+var_1], 1
jmp short loc_2C71C
loc_2C6AB:
mov rax, [rbp+var_30]
movsx edi, byte ptr [rax]
call ma_hex2int
mov [rbp+var_39], al
movsx eax, al
cmp eax, 0FFFFFFFFh
jz short loc_2C6F5
mov rax, [rbp+var_30]
movsx edi, byte ptr [rax+1]
call ma_hex2int
mov [rbp+var_3A], al
movsx eax, al
cmp eax, 0FFFFFFFFh
jz short loc_2C6F5
movsx eax, [rbp+var_39]
shl eax, 4
movsx ecx, [rbp+var_3A]
add eax, ecx
movsx eax, al
mov rcx, [rbp+var_38]
movsx ecx, byte ptr [rcx]
cmp eax, ecx
jz short loc_2C6FB
loc_2C6F5:
mov [rbp+var_1], 1
jmp short loc_2C71C
loc_2C6FB:
mov rax, [rbp+var_30]
add rax, 2
mov [rbp+var_30], rax
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
jmp loc_2C65D
loc_2C718:
mov [rbp+var_1], 0
loc_2C71C:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char ma_pvio_tls_compare_fp(char *a1, int a2, char *a3, int a4)
{
long long v4; // rsi
int v5; // ecx
char v7; // [rsp+6h] [rbp-3Ah]
char v8; // [rsp+7h] [rbp-39h]
char *i; // [rsp+8h] [rbp-38h]
char *v10; // [rsp+10h] [rbp-30h]
v10 = a3;
if ( a2 != 20 )
return 1;
v4 = strchr(a3, 58LL);
v5 = 40;
if ( v4 )
v5 = 59;
if ( a4 != v5 )
return 1;
for ( i = a1; i < a1 + 20; ++i )
{
if ( *v10 == 58 )
++v10;
if ( v10 - a3 > a4 - 1 )
return 1;
v8 = ma_hex2int((unsigned int)*v10);
if ( v8 == -1 )
return 1;
v7 = ma_hex2int((unsigned int)v10[1]);
if ( v7 == -1 || (char)(v7 + 16 * v8) != *i )
return 1;
v10 += 2;
}
return 0;
}
| ma_pvio_tls_compare_fp:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
CMP dword ptr [RBP + -0x14],0x14
JZ 0x0012c61d
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012c71c
LAB_0012c61d:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x40],EAX
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,0x3a
CALL 0x00113170
MOV RSI,RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV ECX,0x28
MOV EDX,0x3b
CMP RSI,0x0
CMOVNZ ECX,EDX
CMP EAX,ECX
JZ 0x0012c655
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012c71c
LAB_0012c655:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
LAB_0012c65d:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
ADD RCX,RDX
CMP RAX,RCX
JNC 0x0012c718
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x3a
JNZ 0x0012c68c
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
LAB_0012c68c:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV ECX,dword ptr [RBP + -0x24]
SUB ECX,0x1
MOVSXD RCX,ECX
CMP RAX,RCX
JLE 0x0012c6ab
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012c71c
LAB_0012c6ab:
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EDI,byte ptr [RAX]
CALL 0x0012c750
MOV byte ptr [RBP + -0x39],AL
MOVSX EAX,AL
CMP EAX,-0x1
JZ 0x0012c6f5
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EDI,byte ptr [RAX + 0x1]
CALL 0x0012c750
MOV byte ptr [RBP + -0x3a],AL
MOVSX EAX,AL
CMP EAX,-0x1
JZ 0x0012c6f5
MOVSX EAX,byte ptr [RBP + -0x39]
SHL EAX,0x4
MOVSX ECX,byte ptr [RBP + -0x3a]
ADD EAX,ECX
MOVSX EAX,AL
MOV RCX,qword ptr [RBP + -0x38]
MOVSX ECX,byte ptr [RCX]
CMP EAX,ECX
JZ 0x0012c6fb
LAB_0012c6f5:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012c71c
LAB_0012c6fb:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x2
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0012c65d
LAB_0012c718:
MOV byte ptr [RBP + -0x1],0x0
LAB_0012c71c:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1 ma_pvio_tls_compare_fp(char *param_1,int param_2,char *param_3,int param_4)
{
char cVar1;
char cVar2;
char *pcVar3;
int iVar4;
char *local_40;
char *local_38;
int1 local_9;
if (param_2 == 0x14) {
pcVar3 = strchr(param_3,0x3a);
iVar4 = 0x28;
if (pcVar3 != (char *)0x0) {
iVar4 = 0x3b;
}
local_40 = param_1;
local_38 = param_3;
if (param_4 == iVar4) {
for (; local_40 < param_1 + 0x14; local_40 = local_40 + 1) {
if (*local_38 == ':') {
local_38 = local_38 + 1;
}
if ((long)(param_4 + -1) < (long)local_38 - (long)param_3) {
return 1;
}
cVar1 = ma_hex2int((int)*local_38);
if (((cVar1 == -1) || (cVar2 = ma_hex2int((int)local_38[1]), cVar2 == -1)) ||
((char)((char)((int)cVar1 << 4) + cVar2) != *local_40)) {
return 1;
}
local_38 = local_38 + 2;
}
local_9 = 0;
}
else {
local_9 = 1;
}
}
else {
local_9 = 1;
}
return local_9;
}
| |
22,517 | my_thread_init_common_mutex | eloqsql/mysys/my_thr_init.c | static void my_thread_init_common_mutex(void)
{
mysql_mutex_init(key_THR_LOCK_open, &THR_LOCK_open, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_lock, &THR_LOCK_lock, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_myisam, &THR_LOCK_myisam, MY_MUTEX_INIT_SLOW);
mysql_mutex_init(key_THR_LOCK_myisam_mmap, &THR_LOCK_myisam_mmap, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_heap, &THR_LOCK_heap, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_net, &THR_LOCK_net, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_charset, &THR_LOCK_charset, MY_MUTEX_INIT_FAST);
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
mysql_mutex_init(key_LOCK_localtime_r, &LOCK_localtime_r, MY_MUTEX_INIT_SLOW);
#endif
} | O3 | c | my_thread_init_common_mutex:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x34c7c9(%rip), %rax # 0x37b1d0
movl (%rax), %edi
leaq 0x2cb448(%rip), %r15 # 0x2f9e58
movq (%r15), %rax
leaq 0x34d196(%rip), %r14 # 0x37bbb0
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
leaq 0x34d449(%rip), %rbx # 0x37be80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24500
leaq 0x34c773(%rip), %rax # 0x37b1bc
movl (%rax), %edi
movq (%r15), %rax
leaq 0x34d1a3(%rip), %r14 # 0x37bbf8
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24500
leaq 0x34c74b(%rip), %rax # 0x37b1c8
movl (%rax), %edi
movq (%r15), %rax
leaq 0x34d1b7(%rip), %r14 # 0x37bc40
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0x24500
leaq 0x34c72c(%rip), %rax # 0x37b1dc
movl (%rax), %edi
movq (%r15), %rax
leaq 0x34d1cc(%rip), %r14 # 0x37bc88
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24500
leaq 0x34c6d4(%rip), %rax # 0x37b1b8
movl (%rax), %edi
movq (%r15), %rax
leaq 0x34d1e0(%rip), %r14 # 0x37bcd0
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24500
leaq 0x34c6b4(%rip), %rax # 0x37b1cc
movl (%rax), %edi
movq (%r15), %rax
leaq 0x34d1f4(%rip), %r14 # 0x37bd18
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24500
leaq 0x34c668(%rip), %rax # 0x37b1b4
movl (%rax), %edi
movq (%r15), %rax
leaq 0x34d208(%rip), %r14 # 0x37bd60
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, 0x40(%r14)
movq %r14, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x24500
| my_thread_init_common_mutex:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
lea rax, key_THR_LOCK_open
mov edi, [rax]
lea r15, PSI_server
mov rax, [r15]
lea r14, THR_LOCK_open
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
lea rbx, my_fast_mutexattr
mov rdi, r14
mov rsi, rbx
call _pthread_mutex_init
lea rax, key_THR_LOCK_lock
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_lock
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
mov rsi, rbx
call _pthread_mutex_init
lea rax, key_THR_LOCK_myisam
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_myisam
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
xor esi, esi
call _pthread_mutex_init
lea rax, key_THR_LOCK_myisam_mmap
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_myisam_mmap
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
mov rsi, rbx
call _pthread_mutex_init
lea rax, key_THR_LOCK_heap
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_heap
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
mov rsi, rbx
call _pthread_mutex_init
lea rax, key_THR_LOCK_net
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_net
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
mov rsi, rbx
call _pthread_mutex_init
lea rax, key_THR_LOCK_charset
mov edi, [rax]
mov rax, [r15]
lea r14, THR_LOCK_charset
mov rsi, r14
call qword ptr [rax+40h]
mov [r14+40h], rax
mov [r14+38h], r14
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
mov rdi, r14
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _pthread_mutex_init
| long long my_thread_init_common_mutex()
{
THR_LOCK_open[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server + 8))(key_THR_LOCK_open, THR_LOCK_open);
THR_LOCK_open[7] = THR_LOCK_open;
*(_OWORD *)&THR_LOCK_open[5] = 0LL;
pthread_mutex_init(THR_LOCK_open, &my_fast_mutexattr);
THR_LOCK_lock[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server + 8))(key_THR_LOCK_lock, THR_LOCK_lock);
THR_LOCK_lock[7] = THR_LOCK_lock;
*(_OWORD *)&THR_LOCK_lock[5] = 0LL;
pthread_mutex_init(THR_LOCK_lock, &my_fast_mutexattr);
THR_LOCK_myisam[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server + 8))(
key_THR_LOCK_myisam,
THR_LOCK_myisam);
THR_LOCK_myisam[7] = THR_LOCK_myisam;
*(_OWORD *)&THR_LOCK_myisam[5] = 0LL;
pthread_mutex_init(THR_LOCK_myisam, 0LL);
THR_LOCK_myisam_mmap[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server + 8))(
key_THR_LOCK_myisam_mmap,
THR_LOCK_myisam_mmap);
THR_LOCK_myisam_mmap[7] = THR_LOCK_myisam_mmap;
*(_OWORD *)&THR_LOCK_myisam_mmap[5] = 0LL;
pthread_mutex_init(THR_LOCK_myisam_mmap, &my_fast_mutexattr);
THR_LOCK_heap[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server + 8))(key_THR_LOCK_heap, THR_LOCK_heap);
THR_LOCK_heap[7] = THR_LOCK_heap;
*(_OWORD *)&THR_LOCK_heap[5] = 0LL;
pthread_mutex_init(THR_LOCK_heap, &my_fast_mutexattr);
THR_LOCK_net[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server + 8))(key_THR_LOCK_net, THR_LOCK_net);
THR_LOCK_net[7] = THR_LOCK_net;
*(_OWORD *)&THR_LOCK_net[5] = 0LL;
pthread_mutex_init(THR_LOCK_net, &my_fast_mutexattr);
THR_LOCK_charset[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server + 8))(
key_THR_LOCK_charset,
THR_LOCK_charset);
THR_LOCK_charset[7] = THR_LOCK_charset;
*(_OWORD *)&THR_LOCK_charset[5] = 0LL;
return pthread_mutex_init(THR_LOCK_charset, &my_fast_mutexattr);
}
| my_thread_init_common_mutex:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
LEA RAX,[0x47b1d0]
MOV EDI,dword ptr [RAX]
LEA R15,[0x3f9e58]
MOV RAX,qword ptr [R15]
LEA R14,[0x47bbb0]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
LEA RBX,[0x47be80]
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124500
LEA RAX,[0x47b1bc]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x47bbf8]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124500
LEA RAX,[0x47b1c8]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x47bc40]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00124500
LEA RAX,[0x47b1dc]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x47bc88]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124500
LEA RAX,[0x47b1b8]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x47bcd0]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124500
LEA RAX,[0x47b1cc]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x47bd18]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124500
LEA RAX,[0x47b1b4]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [R15]
LEA R14,[0x47bd60]
MOV RSI,R14
CALL qword ptr [RAX + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV qword ptr [R14 + 0x38],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00124500
|
void my_thread_init_common_mutex(void)
{
THR_LOCK_open._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_open,THR_LOCK_open);
THR_LOCK_open._56_8_ = THR_LOCK_open;
THR_LOCK_open._40_8_ = 0;
THR_LOCK_open._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_open,(pthread_mutexattr_t *)&my_fast_mutexattr);
THR_LOCK_lock._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_lock,THR_LOCK_lock);
THR_LOCK_lock._56_8_ = THR_LOCK_lock;
THR_LOCK_lock._40_8_ = 0;
THR_LOCK_lock._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_lock,(pthread_mutexattr_t *)&my_fast_mutexattr);
THR_LOCK_myisam._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_myisam);
THR_LOCK_myisam._56_8_ = THR_LOCK_myisam;
THR_LOCK_myisam._40_8_ = 0;
THR_LOCK_myisam._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_myisam,(pthread_mutexattr_t *)0x0);
THR_LOCK_myisam_mmap._64_8_ =
(**(code **)(PSI_server + 0x40))(key_THR_LOCK_myisam_mmap,THR_LOCK_myisam_mmap);
THR_LOCK_myisam_mmap._56_8_ = THR_LOCK_myisam_mmap;
THR_LOCK_myisam_mmap._40_8_ = 0;
THR_LOCK_myisam_mmap._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_myisam_mmap,
(pthread_mutexattr_t *)&my_fast_mutexattr);
THR_LOCK_heap._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_heap,THR_LOCK_heap);
THR_LOCK_heap._56_8_ = THR_LOCK_heap;
THR_LOCK_heap._40_8_ = 0;
THR_LOCK_heap._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_heap,(pthread_mutexattr_t *)&my_fast_mutexattr);
THR_LOCK_net._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_net,THR_LOCK_net);
THR_LOCK_net._56_8_ = THR_LOCK_net;
THR_LOCK_net._40_8_ = 0;
THR_LOCK_net._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_net,(pthread_mutexattr_t *)&my_fast_mutexattr);
THR_LOCK_charset._64_8_ = (**(code **)(PSI_server + 0x40))(key_THR_LOCK_charset,THR_LOCK_charset);
THR_LOCK_charset._56_8_ = THR_LOCK_charset;
THR_LOCK_charset._40_8_ = 0;
THR_LOCK_charset._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)THR_LOCK_charset,(pthread_mutexattr_t *)&my_fast_mutexattr);
return;
}
| |
22,518 | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("UnaryOpExpr.expr is null");
auto e = expr->evaluate(context);
switch (op) {
case Op::Plus: return e;
case Op::Minus: return -e;
case Op::LogicalNot: return !e.to_bool();
case Op::Expansion:
case Op::ExpansionDict:
throw std::runtime_error("Expansion operator is only supported in function calls and collections");
}
throw std::runtime_error("Unknown unary operator");
} | O3 | cpp | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x3cc0a
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3cd66
movl 0x30(%r14), %eax
cmpq $0x4, %rax
ja 0x3cc5a
leaq 0x6aadd(%rip), %rcx # 0xa75a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x48(%rsp), %r15
movups -0x30(%r15), %xmm0
xorl %r12d, %r12d
movq %r12, -0x28(%r15)
movups %xmm0, 0x10(%rbx)
movq %r12, -0x30(%r15)
movups -0x20(%r15), %xmm0
movq %r12, -0x18(%r15)
movups %xmm0, 0x20(%rbx)
movq %r12, -0x20(%r15)
movups -0x10(%r15), %xmm0
movq %r12, -0x8(%r15)
movups %xmm0, 0x30(%rbx)
movq %r12, -0x10(%r15)
leaq 0x40(%rbx), %r14
movups (%r15), %xmm0
movups %xmm0, 0x40(%rbx)
movq %r15, %rdi
xorl %esi, %esi
callq 0x3d0e4
movb $0x0, (%r15)
movq %r12, 0x8(%r15)
jmp 0x3cb66
leaq 0x8(%rsp), %rdi
callq 0x3cf64
xorb $0x1, %al
leaq 0x40(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movzbl %al, %esi
movq %r14, %rdi
callq 0x3f196
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d0e4
jmp 0x3cb82
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3cee0
leaq 0x48(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3d0e4
movq %r14, %rdi
callq 0x49cd2
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3cba7
callq 0x2f20e
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3cbb6
callq 0x2f20e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3cbc5
callq 0x2f20e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3cbfb
movq 0x9f3c2(%rip), %rax # 0xdbf98
cmpb $0x0, (%rax)
je 0x3cbe6
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x3cbf0
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x3cbfb
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x18350
movq %rax, %r14
leaq 0x6ca62(%rip), %rsi # 0xa9680
movq %rax, %rdi
callq 0x18260
movq 0x9f3c3(%rip), %rsi # 0xdbff0
movq 0x9f33c(%rip), %rdx # 0xdbf70
movq %r14, %rdi
callq 0x18b30
movl $0x10, %edi
callq 0x18350
movq %rax, %r14
leaq 0x6ca49(%rip), %rsi # 0xa9699
movq %rax, %rdi
callq 0x18260
jmp 0x3cc76
movl $0x10, %edi
callq 0x18350
movq %rax, %r14
leaq 0x6ca72(%rip), %rsi # 0xa96e0
movq %rax, %rdi
callq 0x18260
movq 0x9f373(%rip), %rsi # 0xdbff0
movq 0x9f2ec(%rip), %rdx # 0xdbf70
movq %r14, %rdi
callq 0x18b30
jmp 0x3cc90
jmp 0x3ccaa
movq %rax, %rbx
movq %r14, %rdi
callq 0x184f0
jmp 0x3ccad
movq %rax, %rbx
movq %r14, %rdi
callq 0x184f0
jmp 0x3ccb7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3d058
movq %rbx, %rdi
callq 0x18bb0
nop
| _ZNK5minja11UnaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
sub rsp, 58h
mov r14, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz loc_3CC0A
mov rbx, rdi
lea rdi, [rsp+78h+var_70]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov eax, [r14+30h]
cmp rax, 4; switch 5 cases
ja def_3CAD2; jumptable 000000000003CAD2 default case
lea rcx, jpt_3CAD2
movsxd rax, ds:(jpt_3CAD2 - 0A75A8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_3CAD4:
xorps xmm0, xmm0; jumptable 000000000003CAD2 case 0
movups xmmword ptr [rbx], xmm0
lea r15, [rsp+78h+var_30]
movups xmm0, xmmword ptr [r15-30h]
xor r12d, r12d
mov [r15-28h], r12
movups xmmword ptr [rbx+10h], xmm0
mov [r15-30h], r12
movups xmm0, xmmword ptr [r15-20h]
mov [r15-18h], r12
movups xmmword ptr [rbx+20h], xmm0
mov [r15-20h], r12
movups xmm0, xmmword ptr [r15-10h]
mov [r15-8], r12
movups xmmword ptr [rbx+30h], xmm0
mov [r15-10h], r12
lea r14, [rbx+40h]
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rbx+40h], xmm0
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r15], 0
mov [r15+8], r12
jmp short loc_3CB66
loc_3CB35:
lea rdi, [rsp+78h+var_70]; jumptable 000000000003CAD2 case 2
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
xor al, 1
lea r14, [rbx+40h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+40h], xmm0
movups xmmword ptr [rbx+30h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
movzx esi, al
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE4EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::boolean_t)
loc_3CB66:
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_3CB82
loc_3CB75:
lea rsi, [rsp+78h+var_70]; jumptable 000000000003CAD2 case 1
mov rdi, rbx
call _ZNK5minja5ValuengEv; minja::Value::operator-(void)
loc_3CB82:
lea r14, [rsp+78h+var_30]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_3CBA7
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_3CBA7:
mov rdi, [rsp+78h+var_48]
test rdi, rdi
jz short loc_3CBB6
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_3CBB6:
mov rdi, [rsp+78h+var_58]
test rdi, rdi
jz short loc_3CBC5
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_3CBC5:
mov rdi, [rsp+78h+var_68]
test rdi, rdi
jz short loc_3CBFB
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_3CBE6
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_3CBF0
loc_3CBE6:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_3CBF0:
cmp eax, 1
jnz short loc_3CBFB
mov rax, [rdi]
call qword ptr [rax+18h]
loc_3CBFB:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
loc_3CC0A:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnaryopexprExp; "UnaryOpExpr.expr is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_3CC3C:
mov edi, 10h; jumptable 000000000003CAD2 cases 3,4
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpansionOpera; "Expansion operator is only supported in"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_3CC76
def_3CAD2:
mov edi, 10h; jumptable 000000000003CAD2 default case
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnknownUnaryOp; "Unknown unary operator"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_3CC76:
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_3CC90
jmp short loc_3CCAA
loc_3CC90:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_3CCAD
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_3CCB7
loc_3CCAA:
mov rbx, rax
loc_3CCAD:
lea rdi, [rsp+78h+var_70]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_3CCB7:
mov rdi, rbx
call __Unwind_Resume
| do_evaluate:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x0013cc0a
MOV RBX,RDI
LEA RDI,[RSP + 0x8]
CALL 0x0013cd66
MOV EAX,dword ptr [R14 + 0x30]
CMP RAX,0x4
JA 0x0013cc5a
LEA RCX,[0x1a75a8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LEA R15,[RSP + 0x48]
MOVUPS XMM0,xmmword ptr [R15 + -0x30]
XOR R12D,R12D
MOV qword ptr [R15 + -0x28],R12
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOV qword ptr [R15 + -0x30],R12
MOVUPS XMM0,xmmword ptr [R15 + -0x20]
MOV qword ptr [R15 + -0x18],R12
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOV qword ptr [R15 + -0x20],R12
MOVUPS XMM0,xmmword ptr [R15 + -0x10]
MOV qword ptr [R15 + -0x8],R12
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV qword ptr [R15 + -0x10],R12
LEA R14,[RBX + 0x40]
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013d0e4
MOV byte ptr [R15],0x0
MOV qword ptr [R15 + 0x8],R12
JMP 0x0013cb66
caseD_2:
LEA RDI,[RSP + 0x8]
CALL 0x0013cf64
XOR AL,0x1
LEA R14,[RBX + 0x40]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVZX ESI,AL
MOV RDI,R14
CALL 0x0013f196
LAB_0013cb66:
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d0e4
JMP 0x0013cb82
caseD_1:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0013cee0
LAB_0013cb82:
LEA R14,[RSP + 0x48]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013d0e4
MOV RDI,R14
CALL 0x00149cd2
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x0013cba7
CALL 0x0012f20e
LAB_0013cba7:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0013cbb6
CALL 0x0012f20e
LAB_0013cbb6:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x0013cbc5
CALL 0x0012f20e
LAB_0013cbc5:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0013cbfb
MOV RAX,qword ptr [0x001dbf98]
CMP byte ptr [RAX],0x0
JZ 0x0013cbe6
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0013cbf0
LAB_0013cbe6:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0013cbf0:
CMP EAX,0x1
JNZ 0x0013cbfb
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0013cbfb:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0013cc0a:
MOV EDI,0x10
CALL 0x00118350
MOV R14,RAX
LAB_0013cc17:
LEA RSI,[0x1a9680]
MOV RDI,RAX
CALL 0x00118260
LAB_0013cc26:
MOV RSI,qword ptr [0x001dbff0]
MOV RDX,qword ptr [0x001dbf70]
MOV RDI,R14
CALL 0x00118b30
caseD_3:
MOV EDI,0x10
CALL 0x00118350
MOV R14,RAX
LAB_0013cc49:
LEA RSI,[0x1a9699]
MOV RDI,RAX
CALL 0x00118260
LAB_0013cc58:
JMP 0x0013cc76
default:
MOV EDI,0x10
CALL 0x00118350
MOV R14,RAX
LAB_0013cc67:
LEA RSI,[0x1a96e0]
MOV RDI,RAX
CALL 0x00118260
LAB_0013cc76:
MOV RSI,qword ptr [0x001dbff0]
MOV RDX,qword ptr [0x001dbf70]
MOV RDI,R14
CALL 0x00118b30
|
/* minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
UnaryOpExpr * __thiscall minja::UnaryOpExpr::do_evaluate(UnaryOpExpr *this,shared_ptr *param_1)
{
int *piVar1;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var2;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var3;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var4;
byte bVar5;
int iVar6;
runtime_error *prVar7;
Expression local_70 [8];
long *local_68;
int8 local_60;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_58;
int8 local_50;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_48;
int8 local_40;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_38;
data local_30;
int7 uStack_2f;
int8 uStack_28;
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013cc17 to 0013cc25 has its CatchHandler @ 0013cc9d */
std::runtime_error::runtime_error(prVar7,"UnaryOpExpr.expr is null");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_001dbff0,PTR__runtime_error_001dbf70);
}
Expression::evaluate(local_70,*(shared_ptr **)(param_1 + 0x20));
p_Var4 = p_Stack_38;
p_Var3 = p_Stack_48;
p_Var2 = p_Stack_58;
switch(*(int4 *)(param_1 + 0x30)) {
case 0:
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
p_Stack_58 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
*(int8 *)(this + 0x10) = local_60;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) = p_Var2;
local_60 = 0;
p_Stack_48 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
*(int8 *)(this + 0x20) = local_50;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28) = p_Var3;
local_50 = 0;
p_Stack_38 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
*(int8 *)(this + 0x30) = local_40;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) = p_Var4;
local_40 = 0;
*(ulong *)(this + 0x40) = CONCAT71(uStack_2f,local_30);
*(int8 *)(this + 0x48) = uStack_28;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_30,0));
local_30 = (data)0x0;
uStack_28 = 0;
break;
case 1:
/* try { // try from 0013cb75 to 0013cb81 has its CatchHandler @ 0013ccaa */
Value::operator-((Value *)this);
goto LAB_0013cb82;
case 2:
/* try { // try from 0013cb35 to 0013cb3e has its CatchHandler @ 0013cc8e */
bVar5 = Value::to_bool((Value *)local_70);
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(this + 0x40,bVar5 ^ 1);
break;
case 3:
case 4:
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013cc49 to 0013cc57 has its CatchHandler @ 0013cc90 */
std::runtime_error::runtime_error
(prVar7,"Expansion operator is only supported in function calls and collections");
goto LAB_0013cc76;
default:
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013cc67 to 0013cc75 has its CatchHandler @ 0013cc8c */
std::runtime_error::runtime_error(prVar7,"Unknown unary operator");
LAB_0013cc76:
/* try { // try from 0013cc76 to 0013cc8b has its CatchHandler @ 0013ccaa */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_001dbff0,PTR__runtime_error_001dbf70);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)this + '@'));
LAB_0013cb82:
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_30,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(&local_30);
if (p_Stack_38 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_38);
}
if (p_Stack_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_48);
}
if (p_Stack_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_58);
}
if (local_68 != (long *)0x0) {
if (*PTR___libc_single_threaded_001dbf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_68 + 0xc);
iVar6 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar6 = *(int *)((long)local_68 + 0xc);
*(int *)((long)local_68 + 0xc) = iVar6 + -1;
}
if (iVar6 == 1) {
(**(code **)(*local_68 + 0x18))();
}
}
return this;
}
| ||
22,519 | ttt::game::FieldBitmap::get(int, int) const | vsennov[P]tictactoe-course/src/core/state.cpp | Sign FieldBitmap::get(int x, int y) const {
if (!is_valid(x, y))
return Sign::NONE;
const int bit_no = (x + y * m_cols) * 2;
const int byte_no = bit_no / 8;
const char value = (m_bitmap[byte_no] >> (bit_no % 8)) & 0b11;
switch (value) {
case 1:
return Sign::X;
case 2:
return Sign::O;
default:
return Sign::NONE;
}
} | O0 | cpp | ttt::game::FieldBitmap::get(int, int) const:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3b40
testb $0x1, %al
jne 0x3aa5
movl $0x2, -0x4(%rbp)
jmp 0x3b29
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %edx
movl 0xc(%rax), %esi
imull %esi, %edx
addl %edx, %ecx
addl %ecx, %ecx
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x7, %edx
testl %ecx, %ecx
cmovsl %edx, %ecx
sarl $0x3, %ecx
movl %ecx, -0x20(%rbp)
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x7, %esi
testl %ecx, %ecx
movl %ecx, %edx
cmovsl %esi, %edx
andl $0xf8, %edx
subl %edx, %ecx
sarl %cl, %eax
andb $0x3, %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x3b10
jmp 0x3b06
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x3b19
jmp 0x3b22
movl $0x0, -0x4(%rbp)
jmp 0x3b29
movl $0x1, -0x4(%rbp)
jmp 0x3b29
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZNK3ttt4game11FieldBitmap3getEii:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov rdi, [rbp+var_10]; this
mov [rbp+var_30], rdi
mov esi, [rbp+var_14]; int
mov edx, [rbp+var_18]; int
call _ZNK3ttt4game11FieldBitmap8is_validEii; ttt::game::FieldBitmap::is_valid(int,int)
test al, 1
jnz short loc_3AA5
mov [rbp+var_4], 2
jmp loc_3B29
loc_3AA5:
mov rax, [rbp+var_30]
mov ecx, [rbp+var_14]
mov edx, [rbp+var_18]
mov esi, [rax+0Ch]
imul edx, esi
add ecx, edx
add ecx, ecx
mov [rbp+var_1C], ecx
mov ecx, [rbp+var_1C]
mov edx, ecx
add edx, 7
test ecx, ecx
cmovs ecx, edx
sar ecx, 3
mov [rbp+var_20], ecx
mov rax, [rax]
movsxd rcx, [rbp+var_20]
movsx eax, byte ptr [rax+rcx]
mov ecx, [rbp+var_1C]
mov esi, ecx
add esi, 7
test ecx, ecx
mov edx, ecx
cmovs edx, esi
and edx, 0F8h
sub ecx, edx
sar eax, cl
and al, 3
mov [rbp+var_21], al
movsx eax, [rbp+var_21]
mov [rbp+var_34], eax
sub eax, 1
jz short loc_3B10
jmp short $+2
loc_3B06:
mov eax, [rbp+var_34]
sub eax, 2
jz short loc_3B19
jmp short loc_3B22
loc_3B10:
mov [rbp+var_4], 0
jmp short loc_3B29
loc_3B19:
mov [rbp+var_4], 1
jmp short loc_3B29
loc_3B22:
mov [rbp+var_4], 2
loc_3B29:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long ttt::game::FieldBitmap::get(ttt::game::FieldBitmap *this, int a2, int a3)
{
int v3; // esi
int v4; // ecx
char v5; // dl
int v7; // [rsp+Ch] [rbp-34h]
char v8; // [rsp+24h] [rbp-1Ch]
if ( (ttt::game::FieldBitmap::is_valid(this, a2, a3) & 1) != 0 )
{
v3 = *((_DWORD *)this + 3);
v8 = 2 * (v3 * a3 + a2);
v4 = 2 * (v3 * a3 + a2);
if ( ((v3 * a3 + a2) & 0x40000000) != 0 )
v4 = 2 * (v3 * a3 + a2) + 7;
v5 = 2 * (v3 * a3 + a2);
if ( ((v3 * a3 + a2) & 0x40000000) != 0 )
v5 = v8 + 7;
v7 = (*(char *)(*(_QWORD *)this + (v4 >> 3)) >> (v8 - (v5 & 0xF8))) & 3;
if ( v7 == 1 )
{
return 0;
}
else if ( v7 == 2 )
{
return 1;
}
else
{
return 2;
}
}
else
{
return 2;
}
}
| get:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RDI
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x18]
CALL 0x00103b40
TEST AL,0x1
JNZ 0x00103aa5
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00103b29
LAB_00103aa5:
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x18]
MOV ESI,dword ptr [RAX + 0xc]
IMUL EDX,ESI
ADD ECX,EDX
ADD ECX,ECX
MOV dword ptr [RBP + -0x1c],ECX
MOV ECX,dword ptr [RBP + -0x1c]
MOV EDX,ECX
ADD EDX,0x7
TEST ECX,ECX
CMOVS ECX,EDX
SAR ECX,0x3
MOV dword ptr [RBP + -0x20],ECX
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
MOV ECX,dword ptr [RBP + -0x1c]
MOV ESI,ECX
ADD ESI,0x7
TEST ECX,ECX
MOV EDX,ECX
CMOVS EDX,ESI
AND EDX,0xf8
SUB ECX,EDX
SAR EAX,CL
AND AL,0x3
MOV byte ptr [RBP + -0x21],AL
MOVSX EAX,byte ptr [RBP + -0x21]
MOV dword ptr [RBP + -0x34],EAX
SUB EAX,0x1
JZ 0x00103b10
JMP 0x00103b06
LAB_00103b06:
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x2
JZ 0x00103b19
JMP 0x00103b22
LAB_00103b10:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00103b29
LAB_00103b19:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00103b29
LAB_00103b22:
MOV dword ptr [RBP + -0x4],0x2
LAB_00103b29:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
/* ttt::game::FieldBitmap::get(int, int) const */
int4 __thiscall ttt::game::FieldBitmap::get(FieldBitmap *this,int param_1,int param_2)
{
int iVar1;
byte bVar2;
ulong uVar3;
int iVar4;
int iVar5;
int4 local_c;
uVar3 = is_valid(this,param_1,param_2);
if ((uVar3 & 1) == 0) {
local_c = 2;
}
else {
iVar1 = (param_1 + param_2 * *(int *)(this + 0xc)) * 2;
iVar4 = iVar1;
if (iVar1 < 0) {
iVar4 = iVar1 + 7;
}
iVar5 = iVar1;
if (iVar1 < 0) {
iVar5 = iVar1 + 7;
}
bVar2 = (byte)((int)*(char *)(*(long *)this + (long)(iVar4 >> 3)) >>
((char)iVar1 - ((byte)iVar5 & 0xf8) & 0x1f)) & 3;
if (bVar2 == 1) {
local_c = 0;
}
else if (bVar2 == 2) {
local_c = 1;
}
else {
local_c = 2;
}
}
return local_c;
}
| |
22,520 | ttt::game::FieldBitmap::get(int, int) const | vsennov[P]tictactoe-course/src/core/state.cpp | Sign FieldBitmap::get(int x, int y) const {
if (!is_valid(x, y))
return Sign::NONE;
const int bit_no = (x + y * m_cols) * 2;
const int byte_no = bit_no / 8;
const char value = (m_bitmap[byte_no] >> (bit_no % 8)) & 0b11;
switch (value) {
case 1:
return Sign::X;
case 2:
return Sign::O;
default:
return Sign::NONE;
}
} | O2 | cpp | ttt::game::FieldBitmap::get(int, int) const:
pushq $0x2
popq %rax
testl %esi, %esi
js 0x1e40
testl %edx, %edx
js 0x1e40
movl 0xc(%rdi), %r8d
cmpl %esi, %r8d
jle 0x1e40
cmpl %edx, 0x8(%rdi)
jle 0x1e40
imull %edx, %r8d
addl %esi, %r8d
leal (%r8,%r8), %ecx
shrl $0x2, %r8d
movq (%rdi), %rax
movsbl (%rax,%r8), %edx
andb $0x6, %cl
sarl %cl, %edx
andl $0x3, %edx
xorl %ecx, %ecx
cmpl $0x2, %edx
setne %cl
incl %ecx
xorl %eax, %eax
cmpl $0x1, %edx
cmovnel %ecx, %eax
retq
nop
| _ZNK3ttt4game11FieldBitmap3getEii:
push 2
pop rax
test esi, esi
js short locret_1E40
test edx, edx
js short locret_1E40
mov r8d, [rdi+0Ch]
cmp r8d, esi
jle short locret_1E40
cmp [rdi+8], edx
jle short locret_1E40
imul r8d, edx
add r8d, esi
lea ecx, [r8+r8]
shr r8d, 2
mov rax, [rdi]
movsx edx, byte ptr [rax+r8]
and cl, 6
sar edx, cl
and edx, 3
xor ecx, ecx
cmp edx, 2
setnz cl
inc ecx
xor eax, eax
cmp edx, 1
cmovnz eax, ecx
locret_1E40:
retn
| long long ttt::game::FieldBitmap::get(ttt::game::FieldBitmap *this, int a2, int a3)
{
long long result; // rax
int v4; // r8d
int v5; // edx
result = 2LL;
if ( a2 >= 0 && a3 >= 0 )
{
v4 = *((_DWORD *)this + 3);
if ( v4 > a2 && *((_DWORD *)this + 2) > a3 )
{
v5 = (*(char *)(*(_QWORD *)this + ((unsigned int)(a2 + a3 * v4) >> 2)) >> ((2 * (a2 + a3 * v4)) & 6)) & 3;
result = 0LL;
if ( v5 != 1 )
return (unsigned int)(v5 != 2) + 1;
}
}
return result;
}
| get:
PUSH 0x2
POP RAX
TEST ESI,ESI
JS 0x00101e40
TEST EDX,EDX
JS 0x00101e40
MOV R8D,dword ptr [RDI + 0xc]
CMP R8D,ESI
JLE 0x00101e40
CMP dword ptr [RDI + 0x8],EDX
JLE 0x00101e40
IMUL R8D,EDX
ADD R8D,ESI
LEA ECX,[R8 + R8*0x1]
SHR R8D,0x2
MOV RAX,qword ptr [RDI]
MOVSX EDX,byte ptr [RAX + R8*0x1]
AND CL,0x6
SAR EDX,CL
AND EDX,0x3
XOR ECX,ECX
CMP EDX,0x2
SETNZ CL
INC ECX
XOR EAX,EAX
CMP EDX,0x1
CMOVNZ EAX,ECX
LAB_00101e40:
RET
|
/* ttt::game::FieldBitmap::get(int, int) const */
char __thiscall ttt::game::FieldBitmap::get(FieldBitmap *this,int param_1,int param_2)
{
char cVar1;
uint uVar2;
cVar1 = '\x02';
if ((((-1 < param_1) && (-1 < param_2)) && (param_1 < *(int *)(this + 0xc))) &&
(param_2 < *(int *)(this + 8))) {
uVar2 = *(int *)(this + 0xc) * param_2 + param_1;
uVar2 = (int)*(char *)(*(long *)this + (ulong)(uVar2 >> 2)) >> ((char)uVar2 * '\x02' & 6U) & 3;
cVar1 = '\0';
if (uVar2 != 1) {
cVar1 = (uVar2 != 2) + '\x01';
}
}
return cVar1;
}
| |
22,521 | js_array_isArray | bluesky950520[P]quickjs/quickjs.c | static JSValue js_array_isArray(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int ret;
ret = JS_IsArray(ctx, argv[0]);
if (ret < 0)
return JS_EXCEPTION;
else
return js_bool(ret);
} | O1 | c | js_array_isArray:
pushq %rax
movq (%r8), %rsi
movq 0x8(%r8), %rdx
callq 0x276be
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
shrl $0x1f, %eax
leaq (%rax,%rax,4), %rdx
incq %rdx
movq %rcx, %rax
popq %rcx
retq
| js_array_isArray:
push rax
mov rsi, [r8]
mov rdx, [r8+8]
call JS_IsArray
xor ecx, ecx
test eax, eax
setnle cl
shr eax, 1Fh
lea rdx, [rax+rax*4]
inc rdx
mov rax, rcx
pop rcx
retn
| _BOOL8 js_array_isArray(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
return (int)JS_IsArray(a1, *a5, a5[1]) > 0;
}
| js_array_isArray:
PUSH RAX
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CALL 0x001276be
XOR ECX,ECX
TEST EAX,EAX
SETG CL
SHR EAX,0x1f
LEA RDX,[RAX + RAX*0x4]
INC RDX
MOV RAX,RCX
POP RCX
RET
|
bool js_array_isArray(int8 param_1)
{
int iVar1;
int8 *in_R8;
iVar1 = JS_IsArray(param_1,*in_R8,in_R8[1]);
return 0 < iVar1;
}
| |
22,522 | js_array_isArray | bluesky950520[P]quickjs/quickjs.c | static JSValue js_array_isArray(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int ret;
ret = JS_IsArray(ctx, argv[0]);
if (ret < 0)
return JS_EXCEPTION;
else
return js_bool(ret);
} | O3 | c | js_array_isArray:
movq 0x8(%r8), %rdx
xorl %eax, %eax
cmpl $-0x1, %edx
jne 0x7a52e
movq (%r8), %rsi
movzwl 0x6(%rsi), %ecx
cmpw $0x30, %cx
je 0x7a53e
xorl %eax, %eax
cmpw $0x2, %cx
sete %al
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl $0x1, %edx
movq %rcx, %rax
retq
pushq %rax
callq 0x27d0d
testl %eax, %eax
leaq 0x8(%rsp), %rsp
jns 0x7a52e
movl $0x6, %edx
xorl %ecx, %ecx
jmp 0x7a53a
| js_array_isArray:
mov rdx, [r8+8]
xor eax, eax
cmp edx, 0FFFFFFFFh
jnz short loc_7A52E
mov rsi, [r8]
movzx ecx, word ptr [rsi+6]
cmp cx, 30h ; '0'
jz short loc_7A53E
xor eax, eax
cmp cx, 2
setz al
loc_7A52E:
xor ecx, ecx
test eax, eax
setnz cl
mov edx, 1
loc_7A53A:
mov rax, rcx
retn
loc_7A53E:
push rax
call js_proxy_isArray
test eax, eax
lea rsp, [rsp+8]
jns short loc_7A52E
mov edx, 6
xor ecx, ecx
jmp short loc_7A53A
| _BOOL8 js_array_isArray(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long *a13,
long long a14)
{
long long v14; // rdx
int isArray; // eax
long long v16; // rcx
v14 = a13[1];
isArray = 0;
if ( (_DWORD)v14 == -1 )
{
v16 = *(unsigned __int16 *)(*a13 + 6);
if ( (_WORD)v16 == 48 )
{
isArray = js_proxy_isArray(a1, *a13, v14, a2, a3, a4, a5, a6, a7, a8, a9, v16, (long long)a13, a14);
if ( isArray < 0 )
return 0LL;
}
else
{
isArray = (_WORD)v16 == 2;
}
}
return isArray != 0;
}
| js_array_isArray:
MOV RDX,qword ptr [R8 + 0x8]
XOR EAX,EAX
CMP EDX,-0x1
JNZ 0x0017a52e
MOV RSI,qword ptr [R8]
MOVZX ECX,word ptr [RSI + 0x6]
CMP CX,0x30
JZ 0x0017a53e
XOR EAX,EAX
CMP CX,0x2
SETZ AL
LAB_0017a52e:
XOR ECX,ECX
TEST EAX,EAX
SETNZ CL
MOV EDX,0x1
LAB_0017a53a:
MOV RAX,RCX
RET
LAB_0017a53e:
PUSH RAX
CALL 0x00127d0d
TEST EAX,EAX
LEA RSP,[RSP + 0x8]
JNS 0x0017a52e
MOV EDX,0x6
XOR ECX,ECX
JMP 0x0017a53a
|
bool js_array_isArray(void)
{
uint uVar1;
long *in_R8;
uVar1 = 0;
if ((int)in_R8[1] == -1) {
if (*(short *)(*in_R8 + 6) == 0x30) {
uVar1 = js_proxy_isArray();
if ((int)uVar1 < 0) {
return false;
}
}
else {
uVar1 = (uint)(*(short *)(*in_R8 + 6) == 2);
}
}
return uVar1 != 0;
}
| |
22,523 | my_mb_wc_eucjpms | eloqsql/strings/ctype-eucjpms.c | static int
my_mb_wc_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII code set: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
if (hi >= 0xA1 && hi <= 0xFE) /* JIS X 0208 code set: [A1..FE][A1..FE] */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
return (*pwc= jisx0208_eucjpms_to_unicode[(hi << 8) + s[1]]) ? 2 :
(s[1] < 0xA1 || s[1] > 0xFE) ? MY_CS_ILSEQ : -2;
}
/* JIS-X-0201 HALF WIDTH KATAKANA: [8E][A1..DF] -> [U+FF61..U+FF9F] */
if (hi == 0x8E)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if (s[1] < 0xA1 || s[1] > 0xDF)
return MY_CS_ILSEQ;
*pwc= 0xFEC0 + s[1]; /* 0xFFC0 = 0xFF61 - 0xA1 */
return 2;
}
if (hi == 0x8F) /* JIS X 0212 code set: [8F][A1..FE][A1..FE] */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
return (*pwc= jisx0212_eucjpms_to_unicode[(((int) s[1]) << 8) + s[2]]) ?
3 :
(s[1] < 0xA1 || s[1] > 0xFE || s[2] < 0xA1 || s[2] > 0xFE) ?
MY_CS_ILSEQ : -3;
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_eucjpms:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x365be
movzbl (%rdx), %edi
testb %dil, %dil
js 0x365c0
movq %rdi, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leal 0x5f(%rdi), %eax
cmpb $0x5d, %al
ja 0x3660c
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x365be
movzbl 0x1(%rdx), %eax
shll $0x9, %edi
leal (%rdi,%rax,2), %eax
leaq 0xa7f0a(%rip), %rcx # 0xde4f0
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0x365be
movb 0x1(%rdx), %al
incb %al
xorl %ecx, %ecx
cmpb $-0x5e, %al
setb %cl
leal -0x2(,%rcx,2), %eax
jmp 0x365be
cmpq $0x8f, %rdi
je 0x36650
cmpl $0x8e, %edi
jne 0x36692
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x365be
movzbl 0x1(%rdx), %ecx
leal 0x20(%rcx), %edx
movl $0x0, %eax
cmpb $-0x3f, %dl
jb 0x365be
addq $0xfec0, %rcx # imm = 0xFEC0
movq %rcx, (%rsi)
movl $0x2, %eax
jmp 0x365be
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0x365be
movzwl 0x1(%rdx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq 0xc7e7c(%rip), %rcx # 0xfe4f0
movzwl (%rcx,%rax,2), %ecx
movq %rcx, (%rsi)
movl $0x3, %eax
testq %rcx, %rcx
jne 0x365be
movb 0x1(%rdx), %al
incb %al
cmpb $-0x5e, %al
jae 0x36699
xorl %eax, %eax
jmp 0x365be
movb 0x2(%rdx), %cl
movl $0x0, %eax
cmpb $-0x5f, %cl
jb 0x365be
xorl %eax, %eax
cmpb $-0x1, %cl
sete %al
leal (%rax,%rax,2), %eax
addl $-0x3, %eax
jmp 0x365be
| my_mb_wc_eucjpms:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_365BE
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_365C0
mov [rsi], rdi
mov eax, 1
loc_365BE:
pop rbp
retn
loc_365C0:
lea eax, [rdi+5Fh]
cmp al, 5Dh ; ']'
ja short loc_3660C
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_365BE
movzx eax, byte ptr [rdx+1]
shl edi, 9
lea eax, [rdi+rax*2]
lea rcx, jisx0208_eucjpms_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_365BE
mov al, [rdx+1]
inc al
xor ecx, ecx
cmp al, 0A2h
setb cl
lea eax, ds:0FFFFFFFFFFFFFFFEh[rcx*2]
jmp short loc_365BE
loc_3660C:
cmp rdi, 8Fh
jz short loc_36650
cmp edi, 8Eh
jnz short loc_36692
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_365BE
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx+20h]
mov eax, 0
cmp dl, 0C1h
jb short loc_365BE
add rcx, 0FEC0h
mov [rsi], rcx
mov eax, 2
jmp loc_365BE
loc_36650:
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_365BE
movzx eax, word ptr [rdx+1]
rol ax, 8
movzx eax, ax
lea rcx, jisx0212_eucjpms_to_unicode
movzx ecx, word ptr [rcx+rax*2]
mov [rsi], rcx
mov eax, 3
test rcx, rcx
jnz loc_365BE
mov al, [rdx+1]
inc al
cmp al, 0A2h
jnb short loc_36699
loc_36692:
xor eax, eax
jmp loc_365BE
loc_36699:
mov cl, [rdx+2]
mov eax, 0
cmp cl, 0A1h
jb loc_365BE
xor eax, eax
cmp cl, 0FFh
setz al
lea eax, [rax+rax*2]
add eax, 0FFFFFFFDh
jmp loc_365BE
| long long my_mb_wc_eucjpms(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
long long v7; // rcx
long long v8; // rcx
unsigned __int8 v9; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x5Du )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = jisx0208_eucjpms_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
return 2 * (unsigned int)((unsigned __int8)(a3[1] + 1) < 0xA2u) - 2;
}
return result;
}
if ( v5 != 143 )
{
if ( (_DWORD)v5 == 142 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v7 = a3[1];
result = 0LL;
if ( (unsigned __int8)(v7 + 32) >= 0xC1u )
{
*a2 = v7 + 65216;
return 2LL;
}
}
return result;
}
return 0LL;
}
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) > a4 )
return result;
v8 = jisx0212_eucjpms_to_unicode[(unsigned __int16)__ROL2__(*(_WORD *)(a3 + 1), 8)];
*a2 = v8;
result = 3LL;
if ( v8 )
return result;
if ( (unsigned __int8)(a3[1] + 1) < 0xA2u )
return 0LL;
v9 = a3[2];
result = 0LL;
if ( v9 >= 0xA1u )
return 3 * (unsigned int)(v9 == 0xFF) - 3;
return result;
}
| my_mb_wc_eucjpms:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001365be
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x001365c0
MOV qword ptr [RSI],RDI
MOV EAX,0x1
LAB_001365be:
POP RBP
RET
LAB_001365c0:
LEA EAX,[RDI + 0x5f]
CMP AL,0x5d
JA 0x0013660c
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001365be
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EDI,0x9
LEA EAX,[RDI + RAX*0x2]
LEA RCX,[0x1de4f0]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x001365be
MOV AL,byte ptr [RDX + 0x1]
INC AL
XOR ECX,ECX
CMP AL,0xa2
SETC CL
LEA EAX,[-0x2 + RCX*0x2]
JMP 0x001365be
LAB_0013660c:
CMP RDI,0x8f
JZ 0x00136650
CMP EDI,0x8e
JNZ 0x00136692
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x001365be
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + 0x20]
MOV EAX,0x0
CMP DL,0xc1
JC 0x001365be
ADD RCX,0xfec0
MOV qword ptr [RSI],RCX
MOV EAX,0x2
JMP 0x001365be
LAB_00136650:
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x001365be
MOVZX EAX,word ptr [RDX + 0x1]
ROL AX,0x8
MOVZX EAX,AX
LEA RCX,[0x1fe4f0]
MOVZX ECX,word ptr [RCX + RAX*0x2]
MOV qword ptr [RSI],RCX
MOV EAX,0x3
TEST RCX,RCX
JNZ 0x001365be
MOV AL,byte ptr [RDX + 0x1]
INC AL
CMP AL,0xa2
JNC 0x00136699
LAB_00136692:
XOR EAX,EAX
JMP 0x001365be
LAB_00136699:
MOV CL,byte ptr [RDX + 0x2]
MOV EAX,0x0
CMP CL,0xa1
JC 0x001365be
XOR EAX,EAX
CMP CL,0xff
SETZ AL
LEA EAX,[RAX + RAX*0x2]
ADD EAX,-0x3
JMP 0x001365be
|
int my_mb_wc_eucjpms(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if ((byte)(bVar1 + 0x5f) < 0x5e) {
iVar3 = -0x66;
if (param_3 + 2 <= param_4) {
uVar2 = *(ushort *)
(jisx0208_eucjpms_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
iVar3 = 2;
if ((ulong)uVar2 == 0) {
iVar3 = (uint)((byte)(param_3[1] + 1) < 0xa2) * 2 + -2;
}
}
}
else {
if ((ulong)bVar1 == 0x8f) {
if (param_4 < param_3 + 3) {
return -0x67;
}
uVar2 = *(ushort *)
(&jisx0212_eucjpms_to_unicode +
(ulong)(ushort)(*(ushort *)(param_3 + 1) << 8 | *(ushort *)(param_3 + 1) >> 8) *
2);
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 3;
}
if (0xa1 < (byte)(param_3[1] + 1)) {
if (param_3[2] < 0xa1) {
return 0;
}
return (uint)(param_3[2] == 0xff) * 3 + -3;
}
}
else if (bVar1 == 0x8e) {
if (param_4 < param_3 + 2) {
return -0x66;
}
if ((byte)(param_3[1] + 0x20) < 0xc1) {
return 0;
}
*param_2 = (ulong)param_3[1] + 0xfec0;
return 2;
}
iVar3 = 0;
}
}
else {
*param_2 = (ulong)bVar1;
iVar3 = 1;
}
}
return iVar3;
}
| |
22,524 | exp_mont_384 | corpus-core[P]colibri-stateless/build_O1/_deps/blst-src/src/exp.c | static void exp_mont_384(vec384 out, const vec384 inp, const byte *pow,
size_t pow_bits, const vec384 p, limb_t n0)
{
#if 1
vec384 ret;
vec_copy(ret, inp, sizeof(ret)); /* ret = inp^1 */
--pow_bits; /* most significant bit is set, skip over */
while (pow_bits--) {
sqr_mont_384(ret, ret, p, n0);
if (is_bit_set(pow, pow_bits))
mul_mont_384(ret, ret, inp, p, n0);
}
vec_copy(out, ret, sizeof(ret)); /* out = ret */
#else
unsigned int i;
vec384 sqr;
vec_copy(sqr, inp, sizeof(sqr));
for (i = 0; !is_bit_set(pow, i++);)
sqr_mont_384(sqr, sqr, sqr, p, n0);
vec_copy(out, sqr, sizeof(sqr));
for (; i < pow_bits; i++) {
sqr_mont_384(sqr, sqr, sqr, p, n0);
if (is_bit_set(pow, i))
mul_mont_384(out, out, sqr, p, n0);
}
#endif
} | O1 | c | exp_mont_384:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movq %rsi, -0x38(%rbp)
movups 0x20(%rsi), %xmm2
movaps %xmm2, -0x50(%rbp)
movaps %xmm1, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
cmpq $0x1, %rcx
je 0x26685
movq %rcx, %r14
movabsq $-0x760c000300030003, %rbx # imm = 0x89F3FFFCFFFCFFFD
leaq 0x194f3(%rip), %r15 # 0x3fb20
leaq -0x70(%rbp), %r12
leaq -0x2(%r14), %r13
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x34460
movq %r13, %rax
shrq $0x3, %rax
movq -0x40(%rbp), %rcx
movzbl (%rcx,%rax), %eax
andl $0x7, %r13d
xorl %ecx, %ecx
btl %r13d, %eax
setb %cl
testq %rcx, %rcx
je 0x2667c
movq %r12, %rdi
movq %r12, %rsi
movq -0x38(%rbp), %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x34be0
decq %r14
cmpq $0x1, %r14
jne 0x26631
movaps -0x70(%rbp), %xmm0
movaps -0x60(%rbp), %xmm1
movaps -0x50(%rbp), %xmm2
movq -0x30(%rbp), %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| exp_mont_384:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_40], rdx
mov [rbp+var_30], rdi
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
mov [rbp+var_38], rsi
movups xmm2, xmmword ptr [rsi+20h]
movaps [rbp+var_50], xmm2
movaps [rbp+var_60], xmm1
movaps [rbp+var_70], xmm0
cmp rcx, 1
jz short loc_26685
mov r14, rcx
mov rbx, 89F3FFFCFFFCFFFDh
lea r15, BLS12_381_P
lea r12, [rbp+var_70]
loc_26631:
lea r13, [r14-2]
mov rdi, r12
mov rsi, r12
mov rdx, r15
mov rcx, rbx
call sqr_mont_384
mov rax, r13
shr rax, 3
mov rcx, [rbp+var_40]
movzx eax, byte ptr [rcx+rax]
and r13d, 7
xor ecx, ecx
bt eax, r13d
setb cl
test rcx, rcx
jz short loc_2667C
mov rdi, r12
mov rsi, r12
mov rdx, [rbp+var_38]
mov rcx, r15
mov r8, rbx
call mul_mont_384
loc_2667C:
dec r14
cmp r14, 1
jnz short loc_26631
loc_26685:
movaps xmm0, [rbp+var_70]
movaps xmm1, [rbp+var_60]
movaps xmm2, [rbp+var_50]
mov rax, [rbp+var_30]
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _OWORD * exp_mont_384(_OWORD *a1, _OWORD *a2, long long a3, long long a4)
{
__int128 v4; // xmm0
__int128 v5; // xmm1
long long i; // r14
int v7; // eax
__int128 v8; // xmm0
__int128 v9; // xmm1
_OWORD *result; // rax
__int128 v11; // [rsp+0h] [rbp-70h] BYREF
__int128 v12; // [rsp+10h] [rbp-60h]
__int128 v13; // [rsp+20h] [rbp-50h]
long long v14; // [rsp+30h] [rbp-40h]
_OWORD *v15; // [rsp+38h] [rbp-38h]
_OWORD *v16; // [rsp+40h] [rbp-30h]
v14 = a3;
v16 = a1;
v4 = *a2;
v5 = a2[1];
v15 = a2;
v13 = a2[2];
v12 = v5;
v11 = v4;
if ( a4 != 1 )
{
for ( i = a4; i != 1; --i )
{
sqr_mont_384(&v11, &v11, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
v7 = *(unsigned __int8 *)(v14 + ((unsigned long long)(i - 2) >> 3));
if ( _bittest(&v7, (i - 2) & 7) )
mul_mont_384(&v11, &v11, v15, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
}
}
v8 = v11;
v9 = v12;
result = v16;
v16[2] = v13;
result[1] = v9;
*result = v8;
return result;
}
| exp_mont_384:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x40],RDX
MOV qword ptr [RBP + -0x30],RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOV qword ptr [RBP + -0x38],RSI
MOVUPS XMM2,xmmword ptr [RSI + 0x20]
MOVAPS xmmword ptr [RBP + -0x50],XMM2
MOVAPS xmmword ptr [RBP + -0x60],XMM1
MOVAPS xmmword ptr [RBP + -0x70],XMM0
CMP RCX,0x1
JZ 0x00126685
MOV R14,RCX
MOV RBX,-0x760c000300030003
LEA R15,[0x13fb20]
LEA R12,[RBP + -0x70]
LAB_00126631:
LEA R13,[R14 + -0x2]
MOV RDI,R12
MOV RSI,R12
MOV RDX,R15
MOV RCX,RBX
CALL 0x00134460
MOV RAX,R13
SHR RAX,0x3
MOV RCX,qword ptr [RBP + -0x40]
MOVZX EAX,byte ptr [RCX + RAX*0x1]
AND R13D,0x7
XOR ECX,ECX
BT EAX,R13D
SETC CL
TEST RCX,RCX
JZ 0x0012667c
MOV RDI,R12
MOV RSI,R12
MOV RDX,qword ptr [RBP + -0x38]
MOV RCX,R15
MOV R8,RBX
CALL 0x00134be0
LAB_0012667c:
DEC R14
CMP R14,0x1
JNZ 0x00126631
LAB_00126685:
MOVAPS XMM0,xmmword ptr [RBP + -0x70]
MOVAPS XMM1,xmmword ptr [RBP + -0x60]
MOVAPS XMM2,xmmword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x30]
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void exp_mont_384(int8 *param_1,int4 *param_2,long param_3,long param_4)
{
int4 local_78;
int4 uStack_74;
int4 uStack_70;
int4 uStack_6c;
int8 local_68;
int8 uStack_60;
int8 local_58;
int8 uStack_50;
long local_48;
int4 *local_40;
int8 *local_38;
local_78 = *param_2;
uStack_74 = param_2[1];
uStack_70 = param_2[2];
uStack_6c = param_2[3];
local_68 = *(int8 *)(param_2 + 4);
uStack_60 = *(int8 *)(param_2 + 6);
local_58 = *(int8 *)(param_2 + 8);
uStack_50 = *(int8 *)(param_2 + 10);
local_38 = param_1;
if (param_4 != 1) {
local_48 = param_3;
local_40 = param_2;
do {
sqr_mont_384(&local_78,&local_78,BLS12_381_P,0x89f3fffcfffcfffd);
if ((*(byte *)(local_48 + (param_4 - 2U >> 3)) >> ((uint)(param_4 - 2U) & 7) & 1) != 0) {
mul_mont_384(&local_78,&local_78,local_40,BLS12_381_P,0x89f3fffcfffcfffd);
}
param_4 = param_4 + -1;
} while (param_4 != 1);
}
local_38[4] = local_58;
local_38[5] = uStack_50;
local_38[2] = local_68;
local_38[3] = uStack_60;
*local_38 = CONCAT44(uStack_74,local_78);
local_38[1] = CONCAT44(uStack_6c,uStack_70);
return;
}
| |
22,525 | make_type | eloqsql/mysys/typelib.c | void make_type(register char * to, register uint nr,
register TYPELIB *typelib)
{
DBUG_ENTER("make_type");
if (!nr)
to[0]=0;
else
(void) strmov(to,get_type(typelib,nr-1));
DBUG_VOID_RETURN;
} | O3 | c | make_type:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
je 0x9f6b3
decl %esi
leaq 0x72d2b(%rip), %rax # 0x1123c2
cmpl %esi, (%rdx)
jbe 0x9f6aa
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
je 0x9f6aa
movl %esi, %eax
movq (%rcx,%rax,8), %rax
movq %rax, %rsi
popq %rbp
jmp 0x5f4a0
movb $0x0, (%rdi)
popq %rbp
retq
| make_type:
push rbp
mov rbp, rsp
test esi, esi
jz short loc_9F6B3
dec esi
lea rax, asc_1123C2; "?"
cmp [rdx], esi
jbe short loc_9F6AA
mov rcx, [rdx+10h]
test rcx, rcx
jz short loc_9F6AA
mov eax, esi
mov rax, [rcx+rax*8]
loc_9F6AA:
mov rsi, rax
pop rbp
jmp _strcpy
loc_9F6B3:
mov byte ptr [rdi], 0
pop rbp
retn
| void make_type(_BYTE *a1, int a2, long long a3)
{
unsigned int v3; // esi
const char *v4; // rax
long long v5; // rcx
if ( a2 )
{
v3 = a2 - 1;
v4 = "?";
if ( *(_DWORD *)a3 > v3 )
{
v5 = *(_QWORD *)(a3 + 16);
if ( v5 )
v4 = *(const char **)(v5 + 8LL * v3);
}
strcpy(a1, v4);
}
else
{
*a1 = 0;
}
}
| make_type:
PUSH RBP
MOV RBP,RSP
TEST ESI,ESI
JZ 0x0019f6b3
DEC ESI
LEA RAX,[0x2123c2]
CMP dword ptr [RDX],ESI
JBE 0x0019f6aa
MOV RCX,qword ptr [RDX + 0x10]
TEST RCX,RCX
JZ 0x0019f6aa
MOV EAX,ESI
MOV RAX,qword ptr [RCX + RAX*0x8]
LAB_0019f6aa:
MOV RSI,RAX
POP RBP
JMP 0x0015f4a0
LAB_0019f6b3:
MOV byte ptr [RDI],0x0
POP RBP
RET
|
void make_type(char *param_1,int param_2,uint *param_3)
{
char *__src;
if (param_2 != 0) {
__src = "?";
if ((param_2 - 1U < *param_3) && (*(long *)(param_3 + 4) != 0)) {
__src = *(char **)(*(long *)(param_3 + 4) + (ulong)(param_2 - 1U) * 8);
}
strcpy(param_1,__src);
return;
}
*param_1 = '\0';
return;
}
| |
22,526 | ggml_quantize_q6_K | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | size_t ggml_quantize_q6_K(const float * src, void * dst, int n, int k, int64_t * hist) {
assert(k % QK_K == 0);
(void)hist; // TODO: collect histograms
for (int j = 0; j < n; j += k) {
block_q6_K * restrict y = (block_q6_K *)dst + j/QK_K;
quantize_row_q6_K_reference(src + j, y, k);
}
return (n/QK_K*sizeof(block_q6_K));
} | O0 | c | ggml_quantize_q6_K:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x173687
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
movl $0x100, %ecx # imm = 0x100
cltd
idivl %ecx
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
imulq $0xd2, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x14(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x8(%rsp), %rsi
movl 0x20(%rsp), %edx
callq 0x172290
movl 0x20(%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x173623
movl 0x24(%rsp), %eax
movl $0x100, %ecx # imm = 0x100
cltd
idivl %ecx
cltq
imulq $0xd2, %rax, %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| ggml_quantize_q6_K:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_14], edx
mov [rsp+38h+var_18], ecx
mov [rsp+38h+var_20], r8
mov [rsp+38h+var_24], 0
loc_173623:
mov eax, [rsp+38h+var_24]
cmp eax, [rsp+38h+var_14]
jge short loc_173687
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_38], rax
mov eax, [rsp+38h+var_24]
mov ecx, 100h
cdq
idiv ecx
mov ecx, eax
mov rax, [rsp+38h+var_38]
movsxd rcx, ecx
imul rcx, 0D2h
add rax, rcx
mov [rsp+38h+var_30], rax
mov rdi, [rsp+38h+var_8]
movsxd rax, [rsp+38h+var_24]
shl rax, 2
add rdi, rax
mov rsi, [rsp+38h+var_30]
mov edx, [rsp+38h+var_18]
call quantize_row_q6_K_reference
mov eax, [rsp+38h+var_18]
add eax, [rsp+38h+var_24]
mov [rsp+38h+var_24], eax
jmp short loc_173623
loc_173687:
mov eax, [rsp+38h+var_14]
mov ecx, 100h
cdq
idiv ecx
cdqe
imul rax, 0D2h
add rsp, 38h
retn
| long long ggml_quantize_q6_K(long long a1, long long a2, int a3, int a4, __m128 a5, __m128 a6)
{
int i; // [rsp+14h] [rbp-24h]
for ( i = 0; i < a3; i += a4 )
quantize_row_q6_K_reference(4LL * i + a1, 210LL * (i / 256) + a2, a4, a5, a6);
return 210LL * (a3 / 256);
}
| |||
22,527 | ggml_quantize_q6_K | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | size_t ggml_quantize_q6_K(const float * src, void * dst, int n, int k, int64_t * hist) {
assert(k % QK_K == 0);
(void)hist; // TODO: collect histograms
for (int j = 0; j < n; j += k) {
block_q6_K * restrict y = (block_q6_K *)dst + j/QK_K;
quantize_row_q6_K_reference(src + j, y, k);
}
return (n/QK_K*sizeof(block_q6_K));
} | O1 | c | ggml_quantize_q6_K:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
testl %edx, %edx
jle 0xb944d
movq %rsi, %r14
movq %rdi, %r15
movslq %ecx, %r12
movl (%rsp), %r13d
leaq (,%r12,4), %rbp
xorl %ebx, %ebx
leal 0xff(%rbx), %eax
testl %ebx, %ebx
cmovnsl %ebx, %eax
sarl $0x8, %eax
cltq
imulq $0xd2, %rax, %rsi
addq %r14, %rsi
movq %r15, %rdi
movl %r12d, %edx
callq 0xb8c6b
addq %r12, %rbx
addq %rbp, %r15
cmpq %r13, %rbx
jl 0xb941d
movq (%rsp), %rcx
leal 0xff(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x8, %eax
imull $0xd2, %eax, %eax
cltq
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ggml_quantize_q6_K:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_38], rdx
test edx, edx
jle short loc_B944D
mov r14, rsi
mov r15, rdi
movsxd r12, ecx
mov r13d, dword ptr [rsp+38h+var_38]
lea rbp, ds:0[r12*4]
xor ebx, ebx
loc_B941D:
lea eax, [rbx+0FFh]
test ebx, ebx
cmovns eax, ebx
sar eax, 8
cdqe
imul rsi, rax, 0D2h
add rsi, r14
mov rdi, r15
mov edx, r12d
call quantize_row_q6_K_reference
add rbx, r12
add r15, rbp
cmp rbx, r13
jl short loc_B941D
loc_B944D:
mov rcx, [rsp+38h+var_38]
lea eax, [rcx+0FFh]
test ecx, ecx
cmovns eax, ecx
sar eax, 8
imul eax, 0D2h
cdqe
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ggml_quantize_q6_K(long long a1, long long a2, int a3, int a4, double a5, __m128 a6, __m128 a7)
{
long long v8; // r12
long long v9; // rbp
long long v10; // rbx
if ( a3 > 0 )
{
v8 = a4;
v9 = 4LL * a4;
v10 = 0LL;
do
{
quantize_row_q6_K_reference(a1, a2 + 210LL * ((int)v10 / 256), v8, a5, a6, a7);
v10 += v8;
a1 += v9;
}
while ( v10 < (unsigned int)a3 );
}
return 210 * (a3 / 256);
}
| |||
22,528 | ggml_quantize_q6_K | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | size_t ggml_quantize_q6_K(const float * src, void * dst, int n, int k, int64_t * hist) {
assert(k % QK_K == 0);
(void)hist; // TODO: collect histograms
for (int j = 0; j < n; j += k) {
block_q6_K * restrict y = (block_q6_K *)dst + j/QK_K;
quantize_row_q6_K_reference(src + j, y, k);
}
return (n/QK_K*sizeof(block_q6_K));
} | O2 | c | ggml_quantize_q6_K:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movslq %ecx, %r12
movl %edx, 0x4(%rsp)
movslq %edx, %rbp
leaq (,%r12,4), %rbx
xorl %r13d, %r13d
cmpq %rbp, %r13
jge 0x9513f
movl %r13d, %eax
cltd
movl $0x100, %ecx # imm = 0x100
idivl %ecx
cltq
imulq $0xd2, %rax, %rsi
addq %r14, %rsi
movq %r15, %rdi
movl %r12d, %edx
callq 0x94a19
addq %r12, %r13
addq %rbx, %r15
jmp 0x95110
movl $0x100, %ecx # imm = 0x100
movl 0x4(%rsp), %eax
cltd
idivl %ecx
imull $0xd2, %eax, %eax
cltq
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ggml_quantize_q6_K:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov r15, rdi
movsxd r12, ecx
mov [rsp+38h+var_34], edx
movsxd rbp, edx
lea rbx, ds:0[r12*4]
xor r13d, r13d
loc_95110:
cmp r13, rbp
jge short loc_9513F
mov eax, r13d
cdq
mov ecx, 100h
idiv ecx
cdqe
imul rsi, rax, 0D2h
add rsi, r14
mov rdi, r15
mov edx, r12d
call quantize_row_q6_K_reference
add r13, r12
add r15, rbx
jmp short loc_95110
loc_9513F:
mov ecx, 100h
mov eax, [rsp+38h+var_34]
cdq
idiv ecx
imul eax, 0D2h
cdqe
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ggml_quantize_q6_K(
long long a1,
long long a2,
int a3,
int a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v11; // r12
long long v12; // rbp
long long v13; // rbx
long long v14; // r13
v11 = a4;
v12 = a3;
v13 = 4LL * a4;
v14 = 0LL;
while ( v14 < v12 )
{
quantize_row_q6_K_reference(a1, a2 + 210LL * ((int)v14 / 256), v11, a5, a6, a7, a8, a9, a10);
v14 += v11;
a1 += v13;
}
return 210 * (a3 / 256);
}
| ggml_quantize_q6_K:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV R15,RDI
MOVSXD R12,ECX
MOV dword ptr [RSP + 0x4],EDX
MOVSXD RBP,EDX
LEA RBX,[R12*0x4]
XOR R13D,R13D
LAB_00195110:
CMP R13,RBP
JGE 0x0019513f
MOV EAX,R13D
CDQ
MOV ECX,0x100
IDIV ECX
CDQE
IMUL RSI,RAX,0xd2
ADD RSI,R14
MOV RDI,R15
MOV EDX,R12D
CALL 0x00194a19
ADD R13,R12
ADD R15,RBX
JMP 0x00195110
LAB_0019513f:
MOV ECX,0x100
MOV EAX,dword ptr [RSP + 0x4]
CDQ
IDIV ECX
IMUL EAX,EAX,0xd2
CDQE
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] ggml_quantize_q6_K(long param_1,long param_2,int param_3,int param_4)
{
ulong uVar1;
int1 auVar2 [16];
for (uVar1 = 0; (long)uVar1 < (long)param_3; uVar1 = uVar1 + (long)param_4) {
quantize_row_q6_K_reference
(param_1,(long)(int)((long)((ulong)(uint)((int)uVar1 >> 0x1f) << 0x20 |
uVar1 & 0xffffffff) / 0x100) * 0xd2 + param_2,param_4);
param_1 = param_1 + (long)param_4 * 4;
}
auVar2._8_8_ = (long)param_3 % 0x100 & 0xffffffff;
auVar2._0_8_ = (long)((param_3 / 0x100) * 0xd2);
return auVar2;
}
| |
22,529 | ggml_quantize_q6_K | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | size_t ggml_quantize_q6_K(const float * src, void * dst, int n, int k, int64_t * hist) {
assert(k % QK_K == 0);
(void)hist; // TODO: collect histograms
for (int j = 0; j < n; j += k) {
block_q6_K * restrict y = (block_q6_K *)dst + j/QK_K;
quantize_row_q6_K_reference(src + j, y, k);
}
return (n/QK_K*sizeof(block_q6_K));
} | O3 | c | ggml_quantize_q6_K:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
testl %edx, %edx
jle 0xb7f5e
movq %rsi, %r14
movq %rdi, %r15
movslq %ecx, %r12
movl (%rsp), %r13d
leaq (,%r12,4), %rbp
xorl %ebx, %ebx
leal 0xff(%rbx), %eax
testl %ebx, %ebx
cmovnsl %ebx, %eax
sarl $0x8, %eax
cltq
imulq $0xd2, %rax, %rsi
addq %r14, %rsi
movq %r15, %rdi
movl %r12d, %edx
callq 0xb7774
addq %r12, %rbx
addq %rbp, %r15
cmpq %r13, %rbx
jl 0xb7f2e
movq (%rsp), %rcx
leal 0xff(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x8, %eax
imull $0xd2, %eax, %eax
cltq
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ggml_quantize_q6_K:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_38], rdx
test edx, edx
jle short loc_B7F5E
mov r14, rsi
mov r15, rdi
movsxd r12, ecx
mov r13d, dword ptr [rsp+38h+var_38]
lea rbp, ds:0[r12*4]
xor ebx, ebx
loc_B7F2E:
lea eax, [rbx+0FFh]
test ebx, ebx
cmovns eax, ebx
sar eax, 8
cdqe
imul rsi, rax, 0D2h
add rsi, r14
mov rdi, r15
mov edx, r12d
call quantize_row_q6_K_reference
add rbx, r12
add r15, rbp
cmp rbx, r13
jl short loc_B7F2E
loc_B7F5E:
mov rcx, [rsp+38h+var_38]
lea eax, [rcx+0FFh]
test ecx, ecx
cmovns eax, ecx
sar eax, 8
imul eax, 0D2h
cdqe
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ggml_quantize_q6_K(long long a1, long long a2, int a3, int a4, double a5, __m128 a6, __m128 a7)
{
long long v8; // r12
long long v9; // rbp
long long v10; // rbx
if ( a3 > 0 )
{
v8 = a4;
v9 = 4LL * a4;
v10 = 0LL;
do
{
quantize_row_q6_K_reference(a1, a2 + 210LL * ((int)v10 / 256), v8, a5, a6, a7);
v10 += v8;
a1 += v9;
}
while ( v10 < (unsigned int)a3 );
}
return 210 * (a3 / 256);
}
| |||
22,530 | rtree_insert_req | eloqsql/storage/myisam/rt_index.c | static int rtree_insert_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
uint key_length, my_off_t page, my_off_t *new_page,
int ins_level, int level)
{
uchar *k;
uint nod_flag;
uchar *page_buf;
int res;
DBUG_ENTER("rtree_insert_req");
if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length +
HA_MAX_KEY_BUFF)))
{
my_errno = HA_ERR_OUT_OF_MEM;
DBUG_RETURN(-1); /* purecov: inspected */
}
if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0))
goto err1;
nod_flag = mi_test_if_nod(page_buf);
DBUG_PRINT("rtree", ("page: %lu level: %d ins_level: %d nod_flag: %u",
(ulong) page, level, ins_level, nod_flag));
if ((ins_level == -1 && nod_flag) || /* key: go down to leaf */
(ins_level > -1 && ins_level > level)) /* branch: go down to ins_level */
{
if ((k = rtree_pick_key(info, keyinfo, key, key_length, page_buf,
nod_flag)) == NULL)
goto err1;
switch ((res = rtree_insert_req(info, keyinfo, key, key_length,
_mi_kpos(nod_flag, k), new_page, ins_level, level + 1)))
{
case 0: /* child was not split */
{
rtree_combine_rect(keyinfo->seg, k, key, k, key_length);
if (_mi_write_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf))
goto err1;
goto ok;
}
case 1: /* child was split */
{
uchar *new_key = page_buf + keyinfo->block_length + nod_flag;
/* set proper MBR for key */
if (rtree_set_key_mbr(info, keyinfo, k, key_length,
_mi_kpos(nod_flag, k)))
goto err1;
/* add new key for new page */
_mi_kpointer(info, new_key - nod_flag, *new_page);
if (rtree_set_key_mbr(info, keyinfo, new_key, key_length, *new_page))
goto err1;
res = rtree_add_key(info, keyinfo, new_key, key_length,
page_buf, new_page);
if (_mi_write_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf))
goto err1;
goto ok;
}
default:
case -1: /* error */
{
goto err1;
}
}
}
else
{
res = rtree_add_key(info, keyinfo, key, key_length, page_buf, new_page);
if (_mi_write_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf))
goto err1;
goto ok;
}
ok:
my_afree((uchar*)page_buf);
DBUG_RETURN(res);
err1:
my_afree((uchar*)page_buf);
DBUG_RETURN(-1); /* purecov: inspected */
} | O3 | c | rtree_insert_req:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, -0x50(%rbp)
movq %r8, %r15
movl %ecx, -0x34(%rbp)
movq %rdx, -0x58(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movzwl 0xe(%rsi), %eax
movq %rsp, %r13
addl $0x4c7, %eax # imm = 0x4C7
andl $-0x10, %eax
subq %rax, %r13
movq %r13, %rsp
xorl %ebx, %ebx
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %r8, %rdx
movl $0x3, %ecx
movq %r13, %r8
xorl %r9d, %r9d
callq 0x83cd8
testq %rax, %rax
je 0x8b1e1
movl 0x18(%rbp), %esi
movl 0x10(%rbp), %edx
movzbl (%r13), %r14d
testb %r14b, %r14b
jns 0x8b043
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %ebx
cmpl $-0x1, %edx
sete %al
testl %ebx, %ebx
setne %cl
testb %cl, %al
jne 0x8b055
testl %edx, %edx
sets %al
cmpl %esi, %edx
setle %cl
orb %al, %cl
jne 0x8b1a4
movq %r15, -0x68(%rbp)
movl %ebx, %r12d
movq %r13, %rcx
addq %r12, %r13
addq $0x2, %r13
movzbl 0x1(%rcx), %eax
andl $0x7f, %r14d
shll $0x8, %r14d
orq %rax, %r14
movq %rcx, -0x60(%rbp)
addq %rcx, %r14
cmpq %r14, %r13
jae 0x8b1e1
movl -0x34(%rbp), %r15d
xorl %ebx, %ebx
movq -0x48(%rbp), %rax
movq 0x28(%rax), %rdi
movq %r13, %rsi
movq -0x58(%rbp), %rdx
movl -0x34(%rbp), %ecx
leaq -0x80(%rbp), %r8
callq 0x8cde1
ucomisd 0x55f22(%rip), %xmm0 # 0xe0fd0
jne 0x8b0b6
jnp 0x8b1e1
movsd -0x80(%rbp), %xmm1
testq %rbx, %rbx
movsd -0x78(%rbp), %xmm3
je 0x8b0de
ucomisd %xmm0, %xmm3
ja 0x8b0de
ucomisd %xmm3, %xmm0
jne 0x8b0ea
jp 0x8b0ea
movsd -0x70(%rbp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x8b0ea
movapd %xmm0, %xmm3
movsd %xmm1, -0x70(%rbp)
movq %r13, %rbx
movq %r12, %rax
testl %r12d, %r12d
jne 0x8b0ff
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl 0x178(%rax), %eax
movsd %xmm3, -0x78(%rbp)
addq %r15, %r13
addq %rax, %r13
cmpq %r14, %r13
jb 0x8b08b
testq %rbx, %rbx
movq -0x68(%rbp), %r14
je 0x8b1e1
movl %r12d, %edi
movq %rbx, %rsi
callq 0x84652
movl 0x18(%rbp), %ecx
movq %rcx, %r10
incl %r10d
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdx
movl -0x34(%rbp), %ecx
movq %rax, %r8
movq -0x50(%rbp), %r9
pushq %r10
movl 0x10(%rbp), %eax
pushq %rax
callq 0x8afb0
addq $0x10, %rsp
cmpl $0x1, %eax
je 0x8b20a
testl %eax, %eax
movq -0x60(%rbp), %r12
jne 0x8b1e1
movq -0x48(%rbp), %r15
movq 0x28(%r15), %rdi
movq %rbx, %rsi
movq -0x58(%rbp), %rdx
movq %rbx, %rcx
movl -0x34(%rbp), %r8d
callq 0x8c3e1
movq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x3, %ecx
movq %r12, %r8
callq 0x83d84
testl %eax, %eax
jne 0x8b1e1
xorl %ebx, %ebx
jmp 0x8b1e6
movq -0x40(%rbp), %r12
movq %r12, %rdi
movq -0x48(%rbp), %r14
movq %r14, %rsi
movq -0x58(%rbp), %rdx
movl -0x34(%rbp), %ecx
movq %r13, %r8
movq -0x50(%rbp), %r9
callq 0x8b2b4
movl %eax, %ebx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x3, %ecx
movq %r13, %r8
callq 0x83d84
testl %eax, %eax
je 0x8b1e6
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x8b2ae
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x48(%rbp), %r15
movzwl 0xe(%r15), %r13d
movl %r12d, %edi
movq %rbx, %rsi
callq 0x84652
movq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl -0x34(%rbp), %ecx
movq %rax, %r8
callq 0x8b42c
testl %eax, %eax
movq -0x60(%rbp), %rax
jne 0x8b1e1
addq %rax, %r13
addq %r13, %r12
movq -0x50(%rbp), %r15
movq (%r15), %rdx
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x851bd
movq (%r15), %r8
movq -0x60(%rbp), %r15
movq %rbx, %rdi
movq -0x48(%rbp), %rsi
movq %r12, %rdx
movl -0x34(%rbp), %ecx
callq 0x8b42c
testl %eax, %eax
jne 0x8b1e1
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %r13
movq %r13, %rsi
movq %r12, %rdx
movl -0x34(%rbp), %ecx
movq %r15, %r8
movq -0x50(%rbp), %r9
callq 0x8b2b4
movl %eax, %ebx
movq -0x40(%rbp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x3, %ecx
movq %r15, %r8
jmp 0x8b1d8
callq 0x29270
nop
| rtree_insert_req:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_50], r9
mov r15, r8
mov [rbp+var_34], ecx
mov [rbp+var_58], rdx
mov rax, fs:28h
mov [rbp+var_30], rax
movzx eax, word ptr [rsi+0Eh]
mov r13, rsp
add eax, 4C7h
and eax, 0FFFFFFF0h
sub r13, rax
mov rsp, r13
xor ebx, ebx
mov [rbp+var_40], rdi
mov [rbp+var_48], rsi
mov rdx, r8
mov ecx, 3
mov r8, r13
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz loc_8B1E1
mov esi, [rbp+arg_8]
mov edx, [rbp+arg_0]
movzx r14d, byte ptr [r13+0]
test r14b, r14b
jns short loc_8B043
mov rax, [rbp+var_40]
mov rax, [rax]
mov ebx, [rax+17Ch]
cmp edx, 0FFFFFFFFh
setz al
test ebx, ebx
setnz cl
test al, cl
jnz short loc_8B055
loc_8B043:
test edx, edx
sets al
cmp edx, esi
setle cl
or cl, al
jnz loc_8B1A4
loc_8B055:
mov [rbp+var_68], r15
mov r12d, ebx
mov rcx, r13
add r13, r12
add r13, 2
movzx eax, byte ptr [rcx+1]
and r14d, 7Fh
shl r14d, 8
or r14, rax
mov [rbp+var_60], rcx
add r14, rcx
cmp r13, r14
jnb loc_8B1E1
mov r15d, [rbp+var_34]
xor ebx, ebx
loc_8B08B:
mov rax, [rbp+var_48]
mov rdi, [rax+28h]
mov rsi, r13
mov rdx, [rbp+var_58]
mov ecx, [rbp+var_34]
lea r8, [rbp+var_80]
call rtree_area_increase
ucomisd xmm0, cs:qword_E0FD0
jnz short loc_8B0B6
jnp loc_8B1E1
loc_8B0B6:
movsd xmm1, [rbp+var_80]
test rbx, rbx
movsd xmm3, [rbp+var_78]
jz short loc_8B0DE
ucomisd xmm3, xmm0
ja short loc_8B0DE
ucomisd xmm0, xmm3
jnz short loc_8B0EA
jp short loc_8B0EA
movsd xmm2, [rbp+var_70]
ucomisd xmm2, xmm1
jbe short loc_8B0EA
loc_8B0DE:
movapd xmm3, xmm0
movsd [rbp+var_70], xmm1
mov rbx, r13
loc_8B0EA:
mov rax, r12
test r12d, r12d
jnz short loc_8B0FF
mov rax, [rbp+var_40]
mov rax, [rax]
mov eax, [rax+178h]
loc_8B0FF:
movsd [rbp+var_78], xmm3
add r13, r15
add r13, rax
cmp r13, r14
jb loc_8B08B
test rbx, rbx
mov r14, [rbp+var_68]
jz loc_8B1E1
mov edi, r12d
mov rsi, rbx
call _mi_kpos
mov ecx, [rbp+arg_8]
mov r10, rcx
inc r10d
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_58]
mov ecx, [rbp+var_34]
mov r8, rax
mov r9, [rbp+var_50]
push r10
mov eax, [rbp+arg_0]
push rax
call rtree_insert_req
add rsp, 10h
cmp eax, 1
jz loc_8B20A
test eax, eax
mov r12, [rbp+var_60]
jnz short loc_8B1E1
mov r15, [rbp+var_48]
mov rdi, [r15+28h]
mov rsi, rbx
mov rdx, [rbp+var_58]
mov rcx, rbx
mov r8d, [rbp+var_34]
call rtree_combine_rect
mov rdi, [rbp+var_40]
mov rsi, r15
mov rdx, r14
mov ecx, 3
mov r8, r12
call _mi_write_keypage
test eax, eax
jnz short loc_8B1E1
xor ebx, ebx
jmp short loc_8B1E6
loc_8B1A4:
mov r12, [rbp+var_40]
mov rdi, r12
mov r14, [rbp+var_48]
mov rsi, r14
mov rdx, [rbp+var_58]
mov ecx, [rbp+var_34]
mov r8, r13
mov r9, [rbp+var_50]
call rtree_add_key
mov ebx, eax
mov rdi, r12
mov rsi, r14
mov rdx, r15
mov ecx, 3
mov r8, r13
loc_8B1D8:
call _mi_write_keypage
test eax, eax
jz short loc_8B1E6
loc_8B1E1:
mov ebx, 0FFFFFFFFh
loc_8B1E6:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_8B2AE
mov eax, ebx
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8B20A:
mov r15, [rbp+var_48]
movzx r13d, word ptr [r15+0Eh]
mov edi, r12d
mov rsi, rbx
call _mi_kpos
mov rdi, [rbp+var_40]
mov rsi, r15
mov rdx, rbx
mov ecx, [rbp+var_34]
mov r8, rax
call rtree_set_key_mbr
test eax, eax
mov rax, [rbp+var_60]
jnz short loc_8B1E1
add r13, rax
add r12, r13
mov r15, [rbp+var_50]
mov rdx, [r15]
mov rbx, [rbp+var_40]
mov rdi, rbx
mov rsi, r13
call _mi_kpointer
mov r8, [r15]
mov r15, [rbp+var_60]
mov rdi, rbx
mov rsi, [rbp+var_48]
mov rdx, r12
mov ecx, [rbp+var_34]
call rtree_set_key_mbr
test eax, eax
jnz loc_8B1E1
mov rdi, [rbp+var_40]
mov r13, [rbp+var_48]
mov rsi, r13
mov rdx, r12
mov ecx, [rbp+var_34]
mov r8, r15
mov r9, [rbp+var_50]
call rtree_add_key
mov ebx, eax
mov rdi, [rbp+var_40]
mov rsi, r13
mov rdx, r14
mov ecx, 3
mov r8, r15
jmp loc_8B1D8
loc_8B2AE:
call ___stack_chk_fail
| // bad sp value at call has been detected, the output may be wrong!
long long rtree_insert_req(
long long *a1,
long long a2,
long long a3,
unsigned int a4,
long long a5,
unsigned long long *a6,
int a7,
int a8)
{
char *v9; // r13
unsigned int v10; // ebx
char v11; // r14
long long v12; // r12
char *v13; // rcx
unsigned long long v14; // r13
long long v15; // rax
unsigned long long v16; // r14
long long v17; // r15
long long v18; // rbx
double v19; // xmm0_8
double v20; // xmm1_8
double v21; // xmm3_8
long long v22; // rax
unsigned long long v23; // r14
int v24; // eax
int inserted; // eax
char *v26; // r12
long long v27; // r15
unsigned int v28; // ebx
long long *v29; // r12
long long v30; // r14
long long *v31; // rdi
long long v32; // rsi
unsigned long long v33; // rdx
char *v34; // r8
long long v36; // r15
long long v37; // r13
unsigned long long v38; // rax
char *v39; // r13
char *v40; // r12
unsigned long long *v41; // r15
long long *v42; // rbx
unsigned long long v43; // r8
char *v44; // r15
long long v45; // r13
double v46; // [rsp+0h] [rbp-80h] BYREF
double v47; // [rsp+8h] [rbp-78h]
double v48; // [rsp+10h] [rbp-70h]
unsigned long long v49; // [rsp+18h] [rbp-68h]
char *v50; // [rsp+20h] [rbp-60h]
long long v51; // [rsp+28h] [rbp-58h]
unsigned long long *v52; // [rsp+30h] [rbp-50h]
long long v53; // [rsp+38h] [rbp-48h]
long long *v54; // [rsp+40h] [rbp-40h]
unsigned int v55; // [rsp+4Ch] [rbp-34h]
unsigned long long v56; // [rsp+50h] [rbp-30h]
v52 = a6;
v55 = a4;
v51 = a3;
v56 = __readfsqword(0x28u);
v9 = (char *)&v46 - ((*(unsigned __int16 *)(a2 + 14) + 1223) & 0xFFFFFFF0);
v10 = 0;
v54 = a1;
v53 = a2;
if ( !mi_fetch_keypage(a1, a2, a5) )
return (unsigned int)-1;
v11 = *v9;
if ( *v9 < 0 && (v10 = *(_DWORD *)(*v54 + 380), v10 != 0 && a7 == -1) || a7 >= 0 && a7 > a8 )
{
v49 = a5;
v12 = v10;
v13 = v9;
v14 = (unsigned long long)&v9[v10 + 2];
v15 = (unsigned __int8)v13[1];
v50 = v13;
v16 = (unsigned long long)&v13[v15 | ((unsigned __int8)(v11 & 0x7F) << 8)];
if ( v14 < v16 )
{
v17 = v55;
v18 = 0LL;
while ( 1 )
{
v19 = rtree_area_increase(*(_QWORD *)(v53 + 40), v14, v51, v55, &v46);
if ( v19 == -1.0 )
break;
v20 = v46;
v21 = v47;
if ( !v18 || v47 > v19 || v19 == v47 && v48 > v46 )
{
v21 = v19;
v48 = v46;
v18 = v14;
}
v22 = v12;
if ( !(_DWORD)v12 )
v22 = *(unsigned int *)(*v54 + 376);
v47 = v21;
v14 += v22 + v17;
if ( v14 >= v16 )
{
v23 = v49;
if ( !v18 )
return (unsigned int)-1;
v24 = mi_kpos(v12, v18);
inserted = rtree_insert_req((_DWORD)v54, v53, v51, v55, v24, (_DWORD)v52, a7, a8 + 1);
if ( inserted == 1 )
{
v36 = v53;
v37 = *(unsigned __int16 *)(v53 + 14);
v38 = mi_kpos(v12, v18);
if ( !(unsigned int)rtree_set_key_mbr(v54, v36, v18, v55, v38) )
{
v39 = &v50[v37];
v40 = &v39[v12];
v41 = v52;
v42 = v54;
mi_kpointer((long long)v54, v39, *v52);
v43 = *v41;
v44 = v50;
if ( !(unsigned int)rtree_set_key_mbr(v42, v53, v40, v55, v43) )
{
v45 = v53;
v28 = rtree_add_key(v54, v53, v40, v55, v44, v52);
v31 = v54;
v32 = v45;
v33 = v23;
v34 = v44;
goto LABEL_22;
}
}
}
else
{
v26 = v50;
if ( !inserted )
{
v27 = v53;
rtree_combine_rect(*(_QWORD *)(v53 + 40), v18, v51, v18, v55, v19, v20);
if ( !(unsigned int)mi_write_keypage(v54, v27, v23, 3u, v26) )
return 0;
}
}
return (unsigned int)-1;
}
}
}
return (unsigned int)-1;
}
v29 = v54;
v30 = v53;
v28 = rtree_add_key(v54, v53, v51, v55, v9, v52);
v31 = v29;
v32 = v30;
v33 = a5;
v34 = v9;
LABEL_22:
if ( (unsigned int)mi_write_keypage(v31, v32, v33, 3u, v34) )
return (unsigned int)-1;
return v28;
}
| rtree_insert_req:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x50],R9
MOV R15,R8
MOV dword ptr [RBP + -0x34],ECX
MOV qword ptr [RBP + -0x58],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOVZX EAX,word ptr [RSI + 0xe]
MOV R13,RSP
ADD EAX,0x4c7
AND EAX,0xfffffff0
SUB R13,RAX
MOV RSP,R13
XOR EBX,EBX
MOV qword ptr [RBP + -0x40],RDI
MOV qword ptr [RBP + -0x48],RSI
MOV RDX,R8
MOV ECX,0x3
MOV R8,R13
XOR R9D,R9D
CALL 0x00183cd8
TEST RAX,RAX
JZ 0x0018b1e1
MOV ESI,dword ptr [RBP + 0x18]
MOV EDX,dword ptr [RBP + 0x10]
MOVZX R14D,byte ptr [R13]
TEST R14B,R14B
JNS 0x0018b043
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX]
MOV EBX,dword ptr [RAX + 0x17c]
CMP EDX,-0x1
SETZ AL
TEST EBX,EBX
SETNZ CL
TEST AL,CL
JNZ 0x0018b055
LAB_0018b043:
TEST EDX,EDX
SETS AL
CMP EDX,ESI
SETLE CL
OR CL,AL
JNZ 0x0018b1a4
LAB_0018b055:
MOV qword ptr [RBP + -0x68],R15
MOV R12D,EBX
MOV RCX,R13
ADD R13,R12
ADD R13,0x2
MOVZX EAX,byte ptr [RCX + 0x1]
AND R14D,0x7f
SHL R14D,0x8
OR R14,RAX
MOV qword ptr [RBP + -0x60],RCX
ADD R14,RCX
CMP R13,R14
JNC 0x0018b1e1
MOV R15D,dword ptr [RBP + -0x34]
XOR EBX,EBX
LAB_0018b08b:
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [RAX + 0x28]
MOV RSI,R13
MOV RDX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x34]
LEA R8,[RBP + -0x80]
CALL 0x0018cde1
UCOMISD XMM0,qword ptr [0x001e0fd0]
JNZ 0x0018b0b6
JNP 0x0018b1e1
LAB_0018b0b6:
MOVSD XMM1,qword ptr [RBP + -0x80]
TEST RBX,RBX
MOVSD XMM3,qword ptr [RBP + -0x78]
JZ 0x0018b0de
UCOMISD XMM3,XMM0
JA 0x0018b0de
UCOMISD XMM0,XMM3
JNZ 0x0018b0ea
JP 0x0018b0ea
MOVSD XMM2,qword ptr [RBP + -0x70]
UCOMISD XMM2,XMM1
JBE 0x0018b0ea
LAB_0018b0de:
MOVAPD XMM3,XMM0
MOVSD qword ptr [RBP + -0x70],XMM1
MOV RBX,R13
LAB_0018b0ea:
MOV RAX,R12
TEST R12D,R12D
JNZ 0x0018b0ff
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x178]
LAB_0018b0ff:
MOVSD qword ptr [RBP + -0x78],XMM3
ADD R13,R15
ADD R13,RAX
CMP R13,R14
JC 0x0018b08b
TEST RBX,RBX
MOV R14,qword ptr [RBP + -0x68]
JZ 0x0018b1e1
MOV EDI,R12D
MOV RSI,RBX
CALL 0x00184652
MOV ECX,dword ptr [RBP + 0x18]
MOV R10,RCX
INC R10D
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x34]
MOV R8,RAX
MOV R9,qword ptr [RBP + -0x50]
PUSH R10
MOV EAX,dword ptr [RBP + 0x10]
PUSH RAX
CALL 0x0018afb0
ADD RSP,0x10
CMP EAX,0x1
JZ 0x0018b20a
TEST EAX,EAX
MOV R12,qword ptr [RBP + -0x60]
JNZ 0x0018b1e1
MOV R15,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [R15 + 0x28]
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x58]
MOV RCX,RBX
MOV R8D,dword ptr [RBP + -0x34]
CALL 0x0018c3e1
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,R15
MOV RDX,R14
MOV ECX,0x3
MOV R8,R12
CALL 0x00183d84
TEST EAX,EAX
JNZ 0x0018b1e1
XOR EBX,EBX
JMP 0x0018b1e6
LAB_0018b1a4:
MOV R12,qword ptr [RBP + -0x40]
MOV RDI,R12
MOV R14,qword ptr [RBP + -0x48]
MOV RSI,R14
MOV RDX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x34]
MOV R8,R13
MOV R9,qword ptr [RBP + -0x50]
CALL 0x0018b2b4
MOV EBX,EAX
MOV RDI,R12
MOV RSI,R14
MOV RDX,R15
MOV ECX,0x3
MOV R8,R13
LAB_0018b1d8:
CALL 0x00183d84
TEST EAX,EAX
JZ 0x0018b1e6
LAB_0018b1e1:
MOV EBX,0xffffffff
LAB_0018b1e6:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0018b2ae
MOV EAX,EBX
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018b20a:
MOV R15,qword ptr [RBP + -0x48]
MOVZX R13D,word ptr [R15 + 0xe]
MOV EDI,R12D
MOV RSI,RBX
CALL 0x00184652
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,R15
MOV RDX,RBX
MOV ECX,dword ptr [RBP + -0x34]
MOV R8,RAX
CALL 0x0018b42c
TEST EAX,EAX
MOV RAX,qword ptr [RBP + -0x60]
JNZ 0x0018b1e1
ADD R13,RAX
ADD R12,R13
MOV R15,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [R15]
MOV RBX,qword ptr [RBP + -0x40]
MOV RDI,RBX
MOV RSI,R13
CALL 0x001851bd
MOV R8,qword ptr [R15]
MOV R15,qword ptr [RBP + -0x60]
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,R12
MOV ECX,dword ptr [RBP + -0x34]
CALL 0x0018b42c
TEST EAX,EAX
JNZ 0x0018b1e1
MOV RDI,qword ptr [RBP + -0x40]
MOV R13,qword ptr [RBP + -0x48]
MOV RSI,R13
MOV RDX,R12
MOV ECX,dword ptr [RBP + -0x34]
MOV R8,R15
MOV R9,qword ptr [RBP + -0x50]
CALL 0x0018b2b4
MOV EBX,EAX
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,R13
MOV RDX,R14
MOV ECX,0x3
MOV R8,R15
JMP 0x0018b1d8
LAB_0018b2ae:
CALL 0x00129270
|
int4
rtree_insert_req(long *param_1,long param_2,int8 param_3,uint param_4,int8 param_5,
int8 *param_6,uint param_7,int param_8)
{
byte bVar1;
byte bVar2;
ushort uVar3;
long lVar4;
int8 *puVar5;
uint uVar6;
int iVar7;
int4 uVar8;
long lVar9;
ulong uVar10;
int8 uVar11;
int8 uVar12;
uint uVar13;
byte *pbVar14;
long lVar15;
long *plVar16;
byte *pbVar17;
ulong uVar18;
byte *pbVar19;
ulong uVar20;
long in_FS_OFFSET;
double dVar21;
ulong auStack_a0 [3];
int8 local_88;
double local_80;
double local_78;
int8 local_70;
byte *local_68;
int8 local_60;
int8 *local_58;
long local_50;
long *local_48;
uint local_3c;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar4 = -(ulong)(*(ushort *)(param_2 + 0xe) + 0x4c7 & 0xfffffff0);
pbVar17 = (byte *)((long)&local_88 + lVar4);
uVar13 = 0;
local_60 = param_3;
local_58 = param_6;
local_50 = param_2;
local_48 = param_1;
local_3c = param_4;
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b00e;
lVar9 = _mi_fetch_keypage(param_1,param_2,param_5,3,pbVar17,0);
uVar6 = local_3c;
plVar16 = local_48;
lVar15 = local_50;
puVar5 = local_58;
uVar12 = local_60;
if (lVar9 != 0) {
bVar1 = *pbVar17;
if ((((char)bVar1 < '\0') &&
(uVar13 = *(uint *)(*local_48 + 0x17c), param_7 == 0xffffffff && uVar13 != 0)) ||
(param_8 < (int)param_7 && -1 < (int)param_7)) {
local_70 = param_5;
uVar18 = (ulong)uVar13;
pbVar19 = pbVar17 + uVar18 + 2;
bVar2 = *(byte *)((long)&local_88 + lVar4 + 1);
local_68 = pbVar17;
if (pbVar19 < pbVar17 + ((ulong)((bVar1 & 0x7f) << 8) | (ulong)bVar2)) {
uVar20 = (ulong)local_3c;
pbVar14 = (byte *)0x0;
do {
uVar6 = local_3c;
uVar11 = local_60;
uVar12 = *(int8 *)(local_50 + 0x28);
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b0a6;
dVar21 = (double)rtree_area_increase(uVar12,pbVar19,uVar11,uVar6,&local_88);
param_5 = local_70;
if ((dVar21 == DAT_001e0fd0) && (!NAN(dVar21) && !NAN(DAT_001e0fd0))) goto LAB_0018b1e1;
if (((pbVar14 == (byte *)0x0) || (dVar21 < local_80)) ||
(((dVar21 == local_80 && (!NAN(dVar21) && !NAN(local_80))) && (local_88 < local_78))))
{
local_78 = local_88;
pbVar14 = pbVar19;
local_80 = dVar21;
}
uVar10 = uVar18;
if (uVar13 == 0) {
uVar10 = (ulong)*(uint *)(*local_48 + 0x178);
}
pbVar19 = pbVar19 + uVar10 + uVar20;
} while (pbVar19 < pbVar17 + ((ulong)((bVar1 & 0x7f) << 8) | (ulong)bVar2));
if (pbVar14 != (byte *)0x0) {
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b12b;
uVar11 = _mi_kpos(uVar18,pbVar14);
uVar6 = local_3c;
plVar16 = local_48;
lVar15 = local_50;
puVar5 = local_58;
uVar12 = local_60;
*(ulong *)((long)auStack_a0 + lVar4 + 0x10) = (ulong)(param_8 + 1);
*(ulong *)((long)auStack_a0 + lVar4 + 8) = (ulong)param_7;
*(int8 *)((long)auStack_a0 + lVar4) = 0x18b155;
iVar7 = rtree_insert_req(plVar16,lVar15,uVar12,uVar6,uVar11,puVar5);
uVar6 = local_3c;
lVar15 = local_50;
uVar12 = local_60;
pbVar17 = local_68;
if (iVar7 == 1) {
uVar3 = *(ushort *)(local_50 + 0xe);
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b21e;
uVar12 = _mi_kpos(uVar13,pbVar14);
uVar13 = local_3c;
plVar16 = local_48;
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b233;
iVar7 = rtree_set_key_mbr(plVar16,lVar15,pbVar14,uVar13,uVar12);
plVar16 = local_48;
puVar5 = local_58;
if (iVar7 == 0) {
pbVar19 = local_68 + uVar3;
uVar12 = *local_58;
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b257;
_mi_kpointer(plVar16,pbVar19,uVar12);
uVar13 = local_3c;
lVar15 = local_50;
pbVar17 = local_68;
uVar12 = *puVar5;
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b270;
iVar7 = rtree_set_key_mbr(plVar16,lVar15,pbVar19 + uVar18,uVar13,uVar12);
uVar13 = local_3c;
plVar16 = local_48;
lVar15 = local_50;
puVar5 = local_58;
if (iVar7 == 0) {
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b295;
uVar8 = rtree_add_key(plVar16,lVar15,pbVar19 + uVar18,uVar13,pbVar17,puVar5);
plVar16 = local_48;
goto LAB_0018b1d8;
}
}
}
else if (iVar7 == 0) {
uVar11 = *(int8 *)(local_50 + 0x28);
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b185;
rtree_combine_rect(uVar11,pbVar14,uVar12,pbVar14,uVar6);
plVar16 = local_48;
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b19c;
iVar7 = _mi_write_keypage(plVar16,lVar15,param_5,3,pbVar17);
if (iVar7 == 0) {
uVar8 = 0;
goto LAB_0018b1e6;
}
}
}
}
}
else {
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b1c5;
uVar8 = rtree_add_key(plVar16,lVar15,uVar12,uVar6,pbVar17,puVar5);
LAB_0018b1d8:
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b1dd;
iVar7 = _mi_write_keypage(plVar16,lVar15,param_5,3,pbVar17);
if (iVar7 == 0) goto LAB_0018b1e6;
}
}
LAB_0018b1e1:
uVar8 = 0xffffffff;
LAB_0018b1e6:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar8;
}
/* WARNING: Subroutine does not return */
*(int8 *)((long)auStack_a0 + lVar4 + 0x10) = 0x18b2b3;
__stack_chk_fail();
}
| |
22,531 | cleanup_dirname | eloqsql/mysys/mf_pack.c | size_t cleanup_dirname(register char *to, const char *from)
{
reg5 size_t length;
reg2 char * pos;
reg3 char * from_ptr;
reg4 char * start;
char parent[5], /* for "FN_PARENTDIR" */
buff[FN_REFLEN + 1],*end_parentdir;
#ifdef BACKSLASH_MBTAIL
CHARSET_INFO *fs= fs_character_set();
#endif
DBUG_ENTER("cleanup_dirname");
DBUG_PRINT("enter",("from: '%s'",from));
start=buff;
from_ptr=(char *) from;
#ifdef FN_DEVCHAR
if ((pos=strrchr(from_ptr,FN_DEVCHAR)) != 0)
{ /* Skip device part */
length=(size_t) (pos-from_ptr)+1;
start=strnmov(buff,from_ptr,length); from_ptr+=length;
}
#endif
parent[0]=FN_LIBCHAR;
length=(size_t) (strmov(parent+1,FN_PARENTDIR)-parent);
for (pos=start ; (*pos= *from_ptr++) != 0 ; pos++)
{
#ifdef BACKSLASH_MBTAIL
uint l;
if (my_ci_use_mb(fs) && (l= my_ismbchar(fs, from_ptr - 1, from_ptr + 2)))
{
for (l-- ; l ; *++pos= *from_ptr++, l--);
start= pos + 1; /* Don't look inside multi-byte char */
continue;
}
#endif
if (*pos == '/')
*pos = FN_LIBCHAR;
if (*pos == FN_LIBCHAR)
{
if ((size_t) (pos-start) > length && memcmp(pos-length,parent,length) == 0)
{ /* If .../../; skip prev */
pos-=length;
if (pos != start)
{ /* not /../ */
pos--;
if (*pos == FN_HOMELIB && (pos == start || pos[-1] == FN_LIBCHAR))
{
if (!home_dir)
{
pos+=length+1; /* Don't unpack ~/.. */
continue;
}
pos=strmov(buff,home_dir)-1; /* Unpacks ~/.. */
if (*pos == FN_LIBCHAR)
pos--; /* home ended with '/' */
}
if (*pos == FN_CURLIB && (pos == start || pos[-1] == FN_LIBCHAR))
{
if (my_getwd(curr_dir,FN_REFLEN,MYF(0)))
{
pos+=length+1; /* Don't unpack ./.. */
continue;
}
pos=strmov(buff,curr_dir)-1; /* Unpacks ./.. */
if (*pos == FN_LIBCHAR)
pos--; /* home ended with '/' */
}
end_parentdir=pos;
while (pos >= start && *pos != FN_LIBCHAR) /* remove prev dir */
pos--;
if (pos[1] == FN_HOMELIB ||
(pos >= start && memcmp(pos, parent, length) == 0))
{ /* Don't remove ~user/ */
pos=strmov(end_parentdir+1,parent);
*pos=FN_LIBCHAR;
continue;
}
}
}
else if ((size_t) (pos-start) == length-1 &&
!memcmp(start,parent+1,length-1))
start=pos; /* Starts with "../" */
else if (pos-start > 0 && pos[-1] == FN_LIBCHAR)
{
#ifdef FN_NETWORK_DRIVES
if (pos-start != 1)
#endif
pos--; /* Remove dupplicate '/' */
}
else if (pos-start > 1 && pos[-1] == FN_CURLIB && pos[-2] == FN_LIBCHAR)
pos-=2; /* Skip /./ */
}
}
(void) strmov(to,buff);
DBUG_PRINT("exit",("to: '%s'",to));
DBUG_RETURN((size_t) (pos-buff));
} | O3 | c | cleanup_dirname:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, -0x248(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x35(%rbp), %r15
movb $0x2f, (%r15)
movw $0x2e2e, 0x1(%r15) # imm = 0x2E2E
movb $0x0, 0x3(%r15)
leaq -0x240(%rbp), %r12
movq %r12, %r13
movzbl (%r14), %eax
movb %al, (%r12)
cmpl $0x2f, %eax
je 0x9c4ba
testl %eax, %eax
jne 0x9c672
jmp 0x9c67d
movb $0x2f, (%r12)
movq %r12, %rax
subq %r13, %rax
cmpq $0x4, %rax
jb 0x9c591
movzwl -0x3(%r12), %ecx
xorw -0x35(%rbp), %cx
movb -0x1(%r12), %dl
xorb -0x33(%rbp), %dl
movzbl %dl, %edx
orw %cx, %dx
jne 0x9c5ae
leaq -0x3(%r12), %rax
cmpq %r13, %rax
je 0x9c5f5
leaq -0x4(%r12), %rbx
movb -0x4(%r12), %al
cmpb $0x7e, %al
jne 0x9c554
cmpq %r13, %rbx
je 0x9c51a
cmpb $0x2f, -0x5(%r12)
jne 0x9c619
leaq 0xb6d3b7(%rip), %rax # 0xc098d8
movq (%rax), %rsi
testq %rsi, %rsi
je 0x9c672
leaq -0x240(%rbp), %rdi
callq 0x29760
leaq -0x1(%rax), %rbx
leaq -0x2(%rax), %rcx
xorl %edx, %edx
cmpb $0x2f, -0x1(%rax)
sete %dl
notq %rdx
cmoveq %rcx, %rbx
movb (%rax,%rdx), %al
cmpb $0x2e, %al
jne 0x9c619
cmpq %r13, %rbx
leaq 0xb6d38a(%rip), %r12 # 0xc098f0
je 0x9c572
cmpb $0x2f, -0x1(%rbx)
jne 0x9c619
movl $0x200, %esi # imm = 0x200
movq %r12, %rdi
xorl %edx, %edx
callq 0x9fa54
testl %eax, %eax
je 0x9c5fa
addq $0x4, %rbx
movq %rbx, %r12
jmp 0x9c672
cmpq $0x2, %rax
jne 0x9c5ae
movzwl (%r13), %eax
cmpw -0x34(%rbp), %ax
je 0x9c5f0
movb -0x1(%r12), %cl
cmpb $0x2f, %cl
je 0x9c5c1
jmp 0x9c5d3
testq %rax, %rax
jle 0x9c672
movb -0x1(%r12), %cl
cmpb $0x2f, %cl
jne 0x9c5c9
decq %r12
jmp 0x9c672
cmpq $0x1, %rax
je 0x9c672
cmpb $0x2e, %cl
jne 0x9c672
leaq -0x2(%r12), %rax
cmpb $0x2f, -0x2(%r12)
cmoveq %rax, %r12
jmp 0x9c672
movq %r12, %r13
jmp 0x9c672
movq %rax, %r12
jmp 0x9c672
leaq -0x240(%rbp), %rdi
movq %r12, %rsi
callq 0x29760
leaq -0x1(%rax), %rbx
leaq -0x2(%rax), %rcx
cmpb $0x2f, -0x1(%rax)
cmoveq %rcx, %rbx
movq %rbx, %r12
cmpq %r13, %rbx
jb 0x9c633
movq %rbx, %r12
cmpb $0x2f, (%r12)
je 0x9c63d
decq %r12
cmpq %r13, %r12
jae 0x9c624
cmpb $0x7e, 0x1(%r12)
je 0x9c65e
jmp 0x9c672
cmpb $0x7e, 0x1(%r12)
je 0x9c65e
movzwl (%r12), %eax
xorw -0x35(%rbp), %ax
movb 0x2(%r12), %cl
xorb -0x33(%rbp), %cl
movzbl %cl, %ecx
orw %ax, %cx
jne 0x9c672
incq %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29760
movq %rax, %r12
movb $0x2f, (%rax)
incq %r14
incq %r12
jmp 0x9c4a0
leaq -0x240(%rbp), %rbx
movq -0x248(%rbp), %rdi
movq %rbx, %rsi
callq 0x29350
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x9c6ba
subq %rbx, %r12
movq %r12, %rax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29250
| cleanup_dirname:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 228h
mov r14, rsi
mov [rbp+var_248], rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r15, [rbp+var_35]
mov byte ptr [r15], 2Fh ; '/'
mov word ptr [r15+1], 2E2Eh
mov byte ptr [r15+3], 0
lea r12, [rbp+var_240]
mov r13, r12
loc_9C4A0:
movzx eax, byte ptr [r14]
mov [r12], al
cmp eax, 2Fh ; '/'
jz short loc_9C4BA
test eax, eax
jnz loc_9C672
jmp loc_9C67D
loc_9C4BA:
mov byte ptr [r12], 2Fh ; '/'
mov rax, r12
sub rax, r13
cmp rax, 4
jb loc_9C591
movzx ecx, word ptr [r12-3]
xor cx, [rbp+var_35]
mov dl, [r12-1]
xor dl, [rbp+var_33]
movzx edx, dl
or dx, cx
jnz loc_9C5AE
lea rax, [r12-3]
cmp rax, r13
jz loc_9C5F5
lea rbx, [r12-4]
mov al, [r12-4]
cmp al, 7Eh ; '~'
jnz short loc_9C554
cmp rbx, r13
jz short loc_9C51A
cmp byte ptr [r12-5], 2Fh ; '/'
jnz loc_9C619
loc_9C51A:
lea rax, home_dir
mov rsi, [rax]
test rsi, rsi
jz loc_9C672
lea rdi, [rbp+var_240]
call _stpcpy
lea rbx, [rax-1]
lea rcx, [rax-2]
xor edx, edx
cmp byte ptr [rax-1], 2Fh ; '/'
setz dl
not rdx
cmovz rbx, rcx
mov al, [rax+rdx]
loc_9C554:
cmp al, 2Eh ; '.'
jnz loc_9C619
cmp rbx, r13
lea r12, curr_dir
jz short loc_9C572
cmp byte ptr [rbx-1], 2Fh ; '/'
jnz loc_9C619
loc_9C572:
mov esi, 200h
mov rdi, r12
xor edx, edx
call my_getwd
test eax, eax
jz short loc_9C5FA
add rbx, 4
mov r12, rbx
jmp loc_9C672
loc_9C591:
cmp rax, 2
jnz short loc_9C5AE
movzx eax, word ptr [r13+0]
cmp ax, [rbp+var_35+1]
jz short loc_9C5F0
mov cl, [r12-1]
cmp cl, 2Fh ; '/'
jz short loc_9C5C1
jmp short loc_9C5D3
loc_9C5AE:
test rax, rax
jle loc_9C672
mov cl, [r12-1]
cmp cl, 2Fh ; '/'
jnz short loc_9C5C9
loc_9C5C1:
dec r12
jmp loc_9C672
loc_9C5C9:
cmp rax, 1
jz loc_9C672
loc_9C5D3:
cmp cl, 2Eh ; '.'
jnz loc_9C672
lea rax, [r12-2]
cmp byte ptr [r12-2], 2Fh ; '/'
cmovz r12, rax
jmp loc_9C672
loc_9C5F0:
mov r13, r12
jmp short loc_9C672
loc_9C5F5:
mov r12, rax
jmp short loc_9C672
loc_9C5FA:
lea rdi, [rbp+var_240]
mov rsi, r12
call _stpcpy
lea rbx, [rax-1]
lea rcx, [rax-2]
cmp byte ptr [rax-1], 2Fh ; '/'
cmovz rbx, rcx
loc_9C619:
mov r12, rbx
cmp rbx, r13
jb short loc_9C633
mov r12, rbx
loc_9C624:
cmp byte ptr [r12], 2Fh ; '/'
jz short loc_9C63D
dec r12
cmp r12, r13
jnb short loc_9C624
loc_9C633:
cmp byte ptr [r12+1], 7Eh ; '~'
jz short loc_9C65E
jmp short loc_9C672
loc_9C63D:
cmp byte ptr [r12+1], 7Eh ; '~'
jz short loc_9C65E
movzx eax, word ptr [r12]
xor ax, [rbp+var_35]
mov cl, [r12+2]
xor cl, [rbp+var_33]
movzx ecx, cl
or cx, ax
jnz short loc_9C672
loc_9C65E:
inc rbx
mov rdi, rbx
mov rsi, r15
call _stpcpy
mov r12, rax
mov byte ptr [rax], 2Fh ; '/'
loc_9C672:
inc r14
inc r12
jmp loc_9C4A0
loc_9C67D:
lea rbx, [rbp+var_240]
mov rdi, [rbp+var_248]
mov rsi, rbx
call _strcpy
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_9C6BA
sub r12, rbx
mov rax, r12
add rsp, 228h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9C6BA:
call ___stack_chk_fail
| long long cleanup_dirname(long long a1, unsigned __int8 *a2)
{
_BYTE *v3; // r12
_WORD *v4; // r13
int v5; // eax
long long v6; // rax
_BYTE *v7; // rbx
char v8; // al
long long v9; // rax
char v10; // cl
long long v11; // rax
long long v13; // [rsp+8h] [rbp-248h]
_BYTE v14[523]; // [rsp+10h] [rbp-240h] BYREF
char v15[5]; // [rsp+21Bh] [rbp-35h] BYREF
unsigned long long v16; // [rsp+220h] [rbp-30h]
v13 = a1;
v16 = __readfsqword(0x28u);
strcpy(v15, "/..");
v3 = v14;
v4 = v14;
while ( 1 )
{
v5 = *a2;
*v3 = v5;
if ( v5 != 47 )
break;
*v3 = 47;
v6 = v3 - (_BYTE *)v4;
if ( (unsigned long long)(v3 - (_BYTE *)v4) < 4 )
{
if ( v6 == 2 )
{
if ( *v4 == *(_WORD *)&v15[1] )
{
v4 = v3;
goto LABEL_45;
}
v10 = *(v3 - 1);
if ( v10 == 47 )
goto LABEL_26;
LABEL_28:
if ( v10 == 46 && *(v3 - 2) == 47 )
v3 -= 2;
goto LABEL_45;
}
}
else if ( !((unsigned __int16)(*(_WORD *)v15 ^ *(_WORD *)(v3 - 3)) | (unsigned __int8)(v15[2] ^ *(v3 - 1))) )
{
if ( v3 - 3 == (_BYTE *)v4 )
{
v3 -= 3;
goto LABEL_45;
}
v7 = v3 - 4;
v8 = *(v3 - 4);
if ( v8 == 126 )
{
if ( v7 == (_BYTE *)v4 || *(v3 - 5) == 47 )
{
if ( !home_dir )
goto LABEL_45;
v9 = stpcpy(v14, home_dir);
v7 = (_BYTE *)(v9 - 1);
if ( *(_BYTE *)(v9 - 1) == 47 )
v7 = (_BYTE *)(v9 - 2);
v8 = *(_BYTE *)(v9 + ~(unsigned long long)(*(_BYTE *)(v9 - 1) == 47));
goto LABEL_15;
}
}
else
{
LABEL_15:
if ( v8 == 46 && (v7 == (_BYTE *)v4 || *(v7 - 1) == 47) )
{
if ( (unsigned int)my_getwd(&curr_dir, 512LL, 0LL) )
{
v3 = v7 + 4;
goto LABEL_45;
}
v11 = stpcpy(v14, &curr_dir);
v7 = (_BYTE *)(v11 - 1);
if ( *(_BYTE *)(v11 - 1) == 47 )
v7 = (_BYTE *)(v11 - 2);
}
}
v3 = v7;
if ( v7 < (_BYTE *)v4 )
{
LABEL_40:
if ( v3[1] == 126 )
goto LABEL_44;
}
else
{
v3 = v7;
while ( *v3 != 47 )
{
if ( --v3 < (_BYTE *)v4 )
goto LABEL_40;
}
if ( v3[1] == 126 || !((unsigned __int16)(*(_WORD *)v15 ^ *(_WORD *)v3) | (unsigned __int8)(v15[2] ^ v3[2])) )
{
LABEL_44:
v3 = (_BYTE *)stpcpy(v7 + 1, v15);
*v3 = 47;
goto LABEL_45;
}
}
goto LABEL_45;
}
if ( v6 <= 0 )
goto LABEL_45;
v10 = *(v3 - 1);
if ( v10 == 47 )
{
LABEL_26:
--v3;
goto LABEL_45;
}
if ( v6 != 1 )
goto LABEL_28;
LABEL_45:
++a2;
++v3;
}
if ( v5 )
goto LABEL_45;
strcpy(v13, v14);
return v3 - v14;
}
| cleanup_dirname:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x228
MOV R14,RSI
MOV qword ptr [RBP + -0x248],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[RBP + -0x35]
MOV byte ptr [R15],0x2f
MOV word ptr [R15 + 0x1],0x2e2e
MOV byte ptr [R15 + 0x3],0x0
LEA R12,[RBP + -0x240]
MOV R13,R12
LAB_0019c4a0:
MOVZX EAX,byte ptr [R14]
MOV byte ptr [R12],AL
CMP EAX,0x2f
JZ 0x0019c4ba
TEST EAX,EAX
JNZ 0x0019c672
JMP 0x0019c67d
LAB_0019c4ba:
MOV byte ptr [R12],0x2f
MOV RAX,R12
SUB RAX,R13
CMP RAX,0x4
JC 0x0019c591
MOVZX ECX,word ptr [R12 + -0x3]
XOR CX,word ptr [RBP + -0x35]
MOV DL,byte ptr [R12 + -0x1]
XOR DL,byte ptr [RBP + -0x33]
MOVZX EDX,DL
OR DX,CX
JNZ 0x0019c5ae
LEA RAX,[R12 + -0x3]
CMP RAX,R13
JZ 0x0019c5f5
LEA RBX,[R12 + -0x4]
MOV AL,byte ptr [R12 + -0x4]
CMP AL,0x7e
JNZ 0x0019c554
CMP RBX,R13
JZ 0x0019c51a
CMP byte ptr [R12 + -0x5],0x2f
JNZ 0x0019c619
LAB_0019c51a:
LEA RAX,[0xd098d8]
MOV RSI,qword ptr [RAX]
TEST RSI,RSI
JZ 0x0019c672
LEA RDI,[RBP + -0x240]
CALL 0x00129760
LEA RBX,[RAX + -0x1]
LEA RCX,[RAX + -0x2]
XOR EDX,EDX
CMP byte ptr [RAX + -0x1],0x2f
SETZ DL
NOT RDX
CMOVZ RBX,RCX
MOV AL,byte ptr [RAX + RDX*0x1]
LAB_0019c554:
CMP AL,0x2e
JNZ 0x0019c619
CMP RBX,R13
LEA R12,[0xd098f0]
JZ 0x0019c572
CMP byte ptr [RBX + -0x1],0x2f
JNZ 0x0019c619
LAB_0019c572:
MOV ESI,0x200
MOV RDI,R12
XOR EDX,EDX
CALL 0x0019fa54
TEST EAX,EAX
JZ 0x0019c5fa
ADD RBX,0x4
MOV R12,RBX
JMP 0x0019c672
LAB_0019c591:
CMP RAX,0x2
JNZ 0x0019c5ae
MOVZX EAX,word ptr [R13]
CMP AX,word ptr [RBP + -0x34]
JZ 0x0019c5f0
MOV CL,byte ptr [R12 + -0x1]
CMP CL,0x2f
JZ 0x0019c5c1
JMP 0x0019c5d3
LAB_0019c5ae:
TEST RAX,RAX
JLE 0x0019c672
MOV CL,byte ptr [R12 + -0x1]
CMP CL,0x2f
JNZ 0x0019c5c9
LAB_0019c5c1:
DEC R12
JMP 0x0019c672
LAB_0019c5c9:
CMP RAX,0x1
JZ 0x0019c672
LAB_0019c5d3:
CMP CL,0x2e
JNZ 0x0019c672
LEA RAX,[R12 + -0x2]
CMP byte ptr [R12 + -0x2],0x2f
CMOVZ R12,RAX
JMP 0x0019c672
LAB_0019c5f0:
MOV R13,R12
JMP 0x0019c672
LAB_0019c5f5:
MOV R12,RAX
JMP 0x0019c672
LAB_0019c5fa:
LEA RDI,[RBP + -0x240]
MOV RSI,R12
CALL 0x00129760
LEA RBX,[RAX + -0x1]
LEA RCX,[RAX + -0x2]
CMP byte ptr [RAX + -0x1],0x2f
CMOVZ RBX,RCX
LAB_0019c619:
MOV R12,RBX
CMP RBX,R13
JC 0x0019c633
MOV R12,RBX
LAB_0019c624:
CMP byte ptr [R12],0x2f
JZ 0x0019c63d
DEC R12
CMP R12,R13
JNC 0x0019c624
LAB_0019c633:
CMP byte ptr [R12 + 0x1],0x7e
JZ 0x0019c65e
JMP 0x0019c672
LAB_0019c63d:
CMP byte ptr [R12 + 0x1],0x7e
JZ 0x0019c65e
MOVZX EAX,word ptr [R12]
XOR AX,word ptr [RBP + -0x35]
MOV CL,byte ptr [R12 + 0x2]
XOR CL,byte ptr [RBP + -0x33]
MOVZX ECX,CL
OR CX,AX
JNZ 0x0019c672
LAB_0019c65e:
INC RBX
MOV RDI,RBX
MOV RSI,R15
CALL 0x00129760
MOV R12,RAX
MOV byte ptr [RAX],0x2f
LAB_0019c672:
INC R14
INC R12
JMP 0x0019c4a0
LAB_0019c67d:
LEA RBX,[RBP + -0x240]
MOV RDI,qword ptr [RBP + -0x248]
MOV RSI,RBX
CALL 0x00129350
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0019c6ba
SUB R12,RBX
MOV RAX,R12
ADD RSP,0x228
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019c6ba:
CALL 0x00129250
|
long cleanup_dirname(char *param_1,char *param_2)
{
char cVar1;
int iVar2;
ulong uVar3;
char *pcVar4;
short *psVar5;
short *psVar6;
short *psVar7;
short *psVar8;
short *psVar9;
long in_FS_OFFSET;
short local_248 [261];
int1 local_3d [2];
char cStack_3b;
int1 local_3a;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
_local_3d = 0x2e2e2f;
local_3a = 0;
psVar7 = local_248;
psVar8 = psVar7;
do {
cVar1 = *param_2;
*(char *)psVar7 = cVar1;
psVar5 = psVar7;
psVar9 = psVar8;
if (cVar1 == '/') {
*(char *)psVar7 = '/';
uVar3 = (long)psVar7 - (long)psVar8;
if (uVar3 < 4) {
if (uVar3 != 2) goto LAB_0019c5ae;
psVar9 = psVar7;
if (*psVar8 == stack0xffffffffffffffc4) goto LAB_0019c672;
cVar1 = *(char *)((long)psVar7 + -1);
if (cVar1 == '/') goto LAB_0019c5c1;
LAB_0019c5d3:
psVar9 = psVar8;
if ((cVar1 == '.') && ((char)psVar7[-1] == '/')) {
psVar5 = psVar7 + -1;
}
}
else if (*(char *)((long)psVar7 + -1) == cStack_3b &&
(int1 [2])*(short *)((long)psVar7 + -3) == local_3d) {
psVar5 = (short *)((long)psVar7 + -3);
if (psVar5 == psVar8) goto LAB_0019c672;
psVar5 = psVar7 + -2;
cVar1 = (char)psVar7[-2];
if (cVar1 == '~') {
if ((psVar5 == psVar8) || (psVar6 = psVar5, *(char *)((long)psVar7 + -5) == '/')) {
psVar5 = psVar7;
if (home_dir == (char *)0x0) goto LAB_0019c672;
pcVar4 = stpcpy((char *)local_248,home_dir);
psVar5 = (short *)(pcVar4 + -1);
if (pcVar4[-1] == '/') {
psVar5 = (short *)(pcVar4 + -2);
}
cVar1 = pcVar4[~(ulong)(pcVar4[-1] == '/')];
goto LAB_0019c554;
}
}
else {
LAB_0019c554:
psVar6 = psVar5;
if ((cVar1 == '.') && ((psVar5 == psVar8 || (*(char *)((long)psVar5 + -1) == '/')))) {
iVar2 = my_getwd(&curr_dir,0x200,0);
if (iVar2 != 0) {
psVar5 = psVar5 + 2;
goto LAB_0019c672;
}
pcVar4 = stpcpy((char *)local_248,&curr_dir);
psVar5 = (short *)(pcVar4 + -1);
psVar6 = (short *)(pcVar4 + -1);
if (pcVar4[-1] == '/') {
psVar5 = (short *)(pcVar4 + -2);
psVar6 = (short *)(pcVar4 + -2);
}
}
}
for (; psVar8 <= psVar5; psVar5 = (short *)((long)psVar5 + -1)) {
if ((char)*psVar5 == '/') {
if (*(char *)((long)psVar5 + 1) == '~') goto LAB_0019c65e;
if ((char)psVar5[1] != cStack_3b || (int1 [2])*psVar5 != local_3d)
goto LAB_0019c672;
goto LAB_0019c65e;
}
}
if (*(char *)((long)psVar5 + 1) == '~') {
LAB_0019c65e:
psVar5 = (short *)stpcpy((char *)((long)psVar6 + 1),local_3d);
*(int1 *)psVar5 = 0x2f;
}
}
else {
LAB_0019c5ae:
if (0 < (long)uVar3) {
cVar1 = *(char *)((long)psVar7 + -1);
if (cVar1 == '/') {
LAB_0019c5c1:
psVar5 = (short *)((long)psVar7 + -1);
psVar9 = psVar8;
}
else if (uVar3 != 1) goto LAB_0019c5d3;
}
}
}
else if (cVar1 == '\0') {
strcpy(param_1,(char *)local_248);
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)psVar7 - (long)local_248;
}
LAB_0019c672:
param_2 = param_2 + 1;
psVar7 = (short *)((long)psVar5 + 1);
psVar8 = psVar9;
} while( true );
}
| |
22,532 | my_fstat | eloqsql/mysys/my_lib.c | int my_fstat(File Filedes, MY_STAT *stat_area,
myf MyFlags __attribute__((unused)))
{
DBUG_ENTER("my_fstat");
DBUG_PRINT("my",("fd: %d MyFlags: %lu", Filedes, MyFlags));
#ifdef _WIN32
DBUG_RETURN(my_win_fstat(Filedes, stat_area));
#elif defined HAVE_valgrind
{
int s= fstat(Filedes, stat_area);
if (!s)
MSAN_STAT_WORKAROUND(stat_area);
DBUG_RETURN(s);
}
#else
DBUG_RETURN(fstat(Filedes, (struct stat *) stat_area));
#endif
} | O3 | c | my_fstat:
pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x24510
nopl (%rax)
| my_fstat:
push rbp
mov rbp, rsp
pop rbp
jmp _fstat64
| long long my_fstat()
{
return fstat64();
}
| my_fstat:
PUSH RBP
MOV RBP,RSP
POP RBP
JMP 0x00124510
|
void my_fstat(int param_1,stat64 *param_2)
{
fstat64(param_1,param_2);
return;
}
| |
22,533 | mysql_stmt_attr_get | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | my_bool STDCALL mysql_stmt_attr_get(MYSQL_STMT *stmt, enum enum_stmt_attr_type attr_type, void *value)
{
switch (attr_type) {
case STMT_ATTR_STATE:
*(enum mysql_stmt_state *)value= stmt->state;
break;
case STMT_ATTR_UPDATE_MAX_LENGTH:
*(my_bool *)value= stmt->update_max_length;
break;
case STMT_ATTR_CURSOR_TYPE:
*(unsigned long *)value= stmt->flags;
break;
case STMT_ATTR_PREFETCH_ROWS:
*(unsigned long *)value= stmt->prefetch_rows;
break;
case STMT_ATTR_PREBIND_PARAMS:
*(unsigned int *)value= stmt->prebind_params;
break;
case STMT_ATTR_ARRAY_SIZE:
*(unsigned int *)value= stmt->array_size;
break;
case STMT_ATTR_ROW_SIZE:
*(size_t *)value= stmt->row_size;
break;
case STMT_ATTR_CB_USER_DATA:
*((void **)value) = stmt->user_data;
break;
default:
return(1);
}
return(0);
} | O3 | c | mysql_stmt_attr_get:
pushq %rbp
movq %rsp, %rbp
movb $0x1, %al
cmpl $0xc7, %esi
jle 0x22679
addl $0xffffff38, %esi # imm = 0xFFFFFF38
cmpl $0x4, %esi
ja 0x226c4
leaq 0x1847c(%rip), %rax # 0x3aae4
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x378(%rdi), %eax
jmp 0x226c0
testl %esi, %esi
je 0x22690
cmpl $0x1, %esi
je 0x226ac
cmpl $0x2, %esi
jne 0x226c4
movq 0x318(%rdi), %rax
jmp 0x226b0
movb 0x313(%rdi), %al
movb %al, (%rdx)
jmp 0x226c2
movq 0x380(%rdi), %rax
jmp 0x226b0
movq 0x370(%rdi), %rax
jmp 0x226b0
movq 0x48(%rdi), %rax
movq %rax, (%rdx)
jmp 0x226c2
movl 0x50(%rdi), %eax
jmp 0x226c0
movl 0x368(%rdi), %eax
movl %eax, (%rdx)
xorl %eax, %eax
popq %rbp
retq
| mysql_stmt_attr_get:
push rbp
mov rbp, rsp
mov al, 1
cmp esi, 0C7h
jle short loc_22679
add esi, 0FFFFFF38h; switch 5 cases
cmp esi, 4
ja short def_2266F; jumptable 000000000002266F default case
lea rax, jpt_2266F
movsxd rcx, ds:(jpt_2266F - 3AAE4h)[rax+rsi*4]
add rcx, rax
jmp rcx; switch jump
loc_22671:
mov eax, [rdi+378h]; jumptable 000000000002266F case 200
jmp short loc_226C0
loc_22679:
test esi, esi
jz short loc_22690
cmp esi, 1
jz short loc_226AC
cmp esi, 2
jnz short def_2266F; jumptable 000000000002266F default case
mov rax, [rdi+318h]
jmp short loc_226B0
loc_22690:
mov al, [rdi+313h]
mov [rdx], al
jmp short loc_226C2
loc_2269A:
mov rax, [rdi+380h]; jumptable 000000000002266F case 204
jmp short loc_226B0
loc_226A3:
mov rax, [rdi+370h]; jumptable 000000000002266F case 202
jmp short loc_226B0
loc_226AC:
mov rax, [rdi+48h]
loc_226B0:
mov [rdx], rax
jmp short loc_226C2
loc_226B5:
mov eax, [rdi+50h]; jumptable 000000000002266F case 203
jmp short loc_226C0
loc_226BA:
mov eax, [rdi+368h]; jumptable 000000000002266F case 201
loc_226C0:
mov [rdx], eax
loc_226C2:
xor eax, eax
def_2266F:
pop rbp; jumptable 000000000002266F default case
retn
| char mysql_stmt_attr_get(long long a1, int a2, _DWORD *a3)
{
char result; // al
int v4; // eax
long long v5; // rax
result = 1;
if ( a2 > 199 )
{
switch ( a2 )
{
case 200:
v4 = *(_DWORD *)(a1 + 888);
goto LABEL_15;
case 201:
v4 = *(_DWORD *)(a1 + 872);
goto LABEL_15;
case 202:
v5 = *(_QWORD *)(a1 + 880);
goto LABEL_12;
case 203:
v4 = *(_DWORD *)(a1 + 80);
LABEL_15:
*a3 = v4;
return 0;
case 204:
v5 = *(_QWORD *)(a1 + 896);
goto LABEL_12;
default:
return result;
}
}
if ( a2 )
{
if ( a2 == 1 )
{
v5 = *(_QWORD *)(a1 + 72);
}
else
{
if ( a2 != 2 )
return result;
v5 = *(_QWORD *)(a1 + 792);
}
LABEL_12:
*(_QWORD *)a3 = v5;
}
else
{
*(_BYTE *)a3 = *(_BYTE *)(a1 + 787);
}
return 0;
}
| mysql_stmt_attr_get:
PUSH RBP
MOV RBP,RSP
MOV AL,0x1
CMP ESI,0xc7
JLE 0x00122679
ADD ESI,0xffffff38
CMP ESI,0x4
JA 0x001226c4
LEA RAX,[0x13aae4]
MOVSXD RCX,dword ptr [RAX + RSI*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_c8:
MOV EAX,dword ptr [RDI + 0x378]
JMP 0x001226c0
LAB_00122679:
TEST ESI,ESI
JZ 0x00122690
CMP ESI,0x1
JZ 0x001226ac
CMP ESI,0x2
JNZ 0x001226c4
MOV RAX,qword ptr [RDI + 0x318]
JMP 0x001226b0
LAB_00122690:
MOV AL,byte ptr [RDI + 0x313]
MOV byte ptr [RDX],AL
JMP 0x001226c2
caseD_cc:
MOV RAX,qword ptr [RDI + 0x380]
JMP 0x001226b0
caseD_ca:
MOV RAX,qword ptr [RDI + 0x370]
JMP 0x001226b0
LAB_001226ac:
MOV RAX,qword ptr [RDI + 0x48]
LAB_001226b0:
MOV qword ptr [RDX],RAX
JMP 0x001226c2
caseD_cb:
MOV EAX,dword ptr [RDI + 0x50]
JMP 0x001226c0
caseD_c9:
MOV EAX,dword ptr [RDI + 0x368]
LAB_001226c0:
MOV dword ptr [RDX],EAX
LAB_001226c2:
XOR EAX,EAX
default:
POP RBP
RET
|
int8 mysql_stmt_attr_get(long param_1,int param_2,int8 *param_3)
{
int4 uVar1;
int8 uVar2;
uVar2 = 1;
if (param_2 < 200) {
if (param_2 != 0) {
if (param_2 == 1) {
uVar2 = *(int8 *)(param_1 + 0x48);
}
else {
if (param_2 != 2) {
return 1;
}
uVar2 = *(int8 *)(param_1 + 0x318);
}
goto LAB_001226b0;
}
*(int1 *)param_3 = *(int1 *)(param_1 + 0x313);
goto LAB_001226c2;
}
switch(param_2) {
case 200:
uVar1 = *(int4 *)(param_1 + 0x378);
break;
case 0xc9:
uVar1 = *(int4 *)(param_1 + 0x368);
break;
case 0xca:
uVar2 = *(int8 *)(param_1 + 0x370);
goto LAB_001226b0;
case 0xcb:
uVar1 = *(int4 *)(param_1 + 0x50);
break;
case 0xcc:
uVar2 = *(int8 *)(param_1 + 0x380);
LAB_001226b0:
*param_3 = uVar2;
goto LAB_001226c2;
default:
goto switchD_0012266f_default;
}
*(int4 *)param_3 = uVar1;
LAB_001226c2:
uVar2 = 0;
switchD_0012266f_default:
return uVar2;
}
| |
22,534 | JS_CreateAsyncFromSyncIterator | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_CreateAsyncFromSyncIterator(JSContext *ctx,
JSValue sync_iter)
{
JSValue async_iter, next_method;
JSAsyncFromSyncIteratorData *s;
next_method = JS_GetProperty(ctx, sync_iter, JS_ATOM_next);
if (JS_IsException(next_method))
return JS_EXCEPTION;
async_iter = JS_NewObjectClass(ctx, JS_CLASS_ASYNC_FROM_SYNC_ITERATOR);
if (JS_IsException(async_iter)) {
JS_FreeValue(ctx, next_method);
return async_iter;
}
s = js_mallocz(ctx, sizeof(*s));
if (!s) {
JS_FreeValue(ctx, async_iter);
JS_FreeValue(ctx, next_method);
return JS_EXCEPTION;
}
s->sync_iter = js_dup(sync_iter);
s->next_method = next_method;
JS_SetOpaqueInternal(async_iter, s);
return async_iter;
} | O0 | c | JS_CreateAsyncFromSyncIterator:
subq $0x88, %rsp
movq %rsi, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movl $0x6b, %ecx
callq 0x30070
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x7503a
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0x75181
movq 0x60(%rsp), %rdi
movl $0x37, %esi
callq 0x30770
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x750ab
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x29f80
movq 0x50(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x75181
movq 0x60(%rsp), %rdi
movl $0x20, %esi
callq 0x28020
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x75105
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x29f80
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x29f80
movl $0x0, 0x78(%rsp)
movq $0x6, 0x80(%rsp)
jmp 0x75181
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x279c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rdx
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x30c90
movq 0x50(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq 0x80(%rsp), %rdx
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_CreateAsyncFromSyncIterator:
sub rsp, 88h
mov [rsp+88h+var_20], rsi
mov [rsp+88h+var_18], rdx
mov [rsp+88h+var_28], rdi
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_20]
mov rdx, [rsp+88h+var_18]
mov ecx, 6Bh ; 'k'
call JS_GetProperty
mov [rsp+88h+var_60], rax
mov [rsp+88h+var_58], rdx
mov rax, [rsp+88h+var_60]
mov [rsp+88h+var_48], rax
mov rax, [rsp+88h+var_58]
mov [rsp+88h+var_40], rax
mov rdi, [rsp+88h+var_48]
mov rsi, [rsp+88h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_7503A
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp loc_75181
loc_7503A:
mov rdi, [rsp+88h+var_28]
mov esi, 37h ; '7'
call JS_NewObjectClass
mov [rsp+88h+var_70], rax
mov [rsp+88h+var_68], rdx
mov rax, [rsp+88h+var_70]
mov [rsp+88h+var_38], rax
mov rax, [rsp+88h+var_68]
mov [rsp+88h+var_30], rax
mov rdi, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_750AB
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_48]
mov rdx, [rsp+88h+var_40]
call JS_FreeValue
mov rax, [rsp+88h+var_38]
mov [rsp+88h+var_10], rax
mov rax, [rsp+88h+var_30]
mov [rsp+88h+var_8], rax
jmp loc_75181
loc_750AB:
mov rdi, [rsp+88h+var_28]
mov esi, 20h ; ' '
call js_mallocz
mov [rsp+88h+var_50], rax
cmp [rsp+88h+var_50], 0
jnz short loc_75105
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_38]
mov rdx, [rsp+88h+var_30]
call JS_FreeValue
mov rdi, [rsp+88h+var_28]
mov rsi, [rsp+88h+var_48]
mov rdx, [rsp+88h+var_40]
call JS_FreeValue
mov dword ptr [rsp+88h+var_10], 0
mov [rsp+88h+var_8], 6
jmp short loc_75181
loc_75105:
mov rax, [rsp+88h+var_50]
mov [rsp+88h+var_88], rax
mov rdi, [rsp+88h+var_20]
mov rsi, [rsp+88h+var_18]
call js_dup
mov rcx, rax
mov rax, [rsp+88h+var_88]
mov [rsp+88h+var_80], rcx
mov [rsp+88h+var_78], rdx
mov rcx, [rsp+88h+var_80]
mov [rax], rcx
mov rcx, [rsp+88h+var_78]
mov [rax+8], rcx
mov rax, [rsp+88h+var_50]
mov rcx, [rsp+88h+var_48]
mov [rax+10h], rcx
mov rcx, [rsp+88h+var_40]
mov [rax+18h], rcx
mov rdx, [rsp+88h+var_50]
mov rdi, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_30]
call JS_SetOpaqueInternal
mov rax, [rsp+88h+var_38]
mov [rsp+88h+var_10], rax
mov rax, [rsp+88h+var_30]
mov [rsp+88h+var_8], rax
loc_75181:
mov rax, [rsp+88h+var_10]
mov rdx, [rsp+88h+var_8]
add rsp, 88h
retn
| long long JS_CreateAsyncFromSyncIterator(long long a1, _DWORD *a2, unsigned int a3)
{
long long v3; // rdx
long long v4; // rdx
long long v5; // rdx
long long v7; // [rsp+18h] [rbp-70h]
long long Property; // [rsp+28h] [rbp-60h]
_QWORD *v9; // [rsp+38h] [rbp-50h]
long long v10; // [rsp+48h] [rbp-40h]
long long v11; // [rsp+58h] [rbp-30h]
long long v13; // [rsp+78h] [rbp-10h]
Property = JS_GetProperty(a1, (int)a2, a3, 107);
v10 = v3;
if ( JS_IsException_1(Property, v3) )
{
LODWORD(v13) = 0;
}
else
{
v7 = JS_NewObjectClass(a1, 55);
v11 = v4;
if ( JS_IsException_1(v7, v4) )
{
JS_FreeValue(a1, Property, v10);
return v7;
}
else
{
v9 = (_QWORD *)js_mallocz(a1, 0x20uLL);
if ( v9 )
{
*v9 = js_dup(a2, a3);
v9[1] = v5;
v9[2] = Property;
v9[3] = v10;
JS_SetOpaqueInternal(v7, v11, (long long)v9);
return v7;
}
else
{
JS_FreeValue(a1, v7, v11);
JS_FreeValue(a1, Property, v10);
LODWORD(v13) = 0;
}
}
}
return v13;
}
| JS_CreateAsyncFromSyncIterator:
SUB RSP,0x88
MOV qword ptr [RSP + 0x68],RSI
MOV qword ptr [RSP + 0x70],RDX
MOV qword ptr [RSP + 0x60],RDI
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
MOV ECX,0x6b
CALL 0x00130070
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x0017503a
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x00175181
LAB_0017503a:
MOV RDI,qword ptr [RSP + 0x60]
MOV ESI,0x37
CALL 0x00130770
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001750ab
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00129f80
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x80],RAX
JMP 0x00175181
LAB_001750ab:
MOV RDI,qword ptr [RSP + 0x60]
MOV ESI,0x20
CALL 0x00128020
MOV qword ptr [RSP + 0x38],RAX
CMP qword ptr [RSP + 0x38],0x0
JNZ 0x00175105
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00129f80
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x6
JMP 0x00175181
LAB_00175105:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x70]
CALL 0x001279c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP + 0x10],RDX
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x18],RCX
MOV RDX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00130c90
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x80],RAX
LAB_00175181:
MOV RAX,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
ADD RSP,0x88
RET
|
int1 [16]
JS_CreateAsyncFromSyncIterator(int8 param_1,int8 param_2,int8 param_3)
{
int4 uVar1;
int iVar2;
int8 uVar4;
int1 (*pauVar5) [16];
int1 auVar7 [16];
int1 auVar8 [16];
int4 local_10;
int4 uStack_c;
int8 local_8;
int8 uVar3;
int8 uVar6;
uVar1 = uStack_c;
auVar7 = JS_GetProperty(param_1,param_2,param_3,0x6b);
uVar6 = auVar7._8_8_;
uVar3 = auVar7._0_8_;
iVar2 = JS_IsException(uVar3,uVar6);
if (iVar2 == 0) {
auVar8 = JS_NewObjectClass(param_1,0x37);
local_8 = auVar8._8_8_;
uVar4 = auVar8._0_8_;
iVar2 = JS_IsException(uVar4,local_8);
local_10 = auVar8._0_4_;
uStack_c = auVar8._4_4_;
if (iVar2 == 0) {
pauVar5 = (int1 (*) [16])js_mallocz(param_1,0x20);
if (pauVar5 == (int1 (*) [16])0x0) {
JS_FreeValue(param_1,uVar4,local_8);
JS_FreeValue(param_1,uVar3,uVar6);
local_10 = 0;
local_8 = 6;
uStack_c = uVar1;
}
else {
auVar8 = js_dup(param_2,param_3);
*pauVar5 = auVar8;
pauVar5[1] = auVar7;
JS_SetOpaqueInternal(uVar4,local_8,pauVar5);
}
}
else {
JS_FreeValue(param_1,uVar3,uVar6);
}
}
else {
local_10 = 0;
local_8 = 6;
uStack_c = uVar1;
}
auVar7._4_4_ = uStack_c;
auVar7._0_4_ = local_10;
auVar7._8_8_ = local_8;
return auVar7;
}
| |
22,535 | minja::Value::to_bool() const | llama.cpp/common/minja/minja.hpp | bool to_bool() const {
if (is_null()) return false;
if (is_boolean()) return get<bool>();
if (is_number()) return get<double>() != 0;
if (is_string()) return !get<std::string>().empty();
if (is_array()) return !empty();
return true;
} | O3 | cpp | minja::Value::to_bool() const:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
cmpq $0x0, 0x20(%rdi)
movq 0x10(%rdi), %rax
movb 0x40(%rdi), %cl
jne 0xbf08c
testq %rax, %rax
jne 0xbf08c
testb %cl, %cl
jne 0xbf08c
cmpq $0x0, 0x30(%rsi)
jne 0xbf08c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cmpb $0x4, %cl
jne 0xbf0a0
movq %rsi, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0xbf118
leal -0x5(%rcx), %edx
cmpb $0x2, %dl
ja 0xbf0c3
movq %rsi, %rdi
callq 0xbf228
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %rbx
andl $0x1, %ebx
jmp 0xbf082
cmpb $0x3, %cl
jne 0xbf0f9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xbf33e
cmpq $0x0, 0x8(%r14)
setne %bl
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xbf082
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20180
jmp 0xbf082
testq %rax, %rax
je 0xbf110
movq %rsi, %rdi
callq 0xbf448
movl %eax, %ebx
xorb $0x1, %bl
jmp 0xbf082
movb $0x1, %bl
jmp 0xbf082
nop
| _ZNK5minja5Value7to_boolEv:
push r14
push rbx
sub rsp, 28h
mov rsi, rdi
cmp qword ptr [rdi+20h], 0
mov rax, [rdi+10h]
mov cl, [rdi+40h]
jnz short loc_BF08C
test rax, rax
jnz short loc_BF08C
test cl, cl
jnz short loc_BF08C
cmp qword ptr [rsi+30h], 0
jnz short loc_BF08C
xor ebx, ebx
loc_BF082:
mov eax, ebx
add rsp, 28h
pop rbx
pop r14
retn
loc_BF08C:
cmp cl, 4
jnz short loc_BF0A0
mov rdi, rsi
add rsp, 28h
pop rbx
pop r14
jmp _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
loc_BF0A0:
lea edx, [rcx-5]
cmp dl, 2
ja short loc_BF0C3
mov rdi, rsi
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
xorpd xmm1, xmm1
cmpneqsd xmm1, xmm0
movq rbx, xmm1
and ebx, 1
jmp short loc_BF082
loc_BF0C3:
cmp cl, 3
jnz short loc_BF0F9
lea r14, [rsp+38h+var_30]
mov rdi, r14
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
cmp qword ptr [r14+8], 0
setnz bl
mov rdi, [r14]; void *
lea rax, [rsp+38h+var_20]
cmp rdi, rax
jz short loc_BF082
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_BF082
loc_BF0F9:
test rax, rax
jz short loc_BF110
mov rdi, rsi; this
call _ZNK5minja5Value5emptyEv; minja::Value::empty(void)
mov ebx, eax
xor bl, 1
jmp loc_BF082
loc_BF110:
mov bl, 1
jmp loc_BF082
| long long minja::Value::to_bool(minja::Value *this)
{
unsigned int v1; // ebx
long long v2; // rax
char v3; // cl
__m128d v5; // xmm0
void *v6[2]; // [rsp+8h] [rbp-30h] BYREF
long long v7; // [rsp+18h] [rbp-20h] BYREF
v2 = *((_QWORD *)this + 2);
v3 = *((_BYTE *)this + 64);
if ( !*((_QWORD *)this + 4) && !v2 && !v3 && !*((_QWORD *)this + 6) )
return 0;
if ( v3 != 4 )
{
if ( (unsigned __int8)(v3 - 5) > 2u )
{
if ( v3 == 3 )
{
minja::Value::get<std::string>(v6, this);
LOBYTE(v1) = v6[1] != 0LL;
if ( v6[0] != &v7 )
operator delete(v6[0], v7 + 1);
}
else if ( v2 )
{
v1 = minja::Value::empty(this);
LOBYTE(v1) = v1 ^ 1;
}
else
{
LOBYTE(v1) = 1;
}
}
else
{
v5.m128d_f64[0] = minja::Value::get<double>(this);
return *(_OWORD *)&_mm_cmpneq_sd((__m128d)0LL, v5) & 1;
}
return v1;
}
return minja::Value::get<bool>(this);
}
| to_bool:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RSI,RDI
CMP qword ptr [RDI + 0x20],0x0
MOV RAX,qword ptr [RDI + 0x10]
MOV CL,byte ptr [RDI + 0x40]
JNZ 0x001bf08c
TEST RAX,RAX
JNZ 0x001bf08c
TEST CL,CL
JNZ 0x001bf08c
CMP qword ptr [RSI + 0x30],0x0
JNZ 0x001bf08c
XOR EBX,EBX
LAB_001bf082:
MOV EAX,EBX
ADD RSP,0x28
POP RBX
POP R14
RET
LAB_001bf08c:
CMP CL,0x4
JNZ 0x001bf0a0
MOV RDI,RSI
ADD RSP,0x28
POP RBX
POP R14
JMP 0x001bf118
LAB_001bf0a0:
LEA EDX,[RCX + -0x5]
CMP DL,0x2
JA 0x001bf0c3
MOV RDI,RSI
CALL 0x001bf228
XORPD XMM1,XMM1
CMPNEQSD XMM1,XMM0
MOVQ RBX,XMM1
AND EBX,0x1
JMP 0x001bf082
LAB_001bf0c3:
CMP CL,0x3
JNZ 0x001bf0f9
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x001bf33e
CMP qword ptr [R14 + 0x8],0x0
SETNZ BL
MOV RDI,qword ptr [R14]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x001bf082
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00120180
JMP 0x001bf082
LAB_001bf0f9:
TEST RAX,RAX
JZ 0x001bf110
MOV RDI,RSI
CALL 0x001bf448
MOV EBX,EAX
XOR BL,0x1
JMP 0x001bf082
LAB_001bf110:
MOV BL,0x1
JMP 0x001bf082
|
/* minja::Value::to_bool() const */
byte __thiscall minja::Value::to_bool(Value *this)
{
Value VVar1;
bool bVar2;
byte bVar3;
double dVar4;
long *local_30;
long local_28;
long local_20 [2];
VVar1 = this[0x40];
if ((((*(long *)(this + 0x20) == 0) && (*(long *)(this + 0x10) == 0)) && (VVar1 == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
bVar3 = 0;
}
else {
if (VVar1 == (Value)0x4) {
bVar2 = get<bool>(this);
return bVar2;
}
if ((byte)((char)VVar1 - 5U) < 3) {
dVar4 = get<double>(this);
bVar3 = -(dVar4 != 0.0) & 1;
}
else if (VVar1 == (Value)0x3) {
get<std::__cxx11::string>();
bVar3 = local_28 != 0;
if (local_30 != local_20) {
operator_delete(local_30,local_20[0] + 1);
}
}
else if (*(long *)(this + 0x10) == 0) {
bVar3 = 1;
}
else {
bVar3 = empty(this);
bVar3 = bVar3 ^ 1;
}
}
return bVar3;
}
| |
22,536 | my_hash_update | eloqsql/mysys/hash.c | my_bool my_hash_update(HASH *hash, uchar *record, uchar *old_key,
size_t old_key_length)
{
uint new_index, new_pos_index, org_index, records, idx;
size_t length, empty, blength;
my_hash_value_type hash_nr;
HASH_LINK org_link,*data,*previous,*pos;
uchar *new_key;
DBUG_ENTER("my_hash_update");
new_key= (uchar*) my_hash_key(hash, record, &length, 1);
hash_nr= hash->hash_function(hash->charset, new_key, length);
if (HASH_UNIQUE & hash->flags)
{
HASH_SEARCH_STATE state;
uchar *found;
if ((found= my_hash_first_from_hash_value(hash, hash_nr, new_key, length,
&state)))
{
do
{
if (found != record)
DBUG_RETURN(1); /* Duplicate entry */
}
while ((found= my_hash_next(hash, new_key, length, &state)));
}
}
data=dynamic_element(&hash->array,0,HASH_LINK*);
blength=hash->blength; records=hash->records;
/* Search after record with key */
idx= my_hash_mask(hash->hash_function(hash->charset, old_key,
(old_key_length ? old_key_length :
hash->key_length)),
blength, records);
org_index= idx;
new_index= my_hash_mask(hash_nr, blength, records);
previous=0;
for (;;)
{
if ((pos= data+idx)->data == record)
break;
previous=pos;
if ((idx=pos->next) == NO_RECORD)
DBUG_RETURN(1); /* Not found in links */
}
if (org_index == new_index)
{
data[idx].hash_nr= hash_nr; /* Hash number may have changed */
DBUG_RETURN(0); /* Record is in right position */
}
org_link= *pos;
empty=idx;
/* Relink record from current chain */
if (!previous)
{
if (pos->next != NO_RECORD)
{
empty=pos->next;
*pos= data[pos->next];
}
}
else
previous->next=pos->next; /* unlink pos */
/* Move data to correct position */
if (new_index == empty)
{
/*
At this point record is unlinked from the old chain, thus it holds
random position. By the chance this position is equal to position
for the first element in the new chain. That means updated record
is the only record in the new chain.
*/
if (empty != idx)
{
/*
Record was moved while unlinking it from the old chain.
Copy data to a new position.
*/
data[empty]= org_link;
}
data[empty].next= NO_RECORD;
data[empty].hash_nr= hash_nr;
DBUG_RETURN(0);
}
pos=data+new_index;
new_pos_index= my_hash_rec_mask(pos, blength, records);
if (new_index != new_pos_index)
{ /* Other record in wrong position */
data[empty]= *pos;
movelink(data,new_index,new_pos_index, (uint) empty);
org_link.next=NO_RECORD;
data[new_index]= org_link;
data[new_index].hash_nr= hash_nr;
}
else
{ /* Link in chain at right position */
org_link.next=data[new_index].next;
data[empty]=org_link;
data[empty].hash_nr= hash_nr;
data[new_index].next= (uint) empty;
}
DBUG_RETURN(0);
} | O0 | c | my_hash_update:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movl $0x1, %ecx
callq 0x70030
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x68(%rcx), %rdi
movq -0x90(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq *%rax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x705ba
movq -0x10(%rbp), %rdi
movl -0x5c(%rbp), %esi
movq -0x90(%rbp), %rdx
movq -0x48(%rbp), %rcx
leaq -0x94(%rbp), %r8
callq 0x6f810
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x705b8
jmp 0x70574
movq -0xa0(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x7058c
jmp 0x70583
movb $0x1, -0x1(%rbp)
jmp 0x708d2
jmp 0x7058e
movq -0x10(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x94(%rbp), %rcx
callq 0x6fa30
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
jne 0x70574
jmp 0x705b8
jmp 0x705ba
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7061a
movq -0x28(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0x70629
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rax
movq -0xa8(%rbp), %rsi
movq -0xb0(%rbp), %rdi
movq -0xc0(%rbp), %rdx
callq *%rax
movl %eax, %edi
movq -0x58(%rbp), %rsi
movl -0x38(%rbp), %eax
movl %eax, %edx
callq 0x6f910
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x5c(%rbp), %edi
movq -0x58(%rbp), %rsi
movl -0x38(%rbp), %eax
movl %eax, %edx
callq 0x6f910
movl %eax, -0x2c(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x78(%rbp), %rax
movl -0x3c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x7069d
jmp 0x706c6
movq -0x88(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $-0x1, %eax
jne 0x706c4
jmp 0x706bb
movb $0x1, -0x1(%rbp)
jmp 0x708d2
jmp 0x7067c
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x706eb
movl -0x5c(%rbp), %ecx
movq -0x78(%rbp), %rax
movl -0x3c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x708d2
movq -0x88(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
movl -0x3c(%rbp), %eax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0x70753
movq -0x88(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x70751
movq -0x88(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x50(%rbp)
movq -0x88(%rbp), %rax
movq -0x78(%rbp), %rcx
movq -0x88(%rbp), %rdx
movl (%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x70762
movq -0x88(%rbp), %rax
movl (%rax), %ecx
movq -0x80(%rbp), %rax
movl %ecx, (%rax)
movl -0x2c(%rbp), %eax
cmpq -0x50(%rbp), %rax
jne 0x707c8
movq -0x50(%rbp), %rax
movl -0x3c(%rbp), %ecx
cmpq %rcx, %rax
je 0x70795
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movl -0x5c(%rbp), %ecx
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x708d2
movq -0x78(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl -0x38(%rbp), %eax
movl %eax, %edx
callq 0x6fa00
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
je 0x70870
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x88(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x78(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
movq -0x50(%rbp), %rax
movl %eax, %ecx
callq 0x700a0
movl $0xffffffff, -0x70(%rbp) # imm = 0xFFFFFFFF
movq -0x78(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x5c(%rbp), %ecx
movq -0x78(%rbp), %rax
movl -0x2c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
jmp 0x708cc
movq -0x78(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x5c(%rbp), %ecx
movq -0x78(%rbp), %rax
movq -0x50(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x50(%rbp), %rax
movl %eax, %ecx
movq -0x78(%rbp), %rax
movl -0x2c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
jmp 0x708ce
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0xc0, %rsp
popq %rbp
retq
nop
| my_hash_update:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
lea rdx, [rbp+var_48]
mov ecx, 1
call my_hash_key
mov [rbp+var_90], rax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+68h]
mov rsi, [rbp+var_90]
mov rdx, [rbp+var_48]
call rax
mov [rbp+var_5C], eax
mov rax, [rbp+var_10]
mov eax, [rax+20h]
and eax, 1
cmp eax, 0
jz short loc_705BA
mov rdi, [rbp+var_10]
mov esi, [rbp+var_5C]
mov rdx, [rbp+var_90]
mov rcx, [rbp+var_48]
lea r8, [rbp+var_94]
call my_hash_first_from_hash_value
mov [rbp+var_A0], rax
cmp rax, 0
jz short loc_705B8
jmp short $+2
loc_70574:
mov rax, [rbp+var_A0]
cmp rax, [rbp+var_18]
jz short loc_7058C
jmp short $+2
loc_70583:
mov [rbp+var_1], 1
jmp loc_708D2
loc_7058C:
jmp short $+2
loc_7058E:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_90]
mov rdx, [rbp+var_48]
lea rcx, [rbp+var_94]
call my_hash_next
mov [rbp+var_A0], rax
cmp rax, 0
jnz short loc_70574
jmp short $+2
loc_705B8:
jmp short $+2
loc_705BA:
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov [rbp+var_78], rax
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_58], rax
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov [rbp+var_38], eax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rbp+var_B8], rax
mov rax, [rbp+var_10]
mov rax, [rax+68h]
mov [rbp+var_B0], rax
mov rax, [rbp+var_20]
mov [rbp+var_A8], rax
cmp [rbp+var_28], 0
jz short loc_7061A
mov rax, [rbp+var_28]
mov [rbp+var_C0], rax
jmp short loc_70629
loc_7061A:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_C0], rax
loc_70629:
mov rax, [rbp+var_B8]
mov rsi, [rbp+var_A8]
mov rdi, [rbp+var_B0]
mov rdx, [rbp+var_C0]
call rax
mov edi, eax
mov rsi, [rbp+var_58]
mov eax, [rbp+var_38]
mov edx, eax
call my_hash_mask
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
mov [rbp+var_34], eax
mov edi, [rbp+var_5C]
mov rsi, [rbp+var_58]
mov eax, [rbp+var_38]
mov edx, eax
call my_hash_mask
mov [rbp+var_2C], eax
mov [rbp+var_80], 0
loc_7067C:
mov rax, [rbp+var_78]
mov ecx, [rbp+var_3C]
shl rcx, 4
add rax, rcx
mov [rbp+var_88], rax
mov rax, [rax+8]
cmp rax, [rbp+var_18]
jnz short loc_7069D
jmp short loc_706C6
loc_7069D:
mov rax, [rbp+var_88]
mov [rbp+var_80], rax
mov rax, [rbp+var_88]
mov eax, [rax]
mov [rbp+var_3C], eax
cmp eax, 0FFFFFFFFh
jnz short loc_706C4
jmp short $+2
loc_706BB:
mov [rbp+var_1], 1
jmp loc_708D2
loc_706C4:
jmp short loc_7067C
loc_706C6:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_2C]
jnz short loc_706EB
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_78]
mov edx, [rbp+var_3C]
shl rdx, 4
add rax, rdx
mov [rax+4], ecx
mov [rbp+var_1], 0
jmp loc_708D2
loc_706EB:
mov rax, [rbp+var_88]
mov rcx, [rax]
mov [rbp+var_70], rcx
mov rax, [rax+8]
mov [rbp+var_68], rax
mov eax, [rbp+var_3C]
mov [rbp+var_50], rax
cmp [rbp+var_80], 0
jnz short loc_70753
mov rax, [rbp+var_88]
cmp dword ptr [rax], 0FFFFFFFFh
jz short loc_70751
mov rax, [rbp+var_88]
mov eax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_88]
mov rcx, [rbp+var_78]
mov rdx, [rbp+var_88]
mov edx, [rdx]
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
loc_70751:
jmp short loc_70762
loc_70753:
mov rax, [rbp+var_88]
mov ecx, [rax]
mov rax, [rbp+var_80]
mov [rax], ecx
loc_70762:
mov eax, [rbp+var_2C]
cmp rax, [rbp+var_50]
jnz short loc_707C8
mov rax, [rbp+var_50]
mov ecx, [rbp+var_3C]
cmp rax, rcx
jz short loc_70795
mov rax, [rbp+var_78]
mov rcx, [rbp+var_50]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_70]
mov [rax], rcx
mov rcx, [rbp+var_68]
mov [rax+8], rcx
loc_70795:
mov rax, [rbp+var_78]
mov rcx, [rbp+var_50]
shl rcx, 4
add rax, rcx
mov dword ptr [rax], 0FFFFFFFFh
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_78]
mov rdx, [rbp+var_50]
shl rdx, 4
add rax, rdx
mov [rax+4], ecx
mov [rbp+var_1], 0
jmp loc_708D2
loc_707C8:
mov rax, [rbp+var_78]
mov ecx, [rbp+var_2C]
shl rcx, 4
add rax, rcx
mov [rbp+var_88], rax
mov rdi, [rbp+var_88]
mov rsi, [rbp+var_58]
mov eax, [rbp+var_38]
mov edx, eax
call my_hash_rec_mask
mov [rbp+var_30], eax
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_30]
jz short loc_70870
mov rax, [rbp+var_78]
mov rcx, [rbp+var_50]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_88]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_78]
mov esi, [rbp+var_2C]
mov edx, [rbp+var_30]
mov rax, [rbp+var_50]
mov ecx, eax
call movelink
mov dword ptr [rbp+var_70], 0FFFFFFFFh
mov rax, [rbp+var_78]
mov ecx, [rbp+var_2C]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_70]
mov [rax], rcx
mov rcx, [rbp+var_68]
mov [rax+8], rcx
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_78]
mov edx, [rbp+var_2C]
shl rdx, 4
add rax, rdx
mov [rax+4], ecx
jmp short loc_708CC
loc_70870:
mov rax, [rbp+var_78]
mov ecx, [rbp+var_2C]
shl rcx, 4
add rax, rcx
mov eax, [rax]
mov dword ptr [rbp+var_70], eax
mov rax, [rbp+var_78]
mov rcx, [rbp+var_50]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_70]
mov [rax], rcx
mov rcx, [rbp+var_68]
mov [rax+8], rcx
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_78]
mov rdx, [rbp+var_50]
shl rdx, 4
add rax, rdx
mov [rax+4], ecx
mov rax, [rbp+var_50]
mov ecx, eax
mov rax, [rbp+var_78]
mov edx, [rbp+var_2C]
shl rdx, 4
add rax, rdx
mov [rax], ecx
loc_708CC:
jmp short $+2
loc_708CE:
mov [rbp+var_1], 0
loc_708D2:
mov al, [rbp+var_1]
add rsp, 0C0h
pop rbp
retn
| char my_hash_update(_QWORD *a1, long long a2, long long a3, long long a4)
{
unsigned int v4; // eax
unsigned int *v5; // rax
_QWORD *v6; // rcx
_QWORD *v7; // rax
_QWORD *v8; // rax
unsigned int *v9; // rcx
_QWORD *v10; // rax
_QWORD *v11; // rax
long long ( *v13)(long long, long long, long long); // [rsp+8h] [rbp-B8h]
long long v14; // [rsp+10h] [rbp-B0h]
long long v15; // [rsp+20h] [rbp-A0h]
unsigned int v16; // [rsp+2Ch] [rbp-94h] BYREF
long long v17; // [rsp+30h] [rbp-90h]
unsigned int *v18; // [rsp+38h] [rbp-88h]
_DWORD *v19; // [rsp+40h] [rbp-80h]
long long v20; // [rsp+48h] [rbp-78h]
long long v21; // [rsp+50h] [rbp-70h]
long long v22; // [rsp+58h] [rbp-68h]
unsigned int v23; // [rsp+64h] [rbp-5Ch]
unsigned long long v24; // [rsp+68h] [rbp-58h]
long long v25; // [rsp+70h] [rbp-50h]
long long v26; // [rsp+78h] [rbp-48h] BYREF
unsigned int v27; // [rsp+84h] [rbp-3Ch]
unsigned int v28; // [rsp+88h] [rbp-38h]
unsigned int v29; // [rsp+8Ch] [rbp-34h]
unsigned int v30; // [rsp+90h] [rbp-30h]
unsigned int v31; // [rsp+94h] [rbp-2Ch]
long long v32; // [rsp+98h] [rbp-28h]
long long v33; // [rsp+A0h] [rbp-20h]
long long v34; // [rsp+A8h] [rbp-18h]
_QWORD *v35; // [rsp+B0h] [rbp-10h]
v35 = a1;
v34 = a2;
v33 = a3;
v32 = a4;
v17 = my_hash_key((long long)a1, a2, &v26, 1);
v23 = ((long long ( *)(_QWORD, long long, long long))v35[11])(v35[13], v17, v26);
if ( (v35[4] & 1) != 0 && (v15 = my_hash_first_from_hash_value(v35, v23, v17, v26, &v16)) != 0 )
{
while ( v15 == v34 )
{
v15 = my_hash_next((long long)v35, v17, v26, &v16);
if ( !v15 )
goto LABEL_6;
}
return 1;
}
else
{
LABEL_6:
v20 = v35[5];
v24 = v35[2];
v28 = v35[3];
v13 = (long long ( *)(long long, long long, long long))v35[11];
v14 = v35[13];
if ( v32 )
v4 = v13(v14, v33, v32);
else
v4 = v13(v14, v33, v35[1]);
v27 = my_hash_mask(v4, v24, v28);
v29 = v27;
v31 = my_hash_mask(v23, v24, v28);
v19 = 0LL;
while ( 1 )
{
v18 = (unsigned int *)(16LL * v27 + v20);
if ( *((_QWORD *)v18 + 1) == v34 )
break;
v19 = v18;
v27 = *v18;
if ( v27 == -1 )
return 1;
}
if ( v29 == v31 )
{
*(_DWORD *)(16LL * v27 + v20 + 4) = v23;
return 0;
}
else
{
v21 = *(_QWORD *)v18;
v22 = *((_QWORD *)v18 + 1);
v25 = v27;
if ( v19 )
{
*v19 = *v18;
}
else if ( *v18 != -1 )
{
v25 = *v18;
v5 = v18;
v6 = (_QWORD *)(16LL * *v18 + v20);
*(_QWORD *)v18 = *v6;
*((_QWORD *)v5 + 1) = v6[1];
}
if ( v31 == v25 )
{
if ( v25 != v27 )
{
v7 = (_QWORD *)(16 * v25 + v20);
*v7 = v21;
v7[1] = v22;
}
*(_DWORD *)(16 * v25 + v20) = -1;
*(_DWORD *)(16 * v25 + v20 + 4) = v23;
return 0;
}
else
{
v18 = (unsigned int *)(16LL * v31 + v20);
v30 = my_hash_rec_mask((long long)v18, v24, v28);
if ( v31 == v30 )
{
LODWORD(v21) = *(_DWORD *)(16LL * v31 + v20);
v11 = (_QWORD *)(16 * v25 + v20);
*v11 = v21;
v11[1] = v22;
*(_DWORD *)(16 * v25 + v20 + 4) = v23;
*(_DWORD *)(16LL * v31 + v20) = v25;
}
else
{
v8 = (_QWORD *)(16 * v25 + v20);
v9 = v18;
*v8 = *(_QWORD *)v18;
v8[1] = *((_QWORD *)v9 + 1);
movelink(v20, v31, v30, v25);
LODWORD(v21) = -1;
v10 = (_QWORD *)(16LL * v31 + v20);
*v10 = v21;
v10[1] = v22;
*(_DWORD *)(16LL * v31 + v20 + 4) = v23;
}
return 0;
}
}
}
}
| my_hash_update:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDX,[RBP + -0x48]
MOV ECX,0x1
CALL 0x00170030
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x68]
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,qword ptr [RBP + -0x48]
CALL RAX
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x20]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001705ba
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x5c]
MOV RDX,qword ptr [RBP + -0x90]
MOV RCX,qword ptr [RBP + -0x48]
LEA R8,[RBP + -0x94]
CALL 0x0016f810
MOV qword ptr [RBP + -0xa0],RAX
CMP RAX,0x0
JZ 0x001705b8
JMP 0x00170574
LAB_00170574:
MOV RAX,qword ptr [RBP + -0xa0]
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x0017058c
JMP 0x00170583
LAB_00170583:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001708d2
LAB_0017058c:
JMP 0x0017058e
LAB_0017058e:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,qword ptr [RBP + -0x48]
LEA RCX,[RBP + -0x94]
CALL 0x0016fa30
MOV qword ptr [RBP + -0xa0],RAX
CMP RAX,0x0
JNZ 0x00170574
JMP 0x001705b8
LAB_001705b8:
JMP 0x001705ba
LAB_001705ba:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0xa8],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0017061a
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0xc0],RAX
JMP 0x00170629
LAB_0017061a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xc0],RAX
LAB_00170629:
MOV RAX,qword ptr [RBP + -0xb8]
MOV RSI,qword ptr [RBP + -0xa8]
MOV RDI,qword ptr [RBP + -0xb0]
MOV RDX,qword ptr [RBP + -0xc0]
CALL RAX
MOV EDI,EAX
MOV RSI,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RBP + -0x38]
MOV EDX,EAX
CALL 0x0016f910
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x34],EAX
MOV EDI,dword ptr [RBP + -0x5c]
MOV RSI,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RBP + -0x38]
MOV EDX,EAX
CALL 0x0016f910
MOV dword ptr [RBP + -0x2c],EAX
MOV qword ptr [RBP + -0x80],0x0
LAB_0017067c:
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,dword ptr [RBP + -0x3c]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x0017069d
JMP 0x001706c6
LAB_0017069d:
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,-0x1
JNZ 0x001706c4
JMP 0x001706bb
LAB_001706bb:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001708d2
LAB_001706c4:
JMP 0x0017067c
LAB_001706c6:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x2c]
JNZ 0x001706eb
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x3c]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],ECX
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001708d2
LAB_001706eb:
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x70],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x68],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RBP + -0x80],0x0
JNZ 0x00170753
MOV RAX,qword ptr [RBP + -0x88]
CMP dword ptr [RAX],-0x1
JZ 0x00170751
MOV RAX,qword ptr [RBP + -0x88]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x88]
MOV EDX,dword ptr [RDX]
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
LAB_00170751:
JMP 0x00170762
LAB_00170753:
MOV RAX,qword ptr [RBP + -0x88]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x80]
MOV dword ptr [RAX],ECX
LAB_00170762:
MOV EAX,dword ptr [RBP + -0x2c]
CMP RAX,qword ptr [RBP + -0x50]
JNZ 0x001707c8
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x3c]
CMP RAX,RCX
JZ 0x00170795
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + 0x8],RCX
LAB_00170795:
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x4
ADD RAX,RCX
MOV dword ptr [RAX],0xffffffff
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x50]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],ECX
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001708d2
LAB_001707c8:
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,dword ptr [RBP + -0x2c]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x88],RAX
MOV RDI,qword ptr [RBP + -0x88]
MOV RSI,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RBP + -0x38]
MOV EDX,EAX
CALL 0x0016fa00
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x30]
JZ 0x00170870
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x78]
MOV ESI,dword ptr [RBP + -0x2c]
MOV EDX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,EAX
CALL 0x001700a0
MOV dword ptr [RBP + -0x70],0xffffffff
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,dword ptr [RBP + -0x2c]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x2c]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],ECX
JMP 0x001708cc
LAB_00170870:
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,dword ptr [RBP + -0x2c]
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x70],EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x50]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV EDX,dword ptr [RBP + -0x2c]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX],ECX
LAB_001708cc:
JMP 0x001708ce
LAB_001708ce:
MOV byte ptr [RBP + -0x1],0x0
LAB_001708d2:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0xc0
POP RBP
RET
|
int1 my_hash_update(long param_1,long param_2,int8 param_3,long param_4)
{
int4 uVar1;
long lVar2;
uint *puVar3;
int8 *puVar4;
long local_c8;
int1 local_9c [4];
int8 local_98;
int8 *local_90;
uint *local_88;
long local_80;
int8 local_78;
int8 local_70;
int4 local_64;
int8 local_60;
ulong local_58;
int8 local_50;
uint local_44;
int4 local_40;
uint local_3c;
uint local_38;
uint local_34;
long local_30;
int8 local_28;
long local_20;
long local_18;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_98 = my_hash_key(param_1,param_2,&local_50,1);
local_64 = (**(code **)(local_18 + 0x58))(*(int8 *)(local_18 + 0x68),local_98,local_50);
if ((*(uint *)(local_18 + 0x20) & 1) != 0) {
lVar2 = my_hash_first_from_hash_value(local_18,local_64,local_98,local_50,local_9c);
while (lVar2 != 0) {
if (lVar2 != local_20) {
return 1;
}
lVar2 = my_hash_next(local_18,local_98,local_50,local_9c);
}
}
local_80 = *(long *)(local_18 + 0x28);
local_60 = *(int8 *)(local_18 + 0x10);
local_40 = (int4)*(int8 *)(local_18 + 0x18);
if (local_30 == 0) {
local_c8 = *(long *)(local_18 + 8);
}
else {
local_c8 = local_30;
}
uVar1 = (**(code **)(local_18 + 0x58))(*(int8 *)(local_18 + 0x68),local_28,local_c8);
local_44 = my_hash_mask(uVar1,local_60,local_40);
local_3c = local_44;
local_34 = my_hash_mask(local_64,local_60,local_40);
local_88 = (uint *)0x0;
while (puVar3 = (uint *)(local_80 + (ulong)local_44 * 0x10), *(long *)(puVar3 + 2) != local_20) {
local_44 = *puVar3;
local_88 = puVar3;
if (local_44 == 0xffffffff) {
return 1;
}
}
if (local_3c == local_34) {
*(int4 *)(local_80 + (ulong)local_44 * 0x10 + 4) = local_64;
return 0;
}
local_78 = *(int8 *)puVar3;
local_70 = *(int8 *)(puVar3 + 2);
local_58 = (ulong)local_44;
if (local_88 == (uint *)0x0) {
if (*puVar3 != 0xffffffff) {
local_58 = (ulong)*puVar3;
puVar4 = (int8 *)(local_80 + (ulong)*puVar3 * 0x10);
*(int8 *)puVar3 = *puVar4;
*(int8 *)(puVar3 + 2) = puVar4[1];
}
}
else {
*local_88 = *puVar3;
}
if (local_34 == local_58) {
if (local_58 != local_44) {
puVar4 = (int8 *)(local_80 + local_58 * 0x10);
*puVar4 = local_78;
puVar4[1] = local_70;
}
*(int4 *)(local_80 + local_58 * 0x10) = 0xffffffff;
*(int4 *)(local_80 + local_58 * 0x10 + 4) = local_64;
return 0;
}
local_90 = (int8 *)(local_80 + (ulong)local_34 * 0x10);
local_38 = my_hash_rec_mask(local_90,local_60,local_40);
if (local_34 == local_38) {
local_78 = CONCAT44(local_78._4_4_,*(int4 *)(local_80 + (ulong)local_34 * 0x10));
puVar4 = (int8 *)(local_80 + local_58 * 0x10);
*puVar4 = local_78;
puVar4[1] = local_70;
*(int4 *)(local_80 + local_58 * 0x10 + 4) = local_64;
*(int *)(local_80 + (ulong)local_34 * 0x10) = (int)local_58;
}
else {
puVar4 = (int8 *)(local_80 + local_58 * 0x10);
*puVar4 = *local_90;
puVar4[1] = local_90[1];
movelink(local_80,local_34,local_38,local_58 & 0xffffffff);
local_78 = CONCAT44(local_78._4_4_,0xffffffff);
puVar4 = (int8 *)(local_80 + (ulong)local_34 * 0x10);
*puVar4 = local_78;
puVar4[1] = local_70;
*(int4 *)(local_80 + (ulong)local_34 * 0x10 + 4) = local_64;
}
return 0;
}
| |
22,537 | ma_remove_table_from_trnman | eloqsql/storage/maria/ma_state.c | void _ma_remove_table_from_trnman(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
TRN *trn= info->trn;
MARIA_USED_TABLES *tables, **prev;
DBUG_ENTER("_ma_remove_table_from_trnman");
DBUG_PRINT("enter", ("trn: %p used_tables: %p share: %p in_trans: %d",
trn, trn->used_tables, share, share->in_trans));
mysql_mutex_assert_owner(&share->intern_lock);
if (trn == &dummy_transaction_object)
DBUG_VOID_RETURN;
/* First remove share from used_tables */
for (prev= (MARIA_USED_TABLES**) (char*) &trn->used_tables;
(tables= *prev);
prev= &tables->next)
{
if (tables->share == share)
{
*prev= tables->next;
/*
We don't have to and can't call decrement_share_in_trans(share) here
as we know there is an active MARIA_HA handler around.
*/
share->in_trans--;
my_free(tables);
break;
}
}
if (!tables)
{
/*
This can only happens in case of rename of intermediate table as
part of alter table
*/
DBUG_PRINT("warning", ("share: %p where not in used_tables_list", share));
}
/* Reset trn and remove table from used_instances */
_ma_reset_trn_for_table(info);
DBUG_VOID_RETURN;
} | O0 | c | ma_remove_table_from_trnman:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x483c5
jmp 0x483c7
jmp 0x483c9
leaq 0x436600(%rip), %rax # 0x47e9d0
cmpq %rax, -0x18(%rbp)
jne 0x483da
jmp 0x483d8
jmp 0x48455
movq -0x18(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4843d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x48431
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x7ac(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x7ac(%rax)
movq -0x20(%rbp), %rdi
callq 0xf9d70
jmp 0x4843d
jmp 0x48433
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x483e6
cmpq $0x0, -0x20(%rbp)
jne 0x4844a
jmp 0x48446
jmp 0x48448
jmp 0x4844a
movq -0x8(%rbp), %rdi
callq 0x48460
jmp 0x48455
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ma_remove_table_from_trnman:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_18], rax
jmp short $+2
loc_483C5:
jmp short $+2
loc_483C7:
jmp short $+2
loc_483C9:
lea rax, dummy_transaction_object
cmp [rbp+var_18], rax
jnz short loc_483DA
jmp short $+2
loc_483D8:
jmp short loc_48455
loc_483DA:
mov rax, [rbp+var_18]
add rax, 58h ; 'X'
mov [rbp+var_28], rax
loc_483E6:
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_4843D
mov rax, [rbp+var_20]
mov rax, [rax+8]
cmp rax, [rbp+var_10]
jnz short loc_48431
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_28]
mov [rax], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+7ACh]
add ecx, 0FFFFFFFFh
mov [rax+7ACh], ecx
mov rdi, [rbp+var_20]
call my_free
jmp short loc_4843D
loc_48431:
jmp short $+2
loc_48433:
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
jmp short loc_483E6
loc_4843D:
cmp [rbp+var_20], 0
jnz short loc_4844A
jmp short $+2
loc_48446:
jmp short $+2
loc_48448:
jmp short $+2
loc_4844A:
mov rdi, [rbp+var_8]
call _ma_reset_trn_for_table
jmp short $+2
loc_48455:
add rsp, 30h
pop rbp
retn
| void * ma_remove_table_from_trnman(long long *a1)
{
void *result; // rax
_QWORD *i; // [rsp+8h] [rbp-28h]
_QWORD *v3; // [rsp+10h] [rbp-20h]
char *v4; // [rsp+18h] [rbp-18h]
long long v5; // [rsp+20h] [rbp-10h]
v5 = *a1;
v4 = (char *)a1[1];
result = &dummy_transaction_object;
if ( v4 != (char *)&dummy_transaction_object )
{
for ( i = v4 + 88; ; i = (_QWORD *)*i )
{
v3 = (_QWORD *)*i;
if ( !*i )
break;
if ( v3[1] == v5 )
{
*i = *v3;
--*(_DWORD *)(v5 + 1964);
my_free(v3);
return (void *)ma_reset_trn_for_table(a1);
}
}
return (void *)ma_reset_trn_for_table(a1);
}
return result;
}
| _ma_remove_table_from_trnman:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001483c5
LAB_001483c5:
JMP 0x001483c7
LAB_001483c7:
JMP 0x001483c9
LAB_001483c9:
LEA RAX,[0x57e9d0]
CMP qword ptr [RBP + -0x18],RAX
JNZ 0x001483da
JMP 0x001483d8
LAB_001483d8:
JMP 0x00148455
LAB_001483da:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x58
MOV qword ptr [RBP + -0x28],RAX
LAB_001483e6:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x0014843d
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x00148431
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x7ac]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x7ac],ECX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001f9d70
JMP 0x0014843d
LAB_00148431:
JMP 0x00148433
LAB_00148433:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001483e6
LAB_0014843d:
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0014844a
JMP 0x00148446
LAB_00148446:
JMP 0x00148448
LAB_00148448:
JMP 0x0014844a
LAB_0014844a:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00148460
JMP 0x00148455
LAB_00148455:
ADD RSP,0x30
POP RBP
RET
|
void _ma_remove_table_from_trnman(long *param_1)
{
long lVar1;
long *plVar2;
long *local_30;
lVar1 = *param_1;
if ((int1 *)param_1[1] != dummy_transaction_object) {
plVar2 = (long *)((int1 *)param_1[1] + 0x58);
do {
local_30 = plVar2;
plVar2 = (long *)*local_30;
if (plVar2 == (long *)0x0) goto LAB_0014844a;
} while (plVar2[1] != lVar1);
*local_30 = *plVar2;
*(int *)(lVar1 + 0x7ac) = *(int *)(lVar1 + 0x7ac) + -1;
my_free(plVar2);
LAB_0014844a:
_ma_reset_trn_for_table(param_1);
}
return;
}
| |
22,538 | ma_remove_table_from_trnman | eloqsql/storage/maria/ma_state.c | void _ma_remove_table_from_trnman(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
TRN *trn= info->trn;
MARIA_USED_TABLES *tables, **prev;
DBUG_ENTER("_ma_remove_table_from_trnman");
DBUG_PRINT("enter", ("trn: %p used_tables: %p share: %p in_trans: %d",
trn, trn->used_tables, share, share->in_trans));
mysql_mutex_assert_owner(&share->intern_lock);
if (trn == &dummy_transaction_object)
DBUG_VOID_RETURN;
/* First remove share from used_tables */
for (prev= (MARIA_USED_TABLES**) (char*) &trn->used_tables;
(tables= *prev);
prev= &tables->next)
{
if (tables->share == share)
{
*prev= tables->next;
/*
We don't have to and can't call decrement_share_in_trans(share) here
as we know there is an active MARIA_HA handler around.
*/
share->in_trans--;
my_free(tables);
break;
}
}
if (!tables)
{
/*
This can only happens in case of rename of intermediate table as
part of alter table
*/
DBUG_PRINT("warning", ("share: %p where not in used_tables_list", share));
}
/* Reset trn and remove table from used_instances */
_ma_reset_trn_for_table(info);
DBUG_VOID_RETURN;
} | O3 | c | ma_remove_table_from_trnman:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
cmpq 0x3461ae(%rip), %rdi # 0x389f70
je 0x43e24
movq (%rbx), %rax
addq $0x58, %rdi
movq %rdi, %rcx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x43ded
cmpq %rax, 0x8(%rdi)
jne 0x43dcb
movq (%rdi), %rdx
movq %rdx, (%rcx)
decl 0x7ac(%rax)
callq 0xa4926
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x43e1c
leaq 0x10(%rbx), %rcx
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x43e11
movq %rax, 0x18(%rdx)
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rax
jmp 0x43e13
xorl %edx, %edx
movq %rdx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _ma_remove_table_from_trnman:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+8]
cmp rdi, cs:dummy_transaction_object_ptr
jz short loc_43E24
mov rax, [rbx]
add rdi, 58h ; 'X'
loc_43DCB:
mov rcx, rdi
mov rdi, [rdi]
test rdi, rdi
jz short loc_43DED
cmp [rdi+8], rax
jnz short loc_43DCB
mov rdx, [rdi]
mov [rcx], rdx
dec dword ptr [rax+7ACh]
call my_free
loc_43DED:
mov rax, [rbx+18h]
test rax, rax
jz short loc_43E1C
lea rcx, [rbx+10h]
mov rdx, [rbx+10h]
test rdx, rdx
jz short loc_43E11
mov [rdx+18h], rax
mov rdx, [rbx+10h]
mov rax, [rbx+18h]
jmp short loc_43E13
loc_43E11:
xor edx, edx
loc_43E13:
mov [rax], rdx
xorps xmm0, xmm0
movups xmmword ptr [rcx], xmm0
loc_43E1C:
mov qword ptr [rbx+8], 0
loc_43E24:
add rsp, 8
pop rbx
pop rbp
retn
| _QWORD * ma_remove_table_from_trnman(_QWORD *a1)
{
_QWORD *result; // rax
_QWORD *v3; // rdi
long long v4; // rax
_QWORD *v5; // rdi
_QWORD *v6; // rcx
long long v7; // rdx
long long v8; // rdx
v3 = (_QWORD *)a1[1];
if ( v3 != dummy_transaction_object )
{
v4 = *a1;
v5 = v3 + 11;
while ( 1 )
{
v6 = v5;
v5 = (_QWORD *)*v5;
if ( !v5 )
break;
if ( v5[1] == v4 )
{
*v6 = *v5;
--*(_DWORD *)(v4 + 1964);
my_free(v5);
break;
}
}
result = (_QWORD *)a1[3];
if ( result )
{
v7 = a1[2];
if ( v7 )
{
*(_QWORD *)(v7 + 24) = result;
v8 = a1[2];
result = (_QWORD *)a1[3];
}
else
{
v8 = 0LL;
}
*result = v8;
*((_OWORD *)a1 + 1) = 0LL;
}
a1[1] = 0LL;
}
return result;
}
| _ma_remove_table_from_trnman:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,qword ptr [0x00489f70]
JZ 0x00143e24
MOV RAX,qword ptr [RBX]
ADD RDI,0x58
LAB_00143dcb:
MOV RCX,RDI
MOV RDI,qword ptr [RDI]
TEST RDI,RDI
JZ 0x00143ded
CMP qword ptr [RDI + 0x8],RAX
JNZ 0x00143dcb
MOV RDX,qword ptr [RDI]
MOV qword ptr [RCX],RDX
DEC dword ptr [RAX + 0x7ac]
CALL 0x001a4926
LAB_00143ded:
MOV RAX,qword ptr [RBX + 0x18]
TEST RAX,RAX
JZ 0x00143e1c
LEA RCX,[RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x10]
TEST RDX,RDX
JZ 0x00143e11
MOV qword ptr [RDX + 0x18],RAX
MOV RDX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RBX + 0x18]
JMP 0x00143e13
LAB_00143e11:
XOR EDX,EDX
LAB_00143e13:
MOV qword ptr [RAX],RDX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX],XMM0
LAB_00143e1c:
MOV qword ptr [RBX + 0x8],0x0
LAB_00143e24:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void _ma_remove_table_from_trnman(long *param_1)
{
int *piVar1;
long *plVar2;
long lVar3;
long *plVar4;
if ((int *)param_1[1] != PTR_dummy_transaction_object_00489f70) {
lVar3 = *param_1;
plVar2 = (long *)((int *)param_1[1] + 0x58);
do {
plVar4 = plVar2;
plVar2 = (long *)*plVar4;
if (plVar2 == (long *)0x0) goto LAB_00143ded;
} while (plVar2[1] != lVar3);
*plVar4 = *plVar2;
piVar1 = (int *)(lVar3 + 0x7ac);
*piVar1 = *piVar1 + -1;
my_free();
LAB_00143ded:
plVar2 = (long *)param_1[3];
if (plVar2 != (long *)0x0) {
if (param_1[2] == 0) {
lVar3 = 0;
}
else {
*(long **)(param_1[2] + 0x18) = plVar2;
lVar3 = param_1[2];
plVar2 = (long *)param_1[3];
}
*plVar2 = lVar3;
param_1[2] = 0;
param_1[3] = 0;
}
param_1[1] = 0;
}
return;
}
| |
22,539 | pow5mult | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static Bigint *pow5mult(Bigint *b, int k, Stack_alloc *alloc)
{
Bigint *b1, *p5, *p51=NULL;
int i;
static int p05[3]= { 5, 25, 125 };
my_bool overflow= FALSE;
if ((i= k & 3))
b= multadd(b, p05[i-1], 0, alloc);
if (!(k>>= 2))
return b;
p5= p5_a;
for (;;)
{
if (k & 1)
{
b1= mult(b, p5, alloc);
Bfree(b, alloc);
b= b1;
}
if (!(k>>= 1))
break;
/* Calculate next power of 5 */
if (overflow)
{
p51= mult(p5, p5, alloc);
Bfree(p5, alloc);
p5= p51;
}
else if (p5 < p5_a + P5A_MAX)
++p5;
else if (p5 == p5_a + P5A_MAX)
{
p5= mult(p5, p5, alloc);
overflow= TRUE;
}
}
if (p51)
Bfree(p51, alloc);
return b;
} | O0 | c | pow5mult:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x3d(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x66323
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1e244f(%rip), %rax # 0x248760
movl (%rax,%rcx,4), %esi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
callq 0x66a60
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x6633e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x66434
leaq 0x1e242b(%rip), %rax # 0x248770
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6637e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66440
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x66690
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x66390
jmp 0x66418
cmpb $0x0, -0x3d(%rbp)
je 0x663c2
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66440
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x66690
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x66413
leaq 0x1e23a7(%rip), %rax # 0x248770
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jae 0x663e3
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
jmp 0x66411
leaq 0x1e2386(%rip), %rax # 0x248770
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jne 0x6640f
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x66440
movq %rax, -0x30(%rbp)
movb $0x1, -0x3d(%rbp)
jmp 0x66411
jmp 0x66413
jmp 0x66349
cmpq $0x0, -0x38(%rbp)
je 0x6642c
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x66690
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| pow5mult:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_38], 0
mov [rbp+var_3D], 0
mov eax, [rbp+var_14]
and eax, 3
mov [rbp+var_3C], eax
cmp eax, 0
jz short loc_66323
mov rdi, [rbp+var_10]
mov eax, [rbp+var_3C]
sub eax, 1
movsxd rcx, eax
lea rax, pow5mult_p05
mov esi, [rax+rcx*4]
mov rcx, [rbp+var_20]
xor edx, edx
call multadd
mov [rbp+var_10], rax
loc_66323:
mov eax, [rbp+var_14]
sar eax, 2
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_6633E
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_66434
loc_6633E:
lea rax, p5_a
mov [rbp+var_30], rax
loc_66349:
mov eax, [rbp+var_14]
and eax, 1
cmp eax, 0
jz short loc_6637E
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
loc_6637E:
mov eax, [rbp+var_14]
sar eax, 1
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_66390
jmp loc_66418
loc_66390:
cmp [rbp+var_3D], 0
jz short loc_663C2
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_38], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_38]
mov [rbp+var_30], rax
jmp short loc_66413
loc_663C2:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnb short loc_663E3
mov rax, [rbp+var_30]
add rax, 18h
mov [rbp+var_30], rax
jmp short loc_66411
loc_663E3:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnz short loc_6640F
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_30], rax
mov [rbp+var_3D], 1
loc_6640F:
jmp short $+2
loc_66411:
jmp short $+2
loc_66413:
jmp loc_66349
loc_66418:
cmp [rbp+var_38], 0
jz short loc_6642C
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_20]
call Bfree
loc_6642C:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_66434:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long pow5mult(long long a1, int a2, long long a3)
{
char v4; // [rsp+3h] [rbp-3Dh]
_BYTE v5[12]; // [rsp+4h] [rbp-3Ch]
_UNKNOWN **v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
int v9; // [rsp+2Ch] [rbp-14h]
long long v10; // [rsp+30h] [rbp-10h]
v10 = a1;
*(_DWORD *)&v5[8] = 0;
v4 = 0;
*(_QWORD *)v5 = a2 & 3;
if ( (a2 & 3) != 0 )
v10 = multadd(a1, pow5mult_p05[*(_DWORD *)v5 - 1], 0LL, a3);
v9 = a2 >> 2;
if ( !(a2 >> 2) )
return v10;
v6 = &p5_a;
while ( 1 )
{
if ( (v9 & 1) != 0 )
{
v7 = mult(v10, v6, a3);
Bfree(v10, a3);
v10 = v7;
}
v9 >>= 1;
if ( !v9 )
break;
if ( v4 )
{
*(_QWORD *)&v5[4] = mult(v6, v6, a3);
Bfree(v6, a3);
v6 = *(_UNKNOWN ***)&v5[4];
}
else if ( v6 >= &p5_a + 18 )
{
if ( v6 == &p5_a + 18 )
{
v6 = (_UNKNOWN **)mult(v6, v6, a3);
v4 = 1;
}
}
else
{
v6 += 3;
}
}
if ( *(_QWORD *)&v5[4] )
Bfree(*(_QWORD *)&v5[4], a3);
return v10;
}
| pow5mult:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x38],0x0
MOV byte ptr [RBP + -0x3d],0x0
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JZ 0x00166323
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
MOVSXD RCX,EAX
LEA RAX,[0x348760]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RBP + -0x20]
XOR EDX,EDX
CALL 0x00166a60
MOV qword ptr [RBP + -0x10],RAX
LAB_00166323:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x0016633e
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00166434
LAB_0016633e:
LEA RAX,[0x348770]
MOV qword ptr [RBP + -0x30],RAX
LAB_00166349:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0016637e
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00166440
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00166690
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
LAB_0016637e:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x00166390
JMP 0x00166418
LAB_00166390:
CMP byte ptr [RBP + -0x3d],0x0
JZ 0x001663c2
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00166440
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00166690
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00166413
LAB_001663c2:
LEA RAX,[0x348770]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNC 0x001663e3
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x18
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00166411
LAB_001663e3:
LEA RAX,[0x348770]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNZ 0x0016640f
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00166440
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [RBP + -0x3d],0x1
LAB_0016640f:
JMP 0x00166411
LAB_00166411:
JMP 0x00166413
LAB_00166413:
JMP 0x00166349
LAB_00166418:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x0016642c
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00166690
LAB_0016642c:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_00166434:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 pow5mult(int8 param_1,uint param_2,int8 param_3)
{
bool bVar1;
int8 uVar2;
int1 *local_40;
int1 *local_38;
uint local_1c;
int8 local_18;
int8 local_10;
local_40 = (int1 *)0x0;
bVar1 = false;
local_18 = param_1;
if ((param_2 & 3) != 0) {
local_18 = multadd(param_1,*(int4 *)(pow5mult_p05 + (long)(int)((param_2 & 3) - 1) * 4),0,
param_3);
}
local_1c = (int)param_2 >> 2;
if (local_1c == 0) {
local_10 = local_18;
}
else {
local_38 = p5_a;
while( true ) {
if ((local_1c & 1) != 0) {
uVar2 = mult(local_18,local_38,param_3);
Bfree(local_18,param_3);
local_18 = uVar2;
}
local_1c = (int)local_1c >> 1;
if (local_1c == 0) break;
if (bVar1) {
local_40 = (int1 *)mult(local_38,local_38,param_3);
Bfree(local_38,param_3);
local_38 = local_40;
}
else if (local_38 < (int1 *)0x348800) {
local_38 = local_38 + 0x18;
}
else if (local_38 == (int1 *)0x348800) {
local_38 = (int1 *)mult(0x348800,0x348800,param_3);
bVar1 = true;
}
}
if (local_40 != (int1 *)0x0) {
Bfree(local_40,param_3);
}
local_10 = local_18;
}
return local_10;
}
| |
22,540 | inline_mysql_file_open | eloqsql/include/mysql/psi/mysql_file.h | static inline File
inline_mysql_file_open(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *filename, int flags, myf myFlags)
{
File file;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_OPEN, filename,
&locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
file= my_open(filename, flags, myFlags);
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);
return file;
}
#endif
file= my_open(filename, flags, myFlags);
return file;
} | O0 | c | inline_mysql_file_open:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x20b500(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x148(%rax), %rax
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x88(%rbp), %rdi
movl $0x2, %edx
leaq -0x40(%rbp), %r8
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xb4c52
leaq 0x20b4b2(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x1f0(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0xf4240
movl %eax, -0x34(%rbp)
leaq 0x20b481(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x200(%rax), %rax
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
callq *%rax
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb4c6b
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0xf4240
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| inline_mysql_file_open_2:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+148h]
mov esi, [rbp+var_8]
mov rcx, [rbp+var_20]
lea rdi, [rbp+var_88]
mov edx, 2
lea r8, [rbp+var_40]
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_B4C52
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1F0h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov rdi, [rbp+var_20]
mov esi, [rbp+var_24]
mov rdx, [rbp+var_30]
call my_open
mov [rbp+var_34], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+200h]
mov rdi, [rbp+var_40]
mov esi, [rbp+var_34]
call rax
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
jmp short loc_B4C6B
loc_B4C52:
mov rdi, [rbp+var_20]
mov esi, [rbp+var_24]
mov rdx, [rbp+var_30]
call my_open
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
loc_B4C6B:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
| long long inline_mysql_file_open_2(
unsigned int a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6)
{
_BYTE v7[72]; // [rsp+8h] [rbp-88h] BYREF
long long v8; // [rsp+50h] [rbp-40h] BYREF
unsigned int v9; // [rsp+5Ch] [rbp-34h]
long long v10; // [rsp+60h] [rbp-30h]
unsigned int v11; // [rsp+6Ch] [rbp-24h]
long long v12; // [rsp+70h] [rbp-20h]
unsigned int v13; // [rsp+7Ch] [rbp-14h]
long long v14; // [rsp+80h] [rbp-10h]
unsigned int v15; // [rsp+88h] [rbp-8h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = a6;
v8 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(v7, a1, 2LL, a4, &v8);
if ( v8 )
{
((void ( *)(long long, long long, _QWORD))PSI_server[62])(v8, v14, v13);
v9 = my_open(v12, v11, v10);
((void ( *)(long long, _QWORD))PSI_server[64])(v8, v9);
}
else
{
return (unsigned int)my_open(v12, v11, v10);
}
return v9;
}
| inline_mysql_file_open:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV ESI,dword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x88]
MOV EDX,0x2
LEA R8,[RBP + -0x40]
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001b4c52
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1f0]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x24]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x001f4240
MOV dword ptr [RBP + -0x34],EAX
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x200]
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x34]
CALL RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001b4c6b
LAB_001b4c52:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x24]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x001f4240
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
LAB_001b4c6b:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int4
inline_mysql_file_open
(int4 param_1,int8 param_2,int4 param_3,int8 param_4,
int4 param_5,int8 param_6)
{
int1 local_90 [72];
long local_48;
int4 local_3c;
int8 local_38;
int4 local_2c;
int8 local_28;
int4 local_1c;
int8 local_18;
int4 local_10;
int4 local_c;
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_48 = (**(code **)(PSI_server + 0x148))(local_90,param_1,2,param_4,&local_48);
if (local_48 == 0) {
local_c = my_open(local_28,local_2c,local_38);
}
else {
(**(code **)(PSI_server + 0x1f0))(local_48,local_18,local_1c);
local_3c = my_open(local_28,local_2c,local_38);
(**(code **)(PSI_server + 0x200))(local_48,local_3c);
local_c = local_3c;
}
return local_c;
}
| |
22,541 | JS_AddIntrinsicRegExp | bluesky950520[P]quickjs/quickjs.c | void JS_AddIntrinsicRegExp(JSContext *ctx)
{
JSValue obj;
JS_AddIntrinsicRegExpCompiler(ctx);
ctx->class_proto[JS_CLASS_REGEXP] = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_REGEXP], js_regexp_proto_funcs,
countof(js_regexp_proto_funcs));
obj = JS_NewGlobalCConstructor(ctx, "RegExp", js_regexp_constructor, 2,
ctx->class_proto[JS_CLASS_REGEXP]);
ctx->regexp_ctor = js_dup(obj);
JS_SetPropertyFunctionList(ctx, obj, js_regexp_funcs, countof(js_regexp_funcs));
ctx->class_proto[JS_CLASS_REGEXP_STRING_ITERATOR] =
JS_NewObjectProto(ctx, ctx->class_proto[JS_CLASS_ITERATOR]);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_REGEXP_STRING_ITERATOR],
js_regexp_string_iterator_proto_funcs,
countof(js_regexp_string_iterator_proto_funcs));
} | O0 | c | JS_AddIntrinsicRegExp:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x54050
movq 0x70(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
callq 0x30860
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0x120(%rax)
movq 0x58(%rsp), %rcx
movq %rcx, 0x128(%rax)
movq 0x70(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x120(%rax), %rsi
movq 0x128(%rax), %rdx
leaq 0x10c9b8(%rip), %rcx # 0x138d70
movl $0x13, %r8d
callq 0x52df0
movq 0x70(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x120(%rax), %r8
movq 0x128(%rax), %r9
leaq 0xe7c4b(%rip), %rsi # 0x114031
leaq 0x28103(%rip), %rdx # 0x544f0
movl $0x2, %ecx
callq 0x54460
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x279c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x78(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x80(%rax)
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq 0x10cb65(%rip), %rcx # 0x138fd0
movl $0x2, %r8d
callq 0x52df0
movq 0x70(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x270(%rax), %rsi
movq 0x278(%rax), %rdx
callq 0x307c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x2e0(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x2e8(%rax)
movq 0x70(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x2e0(%rax), %rsi
movq 0x2e8(%rax), %rdx
leaq 0x10cb1e(%rip), %rcx # 0x139010
movl $0x2, %r8d
callq 0x52df0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_AddIntrinsicRegExp:
sub rsp, 78h
mov [rsp+78h+var_8], rdi
mov rdi, [rsp+78h+var_8]
call JS_AddIntrinsicRegExpCompiler
mov rax, [rsp+78h+var_8]
mov rax, [rax+40h]
mov [rsp+78h+var_70], rax
mov rdi, [rsp+78h+var_8]
call JS_NewObject
mov rcx, rax
mov rax, [rsp+78h+var_70]
mov [rsp+78h+var_28], rcx
mov [rsp+78h+var_20], rdx
mov rcx, [rsp+78h+var_28]
mov [rax+120h], rcx
mov rcx, [rsp+78h+var_20]
mov [rax+128h], rcx
mov rdi, [rsp+78h+var_8]
mov rax, [rsp+78h+var_8]
mov rax, [rax+40h]
mov rsi, [rax+120h]
mov rdx, [rax+128h]
lea rcx, js_regexp_proto_funcs
mov r8d, 13h
call JS_SetPropertyFunctionList
mov rdi, [rsp+78h+var_8]
mov rax, [rsp+78h+var_8]
mov rax, [rax+40h]
mov r8, [rax+120h]
mov r9, [rax+128h]
lea rsi, aRegexp; "RegExp"
lea rdx, js_regexp_constructor
mov ecx, 2
call JS_NewGlobalCConstructor
mov [rsp+78h+var_38], rax
mov [rsp+78h+var_30], rdx
mov rax, [rsp+78h+var_38]
mov [rsp+78h+var_18], rax
mov rax, [rsp+78h+var_30]
mov [rsp+78h+var_10], rax
mov rax, [rsp+78h+var_8]
mov [rsp+78h+var_68], rax
mov rdi, [rsp+78h+var_18]
mov rsi, [rsp+78h+var_10]
call js_dup
mov rcx, rax
mov rax, [rsp+78h+var_68]
mov [rsp+78h+var_48], rcx
mov [rsp+78h+var_40], rdx
mov rcx, [rsp+78h+var_48]
mov [rax+78h], rcx
mov rcx, [rsp+78h+var_40]
mov [rax+80h], rcx
mov rdi, [rsp+78h+var_8]
mov rsi, [rsp+78h+var_18]
mov rdx, [rsp+78h+var_10]
lea rcx, js_regexp_funcs
mov r8d, 2
call JS_SetPropertyFunctionList
mov rax, [rsp+78h+var_8]
mov rax, [rax+40h]
mov [rsp+78h+var_60], rax
mov rdi, [rsp+78h+var_8]
mov rax, [rsp+78h+var_8]
mov rax, [rax+40h]
mov rsi, [rax+270h]
mov rdx, [rax+278h]
call JS_NewObjectProto
mov rcx, rax
mov rax, [rsp+78h+var_60]
mov [rsp+78h+var_58], rcx
mov [rsp+78h+var_50], rdx
mov rcx, [rsp+78h+var_58]
mov [rax+2E0h], rcx
mov rcx, [rsp+78h+var_50]
mov [rax+2E8h], rcx
mov rdi, [rsp+78h+var_8]
mov rax, [rsp+78h+var_8]
mov rax, [rax+40h]
mov rsi, [rax+2E0h]
mov rdx, [rax+2E8h]
lea rcx, js_regexp_string_iterator_proto_funcs
mov r8d, 2
call JS_SetPropertyFunctionList
add rsp, 78h
retn
| long long JS_AddIntrinsicRegExp(_QWORD *a1)
{
long long v1; // rdx
long long v2; // rdx
long long v3; // rdx
long long v4; // rdx
long long v6; // [rsp+8h] [rbp-70h]
_QWORD *v7; // [rsp+18h] [rbp-60h]
_DWORD *v8; // [rsp+40h] [rbp-38h]
long long v9; // [rsp+68h] [rbp-10h]
JS_AddIntrinsicRegExpCompiler(a1);
v6 = a1[8];
*(_QWORD *)(v6 + 288) = JS_NewObject(a1);
*(_QWORD *)(v6 + 296) = v1;
JS_SetPropertyFunctionList(a1, *(_QWORD *)(a1[8] + 288LL), *(_QWORD *)(a1[8] + 296LL), &js_regexp_proto_funcs, 19LL);
v8 = (_DWORD *)JS_NewGlobalCConstructor(
a1,
"RegExp",
js_regexp_constructor,
2LL,
*(_QWORD *)(a1[8] + 288LL),
*(_QWORD *)(a1[8] + 296LL));
v9 = v2;
a1[15] = js_dup(v8, v2);
a1[16] = v3;
JS_SetPropertyFunctionList(a1, v8, v9, &js_regexp_funcs, 2LL);
v7 = (_QWORD *)a1[8];
v7[92] = JS_NewObjectProto(a1, v7[78], v7[79]);
v7[93] = v4;
return JS_SetPropertyFunctionList(
a1,
*(_QWORD *)(a1[8] + 736LL),
*(_QWORD *)(a1[8] + 744LL),
&js_regexp_string_iterator_proto_funcs,
2LL);
}
| JS_AddIntrinsicRegExp:
SUB RSP,0x78
MOV qword ptr [RSP + 0x70],RDI
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x00154050
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x00130860
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x50],RCX
MOV qword ptr [RSP + 0x58],RDX
MOV RCX,qword ptr [RSP + 0x50]
MOV qword ptr [RAX + 0x120],RCX
MOV RCX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX + 0x128],RCX
MOV RDI,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RAX + 0x120]
MOV RDX,qword ptr [RAX + 0x128]
LEA RCX,[0x238d70]
MOV R8D,0x13
CALL 0x00152df0
MOV RDI,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + 0x40]
MOV R8,qword ptr [RAX + 0x120]
MOV R9,qword ptr [RAX + 0x128]
LEA RSI,[0x214031]
LEA RDX,[0x1544f0]
MOV ECX,0x2
CALL 0x00154460
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
CALL 0x001279c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RCX
MOV qword ptr [RSP + 0x38],RDX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x78],RCX
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + 0x80],RCX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
LEA RCX,[0x238fd0]
MOV R8D,0x2
CALL 0x00152df0
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RAX + 0x270]
MOV RDX,qword ptr [RAX + 0x278]
CALL 0x001307c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x20],RCX
MOV qword ptr [RSP + 0x28],RDX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x2e0],RCX
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x2e8],RCX
MOV RDI,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RSP + 0x70]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RAX + 0x2e0]
MOV RDX,qword ptr [RAX + 0x2e8]
LEA RCX,[0x239010]
MOV R8D,0x2
CALL 0x00152df0
ADD RSP,0x78
RET
|
void JS_AddIntrinsicRegExp(long param_1)
{
long lVar1;
int1 auVar2 [16];
int1 auVar3 [16];
JS_AddIntrinsicRegExpCompiler(param_1);
lVar1 = *(long *)(param_1 + 0x40);
auVar2 = JS_NewObject(param_1);
*(int1 (*) [16])(lVar1 + 0x120) = auVar2;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x120),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x128),js_regexp_proto_funcs,0x13);
auVar2 = JS_NewGlobalCConstructor
(param_1,"RegExp",js_regexp_constructor,2,
*(int8 *)(*(long *)(param_1 + 0x40) + 0x120),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x128));
auVar3 = js_dup(auVar2._0_8_,auVar2._8_8_);
*(int1 (*) [16])(param_1 + 0x78) = auVar3;
JS_SetPropertyFunctionList(param_1,auVar2._0_8_,auVar2._8_8_,js_regexp_funcs,2);
lVar1 = *(long *)(param_1 + 0x40);
auVar2 = JS_NewObjectProto(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x270),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x278));
*(int1 (*) [16])(lVar1 + 0x2e0) = auVar2;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x2e0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x2e8),
js_regexp_string_iterator_proto_funcs,2);
return;
}
| |
22,542 | mysql_load_plugin_v | eloqsql/build_O3/libmariadb/libmariadb/ma_client_plugin.c | struct st_mysql_client_plugin * STDCALL
mysql_load_plugin_v(MYSQL *mysql, const char *name, int type,
int argc, va_list args)
{
const char *errmsg;
#ifdef _WIN32
char errbuf[1024];
#endif
char dlpath[FN_REFLEN+1];
void *sym, *dlhandle = NULL;
struct st_mysql_client_plugin *plugin;
char *env_plugin_dir= getenv("MARIADB_PLUGIN_DIR");
CLEAR_CLIENT_ERROR(mysql);
if (is_not_initialized(mysql, name))
return NULL;
pthread_mutex_lock(&LOCK_load_client_plugin);
/* make sure the plugin wasn't loaded meanwhile */
if (type >= 0 && find_plugin(name, type))
{
errmsg= "it is already loaded";
goto err;
}
/* Compile dll path */
#ifndef WIN32
snprintf(dlpath, sizeof(dlpath) - 1, "%s/%s%s",
mysql->options.extension && mysql->options.extension->plugin_dir ?
mysql->options.extension->plugin_dir : (env_plugin_dir) ? env_plugin_dir :
MARIADB_PLUGINDIR, name, SO_EXT);
#else
{
char *p= (mysql->options.extension && mysql->options.extension->plugin_dir) ?
mysql->options.extension->plugin_dir : env_plugin_dir;
snprintf(dlpath, sizeof(dlpath), "%s%s%s%s", p ? p : "", p ? "\\" : "", name, SO_EXT);
}
#endif
if (strpbrk(name, "()[]!@#$%^&/*;.,'?\\"))
{
errmsg= "invalid plugin name";
goto err;
}
/* Open new dll handle */
if (!(dlhandle= dlopen((const char *)dlpath, RTLD_NOW)))
{
#ifdef _WIN32
char winmsg[255];
size_t len;
winmsg[0] = 0;
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
winmsg, 255, NULL);
len= strlen(winmsg);
while (len > 0 && (winmsg[len - 1] == '\n' || winmsg[len - 1] == '\r'))
len--;
if (len)
winmsg[len] = 0;
snprintf(errbuf, sizeof(errbuf), "%s Library path is '%s'", winmsg, dlpath);
errmsg= errbuf;
#else
errmsg= dlerror();
#endif
goto err;
}
if (!(sym= dlsym(dlhandle, plugin_declarations_sym)))
{
errmsg= "not a plugin";
(void)dlclose(dlhandle);
goto err;
}
plugin= (struct st_mysql_client_plugin*)sym;
if (type >=0 && type != plugin->type)
{
errmsg= "type mismatch";
goto err;
}
if (strcmp(name, plugin->name))
{
errmsg= "name mismatch";
goto err;
}
if (type < 0 && find_plugin(name, plugin->type))
{
errmsg= "it is already loaded";
goto err;
}
plugin= add_plugin(mysql, plugin, dlhandle, argc, args);
pthread_mutex_unlock(&LOCK_load_client_plugin);
return plugin;
err:
if (dlhandle)
dlclose(dlhandle);
pthread_mutex_unlock(&LOCK_load_client_plugin);
my_set_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, SQLSTATE_UNKNOWN,
ER(CR_AUTH_PLUGIN_CANNOT_LOAD), name, errmsg);
return NULL;
} | O3 | c | mysql_load_plugin_v:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %r8, -0x258(%rbp)
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq 0xe8b1(%rip), %rdi # 0x38d77
callq 0x135a0
movq %rax, %r15
movl $0x0, 0x90(%r14)
movl $0x30303030, 0x297(%r14) # imm = 0x30303030
movw $0x30, 0x29b(%r14)
movb $0x0, 0x97(%r14)
movq 0x2a0(%r14), %rax
testq %rax, %rax
je 0x2a509
movl $0x0, 0x4(%rax)
cmpb $0x0, 0x255b0(%rip) # 0x4fac0
je 0x2a53f
leaq 0x255af(%rip), %rdi # 0x4fac8
callq 0x136b0
testl %r13d, %r13d
js 0x2a571
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2a41b
testq %rax, %rax
je 0x2a571
leaq 0xe850(%rip), %r15 # 0x38d8a
jmp 0x2a67b
leaq 0x2383a(%rip), %rax # 0x4dd80
movq (%rax), %rdx
leaq 0x23840(%rip), %rax # 0x4dd90
movq 0x1d8(%rax), %rcx
leaq 0xe94a(%rip), %r9 # 0x38ea8
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x80b, %esi # imm = 0x80B
movq %rbx, %r8
jmp 0x2a6b0
movq 0x480(%r14), %rax
testq %rax, %rax
je 0x2a585
movq (%rax), %r9
testq %r9, %r9
jne 0x2a593
testq %r15, %r15
leaq 0xe818(%rip), %r9 # 0x38da7
cmovneq %r15, %r9
leaq 0xe82b(%rip), %r10 # 0x38dc5
leaq 0xe7fe(%rip), %r8 # 0x38d9f
leaq -0x240(%rbp), %rdi
movl $0x200, %esi # imm = 0x200
movl $0x201, %ecx # imm = 0x201
movl $0x1, %edx
xorl %eax, %eax
pushq %r10
pushq %rbx
callq 0x132c0
addq $0x10, %rsp
leaq 0xe7fd(%rip), %rsi # 0x38dc9
movq %rbx, %rdi
callq 0x137b0
testq %rax, %rax
je 0x2a5e5
leaq 0xe7fd(%rip), %r15 # 0x38ddd
jmp 0x2a67b
leaq -0x240(%rbp), %rdi
movl $0x2, %esi
callq 0x13640
testq %rax, %rax
je 0x2a64a
movl %r12d, -0x24c(%rbp)
leaq 0xe7e8(%rip), %rsi # 0x38df1
movq %rax, %r12
movq %rax, %rdi
callq 0x13410
testq %rax, %rax
je 0x2a654
movq %rax, %r15
movq %r12, -0x248(%rbp)
testl %r13d, %r13d
js 0x2a62d
cmpl %r13d, (%r15)
jne 0x2a665
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x13650
testl %eax, %eax
je 0x2a6db
leaq 0xe7e6(%rip), %r15 # 0x38e2e
jmp 0x2a66c
callq 0x13420
movq %rax, %r15
jmp 0x2a67b
movq %r12, %rdi
callq 0x13360
leaq 0xe7b0(%rip), %r15 # 0x38e13
jmp 0x2a673
leaq 0xe7b4(%rip), %r15 # 0x38e20
movq -0x248(%rbp), %r12
movq %r12, %rdi
callq 0x13360
leaq 0x25446(%rip), %rdi # 0x4fac8
callq 0x13330
leaq 0x236f2(%rip), %rax # 0x4dd80
movq (%rax), %rdx
leaq 0x236f8(%rip), %rax # 0x4dd90
movq 0x1d8(%rax), %rcx
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x80b, %esi # imm = 0x80B
movq %rbx, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x184d1
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x2a72c
movq %r12, %rax
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r13d, %r13d
js 0x2a710
movq %r14, %rdi
movq %r15, %rsi
movq -0x248(%rbp), %rdx
movl -0x24c(%rbp), %ecx
movq -0x258(%rbp), %r8
callq 0x2a18c
movq %rax, %r12
leaq 0x253bf(%rip), %rdi # 0x4fac8
callq 0x13330
jmp 0x2a6b7
movl (%r15), %esi
movq %rbx, %rdi
callq 0x2a41b
testq %rax, %rax
je 0x2a6e0
leaq 0xe663(%rip), %r15 # 0x38d8a
jmp 0x2a66c
callq 0x13500
| mysql_load_plugin_v:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 238h
mov [rbp+var_258], r8
mov r12d, ecx
mov r13d, edx
mov rbx, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea rdi, aMariadbPluginD; "MARIADB_PLUGIN_DIR"
call _getenv
mov r15, rax
mov dword ptr [r14+90h], 0
mov dword ptr [r14+297h], 30303030h
mov word ptr [r14+29Bh], 30h ; '0'
mov byte ptr [r14+97h], 0
mov rax, [r14+2A0h]
test rax, rax
jz short loc_2A509
mov dword ptr [rax+4], 0
loc_2A509:
cmp cs:initialized, 0
jz short loc_2A53F
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_lock
test r13d, r13d
js short loc_2A571
mov rdi, rbx
mov esi, r13d
call find_plugin
test rax, rax
jz short loc_2A571
lea r15, aItIsAlreadyLoa; "it is already loaded"
jmp loc_2A67B
loc_2A53F:
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
lea r9, aNotInitialized; "not initialized"
xor r12d, r12d
mov rdi, r14
mov esi, 80Bh
mov r8, rbx
jmp loc_2A6B0
loc_2A571:
mov rax, [r14+480h]
test rax, rax
jz short loc_2A585
mov r9, [rax]
test r9, r9
jnz short loc_2A593
loc_2A585:
test r15, r15
lea r9, aHomeMonoInstal; "/home/mono/install/lib/plugin"
cmovnz r9, r15
loc_2A593:
lea r10, aSo; ".so"
lea r8, aSSS; "%s/%s%s"
lea rdi, [rbp+var_240]
mov esi, 200h
mov ecx, 201h
mov edx, 1
xor eax, eax
push r10
push rbx
call ___snprintf_chk
add rsp, 10h
lea rsi, asc_38DC9; "()[]!@#$%^&/*;.,'?\\"
mov rdi, rbx
call _strpbrk
test rax, rax
jz short loc_2A5E5
lea r15, aInvalidPluginN; "invalid plugin name"
jmp loc_2A67B
loc_2A5E5:
lea rdi, [rbp+var_240]
mov esi, 2
call _dlopen
test rax, rax
jz short loc_2A64A
mov [rbp+var_24C], r12d
lea rsi, aMysqlClientPlu; "_mysql_client_plugin_declaration_"
mov r12, rax
mov rdi, rax
call _dlsym
test rax, rax
jz short loc_2A654
mov r15, rax
mov [rbp+var_248], r12
test r13d, r13d
js short loc_2A62D
cmp [r15], r13d
jnz short loc_2A665
loc_2A62D:
mov rsi, [r15+8]
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_2A6DB
lea r15, aNameMismatch; "name mismatch"
jmp short loc_2A66C
loc_2A64A:
call _dlerror
mov r15, rax
jmp short loc_2A67B
loc_2A654:
mov rdi, r12
call _dlclose
lea r15, aNotAPlugin; "not a plugin"
jmp short loc_2A673
loc_2A665:
lea r15, aTypeMismatch; "type mismatch"
loc_2A66C:
mov r12, [rbp+var_248]
loc_2A673:
mov rdi, r12
call _dlclose
loc_2A67B:
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_unlock
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
xor r12d, r12d
mov rdi, r14
mov esi, 80Bh
mov r8, rbx
mov r9, r15
loc_2A6B0:
xor eax, eax
call my_set_error
loc_2A6B7:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_2A72C
mov rax, r12
add rsp, 238h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2A6DB:
test r13d, r13d
js short loc_2A710
loc_2A6E0:
mov rdi, r14
mov rsi, r15
mov rdx, [rbp+var_248]
mov ecx, [rbp+var_24C]
mov r8, [rbp+var_258]
call add_plugin
mov r12, rax
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_unlock
jmp short loc_2A6B7
loc_2A710:
mov esi, [r15]
mov rdi, rbx
call find_plugin
test rax, rax
jz short loc_2A6E0
lea r15, aItIsAlreadyLoa; "it is already loaded"
jmp loc_2A66C
loc_2A72C:
call ___stack_chk_fail
| long long mysql_load_plugin_v(long long a1, const char *a2, int a3, unsigned int a4, long long a5)
{
long long v7; // r15
long long v8; // rax
const char *v9; // r15
long long v10; // r12
const char **v11; // rax
const char *v12; // r9
double v13; // xmm0_8
long long v14; // rax
long long v15; // r12
long long v16; // rax
int *v17; // r15
unsigned int v20; // [rsp+14h] [rbp-24Ch]
_BYTE v21[528]; // [rsp+20h] [rbp-240h] BYREF
unsigned long long v22; // [rsp+230h] [rbp-30h]
v22 = __readfsqword(0x28u);
v7 = getenv("MARIADB_PLUGIN_DIR");
*(_DWORD *)(a1 + 144) = 0;
strcpy((char *)(a1 + 663), "00000");
*(_BYTE *)(a1 + 151) = 0;
v8 = *(_QWORD *)(a1 + 672);
if ( v8 )
*(_DWORD *)(v8 + 4) = 0;
if ( initialized )
{
pthread_mutex_lock(&LOCK_load_client_plugin);
if ( a3 >= 0 && find_plugin((long long)a2, a3) )
{
v9 = "it is already loaded";
}
else
{
v11 = *(const char ***)(a1 + 1152);
if ( !v11 || (v12 = *v11) == 0LL )
{
v12 = "/home/mono/install/lib/plugin";
if ( v7 )
v12 = (const char *)v7;
}
v13 = __snprintf_chk(v21, 512LL, 1LL, 513LL, "%s/%s%s", v12, a2, ".so");
if ( strpbrk(a2, "()[]!@#$%^&/*;.,'?\\", v13) )
{
v9 = "invalid plugin name";
}
else
{
v14 = dlopen(v21, 2LL);
if ( v14 )
{
v20 = a4;
v15 = v14;
v16 = dlsym(v14, "_mysql_client_plugin_declaration_");
if ( v16 )
{
v17 = (int *)v16;
if ( a3 < 0 || *(_DWORD *)v16 == a3 )
{
if ( !(unsigned int)strcmp(a2, *(_QWORD *)(v16 + 8)) )
{
if ( a3 >= 0 || !find_plugin((long long)a2, *v17) )
{
v10 = add_plugin(a1, (long long)v17, v15, v20, a5);
pthread_mutex_unlock(&LOCK_load_client_plugin);
return v10;
}
v9 = "it is already loaded";
}
else
{
v9 = "name mismatch";
}
}
else
{
v9 = "type mismatch";
}
}
else
{
dlclose(v15);
v9 = "not a plugin";
}
dlclose(v15);
}
else
{
v9 = (const char *)dlerror();
}
}
}
pthread_mutex_unlock(&LOCK_load_client_plugin);
v10 = 0LL;
my_set_error(a1, 2059, (long long)SQLSTATE_UNKNOWN, client_errors[59], a2, v9);
}
else
{
v10 = 0LL;
my_set_error(a1, 2059, (long long)SQLSTATE_UNKNOWN, client_errors[59], a2, "not initialized");
}
return v10;
}
| mysql_load_plugin_v:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x238
MOV qword ptr [RBP + -0x258],R8
MOV R12D,ECX
MOV R13D,EDX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[0x138d77]
CALL 0x001135a0
MOV R15,RAX
MOV dword ptr [R14 + 0x90],0x0
MOV dword ptr [R14 + 0x297],0x30303030
MOV word ptr [R14 + 0x29b],0x30
MOV byte ptr [R14 + 0x97],0x0
MOV RAX,qword ptr [R14 + 0x2a0]
TEST RAX,RAX
JZ 0x0012a509
MOV dword ptr [RAX + 0x4],0x0
LAB_0012a509:
CMP byte ptr [0x0014fac0],0x0
JZ 0x0012a53f
LEA RDI,[0x14fac8]
CALL 0x001136b0
TEST R13D,R13D
JS 0x0012a571
MOV RDI,RBX
MOV ESI,R13D
CALL 0x0012a41b
TEST RAX,RAX
JZ 0x0012a571
LEA R15,[0x138d8a]
JMP 0x0012a67b
LAB_0012a53f:
LEA RAX,[0x14dd80]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x14dd90]
MOV RCX,qword ptr [RAX + 0x1d8]
LEA R9,[0x138ea8]
XOR R12D,R12D
MOV RDI,R14
MOV ESI,0x80b
MOV R8,RBX
JMP 0x0012a6b0
LAB_0012a571:
MOV RAX,qword ptr [R14 + 0x480]
TEST RAX,RAX
JZ 0x0012a585
MOV R9,qword ptr [RAX]
TEST R9,R9
JNZ 0x0012a593
LAB_0012a585:
TEST R15,R15
LEA R9,[0x138da7]
CMOVNZ R9,R15
LAB_0012a593:
LEA R10,[0x138dc5]
LEA R8,[0x138d9f]
LEA RDI,[RBP + -0x240]
MOV ESI,0x200
MOV ECX,0x201
MOV EDX,0x1
XOR EAX,EAX
PUSH R10
PUSH RBX
CALL 0x001132c0
ADD RSP,0x10
LEA RSI,[0x138dc9]
MOV RDI,RBX
CALL 0x001137b0
TEST RAX,RAX
JZ 0x0012a5e5
LEA R15,[0x138ddd]
JMP 0x0012a67b
LAB_0012a5e5:
LEA RDI,[RBP + -0x240]
MOV ESI,0x2
CALL 0x00113640
TEST RAX,RAX
JZ 0x0012a64a
MOV dword ptr [RBP + -0x24c],R12D
LEA RSI,[0x138df1]
MOV R12,RAX
MOV RDI,RAX
CALL 0x00113410
TEST RAX,RAX
JZ 0x0012a654
MOV R15,RAX
MOV qword ptr [RBP + -0x248],R12
TEST R13D,R13D
JS 0x0012a62d
CMP dword ptr [R15],R13D
JNZ 0x0012a665
LAB_0012a62d:
MOV RSI,qword ptr [R15 + 0x8]
MOV RDI,RBX
CALL 0x00113650
TEST EAX,EAX
JZ 0x0012a6db
LEA R15,[0x138e2e]
JMP 0x0012a66c
LAB_0012a64a:
CALL 0x00113420
MOV R15,RAX
JMP 0x0012a67b
LAB_0012a654:
MOV RDI,R12
CALL 0x00113360
LEA R15,[0x138e13]
JMP 0x0012a673
LAB_0012a665:
LEA R15,[0x138e20]
LAB_0012a66c:
MOV R12,qword ptr [RBP + -0x248]
LAB_0012a673:
MOV RDI,R12
CALL 0x00113360
LAB_0012a67b:
LEA RDI,[0x14fac8]
CALL 0x00113330
LEA RAX,[0x14dd80]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x14dd90]
MOV RCX,qword ptr [RAX + 0x1d8]
XOR R12D,R12D
MOV RDI,R14
MOV ESI,0x80b
MOV R8,RBX
MOV R9,R15
LAB_0012a6b0:
XOR EAX,EAX
CALL 0x001184d1
LAB_0012a6b7:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0012a72c
MOV RAX,R12
ADD RSP,0x238
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012a6db:
TEST R13D,R13D
JS 0x0012a710
LAB_0012a6e0:
MOV RDI,R14
MOV RSI,R15
MOV RDX,qword ptr [RBP + -0x248]
MOV ECX,dword ptr [RBP + -0x24c]
MOV R8,qword ptr [RBP + -0x258]
CALL 0x0012a18c
MOV R12,RAX
LEA RDI,[0x14fac8]
CALL 0x00113330
JMP 0x0012a6b7
LAB_0012a710:
MOV ESI,dword ptr [R15]
MOV RDI,RBX
CALL 0x0012a41b
TEST RAX,RAX
JZ 0x0012a6e0
LEA R15,[0x138d8a]
JMP 0x0012a66c
LAB_0012a72c:
CALL 0x00113500
|
int8
mysql_load_plugin_v(long param_1,char *param_2,int param_3,int4 param_4,int8 param_5)
{
int iVar1;
char *pcVar2;
long lVar3;
int *piVar4;
int8 uVar5;
long lVar6;
char *pcVar7;
long in_FS_OFFSET;
int1 local_248 [528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = getenv("MARIADB_PLUGIN_DIR");
*(int4 *)(param_1 + 0x90) = 0;
*(int4 *)(param_1 + 0x297) = 0x30303030;
*(int2 *)(param_1 + 0x29b) = 0x30;
*(int1 *)(param_1 + 0x97) = 0;
if (*(long *)(param_1 + 0x2a0) != 0) {
*(int4 *)(*(long *)(param_1 + 0x2a0) + 4) = 0;
}
if (initialized == '\0') {
pcVar2 = "not initialized";
}
else {
pthread_mutex_lock((pthread_mutex_t *)LOCK_load_client_plugin);
if ((param_3 < 0) || (lVar3 = find_plugin(param_2,param_3), lVar3 == 0)) {
if (((*(long **)(param_1 + 0x480) == (long *)0x0) ||
(pcVar7 = (char *)**(long **)(param_1 + 0x480), pcVar7 == (char *)0x0)) &&
(pcVar7 = "/home/mono/install/lib/plugin", pcVar2 != (char *)0x0)) {
pcVar7 = pcVar2;
}
__snprintf_chk(local_248,0x200,1,0x201,"%s/%s%s",pcVar7,param_2,&DAT_00138dc5);
pcVar2 = strpbrk(param_2,"()[]!@#$%^&/*;.,\'?\\");
if (pcVar2 == (char *)0x0) {
lVar3 = dlopen(local_248,2);
if (lVar3 == 0) {
pcVar2 = (char *)dlerror();
}
else {
piVar4 = (int *)dlsym(lVar3,"_mysql_client_plugin_declaration_");
if (piVar4 == (int *)0x0) {
dlclose(lVar3);
pcVar2 = "not a plugin";
}
else if ((param_3 < 0) || (*piVar4 == param_3)) {
iVar1 = strcmp(param_2,*(char **)(piVar4 + 2));
if (iVar1 == 0) {
if ((-1 < param_3) || (lVar6 = find_plugin(param_2,*piVar4), lVar6 == 0)) {
uVar5 = add_plugin(param_1,piVar4,lVar3,param_4,param_5);
pthread_mutex_unlock((pthread_mutex_t *)LOCK_load_client_plugin);
goto LAB_0012a6b7;
}
pcVar2 = "it is already loaded";
}
else {
pcVar2 = "name mismatch";
}
}
else {
pcVar2 = "type mismatch";
}
dlclose(lVar3);
}
}
else {
pcVar2 = "invalid plugin name";
}
}
else {
pcVar2 = "it is already loaded";
}
pthread_mutex_unlock((pthread_mutex_t *)LOCK_load_client_plugin);
}
uVar5 = 0;
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____0014df68,
param_2,pcVar2);
LAB_0012a6b7:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar5;
}
| |
22,543 | void yoyo::Logger::trace<char const (&) [36]>(char const (&) [36], std::source_location&&) | isyoCode[P]yoyologger/test/../src/logger.hpp | void trace(T&& str,
std::source_location&& loc = std::source_location::current()) {
log(LOGLEVEL::TRACE, std::forward<T>(str), std::move(loc));
} | O1 | cpp | void yoyo::Logger::trace<char const (&) [36]>(char const (&) [36], std::source_location&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsi, %rdi
callq 0x30d0
leaq (%rax,%r14), %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3ed8
movq %r15, %rdi
movl $0x5, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x64bc
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3d46
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3d6d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x33a0
nop
| _ZN4yoyo6Logger5traceIRA36_KcEEvOT_OSt15source_location:
push r15; int
push r14; int
push r13; int
push r12; int
push rbx; char
sub rsp, 20h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea r13, [rsp+48h+var_38]
mov [r13-10h], r13
mov rdi, rsi
call _strlen
lea rdx, [rax+r14]
mov r12, rsp
mov rdi, r12
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, r15; int
mov esi, 5; int
mov rdx, r12; int
mov rcx, rbx; int
call _ZN4yoyo6Logger3logENS_8LOGLEVELEONSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEOSt15source_location; yoyo::Logger::log(yoyo::LOGLEVEL,std::string &&,std::source_location &&)
mov rdi, [rsp+48h+var_48]; void *
cmp rdi, r13
jz short loc_3D46
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D46:
add rsp, 20h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r13
jz short loc_3D6D
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3D6D:
mov rdi, rbx
call __Unwind_Resume
| trace<char_const(&)[36]>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
LEA R13,[RSP + 0x10]
MOV qword ptr [R13 + -0x10],R13
MOV RDI,RSI
CALL 0x001030d0
LEA RDX,[RAX + R14*0x1]
MOV R12,RSP
MOV RDI,R12
MOV RSI,R14
CALL 0x00103ed8
LAB_00103d1d:
MOV RDI,R15
MOV ESI,0x5
MOV RDX,R12
MOV RCX,RBX
CALL 0x001064bc
LAB_00103d30:
MOV RDI,qword ptr [RSP]
CMP RDI,R13
JZ 0x00103d46
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00103290
LAB_00103d46:
ADD RSP,0x20
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* void yoyo::Logger::trace<char const (&) [36]>(char const (&) [36], std::source_location&&) */
void __thiscall
yoyo::Logger::trace<char_const(&)[36]>(Logger *this,char *param_1,source_location *param_2)
{
size_t sVar1;
long *local_48 [2];
long local_38 [2];
local_48[0] = local_38;
sVar1 = strlen(param_1);
std::__cxx11::string::_M_construct<char_const*>(local_48,param_1,param_1 + sVar1);
/* try { // try from 00103d1d to 00103d2f has its CatchHandler @ 00103d54 */
log(this,5,local_48,param_2);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
return;
}
| ||
22,544 | void yoyo::Logger::trace<char const (&) [36]>(char const (&) [36], std::source_location&&) | isyoCode[P]yoyologger/test/../src/logger.hpp | void trace(T&& str,
std::source_location&& loc = std::source_location::current()) {
log(LOGLEVEL::TRACE, std::forward<T>(str), std::move(loc));
} | O3 | cpp | void yoyo::Logger::trace<char const (&) [36]>(char const (&) [36], std::source_location&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsi, %rdi
callq 0x30d0
leaq (%rax,%r14), %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3ef0
movq %r15, %rdi
movl $0x5, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x64e6
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3b1a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3b41
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x33a0
nop
| _ZN4yoyo6Logger5traceIRA34_KcEEvOT_OSt15source_location:
push r15; int
push r14; int
push r13; int
push r12; int
push rbx; char
sub rsp, 20h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea r13, [rsp+48h+var_38]
mov [r13-10h], r13
mov rdi, rsi
call _strlen
lea rdx, [rax+r14]
mov r12, rsp
mov rdi, r12
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, r15; int
mov esi, 5; int
mov rdx, r12; int
mov rcx, rbx; int
call _ZN4yoyo6Logger3logENS_8LOGLEVELEONSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEOSt15source_location; yoyo::Logger::log(yoyo::LOGLEVEL,std::string &&,std::source_location &&)
mov rdi, [rsp+48h+var_48]; void *
cmp rdi, r13
jz short loc_3B1A
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3B1A:
add rsp, 20h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r13
jz short loc_3B41
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3B41:
mov rdi, rbx
call __Unwind_Resume
| trace<char_const(&)[34]>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
LEA R13,[RSP + 0x10]
MOV qword ptr [R13 + -0x10],R13
MOV RDI,RSI
CALL 0x001030d0
LEA RDX,[RAX + R14*0x1]
MOV R12,RSP
MOV RDI,R12
MOV RSI,R14
CALL 0x00103ef0
LAB_00103af1:
MOV RDI,R15
MOV ESI,0x5
MOV RDX,R12
MOV RCX,RBX
CALL 0x001064e6
LAB_00103b04:
MOV RDI,qword ptr [RSP]
CMP RDI,R13
JZ 0x00103b1a
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00103290
LAB_00103b1a:
ADD RSP,0x20
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* void yoyo::Logger::trace<char const (&) [34]>(char const (&) [34], std::source_location&&) */
void __thiscall
yoyo::Logger::trace<char_const(&)[34]>(Logger *this,char *param_1,source_location *param_2)
{
size_t sVar1;
long *local_48 [2];
long local_38 [2];
local_48[0] = local_38;
sVar1 = strlen(param_1);
std::__cxx11::string::_M_construct<char_const*>(local_48,param_1,param_1 + sVar1);
/* try { // try from 00103af1 to 00103b03 has its CatchHandler @ 00103b28 */
log(this,5,local_48,param_2);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
return;
}
| ||
22,545 | google::protobuf::io::CodedInputStream::PushLimit(int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/coded_stream.cc | CodedInputStream::Limit CodedInputStream::PushLimit(int byte_limit) {
// Current position relative to the beginning of the stream.
int current_position = CurrentPosition();
Limit old_limit = current_limit_;
// security: byte_limit is possibly evil, so check for negative values
// and overflow. Also check that the new requested limit is before the
// previous limit; otherwise we continue to enforce the previous limit.
if (PROTOBUF_PREDICT_TRUE(byte_limit >= 0 &&
byte_limit <= INT_MAX - current_position &&
byte_limit < current_limit_ - current_position)) {
current_limit_ = current_position + byte_limit;
RecomputeBufferLimits();
}
return old_limit;
} | O0 | cpp | google::protobuf::io::CodedInputStream::PushLimit(int):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x21fb0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rsp)
movl 0x28(%rax), %eax
movl %eax, 0x14(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x1c(%rsp)
movb %al, 0x13(%rsp)
jl 0x1e6db
movl 0x1c(%rsp), %ecx
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
subl 0x18(%rsp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, 0x13(%rsp)
jg 0x1e6db
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
movl 0x28(%rcx), %ecx
subl 0x18(%rsp), %ecx
cmpl %ecx, %eax
setl %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x1e6e5
jmp 0x1e6fa
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x28(%rdi)
callq 0x21ff0
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf2io16CodedInputStream9PushLimitEi:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_C], esi
mov rdi, [rsp+28h+var_8]; this
mov [rsp+28h+var_20], rdi
call _ZNK6google8protobuf2io16CodedInputStream15CurrentPositionEv; google::protobuf::io::CodedInputStream::CurrentPosition(void)
mov ecx, eax
mov rax, [rsp+28h+var_20]
mov [rsp+28h+var_10], ecx
mov eax, [rax+28h]
mov [rsp+28h+var_14], eax
xor eax, eax
cmp [rsp+28h+var_C], 0
mov [rsp+28h+var_15], al
jl short loc_1E6DB
mov ecx, [rsp+28h+var_C]
mov edx, 7FFFFFFFh
sub edx, [rsp+28h+var_10]
xor eax, eax
cmp ecx, edx
mov [rsp+28h+var_15], al
jg short loc_1E6DB
mov rcx, [rsp+28h+var_20]
mov eax, [rsp+28h+var_C]
mov ecx, [rcx+28h]
sub ecx, [rsp+28h+var_10]
cmp eax, ecx
setl al
mov [rsp+28h+var_15], al
loc_1E6DB:
mov al, [rsp+28h+var_15]
test al, 1
jnz short loc_1E6E5
jmp short loc_1E6FA
loc_1E6E5:
mov rdi, [rsp+28h+var_20]; this
mov eax, [rsp+28h+var_10]
add eax, [rsp+28h+var_C]
mov [rdi+28h], eax
call _ZN6google8protobuf2io16CodedInputStream21RecomputeBufferLimitsEv; google::protobuf::io::CodedInputStream::RecomputeBufferLimits(void)
loc_1E6FA:
mov eax, [rsp+28h+var_14]
add rsp, 28h
retn
| long long google::protobuf::io::CodedInputStream::PushLimit(
google::protobuf::io::CodedInputStream *this,
int a2)
{
bool v3; // [rsp+13h] [rbp-15h]
unsigned int v4; // [rsp+14h] [rbp-14h]
int v5; // [rsp+18h] [rbp-10h]
v5 = google::protobuf::io::CodedInputStream::CurrentPosition(this);
v4 = *((_DWORD *)this + 10);
v3 = 0;
if ( a2 >= 0 )
{
v3 = 0;
if ( a2 <= 0x7FFFFFFF - v5 )
v3 = a2 < *((_DWORD *)this + 10) - v5;
}
if ( v3 )
{
*((_DWORD *)this + 10) = a2 + v5;
google::protobuf::io::CodedInputStream::RecomputeBufferLimits(this);
}
return v4;
}
| PushLimit:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ESI
MOV RDI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00121fb0
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x18],ECX
MOV EAX,dword ptr [RAX + 0x28]
MOV dword ptr [RSP + 0x14],EAX
XOR EAX,EAX
CMP dword ptr [RSP + 0x1c],0x0
MOV byte ptr [RSP + 0x13],AL
JL 0x0011e6db
MOV ECX,dword ptr [RSP + 0x1c]
MOV EDX,0x7fffffff
SUB EDX,dword ptr [RSP + 0x18]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RSP + 0x13],AL
JG 0x0011e6db
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0x1c]
MOV ECX,dword ptr [RCX + 0x28]
SUB ECX,dword ptr [RSP + 0x18]
CMP EAX,ECX
SETL AL
MOV byte ptr [RSP + 0x13],AL
LAB_0011e6db:
MOV AL,byte ptr [RSP + 0x13]
TEST AL,0x1
JNZ 0x0011e6e5
JMP 0x0011e6fa
LAB_0011e6e5:
MOV RDI,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RDI + 0x28],EAX
CALL 0x00121ff0
LAB_0011e6fa:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x28
RET
|
/* google::protobuf::io::CodedInputStream::PushLimit(int) */
int4 __thiscall
google::protobuf::io::CodedInputStream::PushLimit(CodedInputStream *this,int param_1)
{
int4 uVar1;
bool bVar2;
int iVar3;
iVar3 = CurrentPosition(this);
uVar1 = *(int4 *)(this + 0x28);
bVar2 = false;
if ((-1 < param_1) && (bVar2 = false, param_1 <= 0x7fffffff - iVar3)) {
bVar2 = param_1 < *(int *)(this + 0x28) - iVar3;
}
if (bVar2) {
*(int *)(this + 0x28) = iVar3 + param_1;
RecomputeBufferLimits(this);
}
return uVar1;
}
| |
22,546 | ftxui::ButtonOption::Border() | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/component/component_options.cpp | ButtonOption ButtonOption::Border() {
ButtonOption option;
option.transform = [](const EntryState& s) {
auto element = text(s.label) | border;
if (s.active) {
element |= bold;
}
if (s.focused) {
element |= inverted;
}
return element;
};
return option;
} | O3 | cpp | ftxui::ButtonOption::Border():
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x363ae
movups 0x48(%rbx), %xmm0
movaps %xmm0, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movq 0x58(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x12ce(%rip), %rcx # 0x354bc
movq %rcx, 0x58(%rbx)
movq 0x60(%rbx), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x10a8(%rip), %rcx # 0x352aa
movq %rcx, 0x60(%rbx)
testq %rax, %rax
je 0x34218
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x1049a
nop
| _ZN5ftxui12ButtonOption6BorderEv:
push rbx
sub rsp, 20h
mov rbx, rdi
call _ZN5ftxui12ButtonOptionC2Ev; ftxui::ButtonOption::ButtonOption(void)
movups xmm0, xmmword ptr [rbx+48h]
movaps [rsp+28h+var_28], xmm0
xorps xmm0, xmm0
movups xmmword ptr [rbx+48h], xmm0
mov rax, [rbx+58h]
mov [rsp+28h+var_18], rax
lea rcx, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEERKNS1_10EntryStateEEZNS1_12ButtonOption6BorderEvE3$_0E10_M_managerERSt9_Any_dataRKSB_St18_Manager_operation; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::ButtonOption::Border(void)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rbx+58h], rcx
mov rcx, [rbx+60h]
mov [rsp+28h+var_10], rcx
lea rcx, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEERKNS1_10EntryStateEEZNS1_12ButtonOption6BorderEvE3$_0E9_M_invokeERKSt9_Any_dataS6_; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::ButtonOption::Border(void)::$_0>::_M_invoke(std::_Any_data const&,ftxui::EntryState const&)
mov [rbx+60h], rcx
test rax, rax
jz short loc_34218
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_34218:
mov rax, rbx
add rsp, 20h
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
| ftxui::ButtonOption * ftxui::ButtonOption::Border(ftxui::ButtonOption *this)
{
void ( *v1)(__int128 *, __int128 *, long long); // rax
__int128 v3; // [rsp+0h] [rbp-28h] BYREF
void ( *v4)(__int128 *, __int128 *, long long); // [rsp+10h] [rbp-18h]
long long v5; // [rsp+18h] [rbp-10h]
ftxui::ButtonOption::ButtonOption(this);
v3 = *(_OWORD *)((char *)this + 72);
*(_OWORD *)((char *)this + 72) = 0LL;
v4 = (void ( *)(__int128 *, __int128 *, long long))*((_QWORD *)this + 11);
v1 = v4;
*((_QWORD *)this + 11) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::ButtonOption::Border(void)::$_0>::_M_manager;
v5 = *((_QWORD *)this + 12);
*((_QWORD *)this + 12) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(ftxui::EntryState const&),ftxui::ButtonOption::Border(void)::$_0>::_M_invoke;
if ( v1 )
v1(&v3, &v3, 3LL);
return this;
}
| Border:
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
CALL 0x001363ae
MOVUPS XMM0,xmmword ptr [RBX + 0x48]
MOVAPS xmmword ptr [RSP],XMM0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x48],XMM0
MOV RAX,qword ptr [RBX + 0x58]
MOV qword ptr [RSP + 0x10],RAX
LEA RCX,[0x1354bc]
MOV qword ptr [RBX + 0x58],RCX
MOV RCX,qword ptr [RBX + 0x60]
MOV qword ptr [RSP + 0x18],RCX
LEA RCX,[0x1352aa]
MOV qword ptr [RBX + 0x60],RCX
TEST RAX,RAX
JZ 0x00134218
LAB_0013420b:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_00134218:
MOV RAX,RBX
ADD RSP,0x20
POP RBX
RET
|
/* ftxui::ButtonOption::Border() */
ButtonOption * __thiscall ftxui::ButtonOption::Border(ButtonOption *this)
{
int8 local_28;
int8 uStack_20;
code *local_18;
int8 local_10;
ButtonOption(this);
local_28 = *(int8 *)(this + 0x48);
uStack_20 = *(int8 *)(this + 0x50);
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
local_18 = *(code **)(this + 0x58);
*(code **)(this + 0x58) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(ftxui::EntryState_const&),ftxui::ButtonOption::Border()::$_0>
::_M_manager;
local_10 = *(int8 *)(this + 0x60);
*(code **)(this + 0x60) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(ftxui::EntryState_const&),ftxui::ButtonOption::Border()::$_0>
::_M_invoke;
if (local_18 != (code *)0x0) {
/* try { // try from 0013420b to 00134217 has its CatchHandler @ 00134221 */
(*local_18)(&local_28,&local_28,3);
}
return this;
}
| |
22,547 | my_charlen_utf8mb3 | eloqsql/strings/ctype-utf8.c | static
int my_charlen_utf8mb3(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0xf0)
return my_valid_mbcharlen_utf8mb3(s, e);
return MY_CS_ILSEQ;
} | O0 | c | my_charlen_utf8mb3:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0xc7617
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0xc7644
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0xf0, %eax
jge 0xc763d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc84b0
movl %eax, -0x4(%rbp)
jmp 0xc7644
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_charlen_utf8mb3:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jb short loc_C7617
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_C7644
loc_C7617:
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_21], al
movzx eax, [rbp+var_21]
cmp eax, 0F0h
jge short loc_C763D
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_valid_mbcharlen_utf8mb3
mov [rbp+var_4], eax
jmp short loc_C7644
loc_C763D:
mov [rbp+var_4], 0
loc_C7644:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_charlen_utf8mb3(long long a1, unsigned __int8 *a2, unsigned long long a3)
{
if ( (unsigned long long)a2 < a3 )
{
if ( *a2 >= 0xF0u )
return 0;
else
return (unsigned int)my_valid_mbcharlen_utf8mb3(a2, a3);
}
else
{
return (unsigned int)-101;
}
}
| my_charlen_utf8mb3:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JC 0x001c7617
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001c7644
LAB_001c7617:
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x21],AL
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf0
JGE 0x001c763d
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001c84b0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001c7644
LAB_001c763d:
MOV dword ptr [RBP + -0x4],0x0
LAB_001c7644:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_charlen_utf8mb3(int8 param_1,byte *param_2,byte *param_3)
{
int4 local_c;
if (param_2 < param_3) {
if (*param_2 < 0xf0) {
local_c = my_valid_mbcharlen_utf8mb3(param_2,param_3);
}
else {
local_c = 0;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
22,548 | my_charlen_utf8mb3 | eloqsql/strings/ctype-utf8.c | static
int my_charlen_utf8mb3(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0xf0)
return my_valid_mbcharlen_utf8mb3(s, e);
return MY_CS_ILSEQ;
} | O3 | c | my_charlen_utf8mb3:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rdx, %rsi
jae 0x870db
movb (%rsi), %cl
cmpb $-0x11, %cl
ja 0x870d9
movl $0x1, %eax
testb %cl, %cl
jns 0x870db
cmpb $-0x3e, %cl
jae 0x870dd
xorl %eax, %eax
popq %rbp
retq
cmpb $-0x21, %cl
ja 0x870fd
leaq 0x2(%rsi), %rcx
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rdx, %rcx
ja 0x870db
xorl %eax, %eax
cmpb $-0x40, 0x1(%rsi)
setl %al
addl %eax, %eax
jmp 0x870db
leaq 0x3(%rsi), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rdx, %rdi
ja 0x870db
movb 0x1(%rsi), %dl
cmpb $-0x41, %dl
jg 0x870d9
cmpb $-0x41, 0x2(%rsi)
movl $0x0, %eax
jg 0x870db
xorl %eax, %eax
cmpb $-0x60, %dl
setae %al
cmpb $-0x20, %cl
leal (%rax,%rax,2), %ecx
movl $0x3, %eax
cmovel %ecx, %eax
jmp 0x870db
| my_charlen_utf8mb3:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rsi, rdx
jnb short loc_870DB
mov cl, [rsi]
cmp cl, 0EFh
ja short loc_870D9
mov eax, 1
test cl, cl
jns short loc_870DB
cmp cl, 0C2h
jnb short loc_870DD
loc_870D9:
xor eax, eax
loc_870DB:
pop rbp
retn
loc_870DD:
cmp cl, 0DFh
ja short loc_870FD
lea rcx, [rsi+2]
mov eax, 0FFFFFF9Ah
cmp rcx, rdx
ja short loc_870DB
xor eax, eax
cmp byte ptr [rsi+1], 0C0h
setl al
add eax, eax
jmp short loc_870DB
loc_870FD:
lea rdi, [rsi+3]
mov eax, 0FFFFFF99h
cmp rdi, rdx
ja short loc_870DB
mov dl, [rsi+1]
cmp dl, 0BFh
jg short loc_870D9
cmp byte ptr [rsi+2], 0BFh
mov eax, 0
jg short loc_870DB
xor eax, eax
cmp dl, 0A0h
setnb al
cmp cl, 0E0h
lea ecx, [rax+rax*2]
mov eax, 3
cmovz eax, ecx
jmp short loc_870DB
| long long my_charlen_utf8mb3(long long a1, char *a2, unsigned long long a3)
{
long long result; // rax
char v4; // cl
char v5; // dl
result = 4294967195LL;
if ( (unsigned long long)a2 < a3 )
{
v4 = *a2;
if ( (unsigned __int8)*a2 > 0xEFu )
return 0LL;
result = 1LL;
if ( v4 >= 0 )
return result;
if ( (unsigned __int8)v4 < 0xC2u )
return 0LL;
if ( (unsigned __int8)v4 > 0xDFu )
{
result = 4294967193LL;
if ( (unsigned long long)(a2 + 3) <= a3 )
{
v5 = a2[1];
if ( v5 > -65 )
return 0LL;
result = 0LL;
if ( a2[2] <= -65 )
{
result = 3LL;
if ( v4 == -32 )
return 3 * (unsigned int)((unsigned __int8)v5 >= 0xA0u);
}
}
}
else
{
result = 4294967194LL;
if ( (unsigned long long)(a2 + 2) <= a3 )
return 2 * (unsigned int)(a2[1] < -64);
}
}
return result;
}
| my_charlen_utf8mb3:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RSI,RDX
JNC 0x001870db
MOV CL,byte ptr [RSI]
CMP CL,0xef
JA 0x001870d9
MOV EAX,0x1
TEST CL,CL
JNS 0x001870db
CMP CL,0xc2
JNC 0x001870dd
LAB_001870d9:
XOR EAX,EAX
LAB_001870db:
POP RBP
RET
LAB_001870dd:
CMP CL,0xdf
JA 0x001870fd
LEA RCX,[RSI + 0x2]
MOV EAX,0xffffff9a
CMP RCX,RDX
JA 0x001870db
XOR EAX,EAX
CMP byte ptr [RSI + 0x1],0xc0
SETL AL
ADD EAX,EAX
JMP 0x001870db
LAB_001870fd:
LEA RDI,[RSI + 0x3]
MOV EAX,0xffffff99
CMP RDI,RDX
JA 0x001870db
MOV DL,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001870d9
CMP byte ptr [RSI + 0x2],0xbf
MOV EAX,0x0
JG 0x001870db
XOR EAX,EAX
CMP DL,0xa0
SETNC AL
CMP CL,0xe0
LEA ECX,[RAX + RAX*0x2]
MOV EAX,0x3
CMOVZ EAX,ECX
JMP 0x001870db
|
int my_charlen_utf8mb3(int8 param_1,byte *param_2,byte *param_3)
{
byte bVar1;
if (param_3 <= param_2) {
return -0x65;
}
bVar1 = *param_2;
if (bVar1 < 0xf0) {
if (-1 < (char)bVar1) {
return 1;
}
if (0xc1 < bVar1) {
if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
return -0x66;
}
return (uint)((char)param_2[1] < -0x40) * 2;
}
if (param_3 < param_2 + 3) {
return -0x67;
}
if ((char)param_2[1] < -0x40) {
if (-0x41 < (char)param_2[2]) {
return 0;
}
if (bVar1 != 0xe0) {
return 3;
}
return (uint)(0x9f < param_2[1]) * 3;
}
}
}
return 0;
}
| |
22,549 | my_caseup_utf32 | eloqsql/strings/ctype-ucs2.c | static size_t
my_caseup_utf32(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_utf32_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
{
my_toupper_utf32(uni_plane, &wc);
if (res != my_uni_utf32(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O0 | c | my_caseup_utf32:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xac792
jmp 0xac794
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0xac7c4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0xac670
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xac7cd
jmp 0xac827
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb0960
movl -0x34(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xac6a0
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
je 0xac800
jmp 0xac827
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xac794
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_caseup_utf32:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_50], rax
jmp short $+2
loc_AC792:
jmp short $+2
loc_AC794:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_51], al
jnb short loc_AC7C4
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_utf32_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_51], al
loc_AC7C4:
mov al, [rbp+var_51]
test al, 1
jnz short loc_AC7CD
jmp short loc_AC827
loc_AC7CD:
mov rdi, [rbp+var_50]
lea rsi, [rbp+var_30]
call my_toupper_utf32
mov eax, [rbp+var_34]
mov [rbp+var_58], eax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_uni_utf32
mov ecx, eax
mov eax, [rbp+var_58]
cmp eax, ecx
jz short loc_AC800
jmp short loc_AC827
loc_AC800:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_34]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_AC794
loc_AC827:
mov rax, [rbp+var_18]
add rsp, 60h
pop rbp
retn
| long long my_caseup_utf32(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+Fh] [rbp-51h]
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v9; // [rsp+18h] [rbp-48h]
unsigned long long v10; // [rsp+20h] [rbp-40h]
int v11; // [rsp+2Ch] [rbp-34h]
unsigned long long v12[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v13; // [rsp+40h] [rbp-20h]
long long v14; // [rsp+48h] [rbp-18h]
unsigned long long v15; // [rsp+50h] [rbp-10h]
long long v16; // [rsp+58h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12[1] = a5;
v10 = a3 + a2;
v9 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v15 < v10 )
{
v11 = my_utf32_uni(v16, (long long)v12, v15, v10, a5, a6);
v7 = v11 > 0;
}
if ( !v7 )
break;
my_toupper_utf32(v8, v12);
if ( v11 != (unsigned int)my_uni_utf32(v16, v12[0], v13, v9) )
break;
v15 += v11;
v13 += v11;
}
return v14;
}
| my_caseup_utf32:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001ac792
LAB_001ac792:
JMP 0x001ac794
LAB_001ac794:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x51],AL
JNC 0x001ac7c4
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x001ac670
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x51],AL
LAB_001ac7c4:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x001ac7cd
JMP 0x001ac827
LAB_001ac7cd:
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x30]
CALL 0x001b0960
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x58],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x001ac6a0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x58]
CMP EAX,ECX
JZ 0x001ac800
JMP 0x001ac827
LAB_001ac800:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001ac794
LAB_001ac827:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x60
POP RBP
RET
|
long my_caseup_utf32(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_utf32_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_toupper_utf32(uVar1,&local_38);
iVar3 = my_uni_utf32(local_10,local_38,local_28,param_4 + param_5);
if (local_3c != iVar3) {
return local_20;
}
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + local_3c;
}
return local_20;
}
| |
22,550 | inherit_charset_data | eloqsql/mysys/charset.c | static void
inherit_charset_data(struct charset_info_st *cs, CHARSET_INFO *refcs)
{
if (!cs->to_upper)
cs->to_upper= refcs->to_upper;
if (!cs->to_lower)
cs->to_lower= refcs->to_lower;
if (!cs->m_ctype)
cs->m_ctype= refcs->m_ctype;
if (!cs->tab_to_uni)
cs->tab_to_uni= refcs->tab_to_uni;
} | O3 | c | inherit_charset_data:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x50(%rdi)
jne 0x29240
movq 0x50(%rsi), %rax
movq %rax, 0x50(%rdi)
cmpq $0x0, 0x48(%rdi)
jne 0x2924f
movq 0x48(%rsi), %rax
movq %rax, 0x48(%rdi)
cmpq $0x0, 0x40(%rdi)
jne 0x2925e
movq 0x40(%rsi), %rax
movq %rax, 0x40(%rdi)
cmpq $0x0, 0x68(%rdi)
jne 0x2926d
movq 0x68(%rsi), %rax
movq %rax, 0x68(%rdi)
popq %rbp
retq
nop
| inherit_charset_data:
push rbp
mov rbp, rsp
cmp qword ptr [rdi+50h], 0
jnz short loc_29240
mov rax, [rsi+50h]
mov [rdi+50h], rax
loc_29240:
cmp qword ptr [rdi+48h], 0
jnz short loc_2924F
mov rax, [rsi+48h]
mov [rdi+48h], rax
loc_2924F:
cmp qword ptr [rdi+40h], 0
jnz short loc_2925E
mov rax, [rsi+40h]
mov [rdi+40h], rax
loc_2925E:
cmp qword ptr [rdi+68h], 0
jnz short loc_2926D
mov rax, [rsi+68h]
mov [rdi+68h], rax
loc_2926D:
pop rbp
retn
| long long inherit_charset_data(_QWORD *a1, _QWORD *a2)
{
long long result; // rax
if ( !a1[10] )
{
result = a2[10];
a1[10] = result;
}
if ( !a1[9] )
{
result = a2[9];
a1[9] = result;
}
if ( !a1[8] )
{
result = a2[8];
a1[8] = result;
}
if ( !a1[13] )
{
result = a2[13];
a1[13] = result;
}
return result;
}
| inherit_charset_data:
PUSH RBP
MOV RBP,RSP
CMP qword ptr [RDI + 0x50],0x0
JNZ 0x00129240
MOV RAX,qword ptr [RSI + 0x50]
MOV qword ptr [RDI + 0x50],RAX
LAB_00129240:
CMP qword ptr [RDI + 0x48],0x0
JNZ 0x0012924f
MOV RAX,qword ptr [RSI + 0x48]
MOV qword ptr [RDI + 0x48],RAX
LAB_0012924f:
CMP qword ptr [RDI + 0x40],0x0
JNZ 0x0012925e
MOV RAX,qword ptr [RSI + 0x40]
MOV qword ptr [RDI + 0x40],RAX
LAB_0012925e:
CMP qword ptr [RDI + 0x68],0x0
JNZ 0x0012926d
MOV RAX,qword ptr [RSI + 0x68]
MOV qword ptr [RDI + 0x68],RAX
LAB_0012926d:
POP RBP
RET
|
void inherit_charset_data(long param_1,long param_2)
{
if (*(long *)(param_1 + 0x50) == 0) {
*(int8 *)(param_1 + 0x50) = *(int8 *)(param_2 + 0x50);
}
if (*(long *)(param_1 + 0x48) == 0) {
*(int8 *)(param_1 + 0x48) = *(int8 *)(param_2 + 0x48);
}
if (*(long *)(param_1 + 0x40) == 0) {
*(int8 *)(param_1 + 0x40) = *(int8 *)(param_2 + 0x40);
}
if (*(long *)(param_1 + 0x68) == 0) {
*(int8 *)(param_1 + 0x68) = *(int8 *)(param_2 + 0x68);
}
return;
}
| |
22,551 | get_charset_by_csname | eloqsql/mysys/charset.c | CHARSET_INFO *
get_charset_by_csname(const char *cs_name, uint cs_flags, myf flags)
{
MY_CHARSET_LOADER loader;
my_charset_loader_init_mysys(&loader);
return my_charset_get_by_name(&loader, cs_name, cs_flags, flags);
} | O3 | c | get_charset_by_csname:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, %rcx
movl %esi, %edx
movq %rdi, %rsi
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
leaq -0xb8(%rbp), %rdi
movb $0x0, (%rdi)
leaq -0x1249(%rip), %rax # 0x29f96
movq %rax, 0x80(%rdi)
leaq -0x1248(%rip), %rax # 0x29fa5
movq %rax, 0x88(%rdi)
leaq -0x123b(%rip), %rax # 0x29fc0
movq %rax, 0x90(%rdi)
leaq -0x2d53(%rip), %rax # 0x284b6
movq %rax, 0x98(%rdi)
leaq 0x2c88b9(%rip), %rax # 0x2f3ad0
movq (%rax), %rax
movq %rax, 0xa0(%rdi)
leaq -0x124a(%rip), %rax # 0x29fde
movq %rax, 0xa8(%rdi)
callq 0x2b0d8
movq %fs:0x28, %rcx
cmpq -0x8(%rbp), %rcx
jne 0x2b24c
addq $0xc0, %rsp
popq %rbp
retq
callq 0x24370
| get_charset_by_csname:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov rcx, rdx
mov edx, esi
mov rsi, rdi
mov rax, fs:28h
mov [rbp+var_8], rax
lea rdi, [rbp+var_B8]
mov byte ptr [rdi], 0
lea rax, my_once_alloc_c
mov [rdi+80h], rax
lea rax, my_malloc_c
mov [rdi+88h], rax
lea rax, my_realloc_c
mov [rdi+90h], rax
lea rax, my_free
mov [rdi+98h], rax
lea rax, my_charset_error_reporter
mov rax, [rax]
mov [rdi+0A0h], rax
lea rax, add_collation
mov [rdi+0A8h], rax
call my_charset_get_by_name
mov rcx, fs:28h
cmp rcx, [rbp+var_8]
jnz short loc_2B24C
add rsp, 0C0h
pop rbp
retn
loc_2B24C:
call ___stack_chk_fail
| long long get_charset_by_csname(long long a1, unsigned int a2, long long a3)
{
_BYTE v4[128]; // [rsp+8h] [rbp-B8h] BYREF
long long ( *v5)(long long); // [rsp+88h] [rbp-38h]
long long ( *v6)(unsigned long long); // [rsp+90h] [rbp-30h]
long long ( *v7)(long long, unsigned long long); // [rsp+98h] [rbp-28h]
long long ( *v8)(long long); // [rsp+A0h] [rbp-20h]
long long ( *v9)(); // [rsp+A8h] [rbp-18h]
long long ( *v10)(unsigned int *); // [rsp+B0h] [rbp-10h]
unsigned long long v11; // [rsp+B8h] [rbp-8h]
v11 = __readfsqword(0x28u);
v4[0] = 0;
v5 = my_once_alloc_c;
v6 = my_malloc_c;
v7 = my_realloc_c;
v8 = my_free;
v9 = my_charset_error_reporter;
v10 = add_collation;
return my_charset_get_by_name((long long)v4, a1, a2, a3);
}
| get_charset_by_csname:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV RCX,RDX
MOV EDX,ESI
MOV RSI,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[RBP + -0xb8]
MOV byte ptr [RDI],0x0
LEA RAX,[0x129f96]
MOV qword ptr [RDI + 0x80],RAX
LEA RAX,[0x129fa5]
MOV qword ptr [RDI + 0x88],RAX
LEA RAX,[0x129fc0]
MOV qword ptr [RDI + 0x90],RAX
LEA RAX,[0x1284b6]
MOV qword ptr [RDI + 0x98],RAX
LEA RAX,[0x3f3ad0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDI + 0xa0],RAX
LEA RAX,[0x129fde]
MOV qword ptr [RDI + 0xa8],RAX
CALL 0x0012b0d8
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x8]
JNZ 0x0012b24c
ADD RSP,0xc0
POP RBP
RET
LAB_0012b24c:
CALL 0x00124370
|
void get_charset_by_csname(int8 param_1,int4 param_2,int8 param_3)
{
long in_FS_OFFSET;
int1 local_c0 [128];
code *local_40;
code *local_38;
code *local_30;
code *local_28;
int *local_20;
code *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_c0[0] = 0;
local_40 = my_once_alloc_c;
local_38 = my_malloc_c;
local_30 = my_realloc_c;
local_28 = my_free;
local_20 = my_charset_error_reporter;
local_18 = add_collation;
my_charset_get_by_name(local_c0,param_1,param_2,param_3);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
22,552 | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>) | llama.cpp/common/json.hpp | basic_json& operator=(basic_json other) noexcept (
std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value&&
std::is_nothrow_move_assignable<json_base_class_t>::value
)
{
// check that passed value is valid
other.assert_invariant();
using std::swap;
swap(m_data.m_type, other.m_data.m_type);
swap(m_data.m_value, other.m_data.m_value);
json_base_class_t::operator=(std::move(other));
set_parents();
assert_invariant();
return *this;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x7935e
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x7935e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdi, rsi
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov al, [r14]
mov cl, [rbx]
mov [r14], cl
mov [rbx], al
mov rax, [r14+8]
mov rcx, [rbx+8]
mov [r14+8], rcx
mov [rbx+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
| long long nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
long long a1,
long long a2)
{
char v2; // al
long long v3; // rax
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a2);
v2 = *(_BYTE *)a1;
*(_BYTE *)a1 = *(_BYTE *)a2;
*(_BYTE *)a2 = v2;
v3 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a2 + 8) = v3;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
return a1;
}
| operator=:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
MOV ESI,0x1
CALL 0x0017935e
MOV AL,byte ptr [R14]
MOV CL,byte ptr [RBX]
MOV byte ptr [R14],CL
MOV byte ptr [RBX],AL
MOV RAX,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [R14 + 0x8],RCX
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x0017935e
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >,
void>::TEMPNAMEPLACEHOLDERVALUE(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>) */
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
* __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_2)
{
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
int8 uVar2;
assert_invariant(SUB81(param_2,0));
bVar1 = *this;
*this = *param_2;
*param_2 = bVar1;
uVar2 = *(int8 *)(this + 8);
*(int8 *)(this + 8) = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = uVar2;
assert_invariant(SUB81(this,0));
return this;
}
| |
22,553 | mi_get_prev_key | eloqsql/storage/myisam/mi_search.c | static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
uchar *key, uchar *keypos,
uint *return_key_length)
{
uint nod_flag;
DBUG_ENTER("_mi_get_prev_key");
nod_flag=mi_test_if_nod(page);
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
{
*return_key_length=keyinfo->keylength;
bmove((uchar*) key,(uchar*) keypos- *return_key_length-nod_flag,
*return_key_length);
DBUG_RETURN(0);
}
else
{
page+=2+nod_flag;
key[0]=0; /* safety */
while (page < keypos)
{
*return_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,key);
if (*return_key_length == 0)
{
mi_print_error(info->s, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_RETURN(1);
}
}
}
DBUG_RETURN(0);
} | O0 | c | mi_get_prev_key:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xc04c3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
movl %eax, -0x40(%rbp)
jmp 0xc04ca
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0xc04ca
movl -0x40(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movzwl 0xa(%rax), %eax
andl $0x28, %eax
cmpl $0x0, %eax
jne 0xc0529
movq -0x18(%rbp), %rax
movzwl 0x12(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movl -0x3c(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, %edx
callq 0x2a130
movb $0x0, -0x1(%rbp)
jmp 0xc05aa
movl -0x3c(%rbp), %ecx
addl $0x2, %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xc05a2
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x28(%rbp), %rcx
leaq -0x20(%rbp), %rdx
callq *%rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xc05a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x268(%rax), %rsi
movl $0x7e, %edi
callq 0xaf8f0
callq 0xf7440
movl $0x7e, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0xc05aa
jmp 0xc0543
jmp 0xc05a4
jmp 0xc05a6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _mi_get_prev_key:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_C04C3
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+17Ch]
mov [rbp+var_40], eax
jmp short loc_C04CA
loc_C04C3:
xor eax, eax
mov [rbp+var_40], eax
jmp short $+2
loc_C04CA:
mov eax, [rbp+var_40]
mov [rbp+var_3C], eax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+0Ah]
and eax, 28h
cmp eax, 0
jnz short loc_C0529
mov rax, [rbp+var_18]
movzx ecx, word ptr [rax+12h]
mov rax, [rbp+var_38]
mov [rax], ecx
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_30]
mov rax, [rbp+var_38]
mov eax, [rax]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rsi, rax
mov eax, [rbp+var_3C]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rsi, rax
mov rax, [rbp+var_38]
mov eax, [rax]
mov edx, eax
call _memmove
mov [rbp+var_1], 0
jmp loc_C05AA
loc_C0529:
mov ecx, [rbp+var_3C]
add ecx, 2
mov rax, [rbp+var_20]
mov ecx, ecx
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
mov byte ptr [rax], 0
loc_C0543:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnb short loc_C05A2
mov rax, [rbp+var_18]
mov rax, [rax+48h]
mov rdi, [rbp+var_18]
mov esi, [rbp+var_3C]
mov rcx, [rbp+var_28]
lea rdx, [rbp+var_20]
call rax
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax], ecx
mov rax, [rbp+var_38]
cmp dword ptr [rax], 0
jnz short loc_C05A0
mov rax, [rbp+var_10]
mov rax, [rax]
mov rsi, [rax+268h]
mov edi, 7Eh ; '~'
call mi_report_error
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
mov [rbp+var_1], 1
jmp short loc_C05AA
loc_C05A0:
jmp short loc_C0543
loc_C05A2:
jmp short $+2
loc_C05A4:
jmp short $+2
loc_C05A6:
mov [rbp+var_1], 0
loc_C05AA:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char mi_get_prev_key(long long a1, long long a2, _BYTE *a3, _BYTE *a4, unsigned long long a5, _DWORD *a6)
{
const char *v6; // rsi
unsigned int v8; // [rsp+0h] [rbp-40h]
_BYTE *v12; // [rsp+20h] [rbp-20h] BYREF
long long v13; // [rsp+28h] [rbp-18h]
long long v14; // [rsp+30h] [rbp-10h]
v14 = a1;
v13 = a2;
v12 = a3;
if ( (*a3 & 0x80) != 0 )
v8 = *(_DWORD *)(*(_QWORD *)v14 + 380LL);
else
v8 = 0;
if ( (*(_WORD *)(v13 + 10) & 0x28) != 0 )
{
v12 += v8 + 2;
*a4 = 0;
while ( (unsigned long long)v12 < a5 )
{
*a6 = (*(long long ( **)(long long, _QWORD, _BYTE **, _BYTE *))(v13 + 72))(v13, v8, &v12, a4);
if ( !*a6 )
{
v6 = *(const char **)(*(_QWORD *)v14 + 616LL);
mi_report_error(126, (long long)v6);
*(_DWORD *)my_thread_var(126LL, v6) = 126;
return 1;
}
}
return 0;
}
else
{
*a6 = *(unsigned __int16 *)(v13 + 18);
memmove(a4, a5 - (unsigned int)*a6 - v8, (unsigned int)*a6);
return 0;
}
}
| _mi_get_prev_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001c04c3
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001c04ca
LAB_001c04c3:
XOR EAX,EAX
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001c04ca
LAB_001c04ca:
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0xa]
AND EAX,0x28
CMP EAX,0x0
JNZ 0x001c0529
MOV RAX,qword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RAX + 0x12]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RSI,RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RSI,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV EDX,EAX
CALL 0x0012a130
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001c05aa
LAB_001c0529:
MOV ECX,dword ptr [RBP + -0x3c]
ADD ECX,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],0x0
LAB_001c0543:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001c05a2
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x48]
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x28]
LEA RDX,[RBP + -0x20]
CALL RAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
CMP dword ptr [RAX],0x0
JNZ 0x001c05a0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x268]
MOV EDI,0x7e
CALL 0x001af8f0
CALL 0x001f7440
MOV dword ptr [RAX],0x7e
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001c05aa
LAB_001c05a0:
JMP 0x001c0543
LAB_001c05a2:
JMP 0x001c05a4
LAB_001c05a4:
JMP 0x001c05a6
LAB_001c05a6:
MOV byte ptr [RBP + -0x1],0x0
LAB_001c05aa:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1
_mi_get_prev_key(long *param_1,long param_2,byte *param_3,int1 *param_4,byte *param_5,
uint *param_6)
{
uint uVar1;
int4 *puVar2;
uint local_48;
byte *local_28;
long local_20;
long *local_18;
int1 local_9;
if ((*param_3 & 0x80) == 0) {
local_48 = 0;
}
else {
local_48 = *(uint *)(*param_1 + 0x17c);
}
local_20 = param_2;
local_18 = param_1;
if ((*(ushort *)(param_2 + 10) & 0x28) == 0) {
*param_6 = (uint)*(ushort *)(param_2 + 0x12);
local_28 = param_3;
memmove(param_4,param_5 + (-(ulong)local_48 - (ulong)*param_6),(ulong)*param_6);
local_9 = 0;
}
else {
local_28 = param_3 + (local_48 + 2);
*param_4 = 0;
do {
if (param_5 <= local_28) {
return 0;
}
uVar1 = (**(code **)(local_20 + 0x48))(local_20,local_48,&local_28,param_4);
*param_6 = uVar1;
} while (*param_6 != 0);
mi_report_error(0x7e,*(int8 *)(*local_18 + 0x268));
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7e;
local_9 = 1;
}
return local_9;
}
| |
22,554 | ast_create_variable_def | tsotchke[P]eshkol/src/frontend/ast/create/ast_create.c | AstNode* ast_create_variable_def(Arena* arena, AstNode* name, AstNode* value, size_t line, size_t column) {
AstNode* node = ast_create_node(arena, AST_VARIABLE_DEF, line, column);
if (!node) {
return NULL;
}
node->as.variable_def.name = name;
node->as.variable_def.value = value;
return node;
} | O0 | c | ast_create_variable_def:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x1c, %esi
callq 0x5160
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6357
movq $0x0, -0x8(%rbp)
jmp 0x6377
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ast_create_variable_def:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov esi, 1Ch
call ast_create_node
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jnz short loc_6357
mov [rbp+var_8], 0
jmp short loc_6377
loc_6357:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_38]
mov [rax+48h], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_38]
mov [rax+50h], rcx
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_6377:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long ast_create_variable_def(long long a1, long long a2, long long a3, long long a4, long long a5)
{
long long node; // [rsp+8h] [rbp-38h]
node = ast_create_node(a1, 28, a4, a5);
if ( !node )
return 0LL;
*(_QWORD *)(node + 72) = a2;
*(_QWORD *)(node + 80) = a3;
return node;
}
| ast_create_variable_def:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV ESI,0x1c
CALL 0x00105160
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x00106357
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00106377
LAB_00106357:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x48],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x50],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_00106377:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
long ast_create_variable_def
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int8 local_10;
local_10 = ast_create_node(param_1,0x1c,param_4,param_5);
if (local_10 == 0) {
local_10 = 0;
}
else {
*(int8 *)(local_10 + 0x48) = param_2;
*(int8 *)(local_10 + 0x50) = param_3;
}
return local_10;
}
| |
22,555 | inline_mysql_file_create_with_symlink | eloqsql/include/mysql/psi/mysql_file.h | static inline File
inline_mysql_file_create_with_symlink(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *linkname, const char *filename, int create_flags,
int access_flags, myf flags)
{
File file;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_CREATE, filename,
&locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
file= my_create_with_symlink(linkname, filename, create_flags, access_flags,
flags);
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);
return file;
}
#endif
file= my_create_with_symlink(linkname, filename, create_flags, access_flags,
flags);
return file;
} | O3 | c | inline_mysql_file_create_with_symlink:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movl %r8d, %r14d
movq %rcx, %r15
movq %rdx, %r12
movl %esi, -0x2c(%rbp)
movl %edi, %esi
leaq 0x2f5ebf(%rip), %rax # 0x388010
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %r13
xorl %edx, %edx
movq %r13, %r8
callq *0x148(%rax)
movq %rax, (%r13)
testq %rax, %rax
jne 0x92196
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %r14d, %ecx
movq %rbx, %r8
callq 0xa248c
movl %eax, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f5e73(%rip), %r13 # 0x388010
movq (%r13), %rcx
leaq 0x4b279(%rip), %rsi # 0xdd421
movq %rax, %rdi
movl -0x2c(%rbp), %edx
callq *0x1f0(%rcx)
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %r14d, %ecx
movq %rbx, %r8
callq 0xa248c
movl %eax, %ebx
movq (%r13), %rax
movq -0x38(%rbp), %rdi
movl %ebx, %esi
callq *0x200(%rax)
jmp 0x92185
| inline_mysql_file_create_with_symlink_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, r9
mov r14d, r8d
mov r15, rcx
mov r12, rdx
mov [rbp+var_2C], esi
mov esi, edi
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_80]
lea r13, [rbp+var_38]
xor edx, edx
mov r8, r13
call qword ptr [rax+148h]
mov [r13+0], rax
test rax, rax
jnz short loc_92196
mov rdi, r12
mov rsi, r15
xor edx, edx
mov ecx, r14d
mov r8, rbx
call my_create_with_symlink
mov ebx, eax
loc_92185:
mov eax, ebx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_92196:
lea r13, PSI_server
mov rcx, [r13+0]
lea rsi, aWorkspaceLlm4b_19; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov edx, [rbp+var_2C]
call qword ptr [rcx+1F0h]
mov rdi, r12
mov rsi, r15
xor edx, edx
mov ecx, r14d
mov r8, rbx
call my_create_with_symlink
mov ebx, eax
mov rax, [r13+0]
mov rdi, [rbp+var_38]
mov esi, ebx
call qword ptr [rax+200h]
jmp short loc_92185
| long long inline_mysql_file_create_with_symlink_0(
unsigned int a1,
unsigned int a2,
long long a3,
long long a4,
unsigned int a5,
long long a6)
{
long long v10; // rax
_BYTE v12[72]; // [rsp+0h] [rbp-80h] BYREF
long long v13; // [rsp+48h] [rbp-38h] BYREF
unsigned int v14; // [rsp+54h] [rbp-2Ch]
v14 = a2;
v10 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, long long *))PSI_server[41])(v12, a1, 0LL, a4, &v13);
v13 = v10;
if ( v10 )
{
((void ( *)(long long, const char *, _QWORD))PSI_server[62])(
v10,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_create.c",
v14);
a6 = (unsigned int)my_create_with_symlink(a3, a4, 0LL, a5, a6);
((void ( *)(long long, long long))PSI_server[64])(v13, a6);
}
else
{
LODWORD(a6) = my_create_with_symlink(a3, a4, 0LL, a5, a6);
}
return (unsigned int)a6;
}
| inline_mysql_file_create_with_symlink:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,R9
MOV R14D,R8D
MOV R15,RCX
MOV R12,RDX
MOV dword ptr [RBP + -0x2c],ESI
MOV ESI,EDI
LEA RAX,[0x488010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x80]
LEA R13,[RBP + -0x38]
XOR EDX,EDX
MOV R8,R13
CALL qword ptr [RAX + 0x148]
MOV qword ptr [R13],RAX
TEST RAX,RAX
JNZ 0x00192196
MOV RDI,R12
MOV RSI,R15
XOR EDX,EDX
MOV ECX,R14D
MOV R8,RBX
CALL 0x001a248c
MOV EBX,EAX
LAB_00192185:
MOV EAX,EBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00192196:
LEA R13,[0x488010]
MOV RCX,qword ptr [R13]
LEA RSI,[0x1dd421]
MOV RDI,RAX
MOV EDX,dword ptr [RBP + -0x2c]
CALL qword ptr [RCX + 0x1f0]
MOV RDI,R12
MOV RSI,R15
XOR EDX,EDX
MOV ECX,R14D
MOV R8,RBX
CALL 0x001a248c
MOV EBX,EAX
MOV RAX,qword ptr [R13]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,EBX
CALL qword ptr [RAX + 0x200]
JMP 0x00192185
|
int4
inline_mysql_file_create_with_symlink
(int4 param_1,int4 param_2,int8 param_3,int8 param_4,
int4 param_5,int8 param_6)
{
int4 uVar1;
int1 local_88 [72];
long local_40;
int4 local_34;
local_34 = param_2;
local_40 = (**(code **)(PSI_server + 0x148))(local_88,param_1,0,param_4,&local_40);
if (local_40 == 0) {
uVar1 = my_create_with_symlink(param_3,param_4,0,param_5,param_6);
}
else {
(**(code **)(PSI_server + 0x1f0))
(local_40,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_create.c",
local_34);
uVar1 = my_create_with_symlink(param_3,param_4,0,param_5,param_6);
(**(code **)(PSI_server + 0x200))(local_40,uVar1);
}
return uVar1;
}
| |
22,556 | nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type) | monkey531[P]llama/common/json.hpp | static const char* token_type_name(const token_type t) noexcept
{
switch (t)
{
case token_type::uninitialized:
return "<uninitialized>";
case token_type::literal_true:
return "true literal";
case token_type::literal_false:
return "false literal";
case token_type::literal_null:
return "null literal";
case token_type::value_string:
return "string literal";
case token_type::value_unsigned:
case token_type::value_integer:
case token_type::value_float:
return "number literal";
case token_type::begin_array:
return "'['";
case token_type::begin_object:
return "'{'";
case token_type::end_array:
return "']'";
case token_type::end_object:
return "'}'";
case token_type::name_separator:
return "':'";
case token_type::value_separator:
return "','";
case token_type::parse_error:
return "<parse error>";
case token_type::end_of_input:
return "end of input";
case token_type::literal_or_value:
return "'[', '{', or a literal";
// LCOV_EXCL_START
default: // catch non-enum values
return "unknown token";
// LCOV_EXCL_STOP
}
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type):
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x10, %rax
ja 0xcde90
movq -0x18(%rsp), %rax
leaq 0xf41b1(%rip), %rcx # 0x1c1f54
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xf7895(%rip), %rax # 0x1c5648
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf7894(%rip), %rax # 0x1c5658
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf7890(%rip), %rax # 0x1c5665
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf788d(%rip), %rax # 0x1c5673
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf7889(%rip), %rax # 0x1c5680
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf7887(%rip), %rax # 0x1c568f
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf7885(%rip), %rax # 0x1c569e
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf787b(%rip), %rax # 0x1c56a2
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf7871(%rip), %rax # 0x1c56a6
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf7867(%rip), %rax # 0x1c56aa
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf785d(%rip), %rax # 0x1c56ae
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf7853(%rip), %rax # 0x1c56b2
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf7849(%rip), %rax # 0x1c56b6
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xff345(%rip), %rax # 0x1cd1c0
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf783b(%rip), %rax # 0x1c56c4
movq %rax, -0x8(%rsp)
jmp 0xcde9c
leaq 0xf7844(%rip), %rax # 0x1c56db
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE:
mov [rsp+var_C], edi
mov eax, [rsp+var_C]
mov [rsp+var_18], rax
sub rax, 10h; switch 17 cases
ja def_CDDAA; jumptable 00000000000CDDAA default case
mov rax, [rsp+var_18]
lea rcx, jpt_CDDAA
movsxd rax, ds:(jpt_CDDAA - 1C1F54h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_CDDAC:
lea rax, aUninitialized; jumptable 00000000000CDDAA case 0
mov [rsp+var_8], rax
jmp loc_CDE9C
loc_CDDBD:
lea rax, aTrueLiteral; jumptable 00000000000CDDAA case 1
mov [rsp+var_8], rax
jmp loc_CDE9C
loc_CDDCE:
lea rax, aFalseLiteral; jumptable 00000000000CDDAA case 2
mov [rsp+var_8], rax
jmp loc_CDE9C
loc_CDDDF:
lea rax, aNullLiteral; jumptable 00000000000CDDAA case 3
mov [rsp+var_8], rax
jmp loc_CDE9C
loc_CDDF0:
lea rax, aStringLiteral; jumptable 00000000000CDDAA case 4
mov [rsp+var_8], rax
jmp loc_CDE9C
loc_CDE01:
lea rax, aNumberLiteral; jumptable 00000000000CDDAA cases 5-7
mov [rsp+var_8], rax
jmp loc_CDE9C
loc_CDE12:
lea rax, asc_1C569E; jumptable 00000000000CDDAA case 8
mov [rsp+var_8], rax
jmp short loc_CDE9C
loc_CDE20:
lea rax, asc_1C56A2; jumptable 00000000000CDDAA case 9
mov [rsp+var_8], rax
jmp short loc_CDE9C
loc_CDE2E:
lea rax, asc_1C56A6; jumptable 00000000000CDDAA case 10
mov [rsp+var_8], rax
jmp short loc_CDE9C
loc_CDE3C:
lea rax, asc_1C56AA; jumptable 00000000000CDDAA case 11
mov [rsp+var_8], rax
jmp short loc_CDE9C
loc_CDE4A:
lea rax, asc_1C56AE; jumptable 00000000000CDDAA case 12
mov [rsp+var_8], rax
jmp short loc_CDE9C
loc_CDE58:
lea rax, asc_1C56B2; jumptable 00000000000CDDAA case 13
mov [rsp+var_8], rax
jmp short loc_CDE9C
loc_CDE66:
lea rax, aParseError_1; jumptable 00000000000CDDAA case 14
mov [rsp+var_8], rax
jmp short loc_CDE9C
loc_CDE74:
lea rax, aUnexpectedEndO_7+0Bh; jumptable 00000000000CDDAA case 15
mov [rsp+var_8], rax
jmp short loc_CDE9C
loc_CDE82:
lea rax, aOrALiteral; jumptable 00000000000CDDAA case 16
mov [rsp+var_8], rax
jmp short loc_CDE9C
def_CDDAA:
lea rax, aUnknownToken; jumptable 00000000000CDDAA default case
mov [rsp+var_8], rax
loc_CDE9C:
mov rax, [rsp+var_8]
retn
| char * nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::token_type_name(
int a1)
{
char *v2; // [rsp+10h] [rbp-8h]
switch ( a1 )
{
case 0:
v2 = "<uninitialized>";
break;
case 1:
v2 = "true literal";
break;
case 2:
v2 = "false literal";
break;
case 3:
v2 = "null literal";
break;
case 4:
v2 = "string literal";
break;
case 5:
case 6:
case 7:
v2 = "number literal";
break;
case 8:
v2 = "'['";
break;
case 9:
v2 = "'{'";
break;
case 10:
v2 = "']'";
break;
case 11:
v2 = "'}'";
break;
case 12:
v2 = "':'";
break;
case 13:
v2 = "','";
break;
case 14:
v2 = "<parse error>";
break;
case 15:
v2 = "end of input";
break;
case 16:
v2 = "'[', '{', or a literal";
break;
default:
v2 = "unknown token";
break;
}
return v2;
}
| token_type_name:
MOV dword ptr [RSP + -0xc],EDI
MOV EAX,dword ptr [RSP + -0xc]
MOV qword ptr [RSP + -0x18],RAX
SUB RAX,0x10
JA 0x001cde90
MOV RAX,qword ptr [RSP + -0x18]
LEA RCX,[0x2c1f54]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RAX,[0x2c5648]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_1:
LEA RAX,[0x2c5658]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_2:
LEA RAX,[0x2c5665]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_3:
LEA RAX,[0x2c5673]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_4:
LEA RAX,[0x2c5680]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_5:
LEA RAX,[0x2c568f]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_8:
LEA RAX,[0x2c569e]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_9:
LEA RAX,[0x2c56a2]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_a:
LEA RAX,[0x2c56a6]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_b:
LEA RAX,[0x2c56aa]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_c:
LEA RAX,[0x2c56ae]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_d:
LEA RAX,[0x2c56b2]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_e:
LEA RAX,[0x2c56b6]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_f:
LEA RAX,[0x2cd1c0]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
caseD_10:
LEA RAX,[0x2c56c4]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001cde9c
default:
LEA RAX,[0x2c56db]
MOV qword ptr [RSP + -0x8],RAX
LAB_001cde9c:
MOV RAX,qword ptr [RSP + -0x8]
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::token_type) */
char * nlohmann::json_abi_v3_11_3::detail::
lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::token_type_name(int4 param_1)
{
char *local_8;
switch(param_1) {
case 0:
local_8 = "<uninitialized>";
break;
case 1:
local_8 = "true literal";
break;
case 2:
local_8 = "false literal";
break;
case 3:
local_8 = "null literal";
break;
case 4:
local_8 = "string literal";
break;
case 5:
case 6:
case 7:
local_8 = "number literal";
break;
case 8:
local_8 = "\'[\'";
break;
case 9:
local_8 = "\'{\'";
break;
case 10:
local_8 = "\']\'";
break;
case 0xb:
local_8 = "\'}\'";
break;
case 0xc:
local_8 = "\':\'";
break;
case 0xd:
local_8 = "\',\'";
break;
case 0xe:
local_8 = "<parse error>";
break;
case 0xf:
local_8 = "end of input";
break;
case 0x10:
local_8 = "\'[\', \'{\', or a literal";
break;
default:
local_8 = "unknown token";
}
return local_8;
}
| |
22,557 | nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type) | monkey531[P]llama/common/json.hpp | static const char* token_type_name(const token_type t) noexcept
{
switch (t)
{
case token_type::uninitialized:
return "<uninitialized>";
case token_type::literal_true:
return "true literal";
case token_type::literal_false:
return "false literal";
case token_type::literal_null:
return "null literal";
case token_type::value_string:
return "string literal";
case token_type::value_unsigned:
case token_type::value_integer:
case token_type::value_float:
return "number literal";
case token_type::begin_array:
return "'['";
case token_type::begin_object:
return "'{'";
case token_type::end_array:
return "']'";
case token_type::end_object:
return "'}'";
case token_type::name_separator:
return "':'";
case token_type::value_separator:
return "','";
case token_type::parse_error:
return "<parse error>";
case token_type::end_of_input:
return "end of input";
case token_type::literal_or_value:
return "'[', '{', or a literal";
// LCOV_EXCL_START
default: // catch non-enum values
return "unknown token";
// LCOV_EXCL_STOP
}
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::token_type):
cmpl $0x10, %edi
ja 0x51aa6
movl %edi, %eax
leaq 0x5d6e6(%rip), %rcx # 0xaf184
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x6115b(%rip), %rax # 0xb2c08
retq
| _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE:
cmp edi, 10h
ja short loc_51AA6
mov eax, edi
lea rcx, unk_AF184
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_51AA6:
lea rax, aUnknownToken; "unknown token"
retn
| const char * nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::token_type_name(
unsigned int a1)
{
if ( a1 > 0x10 )
return "unknown token";
else
return (char *)dword_AF184 + dword_AF184[a1];
}
| token_type_name:
CMP EDI,0x10
JA 0x00151aa6
MOV EAX,EDI
LEA RCX,[0x1af184]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_00151aa6:
LEA RAX,[0x1b2c08]
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::token_type) */
char * nlohmann::json_abi_v3_11_3::detail::
lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::token_type_name(uint param_1)
{
if (param_1 < 0x11) {
return &DAT_001af184 + *(int *)(&DAT_001af184 + (ulong)param_1 * 4);
}
return "unknown token";
}
| |
22,558 | ftb_parse_query | eloqsql/storage/myisam/ft_boolean_search.c | static int _ftb_parse_query(FTB *ftb, uchar *query, uint len,
struct st_mysql_ftparser *parser)
{
MYSQL_FTPARSER_PARAM *param;
MY_FTB_PARAM ftb_param;
DBUG_ENTER("_ftb_parse_query");
DBUG_ASSERT(parser);
if (ftb->state != UNINITIALIZED)
DBUG_RETURN(0);
if (! (param= ftparser_call_initializer(ftb->info, ftb->keynr, 0)))
DBUG_RETURN(1);
ftb_param.ftb= ftb;
ftb_param.depth= 0;
ftb_param.ftbe= ftb->root;
ftb_param.up_quot= 0;
param->mysql_parse= ftb_parse_query_internal;
param->mysql_add_word= ftb_query_add_word;
param->mysql_ftparam= (void *)&ftb_param;
param->cs= ftb->charset;
param->doc= (char*) query;
param->length= len;
param->flags= 0;
param->mode= MYSQL_FTPARSER_FULL_BOOLEAN_INFO;
DBUG_RETURN(parser->parse(param));
} | O0 | c | ftb_parse_query:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0xa0459
movq -0x10(%rbp), %rax
cmpl $0x0, 0x348(%rax)
je 0xa0474
jmp 0xa0468
movl $0x0, -0x4(%rbp)
jmp 0xa053e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x340(%rax), %esi
xorl %edx, %edx
callq 0xa4630
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xa04a5
jmp 0xa0499
movl $0x1, -0x4(%rbp)
jmp 0xa053e
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rax
leaq 0x118d(%rip), %rcx # 0xa1660
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
leaq 0x121f(%rip), %rcx # 0xa1700
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
leaq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x30(%rbp), %rax
movl $0x2, 0x38(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ftb_parse_query:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
jmp short $+2
loc_A0459:
mov rax, [rbp+var_10]
cmp dword ptr [rax+348h], 0
jz short loc_A0474
jmp short $+2
loc_A0468:
mov [rbp+var_4], 0
jmp loc_A053E
loc_A0474:
mov rax, [rbp+var_10]
mov rdi, [rax+8]
mov rax, [rbp+var_10]
mov esi, [rax+340h]
xor edx, edx
call ftparser_call_initializer
mov [rbp+var_30], rax
cmp rax, 0
jnz short loc_A04A5
jmp short $+2
loc_A0499:
mov [rbp+var_4], 1
jmp loc_A053E
loc_A04A5:
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
mov [rbp+var_38], 0
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov [rbp+var_48], rax
mov [rbp+var_40], 0
mov rax, [rbp+var_30]
lea rcx, ftb_parse_query_internal
mov [rax], rcx
mov rax, [rbp+var_30]
lea rcx, ftb_query_add_word
mov [rax+8], rcx
mov rax, [rbp+var_30]
lea rcx, [rbp+var_50]
mov [rax+18h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_30]
mov [rax+20h], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_30]
mov [rax+28h], rcx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_30]
mov [rax+30h], ecx
mov rax, [rbp+var_30]
mov dword ptr [rax+34h], 0
mov rax, [rbp+var_30]
mov dword ptr [rax+38h], 2
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rdi, [rbp+var_30]
call rax
mov [rbp+var_4], eax
loc_A053E:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long ftb_parse_query(long long a1, long long a2, unsigned int a3, long long a4)
{
long long v4; // rsi
long long v5; // rdx
long long v6; // r8
long long v7; // r9
long long v8; // rcx
long long v10; // [rsp+0h] [rbp-50h] BYREF
long long v11; // [rsp+8h] [rbp-48h]
long long v12; // [rsp+10h] [rbp-40h]
int v13; // [rsp+18h] [rbp-38h]
long long v14; // [rsp+20h] [rbp-30h]
long long v15; // [rsp+28h] [rbp-28h]
unsigned int v16; // [rsp+34h] [rbp-1Ch]
long long v17; // [rsp+38h] [rbp-18h]
long long v18; // [rsp+40h] [rbp-10h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
if ( *(_DWORD *)(a1 + 840) )
{
return 0;
}
else
{
v4 = *(unsigned int *)(v18 + 832);
v14 = ftparser_call_initializer(*(_QWORD *)(v18 + 8), v4, 0LL);
if ( v14 )
{
v10 = v18;
v13 = 0;
v11 = *(_QWORD *)(v18 + 24);
v12 = 0LL;
*(_QWORD *)v14 = ftb_parse_query_internal;
*(_QWORD *)(v14 + 8) = ftb_query_add_word;
*(_QWORD *)(v14 + 24) = &v10;
*(_QWORD *)(v14 + 32) = *(_QWORD *)(v18 + 16);
*(_QWORD *)(v14 + 40) = v17;
v8 = v16;
*(_DWORD *)(v14 + 48) = v16;
*(_DWORD *)(v14 + 52) = 0;
*(_DWORD *)(v14 + 56) = 2;
return (unsigned int)(*(long long ( **)(long long, long long, long long, long long, long long, long long, long long, long long, long long, int))(v15 + 8))(
v14,
v4,
v5,
v8,
v6,
v7,
v10,
v11,
v12,
v13);
}
else
{
return 1;
}
}
}
| _ftb_parse_query:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
JMP 0x001a0459
LAB_001a0459:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x348],0x0
JZ 0x001a0474
JMP 0x001a0468
LAB_001a0468:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001a053e
LAB_001a0474:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX + 0x340]
XOR EDX,EDX
CALL 0x001a4630
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,0x0
JNZ 0x001a04a5
JMP 0x001a0499
LAB_001a0499:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001a053e
LAB_001a04a5:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x50],RAX
MOV dword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x40],0x0
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x1a1660]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x1a1700]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x50]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x28],RCX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x30],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x34],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x38],0x2
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x30]
CALL RAX
MOV dword ptr [RBP + -0x4],EAX
LAB_001a053e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4 _ftb_parse_query(long param_1,int8 param_2,int4 param_3,long param_4)
{
long local_58;
int8 local_50;
int8 local_48;
int4 local_40;
int8 *local_38;
long local_30;
int4 local_24;
int8 local_20;
long local_18;
int4 local_c;
if (*(int *)(param_1 + 0x348) == 0) {
local_30 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
local_38 = (int8 *)
ftparser_call_initializer
(*(int8 *)(param_1 + 8),*(int4 *)(param_1 + 0x340),0);
if (local_38 == (int8 *)0x0) {
local_c = 1;
}
else {
local_58 = local_18;
local_40 = 0;
local_50 = *(int8 *)(local_18 + 0x18);
local_48 = 0;
*local_38 = ftb_parse_query_internal;
local_38[1] = ftb_query_add_word;
local_38[3] = &local_58;
local_38[4] = *(int8 *)(local_18 + 0x10);
local_38[5] = local_20;
*(int4 *)(local_38 + 6) = local_24;
*(int4 *)((long)local_38 + 0x34) = 0;
*(int4 *)(local_38 + 7) = 2;
local_c = (**(code **)(local_30 + 8))(local_38);
}
}
else {
local_c = 0;
}
return local_c;
}
| |
22,559 | js_typed_array_get_toStringTag | bluesky950520[P]quickjs/quickjs.c | static JSValue js_typed_array_get_toStringTag(JSContext *ctx,
JSValue this_val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
return JS_UNDEFINED;
p = JS_VALUE_GET_OBJ(this_val);
if (!(p->class_id >= JS_CLASS_UINT8C_ARRAY &&
p->class_id <= JS_CLASS_FLOAT64_ARRAY))
return JS_UNDEFINED;
return JS_AtomToString(ctx, ctx->rt->class_array[p->class_id].class_name);
} | O2 | c | js_typed_array_get_toStringTag:
movq %rdx, %rax
pushq $0x3
popq %rdx
cmpl $-0x1, %eax
jne 0x700e1
movzwl 0x6(%rsi), %eax
leal -0x15(%rax), %ecx
cmpw $0xb, %cx
ja 0x700e1
pushq %rax
movq 0x18(%rdi), %rcx
movq 0x80(%rcx), %rcx
imulq $0x28, %rax, %rax
movl 0x4(%rcx,%rax), %esi
callq 0x1e540
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %eax
addq $0x8, %rsp
jmp 0x700e5
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
retq
| js_typed_array_get_toStringTag:
mov rax, rdx
push 3
pop rdx
cmp eax, 0FFFFFFFFh
jnz short loc_700E1
movzx eax, word ptr [rsi+6]
lea ecx, [rax-15h]
cmp cx, 0Bh
ja short loc_700E1
push rax
mov rcx, [rdi+18h]
mov rcx, [rcx+80h]
imul rax, 28h ; '('
mov esi, [rcx+rax+4]
call JS_AtomToString
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov eax, eax
add rsp, 8
jmp short loc_700E5
loc_700E1:
xor eax, eax
xor ecx, ecx
loc_700E5:
or rax, rcx
retn
| unsigned long long js_typed_array_get_toStringTag(long long a1, long long a2, int a3)
{
long long v3; // rax
unsigned long long v4; // rcx
long long v5; // rax
if ( a3 == -1 && (v3 = *(unsigned __int16 *)(a2 + 6), (unsigned __int16)(v3 - 21) <= 0xBu) )
{
v5 = JS_AtomToString(a1, *(_DWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 40 * v3 + 4));
v4 = v5 & 0xFFFFFFFF00000000LL;
v5 = (unsigned int)v5;
}
else
{
v5 = 0LL;
v4 = 0LL;
}
return v4 | v5;
}
| js_typed_array_get_toStringTag:
MOV RAX,RDX
PUSH 0x3
POP RDX
CMP EAX,-0x1
JNZ 0x001700e1
MOVZX EAX,word ptr [RSI + 0x6]
LEA ECX,[RAX + -0x15]
CMP CX,0xb
JA 0x001700e1
PUSH RAX
MOV RCX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RCX + 0x80]
IMUL RAX,RAX,0x28
MOV ESI,dword ptr [RCX + RAX*0x1 + 0x4]
CALL 0x0011e540
MOV RCX,-0x100000000
AND RCX,RAX
MOV EAX,EAX
ADD RSP,0x8
JMP 0x001700e5
LAB_001700e1:
XOR EAX,EAX
XOR ECX,ECX
LAB_001700e5:
OR RAX,RCX
RET
|
ulong js_typed_array_get_toStringTag(long param_1,long param_2,int param_3)
{
ulong uVar1;
ulong uVar2;
if ((param_3 == -1) && ((ushort)(*(ushort *)(param_2 + 6) - 0x15) < 0xc)) {
uVar1 = JS_AtomToString(param_1,*(int4 *)
(*(long *)(*(long *)(param_1 + 0x18) + 0x80) + 4 +
(ulong)*(ushort *)(param_2 + 6) * 0x28),3);
uVar2 = uVar1 & 0xffffffff00000000;
uVar1 = uVar1 & 0xffffffff;
}
else {
uVar1 = 0;
uVar2 = 0;
}
return uVar1 | uVar2;
}
| |
22,560 | my_strnxfrm_simple | eloqsql/strings/ctype-simple.c | size_t my_strnxfrm_simple(CHARSET_INFO * cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *d0= dst;
dst= d0 + my_strnxfrm_simple_internal(cs, dst, dstlen, &nweights,
src, srclen);
return my_strxfrm_pad_desc_and_reverse(cs, d0, dst, d0 + dstlen,
nweights, flags, 0);
} | O0 | c | my_strnxfrm_simple:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x1c(%rbp), %rcx
callq 0xa1830
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xa19d0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_simple:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
lea rcx, [rbp+var_1C]
call my_strnxfrm_simple_internal
mov rcx, rax
mov rax, [rbp+var_40]
add rax, rcx
mov [rbp+var_10], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_38]
add rcx, [rbp+var_18]
mov r8d, [rbp+var_1C]
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+50h+var_50], 0
call my_strxfrm_pad_desc_and_reverse
add rsp, 50h
pop rbp
retn
| long long my_strnxfrm_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
unsigned __int8 *a5,
unsigned long long a6,
int a7)
{
_BYTE *v7; // rax
unsigned int v9; // [rsp+34h] [rbp-1Ch] BYREF
unsigned long long v10; // [rsp+38h] [rbp-18h]
unsigned __int8 *v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v7 = my_strnxfrm_simple_internal(a1, a2, a3, &v9, a5, a6);
v11 = &a2[(_QWORD)v7];
return my_strxfrm_pad_desc_and_reverse(v12, (_DWORD)a2, (int)v7 + (int)a2, (int)v10 + (int)a2, v9, a7, 0);
}
| my_strnxfrm_simple:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x1c]
CALL 0x001a1830
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,qword ptr [RBP + -0x18]
MOV R8D,dword ptr [RBP + -0x1c]
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x001a19d0
ADD RSP,0x50
POP RBP
RET
|
void my_strnxfrm_simple(int8 param_1,long param_2,long param_3,int4 param_4,
int8 param_5,int8 param_6,int4 param_7)
{
int4 local_24;
long local_20;
long local_18;
int8 local_10;
local_24 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_18 = my_strnxfrm_simple_internal(param_1,param_2,param_3,&local_24,param_5,param_6);
local_18 = param_2 + local_18;
my_strxfrm_pad_desc_and_reverse(local_10,param_2,local_18,param_2 + local_20,local_24,param_7,0);
return;
}
| |
22,561 | fill_buffer | eloqsql/storage/myisam/mi_packrec.c | static void fill_buffer(MI_BIT_BUFF *bit_buff)
{
if (bit_buff->pos >= bit_buff->end)
{
bit_buff->error= 1;
bit_buff->current_byte=0;
return;
}
#if BITS_SAVED == 64
bit_buff->current_byte= ((((uint) ((uchar) bit_buff->pos[7]))) |
(((uint) ((uchar) bit_buff->pos[6])) << 8) |
(((uint) ((uchar) bit_buff->pos[5])) << 16) |
(((uint) ((uchar) bit_buff->pos[4])) << 24) |
((ulonglong)
((((uint) ((uchar) bit_buff->pos[3]))) |
(((uint) ((uchar) bit_buff->pos[2])) << 8) |
(((uint) ((uchar) bit_buff->pos[1])) << 16) |
(((uint) ((uchar) bit_buff->pos[0])) << 24)) << 32));
bit_buff->pos+=8;
#else
#if BITS_SAVED == 32
bit_buff->current_byte= (((uint) ((uchar) bit_buff->pos[3])) |
(((uint) ((uchar) bit_buff->pos[2])) << 8) |
(((uint) ((uchar) bit_buff->pos[1])) << 16) |
(((uint) ((uchar) bit_buff->pos[0])) << 24));
bit_buff->pos+=4;
#else
bit_buff->current_byte= (uint) (((uint) ((uchar) bit_buff->pos[1])) |
(((uint) ((uchar) bit_buff->pos[0])) << 8));
bit_buff->pos+=2;
#endif
#endif
} | O0 | c | fill_buffer:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xbc3a1
movq -0x8(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
jmp 0xbc3f5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl 0x3(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl 0x2(%rax), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl 0x1(%rax), %eax
shll $0x10, %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
shll $0x18, %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw (%rax,%rax)
| fill_buffer_0:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jb short loc_BC3A1
mov rax, [rbp+var_8]
mov dword ptr [rax+28h], 1
mov rax, [rbp+var_8]
mov dword ptr [rax], 0
jmp short loc_BC3F5
loc_BC3A1:
mov rax, [rbp+var_8]
mov rax, [rax+8]
movzx ecx, byte ptr [rax+3]
mov rax, [rbp+var_8]
mov rax, [rax+8]
movzx eax, byte ptr [rax+2]
shl eax, 8
or ecx, eax
mov rax, [rbp+var_8]
mov rax, [rax+8]
movzx eax, byte ptr [rax+1]
shl eax, 10h
or ecx, eax
mov rax, [rbp+var_8]
mov rax, [rax+8]
movzx eax, byte ptr [rax]
shl eax, 18h
or ecx, eax
mov rax, [rbp+var_8]
mov [rax], ecx
mov rax, [rbp+var_8]
mov rcx, [rax+8]
add rcx, 4
mov [rax+8], rcx
loc_BC3F5:
pop rbp
retn
| long long fill_buffer_0(long long a1)
{
long long result; // rax
if ( *(_QWORD *)(a1 + 8) < *(_QWORD *)(a1 + 16) )
{
*(_DWORD *)a1 = _byteswap_ulong(**(_DWORD **)(a1 + 8));
result = a1;
*(_QWORD *)(a1 + 8) += 4LL;
}
else
{
*(_DWORD *)(a1 + 40) = 1;
result = a1;
*(_DWORD *)a1 = 0;
}
return result;
}
| fill_buffer:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JC 0x001bc3a1
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x28],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],0x0
JMP 0x001bc3f5
LAB_001bc3a1:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOVZX ECX,byte ptr [RAX + 0x3]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOVZX EAX,byte ptr [RAX + 0x2]
SHL EAX,0x8
OR ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOVZX EAX,byte ptr [RAX + 0x1]
SHL EAX,0x10
OR ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOVZX EAX,byte ptr [RAX]
SHL EAX,0x18
OR ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,0x4
MOV qword ptr [RAX + 0x8],RCX
LAB_001bc3f5:
POP RBP
RET
|
void fill_buffer(int4 *param_1)
{
if (*(ulong *)(param_1 + 2) < *(ulong *)(param_1 + 4)) {
*param_1 = CONCAT13(**(int1 **)(param_1 + 2),
CONCAT12(*(int1 *)(*(long *)(param_1 + 2) + 1),
CONCAT11(*(int1 *)(*(long *)(param_1 + 2) + 2),
*(int1 *)(*(long *)(param_1 + 2) + 3))));
*(long *)(param_1 + 2) = *(long *)(param_1 + 2) + 4;
}
else {
param_1[10] = 1;
*param_1 = 0;
}
return;
}
| |
22,562 | my_well_formed_char_length_ucs2 | eloqsql/strings/ctype-ucs2.c | static size_t
my_well_formed_char_length_ucs2(CHARSET_INFO *cs __attribute__((unused)),
const char *b, const char *e,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length= e - b;
if (nchars * 2 <= length)
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= b + (nchars * 2);
return nchars;
}
if (length % 2)
{
status->m_well_formed_error_pos= status->m_source_end_pos= e - 1;
}
else
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= e;
}
return length / 2;
} | O3 | c | my_well_formed_char_length_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rcx, %rax
movq %rdx, %rcx
subq %rsi, %rcx
leaq (%rax,%rax), %rdi
cmpq %rcx, %rdi
jbe 0xc4faf
movl %ecx, %eax
andl $0x1, %eax
movq %rax, %rsi
negq %rsi
leaq -0x1(%rdx), %rdi
andq %rdi, %rsi
testq %rax, %rax
cmoveq %rdx, %rdi
movq %rsi, 0x8(%r8)
movq %rdi, (%r8)
shrq %rcx
movq %rcx, %rax
jmp 0xc4fbd
movq $0x0, 0x8(%r8)
addq %rdi, %rsi
movq %rsi, (%r8)
popq %rbp
retq
| my_well_formed_char_length_ucs2:
push rbp
mov rbp, rsp
mov rax, rcx
mov rcx, rdx
sub rcx, rsi
lea rdi, [rax+rax]
cmp rdi, rcx
jbe short loc_C4FAF
mov eax, ecx
and eax, 1
mov rsi, rax
neg rsi
lea rdi, [rdx-1]
and rsi, rdi
test rax, rax
cmovz rdi, rdx
mov [r8+8], rsi
mov [r8], rdi
shr rcx, 1
mov rax, rcx
jmp short loc_C4FBD
loc_C4FAF:
mov qword ptr [r8+8], 0
add rsi, rdi
mov [r8], rsi
loc_C4FBD:
pop rbp
retn
| unsigned long long my_well_formed_char_length_ucs2(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
_QWORD *a5)
{
unsigned long long result; // rax
unsigned long long v6; // rcx
long long v7; // rdi
result = a4;
v6 = a3 - a2;
if ( 2 * result <= a3 - a2 )
{
a5[1] = 0LL;
*a5 = 2 * result + a2;
}
else
{
v7 = a3 - 1;
if ( (v6 & 1) == 0 )
v7 = a3;
a5[1] = (a3 - 1) & -(long long)(v6 & 1);
*a5 = v7;
return v6 >> 1;
}
return result;
}
| my_well_formed_char_length_ucs2:
PUSH RBP
MOV RBP,RSP
MOV RAX,RCX
MOV RCX,RDX
SUB RCX,RSI
LEA RDI,[RAX + RAX*0x1]
CMP RDI,RCX
JBE 0x001c4faf
MOV EAX,ECX
AND EAX,0x1
MOV RSI,RAX
NEG RSI
LEA RDI,[RDX + -0x1]
AND RSI,RDI
TEST RAX,RAX
CMOVZ RDI,RDX
MOV qword ptr [R8 + 0x8],RSI
MOV qword ptr [R8],RDI
SHR RCX,0x1
MOV RAX,RCX
JMP 0x001c4fbd
LAB_001c4faf:
MOV qword ptr [R8 + 0x8],0x0
ADD RSI,RDI
MOV qword ptr [R8],RSI
LAB_001c4fbd:
POP RBP
RET
|
ulong my_well_formed_char_length_ucs2
(int8 param_1,long param_2,ulong param_3,ulong param_4,ulong *param_5)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
uVar2 = param_3 - param_2;
if (uVar2 < param_4 * 2) {
uVar1 = (ulong)((uint)uVar2 & 1);
uVar3 = param_3 - 1;
if (uVar1 == 0) {
uVar3 = param_3;
}
param_5[1] = -uVar1 & param_3 - 1;
*param_5 = uVar3;
param_4 = uVar2 >> 1;
}
else {
param_5[1] = 0;
*param_5 = param_2 + param_4 * 2;
}
return param_4;
}
| |
22,563 | my_xml_leave | eloqsql/strings/xml.c | static int my_xml_leave(MY_XML_PARSER *p, const char *str, size_t slen)
{
char *e, *tag;
size_t glen;
char s[32];
char g[32];
int rc;
/* Find previous '/' or beginning */
for (e= p->attr.end; (e > p->attr.start) && (e[0] != '/') ; e--);
glen= (size_t) ((e[0] == '/') ? (p->attr.end - e - 1) : p->attr.end - e);
tag= e[0] == '/' ? e + 1 : e;
if (str && (slen != glen || memcmp(str, tag, slen)))
{
mstr(s,str,sizeof(s)-1,slen);
if (glen)
{
mstr(g, tag, sizeof(g)-1, glen);
sprintf(p->errstr,"'</%s>' unexpected ('</%s>' wanted)",s,g);
}
else
sprintf(p->errstr,"'</%s>' unexpected (END-OF-INPUT wanted)", s);
return MY_XML_ERROR;
}
if (p->flags & MY_XML_FLAG_RELATIVE_NAMES)
rc= p->leave_xml ? p->leave_xml(p, str, slen) : MY_XML_OK;
else
rc= (p->leave_xml ?
p->leave_xml(p, p->attr.start, p->attr.end - p->attr.start) :
MY_XML_OK);
*e='\0';
p->attr.end= e;
return rc;
} | O0 | c | my_xml_leave:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
movq %rdx, -0x70(%rbp)
movq -0x60(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rcx
movq -0x60(%rbp), %rdx
xorl %eax, %eax
cmpq 0x118(%rdx), %rcx
movb %al, -0x8d(%rbp)
jbe 0x79c4f
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x8d(%rbp)
movb -0x8d(%rbp), %al
testb $0x1, %al
jne 0x79c5b
jmp 0x79c6b
jmp 0x79c5d
movq -0x78(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x79c23
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x79c96
movq -0x60(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x78(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x79caf
movq -0x60(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x78(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x79cda
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0x79ce5
movq -0x78(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x79d9d
movq -0x70(%rbp), %rax
cmpq -0x88(%rbp), %rax
jne 0x79d1e
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x24130
cmpl $0x0, %eax
je 0x79d9d
leaq -0x30(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rcx
movl $0x1f, %edx
callq 0x7a350
cmpq $0x0, -0x88(%rbp)
je 0x79d77
leaq -0x50(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rcx
movl $0x1f, %edx
callq 0x7a350
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %rcx
leaq 0x5e49(%rip), %rsi # 0x7fbb7
movb $0x0, %al
callq 0x240a0
jmp 0x79d91
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rdx
leaq 0x5e51(%rip), %rsi # 0x7fbdb
movb $0x0, %al
callq 0x240a0
movl $0x1, -0x54(%rbp)
jmp 0x79e72
movq -0x60(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x79df2
movq -0x60(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x79dda
movq -0x60(%rbp), %rax
movq 0x158(%rax), %rax
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq *%rax
movl %eax, -0xa4(%rbp)
jmp 0x79de4
xorl %eax, %eax
movl %eax, -0xa4(%rbp)
jmp 0x79de4
movl -0xa4(%rbp), %eax
movl %eax, -0x8c(%rbp)
jmp 0x79e53
movq -0x60(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x79e3d
movq -0x60(%rbp), %rax
movq 0x158(%rax), %rax
movq -0x60(%rbp), %rdi
movq -0x60(%rbp), %rcx
movq 0x118(%rcx), %rsi
movq -0x60(%rbp), %rcx
movq 0x120(%rcx), %rdx
movq -0x60(%rbp), %rcx
movq 0x118(%rcx), %rcx
subq %rcx, %rdx
callq *%rax
movl %eax, -0xa8(%rbp)
jmp 0x79e47
xorl %eax, %eax
movl %eax, -0xa8(%rbp)
jmp 0x79e47
movl -0xa8(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x78(%rbp), %rax
movb $0x0, (%rax)
movq -0x78(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x120(%rax)
movl -0x8c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0xac(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x79e9c
movl -0xac(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
callq 0x242b0
nopw %cs:(%rax,%rax)
| my_xml_leave:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_60], rdi
mov [rbp+var_68], rsi
mov [rbp+var_70], rdx
mov rax, [rbp+var_60]
mov rax, [rax+120h]
mov [rbp+var_78], rax
loc_79C23:
mov rcx, [rbp+var_78]
mov rdx, [rbp+var_60]
xor eax, eax
cmp rcx, [rdx+118h]
mov [rbp+var_8D], al
jbe short loc_79C4F
mov rax, [rbp+var_78]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
setnz al
mov [rbp+var_8D], al
loc_79C4F:
mov al, [rbp+var_8D]
test al, 1
jnz short loc_79C5B
jmp short loc_79C6B
loc_79C5B:
jmp short $+2
loc_79C5D:
mov rax, [rbp+var_78]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_78], rax
jmp short loc_79C23
loc_79C6B:
mov rax, [rbp+var_78]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_79C96
mov rax, [rbp+var_60]
mov rax, [rax+120h]
mov rcx, [rbp+var_78]
sub rax, rcx
sub rax, 1
mov [rbp+var_98], rax
jmp short loc_79CAF
loc_79C96:
mov rax, [rbp+var_60]
mov rax, [rax+120h]
mov rcx, [rbp+var_78]
sub rax, rcx
mov [rbp+var_98], rax
loc_79CAF:
mov rax, [rbp+var_98]
mov [rbp+var_88], rax
mov rax, [rbp+var_78]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_79CDA
mov rax, [rbp+var_78]
add rax, 1
mov [rbp+var_A0], rax
jmp short loc_79CE5
loc_79CDA:
mov rax, [rbp+var_78]
mov [rbp+var_A0], rax
loc_79CE5:
mov rax, [rbp+var_A0]
mov [rbp+var_80], rax
cmp [rbp+var_68], 0
jz loc_79D9D
mov rax, [rbp+var_70]
cmp rax, [rbp+var_88]
jnz short loc_79D1E
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_70]
call _memcmp
cmp eax, 0
jz short loc_79D9D
loc_79D1E:
lea rdi, [rbp+var_30]
mov rsi, [rbp+var_68]
mov rcx, [rbp+var_70]
mov edx, 1Fh
call mstr_0
cmp [rbp+var_88], 0
jz short loc_79D77
lea rdi, [rbp+var_50]
mov rsi, [rbp+var_80]
mov rcx, [rbp+var_88]
mov edx, 1Fh
call mstr_0
mov rdi, [rbp+var_60]
add rdi, 8
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_50]
lea rsi, aSUnexpectedSWa; "'</%s>' unexpected ('</%s>' wanted)"
mov al, 0
call _sprintf
jmp short loc_79D91
loc_79D77:
mov rdi, [rbp+var_60]
add rdi, 8
lea rdx, [rbp+var_30]
lea rsi, aSUnexpectedEnd; "'</%s>' unexpected (END-OF-INPUT wanted"...
mov al, 0
call _sprintf
loc_79D91:
mov [rbp+var_54], 1
jmp loc_79E72
loc_79D9D:
mov rax, [rbp+var_60]
mov eax, [rax]
and eax, 1
cmp eax, 0
jz short loc_79DF2
mov rax, [rbp+var_60]
cmp qword ptr [rax+158h], 0
jz short loc_79DDA
mov rax, [rbp+var_60]
mov rax, [rax+158h]
mov rdi, [rbp+var_60]
mov rsi, [rbp+var_68]
mov rdx, [rbp+var_70]
call rax
mov [rbp+var_A4], eax
jmp short loc_79DE4
loc_79DDA:
xor eax, eax
mov [rbp+var_A4], eax
jmp short $+2
loc_79DE4:
mov eax, [rbp+var_A4]
mov [rbp+var_8C], eax
jmp short loc_79E53
loc_79DF2:
mov rax, [rbp+var_60]
cmp qword ptr [rax+158h], 0
jz short loc_79E3D
mov rax, [rbp+var_60]
mov rax, [rax+158h]
mov rdi, [rbp+var_60]
mov rcx, [rbp+var_60]
mov rsi, [rcx+118h]
mov rcx, [rbp+var_60]
mov rdx, [rcx+120h]
mov rcx, [rbp+var_60]
mov rcx, [rcx+118h]
sub rdx, rcx
call rax
mov [rbp+var_A8], eax
jmp short loc_79E47
loc_79E3D:
xor eax, eax
mov [rbp+var_A8], eax
jmp short $+2
loc_79E47:
mov eax, [rbp+var_A8]
mov [rbp+var_8C], eax
loc_79E53:
mov rax, [rbp+var_78]
mov byte ptr [rax], 0
mov rcx, [rbp+var_78]
mov rax, [rbp+var_60]
mov [rax+120h], rcx
mov eax, [rbp+var_8C]
mov [rbp+var_54], eax
loc_79E72:
mov eax, [rbp+var_54]
mov [rbp+var_AC], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_79E9C
mov eax, [rbp+var_AC]
add rsp, 0B0h
pop rbp
retn
loc_79E9C:
call ___stack_chk_fail
| long long my_xml_leave(long long a1, long long a2, long long a3)
{
unsigned int v4; // [rsp+8h] [rbp-A8h]
unsigned int v5; // [rsp+Ch] [rbp-A4h]
_BYTE *v6; // [rsp+10h] [rbp-A0h]
long long v7; // [rsp+18h] [rbp-98h]
bool v8; // [rsp+23h] [rbp-8Dh]
unsigned int v9; // [rsp+24h] [rbp-8Ch]
_BYTE *i; // [rsp+38h] [rbp-78h]
char v13[32]; // [rsp+60h] [rbp-50h] BYREF
char v14[40]; // [rsp+80h] [rbp-30h] BYREF
unsigned long long v15; // [rsp+A8h] [rbp-8h]
v15 = __readfsqword(0x28u);
for ( i = *(_BYTE **)(a1 + 288); ; --i )
{
v8 = 0;
if ( (unsigned long long)i > *(_QWORD *)(a1 + 280) )
v8 = *i != 47;
if ( !v8 )
break;
}
if ( *i == 47 )
v7 = *(_QWORD *)(a1 + 288) - (_QWORD)i - 1LL;
else
v7 = *(_QWORD *)(a1 + 288) - (_QWORD)i;
if ( *i == 47 )
v6 = i + 1;
else
v6 = i;
if ( !a2 || a3 == v7 && !(unsigned int)memcmp(a2, v6, a3) )
{
if ( (*(_DWORD *)a1 & 1) != 0 )
{
if ( *(_QWORD *)(a1 + 344) )
v5 = (*(long long ( **)(long long, long long, long long))(a1 + 344))(a1, a2, a3);
else
v5 = 0;
v9 = v5;
}
else
{
if ( *(_QWORD *)(a1 + 344) )
v4 = (*(long long ( **)(long long, _QWORD, _QWORD))(a1 + 344))(
a1,
*(_QWORD *)(a1 + 280),
*(_QWORD *)(a1 + 288) - *(_QWORD *)(a1 + 280));
else
v4 = 0;
v9 = v4;
}
*i = 0;
*(_QWORD *)(a1 + 288) = i;
return v9;
}
else
{
mstr_0(v14, a2, 31LL, a3);
if ( v7 )
{
mstr_0(v13, v6, 31LL, v7);
sprintf(a1 + 8, "'</%s>' unexpected ('</%s>' wanted)", v14, v13);
}
else
{
sprintf(a1 + 8, "'</%s>' unexpected (END-OF-INPUT wanted)", v14);
}
return 1;
}
}
| my_xml_leave:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x60],RDI
MOV qword ptr [RBP + -0x68],RSI
MOV qword ptr [RBP + -0x70],RDX
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x120]
MOV qword ptr [RBP + -0x78],RAX
LAB_00179c23:
MOV RCX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x60]
XOR EAX,EAX
CMP RCX,qword ptr [RDX + 0x118]
MOV byte ptr [RBP + -0x8d],AL
JBE 0x00179c4f
MOV RAX,qword ptr [RBP + -0x78]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
SETNZ AL
MOV byte ptr [RBP + -0x8d],AL
LAB_00179c4f:
MOV AL,byte ptr [RBP + -0x8d]
TEST AL,0x1
JNZ 0x00179c5b
JMP 0x00179c6b
LAB_00179c5b:
JMP 0x00179c5d
LAB_00179c5d:
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x78],RAX
JMP 0x00179c23
LAB_00179c6b:
MOV RAX,qword ptr [RBP + -0x78]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x00179c96
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x120]
MOV RCX,qword ptr [RBP + -0x78]
SUB RAX,RCX
SUB RAX,0x1
MOV qword ptr [RBP + -0x98],RAX
JMP 0x00179caf
LAB_00179c96:
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x120]
MOV RCX,qword ptr [RBP + -0x78]
SUB RAX,RCX
MOV qword ptr [RBP + -0x98],RAX
LAB_00179caf:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x00179cda
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x1
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x00179ce5
LAB_00179cda:
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0xa0],RAX
LAB_00179ce5:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x80],RAX
CMP qword ptr [RBP + -0x68],0x0
JZ 0x00179d9d
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x88]
JNZ 0x00179d1e
MOV RDI,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x70]
CALL 0x00124130
CMP EAX,0x0
JZ 0x00179d9d
LAB_00179d1e:
LEA RDI,[RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x70]
MOV EDX,0x1f
CALL 0x0017a350
CMP qword ptr [RBP + -0x88],0x0
JZ 0x00179d77
LEA RDI,[RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x88]
MOV EDX,0x1f
CALL 0x0017a350
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0x8
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x50]
LEA RSI,[0x17fbb7]
MOV AL,0x0
CALL 0x001240a0
JMP 0x00179d91
LAB_00179d77:
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0x8
LEA RDX,[RBP + -0x30]
LEA RSI,[0x17fbdb]
MOV AL,0x0
CALL 0x001240a0
LAB_00179d91:
MOV dword ptr [RBP + -0x54],0x1
JMP 0x00179e72
LAB_00179d9d:
MOV RAX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RAX]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00179df2
MOV RAX,qword ptr [RBP + -0x60]
CMP qword ptr [RAX + 0x158],0x0
JZ 0x00179dda
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x158]
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x70]
CALL RAX
MOV dword ptr [RBP + -0xa4],EAX
JMP 0x00179de4
LAB_00179dda:
XOR EAX,EAX
MOV dword ptr [RBP + -0xa4],EAX
JMP 0x00179de4
LAB_00179de4:
MOV EAX,dword ptr [RBP + -0xa4]
MOV dword ptr [RBP + -0x8c],EAX
JMP 0x00179e53
LAB_00179df2:
MOV RAX,qword ptr [RBP + -0x60]
CMP qword ptr [RAX + 0x158],0x0
JZ 0x00179e3d
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x158]
MOV RDI,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RCX + 0x118]
MOV RCX,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RCX + 0x120]
MOV RCX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RCX + 0x118]
SUB RDX,RCX
CALL RAX
MOV dword ptr [RBP + -0xa8],EAX
JMP 0x00179e47
LAB_00179e3d:
XOR EAX,EAX
MOV dword ptr [RBP + -0xa8],EAX
JMP 0x00179e47
LAB_00179e47:
MOV EAX,dword ptr [RBP + -0xa8]
MOV dword ptr [RBP + -0x8c],EAX
LAB_00179e53:
MOV RAX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX],0x0
MOV RCX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + 0x120],RCX
MOV EAX,dword ptr [RBP + -0x8c]
MOV dword ptr [RBP + -0x54],EAX
LAB_00179e72:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0xac],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00179e9c
MOV EAX,dword ptr [RBP + -0xac]
ADD RSP,0xb0
POP RBP
RET
LAB_00179e9c:
CALL 0x001242b0
|
int4 my_xml_leave(uint *param_1,void *param_2,size_t param_3)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
int4 local_b0;
int4 local_ac;
char *local_a8;
size_t local_a0;
int4 local_94;
char *local_80;
int4 local_5c;
int1 local_58 [32];
int1 local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_80 = *(char **)(param_1 + 0x48);
while( true ) {
bVar2 = false;
if (*(char **)(param_1 + 0x46) < local_80) {
bVar2 = *local_80 != '/';
}
if (!bVar2) break;
local_80 = local_80 + -1;
}
if (*local_80 == '/') {
local_a0 = (*(long *)(param_1 + 0x48) - (long)local_80) - 1;
}
else {
local_a0 = *(long *)(param_1 + 0x48) - (long)local_80;
}
if (*local_80 == '/') {
local_a8 = local_80 + 1;
}
else {
local_a8 = local_80;
}
if (param_2 == (void *)0x0) {
LAB_00179d9d:
if ((*param_1 & 1) == 0) {
if (*(long *)(param_1 + 0x56) == 0) {
local_b0 = 0;
}
else {
local_b0 = (**(code **)(param_1 + 0x56))
(param_1,*(int8 *)(param_1 + 0x46),
*(long *)(param_1 + 0x48) - *(long *)(param_1 + 0x46));
}
local_94 = local_b0;
}
else {
if (*(long *)(param_1 + 0x56) == 0) {
local_ac = 0;
}
else {
local_ac = (**(code **)(param_1 + 0x56))(param_1,param_2,param_3);
}
local_94 = local_ac;
}
*local_80 = '\0';
*(char **)(param_1 + 0x48) = local_80;
local_5c = local_94;
}
else {
if (param_3 == local_a0) {
iVar1 = memcmp(param_2,local_a8,param_3);
if (iVar1 == 0) goto LAB_00179d9d;
}
mstr(local_38,param_2,0x1f,param_3);
if (local_a0 == 0) {
sprintf((char *)(param_1 + 2),"\'</%s>\' unexpected (END-OF-INPUT wanted)",local_38);
}
else {
mstr(local_58,local_a8,0x1f,local_a0);
sprintf((char *)(param_1 + 2),"\'</%s>\' unexpected (\'</%s>\' wanted)",local_38,local_58);
}
local_5c = 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_5c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
22,564 | ma_apply_redo_index_new_page | eloqsql/storage/maria/ma_key_recover.c | uint _ma_apply_redo_index_new_page(MARIA_HA *info, LSN lsn,
const uchar *header, uint length)
{
pgcache_page_no_t root_page= page_korr(header);
pgcache_page_no_t free_page= page_korr(header + PAGE_STORE_SIZE);
uint key_nr= key_nr_korr(header + PAGE_STORE_SIZE * 2);
my_bool page_type_flag= header[PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE];
enum pagecache_page_lock unlock_method;
enum pagecache_page_pin unpin_method;
MARIA_PINNED_PAGE page_link;
my_off_t file_size;
uchar *buff;
uint result;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_apply_redo_index_new_page");
DBUG_PRINT("enter", ("root_page: %lu free_page: %lu",
(ulong) root_page, (ulong) free_page));
/* Set header to point at key data */
share->state.changed|= (STATE_CHANGED | STATE_NOT_OPTIMIZED_KEYS |
STATE_NOT_SORTED_PAGES | STATE_NOT_ZEROFILLED |
STATE_NOT_MOVABLE);
header+= PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE + 1;
length-= PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE + 1;
file_size= (my_off_t) (root_page + 1) * share->block_size;
if (cmp_translog_addr(lsn, share->state.is_of_horizon) >= 0)
{
/* free_page is 0 if we shouldn't set key_del */
if (free_page)
{
if (free_page != IMPOSSIBLE_PAGE_NO)
share->state.key_del= (my_off_t) free_page * share->block_size;
else
share->state.key_del= HA_OFFSET_ERROR;
}
if (page_type_flag) /* root page */
share->state.key_root[key_nr]= file_size - share->block_size;
}
if (file_size > share->state.state.key_file_length)
{
share->state.state.key_file_length= file_size;
buff= info->keyread_buff;
info->keyread_buff_used= 1;
unlock_method= PAGECACHE_LOCK_WRITE;
unpin_method= PAGECACHE_PIN;
}
else
{
if (!(buff= pagecache_read(share->pagecache, &share->kfile,
root_page, 0, 0,
PAGECACHE_PLAIN_PAGE, PAGECACHE_LOCK_WRITE,
&page_link.link)))
{
if (my_errno != HA_ERR_FILE_TOO_SHORT &&
my_errno != HA_ERR_WRONG_CRC &&
my_errno != HA_ERR_DECRYPTION_FAILED)
{
result= 1;
_ma_set_fatal_error(info, my_errno);
goto err;
}
buff= pagecache_block_link_to_buffer(page_link.link);
}
else if (lsn_korr(buff) >= lsn)
{
/* Already applied */
check_skipped_lsn(info, lsn_korr(buff), 0, root_page);
result= 0;
goto err;
}
unlock_method= PAGECACHE_LOCK_LEFT_WRITELOCKED;
unpin_method= PAGECACHE_PIN_LEFT_PINNED;
}
/* Write modified page */
bzero(buff, LSN_STORE_SIZE);
memcpy(buff + LSN_STORE_SIZE, header, length);
bzero(buff + LSN_STORE_SIZE + length,
share->max_index_block_size - LSN_STORE_SIZE - length);
bfill(buff + share->block_size - KEYPAGE_CHECKSUM_SIZE,
KEYPAGE_CHECKSUM_SIZE, (uchar) 255);
result= 0;
if (unlock_method == PAGECACHE_LOCK_WRITE &&
pagecache_write(share->pagecache,
&share->kfile, root_page, 0,
buff, PAGECACHE_PLAIN_PAGE,
unlock_method, unpin_method,
PAGECACHE_WRITE_DELAY, &page_link.link,
LSN_IMPOSSIBLE))
result= 1;
/* Mark page to be unlocked and written at _ma_unpin_all_pages() */
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
DBUG_RETURN(result);
err:
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
DBUG_RETURN(result);
} | O3 | c | ma_apply_redo_index_new_page:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movl (%rdx), %r10d
movl 0x5(%rdx), %edi
movzbl 0x4(%rdx), %r8d
shlq $0x20, %r8
leaq (%r8,%r10), %rdx
movzbl 0x9(%r13), %esi
movzbl 0xa(%r13), %eax
movb 0xb(%r13), %r9b
movq (%rbx), %r14
orl $0x1b1, 0x170(%r14) # imm = 0x1B1
leaq (%r8,%r10), %r11
incq %r11
movl 0x7bc(%r14), %r10d
imulq %r10, %r11
cmpq %r15, 0x180(%r14)
jg 0x40635
shlq $0x20, %rsi
orq %rdi, %rsi
testq %rsi, %rsi
je 0x40621
movq $-0x1, %rdi
movabsq $0xffffffffff, %r8 # imm = 0xFFFFFFFFFF
cmpq %r8, %rsi
je 0x4061a
imulq %r10, %rsi
movq %rsi, %rdi
movq %rdi, 0x120(%r14)
testb %r9b, %r9b
je 0x40635
imulq %rdx, %r10
movq 0x118(%r14), %rsi
movq %r10, (%rsi,%rax,8)
movq 0x38(%r14), %rax
movq %rax, -0x48(%rbp)
cmpq %rax, %r11
movq %rdx, -0x40(%rbp)
movq %r11, -0x50(%rbp)
jbe 0x4066a
movq %r11, 0x38(%r14)
movq 0x380(%rbx), %r12
movb $0x1, 0x685(%rbx)
movl $0x2, %eax
movq %rax, -0x38(%rbp)
jmp 0x40745
movq %rcx, -0x30(%rbp)
movq 0x600(%r14), %rdi
leaq 0x750(%r14), %rsi
leaq -0x68(%rbp), %rax
movq $0x0, -0x38(%rbp)
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
pushq %rax
pushq $0x4
callq 0x3b116
addq $0x10, %rsp
testq %rax, %rax
je 0x4070a
movq %rax, %r12
movzwl (%rax), %eax
shlq $0x20, %rax
movzbl 0x2(%r12), %ecx
shlq $0x30, %rcx
orq %rax, %rcx
movl 0x3(%r12), %esi
orq %rcx, %rsi
cmpq %r15, %rsi
movq -0x30(%rbp), %rcx
jl 0x40745
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
movq -0x40(%rbp), %rcx
callq 0x35d25
movq 0x600(%r14), %rdi
movq -0x68(%rbp), %rsi
xorl %eax, %eax
movl $0x6, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
callq 0x3ae31
addq $0x10, %rsp
jmp 0x40817
callq 0xa1b26
cmpl $0xaf, (%rax)
je 0x40735
callq 0xa1b26
cmpl $0xb0, (%rax)
je 0x40735
callq 0xa1b26
cmpl $0xc0, (%rax)
jne 0x40829
movq -0x68(%rbp), %rdi
callq 0x3d5f9
movq %rax, %r12
movq -0x30(%rbp), %rcx
movq %rbx, -0x30(%rbp)
addq $0xc, %r13
leal -0xc(%rcx), %eax
xorl %r15d, %r15d
movl %r15d, 0x3(%r12)
movl %r15d, (%r12)
leaq 0x7(%r12), %rdi
movl %eax, %ebx
movq %r13, %rsi
movq %rbx, %rdx
movq %rcx, %r13
callq 0x29080
leaq (%r12,%rbx), %rdi
addq $0x7, %rdi
movl 0x7c0(%r14), %edx
subl %r13d, %edx
addl $0x5, %edx
xorl %esi, %esi
callq 0x292a0
movl 0x7bc(%r14), %eax
movl $0xffffffff, -0x4(%r12,%rax) # imm = 0xFFFFFFFF
movq -0x50(%rbp), %rax
cmpq -0x48(%rbp), %rax
jbe 0x407f8
movq 0x600(%r14), %rdi
addq $0x750, %r14 # imm = 0x750
movl 0x80(%rdi), %eax
subq $0x8, %rsp
xorl %r10d, %r10d
leaq -0x68(%rbp), %r11
movq %r14, %rsi
movq -0x40(%rbp), %rdx
xorl %ecx, %ecx
movq %r12, %r8
movl $0x1, %r9d
pushq %rax
pushq %r10
pushq $0x0
pushq %r11
pushq %r10
pushq -0x38(%rbp)
pushq $0x4
callq 0x3c57a
addq $0x40, %rsp
xorl %r15d, %r15d
testb %al, %al
setne %r15b
leaq -0x68(%rbp), %rsi
movl $0x6, 0x8(%rsi)
movb $0x1, 0x10(%rsi)
movq -0x30(%rbp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
callq 0x91a26
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xa1b26
movl (%rax), %esi
movq %rbx, %rdi
callq 0x3fcb8
movl $0x1, %r15d
jmp 0x406dd
| _ma_apply_redo_index_new_page:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r13, rdx
mov r15, rsi
mov rbx, rdi
mov r10d, [rdx]
mov edi, [rdx+5]
movzx r8d, byte ptr [rdx+4]
shl r8, 20h
lea rdx, [r8+r10]
movzx esi, byte ptr [r13+9]
movzx eax, byte ptr [r13+0Ah]
mov r9b, [r13+0Bh]
mov r14, [rbx]
or dword ptr [r14+170h], 1B1h
lea r11, [r8+r10]
inc r11
mov r10d, [r14+7BCh]
imul r11, r10
cmp [r14+180h], r15
jg short loc_40635
shl rsi, 20h
or rsi, rdi
test rsi, rsi
jz short loc_40621
mov rdi, 0FFFFFFFFFFFFFFFFh
mov r8, 0FFFFFFFFFFh
cmp rsi, r8
jz short loc_4061A
imul rsi, r10
mov rdi, rsi
loc_4061A:
mov [r14+120h], rdi
loc_40621:
test r9b, r9b
jz short loc_40635
imul r10, rdx
mov rsi, [r14+118h]
mov [rsi+rax*8], r10
loc_40635:
mov rax, [r14+38h]
mov [rbp+var_48], rax
cmp r11, rax
mov [rbp+var_40], rdx
mov [rbp+var_50], r11
jbe short loc_4066A
mov [r14+38h], r11
mov r12, [rbx+380h]
mov byte ptr [rbx+685h], 1
mov eax, 2
mov [rbp+var_38], rax
jmp loc_40745
loc_4066A:
mov [rbp+var_30], rcx
mov rdi, [r14+600h]
lea rsi, [r14+750h]
lea rax, [rbp+var_68]
mov [rbp+var_38], 0
xor ecx, ecx
xor r8d, r8d
mov r9d, 1
push rax
push 4
call pagecache_read
add rsp, 10h
test rax, rax
jz short loc_4070A
mov r12, rax
movzx eax, word ptr [rax]
shl rax, 20h
movzx ecx, byte ptr [r12+2]
shl rcx, 30h
or rcx, rax
mov esi, [r12+3]
or rsi, rcx
cmp rsi, r15
mov rcx, [rbp+var_30]
jl short loc_40745
xor r15d, r15d
mov rdi, rbx
xor edx, edx
mov rcx, [rbp+var_40]
call check_skipped_lsn
loc_406DD:
mov rdi, [r14+600h]
mov rsi, [rbp+var_68]
xor eax, eax
mov edx, 6
mov ecx, 3
xor r8d, r8d
xor r9d, r9d
push rax
push rax
call pagecache_unlock_by_link
add rsp, 10h
jmp loc_40817
loc_4070A:
call _my_thread_var
cmp dword ptr [rax], 0AFh
jz short loc_40735
call _my_thread_var
cmp dword ptr [rax], 0B0h
jz short loc_40735
call _my_thread_var
cmp dword ptr [rax], 0C0h
jnz loc_40829
loc_40735:
mov rdi, [rbp+var_68]
call pagecache_block_link_to_buffer
mov r12, rax
mov rcx, [rbp+var_30]
loc_40745:
mov [rbp+var_30], rbx
add r13, 0Ch
lea eax, [rcx-0Ch]
xor r15d, r15d
mov [r12+3], r15d
mov [r12], r15d
lea rdi, [r12+7]
mov ebx, eax
mov rsi, r13
mov rdx, rbx
mov r13, rcx
call _memcpy
lea rdi, [r12+rbx]
add rdi, 7
mov edx, [r14+7C0h]
sub edx, r13d
add edx, 5
xor esi, esi
call _memset
mov eax, [r14+7BCh]
mov dword ptr [r12+rax-4], 0FFFFFFFFh
mov rax, [rbp+var_50]
cmp rax, [rbp+var_48]
jbe short loc_407F8
mov rdi, [r14+600h]
add r14, 750h
mov eax, [rdi+80h]
sub rsp, 8
xor r10d, r10d
lea r11, [rbp+var_68]
mov rsi, r14
mov rdx, [rbp+var_40]
xor ecx, ecx
mov r8, r12
mov r9d, 1
push rax
push r10
push 0
push r11
push r10
push [rbp+var_38]
push 4
call pagecache_write_part
add rsp, 40h
xor r15d, r15d
test al, al
setnz r15b
loc_407F8:
lea rsi, [rbp+var_68]
mov dword ptr [rsi+8], 6
mov byte ptr [rsi+10h], 1
mov rdi, [rbp+var_30]
add rdi, 2E8h
call insert_dynamic
loc_40817:
mov eax, r15d
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_40829:
call _my_thread_var
mov esi, [rax]
mov rdi, rbx
call _ma_set_fatal_error
mov r15d, 1
jmp loc_406DD
| _BOOL8 ma_apply_redo_index_new_page(long long a1, signed long long a2, unsigned int *a3, long long a4)
{
long long v7; // rdi
long long v8; // rdx
long long v9; // rsi
long long v10; // rax
char v11; // r9
long long v12; // r14
long long v13; // r10
unsigned long long v14; // r11
long long v15; // rsi
long long v16; // rdi
long long v17; // r12
long long v18; // rdi
unsigned __int16 *v19; // rax
signed long long v20; // rsi
BOOL v21; // r15d
long long v22; // rbx
unsigned int *v23; // rsi
int v24; // r13d
int *v26; // rax
long long v27; // rdx
long long v28; // rcx
long long v29; // r8
int v30; // r9d
long long v31; // [rsp+8h] [rbp-68h] BYREF
int v32; // [rsp+10h] [rbp-60h]
char v33; // [rsp+18h] [rbp-58h]
unsigned long long v34; // [rsp+20h] [rbp-50h]
unsigned long long v35; // [rsp+28h] [rbp-48h]
long long v36; // [rsp+30h] [rbp-40h]
long long v37; // [rsp+38h] [rbp-38h]
long long v38; // [rsp+40h] [rbp-30h]
v7 = *(unsigned int *)((char *)a3 + 5);
v8 = ((unsigned long long)*((unsigned __int8 *)a3 + 4) << 32) + *a3;
v9 = *((unsigned __int8 *)a3 + 9);
v10 = *((unsigned __int8 *)a3 + 10);
v11 = *((_BYTE *)a3 + 11);
v12 = *(_QWORD *)a1;
*(_DWORD *)(v12 + 368) |= 0x1B1u;
v13 = *(unsigned int *)(v12 + 1980);
v14 = v13 * (v8 + 1);
if ( *(_QWORD *)(v12 + 384) <= a2 )
{
v15 = v7 | (v9 << 32);
if ( v15 )
{
v16 = -1LL;
if ( v15 != 0xFFFFFFFFFFLL )
v16 = v13 * v15;
*(_QWORD *)(v12 + 288) = v16;
}
if ( v11 )
*(_QWORD *)(*(_QWORD *)(v12 + 280) + 8 * v10) = v8 * v13;
}
v35 = *(_QWORD *)(v12 + 56);
v36 = v8;
v34 = v13 * (v8 + 1);
if ( v14 <= v35 )
{
v38 = a4;
v18 = *(_QWORD *)(v12 + 1536);
v37 = 0LL;
v19 = (unsigned __int16 *)pagecache_read(v18, v12 + 1872, v8, 0, 0LL, 1, 4u, &v31);
if ( v19 )
{
v17 = (long long)v19;
v20 = ((unsigned long long)*v19 << 32) | ((unsigned long long)*(unsigned __int8 *)(v17 + 2) << 48) | *(unsigned int *)(v17 + 3);
LODWORD(a4) = v38;
if ( v20 < a2 )
goto LABEL_18;
v21 = 0;
check_skipped_lsn(a1, v20, 0, v36);
}
else
{
if ( *(_DWORD *)my_thread_var(v18) == 175
|| *(_DWORD *)my_thread_var(v18) == 176
|| *(_DWORD *)my_thread_var(v18) == 192 )
{
v17 = pagecache_block_link_to_buffer(v31);
LODWORD(a4) = v38;
goto LABEL_18;
}
v26 = (int *)my_thread_var(v18);
ma_set_fatal_error((_DWORD *)a1, *v26, v27, v28, v29, v30);
v21 = 1;
}
pagecache_unlock_by_link(*(_QWORD *)(v12 + 1536), v31, 6, 3, 0LL, 0LL, 0);
return v21;
}
*(_QWORD *)(v12 + 56) = v14;
v17 = *(_QWORD *)(a1 + 896);
*(_BYTE *)(a1 + 1669) = 1;
v37 = 2LL;
LABEL_18:
v38 = a1;
v21 = 0;
*(_DWORD *)(v17 + 3) = 0;
*(_DWORD *)v17 = 0;
v22 = (unsigned int)(a4 - 12);
v23 = a3 + 3;
v24 = a4;
memcpy(v17 + 7, v23, v22);
memset(v17 + v22 + 7, 0LL, (unsigned int)(*(_DWORD *)(v12 + 1984) - v24 + 5));
*(_DWORD *)(v17 + *(unsigned int *)(v12 + 1980) - 4) = -1;
if ( v34 > v35 )
v21 = (unsigned __int8)pagecache_write_part(
*(__m128i **)(v12 + 1536),
(char *)(v12 + 1872),
v36,
0,
(char *)v17,
1,
4u,
v37,
0,
&v31,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v12 + 1536) + 128LL)) != 0;
v32 = 6;
v33 = 1;
insert_dynamic(v38 + 744, &v31);
return v21;
}
| _ma_apply_redo_index_new_page:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R13,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R10D,dword ptr [RDX]
MOV EDI,dword ptr [RDX + 0x5]
MOVZX R8D,byte ptr [RDX + 0x4]
SHL R8,0x20
LEA RDX,[R8 + R10*0x1]
MOVZX ESI,byte ptr [R13 + 0x9]
MOVZX EAX,byte ptr [R13 + 0xa]
MOV R9B,byte ptr [R13 + 0xb]
MOV R14,qword ptr [RBX]
OR dword ptr [R14 + 0x170],0x1b1
LEA R11,[R8 + R10*0x1]
INC R11
MOV R10D,dword ptr [R14 + 0x7bc]
IMUL R11,R10
CMP qword ptr [R14 + 0x180],R15
JG 0x00140635
SHL RSI,0x20
OR RSI,RDI
TEST RSI,RSI
JZ 0x00140621
MOV RDI,-0x1
MOV R8,0xffffffffff
CMP RSI,R8
JZ 0x0014061a
IMUL RSI,R10
MOV RDI,RSI
LAB_0014061a:
MOV qword ptr [R14 + 0x120],RDI
LAB_00140621:
TEST R9B,R9B
JZ 0x00140635
IMUL R10,RDX
MOV RSI,qword ptr [R14 + 0x118]
MOV qword ptr [RSI + RAX*0x8],R10
LAB_00140635:
MOV RAX,qword ptr [R14 + 0x38]
MOV qword ptr [RBP + -0x48],RAX
CMP R11,RAX
MOV qword ptr [RBP + -0x40],RDX
MOV qword ptr [RBP + -0x50],R11
JBE 0x0014066a
MOV qword ptr [R14 + 0x38],R11
MOV R12,qword ptr [RBX + 0x380]
MOV byte ptr [RBX + 0x685],0x1
MOV EAX,0x2
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00140745
LAB_0014066a:
MOV qword ptr [RBP + -0x30],RCX
MOV RDI,qword ptr [R14 + 0x600]
LEA RSI,[R14 + 0x750]
LEA RAX,[RBP + -0x68]
MOV qword ptr [RBP + -0x38],0x0
XOR ECX,ECX
XOR R8D,R8D
MOV R9D,0x1
PUSH RAX
PUSH 0x4
CALL 0x0013b116
ADD RSP,0x10
TEST RAX,RAX
JZ 0x0014070a
MOV R12,RAX
MOVZX EAX,word ptr [RAX]
SHL RAX,0x20
MOVZX ECX,byte ptr [R12 + 0x2]
SHL RCX,0x30
OR RCX,RAX
MOV ESI,dword ptr [R12 + 0x3]
OR RSI,RCX
CMP RSI,R15
MOV RCX,qword ptr [RBP + -0x30]
JL 0x00140745
XOR R15D,R15D
MOV RDI,RBX
XOR EDX,EDX
MOV RCX,qword ptr [RBP + -0x40]
CALL 0x00135d25
LAB_001406dd:
MOV RDI,qword ptr [R14 + 0x600]
MOV RSI,qword ptr [RBP + -0x68]
XOR EAX,EAX
MOV EDX,0x6
MOV ECX,0x3
XOR R8D,R8D
XOR R9D,R9D
PUSH RAX
PUSH RAX
CALL 0x0013ae31
ADD RSP,0x10
JMP 0x00140817
LAB_0014070a:
CALL 0x001a1b26
CMP dword ptr [RAX],0xaf
JZ 0x00140735
CALL 0x001a1b26
CMP dword ptr [RAX],0xb0
JZ 0x00140735
CALL 0x001a1b26
CMP dword ptr [RAX],0xc0
JNZ 0x00140829
LAB_00140735:
MOV RDI,qword ptr [RBP + -0x68]
CALL 0x0013d5f9
MOV R12,RAX
MOV RCX,qword ptr [RBP + -0x30]
LAB_00140745:
MOV qword ptr [RBP + -0x30],RBX
ADD R13,0xc
LEA EAX,[RCX + -0xc]
XOR R15D,R15D
MOV dword ptr [R12 + 0x3],R15D
MOV dword ptr [R12],R15D
LEA RDI,[R12 + 0x7]
MOV EBX,EAX
MOV RSI,R13
MOV RDX,RBX
MOV R13,RCX
CALL 0x00129080
LEA RDI,[R12 + RBX*0x1]
ADD RDI,0x7
MOV EDX,dword ptr [R14 + 0x7c0]
SUB EDX,R13D
ADD EDX,0x5
XOR ESI,ESI
CALL 0x001292a0
MOV EAX,dword ptr [R14 + 0x7bc]
MOV dword ptr [R12 + RAX*0x1 + -0x4],0xffffffff
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x001407f8
MOV RDI,qword ptr [R14 + 0x600]
ADD R14,0x750
MOV EAX,dword ptr [RDI + 0x80]
SUB RSP,0x8
XOR R10D,R10D
LEA R11,[RBP + -0x68]
MOV RSI,R14
MOV RDX,qword ptr [RBP + -0x40]
XOR ECX,ECX
MOV R8,R12
MOV R9D,0x1
PUSH RAX
PUSH R10
PUSH 0x0
PUSH R11
PUSH R10
PUSH qword ptr [RBP + -0x38]
PUSH 0x4
CALL 0x0013c57a
ADD RSP,0x40
XOR R15D,R15D
TEST AL,AL
SETNZ R15B
LAB_001407f8:
LEA RSI,[RBP + -0x68]
MOV dword ptr [RSI + 0x8],0x6
MOV byte ptr [RSI + 0x10],0x1
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x2e8
CALL 0x00191a26
LAB_00140817:
MOV EAX,R15D
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00140829:
CALL 0x001a1b26
MOV ESI,dword ptr [RAX]
MOV RDI,RBX
CALL 0x0013fcb8
MOV R15D,0x1
JMP 0x001406dd
|
bool _ma_apply_redo_index_new_page(long *param_1,long param_2,uint5 *param_3,long *param_4)
{
byte bVar1;
long lVar2;
uint5 uVar3;
uint5 uVar4;
char cVar5;
ushort *puVar6;
int *piVar7;
int4 *puVar8;
ulong uVar9;
ulong uVar10;
long lVar11;
bool bVar12;
int8 local_70;
int4 local_68;
int1 local_60;
ulong local_58;
ulong local_50;
ulong local_48;
int8 local_40;
long *local_38;
uVar3 = *param_3;
local_48 = (ulong)*param_3;
uVar4 = *(uint5 *)((long)param_3 + 5);
bVar1 = *(byte *)((long)param_3 + 10);
cVar5 = *(char *)((long)param_3 + 0xb);
lVar2 = *param_1;
*(uint *)(lVar2 + 0x170) = *(uint *)(lVar2 + 0x170) | 0x1b1;
uVar10 = (ulong)*(uint *)(lVar2 + 0x7bc);
local_58 = ((ulong)uVar3 + 1) * uVar10;
if (*(long *)(lVar2 + 0x180) <= param_2) {
uVar9 = (ulong)uVar4;
if (uVar9 != 0) {
lVar11 = -1;
if (uVar9 != 0xffffffffff) {
lVar11 = uVar9 * uVar10;
}
*(long *)(lVar2 + 0x120) = lVar11;
}
if (cVar5 != '\0') {
*(ulong *)(*(long *)(lVar2 + 0x118) + (ulong)bVar1 * 8) = uVar10 * local_48;
}
}
local_50 = *(ulong *)(lVar2 + 0x38);
if (local_58 < local_50 || local_58 - local_50 == 0) {
local_40 = 0;
local_38 = param_4;
puVar6 = (ushort *)
pagecache_read(*(int8 *)(lVar2 + 0x600),lVar2 + 0x750,local_48,0,0,1,4,&local_70)
;
if (puVar6 == (ushort *)0x0) {
piVar7 = (int *)_my_thread_var();
if (((*piVar7 != 0xaf) && (piVar7 = (int *)_my_thread_var(), *piVar7 != 0xb0)) &&
(piVar7 = (int *)_my_thread_var(), *piVar7 != 0xc0)) {
puVar8 = (int4 *)_my_thread_var();
_ma_set_fatal_error(param_1,*puVar8);
bVar12 = true;
goto LAB_001406dd;
}
puVar6 = (ushort *)pagecache_block_link_to_buffer(local_70);
param_4 = local_38;
}
else {
uVar10 = (ulong)*(uint *)((long)puVar6 + 3) |
(ulong)(byte)puVar6[1] << 0x30 | (ulong)*puVar6 << 0x20;
param_4 = local_38;
if (param_2 <= (long)uVar10) {
bVar12 = false;
check_skipped_lsn(param_1,uVar10,0,local_48);
LAB_001406dd:
pagecache_unlock_by_link(*(int8 *)(lVar2 + 0x600),local_70,6,3,0,0,0,0);
return bVar12;
}
}
}
else {
*(ulong *)(lVar2 + 0x38) = local_58;
puVar6 = (ushort *)param_1[0x70];
*(int1 *)((long)param_1 + 0x685) = 1;
local_40 = 2;
}
bVar12 = false;
*(int4 *)((long)puVar6 + 3) = 0;
puVar6[0] = 0;
puVar6[1] = 0;
uVar10 = (ulong)((int)param_4 - 0xc);
local_38 = param_1;
memcpy((void *)((long)puVar6 + 7),(void *)((long)param_3 + 0xc),uVar10);
memset((void *)((long)puVar6 + uVar10 + 7),0,(ulong)((*(int *)(lVar2 + 0x7c0) - (int)param_4) + 5)
);
*(int4 *)((long)puVar6 + ((ulong)*(uint *)(lVar2 + 0x7bc) - 4)) = 0xffffffff;
if (local_50 < local_58) {
cVar5 = pagecache_write_part
(*(long *)(lVar2 + 0x600),lVar2 + 0x750,local_48,0,puVar6,1,4,local_40,0,
&local_70,0,0,*(int4 *)(*(long *)(lVar2 + 0x600) + 0x80));
bVar12 = cVar5 != '\0';
}
local_68 = 6;
local_60 = 1;
insert_dynamic(local_38 + 0x5d);
return bVar12;
}
| |
22,565 | unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11]) | monkey531[P]llama/common/json.hpp | size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
// Since we cannot move const Keys, re-construct them in place
for (auto next = it; ++next != this->end(); ++it)
{
it->~value_type(); // Destroy but keep allocation
new (&*it) value_type{std::move(*next)};
}
Container::pop_back();
return 1;
}
}
return 0;
} | O0 | cpp | unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11]):
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xeda30
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rdi
callq 0xeda60
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xeda90
testb $0x1, %al
jne 0x17ba69
jmp 0x17bb41
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xeec00
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rdx
callq 0x17a7e0
testb $0x1, %al
jne 0x17ba9c
jmp 0x17bb30
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xedb10
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0xeda60
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xeda90
testb $0x1, %al
jne 0x17bad9
jmp 0x17bb1b
leaq 0x38(%rsp), %rdi
callq 0xeec00
movq %rax, %rdi
callq 0xeb110
leaq 0x38(%rsp), %rdi
callq 0xedad0
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0xedad0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xef320
leaq 0x38(%rsp), %rdi
callq 0xedb10
jmp 0x17baa6
movq 0x18(%rsp), %rdi
callq 0x17bb60
movq $0x1, 0x50(%rsp)
jmp 0x17bb4a
jmp 0x17bb32
leaq 0x38(%rsp), %rdi
callq 0xedb10
jmp 0x17ba42
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
mov rdi, [rsp+58h+var_10]
mov [rsp+58h+var_40], rdi
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE5beginEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::begin(void)
mov [rsp+58h+var_20], rax
loc_17BA42:
mov rdi, [rsp+58h+var_40]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov [rsp+58h+var_28], rax
lea rdi, [rsp+58h+var_20]
lea rsi, [rsp+58h+var_28]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
test al, 1
jnz short loc_17BA69
jmp loc_17BB41
loc_17BA69:
mov rax, [rsp+58h+var_40]
add rax, 18h
mov [rsp+58h+var_48], rax
lea rdi, [rsp+58h+var_20]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator->(void)
mov rdi, [rsp+58h+var_48]
mov rsi, rax
mov rdx, [rsp+58h+var_18]
call _ZNKSt8equal_toIvEclIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA11_KcEEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSD_OSE_
test al, 1
jnz short loc_17BA9C
jmp loc_17BB30
loc_17BA9C:
mov rax, [rsp+58h+var_20]
mov [rsp+58h+var_30], rax
loc_17BAA6:
lea rdi, [rsp+58h+var_30]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator++(void)
mov rdi, [rsp+58h+var_40]
mov [rsp+58h+var_50], rax
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov rdi, [rsp+58h+var_50]
mov [rsp+58h+var_38], rax
lea rsi, [rsp+58h+var_38]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
test al, 1
jnz short loc_17BAD9
jmp short loc_17BB1B
loc_17BAD9:
lea rdi, [rsp+58h+var_20]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator->(void)
mov rdi, rax
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~pair()
lea rdi, [rsp+58h+var_20]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator*(void)
mov [rsp+58h+var_58], rax
lea rdi, [rsp+58h+var_30]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator*(void)
mov rdi, [rsp+58h+var_58]
mov rsi, rax
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2EOSG_; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pair(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>&&)
lea rdi, [rsp+58h+var_20]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator++(void)
jmp short loc_17BAA6
loc_17BB1B:
mov rdi, [rsp+58h+var_40]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE8pop_backEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::pop_back(void)
mov [rsp+58h+var_8], 1
jmp short loc_17BB4A
loc_17BB30:
jmp short $+2
loc_17BB32:
lea rdi, [rsp+58h+var_20]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator++(void)
jmp loc_17BA42
loc_17BB41:
mov [rsp+58h+var_8], 0
loc_17BB4A:
mov rax, [rsp+58h+var_8]
add rsp, 58h
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_(
long long a1,
long long a2)
{
long long v2; // rax
void *v3; // rax
long long v4; // rax
long long v6; // [rsp+0h] [rbp-58h]
_QWORD *v7; // [rsp+8h] [rbp-50h]
long long v8; // [rsp+20h] [rbp-38h] BYREF
long long v9; // [rsp+28h] [rbp-30h] BYREF
long long v10; // [rsp+30h] [rbp-28h] BYREF
long long i; // [rsp+38h] [rbp-20h] BYREF
long long v12; // [rsp+40h] [rbp-18h]
long long v13; // [rsp+48h] [rbp-10h]
v13 = a1;
v12 = a2;
for ( i = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::begin(a1);
;
__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator++(&i) )
{
v10 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::end(a1);
if ( !__gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>(
(long long)&i,
(long long)&v10) )
return 0LL;
v2 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator->((long long)&i);
if ( std::equal_to<void>::operator()<std::string const&,char const(&)[11]>(a1 + 24, v2, v12) )
break;
}
v9 = i;
while ( 1 )
{
v7 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator++(&v9);
v8 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::end(a1);
if ( !__gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>(
(long long)v7,
(long long)&v8) )
break;
v3 = (void *)__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator->((long long)&i);
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~pair(v3);
v6 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator*((long long)&i);
v4 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator*((long long)&v9);
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pair(
v6,
v4);
__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator++(&i);
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::pop_back(a1);
return 1LL;
}
| |||
22,566 | unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11]) | monkey531[P]llama/common/json.hpp | size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
// Since we cannot move const Keys, re-construct them in place
for (auto next = it; ++next != this->end(); ++it)
{
it->~value_type(); // Destroy but keep allocation
new (&*it) value_type{std::move(*next)};
}
Container::pop_back();
return 1;
}
}
return 0;
} | O2 | cpp | unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11]):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x8(%r14), %r13
cmpq %r13, %rbx
je 0x83125
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2cbe9
testb %al, %al
jne 0x830f8
addq $0x30, %rbx
jmp 0x830da
movq %rbx, %r15
leaq 0x30(%r15), %r12
cmpq 0x8(%r14), %r12
je 0x8311d
movq %r15, %rdi
callq 0x52c30
movq %r15, %rdi
movq %r12, %rsi
callq 0x53894
movq %r12, %r15
jmp 0x830fb
movq %r14, %rdi
callq 0x82dae
xorl %eax, %eax
cmpq %r13, %rbx
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
push r15
push r14
push r13
push r12
push rbx
mov r15, rsi
mov r14, rdi
mov rbx, [rdi]
loc_830DA:
mov r13, [r14+8]
cmp rbx, r13
jz short loc_83125
mov rdi, rbx
mov rsi, r15
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_830F8
add rbx, 30h ; '0'
jmp short loc_830DA
loc_830F8:
mov r15, rbx
loc_830FB:
lea r12, [r15+30h]
cmp r12, [r14+8]
jz short loc_8311D
mov rdi, r15; void *
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~pair()
mov rdi, r15
mov rsi, r12
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2EOSG_; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pair(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>&&)
mov r15, r12
jmp short loc_830FB
loc_8311D:
mov rdi, r14
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE8pop_backEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::pop_back(void)
loc_83125:
xor eax, eax
cmp rbx, r13
setnz al
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| _BOOL8 ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_(
long long *a1)
{
long long i; // rbx
long long v2; // r13
char *j; // r15
for ( i = *a1; ; i += 48LL )
{
v2 = a1[1];
if ( i == v2 )
break;
if ( std::operator==<char>(i) )
{
for ( j = (char *)i; j + 48 != (char *)a1[1]; j += 48 )
{
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~pair(j);
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pair(
(long long)j,
(long long)(j + 48));
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::pop_back((long long)a1);
return i != v2;
}
}
return i != v2;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LAB_001830da:
MOV R13,qword ptr [R14 + 0x8]
CMP RBX,R13
JZ 0x00183125
MOV RDI,RBX
MOV RSI,R15
CALL 0x0012cbe9
TEST AL,AL
JNZ 0x001830f8
ADD RBX,0x30
JMP 0x001830da
LAB_001830f8:
MOV R15,RBX
LAB_001830fb:
LEA R12,[R15 + 0x30]
CMP R12,qword ptr [R14 + 0x8]
JZ 0x0018311d
MOV RDI,R15
CALL 0x00152c30
MOV RDI,R15
MOV RSI,R12
CALL 0x00153894
MOV R15,R12
JMP 0x001830fb
LAB_0018311d:
MOV RDI,R14
CALL 0x00182dae
LAB_00183125:
XOR EAX,EAX
CMP RBX,R13
SETNZ AL
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
bool _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_
(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*param_1,char *param_2)
{
pair *ppVar1;
string *psVar2;
bool bVar3;
string *psVar4;
pair *this;
for (psVar4 = *(string **)param_1; psVar2 = *(string **)(param_1 + 8), psVar4 != psVar2;
psVar4 = psVar4 + 0x30) {
bVar3 = std::operator==(psVar4,param_2);
this = (pair *)psVar4;
if (bVar3) goto LAB_001830fb;
}
LAB_00183125:
return psVar4 != psVar2;
LAB_001830fb:
while (ppVar1 = (pair *)((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this + 0x30), ppVar1 != *(pair **)(param_1 + 8)) {
std::
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::~pair((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this);
std::
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::pair((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this,ppVar1);
this = ppVar1;
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::pop_back(param_1);
goto LAB_00183125;
}
| |
22,567 | CLI::App::get_groups[abi:cxx11]() const | MikePodsytnik[P]TCRtrie/build_O0/_deps/cli11-src/include/CLI/impl/App_inl.hpp | CLI11_NODISCARD CLI11_INLINE std::vector<std::string> App::get_groups() const {
std::vector<std::string> groups;
for(const Option_p &opt : options_) {
// Add group if it is not already in there
if(std::find(groups.begin(), groups.end(), opt->get_group()) == groups.end()) {
groups.push_back(opt->get_group());
}
}
return groups;
} | O0 | cpp | CLI::App::get_groups[abi:cxx11]() const:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x18480
movq -0x70(%rbp), %rax
addq $0xd8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x19480
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x194b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x194e0
testb $0x1, %al
jne 0xd44d
jmp 0xd52b
leaq -0x28(%rbp), %rdi
callq 0x19520
movq -0x80(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0xd5a0
movq -0x80(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0xd890
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
callq 0x195d0
movq %rax, %rdi
callq 0xdd70
movq %rax, -0x88(%rbp)
jmp 0xd48e
movq -0x88(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x19580
movq %rax, -0x90(%rbp)
jmp 0xd4ab
movq -0x80(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xd890
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x19540
testb $0x1, %al
jne 0xd4d6
jmp 0xd51b
movq -0x38(%rbp), %rdi
callq 0x195d0
movq %rax, %rdi
callq 0xdd70
movq %rax, -0x98(%rbp)
jmp 0xd4f0
movq -0x98(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x18510
jmp 0xd502
jmp 0xd51b
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0xe270
jmp 0xd54b
jmp 0xd51d
leaq -0x28(%rbp), %rdi
callq 0x195f0
jmp 0xd437
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xd53e
movq -0x80(%rbp), %rdi
callq 0xe270
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x9a70
nopw %cs:(%rax,%rax)
nop
| _ZNK3CLI3App10get_groupsB5cxx11Ev:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_80], rdi
mov rax, rdi
mov [rbp+var_78], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_70], rax
mov [rbp+var_11], 0
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov rax, [rbp+var_70]
add rax, 0D8h
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
call _ZNKSt6vectorISt10unique_ptrIN3CLI6OptionESt14default_deleteIS2_EESaIS5_EE5beginEv; std::vector<std::unique_ptr<CLI::Option>>::begin(void)
mov [rbp+var_28], rax
mov rdi, [rbp+var_20]
call _ZNKSt6vectorISt10unique_ptrIN3CLI6OptionESt14default_deleteIS2_EESaIS5_EE3endEv; std::vector<std::unique_ptr<CLI::Option>>::end(void)
mov [rbp+var_30], rax
loc_D437:
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_30]
call _ZN9__gnu_cxxneIPKSt10unique_ptrIN3CLI6OptionESt14default_deleteIS3_EESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESH_; __gnu_cxx::operator!=<std::unique_ptr<CLI::Option> const*,std::vector<std::unique_ptr<CLI::Option>>>(__gnu_cxx::__normal_iterator<std::unique_ptr<CLI::Option> const*,std::vector<std::unique_ptr<CLI::Option>>> const&,__gnu_cxx::__normal_iterator<std::unique_ptr<CLI::Option> const*,std::vector<std::unique_ptr<CLI::Option>>> const&)
test al, 1
jnz short loc_D44D
jmp loc_D52B
loc_D44D:
lea rdi, [rbp+var_28]
call _ZNK9__gnu_cxx17__normal_iteratorIPKSt10unique_ptrIN3CLI6OptionESt14default_deleteIS3_EESt6vectorIS6_SaIS6_EEEdeEv; __gnu_cxx::__normal_iterator<std::unique_ptr<CLI::Option> const*,std::vector<std::unique_ptr<CLI::Option>>>::operator*(void)
mov rdi, [rbp+var_80]
mov [rbp+var_38], rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5beginEv; std::vector<std::string>::begin(void)
mov rdi, [rbp+var_80]
mov [rbp+var_48], rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE3endEv; std::vector<std::string>::end(void)
mov [rbp+var_50], rax
mov rdi, [rbp+var_38]
call _ZNKSt10unique_ptrIN3CLI6OptionESt14default_deleteIS1_EEptEv; std::unique_ptr<CLI::Option>::operator->(void)
mov rdi, rax
call _ZNK3CLI10OptionBaseINS_6OptionEE9get_groupB5cxx11Ev; CLI::OptionBase<CLI::Option>::get_group(void)
mov [rbp+var_88], rax
jmp short $+2
loc_D48E:
mov rdx, [rbp+var_88]
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_50]
call _ZSt4findIN9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS7_SaIS7_EEEES7_ET_SD_SD_RKT0_; std::find<__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>,std::string>(__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>,__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>,std::string const&)
mov [rbp+var_90], rax
jmp short $+2
loc_D4AB:
mov rdi, [rbp+var_80]
mov rax, [rbp+var_90]
mov [rbp+var_40], rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE3endEv; std::vector<std::string>::end(void)
mov [rbp+var_68], rax
lea rdi, [rbp+var_40]
lea rsi, [rbp+var_68]
call _ZN9__gnu_cxxeqIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESG_; __gnu_cxx::operator==<std::string *,std::vector<std::string>>(__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>> const&,__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>> const&)
test al, 1
jnz short loc_D4D6
jmp short loc_D51B
loc_D4D6:
mov rdi, [rbp+var_38]
call _ZNKSt10unique_ptrIN3CLI6OptionESt14default_deleteIS1_EEptEv; std::unique_ptr<CLI::Option>::operator->(void)
mov rdi, rax
call _ZNK3CLI10OptionBaseINS_6OptionEE9get_groupB5cxx11Ev; CLI::OptionBase<CLI::Option>::get_group(void)
mov [rbp+var_98], rax
jmp short $+2
loc_D4F0:
mov rsi, [rbp+var_98]
mov rdi, [rbp+var_80]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
jmp short $+2
loc_D502:
jmp short loc_D51B
mov rdi, [rbp+var_80]
mov rcx, rax
mov eax, edx
mov [rbp+var_58], rcx
mov [rbp+var_5C], eax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_D54B
loc_D51B:
jmp short $+2
loc_D51D:
lea rdi, [rbp+var_28]
call _ZN9__gnu_cxx17__normal_iteratorIPKSt10unique_ptrIN3CLI6OptionESt14default_deleteIS3_EESt6vectorIS6_SaIS6_EEEppEv; __gnu_cxx::__normal_iterator<std::unique_ptr<CLI::Option> const*,std::vector<std::unique_ptr<CLI::Option>>>::operator++(void)
jmp loc_D437
loc_D52B:
mov [rbp+var_11], 1
test [rbp+var_11], 1
jnz short loc_D53E
mov rdi, [rbp+var_80]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_D53E:
mov rax, [rbp+var_78]
add rsp, 0A0h
pop rbp
retn
loc_D54B:
mov rdi, [rbp+var_58]
call __Unwind_Resume
| long long CLI::App::get_groups[abi:cxx11](long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v5; // [rsp+8h] [rbp-98h]
long long v6; // [rsp+18h] [rbp-88h]
long long v7; // [rsp+38h] [rbp-68h] BYREF
long long v8; // [rsp+50h] [rbp-50h]
long long v9; // [rsp+58h] [rbp-48h]
long long v10; // [rsp+60h] [rbp-40h] BYREF
long long v11; // [rsp+68h] [rbp-38h]
long long v12; // [rsp+70h] [rbp-30h] BYREF
_QWORD v13[2]; // [rsp+78h] [rbp-28h] BYREF
char v14; // [rsp+8Fh] [rbp-11h]
long long v15; // [rsp+90h] [rbp-10h]
long long v16; // [rsp+98h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = 0;
std::vector<std::string>::vector();
v13[1] = a2 + 216;
v13[0] = std::vector<std::unique_ptr<CLI::Option>>::begin(a2 + 216);
v12 = std::vector<std::unique_ptr<CLI::Option>>::end(a2 + 216);
while ( (__gnu_cxx::operator!=<std::unique_ptr<CLI::Option> const*,std::vector<std::unique_ptr<CLI::Option>>>(
v13,
&v12) & 1) != 0 )
{
v11 = __gnu_cxx::__normal_iterator<std::unique_ptr<CLI::Option> const*,std::vector<std::unique_ptr<CLI::Option>>>::operator*(v13);
v9 = std::vector<std::string>::begin(a1);
v8 = std::vector<std::string>::end(a1);
v2 = std::unique_ptr<CLI::Option>::operator->(v11);
v6 = CLI::OptionBase<CLI::Option>::get_group[abi:cxx11](v2);
v10 = std::find<__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>,std::string>(v9, v8, v6);
v7 = std::vector<std::string>::end(a1);
if ( (__gnu_cxx::operator==<std::string *,std::vector<std::string>>(&v10, &v7) & 1) != 0 )
{
v3 = std::unique_ptr<CLI::Option>::operator->(v11);
v5 = CLI::OptionBase<CLI::Option>::get_group[abi:cxx11](v3);
std::vector<std::string>::push_back(a1, v5);
}
__gnu_cxx::__normal_iterator<std::unique_ptr<CLI::Option> const*,std::vector<std::unique_ptr<CLI::Option>>>::operator++(v13);
}
return a1;
}
| get_groups[abi:cxx11]:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x80],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x78],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x70],RAX
MOV byte ptr [RBP + -0x11],0x0
CALL 0x00118480
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,0xd8
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00119480
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001194b0
MOV qword ptr [RBP + -0x30],RAX
LAB_0010d437:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x30]
CALL 0x001194e0
TEST AL,0x1
JNZ 0x0010d44d
JMP 0x0010d52b
LAB_0010d44d:
LEA RDI,[RBP + -0x28]
CALL 0x00119520
MOV RDI,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x38],RAX
CALL 0x0010d5a0
MOV RDI,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x48],RAX
CALL 0x0010d890
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001195d0
MOV RDI,RAX
LAB_0010d480:
CALL 0x0010dd70
MOV qword ptr [RBP + -0x88],RAX
JMP 0x0010d48e
LAB_0010d48e:
MOV RDX,qword ptr [RBP + -0x88]
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x50]
CALL 0x00119580
MOV qword ptr [RBP + -0x90],RAX
JMP 0x0010d4ab
LAB_0010d4ab:
MOV RDI,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x40],RAX
CALL 0x0010d890
MOV qword ptr [RBP + -0x68],RAX
LEA RDI,[RBP + -0x40]
LEA RSI,[RBP + -0x68]
CALL 0x00119540
TEST AL,0x1
JNZ 0x0010d4d6
JMP 0x0010d51b
LAB_0010d4d6:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001195d0
MOV RDI,RAX
CALL 0x0010dd70
MOV qword ptr [RBP + -0x98],RAX
JMP 0x0010d4f0
LAB_0010d4f0:
MOV RSI,qword ptr [RBP + -0x98]
MOV RDI,qword ptr [RBP + -0x80]
CALL 0x00118510
LAB_0010d500:
JMP 0x0010d502
LAB_0010d502:
JMP 0x0010d51b
LAB_0010d51b:
JMP 0x0010d51d
LAB_0010d51d:
LEA RDI,[RBP + -0x28]
CALL 0x001195f0
JMP 0x0010d437
LAB_0010d52b:
MOV byte ptr [RBP + -0x11],0x1
TEST byte ptr [RBP + -0x11],0x1
JNZ 0x0010d53e
MOV RDI,qword ptr [RBP + -0x80]
CALL 0x0010e270
LAB_0010d53e:
MOV RAX,qword ptr [RBP + -0x78]
ADD RSP,0xa0
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x0010d535) */
/* CLI::App::get_groups[abi:cxx11]() const */
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *
CLI::App::get_groups_abi_cxx11_(void)
{
bool bVar1;
OptionBase<CLI::Option> *pOVar2;
int8 uVar3;
string *psVar4;
long in_RSI;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *in_RDI;
int8 local_70 [3];
int8 local_58;
int8 local_50;
int8 local_48;
unique_ptr<CLI::Option,std::default_delete<CLI::Option>> *local_40;
int8 local_38;
int8 local_30;
vector<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>,std::allocator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>>>
*local_28;
int1 local_19;
local_19 = 0;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector(in_RDI);
local_28 = (vector<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>,std::allocator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>>>
*)(in_RSI + 0xd8);
local_30 = std::
vector<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>,std::allocator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>>>
::begin(local_28);
local_38 = std::
vector<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>,std::allocator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>>>
::end(local_28);
while (bVar1 = __gnu_cxx::operator!=
((__normal_iterator *)&local_30,(__normal_iterator *)&local_38), bVar1) {
local_40 = (unique_ptr<CLI::Option,std::default_delete<CLI::Option>> *)
__gnu_cxx::
__normal_iterator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>const*,std::vector<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>,std::allocator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>>>>
::operator*((__normal_iterator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>const*,std::vector<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>,std::allocator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>>>>
*)&local_30);
local_50 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::begin(in_RDI)
;
local_58 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::end(in_RDI);
pOVar2 = (OptionBase<CLI::Option> *)
std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>::operator->(local_40);
/* try { // try from 0010d480 to 0010d4ff has its CatchHandler @ 0010d504 */
uVar3 = OptionBase<CLI::Option>::get_group_abi_cxx11_(pOVar2);
local_48 = std::
find<__gnu_cxx::__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>,std::__cxx11::string>
(local_50,local_58,uVar3);
local_70[0] = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::end
(in_RDI);
bVar1 = __gnu_cxx::operator==((__normal_iterator *)&local_48,(__normal_iterator *)local_70);
if (bVar1) {
pOVar2 = (OptionBase<CLI::Option> *)
std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>::operator->(local_40);
psVar4 = (string *)OptionBase<CLI::Option>::get_group_abi_cxx11_(pOVar2);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
(in_RDI,psVar4);
}
__gnu_cxx::
__normal_iterator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>const*,std::vector<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>,std::allocator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>>>>
::operator++((__normal_iterator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>const*,std::vector<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>,std::allocator<std::unique_ptr<CLI::Option,std::default_delete<CLI::Option>>>>>
*)&local_30);
}
return in_RDI;
}
| |
22,568 | end_of_previous_entry | eloqsql/storage/maria/ma_blockrec.c | static inline uint end_of_previous_entry(MARIA_SHARE *share,
uchar *dir, uchar *end)
{
uchar *pos;
for (pos= dir + DIR_ENTRY_SIZE ; pos < end ; pos+= DIR_ENTRY_SIZE)
{
uint offset;
if ((offset= uint2korr(pos)))
return offset + uint2korr(pos+2);
}
return PAGE_HEADER_SIZE(share);
} | O0 | c | end_of_previous_entry:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x801f7
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x801e7
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x80207
jmp 0x801e9
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x801bc
movq -0x10(%rbp), %rax
movl 0xc18(%rax), %eax
addl $0xc, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| end_of_previous_entry:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
add rax, 4
mov [rbp+var_28], rax
loc_801BC:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
jnb short loc_801F7
mov rax, [rbp+var_28]
movzx eax, word ptr [rax]
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_801E7
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_28]
movzx ecx, word ptr [rcx+2]
add eax, ecx
mov [rbp+var_4], eax
jmp short loc_80207
loc_801E7:
jmp short $+2
loc_801E9:
mov rax, [rbp+var_28]
add rax, 4
mov [rbp+var_28], rax
jmp short loc_801BC
loc_801F7:
mov rax, [rbp+var_10]
mov eax, [rax+0C18h]
add eax, 0Ch
mov [rbp+var_4], eax
loc_80207:
mov eax, [rbp+var_4]
pop rbp
retn
| long long end_of_previous_entry(long long a1, long long a2, unsigned long long a3)
{
unsigned __int16 *i; // [rsp+4h] [rbp-28h]
for ( i = (unsigned __int16 *)(a2 + 4); (unsigned long long)i < a3; i += 2 )
{
if ( *i )
return (unsigned int)(i[1] + *i);
}
return (unsigned int)(*(_DWORD *)(a1 + 3096) + 12);
}
| end_of_previous_entry:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x4
MOV qword ptr [RBP + -0x28],RAX
LAB_001801bc:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001801f7
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x001801e7
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ECX,word ptr [RCX + 0x2]
ADD EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00180207
LAB_001801e7:
JMP 0x001801e9
LAB_001801e9:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x4
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001801bc
LAB_001801f7:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc18]
ADD EAX,0xc
MOV dword ptr [RBP + -0x4],EAX
LAB_00180207:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int end_of_previous_entry(long param_1,long param_2,ushort *param_3)
{
ushort *local_30;
local_30 = (ushort *)(param_2 + 4);
while( true ) {
if (param_3 <= local_30) {
return *(int *)(param_1 + 0xc18) + 0xc;
}
if (*local_30 != 0) break;
local_30 = local_30 + 2;
}
return (uint)*local_30 + (uint)local_30[1];
}
| |
22,569 | my_casedn_str_utf8mb3 | eloqsql/strings/ctype-utf8.c | static size_t my_casedn_str_utf8mb3(CHARSET_INFO *cs, char *src)
{
my_wc_t wc;
int srcres, dstres;
char *dst= src, *dst0= src;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(cs->casedn_multiply == 1);
while (*src &&
(srcres= my_utf8mb3_uni_no_range(cs, &wc, (uchar *) src)) > 0)
{
my_tolower_utf8mb3(uni_plane, &wc);
if ((dstres= my_uni_utf8mb3_no_range(cs, wc, (uchar*) dst)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
/*
In rare cases lower string can be shorter than
the original string, for example:
"U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE"
(which is 0xC4B0 in utf8mb3, i.e. two bytes)
is converted into
"U+0069 LATIN SMALL LETTER I"
(which is 0x69 in utf8mb3, i.e. one byte)
So, we need to put '\0' terminator after converting.
*/
*dst= '\0';
return (size_t) (dst - dst0);
} | O3 | c | my_casedn_str_utf8mb3:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
movq %rsi, %r14
je 0xcc49e
movq 0x78(%rdi), %r13
leaq -0x30(%rbp), %r15
movq %rbx, %r12
movq %rbx, %r14
movq %r15, %rdi
movq %r12, %rsi
callq 0xccc8c
testl %eax, %eax
je 0xcc49e
movq 0x8(%r13), %rdx
movq -0x30(%rbp), %rcx
movzbl %ch, %esi
movq (%rdx,%rsi,8), %rdx
testq %rdx, %rdx
je 0xcc42d
movzbl %cl, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x4(%rdx,%rcx,4), %ecx
movq %rcx, -0x30(%rbp)
movl $0x1, %edx
cmpq $0x80, %rcx
jb 0xcc487
movl $0x2, %edx
cmpq $0x800, %rcx # imm = 0x800
jb 0xcc46e
cmpq $0xffff, %rcx # imm = 0xFFFF
ja 0xcc49e
movl %ecx, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x2(%r14)
shrq $0x6, %rcx
orq $0x800, %rcx # imm = 0x800
movl $0x3, %edx
movl %ecx, %esi
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x1(%r14)
shrq $0x6, %rcx
orq $0xc0, %rcx
movb %cl, (%r14)
movl %eax, %eax
addq %rdx, %r14
cmpb $0x0, (%r12,%rax)
leaq (%r12,%rax), %r12
jne 0xcc3f7
movb $0x0, (%r14)
subq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_casedn_str_utf8mb3:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
cmp byte ptr [rsi], 0
mov r14, rsi
jz loc_CC49E
mov r13, [rdi+78h]
lea r15, [rbp+var_30]
mov r12, rbx
mov r14, rbx
loc_CC3F7:
mov rdi, r15
mov rsi, r12
call my_utf8mb3_uni_no_range
test eax, eax
jz loc_CC49E
mov rdx, [r13+8]
mov rcx, [rbp+var_30]
movzx esi, ch
mov rdx, [rdx+rsi*8]
test rdx, rdx
jz short loc_CC42D
movzx ecx, cl
lea rcx, [rcx+rcx*2]
mov ecx, [rdx+rcx*4+4]
mov [rbp+var_30], rcx
loc_CC42D:
mov edx, 1
cmp rcx, 80h
jb short loc_CC487
mov edx, 2
cmp rcx, 800h
jb short loc_CC46E
cmp rcx, 0FFFFh
ja short loc_CC49E
mov edx, ecx
and dl, 3Fh
or dl, 80h
mov [r14+2], dl
shr rcx, 6
or rcx, 800h
mov edx, 3
loc_CC46E:
mov esi, ecx
and sil, 3Fh
or sil, 80h
mov [r14+1], sil
shr rcx, 6
or rcx, 0C0h
loc_CC487:
mov [r14], cl
mov eax, eax
add r14, rdx
cmp byte ptr [r12+rax], 0
lea r12, [r12+rax]
jnz loc_CC3F7
loc_CC49E:
mov byte ptr [r14], 0
sub r14, rbx
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_casedn_str_utf8mb3(long long a1, _BYTE *a2)
{
unsigned long long v2; // rax
_BYTE *v3; // r14
long long v4; // r13
_BYTE *v5; // r12
unsigned int v6; // eax
unsigned long long v7; // rcx
long long v8; // rdx
long long v9; // rdx
bool v10; // zf
unsigned long long v12; // [rsp+0h] [rbp-30h] BYREF
v12 = v2;
v3 = a2;
if ( *a2 )
{
v4 = *(_QWORD *)(a1 + 120);
v5 = a2;
v3 = a2;
do
{
v6 = my_utf8mb3_uni_no_range(&v12, v5);
if ( !v6 )
break;
v7 = v12;
v8 = *(_QWORD *)(*(_QWORD *)(v4 + 8) + 8LL * BYTE1(v12));
if ( v8 )
{
v7 = *(unsigned int *)(v8 + 12LL * (unsigned __int8)v12 + 4);
v12 = v7;
}
v9 = 1LL;
if ( v7 >= 0x80 )
{
v9 = 2LL;
if ( v7 >= 0x800 )
{
if ( v7 > 0xFFFF )
break;
v3[2] = v7 & 0x3F | 0x80;
v7 = (v7 >> 6) | 0x800;
v9 = 3LL;
}
v3[1] = v7 & 0x3F | 0x80;
v7 = (v7 >> 6) | 0xC0;
}
*v3 = v7;
v3 += v9;
v10 = v5[v6] == 0;
v5 += v6;
}
while ( !v10 );
}
*v3 = 0;
return v3 - a2;
}
| my_casedn_str_utf8mb3:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
CMP byte ptr [RSI],0x0
MOV R14,RSI
JZ 0x001cc49e
MOV R13,qword ptr [RDI + 0x78]
LEA R15,[RBP + -0x30]
MOV R12,RBX
MOV R14,RBX
LAB_001cc3f7:
MOV RDI,R15
MOV RSI,R12
CALL 0x001ccc8c
TEST EAX,EAX
JZ 0x001cc49e
MOV RDX,qword ptr [R13 + 0x8]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ESI,CH
MOV RDX,qword ptr [RDX + RSI*0x8]
TEST RDX,RDX
JZ 0x001cc42d
MOVZX ECX,CL
LEA RCX,[RCX + RCX*0x2]
MOV ECX,dword ptr [RDX + RCX*0x4 + 0x4]
MOV qword ptr [RBP + -0x30],RCX
LAB_001cc42d:
MOV EDX,0x1
CMP RCX,0x80
JC 0x001cc487
MOV EDX,0x2
CMP RCX,0x800
JC 0x001cc46e
CMP RCX,0xffff
JA 0x001cc49e
MOV EDX,ECX
AND DL,0x3f
OR DL,0x80
MOV byte ptr [R14 + 0x2],DL
SHR RCX,0x6
OR RCX,0x800
MOV EDX,0x3
LAB_001cc46e:
MOV ESI,ECX
AND SIL,0x3f
OR SIL,0x80
MOV byte ptr [R14 + 0x1],SIL
SHR RCX,0x6
OR RCX,0xc0
LAB_001cc487:
MOV byte ptr [R14],CL
MOV EAX,EAX
ADD R14,RDX
CMP byte ptr [R12 + RAX*0x1],0x0
LEA R12,[R12 + RAX*0x1]
JNZ 0x001cc3f7
LAB_001cc49e:
MOV byte ptr [R14],0x0
SUB R14,RBX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_casedn_str_utf8mb3(long param_1,char *param_2)
{
char *pcVar1;
long lVar2;
uint uVar3;
ulong in_RAX;
ulong uVar4;
long lVar5;
char *pcVar6;
char *pcVar7;
ulong local_38;
pcVar7 = param_2;
if (*param_2 != '\0') {
lVar2 = *(long *)(param_1 + 0x78);
pcVar6 = param_2;
local_38 = in_RAX;
do {
uVar3 = my_utf8mb3_uni_no_range(&local_38,pcVar6);
if (uVar3 == 0) break;
lVar5 = *(long *)(*(long *)(lVar2 + 8) + (local_38 >> 8 & 0xff) * 8);
if (lVar5 != 0) {
local_38 = (ulong)*(uint *)(lVar5 + 4 + (local_38 & 0xff) * 0xc);
}
lVar5 = 1;
uVar4 = local_38;
if (0x7f < local_38) {
lVar5 = 2;
if (0x7ff < local_38) {
if (0xffff < local_38) break;
pcVar7[2] = (byte)local_38 & 0x3f | 0x80;
uVar4 = local_38 >> 6 | 0x800;
lVar5 = 3;
}
pcVar7[1] = (byte)uVar4 & 0x3f | 0x80;
uVar4 = uVar4 >> 6 | 0xc0;
}
*pcVar7 = (char)uVar4;
pcVar7 = pcVar7 + lVar5;
pcVar1 = pcVar6 + uVar3;
pcVar6 = pcVar6 + uVar3;
} while (*pcVar1 != '\0');
}
*pcVar7 = '\0';
return (long)pcVar7 - (long)param_2;
}
| |
22,570 | translog_assign_id_to_share | eloqsql/storage/maria/ma_loghandler.c | int translog_assign_id_to_share(MARIA_HA *tbl_info, TRN *trn)
{
uint16 id;
MARIA_SHARE *share= tbl_info->s;
/*
If you give an id to a non-BLOCK_RECORD table, you also need to release
this id somewhere. Then you can change the assertion.
*/
DBUG_ASSERT(share->data_file_type == BLOCK_RECORD);
/* re-check under mutex to avoid having 2 ids for the same share */
mysql_mutex_lock(&share->intern_lock);
if (unlikely(share->id == 0))
{
LSN lsn;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
uchar log_data[FILEID_STORE_SIZE];
/* Inspired by set_short_trid() of trnman.c */
uint i= share->kfile.file % SHARE_ID_MAX + 1;
id= 0;
do
{
for ( ; i <= SHARE_ID_MAX ; i++) /* the range is [1..SHARE_ID_MAX] */
{
void *tmp= NULL;
if (id_to_share[i] == NULL &&
my_atomic_casptr((void **)&id_to_share[i], &tmp, share))
{
id= (uint16) i;
break;
}
}
i= 1; /* scan the whole array */
} while (id == 0);
DBUG_PRINT("info", ("id_to_share: %p -> %u", share, id));
fileid_store(log_data, id);
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
/*
open_file_name is an unresolved name (symlinks are not resolved, datadir
is not realpath-ed, etc) which is good: the log can be moved to another
directory and continue working.
*/
log_array[TRANSLOG_INTERNAL_PARTS + 1].str=
(uchar *)share->open_file_name.str;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length=
share->open_file_name.length + 1;
/*
We can't unlock share->intern_lock before the log entry is written to
ensure no one uses the id before it's logged.
*/
if (unlikely(translog_write_record(&lsn, LOGREC_FILE_ID, trn, tbl_info,
(translog_size_t)
(sizeof(log_data) +
log_array[TRANSLOG_INTERNAL_PARTS +
1].length),
sizeof(log_array)/sizeof(log_array[0]),
log_array, NULL, NULL)))
{
mysql_mutex_unlock(&share->intern_lock);
return 1;
}
/*
Now when translog record is done, we can set share->id.
If we set it before, then translog_write_record may pick up the id
before it's written to the log.
*/
share->id= id;
share->state.logrec_file_id= lsn;
}
mysql_mutex_unlock(&share->intern_lock);
return 0;
} | O3 | c | translog_assign_id_to_share:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %r12
leaq 0x8f0(%r12), %rbx
cmpq $0x0, 0x930(%r12)
jne 0x3825b
movq %rbx, %rdi
callq 0x2a220
cmpw $0x0, 0x620(%r12)
je 0x38271
movq 0x930(%r12), %rdi
testq %rdi, %rdi
jne 0x3835a
movq %rbx, %rdi
callq 0x2a1e0
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa8df6(%rip), %rsi # 0xe1058
movq %rbx, %rdi
movl $0x206a, %edx # imm = 0x206A
callq 0x30603
jmp 0x38225
movslq 0x760(%r12), %rax
imulq $-0x7fff7fff, %rax, %rcx # imm = 0x80008001
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0xf, %ecx
addl %edx, %ecx
movl %ecx, %edx
shll $0x10, %edx
subl %edx, %ecx
addl %ecx, %eax
incl %eax
cmpl $0xffff, %eax # imm = 0xFFFF
ja 0x382d0
movl %eax, %r13d
movq 0xbcfdec(%rip), %rcx # 0xc08098
cmpq $0x0, (%rcx,%r13,8)
jne 0x382c4
xorl %eax, %eax
lock
cmpxchgq %r12, (%rcx,%r13,8)
je 0x382d3
movq 0xbcfdd4(%rip), %rcx # 0xc08098
incq %r13
cmpl $0x10000, %r13d # imm = 0x10000
jne 0x382ac
xorl %r13d, %r13d
movl $0x1, %eax
testw %r13w, %r13w
je 0x3829b
leaq -0x2a(%rbp), %rax
movw %r13w, (%rax)
leaq -0x80(%rbp), %rcx
movq %rax, 0x20(%rcx)
movq $0x2, 0x28(%rcx)
movq 0x5e0(%r12), %rax
movq %rax, 0x30(%rcx)
movq 0x5e8(%r12), %r8
leaq 0x1(%r8), %rax
movq %rax, 0x38(%rcx)
addl $0x3, %r8d
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movq %rcx, (%rsp)
leaq -0x38(%rbp), %rdi
movl $0x23, %esi
movq %r15, %rdx
movq %r14, %rcx
movl $0x4, %r9d
callq 0x2ad24
testb %al, %al
jne 0x3836f
movw %r13w, 0x620(%r12)
movq -0x38(%rbp), %rax
movq %rax, 0x190(%r12)
jmp 0x38231
leaq 0x356ef7(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x38242
movq 0x930(%r12), %rdi
testq %rdi, %rdi
jne 0x3838e
movq %rbx, %rdi
callq 0x2a1e0
movl $0x1, %eax
jmp 0x3824c
leaq 0x356ec3(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x3837c
| translog_assign_id_to_share:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r15, rsi
mov r14, rdi
mov r12, [rdi]
lea rbx, [r12+8F0h]
cmp qword ptr [r12+930h], 0
jnz short loc_3825B
mov rdi, rbx
call _pthread_mutex_lock
loc_38225:
cmp word ptr [r12+620h], 0
jz short loc_38271
loc_38231:
mov rdi, [r12+930h]
test rdi, rdi
jnz loc_3835A
loc_38242:
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
loc_3824C:
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3825B:
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 206Ah
call psi_mutex_lock
jmp short loc_38225
loc_38271:
movsxd rax, dword ptr [r12+760h]
imul rcx, rax, 0FFFFFFFF80008001h
shr rcx, 20h
add ecx, eax
mov edx, ecx
shr edx, 1Fh
sar ecx, 0Fh
add ecx, edx
mov edx, ecx
shl edx, 10h
sub ecx, edx
add eax, ecx
inc eax
loc_3829B:
cmp eax, 0FFFFh
ja short loc_382D0
mov r13d, eax
mov rcx, cs:id_to_share
loc_382AC:
cmp qword ptr [rcx+r13*8], 0
jnz short loc_382C4
xor eax, eax
lock cmpxchg [rcx+r13*8], r12
jz short loc_382D3
mov rcx, cs:id_to_share
loc_382C4:
inc r13
cmp r13d, offset stru_10000
jnz short loc_382AC
loc_382D0:
xor r13d, r13d
loc_382D3:
mov eax, 1
test r13w, r13w
jz short loc_3829B
lea rax, [rbp+var_2A]
mov [rax], r13w
lea rcx, [rbp+var_80]
mov [rcx+20h], rax
mov qword ptr [rcx+28h], 2
mov rax, [r12+5E0h]
mov [rcx+30h], rax
mov r8, [r12+5E8h]
lea rax, [r8+1]
mov [rcx+38h], rax
add r8d, 3
xorps xmm0, xmm0
movups [rsp+0A0h+var_98], xmm0
mov [rsp+0A0h+var_A0], rcx
lea rdi, [rbp+var_38]
mov esi, 23h ; '#'
mov rdx, r15
mov rcx, r14
mov r9d, 4
call translog_write_record
test al, al
jnz short loc_3836F
mov [r12+620h], r13w
mov rax, [rbp+var_38]
mov [r12+190h], rax
jmp loc_38231
loc_3835A:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_38242
loc_3836F:
mov rdi, [r12+930h]
test rdi, rdi
jnz short loc_3838E
loc_3837C:
mov rdi, rbx
call _pthread_mutex_unlock
mov eax, 1
jmp loc_3824C
loc_3838E:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_3837C
| long long translog_assign_id_to_share(signed long long *a1, long long a2)
{
signed long long v2; // r12
long long v3; // rbx
unsigned int v5; // eax
long long v6; // r13
long long v7; // rcx
long long v8; // r8
__int128 v9; // [rsp+20h] [rbp-80h] BYREF
__int16 *v10; // [rsp+40h] [rbp-60h]
long long v11; // [rsp+48h] [rbp-58h]
long long v12; // [rsp+50h] [rbp-50h]
long long v13; // [rsp+58h] [rbp-48h]
long long v14; // [rsp+68h] [rbp-38h] BYREF
__int16 v15; // [rsp+76h] [rbp-2Ah] BYREF
v2 = *a1;
v3 = *a1 + 2288;
if ( *(_QWORD *)(*a1 + 2352) )
psi_mutex_lock(
*a1 + 2288,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x206Au);
else
pthread_mutex_lock(*a1 + 2288);
if ( *(_WORD *)(v2 + 1568) )
{
LABEL_4:
if ( *(_QWORD *)(v2 + 2352) )
PSI_server[44]();
pthread_mutex_unlock(v3);
return 0LL;
}
v5 = *(_DWORD *)(v2 + 1888) % 0xFFFF + 1;
do
{
if ( v5 <= 0xFFFF )
{
v6 = v5;
v7 = id_to_share;
do
{
if ( !*(_QWORD *)(v7 + 8 * v6) )
{
if ( !_InterlockedCompareExchange64((volatile signed long long *)(v7 + 8 * v6), v2, 0LL) )
goto LABEL_16;
v7 = id_to_share;
}
++v6;
}
while ( (_DWORD)v6 != (_DWORD)&stru_10000 );
}
LOWORD(v6) = 0;
LABEL_16:
v5 = 1;
}
while ( !(_WORD)v6 );
v15 = v6;
v10 = &v15;
v11 = 2LL;
v12 = *(_QWORD *)(v2 + 1504);
v8 = *(_QWORD *)(v2 + 1512);
v13 = v8 + 1;
if ( !(unsigned __int8)translog_write_record(
(unsigned long long)&v14,
(long long *)((char *)&qword_20 + 3),
a2,
a1,
(int)v8 + 3,
4,
&v9,
0LL,
0LL) )
{
*(_WORD *)(v2 + 1568) = v6;
*(_QWORD *)(v2 + 400) = v14;
goto LABEL_4;
}
if ( *(_QWORD *)(v2 + 2352) )
PSI_server[44]();
pthread_mutex_unlock(v3);
return 1LL;
}
| translog_assign_id_to_share:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R15,RSI
MOV R14,RDI
MOV R12,qword ptr [RDI]
LEA RBX,[R12 + 0x8f0]
CMP qword ptr [R12 + 0x930],0x0
JNZ 0x0013825b
MOV RDI,RBX
CALL 0x0012a220
LAB_00138225:
CMP word ptr [R12 + 0x620],0x0
JZ 0x00138271
LAB_00138231:
MOV RDI,qword ptr [R12 + 0x930]
TEST RDI,RDI
JNZ 0x0013835a
LAB_00138242:
MOV RDI,RBX
CALL 0x0012a1e0
XOR EAX,EAX
LAB_0013824c:
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013825b:
LEA RSI,[0x1e1058]
MOV RDI,RBX
MOV EDX,0x206a
CALL 0x00130603
JMP 0x00138225
LAB_00138271:
MOVSXD RAX,dword ptr [R12 + 0x760]
IMUL RCX,RAX,-0x7fff7fff
SHR RCX,0x20
ADD ECX,EAX
MOV EDX,ECX
SHR EDX,0x1f
SAR ECX,0xf
ADD ECX,EDX
MOV EDX,ECX
SHL EDX,0x10
SUB ECX,EDX
ADD EAX,ECX
INC EAX
LAB_0013829b:
CMP EAX,0xffff
JA 0x001382d0
MOV R13D,EAX
MOV RCX,qword ptr [0x00d08098]
LAB_001382ac:
CMP qword ptr [RCX + R13*0x8],0x0
JNZ 0x001382c4
XOR EAX,EAX
CMPXCHG.LOCK qword ptr [RCX + R13*0x8],R12
JZ 0x001382d3
MOV RCX,qword ptr [0x00d08098]
LAB_001382c4:
INC R13
CMP R13D,0x10000
JNZ 0x001382ac
LAB_001382d0:
XOR R13D,R13D
LAB_001382d3:
MOV EAX,0x1
TEST R13W,R13W
JZ 0x0013829b
LEA RAX,[RBP + -0x2a]
MOV word ptr [RAX],R13W
LEA RCX,[RBP + -0x80]
MOV qword ptr [RCX + 0x20],RAX
MOV qword ptr [RCX + 0x28],0x2
MOV RAX,qword ptr [R12 + 0x5e0]
MOV qword ptr [RCX + 0x30],RAX
MOV R8,qword ptr [R12 + 0x5e8]
LEA RAX,[R8 + 0x1]
MOV qword ptr [RCX + 0x38],RAX
ADD R8D,0x3
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x8],XMM0
MOV qword ptr [RSP],RCX
LEA RDI,[RBP + -0x38]
MOV ESI,0x23
MOV RDX,R15
MOV RCX,R14
MOV R9D,0x4
CALL 0x0012ad24
TEST AL,AL
JNZ 0x0013836f
MOV word ptr [R12 + 0x620],R13W
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [R12 + 0x190],RAX
JMP 0x00138231
LAB_0013835a:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00138242
LAB_0013836f:
MOV RDI,qword ptr [R12 + 0x930]
TEST RDI,RDI
JNZ 0x0013838e
LAB_0013837c:
MOV RDI,RBX
CALL 0x0012a1e0
MOV EAX,0x1
JMP 0x0013824c
LAB_0013838e:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0013837c
|
int8 translog_assign_id_to_share(long *param_1,int8 param_2)
{
long *plVar1;
pthread_mutex_t *__mutex;
long lVar2;
char cVar3;
long lVar4;
short sVar5;
ulong uVar6;
ulong uVar7;
bool bVar8;
int1 local_88 [32];
short *local_68;
int8 local_60;
int8 local_58;
long local_50;
int8 local_40;
short local_32;
lVar2 = *param_1;
__mutex = (pthread_mutex_t *)(lVar2 + 0x8f0);
if (*(long *)(lVar2 + 0x930) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x206a);
}
if (*(short *)(lVar2 + 0x620) == 0) {
uVar6 = (ulong)(*(int *)(lVar2 + 0x760) % 0xffff + 1);
do {
lVar4 = id_to_share;
if ((uint)uVar6 < 0x10000) {
do {
if (*(long *)(lVar4 + uVar6 * 8) == 0) {
plVar1 = (long *)(lVar4 + uVar6 * 8);
LOCK();
bVar8 = *plVar1 == 0;
if (bVar8) {
*plVar1 = lVar2;
}
UNLOCK();
lVar4 = id_to_share;
uVar7 = uVar6;
if (bVar8) goto LAB_001382d3;
}
uVar6 = uVar6 + 1;
} while ((int)uVar6 != 0x10000);
}
uVar7 = 0;
LAB_001382d3:
uVar6 = 1;
sVar5 = (short)uVar7;
} while (sVar5 == 0);
local_68 = &local_32;
local_60 = 2;
local_58 = *(int8 *)(lVar2 + 0x5e0);
local_50 = *(long *)(lVar2 + 0x5e8) + 1;
local_32 = sVar5;
cVar3 = translog_write_record
(&local_40,0x23,param_2,param_1,(int)*(long *)(lVar2 + 0x5e8) + 3,4,local_88,0
,0);
if (cVar3 != '\0') {
if (*(long *)(lVar2 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return 1;
}
*(short *)(lVar2 + 0x620) = sVar5;
*(int8 *)(lVar2 + 400) = local_40;
}
if (*(long *)(lVar2 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return 0;
}
| |
22,571 | mysql_list_dbs_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_list_dbs_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_list_dbs,
(parms->mysql, parms->wild),
parms->mysql,
MYSQL_RES *,
r_ptr)
} | O0 | c | mysql_list_dbs_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3a780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
| mysql_list_dbs_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax+8]
call mysql_list_dbs
mov [rbp+var_18], rax
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| long long mysql_list_dbs_start_internal(long long a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
*(_QWORD *)(v2 + 8) = mysql_list_dbs(*(_QWORD *)a1, *(const char **)(a1 + 8));
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_list_dbs_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x0013a780
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_list_dbs_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_list_dbs(*param_1,param_1[1]);
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
22,572 | my_write | eloqsql/mysys/my_write.c | size_t my_write(File Filedes, const uchar *Buffer, size_t Count, myf MyFlags)
{
size_t writtenbytes, written;
uint errors;
DBUG_ENTER("my_write");
DBUG_PRINT("my",("fd: %d Buffer: %p Count: %lu MyFlags: %lu",
Filedes, Buffer, (ulong) Count, MyFlags));
errors= 0; written= 0;
if (!(MyFlags & (MY_WME | MY_FAE | MY_FNABP)))
MyFlags|= my_global_flags;
/* The behavior of write(fd, buf, 0) is not portable */
if (unlikely(!Count))
DBUG_RETURN(0);
for (;;)
{
#ifdef _WIN32
if(Filedes < 0)
{
my_errno= errno= EBADF;
DBUG_RETURN((size_t)-1);
}
writtenbytes= my_win_write(Filedes, Buffer, Count);
#else
writtenbytes= write(Filedes, Buffer, Count);
#endif
/**
To simulate the write error set the errno = error code
and the number pf written bytes to -1.
*/
DBUG_EXECUTE_IF ("simulate_file_write_error",
if (!errors) {
errno= ENOSPC;
writtenbytes= (size_t) -1;
});
if (writtenbytes == Count)
break;
if (writtenbytes != (size_t) -1)
{ /* Safeguard */
written+= writtenbytes;
Buffer+= writtenbytes;
Count-= writtenbytes;
}
my_errno= errno;
DBUG_PRINT("error",("Write only %ld bytes, error: %d",
(long) writtenbytes, my_errno));
#ifndef NO_BACKGROUND
if (my_thread_var->abort)
MyFlags&= ~ MY_WAIT_IF_FULL; /* End if aborted by user */
if ((my_errno == ENOSPC || my_errno == EDQUOT) &&
(MyFlags & MY_WAIT_IF_FULL))
{
wait_for_free_space(my_filename(Filedes), errors);
errors++;
continue;
}
if ((writtenbytes == 0 || writtenbytes == (size_t) -1))
{
if (my_errno == EINTR)
{
DBUG_PRINT("debug", ("my_write() was interrupted and returned %ld",
(long) writtenbytes));
continue; /* Interrupted */
}
if (!writtenbytes && !errors++) /* Retry once */
{
/* We may come here if the file quota is exeeded */
errno= EFBIG; /* Assume this is the error */
continue;
}
}
else
continue; /* Retry */
#endif
/* Don't give a warning if it's ok that we only write part of the data */
if (MyFlags & (MY_NABP | MY_FNABP))
{
if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
{
my_error(EE_WRITE, MYF(ME_BELL | (MyFlags & (ME_NOTE | ME_ERROR_LOG))),
my_filename(Filedes),my_errno);
}
DBUG_RETURN(MY_FILE_ERROR); /* Error on read */
}
break; /* Return bytes written */
}
if (MyFlags & (MY_NABP | MY_FNABP))
DBUG_RETURN(0); /* Want only errors */
DBUG_RETURN(writtenbytes+written);
} | O0 | c | my_write:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0xf6d39
movl $0x0, -0x3c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
andq $0x1a, %rax
cmpq $0x0, %rax
jne 0xf6d68
leaq 0xb8bd2b(%rip), %rax # 0xc82a88
movq (%rax), %rax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xf6d99
jmp 0xf6d8c
movq $0x0, -0x8(%rbp)
jmp 0xf6f43
jmp 0xf6d9b
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a780
movq %rax, -0x30(%rbp)
jmp 0xf6db1
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xf6dc0
jmp 0xf6f1b
cmpq $-0x1, -0x30(%rbp)
je 0xf6dee
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
callq 0x2a740
movl (%rax), %eax
movl %eax, -0x40(%rbp)
callq 0xf6080
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
jmp 0xf6e04
callq 0xf6080
movl 0xe0(%rax), %eax
cmpl $0x0, %eax
je 0xf6e26
movabsq $0xffffffdf, %rax # imm = 0xFFFFFFDF
andq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xf6080
cmpl $0x1c, (%rax)
je 0xf6e3a
callq 0xf6080
cmpl $0x7a, (%rax)
jne 0xf6e69
movq -0x28(%rbp), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0xf6e69
movl -0xc(%rbp), %edi
callq 0x1034d0
movq %rax, %rdi
movl -0x3c(%rbp), %esi
callq 0x102c20
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xf6d9b
cmpq $0x0, -0x30(%rbp)
je 0xf6e77
cmpq $-0x1, -0x30(%rbp)
jne 0xf6eb3
callq 0xf6080
cmpl $0x4, (%rax)
jne 0xf6e8a
jmp 0xf6e83
jmp 0xf6e85
jmp 0xf6d9b
cmpq $0x0, -0x30(%rbp)
jne 0xf6eb1
movl -0x3c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x3c(%rbp)
cmpl $0x0, %eax
jne 0xf6eb1
callq 0x2a740
movl $0x1b, (%rax)
jmp 0xf6d9b
jmp 0xf6eb8
jmp 0xf6d9b
movq -0x28(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xf6f19
movq -0x28(%rbp), %rax
andq $0x1a, %rax
cmpq $0x0, %rax
je 0xf6f0d
movq -0x28(%rbp), %rax
andq $0x440, %rax # imm = 0x440
orq $0x4, %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %edi
callq 0x1034d0
movq %rax, -0x48(%rbp)
callq 0xf6080
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movl (%rax), %ecx
movl $0x3, %edi
movb $0x0, %al
callq 0xef8b0
jmp 0xf6f0f
movq $-0x1, -0x8(%rbp)
jmp 0xf6f43
jmp 0xf6f1b
movq -0x28(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xf6f35
jmp 0xf6f2b
movq $0x0, -0x8(%rbp)
jmp 0xf6f43
jmp 0xf6f37
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| my_write:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
jmp short $+2
loc_F6D39:
mov [rbp+var_3C], 0
mov [rbp+var_38], 0
mov rax, [rbp+var_28]
and rax, 1Ah
cmp rax, 0
jnz short loc_F6D68
lea rax, my_global_flags
mov rax, [rax]
or rax, [rbp+var_28]
mov [rbp+var_28], rax
loc_F6D68:
cmp [rbp+var_20], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_F6D99
jmp short $+2
loc_F6D8C:
mov [rbp+var_8], 0
jmp loc_F6F43
loc_F6D99:
jmp short $+2
loc_F6D9B:
mov edi, [rbp+var_C]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _write
mov [rbp+var_30], rax
jmp short $+2
loc_F6DB1:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_20]
jnz short loc_F6DC0
jmp loc_F6F1B
loc_F6DC0:
cmp [rbp+var_30], 0FFFFFFFFFFFFFFFFh
jz short loc_F6DEE
mov rax, [rbp+var_30]
add rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rcx, [rbp+var_30]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
loc_F6DEE:
call ___errno_location
mov eax, [rax]
mov [rbp+var_40], eax
call _my_thread_var
mov ecx, [rbp+var_40]
mov [rax], ecx
jmp short $+2
loc_F6E04:
call _my_thread_var
mov eax, [rax+0E0h]
cmp eax, 0
jz short loc_F6E26
mov rax, 0FFFFFFDFh
and rax, [rbp+var_28]
mov [rbp+var_28], rax
loc_F6E26:
call _my_thread_var
cmp dword ptr [rax], 1Ch
jz short loc_F6E3A
call _my_thread_var
cmp dword ptr [rax], 7Ah ; 'z'
jnz short loc_F6E69
loc_F6E3A:
mov rax, [rbp+var_28]
and rax, 20h
cmp rax, 0
jz short loc_F6E69
mov edi, [rbp+var_C]
call my_filename
mov rdi, rax
mov esi, [rbp+var_3C]
call wait_for_free_space
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
jmp loc_F6D9B
loc_F6E69:
cmp [rbp+var_30], 0
jz short loc_F6E77
cmp [rbp+var_30], 0FFFFFFFFFFFFFFFFh
jnz short loc_F6EB3
loc_F6E77:
call _my_thread_var
cmp dword ptr [rax], 4
jnz short loc_F6E8A
jmp short $+2
loc_F6E83:
jmp short $+2
loc_F6E85:
jmp loc_F6D9B
loc_F6E8A:
cmp [rbp+var_30], 0
jnz short loc_F6EB1
mov eax, [rbp+var_3C]
mov ecx, eax
add ecx, 1
mov [rbp+var_3C], ecx
cmp eax, 0
jnz short loc_F6EB1
call ___errno_location
mov dword ptr [rax], 1Bh
jmp loc_F6D9B
loc_F6EB1:
jmp short loc_F6EB8
loc_F6EB3:
jmp loc_F6D9B
loc_F6EB8:
mov rax, [rbp+var_28]
and rax, 6
cmp rax, 0
jz short loc_F6F19
mov rax, [rbp+var_28]
and rax, 1Ah
cmp rax, 0
jz short loc_F6F0D
mov rax, [rbp+var_28]
and rax, 440h
or rax, 4
mov [rbp+var_50], rax
mov edi, [rbp+var_C]
call my_filename
mov [rbp+var_48], rax
call _my_thread_var
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_48]
mov ecx, [rax]
mov edi, 3
mov al, 0
call my_error
loc_F6F0D:
jmp short $+2
loc_F6F0F:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_F6F43
loc_F6F19:
jmp short $+2
loc_F6F1B:
mov rax, [rbp+var_28]
and rax, 6
cmp rax, 0
jz short loc_F6F35
jmp short $+2
loc_F6F2B:
mov [rbp+var_8], 0
jmp short loc_F6F43
loc_F6F35:
jmp short $+2
loc_F6F37:
mov rax, [rbp+var_30]
add rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_F6F43:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long my_write(unsigned int a1, const char *a2, long long a3, __int16 a4)
{
const char *v4; // rsi
long long v5; // rax
unsigned int *v7; // rax
long long v9; // [rsp+8h] [rbp-48h]
int v10; // [rsp+10h] [rbp-40h]
unsigned int v11; // [rsp+14h] [rbp-3Ch]
long long v12; // [rsp+18h] [rbp-38h]
long long v13; // [rsp+20h] [rbp-30h]
__int16 v14; // [rsp+28h] [rbp-28h]
long long v15; // [rsp+30h] [rbp-20h]
v15 = a3;
v14 = a4;
v11 = 0;
v12 = 0LL;
if ( (a4 & 0x1A) == 0 )
v14 = a4 | my_global_flags;
if ( !a3 )
return 0LL;
while ( 1 )
{
do
{
while ( 1 )
{
v4 = a2;
v13 = write(a1, a2, v15);
if ( v13 == v15 )
goto LABEL_26;
if ( v13 != -1 )
{
v12 += v13;
a2 += v13;
v15 -= v13;
}
v10 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a1, v4) = v10;
if ( *(_DWORD *)(my_thread_var(a1, v4) + 224) )
v14 &= ~0x20u;
if ( *(_DWORD *)my_thread_var(a1, v4) != 28 && *(_DWORD *)my_thread_var(a1, v4) != 122 || (v14 & 0x20) == 0 )
break;
v5 = my_filename(a1);
wait_for_free_space(v5, v11++);
}
}
while ( v13 && v13 != -1 || *(_DWORD *)my_thread_var(a1, v4) == 4 );
if ( v13 )
break;
if ( v11++ )
break;
*(_DWORD *)__errno_location() = 27;
}
if ( (v14 & 6) == 0 )
{
LABEL_26:
if ( (v14 & 6) != 0 )
return 0LL;
else
return v12 + v13;
}
if ( (v14 & 0x1A) != 0 )
{
v9 = my_filename(a1);
v7 = (unsigned int *)my_thread_var(a1, v4);
my_error(3u, v14 & 0x440 | 4LL, v9, *v7);
}
return -1LL;
}
| my_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
JMP 0x001f6d39
LAB_001f6d39:
MOV dword ptr [RBP + -0x3c],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x1a
CMP RAX,0x0
JNZ 0x001f6d68
LEA RAX,[0xd82a88]
MOV RAX,qword ptr [RAX]
OR RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
LAB_001f6d68:
CMP qword ptr [RBP + -0x20],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001f6d99
JMP 0x001f6d8c
LAB_001f6d8c:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001f6f43
LAB_001f6d99:
JMP 0x001f6d9b
LAB_001f6d9b:
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a780
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001f6db1
LAB_001f6db1:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001f6dc0
JMP 0x001f6f1b
LAB_001f6dc0:
CMP qword ptr [RBP + -0x30],-0x1
JZ 0x001f6dee
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_001f6dee:
CALL 0x0012a740
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x40],EAX
CALL 0x001f6080
MOV ECX,dword ptr [RBP + -0x40]
MOV dword ptr [RAX],ECX
JMP 0x001f6e04
LAB_001f6e04:
CALL 0x001f6080
MOV EAX,dword ptr [RAX + 0xe0]
CMP EAX,0x0
JZ 0x001f6e26
MOV RAX,0xffffffdf
AND RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
LAB_001f6e26:
CALL 0x001f6080
CMP dword ptr [RAX],0x1c
JZ 0x001f6e3a
CALL 0x001f6080
CMP dword ptr [RAX],0x7a
JNZ 0x001f6e69
LAB_001f6e3a:
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x20
CMP RAX,0x0
JZ 0x001f6e69
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x002034d0
MOV RDI,RAX
MOV ESI,dword ptr [RBP + -0x3c]
CALL 0x00202c20
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001f6d9b
LAB_001f6e69:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x001f6e77
CMP qword ptr [RBP + -0x30],-0x1
JNZ 0x001f6eb3
LAB_001f6e77:
CALL 0x001f6080
CMP dword ptr [RAX],0x4
JNZ 0x001f6e8a
JMP 0x001f6e83
LAB_001f6e83:
JMP 0x001f6e85
LAB_001f6e85:
JMP 0x001f6d9b
LAB_001f6e8a:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001f6eb1
MOV EAX,dword ptr [RBP + -0x3c]
MOV ECX,EAX
ADD ECX,0x1
MOV dword ptr [RBP + -0x3c],ECX
CMP EAX,0x0
JNZ 0x001f6eb1
CALL 0x0012a740
MOV dword ptr [RAX],0x1b
JMP 0x001f6d9b
LAB_001f6eb1:
JMP 0x001f6eb8
LAB_001f6eb3:
JMP 0x001f6d9b
LAB_001f6eb8:
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001f6f19
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x1a
CMP RAX,0x0
JZ 0x001f6f0d
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x440
OR RAX,0x4
MOV qword ptr [RBP + -0x50],RAX
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x002034d0
MOV qword ptr [RBP + -0x48],RAX
CALL 0x001f6080
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RAX]
MOV EDI,0x3
MOV AL,0x0
CALL 0x001ef8b0
LAB_001f6f0d:
JMP 0x001f6f0f
LAB_001f6f0f:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x001f6f43
LAB_001f6f19:
JMP 0x001f6f1b
LAB_001f6f1b:
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001f6f35
JMP 0x001f6f2b
LAB_001f6f2b:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001f6f43
LAB_001f6f35:
JMP 0x001f6f37
LAB_001f6f37:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f6f43:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long my_write(int param_1,void *param_2,size_t param_3,ulong param_4)
{
int iVar1;
size_t sVar2;
int *piVar3;
long lVar4;
int8 uVar5;
int4 *puVar6;
int local_44;
long local_40;
ulong local_30;
size_t local_28;
void *local_20;
long local_10;
local_44 = 0;
local_40 = 0;
local_30 = param_4;
if ((param_4 & 0x1a) == 0) {
local_30 = my_global_flags | param_4;
}
local_28 = param_3;
local_20 = param_2;
if (param_3 == 0) {
local_10 = 0;
}
else {
while (sVar2 = write(param_1,local_20,local_28), sVar2 != local_28) {
if (sVar2 != 0xffffffffffffffff) {
local_40 = sVar2 + local_40;
local_20 = (void *)(sVar2 + (long)local_20);
local_28 = local_28 - sVar2;
}
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
lVar4 = _my_thread_var();
if (*(int *)(lVar4 + 0xe0) != 0) {
local_30 = local_30 & 0xffffffdf;
}
piVar3 = (int *)_my_thread_var();
if (((*piVar3 == 0x1c) || (piVar3 = (int *)_my_thread_var(), *piVar3 == 0x7a)) &&
((local_30 & 0x20) != 0)) {
uVar5 = my_filename(param_1);
wait_for_free_space(uVar5,local_44);
local_44 = local_44 + 1;
}
else if (((sVar2 == 0) || (sVar2 == 0xffffffffffffffff)) &&
(piVar3 = (int *)_my_thread_var(), *piVar3 != 4)) {
if ((sVar2 != 0) || (local_44 != 0)) {
if ((local_30 & 6) != 0) {
if ((local_30 & 0x1a) != 0) {
uVar5 = my_filename(param_1);
puVar6 = (int4 *)_my_thread_var();
my_error(3,local_30 & 0x440 | 4,uVar5,*puVar6);
}
return -1;
}
break;
}
piVar3 = __errno_location();
*piVar3 = 0x1b;
local_44 = local_44 + 1;
}
}
if ((local_30 & 6) == 0) {
local_10 = sVar2 + local_40;
}
else {
local_10 = 0;
}
}
return local_10;
}
| |
22,573 | my_stat | eloqsql/mysys/my_lib.c | MY_STAT *my_stat(const char *path, MY_STAT *stat_area, myf my_flags)
{
int m_used;
DBUG_ENTER("my_stat");
DBUG_PRINT("my", ("path: '%s' stat_area: %p MyFlags: %lu", path,
stat_area, my_flags));
if ((m_used= (stat_area == NULL)))
if (!(stat_area= (MY_STAT *) my_malloc(key_memory_MY_STAT, sizeof(MY_STAT),
my_flags)))
goto error;
#ifndef _WIN32
if (!stat((char *) path, (struct stat *) stat_area))
{
MSAN_STAT_WORKAROUND(stat_area);
DBUG_RETURN(stat_area);
}
#else
if (!my_win_stat(path, stat_area))
DBUG_RETURN(stat_area);
#endif
DBUG_PRINT("error",("Got errno: %d from stat", errno));
my_errno= errno;
if (m_used) /* Free if new area */
my_free(stat_area);
error:
if (my_flags & (MY_FAE+MY_WME))
{
my_error(EE_STAT, MYF(ME_BELL), path, my_errno);
DBUG_RETURN((MY_STAT *) NULL);
}
DBUG_RETURN((MY_STAT *) NULL);
} | O0 | c | my_stat:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0xf9b86
cmpq $0x0, -0x18(%rbp)
sete %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x24(%rbp)
testb $0x1, %al
jne 0xf9b9f
jmp 0xf9bc4
leaq 0xb94812(%rip), %rax # 0xc8e3b8
movl (%rax), %edi
movq -0x20(%rbp), %rdx
movl $0x90, %esi
callq 0xf9ff0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xf9bc2
jmp 0xf9c0b
jmp 0xf9bc4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a7e0
cmpl $0x0, %eax
jne 0xf9be2
jmp 0xf9bd8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf9c51
jmp 0xf9be4
jmp 0xf9be6
callq 0x2a770
movl (%rax), %eax
movl %eax, -0x28(%rbp)
callq 0xfc990
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x24(%rbp)
je 0xf9c09
movq -0x18(%rbp), %rdi
callq 0xfa370
jmp 0xf9c0b
movq -0x20(%rbp), %rax
andq $0x18, %rax
cmpq $0x0, %rax
je 0xf9c47
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xfc990
movq -0x30(%rbp), %rdx
movl (%rax), %ecx
movl $0xd, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0xf2ae0
movq $0x0, -0x8(%rbp)
jmp 0xf9c51
jmp 0xf9c49
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_stat:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
jmp short $+2
loc_F9B86:
cmp [rbp+var_18], 0
setz al
mov cl, al
and cl, 1
movzx ecx, cl
mov [rbp+var_24], ecx
test al, 1
jnz short loc_F9B9F
jmp short loc_F9BC4
loc_F9B9F:
lea rax, key_memory_MY_STAT
mov edi, [rax]
mov rdx, [rbp+var_20]
mov esi, 90h
call my_malloc
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_F9BC2
jmp short loc_F9C0B
loc_F9BC2:
jmp short $+2
loc_F9BC4:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _stat64
cmp eax, 0
jnz short loc_F9BE2
jmp short $+2
loc_F9BD8:
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
jmp short loc_F9C51
loc_F9BE2:
jmp short $+2
loc_F9BE4:
jmp short $+2
loc_F9BE6:
call ___errno_location
mov eax, [rax]
mov [rbp+var_28], eax
call _my_thread_var
mov ecx, [rbp+var_28]
mov [rax], ecx
cmp [rbp+var_24], 0
jz short loc_F9C09
mov rdi, [rbp+var_18]
call my_free
loc_F9C09:
jmp short $+2
loc_F9C0B:
mov rax, [rbp+var_20]
and rax, 18h
cmp rax, 0
jz short loc_F9C47
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
call _my_thread_var
mov rdx, [rbp+var_30]
mov ecx, [rax]
mov edi, 0Dh
mov esi, 4
mov al, 0
call my_error
mov [rbp+var_8], 0
jmp short loc_F9C51
loc_F9C47:
jmp short $+2
loc_F9C49:
mov [rbp+var_8], 0
loc_F9C51:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| const char * my_stat(const char *a1, const char *a2, long long a3)
{
const char *v3; // rdi
const char *v4; // rsi
unsigned int *v5; // rax
int v7; // [rsp+8h] [rbp-28h]
BOOL v8; // [rsp+Ch] [rbp-24h]
char v9; // [rsp+10h] [rbp-20h]
const char *v10; // [rsp+18h] [rbp-18h]
v10 = a2;
v9 = a3;
v8 = a2 == 0LL;
if ( a2
|| (v3 = (const char *)key_memory_MY_STAT,
v4 = (const char *)&qword_90,
(v10 = (const char *)my_malloc(key_memory_MY_STAT, 144LL, a3)) != 0LL) )
{
v3 = a1;
v4 = v10;
if ( !(unsigned int)stat64(a1, v10) )
return v10;
v7 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a1, v10) = v7;
if ( v8 )
{
v3 = v10;
my_free(v10);
}
}
if ( (v9 & 0x18) != 0 )
{
v5 = (unsigned int *)my_thread_var(v3, v4);
my_error(0xDu, 4LL, a1, *v5);
}
return 0LL;
}
| my_stat:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
JMP 0x001f9b86
LAB_001f9b86:
CMP qword ptr [RBP + -0x18],0x0
SETZ AL
MOV CL,AL
AND CL,0x1
MOVZX ECX,CL
MOV dword ptr [RBP + -0x24],ECX
TEST AL,0x1
JNZ 0x001f9b9f
JMP 0x001f9bc4
LAB_001f9b9f:
LEA RAX,[0xd8e3b8]
MOV EDI,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x20]
MOV ESI,0x90
CALL 0x001f9ff0
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x001f9bc2
JMP 0x001f9c0b
LAB_001f9bc2:
JMP 0x001f9bc4
LAB_001f9bc4:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a7e0
CMP EAX,0x0
JNZ 0x001f9be2
JMP 0x001f9bd8
LAB_001f9bd8:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001f9c51
LAB_001f9be2:
JMP 0x001f9be4
LAB_001f9be4:
JMP 0x001f9be6
LAB_001f9be6:
CALL 0x0012a770
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x28],EAX
CALL 0x001fc990
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
CMP dword ptr [RBP + -0x24],0x0
JZ 0x001f9c09
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001fa370
LAB_001f9c09:
JMP 0x001f9c0b
LAB_001f9c0b:
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x18
CMP RAX,0x0
JZ 0x001f9c47
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x001fc990
MOV RDX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
MOV EDI,0xd
MOV ESI,0x4
MOV AL,0x0
CALL 0x001f2ae0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001f9c51
LAB_001f9c47:
JMP 0x001f9c49
LAB_001f9c49:
MOV qword ptr [RBP + -0x8],0x0
LAB_001f9c51:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
stat64 * my_stat(char *param_1,stat64 *param_2,ulong param_3)
{
int iVar1;
int *piVar2;
int4 *puVar3;
stat64 *local_20;
local_20 = param_2;
if ((param_2 != (stat64 *)0x0) ||
(local_20 = (stat64 *)my_malloc(key_memory_MY_STAT,0x90,param_3), local_20 != (stat64 *)0x0)) {
iVar1 = stat64(param_1,local_20);
if (iVar1 == 0) {
return local_20;
}
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
if (param_2 == (stat64 *)0x0) {
my_free(local_20);
}
}
if ((param_3 & 0x18) != 0) {
puVar3 = (int4 *)_my_thread_var();
my_error(0xd,4,param_1,*puVar3);
}
return (stat64 *)0x0;
}
| |
22,574 | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const::'lambda'(int)::operator()(int) const | monkey531[P]llama/common/minja.hpp | void dump(std::ostringstream & out, int indent = -1, int level = 0, bool to_json = false) const {
auto print_indent = [&](int level) {
if (indent > 0) {
out << "\n";
for (int i = 0, n = level * indent; i < n; ++i) out << ' ';
}
};
auto print_sub_sep = [&]() {
out << ',';
if (indent < 0) out << ' ';
else print_indent(level + 1);
};
auto string_quote = to_json ? '"' : '\'';
if (is_null()) out << "null";
else if (array_) {
out << "[";
print_indent(level + 1);
for (size_t i = 0; i < array_->size(); ++i) {
if (i) print_sub_sep();
(*array_)[i].dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "]";
} else if (object_) {
out << "{";
print_indent(level + 1);
for (auto begin = object_->begin(), it = begin; it != object_->end(); ++it) {
if (it != begin) print_sub_sep();
if (it->first.is_string()) {
dump_string(it->first, out, string_quote);
} else {
out << string_quote << it->first.dump() << string_quote;
}
out << ": ";
it->second.dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "}";
} else if (callable_) {
throw std::runtime_error("Cannot dump callable to JSON");
} else if (is_boolean() && !to_json) {
out << (this->to_bool() ? "True" : "False");
} else if (is_string() && !to_json) {
dump_string(primitive_, out, string_quote);
} else {
out << primitive_.dump();
}
} | O0 | cpp | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const::'lambda'(int)::operator()(int) const:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
cmpl $0x0, (%rax)
jle 0xae4bb
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x11235b(%rip), %rsi # 0x1c07ca
callq 0x528b0
movq 0x8(%rsp), %rcx
movl $0x0, 0x18(%rsp)
movl 0x1c(%rsp), %eax
movq (%rcx), %rcx
imull (%rcx), %eax
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xae4b9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x20, %esi
callq 0x529d0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xae48f
jmp 0xae4bb
addq $0x28, %rsp
retq
| _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_C], esi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_20], rax
mov rax, [rax]
cmp dword ptr [rax], 0
jle short loc_AE4BB
mov rax, [rsp+28h+var_20]
mov rdi, [rax+8]
lea rsi, asc_1C075E+6Ch; "\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rcx, [rsp+28h+var_20]
mov [rsp+28h+var_10], 0
mov eax, [rsp+28h+var_C]
mov rcx, [rcx]
imul eax, [rcx]
mov [rsp+28h+var_14], eax
loc_AE48F:
mov eax, [rsp+28h+var_10]
cmp eax, [rsp+28h+var_14]
jge short loc_AE4B9
mov rax, [rsp+28h+var_20]
mov rdi, [rax+8]
mov esi, 20h ; ' '
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
mov eax, [rsp+28h+var_10]
add eax, 1
mov [rsp+28h+var_10], eax
jmp short loc_AE48F
loc_AE4B9:
jmp short $+2
loc_AE4BB:
add rsp, 28h
retn
| int * minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(
int **a1,
int a2)
{
int *result; // rax
int v3; // [rsp+14h] [rbp-14h]
int v4; // [rsp+18h] [rbp-10h]
result = *a1;
if ( **a1 > 0 )
{
std::operator<<<std::char_traits<char>>(a1[1], "\n");
v4 = 0;
v3 = **a1 * a2;
while ( 1 )
{
result = (int *)(unsigned int)v4;
if ( v4 >= v3 )
break;
std::operator<<<std::char_traits<char>>(a1[1], 32LL);
++v4;
}
}
return result;
}
| operator():
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ESI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX],0x0
JLE 0x001ae4bb
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[0x2c07ca]
CALL 0x001528b0
MOV RCX,qword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x18],0x0
MOV EAX,dword ptr [RSP + 0x1c]
MOV RCX,qword ptr [RCX]
IMUL EAX,dword ptr [RCX]
MOV dword ptr [RSP + 0x14],EAX
LAB_001ae48f:
MOV EAX,dword ptr [RSP + 0x18]
CMP EAX,dword ptr [RSP + 0x14]
JGE 0x001ae4b9
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x8]
MOV ESI,0x20
CALL 0x001529d0
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,0x1
MOV dword ptr [RSP + 0x18],EAX
JMP 0x001ae48f
LAB_001ae4b9:
JMP 0x001ae4bb
LAB_001ae4bb:
ADD RSP,0x28
RET
|
/* minja::Value::dump(std::__cxx11::ostringstream&, int, int, bool)
const::{lambda(int)#1}::TEMPNAMEPLACEHOLDERVALUE(int) const */
_func_dump_ostringstream_ptr_int_int_bool * __thiscall
const::{lambda(int)#1}::operator()(_lambda_int__1_ *this,int param_1)
{
int iVar1;
_func_dump_ostringstream_ptr_int_int_bool *p_Var2;
uint local_10;
p_Var2 = *(_func_dump_ostringstream_ptr_int_int_bool **)this;
if (0 < *(int *)p_Var2) {
std::operator<<(*(ostream **)(this + 8),"\n");
local_10 = 0;
iVar1 = **(int **)this;
for (; p_Var2 = (_func_dump_ostringstream_ptr_int_int_bool *)(ulong)local_10,
(int)local_10 < param_1 * iVar1; local_10 = local_10 + 1) {
std::operator<<(*(ostream **)(this + 8),' ');
}
}
return p_Var2;
}
| |
22,575 | ft_parse | eloqsql/storage/myisam/ft_parser.c | int ft_parse(TREE *wtree, uchar *doc, int doclen,
struct st_mysql_ftparser *parser,
MYSQL_FTPARSER_PARAM *param, MEM_ROOT *mem_root)
{
MY_FT_PARSER_PARAM my_param;
DBUG_ENTER("ft_parse");
DBUG_ASSERT(parser);
my_param.wtree= wtree;
my_param.mem_root= mem_root;
param->mysql_parse= ft_parse_internal;
param->mysql_add_word= ft_add_word;
param->mysql_ftparam= &my_param;
param->cs= wtree->custom_arg;
param->doc= (char*) doc;
param->length= doclen;
param->mode= MYSQL_FTPARSER_SIMPLE_MODE;
DBUG_RETURN(parser->parse(param));
} | O0 | c | ft_parse:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0xa2341
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
leaq 0x74(%rip), %rcx # 0xa23d0
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
leaq 0x116(%rip), %rcx # 0xa2480
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
leaq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x230(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| ft_parse:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
jmp short $+2
loc_A2341:
mov rax, [rbp+var_8]
mov [rbp+var_40], rax
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
lea rcx, ft_parse_internal
mov [rax], rcx
mov rax, [rbp+var_28]
lea rcx, ft_add_word
mov [rax+8], rcx
mov rax, [rbp+var_28]
lea rcx, [rbp+var_40]
mov [rax+18h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+230h]
mov rax, [rbp+var_28]
mov [rax+20h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_28]
mov [rax+28h], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_28]
mov [rax+30h], ecx
mov rax, [rbp+var_28]
mov dword ptr [rax+38h], 0
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rdi, [rbp+var_28]
call rax
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
| long long ft_parse(long long a1, long long a2, int a3, long long a4, _QWORD *a5, long long a6)
{
_QWORD v7[3]; // [rsp+10h] [rbp-40h] BYREF
_QWORD *v8; // [rsp+28h] [rbp-28h]
long long v9; // [rsp+30h] [rbp-20h]
int v10; // [rsp+3Ch] [rbp-14h]
long long v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v8 = a5;
v7[2] = a6;
v7[0] = a1;
v7[1] = a6;
*a5 = ft_parse_internal;
v8[1] = ft_add_word;
v8[3] = v7;
v8[4] = *(_QWORD *)(v12 + 560);
v8[5] = v11;
*((_DWORD *)v8 + 12) = v10;
*((_DWORD *)v8 + 14) = 0;
return (*(unsigned int ( **)(_QWORD *))(v9 + 8))(v8);
}
| ft_parse:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
JMP 0x001a2341
LAB_001a2341:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[0x1a23d0]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[0x1a2480]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RBP + -0x40]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x230]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x28],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x30],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x38],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x28]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
|
int4
ft_parse(long param_1,int8 param_2,int4 param_3,long param_4,int8 *param_5,
int8 param_6)
{
int4 uVar1;
long local_48;
int8 local_40;
int8 local_38;
int8 *local_30;
long local_28;
int4 local_1c;
int8 local_18;
long local_10;
*param_5 = ft_parse_internal;
param_5[1] = ft_add_word;
param_5[3] = &local_48;
param_5[4] = *(int8 *)(param_1 + 0x230);
param_5[5] = param_2;
*(int4 *)(param_5 + 6) = param_3;
*(int4 *)(param_5 + 7) = 0;
local_48 = param_1;
local_40 = param_6;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
uVar1 = (**(code **)(param_4 + 8))(param_5);
return uVar1;
}
| |
22,576 | OpenSubdiv::v3_6_0::Far::TopologyRefiner::updateInventory(OpenSubdiv::v3_6_0::Vtr::internal::Level const&) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/../far/../vtr/level.h | int getNumVertices() const { return _vertCount; } | O2 | c | OpenSubdiv::v3_6_0::Far::TopologyRefiner::updateInventory(OpenSubdiv::v3_6_0::Vtr::internal::Level const&):
movdqu 0x8(%rsi), %xmm0
movq (%rsi), %xmm1
movq 0x38(%rsi), %rax
subq 0x30(%rsi), %rax
shrq $0x2, %rax
movdqu 0x14(%rdi), %xmm2
movd %eax, %xmm3
punpcklqdq %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
punpckldq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
shufps $0x29, %xmm3, %xmm1 # xmm1 = xmm1[1,2],xmm3[2,0]
paddd %xmm2, %xmm1
movdqu %xmm1, 0x14(%rdi)
movl 0x14(%rsi), %eax
movl 0x24(%rdi), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
movl %eax, 0x24(%rdi)
retq
| _ZN10OpenSubdiv6v3_6_03Far15TopologyRefiner15updateInventoryERKNS0_3Vtr8internal5LevelE:
movdqu xmm0, xmmword ptr [rsi+8]
movq xmm1, qword ptr [rsi]
mov rax, [rsi+38h]
sub rax, [rsi+30h]
shr rax, 2
movdqu xmm2, xmmword ptr [rdi+14h]
movd xmm3, eax
punpcklqdq xmm3, xmm1
punpckldq xmm1, xmm0
shufps xmm1, xmm3, 29h ; ')'
paddd xmm1, xmm2
movdqu xmmword ptr [rdi+14h], xmm1
mov eax, [rsi+14h]
mov ecx, [rdi+24h]
cmp ecx, eax
cmovg eax, ecx
mov [rdi+24h], eax
retn
| long long OpenSubdiv::v3_6_0::Far::TopologyRefiner::updateInventory(
OpenSubdiv::v3_6_0::Far::TopologyRefiner *this,
const OpenSubdiv::v3_6_0::Vtr::internal::Level *a2)
{
__m128i v2; // xmm1
long long result; // rax
int v4; // ecx
v2 = _mm_loadl_epi64((const __m128i *)a2);
*(__m128i *)((char *)this + 20) = _mm_add_epi32(
(__m128i)_mm_shuffle_ps(
(__m128)_mm_unpacklo_epi32(
v2,
_mm_loadu_si128((const __m128i *)((char *)a2 + 8))),
(__m128)_mm_unpacklo_epi64(
_mm_cvtsi32_si128((*((_QWORD *)a2 + 7) - *((_QWORD *)a2 + 6)) >> 2),
v2),
41),
_mm_loadu_si128((const __m128i *)((char *)this + 20)));
result = *((unsigned int *)a2 + 5);
v4 = *((_DWORD *)this + 9);
if ( v4 > (int)result )
result = (unsigned int)v4;
*((_DWORD *)this + 9) = result;
return result;
}
| updateInventory:
MOVDQU XMM0,xmmword ptr [RSI + 0x8]
MOVQ XMM1,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x38]
SUB RAX,qword ptr [RSI + 0x30]
SHR RAX,0x2
MOVDQU XMM2,xmmword ptr [RDI + 0x14]
MOVD XMM3,EAX
PUNPCKLQDQ XMM3,XMM1
PUNPCKLDQ XMM1,XMM0
SHUFPS XMM1,XMM3,0x29
PADDD XMM1,XMM2
MOVDQU xmmword ptr [RDI + 0x14],XMM1
MOV EAX,dword ptr [RSI + 0x14]
MOV ECX,dword ptr [RDI + 0x24]
CMP ECX,EAX
CMOVG EAX,ECX
MOV dword ptr [RDI + 0x24],EAX
RET
|
/* OpenSubdiv::v3_6_0::Far::TopologyRefiner::updateInventory(OpenSubdiv::v3_6_0::Vtr::internal::Level
const&) */
void __thiscall
OpenSubdiv::v3_6_0::Far::TopologyRefiner::updateInventory(TopologyRefiner *this,Level *param_1)
{
int8 uVar1;
long lVar2;
long lVar3;
int iVar4;
uVar1 = *(int8 *)param_1;
lVar2 = *(long *)(param_1 + 0x38);
lVar3 = *(long *)(param_1 + 0x30);
*(int *)(this + 0x14) = *(int *)(param_1 + 8) + *(int *)(this + 0x14);
*(int *)(this + 0x18) = (int)((ulong)uVar1 >> 0x20) + *(int *)(this + 0x18);
*(int *)(this + 0x1c) = (int)uVar1 + *(int *)(this + 0x1c);
*(int *)(this + 0x20) = (int)((ulong)(lVar2 - lVar3) >> 2) + *(int *)(this + 0x20);
iVar4 = *(int *)(param_1 + 0x14);
if (*(int *)(param_1 + 0x14) < *(int *)(this + 0x24)) {
iVar4 = *(int *)(this + 0x24);
}
*(int *)(this + 0x24) = iVar4;
return;
}
| |
22,577 | get_dynamic | eloqsql/mysys/array.c | void get_dynamic(DYNAMIC_ARRAY *array, void *element, uint idx)
{
if (idx >= array->elements)
{
DBUG_PRINT("warning",("To big array idx: %d, array size is %d",
idx,array->elements));
bzero(element,array->size_of_element);
return;
}
memcpy(element,array->buffer+idx*array->size_of_element,
(size_t) array->size_of_element);
} | O3 | c | get_dynamic:
pushq %rbp
movq %rsp, %rbp
cmpl %edx, 0x8(%rdi)
jbe 0x44bba
movl 0x14(%rdi), %eax
imull %eax, %edx
addq (%rdi), %rdx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
popq %rbp
jmp 0x26290
movl 0x14(%rdi), %edx
movq %rsi, %rdi
xorl %esi, %esi
popq %rbp
jmp 0x261c0
| get_dynamic:
push rbp
mov rbp, rsp
cmp [rdi+8], edx
jbe short loc_44BBA
mov eax, [rdi+14h]
imul edx, eax
add rdx, [rdi]
mov rdi, rsi
mov rsi, rdx
mov rdx, rax
pop rbp
jmp _memcpy
loc_44BBA:
mov edx, [rdi+14h]
mov rdi, rsi
xor esi, esi
pop rbp
jmp _memset
| long long get_dynamic(long long a1, long long a2, unsigned int a3)
{
if ( *(_DWORD *)(a1 + 8) <= a3 )
return memset(a2, 0LL, *(unsigned int *)(a1 + 20));
else
return memcpy(a2, *(_QWORD *)a1 + *(_DWORD *)(a1 + 20) * a3, *(unsigned int *)(a1 + 20));
}
| get_dynamic:
PUSH RBP
MOV RBP,RSP
CMP dword ptr [RDI + 0x8],EDX
JBE 0x00144bba
MOV EAX,dword ptr [RDI + 0x14]
IMUL EDX,EAX
ADD RDX,qword ptr [RDI]
MOV RDI,RSI
MOV RSI,RDX
MOV RDX,RAX
POP RBP
JMP 0x00126290
LAB_00144bba:
MOV EDX,dword ptr [RDI + 0x14]
MOV RDI,RSI
XOR ESI,ESI
POP RBP
JMP 0x001261c0
|
void get_dynamic(long *param_1,void *param_2,uint param_3)
{
if (param_3 < *(uint *)(param_1 + 1)) {
memcpy(param_2,(void *)((ulong)(param_3 * *(uint *)((long)param_1 + 0x14)) + *param_1),
(ulong)*(uint *)((long)param_1 + 0x14));
return;
}
memset(param_2,0,(ulong)*(uint *)((long)param_1 + 0x14));
return;
}
| |
22,578 | mbr_join | eloqsql/storage/maria/ma_rt_split.c | static void mbr_join(double *a, const double *b, int n_dim)
{
double *end= a + n_dim * 2;
do
{
if (a[0] > b[0])
a[0]= b[0];
if (a[1] < b[1])
a[1]= b[1];
a+= 2;
b+= 2;
} while (a != end);
} | O0 | c | mbr_join:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x87368
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x87392
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x87346
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mbr_join:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov ecx, [rbp+var_14]
shl ecx, 1
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov [rbp+var_20], rax
loc_87346:
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_10]
ucomisd xmm0, qword ptr [rax]
jbe short loc_87368
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_8]
movsd qword ptr [rax], xmm0
loc_87368:
mov rax, [rbp+var_8]
movsd xmm1, qword ptr [rax+8]
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax+8]
ucomisd xmm0, xmm1
jbe short loc_87392
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax+8]
mov rax, [rbp+var_8]
movsd qword ptr [rax+8], xmm0
loc_87392:
mov rax, [rbp+var_8]
add rax, 10h
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
add rax, 10h
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
cmp rax, [rbp+var_20]
jnz short loc_87346
pop rbp
retn
| double * mbr_join(double *a1, double *a2, int a3)
{
double *result; // rax
double *v5; // [rsp+18h] [rbp-8h]
v5 = a1;
do
{
if ( *v5 > *a2 )
*v5 = *a2;
if ( a2[1] > v5[1] )
v5[1] = a2[1];
v5 += 2;
a2 += 2;
result = v5;
}
while ( v5 != &a1[2 * a3] );
return result;
}
| mbr_join:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x14]
SHL ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_00187346:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
UCOMISD XMM0,qword ptr [RAX]
JBE 0x00187368
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOVSD qword ptr [RAX],XMM0
LAB_00187368:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM1,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x8]
UCOMISD XMM0,XMM1
JBE 0x00187392
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOVSD qword ptr [RAX + 0x8],XMM0
LAB_00187392:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x10
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x10
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00187346
POP RBP
RET
|
void mbr_join(double *param_1,double *param_2,int param_3)
{
double *local_18;
double *local_10;
local_18 = param_2;
local_10 = param_1;
do {
if (*local_18 <= *local_10 && *local_10 != *local_18) {
*local_10 = *local_18;
}
if (local_10[1] < local_18[1]) {
local_10[1] = local_18[1];
}
local_10 = local_10 + 2;
local_18 = local_18 + 2;
} while (local_10 != param_1 + (param_3 << 1));
return;
}
| |
22,579 | reset_partitioned_key_cache_counters | eloqsql/mysys/mf_keycache.c | static int
reset_partitioned_key_cache_counters(const char *name __attribute__((unused)),
PARTITIONED_KEY_CACHE_CB *keycache)
{
uint i;
uint partitions= keycache->partitions;
DBUG_ENTER("partitioned_reset_key_cache_counters");
for (i = 0; i < partitions; i++)
{
reset_simple_key_cache_counters(name, keycache->partition_array[i]);
}
DBUG_RETURN(0);
} | O0 | c | reset_partitioned_key_cache_counters:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x7605c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x745d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x76031
jmp 0x7605e
jmp 0x76060
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| reset_partitioned_key_cache_counters:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov eax, [rax+1Ch]
mov [rbp+var_18], eax
mov [rbp+var_14], 0
loc_76031:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jnb short loc_7605C
mov rdi, [rbp+var_8]
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov ecx, [rbp+var_14]
mov rsi, [rax+rcx*8]
call reset_simple_key_cache_counters
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_76031
loc_7605C:
jmp short $+2
loc_7605E:
jmp short $+2
loc_76060:
xor eax, eax
add rsp, 20h
pop rbp
retn
| long long reset_partitioned_key_cache_counters(long long a1, long long a2)
{
unsigned int v3; // [rsp+8h] [rbp-18h]
unsigned int i; // [rsp+Ch] [rbp-14h]
v3 = *(_DWORD *)(a2 + 28);
for ( i = 0; i < v3; ++i )
reset_simple_key_cache_counters(a1, *(_QWORD *)(*(_QWORD *)(a2 + 8) + 8LL * i));
return 0LL;
}
| reset_partitioned_key_cache_counters:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0x18],EAX
MOV dword ptr [RBP + -0x14],0x0
LAB_00176031:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JNC 0x0017605c
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RAX + RCX*0x8]
CALL 0x001745d0
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00176031
LAB_0017605c:
JMP 0x0017605e
LAB_0017605e:
JMP 0x00176060
LAB_00176060:
XOR EAX,EAX
ADD RSP,0x20
POP RBP
RET
|
int8 reset_partitioned_key_cache_counters(int8 param_1,long param_2)
{
uint uVar1;
int4 local_1c;
uVar1 = *(uint *)(param_2 + 0x1c);
for (local_1c = 0; local_1c < uVar1; local_1c = local_1c + 1) {
reset_simple_key_cache_counters
(param_1,*(int8 *)(*(long *)(param_2 + 8) + (ulong)local_1c * 8));
}
return 0;
}
| |
22,580 | my_numcells_eucjpms | eloqsql/strings/ctype-eucjpms.c | static
size_t my_numcells_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *str_end)
{
size_t clen;
const uchar *b= (const uchar *) str;
const uchar *e= (const uchar *) str_end;
for (clen= 0; b < e; )
{
if (*b == 0x8E)
{
clen++;
b+= 2;
}
else if (*b == 0x8F)
{
clen+= 2;
b+= 3;
}
else if (*b & 0x80)
{
clen+= 2;
b+= 2;
}
else
{
clen++;
b++;
}
}
return clen;
} | O3 | c | my_numcells_eucjpms:
cmpq %rdx, %rsi
jae 0x392c1
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movzbl (%rsi), %edi
cmpl $0x8e, %edi
je 0x3929a
cmpl $0x8f, %edi
jne 0x392a6
movl $0x3, %edi
movl $0x2, %ecx
jmp 0x392b4
movl $0x2, %edi
movl $0x1, %ecx
jmp 0x392b4
xorl %ecx, %ecx
testb %dil, %dil
sets %cl
incq %rcx
movq %rcx, %rdi
addq %rcx, %rax
addq %rdi, %rsi
cmpq %rdx, %rsi
jb 0x3927b
popq %rbp
retq
xorl %eax, %eax
retq
| my_numcells_eucjpms:
cmp rsi, rdx
jnb short loc_392C1
push rbp
mov rbp, rsp
xor eax, eax
loc_3927B:
movzx edi, byte ptr [rsi]
cmp edi, 8Eh
jz short loc_3929A
cmp edi, 8Fh
jnz short loc_392A6
mov edi, 3
mov ecx, 2
jmp short loc_392B4
loc_3929A:
mov edi, 2
mov ecx, 1
jmp short loc_392B4
loc_392A6:
xor ecx, ecx
test dil, dil
sets cl
inc rcx
mov rdi, rcx
loc_392B4:
add rax, rcx
add rsi, rdi
cmp rsi, rdx
jb short loc_3927B
pop rbp
retn
loc_392C1:
xor eax, eax
retn
| long long my_numcells_eucjpms(long long a1, unsigned __int8 *a2, unsigned long long a3)
{
long long result; // rax
int v4; // edi
long long v5; // rdi
long long v6; // rcx
if ( (unsigned long long)a2 >= a3 )
return 0LL;
result = 0LL;
do
{
v4 = *a2;
if ( v4 == 142 )
{
v5 = 2LL;
v6 = 1LL;
}
else if ( v4 == 143 )
{
v5 = 3LL;
v6 = 2LL;
}
else
{
v6 = ((v4 & 0x80u) != 0) + 1LL;
v5 = v6;
}
result += v6;
a2 += v5;
}
while ( (unsigned long long)a2 < a3 );
return result;
}
| my_numcells_eucjpms:
CMP RSI,RDX
JNC 0x001392c1
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
LAB_0013927b:
MOVZX EDI,byte ptr [RSI]
CMP EDI,0x8e
JZ 0x0013929a
CMP EDI,0x8f
JNZ 0x001392a6
MOV EDI,0x3
MOV ECX,0x2
JMP 0x001392b4
LAB_0013929a:
MOV EDI,0x2
MOV ECX,0x1
JMP 0x001392b4
LAB_001392a6:
XOR ECX,ECX
TEST DIL,DIL
SETS CL
INC RCX
MOV RDI,RCX
LAB_001392b4:
ADD RAX,RCX
ADD RSI,RDI
CMP RSI,RDX
JC 0x0013927b
POP RBP
RET
LAB_001392c1:
XOR EAX,EAX
RET
|
long my_numcells_eucjpms(int8 param_1,char *param_2,char *param_3)
{
char cVar1;
long lVar2;
long lVar3;
long lVar4;
if (param_2 < param_3) {
lVar2 = 0;
do {
cVar1 = *param_2;
if (cVar1 == -0x72) {
lVar4 = 2;
lVar3 = 1;
}
else if (cVar1 == -0x71) {
lVar3 = 2;
lVar4 = 3;
}
else {
lVar3 = (ulong)(cVar1 < '\0') + 1;
lVar4 = lVar3;
}
lVar2 = lVar2 + lVar3;
param_2 = param_2 + lVar4;
} while (param_2 < param_3);
return lVar2;
}
return 0;
}
| |
22,581 | translog_interpret_file_header | eloqsql/storage/maria/ma_loghandler.c | void translog_interpret_file_header(LOGHANDLER_FILE_INFO *desc,
uchar *page_buff)
{
uchar *ptr;
ptr= page_buff + sizeof(maria_trans_file_magic);
desc->timestamp= uint8korr(ptr);
ptr+= 8;
desc->maria_version= uint4korr(ptr);
ptr+= 4;
desc->mysql_version= uint4korr(ptr);
ptr+= 4;
desc->server_id= uint4korr(ptr);
ptr+= 4;
desc->page_size= uint2korr(ptr) + 1;
ptr+= 2;
desc->file_number= uint3korr(ptr);
ptr+= 3;
desc->max_lsn= lsn_korr(ptr);
} | O0 | c | translog_interpret_file_header:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
shlq $0x20, %rcx
movq -0x18(%rbp), %rax
movl 0x3(%rax), %eax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| translog_interpret_file_header:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
add rax, 0Ch
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, [rax]
mov rax, [rbp+var_8]
mov [rax+8], rcx
mov rax, [rbp+var_18]
add rax, 8
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax]
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+10h], rcx
mov rax, [rbp+var_18]
add rax, 4
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax]
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+18h], rcx
mov rax, [rbp+var_18]
add rax, 4
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax]
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+20h], rcx
mov rax, [rbp+var_18]
add rax, 4
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
add eax, 1
movsxd rcx, eax
mov rax, [rbp+var_8]
mov [rax+28h], rcx
mov rax, [rbp+var_18]
add rax, 2
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
mov ecx, eax
mov rax, [rbp+var_8]
mov [rax+30h], rcx
mov rax, [rbp+var_18]
add rax, 3
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
mov ecx, eax
shl rcx, 20h
mov rax, [rbp+var_18]
mov eax, [rax+3]
or rcx, rax
mov rax, [rbp+var_8]
mov [rax], rcx
pop rbp
retn
| unsigned long long * translog_interpret_file_header(unsigned long long *a1, long long a2)
{
unsigned long long *result; // rax
a1[1] = *(_QWORD *)(a2 + 12);
a1[2] = *(unsigned int *)(a2 + 20);
a1[3] = *(unsigned int *)(a2 + 24);
a1[4] = *(unsigned int *)(a2 + 28);
a1[5] = *(unsigned __int16 *)(a2 + 32) + 1;
a1[6] = (*(unsigned __int8 *)(a2 + 36) << 16) | (unsigned int)*(unsigned __int16 *)(a2 + 34);
result = a1;
*a1 = *(unsigned int *)(a2 + 40) | ((unsigned long long)((*(unsigned __int8 *)(a2 + 39) << 16) | (unsigned int)*(unsigned __int16 *)(a2 + 37)) << 32);
return result;
}
| translog_interpret_file_header:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0xc
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x8
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x4
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x4
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x4
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
ADD EAX,0x1
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x30],RCX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
MOV ECX,EAX
SHL RCX,0x20
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x3]
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void translog_interpret_file_header(ulong *param_1,long param_2)
{
param_1[1] = *(ulong *)(param_2 + 0xc);
param_1[2] = (ulong)*(uint *)(param_2 + 0x14);
param_1[3] = (ulong)*(uint *)(param_2 + 0x18);
param_1[4] = (ulong)*(uint *)(param_2 + 0x1c);
param_1[5] = (long)(int)(*(ushort *)(param_2 + 0x20) + 1);
param_1[6] = (ulong)*(uint3 *)(param_2 + 0x22);
*param_1 = (ulong)CONCAT34(*(int3 *)(param_2 + 0x25),*(int4 *)(param_2 + 0x28));
return;
}
| |
22,582 | translog_interpret_file_header | eloqsql/storage/maria/ma_loghandler.c | void translog_interpret_file_header(LOGHANDLER_FILE_INFO *desc,
uchar *page_buff)
{
uchar *ptr;
ptr= page_buff + sizeof(maria_trans_file_magic);
desc->timestamp= uint8korr(ptr);
ptr+= 8;
desc->maria_version= uint4korr(ptr);
ptr+= 4;
desc->mysql_version= uint4korr(ptr);
ptr+= 4;
desc->server_id= uint4korr(ptr);
ptr+= 4;
desc->page_size= uint2korr(ptr) + 1;
ptr+= 2;
desc->file_number= uint3korr(ptr);
ptr+= 3;
desc->max_lsn= lsn_korr(ptr);
} | O3 | c | translog_interpret_file_header:
pushq %rbp
movq %rsp, %rbp
movq 0xc(%rsi), %rax
movq %rax, 0x8(%rdi)
movl 0x14(%rsi), %eax
movq %rax, 0x10(%rdi)
movl 0x18(%rsi), %eax
movq %rax, 0x18(%rdi)
movl 0x1c(%rsi), %eax
movq %rax, 0x20(%rdi)
movzwl 0x20(%rsi), %eax
incq %rax
movq %rax, 0x28(%rdi)
movzwl 0x22(%rsi), %eax
movzbl 0x24(%rsi), %ecx
shll $0x10, %ecx
orq %rax, %rcx
movq %rcx, 0x30(%rdi)
movzwl 0x25(%rsi), %eax
shlq $0x20, %rax
movzbl 0x27(%rsi), %ecx
shlq $0x30, %rcx
orq %rax, %rcx
movl 0x28(%rsi), %eax
orq %rcx, %rax
movq %rax, (%rdi)
popq %rbp
retq
| translog_interpret_file_header:
push rbp
mov rbp, rsp
mov rax, [rsi+0Ch]
mov [rdi+8], rax
mov eax, [rsi+14h]
mov [rdi+10h], rax
mov eax, [rsi+18h]
mov [rdi+18h], rax
mov eax, [rsi+1Ch]
mov [rdi+20h], rax
movzx eax, word ptr [rsi+20h]
inc rax
mov [rdi+28h], rax
movzx eax, word ptr [rsi+22h]
movzx ecx, byte ptr [rsi+24h]
shl ecx, 10h
or rcx, rax
mov [rdi+30h], rcx
movzx eax, word ptr [rsi+25h]
shl rax, 20h
movzx ecx, byte ptr [rsi+27h]
shl rcx, 30h
or rcx, rax
mov eax, [rsi+28h]
or rax, rcx
mov [rdi], rax
pop rbp
retn
| unsigned long long translog_interpret_file_header(unsigned long long *a1, long long a2)
{
unsigned long long result; // rax
a1[1] = *(_QWORD *)(a2 + 12);
a1[2] = *(unsigned int *)(a2 + 20);
a1[3] = *(unsigned int *)(a2 + 24);
a1[4] = *(unsigned int *)(a2 + 28);
a1[5] = *(unsigned __int16 *)(a2 + 32) + 1LL;
a1[6] = *(unsigned __int16 *)(a2 + 34) | (unsigned long long)(*(unsigned __int8 *)(a2 + 36) << 16);
result = ((unsigned long long)*(unsigned __int16 *)(a2 + 37) << 32) | ((unsigned long long)*(unsigned __int8 *)(a2 + 39) << 48) | *(unsigned int *)(a2 + 40);
*a1 = result;
return result;
}
| translog_interpret_file_header:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RSI + 0xc]
MOV qword ptr [RDI + 0x8],RAX
MOV EAX,dword ptr [RSI + 0x14]
MOV qword ptr [RDI + 0x10],RAX
MOV EAX,dword ptr [RSI + 0x18]
MOV qword ptr [RDI + 0x18],RAX
MOV EAX,dword ptr [RSI + 0x1c]
MOV qword ptr [RDI + 0x20],RAX
MOVZX EAX,word ptr [RSI + 0x20]
INC RAX
MOV qword ptr [RDI + 0x28],RAX
MOVZX EAX,word ptr [RSI + 0x22]
MOVZX ECX,byte ptr [RSI + 0x24]
SHL ECX,0x10
OR RCX,RAX
MOV qword ptr [RDI + 0x30],RCX
MOVZX EAX,word ptr [RSI + 0x25]
SHL RAX,0x20
MOVZX ECX,byte ptr [RSI + 0x27]
SHL RCX,0x30
OR RCX,RAX
MOV EAX,dword ptr [RSI + 0x28]
OR RAX,RCX
MOV qword ptr [RDI],RAX
POP RBP
RET
|
void translog_interpret_file_header(ulong *param_1,long param_2)
{
param_1[1] = *(ulong *)(param_2 + 0xc);
param_1[2] = (ulong)*(uint *)(param_2 + 0x14);
param_1[3] = (ulong)*(uint *)(param_2 + 0x18);
param_1[4] = (ulong)*(uint *)(param_2 + 0x1c);
param_1[5] = (ulong)*(ushort *)(param_2 + 0x20) + 1;
param_1[6] = (ulong)*(uint3 *)(param_2 + 0x22);
*param_1 = (ulong)*(uint *)(param_2 + 0x28) |
(ulong)*(byte *)(param_2 + 0x27) << 0x30 | (ulong)*(ushort *)(param_2 + 0x25) << 0x20;
return;
}
| |
22,583 | inline_mysql_file_chsize | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_chsize(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, my_off_t newlength, int filler, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_CHSIZE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) newlength, src_file,
src_line);
result= my_chsize(file, newlength, filler, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) newlength);
return result;
}
#endif
result= my_chsize(file, newlength, filler, flags);
return result;
} | O0 | c | inline_mysql_file_chsize:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x249c00(%rip), %rax # 0x2c1238
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0xd, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x776d2
leaq 0x249bba(%rip), %rax # 0x2c1238
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0xf0100
movl %eax, -0x34(%rbp)
leaq 0x249b82(%rip), %rax # 0x2c1238
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x776ee
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0xf0100
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| inline_mysql_file_chsize_2:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 0Dh
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_776D2
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_30]
call my_chsize
mov [rbp+var_34], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_20]
call rax
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
jmp short loc_776EE
loc_776D2:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_30]
call my_chsize
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
loc_776EE:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
| long long inline_mysql_file_chsize_2(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6)
{
_BYTE v7[72]; // [rsp+8h] [rbp-88h] BYREF
long long v8; // [rsp+50h] [rbp-40h]
unsigned int v9; // [rsp+5Ch] [rbp-34h]
long long v10; // [rsp+60h] [rbp-30h]
unsigned int v11; // [rsp+6Ch] [rbp-24h]
long long v12; // [rsp+70h] [rbp-20h]
unsigned int v13; // [rsp+78h] [rbp-18h]
unsigned int v14; // [rsp+7Ch] [rbp-14h]
long long v15; // [rsp+80h] [rbp-10h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v10 = a6;
v8 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v7, a3, 13LL);
if ( v8 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v8, v12, v15, v14);
v9 = my_chsize(v13, v12, v11, v10);
((void ( *)(long long, long long))PSI_server[67])(v8, v12);
}
else
{
return (unsigned int)my_chsize(v13, v12, v11, v10);
}
return v9;
}
| inline_mysql_file_chsize:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3c1238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0xd
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001776d2
LEA RAX,[0x3c1238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001f0100
MOV dword ptr [RBP + -0x34],EAX
LEA RAX,[0x3c1238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x20]
CALL RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001776ee
LAB_001776d2:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001f0100
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
LAB_001776ee:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int4
inline_mysql_file_chsize
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
int4 param_5,int8 param_6)
{
int1 local_90 [72];
long local_48;
int4 local_3c;
int8 local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int4 local_c;
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,0xd);
if (local_48 == 0) {
local_c = my_chsize(local_20,local_28,local_2c,local_38);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_28,local_18,local_1c);
local_3c = my_chsize(local_20,local_28,local_2c,local_38);
(**(code **)(PSI_server + 0x218))(local_48,local_28);
local_c = local_3c;
}
return local_c;
}
| |
22,584 | minja::Value::get(minja::Value const&) | llama.cpp/common/minja/minja.hpp | Value get(const Value& key) {
if (array_) {
if (!key.is_number_integer()) {
return Value();
}
auto index = key.get<int>();
return array_->at(index < 0 ? array_->size() + index : index);
} else if (object_) {
if (!key.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
auto it = object_->find(key.primitive_);
if (it == object_->end()) return Value();
return it->second;
}
return Value();
} | O3 | cpp | minja::Value::get(minja::Value const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rsi)
je 0xd4a6c
movb 0x40(%r15), %al
addb $-0x5, %al
cmpb $0x2, %al
jae 0xd4b1a
movq %r15, %rdi
callq 0xca034
movq 0x10(%r14), %rcx
testl %eax, %eax
js 0xd4ac9
movl %eax, %eax
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
jmp 0xd4aea
movq 0x20(%r14), %r13
testq %r13, %r13
je 0xd4b1a
cmpq $0x0, 0x10(%r15)
jne 0xd4b79
cmpq $0x0, 0x20(%r15)
jne 0xd4b79
cmpq $0x0, 0x30(%r15)
jne 0xd4b79
movq (%r13), %r12
movq 0x8(%r13), %rsi
cmpq %rsi, %r12
je 0xd4b07
addq $0x40, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0xc613e
testb %al, %al
jne 0xd4afc
addq $0x60, %r12
movq 0x8(%r13), %rsi
cmpq %rsi, %r12
jne 0xd4aab
jmp 0xd4aff
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cltq
addq %rdx, %rax
cmpq %rax, %rdx
jbe 0xd4b68
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rsi
jmp 0xd4b10
movq %r12, %rsi
movq 0x20(%r14), %rax
movq 0x8(%rax), %r12
cmpq %r12, %rsi
je 0xd4b1a
addq $0x10, %rsi
movq %rbx, %rdi
callq 0xc793a
jmp 0xd4b56
leaq 0x40(%rbx), %r14
movq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movb $0x0, 0x40(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x9524a
movq %r14, %rdi
movl $0x1, %esi
callq 0x9524a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x54fcc(%rip), %rdi # 0x129b3b
movq %rax, %rsi
xorl %eax, %eax
callq 0x21090
movl $0x10, %edi
callq 0x21660
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xc030c
leaq 0x550c5(%rip), %rsi # 0x129c66
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xba080
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x21480
xorl %ebp, %ebp
movq 0x993f7(%rip), %rsi # 0x16dfc0
movq 0x993b0(%rip), %rdx # 0x16df80
movq %rbx, %rdi
callq 0x21a80
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd4bf6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21180
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd4c11
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
testb %bpl, %bpl
jne 0xd4c3b
jmp 0xd4c43
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd4c3b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
jmp 0xd4c3b
movq %rax, %r14
movq %rbx, %rdi
callq 0x21f50
movq %r14, %rdi
callq 0x21b20
nop
| _ZN5minja5Value3getERKS0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
cmp qword ptr [rsi+10h], 0
jz short loc_D4A6C
mov al, [r15+40h]
add al, 0FBh
cmp al, 2
jnb loc_D4B1A
mov rdi, r15
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
mov rcx, [r14+10h]
test eax, eax
js short loc_D4AC9
mov eax, eax
mov rsi, [rcx]
mov rcx, [rcx+8]
sub rcx, rsi
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
jmp short loc_D4AEA
loc_D4A6C:
mov r13, [r14+20h]
test r13, r13
jz loc_D4B1A
cmp qword ptr [r15+10h], 0
jnz loc_D4B79
cmp qword ptr [r15+20h], 0
jnz loc_D4B79
cmp qword ptr [r15+30h], 0
jnz loc_D4B79
mov r12, [r13+0]
mov rsi, [r13+8]
cmp r12, rsi
jz short loc_D4B07
add r15, 40h ; '@'
loc_D4AAB:
mov rdi, r12
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
test al, al
jnz short loc_D4AFC
add r12, 60h ; '`'
mov rsi, [r13+8]
cmp r12, rsi
jnz short loc_D4AAB
jmp short loc_D4AFF
loc_D4AC9:
mov rsi, [rcx]
mov rcx, [rcx+8]
sub rcx, rsi
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
cdqe
add rax, rdx
loc_D4AEA:
cmp rdx, rax
jbe short loc_D4B68
lea rax, [rax+rax*4]
shl rax, 4
add rsi, rax
jmp short loc_D4B10
loc_D4AFC:
mov rsi, r12
loc_D4AFF:
mov rax, [r14+20h]
mov r12, [rax+8]
loc_D4B07:
cmp rsi, r12
jz short loc_D4B1A
add rsi, 10h; minja::Value *
loc_D4B10:
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
jmp short loc_D4B56
loc_D4B1A:
lea r14, [rbx+40h]
mov qword ptr [rbx+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov byte ptr [rbx+40h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
loc_D4B56:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D4B68:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
mov rsi, rax
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
loc_D4B79:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+78h+var_70]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_50]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_D4BF6
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D4BF6:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_D4C11
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D4C11:
test bpl, bpl
jnz short loc_D4C3B
jmp short loc_D4C43
mov r14, rax
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_D4C3B
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D4C3B
mov r14, rax
loc_D4C3B:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_D4C43:
mov rdi, r14
call __Unwind_Resume
| minja::Value * minja::Value::get(minja::Value *this, const minja::Value *a2, long long a3, __m128d a4)
{
unsigned long long v5; // rax
long long *v6; // rcx
long long v7; // rsi
unsigned long long v8; // rdx
unsigned __int8 **v9; // r13
unsigned __int8 *v10; // r12
unsigned __int8 *v11; // rsi
unsigned __int8 *v12; // r15
const minja::Value *v13; // rsi
void *exception; // rbx
_BYTE v16[16]; // [rsp+8h] [rbp-70h] BYREF
_QWORD v17[2]; // [rsp+28h] [rbp-50h] BYREF
if ( *((_QWORD *)a2 + 2) )
{
if ( (unsigned __int8)(*(_BYTE *)(a3 + 64) - 5) < 2u )
{
LODWORD(v5) = minja::Value::get<int>(a3);
v6 = (long long *)*((_QWORD *)a2 + 2);
if ( (v5 & 0x80000000) != 0LL )
{
v7 = *v6;
v8 = 0xCCCCCCCCCCCCCCCDLL * ((v6[1] - *v6) >> 4);
v5 = v8 + (int)v5;
}
else
{
v5 = (unsigned int)v5;
v7 = *v6;
v8 = 0xCCCCCCCCCCCCCCCDLL * ((v6[1] - *v6) >> 4);
}
if ( v8 <= v5 )
std::__throw_out_of_range_fmt(
"vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)",
v5,
v8);
v13 = (const minja::Value *)(80 * v5 + v7);
goto LABEL_21;
}
LABEL_22:
*((_QWORD *)this + 9) = 0LL;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_BYTE *)this + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
return this;
}
v9 = (unsigned __int8 **)*((_QWORD *)a2 + 4);
if ( !v9 )
goto LABEL_22;
if ( *(_QWORD *)(a3 + 16) || *(_QWORD *)(a3 + 32) || *(_QWORD *)(a3 + 48) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v16, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>(v17, (long long)"Unashable type: ", (long long)v16);
std::runtime_error::runtime_error(exception, v17);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v10 = *v9;
v11 = v9[1];
if ( *v9 != v11 )
{
v12 = (unsigned __int8 *)(a3 + 64);
while ( !(unsigned __int8)nlohmann::json_abi_v3_11_3::operator==(v10, v12, a4) )
{
v10 += 96;
v11 = v9[1];
if ( v10 == v11 )
goto LABEL_18;
}
v11 = v10;
LABEL_18:
v10 = *(unsigned __int8 **)(*((_QWORD *)a2 + 4) + 8LL);
}
if ( v11 == v10 )
goto LABEL_22;
v13 = (const minja::Value *)(v11 + 16);
LABEL_21:
minja::Value::Value(this, v13);
return this;
}
| get:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
CMP qword ptr [RSI + 0x10],0x0
JZ 0x001d4a6c
MOV AL,byte ptr [R15 + 0x40]
ADD AL,0xfb
CMP AL,0x2
JNC 0x001d4b1a
MOV RDI,R15
CALL 0x001ca034
MOV RCX,qword ptr [R14 + 0x10]
TEST EAX,EAX
JS 0x001d4ac9
MOV EAX,EAX
MOV RSI,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,RSI
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
JMP 0x001d4aea
LAB_001d4a6c:
MOV R13,qword ptr [R14 + 0x20]
TEST R13,R13
JZ 0x001d4b1a
CMP qword ptr [R15 + 0x10],0x0
JNZ 0x001d4b79
CMP qword ptr [R15 + 0x20],0x0
JNZ 0x001d4b79
CMP qword ptr [R15 + 0x30],0x0
JNZ 0x001d4b79
MOV R12,qword ptr [R13]
MOV RSI,qword ptr [R13 + 0x8]
CMP R12,RSI
JZ 0x001d4b07
ADD R15,0x40
LAB_001d4aab:
MOV RDI,R12
MOV RSI,R15
CALL 0x001c613e
TEST AL,AL
JNZ 0x001d4afc
ADD R12,0x60
MOV RSI,qword ptr [R13 + 0x8]
CMP R12,RSI
JNZ 0x001d4aab
JMP 0x001d4aff
LAB_001d4ac9:
MOV RSI,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,RSI
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
CDQE
ADD RAX,RDX
LAB_001d4aea:
CMP RDX,RAX
JBE 0x001d4b68
LEA RAX,[RAX + RAX*0x4]
SHL RAX,0x4
ADD RSI,RAX
JMP 0x001d4b10
LAB_001d4afc:
MOV RSI,R12
LAB_001d4aff:
MOV RAX,qword ptr [R14 + 0x20]
MOV R12,qword ptr [RAX + 0x8]
LAB_001d4b07:
CMP RSI,R12
JZ 0x001d4b1a
ADD RSI,0x10
LAB_001d4b10:
MOV RDI,RBX
CALL 0x001c793a
JMP 0x001d4b56
LAB_001d4b1a:
LEA R14,[RBX + 0x40]
MOV qword ptr [RBX + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV byte ptr [RBX + 0x40],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0019524a
MOV RDI,R14
MOV ESI,0x1
CALL 0x0019524a
LAB_001d4b56:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001d4b68:
LEA RDI,[0x229b3b]
MOV RSI,RAX
XOR EAX,EAX
CALL 0x00121090
LAB_001d4b79:
MOV EDI,0x10
CALL 0x00121660
MOV RBX,RAX
LAB_001d4b86:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001c030c
LAB_001d4b9a:
LEA RSI,[0x229c66]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x001ba080
MOV BPL,0x1
LAB_001d4bb3:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00121480
XOR EBP,EBP
MOV RSI,qword ptr [0x0026dfc0]
MOV RDX,qword ptr [0x0026df80]
MOV RDI,RBX
CALL 0x00121a80
|
/* minja::Value::get(minja::Value const&) */
Value * minja::Value::get(Value *param_1)
{
long *plVar1;
char cVar2;
uint uVar3;
ulong uVar4;
runtime_error *this;
Value *in_RDX;
ulong uVar5;
long in_RSI;
long lVar6;
Value *pVVar7;
basic_json *pbVar8;
bool bVar9;
basic_json *pbVar10;
int1 local_70 [32];
string local_50 [32];
if (*(long *)(in_RSI + 0x10) == 0) {
plVar1 = *(long **)(in_RSI + 0x20);
if (plVar1 != (long *)0x0) {
if (((*(long *)(in_RDX + 0x10) != 0) || (*(long *)(in_RDX + 0x20) != 0)) ||
(*(long *)(in_RDX + 0x30) != 0)) goto LAB_001d4b79;
pbVar10 = (basic_json *)*plVar1;
pbVar8 = (basic_json *)plVar1[1];
if (pbVar10 != pbVar8) {
do {
pbVar8 = pbVar10;
cVar2 = nlohmann::json_abi_v3_11_3::operator==(pbVar8,(basic_json *)(in_RDX + 0x40));
if (cVar2 != '\0') break;
pbVar10 = pbVar8 + 0x60;
pbVar8 = (basic_json *)plVar1[1];
} while (pbVar10 != pbVar8);
pbVar10 = *(basic_json **)(*(long *)(in_RSI + 0x20) + 8);
}
if (pbVar8 != pbVar10) {
pVVar7 = (Value *)(pbVar8 + 0x10);
goto LAB_001d4b10;
}
}
}
else if ((byte)((char)in_RDX[0x40] - 5U) < 2) {
uVar3 = get<int>(in_RDX);
plVar1 = *(long **)(in_RSI + 0x10);
if ((int)uVar3 < 0) {
lVar6 = *plVar1;
uVar5 = (plVar1[1] - lVar6 >> 4) * -0x3333333333333333;
uVar4 = (long)(int)uVar3 + uVar5;
}
else {
uVar4 = (ulong)uVar3;
lVar6 = *plVar1;
uVar5 = (plVar1[1] - lVar6 >> 4) * -0x3333333333333333;
}
if (uVar4 < uVar5) {
pVVar7 = (Value *)(lVar6 + uVar4 * 0x50);
LAB_001d4b10:
Value(param_1,pVVar7);
return param_1;
}
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)",uVar4);
LAB_001d4b79:
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001d4b86 to 001d4b99 has its CatchHandler @ 001d4c38 */
dump_abi_cxx11_((int)local_70,SUB81(in_RSI,0));
/* try { // try from 001d4b9a to 001d4baf has its CatchHandler @ 001d4c18 */
std::operator+((char *)local_50,(string *)"Unashable type: ");
/* try { // try from 001d4bb3 to 001d4bd7 has its CatchHandler @ 001d4bd8 */
std::runtime_error::runtime_error(this,local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0026dfc0,PTR__runtime_error_0026df80);
}
bVar9 = (bool)((char)param_1 + '@');
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
param_1[0x40] = (Value)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar9);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar9);
return param_1;
}
| |
22,585 | google::protobuf::MapValueConstRef::GetUInt64Value() const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/map_field.h | uint64_t GetUInt64Value() const {
TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
"MapValueConstRef::GetUInt64Value");
return *reinterpret_cast<uint64_t*>(data_);
} | O0 | c | google::protobuf::MapValueConstRef::GetUInt64Value() const:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x4188d0
cmpl $0x4, %eax
je 0x4262aa
leaq 0x1cde0f(%rip), %rdx # 0x5f3f90
leaq 0x68(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movl $0x3, %esi
movl $0x2cb, %ecx # imm = 0x2CB
callq 0x3ef0b0
movq 0x40(%rsp), %rdi
leaq 0x1cde4f(%rip), %rsi # 0x5f3ff5
callq 0x3ee970
movq %rax, 0x48(%rsp)
jmp 0x4261b2
movq 0x48(%rsp), %rdi
leaq 0x1ce436(%rip), %rsi # 0x5f45f4
callq 0x3ee970
movq %rax, 0x38(%rsp)
jmp 0x4261ca
movq 0x38(%rsp), %rdi
leaq 0x1cde62(%rip), %rsi # 0x5f4038
callq 0x3ee970
movq %rax, 0x30(%rsp)
jmp 0x4261e2
movq 0x30(%rsp), %rdi
leaq 0x1cde60(%rip), %rsi # 0x5f404e
callq 0x3ee970
movq %rax, 0x28(%rsp)
jmp 0x4261fa
movl $0x4, %edi
callq 0x4189a0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x3ee970
movq %rax, 0x20(%rsp)
jmp 0x426218
movq 0x20(%rsp), %rdi
leaq 0x1d2807(%rip), %rsi # 0x5f8a2b
callq 0x3ee970
movq %rax, 0x18(%rsp)
jmp 0x426230
movq 0x18(%rsp), %rdi
leaq 0x1cde20(%rip), %rsi # 0x5f405c
callq 0x3ee970
movq %rax, 0x10(%rsp)
jmp 0x426248
movq 0x50(%rsp), %rdi
callq 0x4188d0
movl %eax, 0xc(%rsp)
jmp 0x426258
movl 0xc(%rsp), %edi
callq 0x4189a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3ee970
movq %rax, (%rsp)
jmp 0x426274
movq (%rsp), %rsi
leaq 0x5b(%rsp), %rdi
callq 0x3eeb20
jmp 0x426284
leaq 0x68(%rsp), %rdi
callq 0x3ef0f0
jmp 0x4262aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x3ef0f0
jmp 0x4262bd
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x198ce0
nopw (%rax,%rax)
| _ZNK6google8protobuf16MapValueConstRef14GetUInt64ValueEv:
sub rsp, 0A8h
mov [rsp+0A8h+var_8], rdi
mov rdi, [rsp+0A8h+var_8]; this
mov [rsp+0A8h+var_58], rdi
call _ZNK6google8protobuf16MapValueConstRef4typeEv; google::protobuf::MapValueConstRef::type(void)
cmp eax, 4
jz loc_4262AA
lea rdx, aWorkspaceLlm4b_25; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0A8h+var_40]
mov [rsp+0A8h+var_68], rdi
mov esi, 3
mov ecx, 2CBh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+0A8h+var_68]
lea rsi, aProtocolBuffer_0; "Protocol Buffer map usage error:\n"
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0A8h+var_60], rax
jmp short $+2
loc_4261B2:
mov rdi, [rsp+0A8h+var_60]
lea rsi, aMapvalueconstr_3; "MapValueConstRef::GetUInt64Value"
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0A8h+var_70], rax
jmp short $+2
loc_4261CA:
mov rdi, [rsp+0A8h+var_70]
lea rsi, aTypeDoesNotMat; " type does not match\n"
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0A8h+var_78], rax
jmp short $+2
loc_4261E2:
mov rdi, [rsp+0A8h+var_78]
lea rsi, aExpected; " Expected : "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0A8h+var_80], rax
jmp short $+2
loc_4261FA:
mov edi, 4
call _ZN6google8protobuf15FieldDescriptor11CppTypeNameENS1_7CppTypeE; google::protobuf::FieldDescriptor::CppTypeName(google::protobuf::FieldDescriptor::CppType)
mov rdi, [rsp+0A8h+var_80]
mov rsi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0A8h+var_88], rax
jmp short $+2
loc_426218:
mov rdi, [rsp+0A8h+var_88]
lea rsi, aSyntax0+0Fh; "\n"
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0A8h+var_90], rax
jmp short $+2
loc_426230:
mov rdi, [rsp+0A8h+var_90]
lea rsi, aActual_0; " Actual : "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0A8h+var_98], rax
jmp short $+2
loc_426248:
mov rdi, [rsp+0A8h+var_58]; this
call _ZNK6google8protobuf16MapValueConstRef4typeEv; google::protobuf::MapValueConstRef::type(void)
mov [rsp+0A8h+var_9C], eax
jmp short $+2
loc_426258:
mov edi, [rsp+0A8h+var_9C]
call _ZN6google8protobuf15FieldDescriptor11CppTypeNameENS1_7CppTypeE; google::protobuf::FieldDescriptor::CppTypeName(google::protobuf::FieldDescriptor::CppType)
mov rdi, [rsp+0A8h+var_98]
mov rsi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0A8h+var_A8], rax
jmp short $+2
loc_426274:
mov rsi, [rsp+0A8h+var_A8]
lea rdi, [rsp+0A8h+var_4D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_426284:
lea rdi, [rsp+0A8h+var_40]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_4262AA
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
lea rdi, [rsp+arg_60]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_4262BD
loc_4262AA:
mov rax, [rsp+0A8h+var_58]
mov rax, [rax]
mov rax, [rax]
add rsp, 0A8h
retn
loc_4262BD:
mov rdi, [rsp+arg_58]
call __Unwind_Resume
| long long google::protobuf::MapValueConstRef::GetUInt64Value(google::protobuf::MapValueConstRef *this)
{
char *v1; // rax
char *v2; // rax
google::protobuf::internal::LogMessage *v4; // [rsp+0h] [rbp-A8h]
int v5; // [rsp+Ch] [rbp-9Ch]
long long v6; // [rsp+10h] [rbp-98h]
long long v7; // [rsp+18h] [rbp-90h]
long long v8; // [rsp+20h] [rbp-88h]
long long v9; // [rsp+28h] [rbp-80h]
long long v10; // [rsp+30h] [rbp-78h]
long long v11; // [rsp+38h] [rbp-70h]
long long v12; // [rsp+48h] [rbp-60h]
_BYTE v13[13]; // [rsp+5Bh] [rbp-4Dh] BYREF
_BYTE v14[56]; // [rsp+68h] [rbp-40h] BYREF
google::protobuf::MapValueConstRef *v15; // [rsp+A0h] [rbp-8h]
v15 = this;
if ( (unsigned int)google::protobuf::MapValueConstRef::type(this) != 4 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v14,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/map_field.h",
715);
v12 = google::protobuf::internal::LogMessage::operator<<(
(long long)v14,
(long long)"Protocol Buffer map usage error:\n");
v11 = google::protobuf::internal::LogMessage::operator<<(v12, (long long)"MapValueConstRef::GetUInt64Value");
v10 = google::protobuf::internal::LogMessage::operator<<(v11, (long long)" type does not match\n");
v9 = google::protobuf::internal::LogMessage::operator<<(v10, (long long)" Expected : ");
v1 = google::protobuf::FieldDescriptor::CppTypeName(4);
v8 = google::protobuf::internal::LogMessage::operator<<(v9, (long long)v1);
v7 = google::protobuf::internal::LogMessage::operator<<(v8, (long long)"\n");
v6 = google::protobuf::internal::LogMessage::operator<<(v7, (long long)" Actual : ");
v5 = google::protobuf::MapValueConstRef::type(this);
v2 = google::protobuf::FieldDescriptor::CppTypeName(v5);
v4 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(v6, (long long)v2);
google::protobuf::internal::LogFinisher::operator=((long long)v13, v4);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v14);
}
return **(_QWORD **)this;
}
| _Scoped_node<std::piecewise_construct_t_const&,std::tuple<std::basic_string_view<char,std::char_traits<char>>const&>,std::tuple<>>:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x10],R8
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RAX
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
CALL 0x004265e0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x8],RCX
ADD RSP,0x38
RET
|
/* std::_Hashtable<std::basic_string_view<char, std::char_traits<char> >,
std::pair<std::basic_string_view<char, std::char_traits<char> > const,
std::vector<aimrt::runtime::core::rpc::ClientFuncWrapper*,
std::allocator<aimrt::runtime::core::rpc::ClientFuncWrapper*> > >,
std::allocator<std::pair<std::basic_string_view<char, std::char_traits<char> > const,
std::vector<aimrt::runtime::core::rpc::ClientFuncWrapper*,
std::allocator<aimrt::runtime::core::rpc::ClientFuncWrapper*> > > >, std::__detail::_Select1st,
std::equal_to<std::basic_string_view<char, std::char_traits<char> > >,
std::hash<std::basic_string_view<char, std::char_traits<char> > >,
std::__detail::_Mod_range_hashing, std::__detail::_Default_ranged_hash,
std::__detail::_Prime_rehash_policy, std::__detail::_Hashtable_traits<true, false, true>
>::_Scoped_node::_Scoped_node<std::piecewise_construct_t const&,
std::tuple<std::basic_string_view<char, std::char_traits<char> > const&>, std::tuple<>
>(std::__detail::_Hashtable_alloc<std::allocator<std::__detail::_Hash_node<std::pair<std::basic_string_view<char,
std::char_traits<char> > const, std::vector<aimrt::runtime::core::rpc::ClientFuncWrapper*,
std::allocator<aimrt::runtime::core::rpc::ClientFuncWrapper*> > >, true> > >*,
std::piecewise_construct_t const&, std::tuple<std::basic_string_view<char, std::char_traits<char>
> const&>&&, std::tuple<>&&) */
void __thiscall
std::
_Hashtable<std::basic_string_view<char,std::char_traits<char>>,std::pair<std::basic_string_view<char,std::char_traits<char>>const,std::vector<aimrt::runtime::core::rpc::ClientFuncWrapper*,std::allocator<aimrt::runtime::core::rpc::ClientFuncWrapper*>>>,std::allocator<std::pair<std::basic_string_view<char,std::char_traits<char>>const,std::vector<aimrt::runtime::core::rpc::ClientFuncWrapper*,std::allocator<aimrt::runtime::core::rpc::ClientFuncWrapper*>>>>,std::__detail::_Select1st,std::equal_to<std::basic_string_view<char,std::char_traits<char>>>,std::hash<std::basic_string_view<char,std::char_traits<char>>>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::_Scoped_node::
_Scoped_node<std::piecewise_construct_t_const&,std::tuple<std::basic_string_view<char,std::char_traits<char>>const&>,std::tuple<>>
(_Scoped_node *this,_Hashtable_alloc *param_1,piecewise_construct_t *param_2,
tuple *param_3,tuple *param_4)
{
_Hash_node *p_Var1;
*(_Hashtable_alloc **)this = param_1;
p_Var1 = __detail::
_Hashtable_alloc<std::allocator<std::__detail::_Hash_node<std::pair<std::basic_string_view<char,std::char_traits<char>>const,std::vector<aimrt::runtime::core::rpc::ClientFuncWrapper*,std::allocator<aimrt::runtime::core::rpc::ClientFuncWrapper*>>>,true>>>
::
_M_allocate_node<std::piecewise_construct_t_const&,std::tuple<std::basic_string_view<char,std::char_traits<char>>const&>,std::tuple<>>
((_Hashtable_alloc<std::allocator<std::__detail::_Hash_node<std::pair<std::basic_string_view<char,std::char_traits<char>>const,std::vector<aimrt::runtime::core::rpc::ClientFuncWrapper*,std::allocator<aimrt::runtime::core::rpc::ClientFuncWrapper*>>>,true>>>
*)param_1,param_2,param_3,param_4);
*(_Hash_node **)(this + 8) = p_Var1;
return;
}
| |
22,586 | inline_mysql_rwlock_destroy | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_rwlock_destroy(
mysql_rwlock_t *that)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
{
PSI_RWLOCK_CALL(destroy_rwlock)(that->m_psi);
that->m_psi= NULL;
}
#endif
return rwlock_destroy(&that->m_rwlock);
} | O0 | c | inline_mysql_rwlock_destroy:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xfde1d
leaq 0x1c129e(%rip), %rax # 0x2bf098
movq (%rax), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x8(%rbp), %rdi
callq 0xf9470
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| inline_mysql_rwlock_destroy_1:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+90h], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_FDE1D
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+58h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+90h]
call rax
mov rax, [rbp+var_8]
mov qword ptr [rax+90h], 0
loc_FDE1D:
mov rdi, [rbp+var_8]
call my_rw_destroy
add rsp, 10h
pop rbp
retn
| long long inline_mysql_rwlock_destroy_1(long long a1, double a2)
{
if ( *(_QWORD *)(a1 + 144) )
{
((void ( *)(_QWORD))PSI_server[11])(*(_QWORD *)(a1 + 144));
*(_QWORD *)(a1 + 144) = 0LL;
}
return my_rw_destroy(a1, a2);
}
| inline_mysql_rwlock_destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x90],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001fde1d
LEA RAX,[0x3bf098]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x90],0x0
LAB_001fde1d:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001f9470
ADD RSP,0x10
POP RBP
RET
|
void inline_mysql_rwlock_destroy(long param_1)
{
if (*(long *)(param_1 + 0x90) != 0) {
(**(code **)(PSI_server + 0x58))(*(int8 *)(param_1 + 0x90));
*(int8 *)(param_1 + 0x90) = 0;
}
my_rw_destroy(param_1);
return;
}
| |
22,587 | LefDefParser::defwEndBeginext() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp | int
defwEndBeginext()
{
if (!defwFile)
return DEFW_UNINITIALIZED;
if (!defwDidInit)
return DEFW_BAD_ORDER;
if (defwState != DEFW_BEGINEXT_START &&
defwState != DEFW_BEGINEXT)
return DEFW_BAD_ORDER;
fprintf(defwFile, ";\nENDEXT\n\n");
defwState = DEFW_BEGINEXT_END;
defwLines++;
return DEFW_OK;
} | O0 | cpp | LefDefParser::defwEndBeginext():
pushq %rax
leaq 0x90a0(%rip), %rax # 0x2b158
cmpq $0x0, (%rax)
jne 0x220c8
movl $0x1, 0x4(%rsp)
jmp 0x22142
leaq 0x90a5(%rip), %rax # 0x2b174
cmpl $0x0, (%rax)
jne 0x220de
movl $0x2, 0x4(%rsp)
jmp 0x22142
leaq 0x907f(%rip), %rax # 0x2b164
cmpl $0x60, (%rax)
je 0x22100
leaq 0x9073(%rip), %rax # 0x2b164
cmpl $0x61, (%rax)
je 0x22100
movl $0x2, 0x4(%rsp)
jmp 0x22142
leaq 0x9051(%rip), %rax # 0x2b158
movq (%rax), %rdi
leaq 0x3297(%rip), %rsi # 0x253a8
movb $0x0, %al
callq 0x10f0
leaq 0x9045(%rip), %rax # 0x2b164
movl $0x62, (%rax)
leaq 0x9034(%rip), %rax # 0x2b160
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x9028(%rip), %rax # 0x2b160
movl %ecx, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopl (%rax,%rax)
| _ZN12LefDefParser15defwEndBeginextEv:
push rax
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
cmp qword ptr [rax], 0
jnz short loc_220C8
mov [rsp+8+var_4], 1
jmp short loc_22142
loc_220C8:
lea rax, _ZN12LefDefParser11defwDidInitE; LefDefParser::defwDidInit
cmp dword ptr [rax], 0
jnz short loc_220DE
mov [rsp+8+var_4], 2
jmp short loc_22142
loc_220DE:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 60h ; '`'
jz short loc_22100
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 61h ; 'a'
jz short loc_22100
mov [rsp+8+var_4], 2
jmp short loc_22142
loc_22100:
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
lea rsi, aEndext; ";\nENDEXT\n\n"
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov dword ptr [rax], 62h ; 'b'
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov [rax], ecx
mov [rsp+8+var_4], 0
loc_22142:
mov eax, [rsp+8+var_4]
pop rcx
retn
| long long LefDefParser::defwEndBeginext(LefDefParser *this)
{
if ( LefDefParser::defwFile )
{
if ( LefDefParser::defwDidInit )
{
if ( LefDefParser::defwState == 96 || LefDefParser::defwState == 97 )
{
fprintf(LefDefParser::defwFile, ";\nENDEXT\n\n");
LefDefParser::defwState = 98;
++LefDefParser::defwLines;
return 0;
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| defwEndBeginext:
PUSH RAX
LEA RAX,[0x12b158]
CMP qword ptr [RAX],0x0
JNZ 0x001220c8
MOV dword ptr [RSP + 0x4],0x1
JMP 0x00122142
LAB_001220c8:
LEA RAX,[0x12b174]
CMP dword ptr [RAX],0x0
JNZ 0x001220de
MOV dword ptr [RSP + 0x4],0x2
JMP 0x00122142
LAB_001220de:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x60
JZ 0x00122100
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x61
JZ 0x00122100
MOV dword ptr [RSP + 0x4],0x2
JMP 0x00122142
LAB_00122100:
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1253a8]
MOV AL,0x0
CALL 0x001010f0
LEA RAX,[0x12b164]
MOV dword ptr [RAX],0x62
LEA RAX,[0x12b160]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x12b160]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x4],0x0
LAB_00122142:
MOV EAX,dword ptr [RSP + 0x4]
POP RCX
RET
|
/* LefDefParser::defwEndBeginext() */
int4 LefDefParser::defwEndBeginext(void)
{
int4 local_4;
if (defwFile == (FILE *)0x0) {
local_4 = 1;
}
else if (defwDidInit == 0) {
local_4 = 2;
}
else if ((defwState == 0x60) || (defwState == 0x61)) {
fprintf(defwFile,";\nENDEXT\n\n");
defwState = 0x62;
defwLines = defwLines + 1;
local_4 = 0;
}
else {
local_4 = 2;
}
return local_4;
}
| |
22,588 | Balloc | eloqsql/strings/dtoa.c | static Bigint *Balloc(int k, Stack_alloc *alloc)
{
Bigint *rv;
DBUG_ASSERT(k <= Kmax);
if (k <= Kmax && alloc->freelist[k])
{
rv= alloc->freelist[k];
alloc->freelist[k]= rv->p.next;
}
else
{
int x, len;
x= 1 << k;
len= MY_ALIGN(sizeof(Bigint) + x * sizeof(ULong), SIZEOF_CHARP);
if (alloc->free + len <= alloc->end)
{
rv= (Bigint*) alloc->free;
alloc->free+= len;
}
else
rv= (Bigint*) malloc(len);
rv->k= k;
rv->maxwds= x;
}
rv->sign= rv->wds= 0;
rv->p.x= (ULong*) (rv + 1);
return rv;
} | O3 | c | Balloc:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
cmpl $0xf, %edi
jg 0x5701d
movslq %ebx, %rcx
movq 0x18(%rsi,%rcx,8), %rax
testq %rax, %rax
je 0x5701d
movq (%rax), %rdx
movq %rdx, 0x18(%rsi,%rcx,8)
jmp 0x57058
movl $0x1, %r14d
movl %ebx, %ecx
shll %cl, %r14d
movl $0x4, %edx
shll %cl, %edx
addl $0x1f, %edx
andl $-0x8, %edx
movq 0x8(%rsi), %rax
movslq %edx, %rdi
leaq (%rax,%rdi), %rcx
cmpq 0x10(%rsi), %rcx
jbe 0x5704d
callq 0x243b0
jmp 0x57051
movq %rcx, 0x8(%rsi)
movl %ebx, 0x8(%rax)
movl %r14d, 0xc(%rax)
movq $0x0, 0x10(%rax)
leaq 0x18(%rax), %rcx
movq %rcx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
| Balloc:
push rbp
mov rbp, rsp
push r14
push rbx
mov ebx, edi
cmp edi, 0Fh
jg short loc_5701D
movsxd rcx, ebx
mov rax, [rsi+rcx*8+18h]
test rax, rax
jz short loc_5701D
mov rdx, [rax]
mov [rsi+rcx*8+18h], rdx
jmp short loc_57058
loc_5701D:
mov r14d, 1
mov ecx, ebx
shl r14d, cl
mov edx, 4
shl edx, cl
add edx, 1Fh
and edx, 0FFFFFFF8h
mov rax, [rsi+8]
movsxd rdi, edx
lea rcx, [rax+rdi]
cmp rcx, [rsi+10h]
jbe short loc_5704D
call _malloc
jmp short loc_57051
loc_5704D:
mov [rsi+8], rcx
loc_57051:
mov [rax+8], ebx
mov [rax+0Ch], r14d
loc_57058:
mov qword ptr [rax+10h], 0
lea rcx, [rax+18h]
mov [rax], rcx
pop rbx
pop r14
pop rbp
retn
| long long Balloc(int a1, long long a2)
{
long long result; // rax
long long v4; // rdi
if ( a1 <= 15 && (result = *(_QWORD *)(a2 + 8LL * a1 + 24)) != 0 )
{
*(_QWORD *)(a2 + 8LL * a1 + 24) = *(_QWORD *)result;
}
else
{
result = *(_QWORD *)(a2 + 8);
v4 = (int)(((4 << a1) + 31) & 0xFFFFFFF8);
if ( (unsigned long long)(result + v4) <= *(_QWORD *)(a2 + 16) )
*(_QWORD *)(a2 + 8) = result + v4;
else
result = malloc(v4);
*(_DWORD *)(result + 8) = a1;
*(_DWORD *)(result + 12) = 1 << a1;
}
*(_QWORD *)(result + 16) = 0LL;
*(_QWORD *)result = result + 24;
return result;
}
| Balloc:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV EBX,EDI
CMP EDI,0xf
JG 0x0015701d
MOVSXD RCX,EBX
MOV RAX,qword ptr [RSI + RCX*0x8 + 0x18]
TEST RAX,RAX
JZ 0x0015701d
MOV RDX,qword ptr [RAX]
MOV qword ptr [RSI + RCX*0x8 + 0x18],RDX
JMP 0x00157058
LAB_0015701d:
MOV R14D,0x1
MOV ECX,EBX
SHL R14D,CL
MOV EDX,0x4
SHL EDX,CL
ADD EDX,0x1f
AND EDX,0xfffffff8
MOV RAX,qword ptr [RSI + 0x8]
MOVSXD RDI,EDX
LEA RCX,[RAX + RDI*0x1]
CMP RCX,qword ptr [RSI + 0x10]
JBE 0x0015704d
CALL 0x001243b0
JMP 0x00157051
LAB_0015704d:
MOV qword ptr [RSI + 0x8],RCX
LAB_00157051:
MOV dword ptr [RAX + 0x8],EBX
MOV dword ptr [RAX + 0xc],R14D
LAB_00157058:
MOV qword ptr [RAX + 0x10],0x0
LEA RCX,[RAX + 0x18]
MOV qword ptr [RAX],RCX
POP RBX
POP R14
POP RBP
RET
|
void Balloc(int param_1,long param_2)
{
ulong uVar1;
long *plVar2;
size_t __size;
if (param_1 < 0x10) {
plVar2 = *(long **)(param_2 + 0x18 + (long)param_1 * 8);
if (plVar2 != (long *)0x0) {
*(long *)(param_2 + 0x18 + (long)param_1 * 8) = *plVar2;
goto LAB_00157058;
}
}
plVar2 = *(long **)(param_2 + 8);
__size = (size_t)(int)((4 << ((byte)param_1 & 0x1f)) + 0x1fU & 0xfffffff8);
uVar1 = (long)plVar2 + __size;
if (*(ulong *)(param_2 + 0x10) < uVar1) {
plVar2 = (long *)malloc(__size);
}
else {
*(ulong *)(param_2 + 8) = uVar1;
}
*(int *)(plVar2 + 1) = param_1;
*(int *)((long)plVar2 + 0xc) = 1 << ((byte)param_1 & 0x1f);
LAB_00157058:
plVar2[2] = 0;
*plVar2 = (long)(plVar2 + 3);
return;
}
| |
22,589 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, unsigned long) | monkey531[P]llama/common/./json.hpp | explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
noexcept(std::is_nothrow_move_constructible<IteratorType>::value
&& std::is_nothrow_default_constructible<string_type>::value)
: anchor(std::move(it))
, array_index(array_index_)
{} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, unsigned long):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
addq $0x30, %rax
movq %rax, 0x8(%rsp)
leaq 0x1f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x52fe0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x11c8ea(%rip), %rsi # 0x1e22ee
callq 0x5b620
jmp 0xc5a0b
leaq 0x1f(%rsp), %rdi
callq 0x533e0
movq (%rsp), %rdi
addq $0x50, %rdi
callq 0x525d0
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x5bb40
nop
| _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESH_m:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_18], rdx
mov rax, [rsp+38h+var_8]
mov [rsp+38h+var_38], rax
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
mov rcx, [rsp+38h+var_18]
mov [rax+20h], rcx
mov qword ptr [rax+28h], 0
add rax, 30h ; '0'
mov [rsp+38h+var_30], rax
lea rdi, [rsp+38h+var_19]
mov [rsp+38h+var_28], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+38h+var_30]
mov rdx, [rsp+38h+var_28]
lea rsi, aMinExp0+0Ah; "0"
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_C5A0B:
lea rdi, [rsp+38h+var_19]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rdi, [rsp+38h+var_38]
add rdi, 50h ; 'P'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
add rsp, 38h
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::iteration_proxy_value(
long long a1,
_OWORD *a2,
long long a3)
{
__int128 v3; // xmm0
char v5; // [rsp+1Fh] [rbp-19h] BYREF
long long v6; // [rsp+20h] [rbp-18h]
_OWORD *v7; // [rsp+28h] [rbp-10h]
long long v8; // [rsp+30h] [rbp-8h]
v8 = a1;
v7 = a2;
v6 = a3;
v3 = *a2;
*(_OWORD *)(a1 + 16) = a2[1];
*(_OWORD *)a1 = v3;
*(_QWORD *)(a1 + 32) = v6;
*(_QWORD *)(a1 + 40) = 0LL;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(a1 + 48, (long long)"0", (long long)&v5);
std::allocator<char>::~allocator(&v5);
return std::string::basic_string(a1 + 80);
}
| iteration_proxy_value:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP],RAX
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x20],RCX
MOV qword ptr [RAX + 0x28],0x0
ADD RAX,0x30
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x1f]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00152fe0
MOV RDI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001c59fd:
LEA RSI,[0x2e22ee]
CALL 0x0015b620
JMP 0x001c5a0b
LAB_001c5a0b:
LEA RDI,[RSP + 0x1f]
CALL 0x001533e0
MOV RDI,qword ptr [RSP]
ADD RDI,0x50
CALL 0x001525d0
ADD RSP,0x38
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >
>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >, unsigned long) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::iteration_proxy_value
(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this,int8 *param_2,int8 param_3)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
allocator local_19;
int8 local_18;
int8 *local_10;
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*local_8;
uVar1 = *param_2;
uVar2 = param_2[1];
uVar3 = param_2[3];
*(int8 *)(this + 0x10) = param_2[2];
*(int8 *)(this + 0x18) = uVar3;
*(int8 *)this = uVar1;
*(int8 *)(this + 8) = uVar2;
*(int8 *)(this + 0x20) = param_3;
*(int8 *)(this + 0x28) = 0;
local_18 = param_3;
local_10 = param_2;
local_8 = this;
std::allocator<char>::allocator();
/* try { // try from 001c59fd to 001c5a08 has its CatchHandler @ 001c5a27 */
std::__cxx11::string::string<std::allocator<char>>((string *)(this + 0x30),"0",&local_19);
std::allocator<char>::~allocator((allocator<char> *)&local_19);
std::__cxx11::string::string((string *)(this + 0x50));
return;
}
| |
22,590 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, unsigned long) | monkey531[P]llama/common/./json.hpp | explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
noexcept(std::is_nothrow_move_constructible<IteratorType>::value
&& std::is_nothrow_default_constructible<string_type>::value)
: anchor(std::move(it))
, array_index(array_index_)
{} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, unsigned long):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
leaq 0x6e80f(%rip), %rsi # 0xb9a9a
leaq 0x6e809(%rip), %rdx # 0xb9a9b
callq 0x20c8e
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x2041f
nop
| _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESI_m:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov [rdi+20h], rdx
mov qword ptr [rdi+28h], 0
add rdi, 30h ; '0'
lea rax, [rbx+40h]
mov [rbx+30h], rax
lea rsi, aMinExp0+0Ah; "0"
lea rdx, aMinExp0+0Bh; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rax, [rbx+60h]
mov [rbx+50h], rax
mov qword ptr [rbx+58h], 0
mov byte ptr [rbx+60h], 0
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::iteration_proxy_value(
long long a1,
__int128 *a2,
long long a3)
{
__int128 v3; // xmm0
long long result; // rax
v3 = *a2;
*(_OWORD *)(a1 + 16) = a2[1];
*(_OWORD *)a1 = v3;
*(_QWORD *)(a1 + 32) = a3;
*(_QWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 48) = a1 + 64;
std::string::_M_construct<char const*>((_QWORD *)(a1 + 48), "0", (long long)"");
result = a1 + 96;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
return result;
}
| iteration_proxy_value:
PUSH RBX
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x20],RDX
MOV qword ptr [RDI + 0x28],0x0
ADD RDI,0x30
LEA RAX,[RBX + 0x40]
MOV qword ptr [RBX + 0x30],RAX
LAB_0014b284:
LEA RSI,[0x1b9a9a]
LEA RDX,[0x1b9a9b]
CALL 0x00120c8e
LEA RAX,[RBX + 0x60]
MOV qword ptr [RBX + 0x50],RAX
MOV qword ptr [RBX + 0x58],0x0
MOV byte ptr [RBX + 0x60],0x0
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>
>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>, unsigned long) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::iteration_proxy_value
(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*this,int4 *param_2,int8 param_3)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
uVar1 = *param_2;
uVar2 = param_2[1];
uVar3 = param_2[2];
uVar4 = param_2[3];
uVar5 = param_2[5];
uVar6 = param_2[6];
uVar7 = param_2[7];
*(int4 *)(this + 0x10) = param_2[4];
*(int4 *)(this + 0x14) = uVar5;
*(int4 *)(this + 0x18) = uVar6;
*(int4 *)(this + 0x1c) = uVar7;
*(int4 *)this = uVar1;
*(int4 *)(this + 4) = uVar2;
*(int4 *)(this + 8) = uVar3;
*(int4 *)(this + 0xc) = uVar4;
*(int8 *)(this + 0x20) = param_3;
*(int8 *)(this + 0x28) = 0;
*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
**)(this + 0x30) = this + 0x40;
/* try { // try from 0014b284 to 0014b296 has its CatchHandler @ 0014b2ad */
std::__cxx11::string::_M_construct<char_const*>(this + 0x30,"0","");
*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
)0x0;
return;
}
| |
22,591 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, unsigned long) | monkey531[P]llama/common/./json.hpp | explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
noexcept(std::is_nothrow_move_constructible<IteratorType>::value
&& std::is_nothrow_default_constructible<string_type>::value)
: anchor(std::move(it))
, array_index(array_index_)
{} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, unsigned long):
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x5ac71(%rip), %rsi # 0x9aac5
leaq 0xf(%rsp), %rdx
callq 0x255a4
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x24faa
| _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESH_m:
push rbx
sub rsp, 10h
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov [rdi+20h], rdx
and qword ptr [rdi+28h], 0
add rdi, 30h ; '0'
lea rsi, aMinExp0+0Ah; "0"
lea rdx, [rsp+18h+var_9]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rbx+60h]
mov [rbx+50h], rax
and qword ptr [rbx+58h], 0
mov byte ptr [rbx+60h], 0
add rsp, 10h
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::iteration_proxy_value(
long long a1,
__int128 *a2,
long long a3)
{
__int128 v3; // xmm0
long long result; // rax
v3 = *a2;
*(_OWORD *)(a1 + 16) = a2[1];
*(_OWORD *)a1 = v3;
*(_QWORD *)(a1 + 32) = a3;
*(_QWORD *)(a1 + 40) = 0LL;
std::string::basic_string<std::allocator<char>>((_QWORD *)(a1 + 48), (long long)"0");
result = a1 + 96;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
return result;
}
| iteration_proxy_value:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x20],RDX
AND qword ptr [RDI + 0x28],0x0
ADD RDI,0x30
LAB_0013fe4d:
LEA RSI,[0x19aac5]
LEA RDX,[RSP + 0xf]
CALL 0x001255a4
LEA RAX,[RBX + 0x60]
MOV qword ptr [RBX + 0x50],RAX
AND qword ptr [RBX + 0x58],0x0
MOV byte ptr [RBX + 0x60],0x0
ADD RSP,0x10
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >
>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >, unsigned long) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::iteration_proxy_value
(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this,int8 *param_2,int8 param_3)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
allocator local_9;
uVar1 = *param_2;
uVar2 = param_2[1];
uVar3 = param_2[3];
*(int8 *)(this + 0x10) = param_2[2];
*(int8 *)(this + 0x18) = uVar3;
*(int8 *)this = uVar1;
*(int8 *)(this + 8) = uVar2;
*(int8 *)(this + 0x20) = param_3;
*(int8 *)(this + 0x28) = 0;
/* try { // try from 0013fe4d to 0013fe5d has its CatchHandler @ 0013fe75 */
std::__cxx11::string::string<std::allocator<char>>((string *)(this + 0x30),"0",&local_9);
*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
)0x0;
return;
}
| |
22,592 | sp_get_linestring_mbr | eloqsql/storage/myisam/sp_key.c | static int sp_get_linestring_mbr(uchar *(*wkb), uchar *end, uint n_dims,
uchar byte_order, double *mbr)
{
uint n_points;
n_points = uint4korr(*wkb);
(*wkb) += 4;
for (; n_points > 0; --n_points)
{
/* Add next point to mbr */
if (sp_add_point_to_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
return 0;
} | O3 | c | sp_get_linestring_mbr:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movl (%rax), %ecx
addq $0x4, %rax
movq %rax, (%rdi)
testl %ecx, %ecx
je 0x48a8e
addq $-0x8, %rsi
movb $0x1, %r8b
xorl %r9d, %r9d
movq (%rdi), %rax
cmpq %rsi, %rax
ja 0x48a87
movsd (%rax), %xmm0
addq $0x8, %rax
movq %rax, (%rdi)
movsd (%rdx,%r9), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x48a5a
movsd %xmm0, (%rdx,%r9)
ucomisd 0x8(%rdx,%r9), %xmm0
jbe 0x48a6d
orq $0x8, %r9
movsd %xmm0, (%rdx,%r9)
movl $0x10, %r9d
xorl %eax, %eax
testb $0x1, %r8b
movl $0x0, %r8d
jne 0x48a35
decl %ecx
jne 0x48a2f
jmp 0x48a90
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x48a90
xorl %eax, %eax
popq %rbp
retq
| sp_get_linestring_mbr:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov ecx, [rax]
add rax, 4
mov [rdi], rax
test ecx, ecx
jz short loc_48A8E
add rsi, 0FFFFFFFFFFFFFFF8h
loc_48A2F:
mov r8b, 1
xor r9d, r9d
loc_48A35:
mov rax, [rdi]
cmp rax, rsi
ja short loc_48A87
movsd xmm0, qword ptr [rax]
add rax, 8
mov [rdi], rax
movsd xmm1, qword ptr [rdx+r9]
ucomisd xmm1, xmm0
jbe short loc_48A5A
movsd qword ptr [rdx+r9], xmm0
loc_48A5A:
ucomisd xmm0, qword ptr [rdx+r9+8]
jbe short loc_48A6D
or r9, 8
movsd qword ptr [rdx+r9], xmm0
loc_48A6D:
mov r9d, 10h
xor eax, eax
test r8b, 1
mov r8d, 0
jnz short loc_48A35
dec ecx
jnz short loc_48A2F
jmp short loc_48A90
loc_48A87:
mov eax, 0FFFFFFFFh
jmp short loc_48A90
loc_48A8E:
xor eax, eax
loc_48A90:
pop rbp
retn
| long long sp_get_linestring_mbr(double **a1, long long a2, long long a3)
{
int v3; // ecx
unsigned long long v4; // rsi
char v5; // r8
long long v6; // r9
double *v7; // rax
double v8; // xmm0_8
long long result; // rax
bool v10; // zf
v3 = *(_DWORD *)*a1;
*a1 = (double *)((char *)*a1 + 4);
if ( !v3 )
return 0LL;
v4 = a2 - 8;
while ( 2 )
{
v5 = 1;
v6 = 0LL;
do
{
v7 = *a1;
if ( (unsigned long long)*a1 > v4 )
return 0xFFFFFFFFLL;
v8 = *v7;
*a1 = v7 + 1;
if ( *(double *)(a3 + v6) > v8 )
*(double *)(a3 + v6) = v8;
if ( v8 > *(double *)(a3 + v6 + 8) )
*(double *)(a3 + (v6 | 8)) = v8;
v6 = 16LL;
result = 0LL;
v10 = (v5 & 1) == 0;
v5 = 0;
}
while ( !v10 );
if ( --v3 )
continue;
break;
}
return result;
}
| sp_get_linestring_mbr:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV ECX,dword ptr [RAX]
ADD RAX,0x4
MOV qword ptr [RDI],RAX
TEST ECX,ECX
JZ 0x00148a8e
ADD RSI,-0x8
LAB_00148a2f:
MOV R8B,0x1
XOR R9D,R9D
LAB_00148a35:
MOV RAX,qword ptr [RDI]
CMP RAX,RSI
JA 0x00148a87
MOVSD XMM0,qword ptr [RAX]
ADD RAX,0x8
MOV qword ptr [RDI],RAX
MOVSD XMM1,qword ptr [RDX + R9*0x1]
UCOMISD XMM1,XMM0
JBE 0x00148a5a
MOVSD qword ptr [RDX + R9*0x1],XMM0
LAB_00148a5a:
UCOMISD XMM0,qword ptr [RDX + R9*0x1 + 0x8]
JBE 0x00148a6d
OR R9,0x8
MOVSD qword ptr [RDX + R9*0x1],XMM0
LAB_00148a6d:
MOV R9D,0x10
XOR EAX,EAX
TEST R8B,0x1
MOV R8D,0x0
JNZ 0x00148a35
DEC ECX
JNZ 0x00148a2f
JMP 0x00148a90
LAB_00148a87:
MOV EAX,0xffffffff
JMP 0x00148a90
LAB_00148a8e:
XOR EAX,EAX
LAB_00148a90:
POP RBP
RET
|
int8 sp_get_linestring_mbr(int8 *param_1,long param_2,long param_3)
{
double dVar1;
double *pdVar2;
bool bVar3;
int iVar4;
bool bVar5;
ulong uVar6;
iVar4 = *(int *)*param_1;
*param_1 = (int *)*param_1 + 1;
if (iVar4 != 0) {
do {
uVar6 = 0;
bVar3 = true;
do {
bVar5 = bVar3;
pdVar2 = (double *)*param_1;
if ((double *)(param_2 + -8) < pdVar2) {
return 0xffffffff;
}
dVar1 = *pdVar2;
*param_1 = pdVar2 + 1;
if (dVar1 < *(double *)(param_3 + uVar6)) {
*(double *)(param_3 + uVar6) = dVar1;
}
pdVar2 = (double *)(param_3 + 8 + uVar6);
if (*pdVar2 <= dVar1 && dVar1 != *pdVar2) {
*(double *)(param_3 + (uVar6 | 8)) = dVar1;
}
uVar6 = 0x10;
bVar3 = false;
} while (bVar5);
iVar4 = iVar4 + -1;
} while (iVar4 != 0);
}
return 0;
}
| |
22,593 | plutovg_matrix_rotate | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-matrix.c | void plutovg_matrix_rotate(plutovg_matrix_t* matrix, float angle)
{
plutovg_matrix_t m;
plutovg_matrix_init_rotate(&m, angle);
plutovg_matrix_multiply(matrix, &m, matrix);
} | O1 | c | plutovg_matrix_rotate:
pushq %rbx
subq $0x20, %rsp
movss %xmm0, (%rsp)
movq %rdi, %rbx
callq 0xa270
movss %xmm0, 0x4(%rsp)
movss (%rsp), %xmm0
callq 0xa2b0
movaps 0x1b2a4(%rip), %xmm1 # 0x43100
xorps %xmm0, %xmm1
leaq 0x8(%rsp), %rsi
movss 0x4(%rsp), %xmm2
movss %xmm2, (%rsi)
movss %xmm0, 0x4(%rsi)
movss %xmm1, 0x8(%rsi)
movss %xmm2, 0xc(%rsi)
movq $0x0, 0x10(%rsi)
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x27d51
addq $0x20, %rsp
popq %rbx
retq
| plutovg_matrix_rotate:
push rbx
sub rsp, 20h
movss [rsp+28h+var_28], xmm0
mov rbx, rdi
call _cosf
movss [rsp+28h+var_24], xmm0
movss xmm0, [rsp+28h+var_28]
call _sinf
movaps xmm1, cs:xmmword_43100
xorps xmm1, xmm0
lea rsi, [rsp+28h+var_20]
movss xmm2, [rsp+28h+var_24]
movss dword ptr [rsi], xmm2
movss dword ptr [rsi+4], xmm0
movss dword ptr [rsi+8], xmm1
movss dword ptr [rsi+0Ch], xmm2
mov qword ptr [rsi+10h], 0
mov rdi, rbx
mov rdx, rbx
call plutovg_matrix_multiply
add rsp, 20h
pop rbx
retn
| void plutovg_matrix_rotate(float *a1, float a2)
{
float v3; // [rsp+8h] [rbp-20h] BYREF
float v4; // [rsp+Ch] [rbp-1Ch]
float v5; // [rsp+10h] [rbp-18h]
float v6; // [rsp+14h] [rbp-14h]
long long v7; // [rsp+18h] [rbp-10h]
v3 = cosf();
v4 = sinf(a2);
v5 = -v4;
v6 = v3;
v7 = 0LL;
plutovg_matrix_multiply(a1, &v3, a1);
}
| plutovg_matrix_rotate:
PUSH RBX
SUB RSP,0x20
MOVSS dword ptr [RSP],XMM0
MOV RBX,RDI
CALL 0x0010a270
MOVSS dword ptr [RSP + 0x4],XMM0
MOVSS XMM0,dword ptr [RSP]
CALL 0x0010a2b0
MOVAPS XMM1,xmmword ptr [0x00143100]
XORPS XMM1,XMM0
LEA RSI,[RSP + 0x8]
MOVSS XMM2,dword ptr [RSP + 0x4]
MOVSS dword ptr [RSI],XMM2
MOVSS dword ptr [RSI + 0x4],XMM0
MOVSS dword ptr [RSI + 0x8],XMM1
MOVSS dword ptr [RSI + 0xc],XMM2
MOV qword ptr [RSI + 0x10],0x0
MOV RDI,RBX
MOV RDX,RBX
CALL 0x00127d51
ADD RSP,0x20
POP RBX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void plutovg_matrix_rotate(float param_1,int8 param_2)
{
float fVar1;
float local_20;
float local_1c;
uint local_18;
float local_14;
int8 local_10;
fVar1 = cosf(param_1);
local_1c = sinf(param_1);
local_18 = _DAT_00143100 ^ (uint)local_1c;
local_10 = 0;
local_20 = fVar1;
local_14 = fVar1;
plutovg_matrix_multiply(param_2,&local_20,param_2);
return;
}
| |
22,594 | my_well_formed_char_length_ucs2 | eloqsql/strings/ctype-ucs2.c | static size_t
my_well_formed_char_length_ucs2(CHARSET_INFO *cs __attribute__((unused)),
const char *b, const char *e,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t length= e - b;
if (nchars * 2 <= length)
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= b + (nchars * 2);
return nchars;
}
if (length % 2)
{
status->m_well_formed_error_pos= status->m_source_end_pos= e - 1;
}
else
{
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= e;
}
return length / 2;
} | O0 | c | my_well_formed_char_length_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
cmpq -0x38(%rbp), %rax
ja 0x62bff
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
shlq %rax
addq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x62c48
movq -0x38(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x62c26
movq -0x20(%rbp), %rcx
addq $-0x1, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x62c3d
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| my_well_formed_char_length_ucs2:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
shl rax, 1
cmp rax, [rbp+var_38]
ja short loc_62BFF
mov rax, [rbp+var_30]
mov qword ptr [rax+8], 0
mov rcx, [rbp+var_18]
mov rax, [rbp+var_28]
shl rax, 1
add rcx, rax
mov rax, [rbp+var_30]
mov [rax], rcx
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_62C48
loc_62BFF:
mov rax, [rbp+var_38]
and rax, 1
cmp rax, 0
jz short loc_62C26
mov rcx, [rbp+var_20]
add rcx, 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_30]
mov [rax], rcx
mov rax, [rbp+var_30]
mov [rax+8], rcx
jmp short loc_62C3D
loc_62C26:
mov rax, [rbp+var_30]
mov qword ptr [rax+8], 0
mov rcx, [rbp+var_20]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_62C3D:
mov rax, [rbp+var_38]
shr rax, 1
mov [rbp+var_8], rax
loc_62C48:
mov rax, [rbp+var_8]
pop rbp
retn
| unsigned long long my_well_formed_char_length_ucs2(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
unsigned long long v6; // [rsp+0h] [rbp-38h]
v6 = a3 - a2;
if ( 2 * a4 > (unsigned long long)(a3 - a2) )
{
if ( (v6 & 1) != 0 )
{
*a5 = a3 - 1;
a5[1] = a3 - 1;
}
else
{
a5[1] = 0LL;
*a5 = a3;
}
return v6 >> 1;
}
else
{
a5[1] = 0LL;
*a5 = 2 * a4 + a2;
return a4;
}
}
| my_well_formed_char_length_ucs2:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x1
CMP RAX,qword ptr [RBP + -0x38]
JA 0x00162bff
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],0x0
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x1
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00162c48
LAB_00162bff:
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x1
CMP RAX,0x0
JZ 0x00162c26
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,-0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x00162c3d
LAB_00162c26:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],0x0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00162c3d:
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
LAB_00162c48:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong my_well_formed_char_length_ucs2
(int8 param_1,long param_2,long param_3,ulong param_4,long *param_5)
{
ulong local_10;
local_10 = param_3 - param_2;
if (param_4 * 2 < local_10 || param_4 * 2 - local_10 == 0) {
param_5[1] = 0;
*param_5 = param_2 + param_4 * 2;
local_10 = param_4;
}
else {
if ((local_10 & 1) == 0) {
param_5[1] = 0;
*param_5 = param_3;
}
else {
*param_5 = param_3 + -1;
param_5[1] = param_3 + -1;
}
local_10 = local_10 >> 1;
}
return local_10;
}
| |
22,595 | httplib::Server::write_content_with_provider(httplib::Stream&, httplib::Request const&, httplib::Response&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/examples/server/httplib.h | inline bool
Server::write_content_with_provider(Stream &strm, const Request &req,
Response &res, const std::string &boundary,
const std::string &content_type) {
auto is_shutting_down = [this]() {
return this->svr_sock_ == INVALID_SOCKET;
};
if (res.content_length_ > 0) {
if (req.ranges.empty()) {
return detail::write_content(strm, res.content_provider_, 0,
res.content_length_, is_shutting_down);
} else if (req.ranges.size() == 1) {
auto offset_and_length = detail::get_range_offset_and_length(
req.ranges[0], res.content_length_);
return detail::write_content(strm, res.content_provider_,
offset_and_length.first,
offset_and_length.second, is_shutting_down);
} else {
return detail::write_multipart_ranges_data(
strm, req, res, boundary, content_type, res.content_length_,
is_shutting_down);
}
} else {
if (res.is_chunked_content_provider_) {
auto type = detail::encoding_type(req, res);
std::unique_ptr<detail::compressor> compressor;
if (type == detail::EncodingType::Gzip) {
#ifdef CPPHTTPLIB_ZLIB_SUPPORT
compressor = detail::make_unique<detail::gzip_compressor>();
#endif
} else if (type == detail::EncodingType::Brotli) {
#ifdef CPPHTTPLIB_BROTLI_SUPPORT
compressor = detail::make_unique<detail::brotli_compressor>();
#endif
} else {
compressor = detail::make_unique<detail::nocompressor>();
}
assert(compressor != nullptr);
return detail::write_content_chunked(strm, res.content_provider_,
is_shutting_down, *compressor);
} else {
return detail::write_content_without_length(strm, res.content_provider_,
is_shutting_down);
}
}
} | O3 | c | httplib::Server::write_content_with_provider(httplib::Stream&, httplib::Request const&, httplib::Response&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, 0x20(%rsp)
movq 0xc0(%rcx), %rcx
testq %rcx, %rcx
je 0x65751
movq %rdi, %rax
movq 0x188(%rdx), %rsi
movq 0x190(%rdx), %rdi
cmpq %rdi, %rsi
je 0x65779
subq %rsi, %rdi
cmpq $0x10, %rdi
jne 0x6579e
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
subq %rdx, %rcx
incq %rcx
addq $0xc8, %r14
leaq 0x28(%rsp), %r9
movl $0x0, (%r9)
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x65794
cmpb $0x1, 0x108(%r14)
jne 0x657d6
movq %rdx, %rdi
movq %r14, %rsi
callq 0x6585e
decl %eax
cmpl $0x2, %eax
jae 0x657fb
xorl %r15d, %r15d
jmp 0x65812
addq $0xc8, %r14
leaq 0x28(%rsp), %r9
movl $0x0, (%r9)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %r8
callq 0x671c9
jmp 0x657ed
movq %rbx, 0x28(%rsp)
movq %r14, 0x30(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rax, 0x10(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rdx, %rdi
movq %r8, %rsi
movq %r9, %rdx
movq %rbx, %r8
movq %rbx, %r9
callq 0x67739
jmp 0x657ed
addq $0xc8, %r14
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x670a3
movl %eax, %ebx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x1fab0
movq %rax, %r15
leaq 0x13c951(%rip), %rax # 0x1a2160
movq %rax, (%r15)
addq $0xc8, %r14
leaq 0x28(%rsp), %r8
movl $0x0, (%r8)
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x67bb9
movl %eax, %ebx
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
jmp 0x657ef
movq %rax, %rbx
testq %r15, %r15
je 0x65856
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x20380
| _ZN7httplib6Server27write_content_with_providerERNS_6StreamERKNS_7RequestERNS_8ResponseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESF_:
push r15
push r14
push rbx
sub rsp, 40h
mov r14, rcx
mov rbx, rsi
mov [rsp+58h+var_38], rdi
mov rcx, [rcx+0C0h]; int
test rcx, rcx
jz short loc_65751
mov rax, rdi
mov rsi, [rdx+188h]
mov rdi, [rdx+190h]
cmp rsi, rdi
jz short loc_65779
sub rdi, rsi
cmp rdi, 10h
jnz short loc_6579E
mov rdx, [rsi]; int
mov rcx, [rsi+8]
sub rcx, rdx
inc rcx
add r14, 0C8h
lea r9, [rsp+58h+var_30]; int
mov dword ptr [r9], 0
mov rdi, rbx
mov rsi, r14
jmp short loc_65794
loc_65751:
cmp byte ptr [r14+108h], 1
jnz short loc_657D6
mov rdi, rdx; int
mov rsi, r14; int
call _ZN7httplib6detail13encoding_typeERKNS_7RequestERKNS_8ResponseE; httplib::detail::encoding_type(httplib::Request const&,httplib::Response const&)
dec eax
cmp eax, 2
jnb loc_657FB
xor r15d, r15d
jmp loc_65812
loc_65779:
add r14, 0C8h
lea r9, [rsp+58h+var_30]
mov dword ptr [r9], 0
mov rdi, rbx
mov rsi, r14
xor edx, edx
loc_65794:
mov r8, rax
call _ZN7httplib6detail13write_contentIZNS_6Server27write_content_with_providerERNS_6StreamERKNS_7RequestERNS_8ResponseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESH_EUlvE_EEbS4_RKSt8functionIFbmmRNS_8DataSinkEEEmmT_RNS_5ErrorE; httplib::detail::write_content<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(httplib::Stream &,std::function<bool ()(ulong,ulong,httplib::DataSink &)> const&,ulong,ulong,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1},httplib::Error &)
jmp short loc_657ED
loc_6579E:
mov [rsp+58h+var_30], rbx
mov [rsp+58h+var_30+8], r14
lea rax, [rsp+58h+var_38]
mov [rsp+58h+var_20], rax
mov [rsp+58h+var_48], rax; __int64
movups xmm0, xmmword ptr [rsp+58h+var_30]
movups xmmword ptr [rsp+58h+var_58], xmm0; void *
mov rdi, rdx; int
mov rsi, r8; int
mov rdx, r9; int
mov r8, rbx; int
mov r9, rbx; int
call _ZN7httplib6detail29process_multipart_ranges_dataIZNS0_27write_multipart_ranges_dataIZNS_6Server27write_content_with_providerERNS_6StreamERKNS_7RequestERNS_8ResponseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESI_EUlvE_EEbS5_S8_SA_SI_SI_mRKT_EUlSI_E_ZNS2_ISJ_EEbS5_S8_SA_SI_SI_mSM_EUlSI_E0_ZNS2_ISJ_EEbS5_S8_SA_SI_SI_mSM_EUlmmE_EEbS8_SI_SI_mSK_T0_T1_; httplib::detail::process_multipart_ranges_data<httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&,ulong,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1} const&)::{lambda(std::string const&)#1},httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&,ulong,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1} const&)::{lambda(std::string const&)#2},httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&,ulong,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1} const&)::{lambda(ulong,ulong)#1}>(httplib::Request const&,std::string const&,std::string const&,ulong,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1},httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&,ulong,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1} const&)::{lambda(std::string const&)#2},httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&,ulong,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1} const&)::{lambda(ulong,ulong)#1})
jmp short loc_657ED
loc_657D6:
add r14, 0C8h
lea rdx, [rsp+58h+var_38]
mov rdi, rbx
mov rsi, r14
call _ZN7httplib6detail28write_content_without_lengthIZNS_6Server27write_content_with_providerERNS_6StreamERKNS_7RequestERNS_8ResponseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESH_EUlvE_EEbS4_RKSt8functionIFbmmRNS_8DataSinkEEERKT_; httplib::detail::write_content_without_length<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(httplib::Stream &,std::function<bool ()(ulong,ulong,httplib::DataSink &)> const&,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1} const&)
loc_657ED:
mov ebx, eax
loc_657EF:
mov eax, ebx
add rsp, 40h
pop rbx
pop r14
pop r15
retn
loc_657FB:
mov edi, 8; unsigned __int64
call __Znwm; operator new(ulong)
mov r15, rax
lea rax, off_1A2160
mov [r15], rax
loc_65812:
add r14, 0C8h
lea r8, [rsp+58h+var_30]
mov dword ptr [r8], 0
lea rdx, [rsp+58h+var_38]
mov rdi, rbx
mov rsi, r14
mov rcx, r15
call _ZN7httplib6detail21write_content_chunkedIZNS_6Server27write_content_with_providerERNS_6StreamERKNS_7RequestERNS_8ResponseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESH_EUlvE_NS0_10compressorEEEbS4_RKSt8functionIFbmmRNS_8DataSinkEEERKT_RT0_RNS_5ErrorE; httplib::detail::write_content_chunked<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1},httplib::detail::compressor>(httplib::Stream &,std::function<bool ()(ulong,ulong,httplib::DataSink &)> const&,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1} const&,httplib::detail::compressor &,httplib::Error &)
mov ebx, eax
mov rax, [r15]
mov rdi, r15
call qword ptr [rax+8]
jmp short loc_657EF
mov rbx, rax
test r15, r15
jz short loc_65856
mov rax, [r15]
mov rdi, r15
call qword ptr [rax+8]
loc_65856:
mov rdi, rbx
call __Unwind_Resume
| long long httplib::Server::write_content_with_provider(
long long a1,
void *a2,
long long a3,
long long a4,
int a5,
int a6)
{
long long v8; // rcx
char *v10; // rsi
char *v11; // rdi
long long v12; // rdx
void *v13; // rdi
long long v14; // rsi
long long v15; // r15
unsigned int v17; // ebx
void *v19; // [rsp+0h] [rbp-58h]
int v20; // [rsp+8h] [rbp-50h]
long long v21; // [rsp+10h] [rbp-48h]
long long v22; // [rsp+20h] [rbp-38h] BYREF
void *v23[2]; // [rsp+28h] [rbp-30h] BYREF
long long *v24; // [rsp+38h] [rbp-20h]
v22 = a1;
v8 = *(_QWORD *)(a4 + 192);
if ( v8 )
{
v10 = *(char **)(a3 + 392);
v11 = *(char **)(a3 + 400);
if ( v10 == v11 )
{
LODWORD(v23[0]) = 0;
v13 = a2;
v14 = a4 + 200;
v12 = 0LL;
}
else
{
if ( v11 - v10 != 16 )
{
v23[0] = a2;
v23[1] = (void *)a4;
v24 = &v22;
return (unsigned int)httplib::detail::process_multipart_ranges_data<bool httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&,unsigned long,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1} const&)::{lambda(std::string const&)#1},bool httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&,unsigned long,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1} const&)::{lambda(std::string const&)#2},bool httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&,unsigned long,httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1} const&)::{lambda(unsigned long,unsigned long)#1}>(
a3,
a5,
a6,
v8,
(int)a2,
(int)a2,
a2,
a4,
(long long)&v22);
}
v12 = *(_QWORD *)v10;
v8 = *((_QWORD *)v10 + 1) - *(_QWORD *)v10 + 1LL;
LODWORD(v23[0]) = 0;
v13 = a2;
v14 = a4 + 200;
}
return (unsigned int)httplib::detail::write_content<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(
v13,
v14,
v12,
v8,
a1);
}
if ( *(_BYTE *)(a4 + 264) != 1 )
return (unsigned int)httplib::detail::write_content_without_length<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1}>(
a2,
a4 + 200,
&v22);
if ( (unsigned int)httplib::detail::encoding_type(a3, a4, a3, 0, a5, a6, v19, v20, v21) - 1 >= 2 )
{
v15 = operator new(8uLL);
*(_QWORD *)v15 = off_1A2160;
}
else
{
v15 = 0LL;
}
LODWORD(v23[0]) = 0;
v17 = httplib::detail::write_content_chunked<httplib::Server::write_content_with_provider(httplib::Stream &,httplib::Request const&,httplib::Response &,std::string const&,std::string const&)::{lambda(void)#1},httplib::detail::compressor>(
a2,
a4 + 200,
&v22,
v15,
v23);
(*(void ( **)(long long))(*(_QWORD *)v15 + 8LL))(v15);
return v17;
}
| write_content_with_provider:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RCX
MOV RBX,RSI
MOV qword ptr [RSP + 0x20],RDI
MOV RCX,qword ptr [RCX + 0xc0]
TEST RCX,RCX
JZ 0x00165751
MOV RAX,RDI
MOV RSI,qword ptr [RDX + 0x188]
MOV RDI,qword ptr [RDX + 0x190]
CMP RSI,RDI
JZ 0x00165779
SUB RDI,RSI
CMP RDI,0x10
JNZ 0x0016579e
MOV RDX,qword ptr [RSI]
MOV RCX,qword ptr [RSI + 0x8]
SUB RCX,RDX
INC RCX
ADD R14,0xc8
LEA R9,[RSP + 0x28]
MOV dword ptr [R9],0x0
MOV RDI,RBX
MOV RSI,R14
JMP 0x00165794
LAB_00165751:
CMP byte ptr [R14 + 0x108],0x1
JNZ 0x001657d6
MOV RDI,RDX
MOV RSI,R14
CALL 0x0016585e
DEC EAX
CMP EAX,0x2
JNC 0x001657fb
XOR R15D,R15D
JMP 0x00165812
LAB_00165779:
ADD R14,0xc8
LEA R9,[RSP + 0x28]
MOV dword ptr [R9],0x0
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
LAB_00165794:
MOV R8,RAX
CALL 0x001671c9
JMP 0x001657ed
LAB_0016579e:
MOV qword ptr [RSP + 0x28],RBX
MOV qword ptr [RSP + 0x30],R14
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x28]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RDX
MOV RSI,R8
MOV RDX,R9
MOV R8,RBX
MOV R9,RBX
CALL 0x00167739
JMP 0x001657ed
LAB_001657d6:
ADD R14,0xc8
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV RSI,R14
CALL 0x001670a3
LAB_001657ed:
MOV EBX,EAX
LAB_001657ef:
MOV EAX,EBX
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
LAB_001657fb:
MOV EDI,0x8
CALL 0x0011fab0
MOV R15,RAX
LEA RAX,[0x2a2160]
MOV qword ptr [R15],RAX
LAB_00165812:
ADD R14,0xc8
LEA R8,[RSP + 0x28]
MOV dword ptr [R8],0x0
LAB_00165825:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV RSI,R14
MOV RCX,R15
CALL 0x00167bb9
LAB_00165838:
MOV EBX,EAX
MOV RAX,qword ptr [R15]
MOV RDI,R15
CALL qword ptr [RAX + 0x8]
JMP 0x001657ef
|
/* httplib::Server::write_content_with_provider(httplib::Stream&, httplib::Request const&,
httplib::Response&, std::__cxx11::string const&, std::__cxx11::string const&) */
ulong __thiscall
httplib::Server::write_content_with_provider
(Server *this,Stream *param_1,Request *param_2,Response *param_3,string *param_4,
string *param_5)
{
long *plVar1;
int4 uVar2;
int4 uVar3;
bool bVar4;
int iVar5;
int7 extraout_var;
int7 extraout_var_00;
int7 extraout_var_01;
compressor *pcVar7;
int7 extraout_var_02;
long lVar8;
long lVar9;
Server *local_38;
int8 local_30;
Response *pRStack_28;
Server **local_20;
uint uVar6;
lVar8 = *(long *)(param_3 + 0xc0);
local_38 = this;
if (lVar8 == 0) {
if (param_3[0x108] == (Response)0x1) {
iVar5 = detail::encoding_type(param_2,param_3);
if (iVar5 - 1U < 2) {
pcVar7 = (compressor *)0x0;
}
else {
pcVar7 = (compressor *)operator_new(8);
*(int ***)pcVar7 = &PTR__compressor_002a2160;
}
local_30 = (Stream *)((ulong)local_30._4_4_ << 0x20);
/* try { // try from 00165825 to 00165837 has its CatchHandler @ 00165845 */
bVar4 = detail::
write_content_chunked<httplib::Server::write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)::_lambda()_1_,httplib::detail::compressor>
(param_1,param_3 + 200,(_lambda___1_ *)&local_38,pcVar7,(Error *)&local_30);
(**(code **)(*(long *)pcVar7 + 8))(pcVar7);
return CONCAT71(extraout_var_02,bVar4) & 0xffffffff;
}
bVar4 = detail::
write_content_without_length<httplib::Server::write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)::_lambda()_1_>
(param_1,param_3 + 200,(_lambda___1_ *)&local_38);
uVar6 = (uint)CONCAT71(extraout_var_01,bVar4);
}
else {
plVar1 = *(long **)(param_2 + 0x188);
if (plVar1 == *(long **)(param_2 + 400)) {
lVar9 = 0;
}
else {
if ((long)*(long **)(param_2 + 400) - (long)plVar1 != 0x10) {
local_20 = &local_38;
local_30._0_4_ = SUB84(param_1,0);
pRStack_28._0_4_ = SUB84(param_3,0);
uVar2 = (int4)local_30;
local_30 = param_1;
uVar3 = pRStack_28._0_4_;
pRStack_28 = param_3;
bVar4 = detail::
process_multipart_ranges_data<httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)::_lambda()_1_>(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&,unsigned_long,httplib::Server::write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)::_lambda()_1_const&)::_lambda(std::__cxx11::string_const&)_1_,httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)::_lambda()_1_>(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&,unsigned_long,httplib::Server::write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)::_lambda()_1_const&)::_lambda(std::__cxx11::string_const&)_2_,httplib::detail::write_multipart_ranges_data<httplib::Server::write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)::_lambda()_1_>(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&,unsigned_long,httplib::Server::write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)::_lambda()_1_const&)::_lambda(unsigned_long,unsigned_long)_1_>
(param_2,param_4,param_5,lVar8,param_1,param_1,uVar2,uVar3,local_20);
uVar6 = (uint)CONCAT71(extraout_var_00,bVar4);
goto LAB_001657ed;
}
lVar9 = *plVar1;
lVar8 = (plVar1[1] - lVar9) + 1;
}
local_30 = (Stream *)((ulong)local_30 & 0xffffffff00000000);
bVar4 = detail::
write_content<httplib::Server::write_content_with_provider(httplib::Stream&,httplib::Request_const&,httplib::Response&,std::__cxx11::string_const&,std::__cxx11::string_const&)::_lambda()_1_>
(param_1,param_3 + 200,lVar9,lVar8,this);
uVar6 = (uint)CONCAT71(extraout_var,bVar4);
}
LAB_001657ed:
return (ulong)uVar6;
}
| |
22,596 | fmt::v11::detail::bigint::divmod_assign(fmt::v11::detail::bigint const&) | zkingston[P]unknot/build_O0/_deps/fmt-src/include/fmt/format.h | FMT_CONSTEXPR auto divmod_assign(const bigint& divisor) -> int {
FMT_ASSERT(this != &divisor, "");
if (compare(*this, divisor) < 0) return 0;
FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
align(divisor);
int quotient = 0;
do {
subtract_aligned(divisor);
++quotient;
} while (compare(*this, divisor) >= 0);
return quotient;
} | O0 | c | fmt::v11::detail::bigint::divmod_assign(fmt::v11::detail::bigint const&):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq 0x20(%rsp), %rax
setne %al
andb $0x1, %al
movb %al, 0x1f(%rsp)
leaq 0x1f(%rsp), %rdi
leaq 0x534e1a(%rip), %rsi # 0x5ed65c
callq 0xa6b30
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb8900
cmpl $0x0, %eax
jge 0xb8868
movl $0x0, 0x34(%rsp)
jmp 0xb88f7
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb8da0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xb9bb0
cmpl $0x0, (%rax)
setne %al
andb $0x1, %al
movb %al, 0x1e(%rsp)
leaq 0x1e(%rsp), %rdi
leaq 0x534db7(%rip), %rsi # 0x5ed65c
callq 0xa6b30
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb9bd0
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb9ce0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb8900
cmpl $0x0, %eax
jge 0xb88c1
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
| _ZN3fmt3v116detail6bigint13divmod_assignERKS2_:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_28], rax
cmp rax, [rsp+38h+var_18]
setnz al
and al, 1
mov [rsp+38h+var_19], al
lea rdi, [rsp+38h+var_19]
lea rsi, asc_5ED65A+2; ""
call _ZN3fmt3v116detail13ignore_unusedIJbA1_cEEEvDpRKT_; fmt::v11::detail::ignore_unused<bool,char [1]>(bool,char [1] const&)
mov rdi, [rsp+38h+var_28]; this
mov rsi, [rsp+38h+var_18]; fmt::v11::detail::bigint *
call _ZN3fmt3v116detail7compareERKNS1_6bigintES4_; fmt::v11::detail::compare(fmt::v11::detail::bigint const&,fmt::v11::detail::bigint const&)
cmp eax, 0
jge short loc_B8868
mov [rsp+38h+var_4], 0
jmp loc_B88F7
loc_B8868:
mov rax, [rsp+38h+var_18]
mov [rsp+38h+var_30], rax
mov rdi, [rsp+38h+var_18]
call _ZNK3fmt3v116detail6bufferIjE4sizeEv; fmt::v11::detail::buffer<uint>::size(void)
mov rdi, [rsp+38h+var_30]
mov rsi, rax
sub rsi, 1
call _ZNK3fmt3v116detail6bufferIjEixImEERKjT_; fmt::v11::detail::buffer<uint>::operator[]<ulong>(ulong)
cmp dword ptr [rax], 0
setnz al
and al, 1
mov [rsp+38h+var_1A], al
lea rdi, [rsp+38h+var_1A]
lea rsi, asc_5ED65A+2; ""
call _ZN3fmt3v116detail13ignore_unusedIJbA1_cEEEvDpRKT_; fmt::v11::detail::ignore_unused<bool,char [1]>(bool,char [1] const&)
mov rdi, [rsp+38h+var_28]; this
mov rsi, [rsp+38h+var_18]; fmt::v11::detail::bigint *
call _ZN3fmt3v116detail6bigint5alignERKS2_; fmt::v11::detail::bigint::align(fmt::v11::detail::bigint const&)
mov [rsp+38h+var_20], 0
loc_B88C1:
mov rdi, [rsp+38h+var_28]; this
mov rsi, [rsp+38h+var_18]; fmt::v11::detail::bigint *
call _ZN3fmt3v116detail6bigint16subtract_alignedERKS2_; fmt::v11::detail::bigint::subtract_aligned(fmt::v11::detail::bigint const&)
mov eax, [rsp+38h+var_20]
add eax, 1
mov [rsp+38h+var_20], eax
mov rdi, [rsp+38h+var_28]; this
mov rsi, [rsp+38h+var_18]; fmt::v11::detail::bigint *
call _ZN3fmt3v116detail7compareERKNS1_6bigintES4_; fmt::v11::detail::compare(fmt::v11::detail::bigint const&,fmt::v11::detail::bigint const&)
cmp eax, 0
jge short loc_B88C1
mov eax, [rsp+38h+var_20]
mov [rsp+38h+var_4], eax
loc_B88F7:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long fmt::v11::detail::bigint::divmod_assign(
fmt::v11::detail::bigint *this,
const fmt::v11::detail::bigint *a2)
{
const fmt::v11::detail::bigint *v2; // rdx
long long v3; // rax
const fmt::v11::detail::bigint *v4; // rdx
unsigned int v6; // [rsp+18h] [rbp-20h]
fmt::v11::detail::ignore_unused<bool,char [1]>();
if ( (int)fmt::v11::detail::compare(this, a2, v2) >= 0 )
{
v3 = fmt::v11::detail::buffer<unsigned int>::size(a2, a2);
fmt::v11::detail::buffer<unsigned int>::operator[]<unsigned long>(a2, v3 - 1);
fmt::v11::detail::ignore_unused<bool,char [1]>();
fmt::v11::detail::bigint::align(this, a2);
v6 = 0;
do
{
fmt::v11::detail::bigint::subtract_aligned(this, a2);
++v6;
}
while ( (int)fmt::v11::detail::compare(this, a2, v4) >= 0 );
return v6;
}
else
{
return 0;
}
}
| divmod_assign:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x10],RAX
CMP RAX,qword ptr [RSP + 0x20]
SETNZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x1f],AL
LEA RDI,[RSP + 0x1f]
LEA RSI,[0x6ed65c]
CALL 0x001a6b30
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x001b8900
CMP EAX,0x0
JGE 0x001b8868
MOV dword ptr [RSP + 0x34],0x0
JMP 0x001b88f7
LAB_001b8868:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001b8da0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
SUB RSI,0x1
CALL 0x001b9bb0
CMP dword ptr [RAX],0x0
SETNZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x1e],AL
LEA RDI,[RSP + 0x1e]
LEA RSI,[0x6ed65c]
CALL 0x001a6b30
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x001b9bd0
MOV dword ptr [RSP + 0x18],0x0
LAB_001b88c1:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x001b9ce0
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,0x1
MOV dword ptr [RSP + 0x18],EAX
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x001b8900
CMP EAX,0x0
JGE 0x001b88c1
MOV EAX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x34],EAX
LAB_001b88f7:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
/* fmt::v11::detail::bigint::divmod_assign(fmt::v11::detail::bigint const&) */
int __thiscall fmt::v11::detail::bigint::divmod_assign(bigint *this,bigint *param_1)
{
bigint *this_00;
int iVar1;
long lVar2;
uint *puVar3;
int local_20;
bool local_1a;
bool local_19;
bigint *local_18;
bigint *local_10;
int local_4;
local_19 = this != param_1;
local_18 = param_1;
local_10 = this;
ignore_unused<bool,char[1]>(&local_19,"");
iVar1 = compare(this,local_18);
this_00 = local_18;
if (iVar1 < 0) {
local_4 = 0;
}
else {
lVar2 = buffer<unsigned_int>::size((buffer<unsigned_int> *)local_18);
puVar3 = buffer<unsigned_int>::operator[]<unsigned_long>
((buffer<unsigned_int> *)this_00,lVar2 - 1);
local_1a = *puVar3 != 0;
ignore_unused<bool,char[1]>(&local_1a,"");
align(this,local_18);
local_20 = 0;
do {
subtract_aligned(this,local_18);
local_20 = local_20 + 1;
iVar1 = compare(this,local_18);
local_4 = local_20;
} while (-1 < iVar1);
}
return local_4;
}
| |
22,597 | my_mb_wc_euc_jp | eloqsql/strings/ctype-ujis.c | static int
my_mb_wc_euc_jp(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII code set: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
if (hi >= 0xA1 && hi <= 0xFE) /* JIS-X-0208 code set: [A1..FE][A1..FE] */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
return (*pwc= jisx0208_eucjp_to_unicode[(hi << 8) + s[1]]) ? 2 :
(s[1] < 0xA1 || s[1] > 0xFE) ? MY_CS_ILSEQ : -2;
}
/* JIS-X-0201 HALF WIDTH KATAKANA: [8E][A1..DF] -> [U+FF61..U+FF9F] */
if (hi == 0x8E)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if (s[1] < 0xA1 || s[1] > 0xDF)
return MY_CS_ILSEQ;
*pwc= 0xFEC0 + s[1]; /* 0xFFC0 = 0xFF61 - 0xA1 */
return 2;
}
if (hi == 0x8F) /* JIS X 0212 code set: [8F][A1..FE][A1..FE] */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
return (*pwc= jisx0212_eucjp_to_unicode[(((int) s[1]) << 8) + s[2]]) ?
3 :
(s[1] < 0xA1 || s[1] > 0xFE || s[2] < 0xA1 || s[2] > 0xFE) ?
MY_CS_ILSEQ : -3;
}
return MY_CS_ILSEQ;
} | O0 | c | my_mb_wc_euc_jp:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x6e48a
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x6e6a6
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x80, %eax
jge 0x6e4b2
movslq -0x2c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6e6a6
cmpl $0xa1, -0x2c(%rbp)
jl 0x6e561
cmpl $0xfe, -0x2c(%rbp)
jg 0x6e561
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x6e4e6
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x6e6a6
movl -0x2c(%rbp), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x27db30(%rip), %rax # 0x2ec030
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x6e51b
movl $0x2, %eax
movl %eax, -0x30(%rbp)
jmp 0x6e556
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0xa1, %ecx
movb %al, -0x31(%rbp)
jl 0x6e543
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfe, %eax
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %dl
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6e6a6
cmpl $0x8e, -0x2c(%rbp)
jne 0x6e5d1
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x6e584
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x6e6a6
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa1, %eax
jl 0x6e5a2
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xdf, %eax
jle 0x6e5ae
movl $0x0, -0x4(%rbp)
jmp 0x6e6a6
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
addl $0xfec0, %eax # imm = 0xFEC0
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x6e6a6
cmpl $0x8f, -0x2c(%rbp)
jne 0x6e69f
movq -0x20(%rbp), %rax
addq $0x3, %rax
cmpq -0x28(%rbp), %rax
jbe 0x6e5f8
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0x6e6a6
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x29da19(%rip), %rax # 0x30c030
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x6e632
movl $0x3, %eax
movl %eax, -0x38(%rbp)
jmp 0x6e697
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0xa1, %ecx
movb %al, -0x39(%rbp)
jl 0x6e684
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0xfe, %ecx
movb %al, -0x39(%rbp)
jg 0x6e684
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %ecx
movb $0x1, %al
cmpl $0xa1, %ecx
movb %al, -0x39(%rbp)
jl 0x6e684
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0xfe, %eax
setg %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %dl
movl $0xfffffffd, %eax # imm = 0xFFFFFFFD
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6e6a6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_mb_wc_euc_jp:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_6E48A
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_6E6A6
loc_6E48A:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
cmp eax, 80h
jge short loc_6E4B2
movsxd rcx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_6E6A6
loc_6E4B2:
cmp [rbp+var_2C], 0A1h
jl loc_6E561
cmp [rbp+var_2C], 0FEh
jg loc_6E561
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_6E4E6
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_6E6A6
loc_6E4E6:
mov eax, [rbp+var_2C]
shl eax, 8
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
add eax, ecx
movsxd rcx, eax
lea rax, jisx0208_eucjp_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jz short loc_6E51B
mov eax, 2
mov [rbp+var_30], eax
jmp short loc_6E556
loc_6E51B:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov al, 1
cmp ecx, 0A1h
mov [rbp+var_31], al
jl short loc_6E543
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0FEh
setnle al
mov [rbp+var_31], al
loc_6E543:
mov dl, [rbp+var_31]
mov eax, 0FFFFFFFEh
xor ecx, ecx
test dl, 1
cmovnz eax, ecx
mov [rbp+var_30], eax
loc_6E556:
mov eax, [rbp+var_30]
mov [rbp+var_4], eax
jmp loc_6E6A6
loc_6E561:
cmp [rbp+var_2C], 8Eh
jnz short loc_6E5D1
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_6E584
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_6E6A6
loc_6E584:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0A1h
jl short loc_6E5A2
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0DFh
jle short loc_6E5AE
loc_6E5A2:
mov [rbp+var_4], 0
jmp loc_6E6A6
loc_6E5AE:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
add eax, 0FEC0h
movsxd rcx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 2
jmp loc_6E6A6
loc_6E5D1:
cmp [rbp+var_2C], 8Fh
jnz loc_6E69F
mov rax, [rbp+var_20]
add rax, 3
cmp rax, [rbp+var_28]
jbe short loc_6E5F8
mov [rbp+var_4], 0FFFFFF99h
jmp loc_6E6A6
loc_6E5F8:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
shl eax, 8
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+2]
add eax, ecx
movsxd rcx, eax
lea rax, jisx0212_eucjp_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jz short loc_6E632
mov eax, 3
mov [rbp+var_38], eax
jmp short loc_6E697
loc_6E632:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov al, 1
cmp ecx, 0A1h
mov [rbp+var_39], al
jl short loc_6E684
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov al, 1
cmp ecx, 0FEh
mov [rbp+var_39], al
jg short loc_6E684
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+2]
mov al, 1
cmp ecx, 0A1h
mov [rbp+var_39], al
jl short loc_6E684
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
cmp eax, 0FEh
setnle al
mov [rbp+var_39], al
loc_6E684:
mov dl, [rbp+var_39]
mov eax, 0FFFFFFFDh
xor ecx, ecx
test dl, 1
cmovnz eax, ecx
mov [rbp+var_38], eax
loc_6E697:
mov eax, [rbp+var_38]
mov [rbp+var_4], eax
jmp short loc_6E6A6
loc_6E69F:
mov [rbp+var_4], 0
loc_6E6A6:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_mb_wc_euc_jp(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long v4; // rax
unsigned int v5; // eax
long long v6; // rax
unsigned int v7; // eax
bool v9; // [rsp+1h] [rbp-39h]
bool v11; // [rsp+9h] [rbp-31h]
unsigned int v13; // [rsp+Eh] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
v13 = *a3;
if ( v13 >= 0x80 )
{
if ( *a3 < 0xA1u || *a3 == 255 )
{
if ( v13 == 142 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
if ( a3[1] >= 0xA1u && a3[1] <= 0xDFu )
{
*a2 = a3[1] + 65216;
return 2;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-102;
}
}
else if ( v13 == 143 )
{
if ( (unsigned long long)(a3 + 3) <= a4 )
{
v6 = jisx0212_eucjp_to_unicode[256 * a3[1] + a3[2]];
*a2 = v6;
if ( v6 )
{
return 3;
}
else
{
v9 = 1;
if ( a3[1] >= 0xA1u )
{
v9 = 1;
if ( a3[1] != 255 )
{
v9 = 1;
if ( a3[2] >= 0xA1u )
v9 = a3[2] == 255;
}
}
v7 = -3;
if ( v9 )
v7 = 0;
return v7;
}
}
else
{
return (unsigned int)-103;
}
}
else
{
return 0;
}
}
else if ( (unsigned long long)(a3 + 2) <= a4 )
{
v4 = jisx0208_eucjp_to_unicode[a3[1] + (v13 << 8)];
*a2 = v4;
if ( v4 )
{
return 2;
}
else
{
v11 = 1;
if ( a3[1] >= 0xA1u )
v11 = a3[1] == 255;
v5 = -2;
if ( v11 )
v5 = 0;
return v5;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
*a2 = *a3;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_mb_wc_euc_jp:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0016e48a
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0016e6a6
LAB_0016e48a:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x80
JGE 0x0016e4b2
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0016e6a6
LAB_0016e4b2:
CMP dword ptr [RBP + -0x2c],0xa1
JL 0x0016e561
CMP dword ptr [RBP + -0x2c],0xfe
JG 0x0016e561
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0016e4e6
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0016e6a6
LAB_0016e4e6:
MOV EAX,dword ptr [RBP + -0x2c]
SHL EAX,0x8
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x1]
ADD EAX,ECX
MOVSXD RCX,EAX
LEA RAX,[0x3ec030]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x0016e51b
MOV EAX,0x2
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0016e556
LAB_0016e51b:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV AL,0x1
CMP ECX,0xa1
MOV byte ptr [RBP + -0x31],AL
JL 0x0016e543
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xfe
SETG AL
MOV byte ptr [RBP + -0x31],AL
LAB_0016e543:
MOV DL,byte ptr [RBP + -0x31]
MOV EAX,0xfffffffe
XOR ECX,ECX
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x30],EAX
LAB_0016e556:
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016e6a6
LAB_0016e561:
CMP dword ptr [RBP + -0x2c],0x8e
JNZ 0x0016e5d1
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0016e584
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0016e6a6
LAB_0016e584:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa1
JL 0x0016e5a2
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xdf
JLE 0x0016e5ae
LAB_0016e5a2:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016e6a6
LAB_0016e5ae:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
ADD EAX,0xfec0
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0016e6a6
LAB_0016e5d1:
CMP dword ptr [RBP + -0x2c],0x8f
JNZ 0x0016e69f
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0016e5f8
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x0016e6a6
LAB_0016e5f8:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
SHL EAX,0x8
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x2]
ADD EAX,ECX
MOVSXD RCX,EAX
LEA RAX,[0x40c030]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x0016e632
MOV EAX,0x3
MOV dword ptr [RBP + -0x38],EAX
JMP 0x0016e697
LAB_0016e632:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV AL,0x1
CMP ECX,0xa1
MOV byte ptr [RBP + -0x39],AL
JL 0x0016e684
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV AL,0x1
CMP ECX,0xfe
MOV byte ptr [RBP + -0x39],AL
JG 0x0016e684
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x2]
MOV AL,0x1
CMP ECX,0xa1
MOV byte ptr [RBP + -0x39],AL
JL 0x0016e684
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
CMP EAX,0xfe
SETG AL
MOV byte ptr [RBP + -0x39],AL
LAB_0016e684:
MOV DL,byte ptr [RBP + -0x39]
MOV EAX,0xfffffffd
XOR ECX,ECX
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
LAB_0016e697:
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0016e6a6
LAB_0016e69f:
MOV dword ptr [RBP + -0x4],0x0
LAB_0016e6a6:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_euc_jp(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
ushort uVar1;
bool bVar2;
uint uVar3;
int4 local_40;
int4 local_38;
int4 local_c;
if (param_3 < param_4) {
uVar3 = (uint)*param_3;
if (uVar3 < 0x80) {
*param_2 = (long)(int)uVar3;
local_c = 1;
}
else if ((uVar3 < 0xa1) || (0xfe < uVar3)) {
if (uVar3 == 0x8e) {
if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else if ((param_3[1] < 0xa1) || (0xdf < param_3[1])) {
local_c = 0;
}
else {
*param_2 = (long)(int)(param_3[1] + 0xfec0);
local_c = 2;
}
}
else if (uVar3 == 0x8f) {
if (param_4 < param_3 + 3) {
local_c = 0xffffff99;
}
else {
uVar1 = *(ushort *)
(&jisx0212_eucjp_to_unicode +
(long)(int)((uint)param_3[1] * 0x100 + (uint)param_3[2]) * 2);
*param_2 = (ulong)uVar1;
if ((ulong)uVar1 == 0) {
bVar2 = true;
if (((0xa0 < param_3[1]) && (bVar2 = true, param_3[1] != 0xff)) &&
(bVar2 = true, 0xa0 < param_3[2])) {
bVar2 = 0xfe < param_3[2];
}
local_40 = 0xfffffffd;
if (bVar2) {
local_40 = 0;
}
}
else {
local_40 = 3;
}
local_c = local_40;
}
}
else {
local_c = 0;
}
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
uVar1 = *(ushort *)
(jisx0208_eucjp_to_unicode + (long)(int)(uVar3 * 0x100 + (uint)param_3[1]) * 2);
*param_2 = (ulong)uVar1;
if ((ulong)uVar1 == 0) {
bVar2 = true;
if (0xa0 < param_3[1]) {
bVar2 = 0xfe < param_3[1];
}
local_38 = 0xfffffffe;
if (bVar2) {
local_38 = 0;
}
}
else {
local_38 = 2;
}
local_c = local_38;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
22,598 | testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(char const*) | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest-matchers.cc | Matcher<const std::string&>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | O1 | cpp | testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(char const*):
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x3fd30(%rip), %r14 # 0x59718
movq %r14, (%rdi)
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3518c
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xf66a
leaq 0x3ff6f(%rip), %rax # 0x59990
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
leaq 0x401ab(%rip), %rax # 0x59be0
movq %rax, 0x30(%rsp)
movl $0x28, %edi
callq 0x9490
movl $0x1, (%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdx
cmpq %r15, %rdx
je 0x19a6e
movq %rdx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x19a75
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r15, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
movq %rax, 0x10(%rsi)
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x39604
leaq 0x28(%rsp), %rdi
callq 0x351ca
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x19ac6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19ae1
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x94c0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x351ca
jmp 0x19afd
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x19b19
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x19b19
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19b39
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x19b39
movq %rax, %r14
movq %rbx, %rdi
callq 0x351ca
movq %r14, %rdi
callq 0x99a0
nop
| _ZN7testing7MatcherIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2EPKc:
push r15; Alternative name is 'testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(char const*)'
push r14
push rbx
sub rsp, 60h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
lea r14, off_59718
mov [rdi], r14
lea rdi, [rsp+78h+var_38]
lea rdx, [rsp+78h+var_71]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea r15, [rsp+78h+var_60]
mov [r15-10h], r15
mov rsi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
add rdx, rsi
lea rdi, [rsp+78h+var_70]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rax, off_59990
mov [rsp+78h+var_50], rax
xorps xmm0, xmm0
movups [rsp+78h+var_48], xmm0
lea rax, _ZZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE9GetVTableINSA_11ValuePolicyINS0_9EqMatcherIS7_EELb0EEEEEPKNSA_6VTableEvE7kVTableB5cxx11; testing::internal::MatcherBase<std::string const&>::GetVTable<testing::internal::MatcherBase<std::string const&>::ValuePolicy<testing::internal::EqMatcher<std::string>,false>>(void)::kVTable
mov qword ptr [rsp+78h+var_48], rax
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov dword ptr [rax], 1
mov rcx, rax
add rcx, 18h
mov [rax+8], rcx
mov rdx, [rsp+78h+var_70]
cmp rdx, r15
jz short loc_19A6E
mov [rax+8], rdx
mov rcx, [rsp+78h+var_60]
mov [rax+18h], rcx
jmp short loc_19A75
loc_19A6E:
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rcx], xmm0
loc_19A75:
mov rcx, [rsp+78h+var_68]
mov [rax+10h], rcx
mov [rsp+78h+var_70], r15
mov [rsp+78h+var_68], 0
mov byte ptr [rsp+78h+var_60], 0
lea rsi, [rsp+78h+var_50]
mov [rsi+10h], rax
mov [rsi], r14
mov rdi, rbx
call _ZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEaSEOSA_; testing::internal::MatcherBase<std::string const&>::operator=(testing::internal::MatcherBase<std::string const&>&&)
lea rdi, [rsp+78h+var_50]
call _ZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; testing::internal::MatcherBase<std::string const&>::~MatcherBase()
mov rdi, [rsp+78h+var_70]; void *
cmp rdi, r15
jz short loc_19AC6
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_19AC6:
lea rax, [rsp+78h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_19AE1
mov rsi, [rsp+78h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_19AE1:
add rsp, 60h
pop rbx
pop r14
pop r15
retn
mov r14, rax
lea rdi, [rsp+arg_20]
call _ZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; testing::internal::MatcherBase<std::string const&>::~MatcherBase()
jmp short loc_19AFD
mov r14, rax
loc_19AFD:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_19B19
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_19B19
mov r14, rax
loc_19B19:
lea rax, [rsp+arg_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_19B39
mov rsi, [rsp+arg_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_19B39
mov r14, rax
loc_19B39:
mov rdi, rbx
call _ZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; testing::internal::MatcherBase<std::string const&>::~MatcherBase()
mov rdi, r14
call __Unwind_Resume
| void testing::Matcher<std::string const&>::Matcher(long long a1, long long a2)
{
long long v2; // rax
char v3; // [rsp+7h] [rbp-71h] BYREF
void *v4; // [rsp+8h] [rbp-70h] BYREF
long long v5; // [rsp+10h] [rbp-68h]
__int128 v6; // [rsp+18h] [rbp-60h] BYREF
_QWORD v7[2]; // [rsp+28h] [rbp-50h] BYREF
long long v8; // [rsp+38h] [rbp-40h]
void *v9[2]; // [rsp+40h] [rbp-38h] BYREF
long long v10; // [rsp+50h] [rbp-28h] BYREF
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)a1 = &off_59718;
std::string::basic_string<std::allocator<char>>(v9, a2, &v3);
v4 = &v6;
std::string::_M_construct<char *>(&v4, (_BYTE *)v9[0], (long long)v9[0] + (unsigned long long)v9[1]);
v7[0] = &off_59990;
v8 = 0LL;
v7[1] = testing::internal::MatcherBase<std::string const&>::GetVTable<testing::internal::MatcherBase<std::string const&>::ValuePolicy<testing::internal::EqMatcher<std::string>,false>>(void)::kVTable[abi:cxx11];
v2 = operator new(0x28uLL);
*(_DWORD *)v2 = 1;
*(_QWORD *)(v2 + 8) = v2 + 24;
if ( v4 == &v6 )
{
*(_OWORD *)(v2 + 24) = v6;
}
else
{
*(_QWORD *)(v2 + 8) = v4;
*(_QWORD *)(v2 + 24) = v6;
}
*(_QWORD *)(v2 + 16) = v5;
v4 = &v6;
v5 = 0LL;
LOBYTE(v6) = 0;
v8 = v2;
v7[0] = &off_59718;
testing::internal::MatcherBase<std::string const&>::operator=(a1);
testing::internal::MatcherBase<std::string const&>::~MatcherBase(v7);
if ( v4 != &v6 )
operator delete(v4, v6 + 1);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 1);
}
| Matcher:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
LEA R14,[0x159718]
MOV qword ptr [RDI],R14
LAB_001199eb:
LEA RDI,[RSP + 0x40]
LEA RDX,[RSP + 0x7]
CALL 0x0013518c
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
ADD RDX,RSI
LAB_00119a10:
LEA RDI,[RSP + 0x8]
CALL 0x0010f66a
LEA RAX,[0x159990]
MOV qword ptr [RSP + 0x28],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x30],XMM0
LEA RAX,[0x159be0]
MOV qword ptr [RSP + 0x30],RAX
LAB_00119a3a:
MOV EDI,0x28
CALL 0x00109490
MOV dword ptr [RAX],0x1
MOV RCX,RAX
ADD RCX,0x18
MOV qword ptr [RAX + 0x8],RCX
MOV RDX,qword ptr [RSP + 0x8]
CMP RDX,R15
JZ 0x00119a6e
MOV qword ptr [RAX + 0x8],RDX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x18],RCX
JMP 0x00119a75
LAB_00119a6e:
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RCX],XMM0
LAB_00119a75:
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV qword ptr [RSP + 0x8],R15
MOV qword ptr [RSP + 0x10],0x0
MOV byte ptr [RSP + 0x18],0x0
LEA RSI,[RSP + 0x28]
MOV qword ptr [RSI + 0x10],RAX
MOV qword ptr [RSI],R14
LAB_00119a9d:
MOV RDI,RBX
CALL 0x00139604
LAB_00119aa5:
LEA RDI,[RSP + 0x28]
CALL 0x001351ca
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x00119ac6
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001094c0
LAB_00119ac6:
LEA RAX,[RSP + 0x50]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00119ae1
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x001094c0
LAB_00119ae1:
ADD RSP,0x60
POP RBX
POP R14
POP R15
RET
|
/* testing::Matcher<std::__cxx11::string const&>::Matcher(char const*) */
void __thiscall
testing::Matcher<std::__cxx11::string_const&>::Matcher
(Matcher<std::__cxx11::string_const&> *this,char *param_1)
{
allocator local_71;
int1 *local_70;
int8 local_68;
int1 local_60;
int7 uStack_5f;
int8 uStack_58;
int **local_50;
int1 *local_48;
int4 *puStack_40;
long *local_38;
long local_30;
long local_28 [2];
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int ***)this = &PTR__MatcherBase_00159718;
/* try { // try from 001199eb to 001199f9 has its CatchHandler @ 00119b36 */
std::__cxx11::string::string<std::allocator<char>>((string *)&local_38,param_1,&local_71);
/* try { // try from 00119a10 to 00119a19 has its CatchHandler @ 00119b16 */
local_70 = &local_60;
std::__cxx11::string::_M_construct<char*>(&local_70,local_38,local_30 + (long)local_38);
local_50 = &PTR__MatcherBase_00159990;
puStack_40 = (int4 *)0x0;
local_48 = internal::MatcherBase<std::__cxx11::string_const&>::
GetVTable<testing::internal::MatcherBase<std::__cxx11::string_const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string>,false>>()
::kVTable_abi_cxx11_;
/* try { // try from 00119a3a to 00119a43 has its CatchHandler @ 00119afa */
puStack_40 = (int4 *)operator_new(0x28);
*puStack_40 = 1;
*(int4 **)(puStack_40 + 2) = puStack_40 + 6;
if (local_70 == &local_60) {
*(ulong *)(puStack_40 + 6) = CONCAT71(uStack_5f,local_60);
*(int8 *)(puStack_40 + 8) = uStack_58;
}
else {
*(int1 **)(puStack_40 + 2) = local_70;
*(ulong *)(puStack_40 + 6) = CONCAT71(uStack_5f,local_60);
}
*(int8 *)(puStack_40 + 4) = local_68;
local_68 = 0;
local_60 = 0;
local_50 = &PTR__MatcherBase_00159718;
local_70 = &local_60;
/* try { // try from 00119a9d to 00119aa4 has its CatchHandler @ 00119aeb */
internal::MatcherBase<std::__cxx11::string_const&>::operator=
((MatcherBase<std::__cxx11::string_const&> *)this,(MatcherBase *)&local_50);
internal::MatcherBase<std::__cxx11::string_const&>::~MatcherBase
((MatcherBase<std::__cxx11::string_const&> *)&local_50);
if (local_70 != &local_60) {
operator_delete(local_70,CONCAT71(uStack_5f,local_60) + 1);
}
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
return;
}
| |
22,599 | my_mb_wc_gbk | eloqsql/strings/ctype-gbk.c | static int
my_mb_wc_gbk(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
hi=s[0];
if (hi<0x80)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_gbk_uni_onechar( (hi<<8) + s[1])))
return -2;
return 2;
} | O0 | c | my_mb_wc_gbk:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x4cbbe
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x4cc99
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x80, -0x2c(%rbp)
jge 0x4cbe8
movslq -0x2c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4cc99
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x4cc02
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x4cc99
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
movl $0x81, %eax
cmpl %ecx, %eax
jg 0x4cc5c
movl -0x2c(%rbp), %eax
movzbl %al, %eax
cmpl $0xfe, %eax
jg 0x4cc5c
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jg 0x4cc3c
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x7e, %eax
jle 0x4cc65
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x80, %eax
cmpl %ecx, %eax
jg 0x4cc5c
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfe, %eax
jle 0x4cc65
movl $0x0, -0x4(%rbp)
jmp 0x4cc99
movl -0x2c(%rbp), %edi
shll $0x8, %edi
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %edi
callq 0x4cfe0
cltq
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x4cc92
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x4cc99
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_mb_wc_gbk:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_4CBBE
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_4CC99
loc_4CBBE:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 80h
jge short loc_4CBE8
movsxd rcx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_4CC99
loc_4CBE8:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_4CC02
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_4CC99
loc_4CC02:
mov eax, [rbp+var_2C]
movzx ecx, al
mov eax, 81h
cmp eax, ecx
jg short loc_4CC5C
mov eax, [rbp+var_2C]
movzx eax, al
cmp eax, 0FEh
jg short loc_4CC5C
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov eax, 40h ; '@'
cmp eax, ecx
jg short loc_4CC3C
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 7Eh ; '~'
jle short loc_4CC65
loc_4CC3C:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov eax, 80h
cmp eax, ecx
jg short loc_4CC5C
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0FEh
jle short loc_4CC65
loc_4CC5C:
mov [rbp+var_4], 0
jmp short loc_4CC99
loc_4CC65:
mov edi, [rbp+var_2C]
shl edi, 8
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
add edi, eax
call func_gbk_uni_onechar
cdqe
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jnz short loc_4CC92
mov [rbp+var_4], 0FFFFFFFEh
jmp short loc_4CC99
loc_4CC92:
mov [rbp+var_4], 2
loc_4CC99:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_mb_wc_gbk(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
int v4; // eax
unsigned int v6; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
v6 = *a3;
if ( v6 >= 0x80 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
if ( (unsigned __int8)v6 < 0x81u
|| (unsigned __int8)v6 == 255
|| (a3[1] < 0x40u || a3[1] > 0x7Eu) && (a3[1] < 0x80u || a3[1] == 255) )
{
return 0;
}
else
{
v4 = func_gbk_uni_onechar(a3[1] + (v6 << 8));
*a2 = v4;
if ( v4 )
return 2;
else
return (unsigned int)-2;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
*a2 = *a3;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_mb_wc_gbk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0014cbbe
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0014cc99
LAB_0014cbbe:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0x80
JGE 0x0014cbe8
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014cc99
LAB_0014cbe8:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0014cc02
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0014cc99
LAB_0014cc02:
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX ECX,AL
MOV EAX,0x81
CMP EAX,ECX
JG 0x0014cc5c
MOV EAX,dword ptr [RBP + -0x2c]
MOVZX EAX,AL
CMP EAX,0xfe
JG 0x0014cc5c
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x40
CMP EAX,ECX
JG 0x0014cc3c
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x7e
JLE 0x0014cc65
LAB_0014cc3c:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RAX + 0x1]
MOV EAX,0x80
CMP EAX,ECX
JG 0x0014cc5c
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xfe
JLE 0x0014cc65
LAB_0014cc5c:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014cc99
LAB_0014cc65:
MOV EDI,dword ptr [RBP + -0x2c]
SHL EDI,0x8
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x1]
ADD EDI,EAX
CALL 0x0014cfe0
CDQE
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x0014cc92
MOV dword ptr [RBP + -0x4],0xfffffffe
JMP 0x0014cc99
LAB_0014cc92:
MOV dword ptr [RBP + -0x4],0x2
LAB_0014cc99:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_mb_wc_gbk(int8 param_1,long *param_2,byte *param_3,byte *param_4)
{
uint uVar1;
int iVar2;
int4 local_c;
if (param_3 < param_4) {
uVar1 = (uint)*param_3;
if (uVar1 < 0x80) {
*param_2 = (long)(int)uVar1;
local_c = 1;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else if (((uVar1 < 0x81) || (0xfe < uVar1)) ||
(((param_3[1] < 0x40 || (0x7e < param_3[1])) &&
((param_3[1] < 0x80 || (param_3[1] == 0xff)))))) {
local_c = 0;
}
else {
iVar2 = func_gbk_uni_onechar(uVar1 * 0x100 + (uint)param_3[1]);
*param_2 = (long)iVar2;
if ((long)iVar2 == 0) {
local_c = 0xfffffffe;
}
else {
local_c = 2;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.